Netflix 클론 코딩 URLSession 리팩토링해보기/ Endpint

URL

 

URL은 원격 서버의 항목이나 로컬 파일의 경로와 같은 특정 리소스의 위치를 나타낸다.

주로 Network 요청, FileManager 에서 사용.

let urlString = URL(string: "https://api.themoviedb.org/3/movie/top_rated?api_key=123456780eb5a8248e85f2742a7868a8")
url.absoluteURL    // https://api.themoviedb.org/3/movie/top_rated?api_key=123456780eb5a8248e85f2742a7868a8
url.scheme         // "https"
url.host           // "api.themoviedb.org"
url.path           // "/3/movie/top_rated"
url.query          // "api_key=123456780eb5a8248e85f2742a7868a8"

 

 

URLComponents

URL과 같이 읽기 부분.

let urlComponents = URLComponents(string: "https://api.themoviedb.org/3/movie/top_rated?api_key=123456780eb5a8248e85f2742a7868a8")
urlComponents!.scheme     // scheme: "https"
urlComponents!.host       // host: "api.themoviedb.org"
urlComponents!.path       // path: "/3/movie/top_rated"
urlComponents!.query      // "api_key=426472920eb5a8248e85f2742a7868a8"
urlComponents!.queryItems // ["api_key=426472920eb5a8248e85f2742a7868a8"]

 

 

이런식으로 쓰기가 가능해 URL보다 유동적으로 사용 가능하다.

let urlComponents = URLComponents()
urlComponents.scheme = "https"
urlComponents.host = "api.themoviedb.org"
urlComponents.path = "/3/movie/top_rated"
urlComponents.query = "api_key=426472920eb5a8248e85f2742a7868a8"
//여러 쿼리 아이템이 있을 시 queryItems으로 배열로 다룰 수 있음.
urlComponents.queryItems = [URLQueryItem(name: "api_key", value: "426472920eb5a8248e85f2742a7868a8")]

urlComponents.url // "https://api.themoviedb.org/3/movie/top_rated?api_key=123456780eb5a8248e85f2742a7868a8"

 

 

URLComponents를 사용하여 URL을 생성 시, 다양한 URL 구성 요소

 

1. scheme: URL의 스킴을 설정. 예를 들어, "https", "http", "ftp" 등

2. host: URL의 호스트 이름을 설정

3. port: URL의 포트를 설정. 생략할 경우 기본 포트를 사용

4. path: URL의 경로를 설정

5. query: URL의 쿼리 문자열을 직접 설정. 쿼리 문자열은 key=value 쌍으로 구성

components.query = "key1=value1&key2=value2"

6. queryItems: URL의 쿼리 항목을 설정. URLQueryItem 객체의 배열로 설정되며, 쿼리 파라미터를 자동으로 인코딩

배열의 형태를 가지고 있어 여러 아이템 추가해서 사용 가능.

components.queryItems = [URLQueryItem(name: "key1", value: "value1"),
                          URLQueryItem(name: "key2", value: "value2")]

7. fragment: URL의 프래그먼트를 설정. 이는 URL의 해시 부분에 해당하며, 페이지 내 위치를 지정하는 데 사용

components.fragment = "section1"

 

 

---

기존에 사용했던 URLSession 

//방법1
func fetch<T: Decodable>(urlString: String, type: T) -> T {
    let session = URLSession(configuration: .default)
    let url = URL(string: urlString)
    let request = URLRequest(url: url)
    
    session.dataTask(with: request) { data, response, error in 
        // do something
    }
}    

//방법2
func fetch<T: Decodable>(url: URL) -> Single<T> {
    return Single.create { observer in
        let session = URLSession(configuration: .default)
        session.dataTask(with: URLRequest(url: url)) { data, response, error in
        
        }.resume()
    }
}


//방법2 사용
let urlString = "https://api.themoviedb.org/3/movie/popular?api_key=\(apiKey)")
guard let url = urlString else { return }
NetworkManager.shared.fetch(url: url)
... 생략

 

