🤔 왜 네트워킹을 알아야 할까?

야, 솔직히 말해볼게. 요즘 앱 중에 인터넷 통신 안 하는 앱이 있어? 🤣
날씨 앱은 서버에서 날씨 데이터 받아오고, 쇼핑 앱은 상품 목록 불러오고, SNS는 피드 업데이트하고...
현대 iOS 앱의 90% 이상은 어떤 형태로든 네트워크 통신을 사용해.

그래서 Swift로 iOS 개발을 한다면 네트워킹은 선택이 아니라 필수 스킬이야.
오늘은 Apple이 기본으로 제공하는 URLSession부터 시작해서,
개발자들이 사랑하는 서드파티 라이브러리 Alamofire까지 제대로 파헤쳐볼 거야!

겁먹지 마. 차근차근 같이 가보자고 😎

📡 HTTP와 REST API 기초 — 먼저 이것부터!

URLSession이고 Alamofire고 간에, 그 전에 HTTP와 REST API가 뭔지 알아야 해.
이미 안다고? 그래도 한 번만 같이 복습하자. 기초가 탄탄해야 나중에 안 흔들리거든.

🌍 HTTP 메서드의 종류

서버랑 대화할 때 우리가 쓰는 "동사"들이야:

📊 HTTP 상태 코드

서버가 "나 지금 어때?" 라고 알려주는 숫자 코드야:

🔑 JSON — 데이터 교환의 표준어

서버랑 앱이 데이터를 주고받을 때 가장 많이 쓰는 형식이 JSON(JavaScript Object Notation)이야.
Swift에서는 Codable 프로토콜로 JSON을 쉽게 다룰 수 있어.

{
  "id": 1,
  "name": "김개발",
  "email": "dev@example.com",
  "skills": ["Swift", "iOS", "Xcode"],
  "isActive": true
}

🔗 URLSession — Apple이 만든 네트워킹의 기본기

URLSession은 Apple이 iOS SDK에 기본으로 포함시킨 네트워킹 프레임워크야.
외부 라이브러리 없이도 HTTP 통신을 완벽하게 처리할 수 있어.
처음엔 좀 복잡해 보일 수 있는데, 구조를 이해하면 생각보다 깔끔해!

🚀 URLSession 기본 GET 요청

가장 기본적인 GET 요청부터 시작해보자!

import Foundation

// 1. URL 생성
guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/1") else {
    print("잘못된 URL이에요!")
    return
}

// 2. URLSession 데이터 태스크 생성 및 실행
let task = URLSession.shared.dataTask(with: url) { data, response, error in
    
    // 3. 에러 처리
    if let error = error {
        print("에러 발생: \(error.localizedDescription)")
        return
    }
    
    // 4. HTTP 응답 상태 코드 확인
    guard let httpResponse = response as? HTTPURLResponse,
          (200...299).contains(httpResponse.statusCode) else {
        print("서버 응답 오류!")
        return
    }
    
    // 5. 데이터 처리
    guard let data = data else {
        print("데이터가 없어요!")
        return
    }
    
    // 6. JSON 파싱
    do {
        let json = try JSONSerialization.jsonObject(with: data, options: [])
        print("받은 데이터: \(json)")
    } catch {
        print("JSON 파싱 실패: \(error)")
    }
}

// 7. 태스크 시작 (이거 빠뜨리면 아무것도 안 됨! 주의!)
task.resume()

🏗️ Codable로 JSON 파싱하기

JSONSerialization도 좋지만, Swift의 Codable 프로토콜을 쓰면 훨씬 우아하게 JSON을 다룰 수 있어.
타입 안전성도 보장되고, 코드도 훨씬 깔끔해지거든!

// 서버에서 받을 데이터 구조 정의
struct Post: Codable {
    let id: Int
    let userId: Int
    let title: String
    let body: String
}

struct User: Codable {
    let id: Int
    let name: String
    let email: String
    let username: String
}

// 배열로 받을 때
// [Post] 이런 식으로 사용

func fetchPost(id: Int, completion: @escaping (Result<Post, Error>) -> Void) {
    
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/\(id)") else {
        completion(.failure(NetworkError.invalidURL))
        return
    }
    
    URLSession.shared.dataTask(with: url) { data, response, error in
        
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            completion(.failure(NetworkError.invalidResponse))
            return
        }
        
        guard let data = data else {
            completion(.failure(NetworkError.noData))
            return
        }
        
        do {
            let decoder = JSONDecoder()
            // 서버가 snake_case를 쓴다면 이 설정 추가!
            decoder.keyDecodingStrategy = .convertFromSnakeCase
            let post = try decoder.decode(Post.self, from: data)
            completion(.success(post))
        } catch {
            completion(.failure(error))
        }
        
    }.resume()
}

// 커스텀 에러 타입
enum NetworkError: Error {
    case invalidURL
    case invalidResponse
    case noData
    case decodingError
}

📤 POST 요청 — 데이터 보내기

GET은 데이터를 받는 거고, POST는 데이터를 서버로 보내는 거야. 조금 더 설정이 필요해!

