🎯 왜 JSON 파싱이 중요할까?

안녕! 오늘은 Swift 개발자라면 반드시 알아야 할 JSON 파싱과 Codable 프로토콜에 대해 이야기해볼게. 😊

요즘 앱 개발하면서 서버와 통신 안 하는 경우가 거의 없잖아? 날씨 정보를 가져오든, 사용자 프로필을 불러오든, 쇼핑몰 상품 목록을 보여주든... 모든 게 서버와의 데이터 주고받기로 시작되지. 그리고 그 데이터 형식의 90% 이상이 바로 JSON(JavaScript Object Notation)이야! 📦

예전에는 JSON 파싱이 정말 골치 아픈 작업이었어. JSONSerialization을 사용해서 딕셔너리로 변환하고, 타입 캐스팅하고, 옵셔널 체이닝 지옥에 빠지고... 생각만 해도 끔찍하지? 😱

하지만 Swift 4부터 등장한 Codable 프로토콜은 이 모든 걸 혁명적으로 바꿔놨어. 마치 마법처럼 JSON 데이터가 Swift 객체로 변신하거든!

📚 Codable 프로토콜의 정체

자, 본격적으로 Codable이 뭔지 파헤쳐보자! 🔍

Codable은 사실 두 개의 프로토콜을 합쳐놓은 타입 별칭(typealias)이야:

typealias Codable = Decodable & Encodable

즉, Decodable과 Encodable 두 프로토콜을 동시에 채택한 거지. 각각의 역할을 보면:

대부분의 경우 양방향 변환이 필요하니까 그냥 Codable을 사용하면 돼. 간단하지? 😎

🛠️ 커스텀 디코딩: init(from:) 구현하기

때로는 자동 디코딩만으로는 부족한 경우가 있어. 예를 들어:

• JSON 데이터를 변환하거나 가공해야 할 때
• 기본값을 설정해야 할 때
• 여러 JSON 키를 하나의 프로퍼티로 합쳐야 할 때
• 날짜 형식을 변환해야 할 때

이럴 때는 init(from decoder: Decoder) 메서드를 직접 구현하면 돼! 🎯

예를 들어, 서버에서 온도를 화씨로 보내는데 우리는 섭씨로 저장하고 싶다면:

struct Temperature: Codable {
    let celsius: Double
    let location: String
    
    enum CodingKeys: String, CodingKey {
        case fahrenheit = "temperature"
        case location
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        // 화씨를 섭씨로 변환
        let fahrenheit = try container.decode(Double.self, forKey: .fahrenheit)
        self.celsius = (fahrenheit - 32) * 5 / 9
        
        // location은 그대로
        self.location = try container.decode(String.self, forKey: .location)
    }
}

더 복잡한 예제를 볼까? 사용자의 전체 이름이 firstName과 lastName으로 나뉘어 있는데, 우리는 fullName 하나로 저장하고 싶다면:

struct Person: Codable {
    let fullName: String
    let age: Int
    let email: String
    
    enum CodingKeys: String, CodingKey {
        case firstName
        case lastName
        case age
        case email
    }
    
    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        
        // firstName과 lastName을 합쳐서 fullName 생성
        let firstName = try container.decode(String.self, forKey: .firstName)
        let lastName = try container.decode(String.self, forKey: .lastName)
        self.fullName = "\(firstName) \(lastName)"
        
        // 나머지는 그대로 디코딩
        self.age = try container.decode(Int.self, forKey: .age)
        self.email = try container.decode(String.self, forKey: .email)
    }
}

⚠️ 에러 처리와 디버깅

JSON 파싱은 실패할 수 있는 작업이야. 네트워크 문제, 잘못된 데이터 형식, 예상치 못한 구조 등... 에러 처리가 정말 중요하지! 🚨

🔍 일반적인 디코딩 에러들

do {
    let user = try decoder.decode(User.self, from: jsonData)
    print("성공: \(user)")
} catch DecodingError.keyNotFound(let key, let context) {
    print("키를 찾을 수 없음: \(key.stringValue)")
    print("경로: \(context.codingPath)")
    print("설명: \(context.debugDescription)")
    
} catch DecodingError.typeMismatch(let type, let context) {
    print("타입 불일치: 예상 타입 \(type)")
    print("경로: \(context.codingPath)")
    print("설명: \(context.debugDescription)")
    
} catch DecodingError.valueNotFound(let type, let context) {
    print("값을 찾을 수 없음: \(type)")
    print("경로: \(context.codingPath)")
    
} catch DecodingError.dataCorrupted(let context) {
    print("데이터 손상")
    print("경로: \(context.codingPath)")
    print("설명: \(context.debugDescription)")
    
} catch {
    print("알 수 없는 에러: \(error)")
}