여기서 URL에서 원시값을 직접 입력하고 관리할 때 오타 등과 같이 실수가 발생할 수 있다. 

네트워크 요청을 해야하는 인스턴스는 url, urlString을 생성, 관리하는 책임이 추가적으로 생긴다. 

-> 엔드포인트가 많아진다면, 인스턴스로 따로 만들어 책임을 분리해볼 것.

 

 

 

---

Endpoint(엔드포인트)

URLSession에서 endPoint는 클라이언트(사용 중인 앱)가 서버로 요청을 보낼 때 그 요청이 어디로 가야 하는지 알려주는 서버의 특정 위치나 경로

 

예를 들어어보자면,

• Base URL: https://api.example.com
• 엔드포인트: /v1/users

여기서 https://api.example.com/v1/users는 사용자 정보에 접근하기 위한 전체 URL이 된다.

 

 

쿼리(Query)

요청하는 데이터에 대해 추가적인 조건이나 필터를 지정하기 위해 URL에 붙는 파라미터를 말한다.

주로 ? 뒤에 위치하며, 여러 파라미터를 사용하면 &로 구분된다.

 

예를 들어, 특정 사용자 ID에 해당하는 정보를 가져오고 싶다면,

• Base URL: https://api.example.com
• 엔드포인트: /v1/users
• 쿼리: ?id=123&name=John

전체 URL은 https://api.example.com/v1/users?id=123&name=John이 된다.

여기서 id=123과 name=John은 서버에 추가 정보를 요청하는 조건이다.

 

 

차이점 요약

엔드포인트(Endpoint): 서버의 특정 리소스나 기능에 접근하기 위한 경로.

예시: /v1/users

 

쿼리(Query): 요청에 추가 조건을 지정하여 필터링하거나 검색할 때 사용.

예시: ?id=123&name=John

---

endpoint는 URL이 아닌, URL을 구성하기 위한 정보를 담고 있는 Endpoint 클래스의 인스턴스다.

실제 URL 객체는 creatEndpoint() 메서드를 호출하여 URLRequest를 생성하는 과정에서 만들어진다.

따라서, endpoint 자체는 URL이 아니며, endpoint에서 creatEndpoint() 메서드를 호출하여

URLRequest 객체를 생성하면, 이 URLRequest 객체가 URL을 포함하게 된다.

import Foundation

enum HTTPMethodType: String {
    case post = "POST"
    case get = "GET"
    case put = "PUT"
    case delete = "DELETE"
}

final class Endpoint{
    let baseURL: String
    let method: HTTPMethodType
    let headerParpmeters: [String: String]
    let path: String
    let queryParameters: [String: Any]
    
    
    init(baseURL: String = "https://api.themoviedb.org",
         method: HTTPMethodType = .get,
         headerParpmeters: [String : String] = [:],
         path: String = "",
         queryParameters: [String : Any] = [:]
    ) {
        self.baseURL = baseURL
        self.method = method
        self.headerParpmeters = headerParpmeters
        self.path = path
        self.queryParameters = queryParameters
    }
    
    
    //URL 생성 메서드
    func creatURL() -> URL? {
        var urlComponents = URLComponents(string: baseURL.appending(path)) 
        
        var queryItems = [URLQueryItem]() // name, value 속성 있음
        
        queryParameters.forEach {
            queryItems.append(URLQueryItem(name: $0.key, value: "\($0.value)"))
        }
        
        urlComponents?.queryItems = queryItems
        
        return urlComponents?.url
        
    }
    
    
    //endpoint 생성 메서드 
    func creatEndpoint() throws -> URLRequest { 
        guard let url = creatURL() else {throw NetworkError.invalidUrl}
        
        var request = URLRequest(url: url)
        request.httpMethod = method.rawValue
        
        var allHeaders: [String: String] = [:]
        headerParpmeters.forEach {
            allHeaders.updateValue($1, forKey: $0)
        }
        return request
    }
    
}

import Foundation
import RxSwift