func createPost(title: String, body: String, userId: Int, 
                completion: @escaping (Result<Post, Error>) -> Void) {
    
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
        completion(.failure(NetworkError.invalidURL))
        return
    }
    
    // URLRequest 설정
    var request = URLRequest(url: url)
    request.httpMethod = "POST"  // 메서드 설정
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.setValue("application/json", forHTTPHeaderField: "Accept")
    
    // 보낼 데이터 구조체
    struct NewPost: Encodable {
        let title: String
        let body: String
        let userId: Int
    }
    
    let newPost = NewPost(title: title, body: body, userId: userId)
    
    do {
        let encoder = JSONEncoder()
        request.httpBody = try encoder.encode(newPost)
    } catch {
        completion(.failure(error))
        return
    }
    
    URLSession.shared.dataTask(with: request) { data, response, error in
        
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data else {
            completion(.failure(NetworkError.noData))
            return
        }
        
        do {
            let post = try JSONDecoder().decode(Post.self, from: data)
            completion(.success(post))
        } catch {
            completion(.failure(error))
        }
        
    }.resume()
}

⚡ async/await — 현대적인 비동기 처리

Swift 5.5부터 도입된 async/await는 비동기 코드를 동기 코드처럼 읽기 쉽게 만들어줘.
콜백 지옥(callback hell)에서 해방되는 느낌이랄까? 😍
iOS 15+ 이상을 타겟으로 한다면 적극 활용해봐!

fetchUser { user in

fetchPosts(user) { posts in

fetchComments(posts) { comments in

// 콜백 지옥 😱

}

}

}

let user = await fetchUser()

let posts = await fetchPosts(user)

let comments = await fetchComments(posts)

// 훨씬 깔끔! 🎉

// async 함수 정의
func fetchPost(id: Int) async throws -> Post {
    
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts/\(id)") else {
        throw NetworkError.invalidURL
    }
    
    // iOS 15+에서 URLSession이 async/await를 네이티브 지원!
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse,
          (200...299).contains(httpResponse.statusCode) else {
        throw NetworkError.invalidResponse
    }
    
    let post = try JSONDecoder().decode(Post.self, from: data)
    return post
}

// 사용하는 곳 (SwiftUI View나 ViewModel에서)
Task {
    do {
        let post = try await fetchPost(id: 1)
        print("제목: \(post.title)")
    } catch {
        print("에러: \(error)")
    }
}

// POST 요청도 async/await로!
func createPost(newPost: NewPost) async throws -> Post {
    
    guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
        throw NetworkError.invalidURL
    }
    
    var request = URLRequest(url: url)
    request.httpMethod = "POST"
    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
    request.httpBody = try JSONEncoder().encode(newPost)
    
    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONDecoder().decode(Post.self, from: data)
}

🔄 withCheckedThrowingContinuation — 구버전 호환

iOS 14 이하도 지원해야 한다면 이 방법으로 기존 콜백을 async/await로 변환할 수 있어:

func fetchPostCompat(id: Int) async throws -> Post {
    return try await withCheckedThrowingContinuation { continuation in
        // 기존 콜백 방식 함수 호출
        fetchPost(id: id) { result in
            switch result {
            case .success(let post):
                continuation.resume(returning: post)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

🏛️ 네트워크 레이어 아키텍처 설계

실제 프로젝트에서는 네트워크 코드를 여기저기 흩뿌리면 안 돼.
잘 설계된 네트워크 레이어를 만들어야 유지보수도 쉽고, 테스트도 가능해지거든!
실무에서 많이 쓰는 패턴을 보여줄게.

// MARK: - Endpoint 프로토콜
protocol Endpoint {
    var baseURL: String { get }
    var path: String { get }
    var method: HTTPMethod { get }
    var headers: [String: String]? { get }
    var parameters: [String: Any]? { get }
    var body: Encodable? { get }
}

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

// MARK: - 기본값 제공 (Extension)
extension Endpoint {
    var baseURL: String { return "https://api.example.com" }
    var headers: [String: String]? { return ["Content-Type": "application/json"] }
    var parameters: [String: Any]? { return nil }
    var body: Encodable? { return nil }
}

// MARK: - 실제 API 엔드포인트 정의
enum PostEndpoint: Endpoint {
    case getPost(id: Int)
    case getPosts
    case createPost(title: String, body: String, userId: Int)
    case deletePost(id: Int)
    
    var path: String {
        switch self {
        case .getPost(let id): return "/posts/\(id)"
        case .getPosts: return "/posts"
        case .createPost: return "/posts"
        case .deletePost(let id): return "/posts/\(id)"
        }
    }
    
    var method: HTTPMethod {
        switch self {
        case .getPost, .getPosts: return .get
        case .createPost: return .post
        case .deletePost: return .delete
        }
    }
    
    var body: Encodable? {
        switch self {
        case .createPost(let title, let body, let userId):
            return ["title": title, "body": body, "userId": userId]
        default:
            return nil
        }
    }
}

// MARK: - NetworkManager
class NetworkManager {
    static let shared = NetworkManager()
    private let session: URLSession
    
    private init() {
        let config = URLSessionConfiguration.default
        config.timeoutIntervalForRequest = 30
        config.timeoutIntervalForResource = 60
        self.session = URLSession(configuration: config)
    }
    
    func request<T: Decodable>(_ endpoint: Endpoint) async throws -> T {
        
        // URL 구성
        guard let url = URL(string: endpoint.baseURL + endpoint.path) else {
            throw NetworkError.invalidURL
        }
        
        var urlRequest = URLRequest(url: url)
        urlRequest.httpMethod = endpoint.method.rawValue
        
        // 헤더 설정
        endpoint.headers?.forEach { key, value in
            urlRequest.setValue(value, forHTTPHeaderField: key)
        }
        
        // 바디 설정
        if let body = endpoint.body {
            urlRequest.httpBody = try JSONEncoder().encode(body)
        }
        
        // 요청 실행
        let (data, response) = try await session.data(for: urlRequest)
        
        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.invalidResponse
        }
        
        // 상태 코드 처리
        switch httpResponse.statusCode {
        case 200...299:
            break
        case 401:
            throw NetworkError.unauthorized
        case 404:
            throw NetworkError.notFound
        case 500...599:
            throw NetworkError.serverError(httpResponse.statusCode)
        default:
            throw NetworkError.unknown(httpResponse.statusCode)
        }
        
        return try JSONDecoder().decode(T.self, from: data)
    }
}

// MARK: - 사용 예시
class PostViewModel: ObservableObject {
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    func loadPosts() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            posts = try await NetworkManager.shared.request(PostEndpoint.getPosts)
        } catch {
            errorMessage = error.localizedDescription
        }
    }
}

🔥 Alamofire — 네트워킹을 더 쉽게!

자, 이제 많은 iOS 개발자들이 사랑하는 Alamofire를 알아볼 시간이야! 🎉
Alamofire는 URLSession을 기반으로 만들어진 서드파티 네트워킹 라이브러리야.
GitHub 스타가 4만 개 이상인 엄청난 인기 라이브러리지!

URLSession보다 훨씬 간결한 코드로 같은 작업을 할 수 있어.
특히 복잡한 요청, 파일 업로드, 인증 처리 등에서 빛을 발해.

📦 Alamofire 설치

Swift Package Manager(SPM)로 설치하는 게 가장 쉬워:

// Package.swift에 추가하는 경우
dependencies: [
    .package(
        url: "https://github.com/Alamofire/Alamofire.git",
        .upToNextMajor(from: "5.9.0")
    )
]

// Xcode에서는:
// File → Add Package Dependencies → 
// https://github.com/Alamofire/Alamofire.git 입력

🚀 Alamofire 기본 사용법

URLSession과 비교해보면 얼마나 코드가 줄어드는지 바로 느껴질 거야!

import Alamofire

// 기본 GET 요청 - 이게 전부야! 😲
AF.request("https://jsonplaceholder.typicode.com/posts/1")
    .responseDecodable(of: Post.self) { response in
        switch response.result {
        case .success(let post):
            print("제목: \(post.title)")
        case .failure(let error):
            print("에러: \(error)")
        }
    }

// 배열 받기
AF.request("https://jsonplaceholder.typicode.com/posts")
    .responseDecodable(of: [Post].self) { response in
        switch response.result {
        case .success(let posts):
            print("게시글 수: \(posts.count)")
        case .failure(let error):
            print("에러: \(error)")
        }
    }

// POST 요청
let parameters: [String: Any] = [
    "title": "새 게시글",
    "body": "내용입니다",
    "userId": 1
]

AF.request(
    "https://jsonplaceholder.typicode.com/posts",
    method: .post,
    parameters: parameters,
    encoding: JSONEncoding.default,
    headers: ["Content-Type": "application/json"]
)
.responseDecodable(of: Post.self) { response in
    switch response.result {
    case .success(let post):
        print("생성된 게시글 ID: \(post.id)")
    case .failure(let error):
        print("에러: \(error)")
    }
}

// Encodable 구조체 직접 사용 (더 타입 안전!)
struct CreatePostRequest: Encodable {
    let title: String
    let body: String
    let userId: Int
}

let newPost = CreatePostRequest(title: "제목", body: "내용", userId: 1)

AF.request(
    "https://jsonplaceholder.typicode.com/posts",
    method: .post,
    parameters: newPost,
    encoder: JSONParameterEncoder.default
)
.responseDecodable(of: Post.self) { response in
    // 처리...
}

⚡ Alamofire + async/await

Alamofire 5.5+부터 async/await를 완벽하게 지원해!

// async/await 방식
func fetchPost(id: Int) async throws -> Post {
    return try await AF.request(
        "https://jsonplaceholder.typicode.com/posts/\(id)"
    )
    .serializingDecodable(Post.self)
    .value
}

// 배열 받기
func fetchAllPosts() async throws -> [Post] {
    return try await AF.request(
        "https://jsonplaceholder.typicode.com/posts"
    )
    .serializingDecodable([Post].self)
    .value
}

// 사용
Task {
    do {
        let post = try await fetchPost(id: 1)
        print(post.title)
    } catch {
        print(error)
    }
}

🛡️ Alamofire 고급 기능

Alamofire가 URLSession보다 진짜 빛나는 부분이 여기야.
인터셉터, 인증 처리, 재시도 로직 같은 복잡한 기능들을 엄청 쉽게 구현할 수 있거든!

🔐 RequestInterceptor — 인증 토큰 자동 처리

모든 요청에 Authorization 헤더를 자동으로 붙이거나,
토큰이 만료됐을 때 자동으로 갱신하는 로직을 구현할 수 있어.

import Alamofire

// MARK: - 인증 인터셉터
class AuthInterceptor: RequestInterceptor {
    
    private let tokenManager: TokenManager
    
    init(tokenManager: TokenManager = .shared) {
        self.tokenManager = tokenManager
    }
    
    // 요청 전에 실행 - 헤더 추가
    func adapt(_ urlRequest: URLRequest, 
               for session: Session, 
               completion: @escaping (Result<URLRequest, Error>) -> Void) {
        
        var request = urlRequest
        
        // 액세스 토큰이 있으면 헤더에 추가
        if let token = tokenManager.accessToken {
            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }
        
        completion(.success(request))
    }
    
    // 요청 실패 시 재시도 로직
    func retry(_ request: Request, 
               for session: Session, 
               dueTo error: Error,
               completion: @escaping (RetryResult) -> Void) {
        
        guard let response = request.task?.response as? HTTPURLResponse,
              response.statusCode == 401 else {
            // 401이 아니면 재시도 안 함
            completion(.doNotRetry)
            return
        }
        
        // 토큰 갱신 시도
        tokenManager.refreshToken { [weak self] success in
            if success {
                // 토큰 갱신 성공 → 요청 재시도
                completion(.retry)
            } else {
                // 토큰 갱신 실패 → 로그아웃 처리
                self?.handleLogout()
                completion(.doNotRetry)
            }
        }
    }
    
    private func handleLogout() {
        // 로그아웃 처리 로직
        NotificationCenter.default.post(name: .userDidLogout, object: nil)
    }
}

// MARK: - 토큰 매니저 (간단 예시)
class TokenManager {
    static let shared = TokenManager()
    
    var accessToken: String? {
        return UserDefaults.standard.string(forKey: "accessToken")
    }
    
    func refreshToken(completion: @escaping (Bool) -> Void) {
        // 리프레시 토큰으로 새 액세스 토큰 요청
        // 실제 구현에서는 서버 API 호출
        completion(true)
    }
}

// MARK: - 인터셉터가 적용된 Session 생성
let authenticatedSession = Session(interceptor: AuthInterceptor())

// 사용
authenticatedSession.request("https://api.example.com/profile")
    .responseDecodable(of: UserProfile.self) { response in
        // 자동으로 토큰이 붙어서 요청됨!
    }

📁 파일 업로드

이미지나 파일 업로드도 Alamofire로 엄청 쉽게 할 수 있어!

// 이미지 업로드 (multipart/form-data)
func uploadImage(_ image: UIImage, completion: @escaping (Result<String, Error>) -> Void) {
    
    guard let imageData = image.jpegData(compressionQuality: 0.8) else {
        completion(.failure(NetworkError.noData))
        return
    }
    
    AF.upload(
        multipartFormData: { formData in
            // 이미지 데이터 추가
            formData.append(
                imageData,
                withName: "image",
                fileName: "photo.jpg",
                mimeType: "image/jpeg"
            )
            // 추가 파라미터
            formData.append(
                "profile".data(using: .utf8)!,
                withName: "type"
            )
        },
        to: "https://api.example.com/upload"
    )
    .uploadProgress { progress in
        // 업로드 진행률 (0.0 ~ 1.0)
        print("업로드 진행률: \(Int(progress.fractionCompleted * 100))%")
    }
    .responseDecodable(of: UploadResponse.self) { response in
        switch response.result {
        case .success(let uploadResponse):
            completion(.success(uploadResponse.imageURL))
        case .failure(let error):
            completion(.failure(error))
        }
    }
}

struct UploadResponse: Decodable {
    let imageURL: String
    let success: Bool
}

📥 파일 다운로드

func downloadFile(from url: String) {
    
    let destination: DownloadRequest.Destination = { _, _ in
        let documentsURL = FileManager.default.urls(
            for: .documentDirectory, 
            in: .userDomainMask
        )[0]
        let fileURL = documentsURL.appendingPathComponent("downloaded_file.pdf")
        return (fileURL, [.removePreviousFile, .createIntermediateDirectories])
    }
    
    AF.download(url, to: destination)
        .downloadProgress { progress in
            print("다운로드 진행률: \(Int(progress.fractionCompleted * 100))%")
        }
        .response { response in
            if let error = response.error {
                print("다운로드 실패: \(error)")
            } else if let fileURL = response.fileURL {
                print("다운로드 완료! 저장 위치: \(fileURL)")
            }
        }
}

🔄 EventMonitor — 요청/응답 로깅

디버깅할 때 모든 네트워크 요청을 로그로 찍고 싶다면 EventMonitor를 써봐!

class NetworkLogger: EventMonitor {
    
    let queue = DispatchQueue(label: "com.app.networkLogger")
    
    func requestDidFinish(_ request: Request) {
        print("\n🌐 ===== 네트워크 요청 =====")
        print("📍 URL: \(request.request?.url?.absoluteString ?? "없음")")
        print("📋 Method: \(request.request?.httpMethod ?? "없음")")
        
        if let headers = request.request?.allHTTPHeaderFields {
            print("📨 Headers: \(headers)")
        }
        
        if let body = request.request?.httpBody,
           let bodyString = String(data: body, encoding: .utf8) {
            print("📦 Body: \(bodyString)")
        }
    }
    
    func request<Value>(_ request: DataRequest, 
                         didParseResponse response: DataResponse<Value, AFError>) {
        print("\n📬 ===== 네트워크 응답 =====")
        print("📊 Status: \(response.response?.statusCode ?? 0)")
        
        if let data = response.data,
           let jsonString = String(data: data, encoding: .utf8) {
            print("📄 Response: \(jsonString.prefix(500))") // 처음 500자만
        }
        print("===========================\n")
    }
}

// 로거가 적용된 Session
let loggingSession = Session(eventMonitors: [NetworkLogger()])

🏗️ Alamofire 기반 실전 네트워크 레이어

자, 이제 진짜 실무에서 쓸 수 있는 수준의 네트워크 레이어를 만들어볼게.
프로토콜 지향 설계 + Alamofire + async/await의 조합이야!

import Alamofire
import Foundation

// MARK: - API 라우터 (Router Pattern)
enum APIRouter: URLRequestConvertible {
    
    // 엔드포인트 케이스들
    case login(email: String, password: String)
    case getPosts
    case getPost(id: Int)
    case createPost(title: String, body: String)
    case updatePost(id: Int, title: String, body: String)
    case deletePost(id: Int)
    case uploadImage(data: Data)
    
    // 기본 URL
    static let baseURL = "https://api.example.com/v1"
    
    // HTTP 메서드
    var method: HTTPMethod {
        switch self {
        case .login, .createPost, .uploadImage:
            return .post
        case .getPosts, .getPost:
            return .get
        case .updatePost:
            return .put
        case .deletePost:
            return .delete
        }
    }
    
    // 경로
    var path: String {
        switch self {
        case .login:
            return "/auth/login"
        case .getPosts:
            return "/posts"
        case .getPost(let id):
            return "/posts/\(id)"
        case .createPost:
            return "/posts"
        case .updatePost(let id, _, _):
            return "/posts/\(id)"
        case .deletePost(let id):
            return "/posts/\(id)"
        case .uploadImage:
            return "/media/upload"
        }
    }
    
    // 파라미터
    var parameters: Parameters? {
        switch self {
        case .login(let email, let password):
            return ["email": email, "password": password]
        case .createPost(let title, let body):
            return ["title": title, "body": body]
        case .updatePost(_, let title, let body):
            return ["title": title, "body": body]
        default:
            return nil
        }
    }
    
    // URLRequest 생성
    func asURLRequest() throws -> URLRequest {
        let url = try APIRouter.baseURL.asURL().appendingPathComponent(path)
        var request = URLRequest(url: url)
        request.method = method
        request.timeoutInterval = 30
        
        // 공통 헤더
        request.setValue("application/json", forHTTPHeaderField: "Accept")
        request.setValue("iOS", forHTTPHeaderField: "X-Platform")
        
        // 파라미터 인코딩
        switch method {
        case .get:
            return try URLEncoding.default.encode(request, with: parameters)
        default:
            return try JSONEncoding.default.encode(request, with: parameters)
        }
    }
}

// MARK: - API 서비스 프로토콜
protocol APIServiceProtocol {
    func login(email: String, password: String) async throws -> LoginResponse
    func getPosts() async throws -> [Post]
    func getPost(id: Int) async throws -> Post
    func createPost(title: String, body: String) async throws -> Post
    func deletePost(id: Int) async throws
}

// MARK: - API 서비스 구현
class APIService: APIServiceProtocol {
    
    static let shared = APIService()
    private let session: Session
    
    private init() {
        let interceptor = AuthInterceptor()
        let logger = NetworkLogger()
        
        session = Session(
            interceptor: interceptor,
            eventMonitors: [logger]
        )
    }
    
    // 제네릭 요청 메서드
    private func request<T: Decodable>(_ router: APIRouter) async throws -> T {
        return try await session.request(router)
            .validate(statusCode: 200...299)
            .serializingDecodable(T.self)
            .value
    }
    
    // 응답 없는 요청 (DELETE 등)
    private func requestVoid(_ router: APIRouter) async throws {
        let response = await session.request(router)
            .validate(statusCode: 200...299)
            .serializingData()
            .response
        
        if let error = response.error {
            throw error
        }
    }
    
    // MARK: - 실제 API 메서드들
    func login(email: String, password: String) async throws -> LoginResponse {
        return try await request(.login(email: email, password: password))
    }
    
    func getPosts() async throws -> [Post] {
        return try await request(.getPosts)
    }
    
    func getPost(id: Int) async throws -> Post {
        return try await request(.getPost(id: id))
    }
    
    func createPost(title: String, body: String) async throws -> Post {
        return try await request(.createPost(title: title, body: body))
    }
    
    func deletePost(id: Int) async throws {
        try await requestVoid(.deletePost(id: id))
    }
}

// MARK: - 응답 모델들
struct LoginResponse: Decodable {
    let accessToken: String
    let refreshToken: String
    let user: User
}

// MARK: - ViewModel에서 사용
@MainActor
class PostListViewModel: ObservableObject {
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let apiService: APIServiceProtocol
    
    init(apiService: APIServiceProtocol = APIService.shared) {
        self.apiService = apiService
    }
    
    func loadPosts() async {
        isLoading = true
        errorMessage = nil
        
        do {
            posts = try await apiService.getPosts()
        } catch let error as AFError {
            handleAFError(error)
        } catch {
            errorMessage = error.localizedDescription
        }
        
        isLoading = false
    }
    
    private func handleAFError(_ error: AFError) {
        switch error {
        case .responseValidationFailed(let reason):
            switch reason {
            case .unacceptableStatusCode(let code):
                errorMessage = "서버 오류 (코드: \(code))"
            default:
                errorMessage = "응답 검증 실패"
            }
        case .sessionTaskFailed(let error):
            if (error as NSError).code == NSURLErrorNotConnectedToInternet {
                errorMessage = "인터넷 연결을 확인해주세요"
            } else {
                errorMessage = "네트워크 오류: \(error.localizedDescription)"
            }
        default:
            errorMessage = error.localizedDescription
        }
    }
}

🧪 네트워크 코드 테스트하기

실무에서 진짜 중요한 부분이야. 네트워크 코드를 테스트하려면 Mock 객체를 활용해야 해.
실제 서버에 의존하지 않고 테스트할 수 있어서 빠르고 안정적이거든!

import XCTest
@testable import MyApp

// MARK: - Mock API 서비스
class MockAPIService: APIServiceProtocol {
    
    // 테스트용 더미 데이터
    var mockPosts: [Post] = [
        Post(id: 1, userId: 1, title: "테스트 게시글", body: "내용"),
        Post(id: 2, userId: 1, title: "두 번째 게시글", body: "내용2")
    ]
    
    var shouldThrowError = false
    var mockError: Error = NetworkError.serverError(500)
    
    func login(email: String, password: String) async throws -> LoginResponse {
        if shouldThrowError { throw mockError }
        return LoginResponse(
            accessToken: "mock_token",
            refreshToken: "mock_refresh",
            user: User(id: 1, name: "테스트유저", email: email, username: "test")
        )
    }
    
    func getPosts() async throws -> [Post] {
        if shouldThrowError { throw mockError }
        return mockPosts
    }
    
    func getPost(id: Int) async throws -> Post {
        if shouldThrowError { throw mockError }
        guard let post = mockPosts.first(where: { $0.id == id }) else {
            throw NetworkError.notFound
        }
        return post
    }
    
    func createPost(title: String, body: String) async throws -> Post {
        if shouldThrowError { throw mockError }
        let newPost = Post(id: mockPosts.count + 1, userId: 1, title: title, body: body)
        mockPosts.append(newPost)
        return newPost
    }
    
    func deletePost(id: Int) async throws {
        if shouldThrowError { throw mockError }
        mockPosts.removeAll { $0.id == id }
    }
}

// MARK: - ViewModel 테스트
class PostListViewModelTests: XCTestCase {
    
    var viewModel: PostListViewModel!
    var mockService: MockAPIService!
    
    override func setUp() {
        super.setUp()
        mockService = MockAPIService()
        viewModel = PostListViewModel(apiService: mockService)
    }
    
    // 게시글 로드 성공 테스트
    func testLoadPostsSuccess() async {
        await viewModel.loadPosts()
        
        XCTAssertEqual(viewModel.posts.count, 2)
        XCTAssertNil(viewModel.errorMessage)
        XCTAssertFalse(viewModel.isLoading)
    }
    
    // 게시글 로드 실패 테스트
    func testLoadPostsFailure() async {
        mockService.shouldThrowError = true
        
        await viewModel.loadPosts()
        
        XCTAssertTrue(viewModel.posts.isEmpty)
        XCTAssertNotNil(viewModel.errorMessage)
        XCTAssertFalse(viewModel.isLoading)
    }
}

🌐 실전 시나리오: 페이지네이션 구현

실제 앱에서 자주 쓰이는 무한 스크롤(페이지네이션)을 구현해볼게.
이건 재능넷 같은 플랫폼에서도 콘텐츠 목록을 불러올 때 꼭 필요한 기능이야!

@MainActor
class PaginatedPostViewModel: ObservableObject {
    
    @Published var posts: [Post] = []
    @Published var isLoading = false
    @Published var isLoadingMore = false
    @Published var hasMorePages = true
    @Published var errorMessage: String?
    
    private var currentPage = 1
    private let pageSize = 20
    private var isFetching = false
    
    // 처음 로드
    func loadInitial() async {
        guard !isFetching else { return }
        
        currentPage = 1
        posts = []
        hasMorePages = true
        
        await fetchPosts(page: currentPage)
    }
    
    // 다음 페이지 로드 (무한 스크롤)
    func loadMore() async {
        guard !isFetching, hasMorePages else { return }
        
        currentPage += 1
        await fetchPosts(page: currentPage)
    }
    
    private func fetchPosts(page: Int) async {
        isFetching = true
        
        if page == 1 {
            isLoading = true
        } else {
            isLoadingMore = true
        }
        
        defer {
            isFetching = false
            isLoading = false
            isLoadingMore = false
        }
        
        do {
            let newPosts = try await fetchPostsFromAPI(page: page, size: pageSize)
            
            if page == 1 {
                posts = newPosts
            } else {
                posts.append(contentsOf: newPosts)
            }
            
            // 받은 데이터가 pageSize보다 적으면 마지막 페이지
            hasMorePages = newPosts.count == pageSize
            
        } catch {
            errorMessage = error.localizedDescription
            if page > 1 {
                currentPage -= 1 // 실패 시 페이지 롤백
            }
        }
    }
    
    private func fetchPostsFromAPI(page: Int, size: Int) async throws -> [Post] {
        // Alamofire로 페이지네이션 API 호출
        let parameters: Parameters = [
            "page": page,
            "size": size
        ]
        
        return try await AF.request(
            "https://api.example.com/posts",
            parameters: parameters
        )
        .serializingDecodable([Post].self)
        .value
    }
}

// SwiftUI에서 사용
struct PostListView: View {
    @StateObject private var viewModel = PaginatedPostViewModel()
    
    var body: some View {
        List {
            ForEach(viewModel.posts) { post in
                PostRow(post: post)
                    .onAppear {
                        // 마지막 아이템이 보이면 다음 페이지 로드
                        if post.id == viewModel.posts.last?.id {
                            Task { await viewModel.loadMore() }
                        }
                    }
            }
            
            if viewModel.isLoadingMore {
                ProgressView()
                    .frame(maxWidth: .infinity)
            }
        }
        .task {
            await viewModel.loadInitial()
        }
    }
}

🔒 보안 고려사항

네트워킹 코드를 짤 때 보안도 절대 빠뜨리면 안 돼!
특히 iOS 앱에서 중요한 보안 포인트들을 알아보자.

import Security

class KeychainManager {
    static let shared = KeychainManager()
    
    func save(key: String, value: String) {
        let data = value.data(using: .utf8)!
        
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecValueData as String: data
        ]
        
        SecItemDelete(query as CFDictionary) // 기존 값 삭제
        SecItemAdd(query as CFDictionary, nil)
    }
    
    func load(key: String) -> String? {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key,
            kSecReturnData as String: true,
            kSecMatchLimit as String: kSecMatchLimitOne
        ]
        
        var result: AnyObject?
        SecItemCopyMatching(query as CFDictionary, &result)
        
        guard let data = result as? Data else { return nil }
        return String(data: data, encoding: .utf8)
    }
    
    func delete(key: String) {
        let query: [String: Any] = [
            kSecClass as String: kSecClassGenericPassword,
            kSecAttrAccount as String: key
        ]
        SecItemDelete(query as CFDictionary)
    }
}