더 사용자 친화적인 에러 처리:

enum APIError: Error, LocalizedError {
    case decodingFailed(String)
    case networkError(String)
    case invalidResponse
    
    var errorDescription: String? {
        switch self {
        case .decodingFailed(let message):
            return "데이터 변환 실패: \(message)"
        case .networkError(let message):
            return "네트워크 오류: \(message)"
        case .invalidResponse:
            return "잘못된 서버 응답"
        }
    }
}

func fetchUser(id: Int) async throws -> User {
    guard let url = URL(string: "https://api.example.com/users/\(id)") else {
        throw APIError.invalidResponse
    }
    
    do {
        let (data, response) = try await URLSession.shared.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw APIError.networkError("상태 코드 오류")
        }
        
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        
        return try decoder.decode(User.self, from: data)
        
    } catch let error as DecodingError {
        // 디코딩 에러를 더 읽기 쉽게 변환
        let message = parseDecodingError(error)
        throw APIError.decodingFailed(message)
    } catch {
        throw APIError.networkError(error.localizedDescription)
    }
}

func parseDecodingError(_ error: DecodingError) -> String {
    switch error {
    case .keyNotFound(let key, _):
        return "필수 필드 '\(key.stringValue)'가 없습니다"
    case .typeMismatch(let type, let context):
        let path = context.codingPath.map { $0.stringValue }.joined(separator: ".")
        return "'\(path)' 필드의 타입이 \(type)과 일치하지 않습니다"
    case .valueNotFound(let type, let context):
        let path = context.codingPath.map { $0.stringValue }.joined(separator: ".")
        return "'\(path)' 필드에 \(type) 값이 없습니다"
    case .dataCorrupted(let context):
        return "데이터 형식 오류: \(context.debugDescription)"
    @unknown default:
        return "알 수 없는 디코딩 오류"
    }
}

🐛 디버깅 팁

// 1. JSON 데이터를 먼저 출력해서 확인
if let jsonString = String(data: jsonData, encoding: .utf8) {
    print("받은 JSON:")
    print(jsonString)
}

// 2. Pretty print로 보기 좋게
func prettyPrintJSON(_ data: Data) {
    guard let object = try? JSONSerialization.jsonObject(with: data),
          let prettyData = try? JSONSerialization.data(
            withJSONObject: object,
            options: .prettyPrinted
          ),
          let prettyString = String(data: prettyData, encoding: .utf8) else {
        print("JSON 파싱 실패")
        return
    }
    print(prettyString)
}

// 3. 부분적으로 디코딩해서 문제 찾기
struct PartialUser: Codable {
    let id: Int?
    let name: String?
    let email: String?
    // 모든 필드를 옵셔널로 만들어서 어디서 실패하는지 확인
}

// 4. 커스텀 디버그 정보 추가
extension DecodingError {
    var detailedDescription: String {
        switch self {
        case .keyNotFound(let key, let context):
            return """
            키 없음: \(key.stringValue)
            경로: \(context.codingPath.map { $0.stringValue }.joined(separator: " → "))
            설명: \(context.debugDescription)
            """
        case .typeMismatch(_, let context):
            return """
            타입 불일치
            경로: \(context.codingPath.map { $0.stringValue }.joined(separator: " → "))
            설명: \(context.debugDescription)
            """
        case .valueNotFound(_, let context):
            return """
            값 없음
            경로: \(context.codingPath.map { $0.stringValue }.joined(separator: " → "))
            설명: \(context.debugDescription)
            """
        case .dataCorrupted(let context):
            return """
            데이터 손상
            경로: \(context.codingPath.map { $0.stringValue }.joined(separator: " → "))
            설명: \(context.debugDescription)
            """
        @unknown default:
            return "알 수 없는 에러"
        }
    }
}

🚀 실전 예제: 완전한 API 통신

이제 배운 걸 모두 활용해서 실제 API 통신 코드를 만들어보자! GitHub API를 사용하는 예제야. 😎

import Foundation

// MARK: - 모델 정의
struct GitHubUser: Codable {
    let login: String
    let id: Int
    let avatarUrl: String
    let name: String?
    let bio: String?
    let publicRepos: Int
    let followers: Int
    let following: Int
    let createdAt: Date
    let updatedAt: Date
    