enum NetworkError: Error {
    case invalidUrl
    case dataFetchFail
    case decodingFail
}

class NetworkManager {
    static let shared = NetworkManager()
    private init(){}

	//url에서 endpoint로 url 받아오기
    func fetch<T: Decodable>(endpoint: Endpoint) -> Single<T> {
        
        do {
        	//URLRequest 생성
            let request = try endpoint.creatEndpoint() //URLRequest 타입 리턴 
        
            return Single.create { observer in   
            	//URLSession을 통해 요청 보내기
                let session = URLSession(configuration: .default)
                session.dataTask(with: request) { data, response, error in
                    
                    // error 가 있다면 Single 에 fail 방출.
                    if let error = error {
                        observer(.failure(error))
                        return
                    }
                    
                    // data 가 없거나 http 통신 에러 일 때 dataFetchFail 방출.
                    guard let data = data,
                          let response = response as? HTTPURLResponse,
                          (200..<300).contains(response.statusCode) else {
                        observer(.failure(NetworkError.dataFetchFail))
                        return
                    }
                    
                    do {
                        // data 를 받고 json 디코딩 과정까지 성공한다면 결과를 success 와 함께 방출.
                        let decodedData = try JSONDecoder().decode(T.self, from: data)
                        observer(.success(decodedData))
                    } catch {
                        // 디코딩 실패했다면 decodingFail 방출.
                        observer(.failure(NetworkError.decodingFail))
                    }
                }.resume()  
                return Disposables.create()
            }
        } catch let error {
            return Single.create { observer in
                observer(.failure(error))
                return Disposables.create()
            }
        }
    }
    
    
    // 기존 코드
	func fetch<T: Decodable>(url: URL) -> Single<T> {

        return Single.create { observer in
            let session = URLSession(configuration: .default)
            session.dataTask(with: url) { data, response, error in
                
                // error 가 있다면 Single 에 fail 방출.
                if let error = error {
                    observer(.failure(error))
                    return
                }
                
                // data 가 없거나 http 통신 에러 일 때 dataFetchFail 방출.
                guard let data = data,
                      let response = response as? HTTPURLResponse,
                      (200..<300).contains(response.statusCode) else {
                    observer(.failure(NetworkError.dataFetchFail))
                    return
                }
                
                do {
                    // data 를 받고 json 디코딩 과정까지 성공한다면 결과를 success 와 함께 방출.
                    let decodedData = try JSONDecoder().decode(T.self, from: data)
                    observer(.success(decodedData))
                } catch {
                    // 디코딩 실패했다면 decodingFail 방출.
                    observer(.failure(NetworkError.decodingFail))
                }
            }.resume()
            
            return Disposables.create()
        }
    }
}

//MainViewModel

	func fetchPopularMovie(){
        //기존 url 생성했던 방법 
//        guard let url = URL(string: "https://api.themoviedb.org/3/movie/popular?api_key=\(apiKey)") else {
//            popularMovieSubject.onError(NetworkError.invalidUrl)
//            return
//        }
        
        //endpoint 인스턴스 생성 후 변수 할당
        let endpoint = Endpoint(
            path: "/3/movie/popular",
            queryParameters: ["api_key": apiKey]
        )

        
        // 이 네트워크 fetch 의 결과가 Single 타입으로 옵저버블이기 때문에 구독할 수 있다
        NetworkManager.shared.fetch(endpoint: endpoint)
            .subscribe(onSuccess: { [weak self] (movieResponse: MovieResponse) in  //구독 시작.
                //fetch에서 값이 방출 됐다면onSuccess 또는 onFailure 로직 실행
                //디코딩 성공했다면 observer(.success(decodedData))로 이벤트가 방출 되고 movieResponse로 값이 들어와 BehaviorSubject에 값을 넣어준다.
                self?.popularMovieSubject.onNext(movieResponse.results)
            }, onFailure: { [weak self] error in
                self?.popularMovieSubject.onError(error)
            }).disposed(by: disposeBag)
    }