// 사용
KeychainManager.shared.save(key: "accessToken", value: "your_token_here")
let token = KeychainManager.shared.load(key: "accessToken")

// SSL Pinning 설정
let evaluators: [String: ServerTrustEvaluating] = [
    "api.example.com": PinnedCertificatesTrustEvaluator(
        certificates: Bundle.main.af.certificates
    )
]

let serverTrustManager = ServerTrustManager(evaluators: evaluators)

let secureSession = Session(
    serverTrustManager: serverTrustManager
)

// 이제 이 session으로 요청하면 인증서 검증이 자동으로 됨!

<key>NSAppTransportSecurity</key>
<dict>
    <key>NSExceptionDomains</key>
    <dict>
        <key>api.example.com</key>
        <dict>
            <key>NSExceptionAllowsInsecureHTTPLoads</key>
            <true/>
        </dict>
    </dict>
</dict>

<!-- 전체 HTTP 허용은 절대 하지 마! (보안 위험) -->
<!-- NSAllowsArbitraryLoads: true ← 이건 앱스토어 심사에서도 문제됨 -->

⚡ 성능 최적화 팁

🔄 요청 취소 (Task Cancellation)

class SearchViewModel: ObservableObject {
    @Published var results: [Post] = []
    private var searchTask: Task<Void, Never>?
    