    enum CodingKeys: String, CodingKey {
        case login, id, name, bio, followers, following
        case avatarUrl = "avatar_url"
        case publicRepos = "public_repos"
        case createdAt = "created_at"
        case updatedAt = "updated_at"
    }
}

struct Repository: Codable {
    let id: Int
    let name: String
    let fullName: String
    let description: String?
    let stargazersCount: Int
    let forksCount: Int
    let language: String?
    let createdAt: Date
    let updatedAt: Date
    
    enum CodingKeys: String, CodingKey {
        case id, name, description, language
        case fullName = "full_name"
        case stargazersCount = "stargazers_count"
        case forksCount = "forks_count"
        case createdAt = "created_at"
        case updatedAt = "updated_at"
    }
}

// MARK: - API 서비스
class GitHubService {
    private let baseURL = "https://api.github.com"
    private let decoder: JSONDecoder
    
    init() {
        decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
    }
    
    func fetchUser(username: String) async throws -> GitHubUser {
        let urlString = "\(baseURL)/users/\(username)"
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        let (data, response) = try await URLSession.shared.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse else {
            throw URLError(.badServerResponse)
        }
        
        guard (200...299).contains(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }
        
        do {
            return try decoder.decode(GitHubUser.self, from: data)
        } catch {
            print("디코딩 에러: \(error)")
            if let decodingError = error as? DecodingError {
                print(decodingError.detailedDescription)
            }
            throw error
        }
    }
    
    func fetchRepositories(username: String) async throws -> [Repository] {
        let urlString = "\(baseURL)/users/\(username)/repos"
        guard let url = URL(string: urlString) else {
            throw URLError(.badURL)
        }
        
        let (data, response) = try await URLSession.shared.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }
        
        return try decoder.decode([Repository].self, from: data)
    }
}

// MARK: - 사용 예제
Task {
    let service = GitHubService()
    
    do {
        // 사용자 정보 가져오기
        let user = try await service.fetchUser(username: "apple")
        print("사용자: \(user.login)")
        print("이름: \(user.name ?? "없음")")
        print("팔로워: \(user.followers)명")
        print("공개 저장소: \(user.publicRepos)개")
        
        // 저장소 목록 가져오기
        let repos = try await service.fetchRepositories(username: "apple")
        print("\n저장소 목록:")
        for repo in repos.prefix(5) {
            print("- \(repo.name)")
            print("  ⭐️ \(repo.stargazersCount) stars")
            if let language = repo.language {
                print("  💻 \(language)")
            }
        }
        
    } catch {
        print("에러 발생: \(error.localizedDescription)")
    }
}

SwiftUI와 함께 사용하는 예제:

import SwiftUI

class GitHubViewModel: ObservableObject {
    @Published var user: GitHubUser?
    @Published var repositories: [Repository] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let service = GitHubService()
    
    @MainActor
    func loadUser(username: String) async {
        isLoading = true
        errorMessage = nil
        
        do {
            user = try await service.fetchUser(username: username)
            repositories = try await service.fetchRepositories(username: username)
        } catch {
            errorMessage = "데이터를 불러올 수 없습니다: \(error.localizedDescription)"
        }
        
        isLoading = false
    }
}

struct GitHubProfileView: View {
    @StateObject private var viewModel = GitHubViewModel()
    @State private var username = "apple"
    
    var body: some View {
        NavigationView {
            VStack {
                if viewModel.isLoading {
                    ProgressView("로딩 중...")
                } else if let user = viewModel.user {
                    ScrollView {
                        VStack(alignment: .leading, spacing: 20) {
                            // 사용자 정보
                            HStack {
                                AsyncImage(url: URL(string: user.avatarUrl)) { image in
                                    image.resizable()
                                } placeholder: {
                                    Color.gray
                                }
                                .frame(width: 80, height: 80)
                                .clipShape(Circle())
                                
                                VStack(alignment: .leading) {
                                    Text(user.name ?? user.login)
                                        .font(.title)
                                    Text("@\(user.login)")
                                        .foregroundColor(.secondary)
                                }
                            }
                            
                            if let bio = user.bio {
                                Text(bio)
                                    .font(.body)
                            }
                            
                            HStack(spacing: 20) {
                                StatView(title: "팔로워", value: "\(user.followers)")
                                StatView(title: "팔로잉", value: "\(user.following)")
                                StatView(title: "저장소", value: "\(user.publicRepos)")
                            }
                            
                            // 저장소 목록
                            Text("저장소")
                                .font(.headline)
                            
                            ForEach(viewModel.repositories.prefix(10), id: \.id) { repo in
                                RepositoryRow(repository: repo)
                            }
                        }
                        .padding()
                    }
                } else if let error = viewModel.errorMessage {
                    Text(error)
                        .foregroundColor(.red)
                }
            }
            .navigationTitle("GitHub Profile")
            .task {
                await viewModel.loadUser(username: username)
            }
        }
    }
}