    func search(query: String) {
        // 이전 검색 취소
        searchTask?.cancel()
        
        searchTask = Task {
            // 디바운싱 (300ms 대기)
            try? await Task.sleep(nanoseconds: 300_000_000)
            
            guard !Task.isCancelled else { return }
            
            do {
                let posts = try await searchPosts(query: query)
                
                guard !Task.isCancelled else { return }
                
                await MainActor.run {
                    self.results = posts
                }
            } catch is CancellationError {
                // 취소는 에러가 아님
            } catch {
                print("검색 에러: \(error)")
            }
        }
    }
    
    private func searchPosts(query: String) async throws -> [Post] {
        return try await AF.request(
            "https://api.example.com/posts/search",
            parameters: ["q": query]
        )
        .serializingDecodable([Post].self)
        .value
    }
}

// Alamofire 요청 취소
class DataFetcher {
    private var currentRequest: DataRequest?
    
    func fetchData() {
        currentRequest = AF.request("https://api.example.com/data")
            .responseDecodable(of: [Post].self) { response in
                // 처리
            }
    }
    
    func cancelFetch() {
        currentRequest?.cancel()
    }
}

⚡ 병렬 요청 (async let)

// 순차 실행 (느림 😴)
func loadDataSequential() async throws {
    let user = try await fetchUser(id: 1)        // 기다림...
    let posts = try await fetchPosts(userId: 1)   // 또 기다림...
    let comments = try await fetchComments()       // 또또 기다림...
    
    // 총 시간 = A + B + C
}