struct StatView: View {
    let title: String
    let value: String
    
    var body: some View {
        VStack {
            Text(value)
                .font(.title2)
                .fontWeight(.bold)
            Text(title)
                .font(.caption)
                .foregroundColor(.secondary)
        }
    }
}

struct RepositoryRow: View {
    let repository: Repository
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text(repository.name)
                .font(.headline)
            
            if let description = repository.description {
                Text(description)
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                    .lineLimit(2)
            }
            
            HStack {
                if let language = repository.language {
                    Label(language, systemImage: "chevron.left.forwardslash.chevron.right")
                        .font(.caption)
                }
                
                Label("\(repository.stargazersCount)", systemImage: "star.fill")
                    .font(.caption)
                
                Label("\(repository.forksCount)", systemImage: "tuningfork")
                    .font(.caption)
            }
            .foregroundColor(.secondary)
        }
        .padding()
        .background(Color.gray.opacity(0.1))
        .cornerRadius(10)
    }
}

💎 고급 테크닉과 최적화

이제 좀 더 고급 기술들을 알아보자! 실무에서 유용한 팁들이야. 🎓

1️⃣ 제네릭을 활용한 재사용 가능한 API 클라이언트

protocol APIRequest {
    associatedtype Response: Codable
    
    var path: String { get }
    var method: String { get }
    var queryItems: [URLQueryItem]? { get }
    var body: Data? { get }
}

extension APIRequest {
    var method: String { "GET" }
    var queryItems: [URLQueryItem]? { nil }
    var body: Data? { nil }
}

class APIClient {
    private let baseURL: URL
    private let session: URLSession
    private let decoder: JSONDecoder
    
    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
        
        self.decoder = JSONDecoder()
        self.decoder.keyDecodingStrategy = .convertFromSnakeCase
        self.decoder.dateDecodingStrategy = .iso8601
    }
    
    func send<T: APIRequest>(_ request: T) async throws -> T.Response {
        var components = URLComponents(
            url: baseURL.appendingPathComponent(request.path),
            resolvingAgainstBaseURL: true
        )
        components?.queryItems = request.queryItems
        
        guard let url = components?.url else {
            throw URLError(.badURL)
        }
        
        var urlRequest = URLRequest(url: url)
        urlRequest.httpMethod = request.method
        urlRequest.httpBody = request.body
        urlRequest.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let (data, response) = try await session.data(for: urlRequest)
        
        guard let httpResponse = response as? HTTPURLResponse,
              (200...299).contains(httpResponse.statusCode) else {
            throw URLError(.badServerResponse)
        }
        
        return try decoder.decode(T.Response.self, from: data)
    }
}

// 사용 예제
struct GetUserRequest: APIRequest {
    typealias Response = GitHubUser
    
    let username: String
    
    var path: String {
        "/users/\(username)"
    }
}

struct SearchRepositoriesRequest: APIRequest {
    typealias Response = SearchResult
    
    let query: String
    let page: Int
    
    var path: String { "/search/repositories" }
    
    var queryItems: [URLQueryItem]? {
        [
            URLQueryItem(name: "q", value: query),
            URLQueryItem(name: "page", value: "\(page)")
        ]
    }
}

struct SearchResult: Codable {
    let totalCount: Int
    let items: [Repository]
}

// 실제 사용
let client = APIClient(baseURL: URL(string: "https://api.github.com")!)

Task {
    let user = try await client.send(GetUserRequest(username: "apple"))
    print(user.name ?? "")
    
    let searchResult = try await client.send(
        SearchRepositoriesRequest(query: "swift", page: 1)
    )
    print("검색 결과: \(searchResult.totalCount)개")
}

2️⃣ 캐싱 전략

actor DataCache<Key: Hashable, Value> {
    private var cache: [Key: CacheEntry<Value>] = [:]
    private let expirationInterval: TimeInterval
    
    struct CacheEntry<T> {
        let value: T
        let expirationDate: Date
    }
    
    init(expirationInterval: TimeInterval = 300) { // 5분 기본값
        self.expirationInterval = expirationInterval
    }
    
    func get(_ key: Key) -> Value? {
        guard let entry = cache[key] else { return nil }
        
        if Date() > entry.expirationDate {
            cache.removeValue(forKey: key)
            return nil
        }
        
        return entry.value
    }
    
    func set(_ value: Value, forKey key: Key) {
        let expirationDate = Date().addingTimeInterval(expirationInterval)
        cache[key] = CacheEntry(value: value, expirationDate: expirationDate)
    }
    
    func clear() {
        cache.removeAll()
    }
}

class CachedAPIClient {
    private let client: APIClient
    private let cache = DataCache<String, Any>()
    
    init(client: APIClient) {
        self.client = client
    }
    
    func send<T: APIRequest>(_ request: T, useCache: Bool = true) async throws -> T.Response {
        let cacheKey = "\(request.path)_\(request.method)"
        
        if useCache, let cached = await cache.get(cacheKey) as? T.Response {
            print("캐시에서 반환")
            return cached
        }
        
        let response = try await client.send(request)
        await cache.set(response, forKey: cacheKey)
        
        return response
    }
}

3️⃣ 대용량 JSON 스트리밍

// 큰 JSON 파일을 한 번에 메모리에 올리지 않고 스트리밍으로 처리
class JSONStreamDecoder<T: Codable> {
    private let decoder = JSONDecoder()
    
    func decode(from url: URL, batchSize: Int = 100, 
                handler: @escaping ([T]) -> Void) throws {
        guard let inputStream = InputStream(url: url) else {
            throw NSError(domain: "StreamError", code: -1)
        }
        
        inputStream.open()
        defer { inputStream.close() }
        
        var buffer = [UInt8](repeating: 0, count: 4096)
        var jsonString = ""
        var batch: [T] = []
        
        while inputStream.hasBytesAvailable {
            let bytesRead = inputStream.read(&buffer, maxLength: buffer.count)
            if bytesRead > 0 {
                if let chunk = String(bytes: buffer[..<bytesRead], encoding: .utf8) {
                    jsonString += chunk
                    
                    // JSON 객체 파싱 시도
                    if let data = jsonString.data(using: .utf8),
                       let item = try? decoder.decode(T.self, from: data) {
                        batch.append(item)
                        jsonString = ""
                        
                        if batch.count >= batchSize {
                            handler(batch)
                            batch.removeAll()
                        }
                    }
                }
            }
        }
        
        if !batch.isEmpty {
            handler(batch)
        }
    }
}

🎨 실무 패턴과 아키텍처

실제 프로젝트에서는 깔끔한 아키텍처가 중요해. 재능넷 같은 플랫폼에서 프로그래밍 재능을 공유할 때도 이런 구조화된 코드가 큰 도움이 되지! 🏗️

📦 Repository 패턴

// 데이터 소스 프로토콜
protocol UserDataSource {
    func fetchUser(id: Int) async throws -> User
    func updateUser(_ user: User) async throws
}

// 원격 데이터 소스 (API)
class RemoteUserDataSource: UserDataSource {
    private let apiClient: APIClient
    
    init(apiClient: APIClient) {
        self.apiClient = apiClient
    }
    
    func fetchUser(id: Int) async throws -> User {
        struct GetUserRequest: APIRequest {
            typealias Response = User
            let id: Int
            var path: String { "/users/\(id)" }
        }
        
        return try await apiClient.send(GetUserRequest(id: id))
    }
    
    func updateUser(_ user: User) async throws {
        // PUT 요청 구현
    }
}

// 로컬 데이터 소스 (캐시/DB)
class LocalUserDataSource: UserDataSource {
    private let cache: DataCache<Int, User>
    
    init() {
        self.cache = DataCache()
    }
    
    func fetchUser(id: Int) async throws -> User {
        guard let user = await cache.get(id) else {
            throw NSError(domain: "CacheError", code: 404)
        }
        return user
    }
    
    func updateUser(_ user: User) async throws {
        await cache.set(user, forKey: user.id)
    }
}

// Repository (데이터 소스 조합)
class UserRepository {
    private let remoteDataSource: RemoteUserDataSource
    private let localDataSource: LocalUserDataSource
    
    init(remoteDataSource: RemoteUserDataSource,
         localDataSource: LocalUserDataSource) {
        self.remoteDataSource = remoteDataSource
        self.localDataSource = localDataSource
    }
    
    func getUser(id: Int, forceRefresh: Bool = false) async throws -> User {
        // 캐시 우선 전략
        if !forceRefresh {
            if let cachedUser = try? await localDataSource.fetchUser(id: id) {
                return cachedUser
            }
        }
        
        // 원격에서 가져오기
        let user = try await remoteDataSource.fetchUser(id: id)
        
        // 로컬에 저장
        try? await localDataSource.updateUser(user)
        
        return user
    }
    