// 병렬 실행 (빠름 🚀)
func loadDataParallel() async throws {
    async let user = fetchUser(id: 1)
    async let posts = fetchPosts(userId: 1)
    async let comments = fetchComments()
    
    // 세 요청이 동시에 실행됨!
    let (userData, postsData, commentsData) = try await (user, posts, comments)
    
    // 총 시간 = max(A, B, C)
    print("유저: \(userData.name)")
    print("게시글: \(postsData.count)개")
    print("댓글: \(commentsData.count)개")
}

// TaskGroup으로 동적 병렬 처리
func fetchMultiplePosts(ids: [Int]) async throws -> [Post] {
    return try await withThrowingTaskGroup(of: Post.self) { group in
        for id in ids {
            group.addTask {
                try await self.fetchPost(id: id)
            }
        }
        
        var posts: [Post] = []
        for try await post in group {
            posts.append(post)
        }
        return posts.sorted { $0.id < $1.id }
    }
}

💾 URLCache 활용

// 앱 시작 시 캐시 설정 (AppDelegate 또는 App struct)
func setupURLCache() {
    let memoryCapacity = 50 * 1024 * 1024  // 50MB 메모리 캐시
    let diskCapacity = 200 * 1024 * 1024   // 200MB 디스크 캐시
    
    URLCache.shared = URLCache(
        memoryCapacity: memoryCapacity,
        diskCapacity: diskCapacity
    )
}