    func updateUser(_ user: User) async throws {
        // 원격 업데이트
        try await remoteDataSource.updateUser(user)
        
        // 로컬 캐시 업데이트
        try await localDataSource.updateUser(user)
    }
}

🎯 Result 타입 활용

extension APIClient {
    func sendSafe<T: APIRequest>(_ request: T) async -> Result<T.Response, Error> {
        do {
            let response = try await send(request)
            return .success(response)
        } catch {
            return .failure(error)
        }
    }
}

// 사용 예제
class UserViewModel: ObservableObject {
    @Published var user: User?
    @Published var errorMessage: String?
    @Published var isLoading = false
    
    private let repository: UserRepository
    
    init(repository: UserRepository) {
        self.repository = repository
    }
    
    @MainActor
    func loadUser(id: Int) async {
        isLoading = true
        errorMessage = nil
        
        do {
            user = try await repository.getUser(id: id)
        } catch {
            errorMessage = handleError(error)
        }
        
        isLoading = false
    }
    
    private func handleError(_ error: Error) -> String {
        if let urlError = error as? URLError {
            switch urlError.code {
            case .notConnectedToInternet:
                return "인터넷 연결을 확인해주세요"
            case .timedOut:
                return "요청 시간이 초과되었습니다"
            default:
                return "네트워크 오류가 발생했습니다"
            }
        } else if let decodingError = error as? DecodingError {
            return "데이터 형식 오류"
        } else {
            return "알 수 없는 오류가 발생했습니다"
        }
    }
}

🔄 Combine과 통합

import Combine

extension APIClient {
    func sendPublisher<T: APIRequest>(_ request: T) -> AnyPublisher<T.Response, Error> {
        Future { promise in
            Task {
                do {
                    let response = try await self.send(request)
                    promise(.success(response))
                } catch {
                    promise(.failure(error))
                }
            }
        }
        .eraseToAnyPublisher()
    }
}

class CombineUserViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    
    private let apiClient: APIClient
    private var cancellables = Set<AnyCancellable>()
    
    init(apiClient: APIClient) {
        self.apiClient = apiClient
    }
    
    func loadUser(id: Int) {
        isLoading = true
        
        apiClient.sendPublisher(GetUserRequest(id: id))
            .receive(on: DispatchQueue.main)
            .sink { [weak self] completion in
                self?.isLoading = false
                if case .failure(let error) = completion {
                    print("에러: \(error)")
                }
            } receiveValue: { [weak self] user in
                self?.user = user
            }
            .store(in: &cancellables)
    }
}

🧪 테스트하기

JSON 파싱 코드도 테스트가 필요해! 특히 다양한 엣지 케이스를 다뤄야 하니까. 🔬

import XCTest

class UserDecodingTests: XCTestCase {
    var decoder: JSONDecoder!
    
    override func setUp() {
        super.setUp()
        decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
    }
    
    func testValidUserDecoding() throws {
        let json = """
        {
            "id": 1,
            "username": "testuser",
            "email": "test@example.com",
            "created_at": "2024-01-01T00:00:00Z"
        }
        """
        
        let data = json.data(using: .utf8)!
        let user = try decoder.decode(User.self, from: data)
        
        XCTAssertEqual(user.id, 1)
        XCTAssertEqual(user.username, "testuser")
        XCTAssertEqual(user.email, "test@example.com")
    }
    
    func testMissingOptionalField() throws {
        let json = """
        {
            "id": 1,
            "username": "testuser",
            "email": "test@example.com"
        }
        """
        
        let data = json.data(using: .utf8)!
        let user = try decoder.decode(User.self, from: data)
        
        XCTAssertNil(user.bio)
        XCTAssertNil(user.profileImage)
    }
    
    func testInvalidDateFormat() {
        let json = """
        {
            "id": 1,
            "username": "testuser",
            "email": "test@example.com",
            "created_at": "invalid-date"
        }
        """
        
        let data = json.data(using: .utf8)!
        
        XCTAssertThrowsError(try decoder.decode(User.self, from: data)) { error in
            XCTAssertTrue(error is DecodingError)
        }
    }
    
    func testTypeMismatch() {
        let json = """
        {
            "id": "not-a-number",
            "username": "testuser",
            "email": "test@example.com"
        }
        """
        
        let data = json.data(using: .utf8)!
        
        XCTAssertThrowsError(try decoder.decode(User.self, from: data)) { error in
            guard case DecodingError.typeMismatch = error else {
                XCTFail("예상한 에러 타입이 아닙니다")
                return
            }
        }
    }
    
    func testArrayDecoding() throws {
        let json = """
        [
            {"id": 1, "username": "user1", "email": "user1@example.com"},
            {"id": 2, "username": "user2", "email": "user2@example.com"}
        ]
        """
        
        let data = json.data(using: .utf8)!
        let users = try decoder.decode([User].self, from: data)
        
        XCTAssertEqual(users.count, 2)
        XCTAssertEqual(users[0].username, "user1")
        XCTAssertEqual(users[1].username, "user2")
    }
    
    func testNestedStructureDecoding() throws {
        let json = """
        {
            "user": {
                "id": 1,
                "username": "testuser"
            },
            "posts": [
                {"id": 1, "title": "첫 번째 글"},
                {"id": 2, "title": "두 번째 글"}
            ]
        }
        """
        
        struct UserWithPosts: Codable {
            let user: User
            let posts: [Post]
        }
        
        struct Post: Codable {
            let id: Int
            let title: String
        }
        
        let data = json.data(using: .utf8)!
        let result = try decoder.decode(UserWithPosts.self, from: data)
        
        XCTAssertEqual(result.user.username, "testuser")
        XCTAssertEqual(result.posts.count, 2)
    }
}

// Mock API Client for testing
class MockAPIClient: APIClient {
    var mockResponse: Any?
    var mockError: Error?
    
    override func send<T: APIRequest>(_ request: T) async throws -> T.Response {
        if let error = mockError {
            throw error
        }
        
        guard let response = mockResponse as? T.Response else {
            throw URLError(.badServerResponse)
        }
        
        return response
    }
}

class UserRepositoryTests: XCTestCase {
    var repository: UserRepository!
    var mockClient: MockAPIClient!
    
    override func setUp() {
        super.setUp()
        mockClient = MockAPIClient(baseURL: URL(string: "https://api.example.com")!)
        let remoteDataSource = RemoteUserDataSource(apiClient: mockClient)
        let localDataSource = LocalUserDataSource()
        repository = UserRepository(
            remoteDataSource: remoteDataSource,
            localDataSource: localDataSource
        )
    }
    
    func testGetUserSuccess() async throws {
        let expectedUser = User(
            id: 1,
            username: "testuser",
            email: "test@example.com"
        )
        mockClient.mockResponse = expectedUser
        
        let user = try await repository.getUser(id: 1)
        
        XCTAssertEqual(user.id, expectedUser.id)
        XCTAssertEqual(user.username, expectedUser.username)
    }
    
    func testGetUserNetworkError() async {
        mockClient.mockError = URLError(.notConnectedToInternet)
        
        do {
            _ = try await repository.getUser(id: 1)
            XCTFail("에러가 발생해야 합니다")
        } catch {
            XCTAssertTrue(error is URLError)
        }
    }
}

🎓 Best Practices 정리

지금까지 배운 내용을 바탕으로 실무에서 지켜야 할 베스트 프랙티스를 정리해볼게! ✨

🚀 실전 프로젝트 구조 예제

마지막으로 실제 프로젝트에서 사용할 수 있는 완전한 구조를 보여줄게! 📁

MyApp/
├── Models/
│   ├── User.swift
│   ├── Product.swift
│   └── Order.swift
│
├── Networking/
│   ├── APIClient.swift
│   ├── APIRequest.swift
│   ├── APIError.swift
│   └── Endpoints/
│       ├── UserEndpoint.swift
│       └── ProductEndpoint.swift
│
├── Repositories/
│   ├── UserRepository.swift
│   └── ProductRepository.swift
│
├── DataSources/
│   ├── Remote/
│   │   ├── RemoteUserDataSource.swift
│   │   └── RemoteProductDataSource.swift
│   └── Local/
│       ├── LocalUserDataSource.swift
│       └── LocalProductDataSource.swift
│
├── ViewModels/
│   ├── UserViewModel.swift
│   └── ProductViewModel.swift
│
├── Views/
│   ├── UserProfileView.swift
│   └── ProductListView.swift
│
└── Utilities/
    ├── DataCache.swift
    ├── NetworkMonitor.swift
    └── Extensions/
        ├── Codable+Extensions.swift
        └── JSONDecoder+Extensions.swift

각 파일의 역할:

// Models/User.swift
struct User: Codable, Identifiable {
    let id: Int
    let username: String
    let email: String
    let profileImageUrl: String?
    let createdAt: Date
    
    enum CodingKeys: String, CodingKey {
        case id, username, email
        case profileImageUrl = "profile_image_url"
        case createdAt = "created_at"
    }
}