// 캐시 정책 설정
var request = URLRequest(url: url)
request.cachePolicy = .returnCacheDataElseLoad  // 캐시 우선, 없으면 네트워크

// Alamofire에서 캐시 활용
let config = URLSessionConfiguration.default
config.urlCache = URLCache.shared
config.requestCachePolicy = .useProtocolCachePolicy

let cachedSession = Session(configuration: config)

🎯 URLSession vs Alamofire — 언제 뭘 써야 해?

이게 진짜 많이 받는 질문이야. "URLSession 쓸까요, Alamofire 쓸까요?"
정답은 없어. 상황에 따라 다르거든. 내 기준을 공유해줄게!

🐛 자주 만나는 에러와 해결법

개발하다 보면 반드시 만나게 되는 에러들이 있어.
미리 알아두면 삽질 시간을 엄청 줄일 수 있어!

import Network

class NetworkMonitor: ObservableObject {
    static let shared = NetworkMonitor()
    
    @Published var isConnected = true
    @Published var connectionType: ConnectionType = .unknown
    
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue(label: "NetworkMonitor")
    
    enum ConnectionType {
        case wifi, cellular, ethernet, unknown
    }
    
    private init() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
                
                if path.usesInterfaceType(.wifi) {
                    self?.connectionType = .wifi
                } else if path.usesInterfaceType(.cellular) {
                    self?.connectionType = .cellular
                } else if path.usesInterfaceType(.wiredEthernet) {
                    self?.connectionType = .ethernet
                } else {
                    self?.connectionType = .unknown
                }
            }
        }
        monitor.start(queue: queue)
    }
    
    deinit {
        monitor.cancel()
    }
}

// SwiftUI에서 사용
struct ContentView: View {
    @StateObject private var networkMonitor = NetworkMonitor.shared
    
    var body: some View {
        VStack {
            if !networkMonitor.isConnected {
                Text("⚠️ 인터넷 연결이 없습니다")
                    .foregroundColor(.red)
                    .padding()
                    .background(Color.yellow.opacity(0.3))
                    .cornerRadius(8)
            }
            // 나머지 콘텐츠
        }
    }
}

📚 정리 — 오늘 배운 것들

오늘 정말 많은 내용을 다뤘어! 한 번에 다 외우려고 하지 말고,
실제로 코드를 쳐보면서 익히는 게 가장 중요해.

처음엔 URLSession으로 간단한 GET 요청부터 시작해서,
점점 복잡한 기능들을 추가해나가는 방식으로 연습해봐!

그리고 재능넷에서 iOS 개발 관련 재능을 찾아보면,
실무 경험이 있는 개발자들에게 직접 코드 리뷰나 멘토링을 받을 수도 있어.
혼자 공부하는 것보다 훨씬 빠르게 성장할 수 있거든! 💪