// Networking/APIClient.swift
class APIClient {
    static let shared = APIClient()
    
    private let baseURL = URL(string: "https://api.example.com")!
    private let session: URLSession
    private let decoder: JSONDecoder
    
    private init() {
        let configuration = URLSessionConfiguration.default
        configuration.timeoutIntervalForRequest = 30
        configuration.waitsForConnectivity = true
        
        self.session = URLSession(configuration: configuration)
        
        self.decoder = JSONDecoder()
        self.decoder.keyDecodingStrategy = .convertFromSnakeCase
        self.decoder.dateDecodingStrategy = .iso8601
    }
    
    func send<T: APIRequest>(_ request: T) async throws -> T.Response {
        // 구현...
    }
}

// Networking/Endpoints/UserEndpoint.swift
enum UserEndpoint {
    case getUser(id: Int)
    case updateUser(User)
    case searchUsers(query: String)
}

extension UserEndpoint: APIRequest {
    typealias Response = User
    
    var path: String {
        switch self {
        case .getUser(let id):
            return "/users/\(id)"
        case .updateUser:
            return "/users"
        case .searchUsers:
            return "/users/search"
        }
    }
    
    var method: String {
        switch self {
        case .getUser, .searchUsers:
            return "GET"
        case .updateUser:
            return "PUT"
        }
    }
    
    var queryItems: [URLQueryItem]? {
        switch self {
        case .searchUsers(let query):
            return [URLQueryItem(name: "q", value: query)]
        default:
            return nil
        }
    }
}

// Repositories/UserRepository.swift
class UserRepository {
    private let remoteDataSource: RemoteUserDataSource
    private let localDataSource: LocalUserDataSource
    
    init(remoteDataSource: RemoteUserDataSource = .init(),
         localDataSource: LocalUserDataSource = .init()) {
        self.remoteDataSource = remoteDataSource
        self.localDataSource = localDataSource
    }
    
    func getUser(id: Int, forceRefresh: Bool = false) async throws -> User {
        if !forceRefresh, let cached = try? await localDataSource.getUser(id: id) {
            return cached
        }
        
        let user = try await remoteDataSource.getUser(id: id)
        try? await localDataSource.saveUser(user)
        
        return user
    }
}

// ViewModels/UserViewModel.swift
@MainActor
class UserViewModel: ObservableObject {
    @Published var user: User?
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let repository: UserRepository
    
    init(repository: UserRepository = UserRepository()) {
        self.repository = repository
    }
    
    func loadUser(id: Int) async {
        isLoading = true
        errorMessage = nil
        
        do {
            user = try await repository.getUser(id: id)
        } catch {
            errorMessage = error.localizedDescription
        }
        
        isLoading = false
    }
}

// Utilities/Extensions/JSONDecoder+Extensions.swift
extension JSONDecoder {
    static var `default`: JSONDecoder {
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
        return decoder
    }
    
    static var flexible: JSONDecoder {
        let decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .custom { decoder in
            let container = try decoder.singleValueContainer()
            let dateString = try container.decode(String.self)
            
            // 여러 날짜 형식 시도
            let formatters = [
                ISO8601DateFormatter(),
                // 추가 포맷터들...
            ]
            
            for formatter in formatters {
                if let date = formatter.date(from: dateString) {
                    return date
                }
            }
            
            throw DecodingError.dataCorruptedError(
                in: container,
                debugDescription: "날짜 형식을 파싱할 수 없습니다"
            )
        }
        return decoder
    }
}

💡 마무리하며

와! 여기까지 정말 긴 여정이었어! 🎉

Swift의 Codable 프로토콜은 정말 강력한 도구야. JSON 파싱이 이렇게 쉬워질 줄 누가 알았겠어? 예전에는 수십 줄의 보일러플레이트 코드를 작성해야 했는데, 이제는 단 한 줄로 해결되잖아!

핵심 포인트를 다시 정리하면:

이제 여러분은 Swift에서 JSON을 자유자재로 다룰 수 있어! 🎊

실제 프로젝트에 적용하면서 더 많은 경험을 쌓아보길 바라. 그리고 막히는 부분이 있다면 재능넷에서 Swift 전문가들의 도움을 받을 수도 있어. 프로그래밍은 혼자 하는 게 아니라 함께 성장하는 거니까! 💪

재능넷에는 다양한 프로그래밍 재능을 가진 분들이 많으니, 여러분도 배운 지식을 공유하거나 더 깊은 내용을 배울 수 있을 거야.

Happy Coding! 즐거운 코딩 되길! 🚀✨