Using JSON with Custom Types 📙

1️⃣ 설명

스위프트의 JSON 지원을 사용하여 JSON 데이터의 구조에 관계없이 JSON 데이터를 인코딩하고 디코딩할 수 있음

• 다른 앱, 서비스 및 파일에서 보내거나 받는 JSON 데이터는 여러 다른 모양과 구조를 가질 수 있음

2️⃣ 샘플

• 이 샘플에서 설명하는 기술을 사용하여 외부 JSON 데이터와 앱 모델 타입 간의 차이를 처리
• Swift의 표현적인 타입 시스템을 사용하여 구조가 동일한 객체들의 컬렉션을 수동으로 루프를 돌리지 않고 데이터를 읽을 수 있음

  표현적인 타입 시스템Swift’s expressive type system

  • Swift가 강력한 타입 추론과 타입 안전성을 제공하며, 다양한 유형의 데이터와 연산을 간결하고 명확하게 표현할 수 있게 해줌

📌 Read Data From Arrays

• 이 예제에서는 값으로 배열 타입을 사용하여 구조화된 JSON 데이터를 처리하는 방법을 살펴볼 수 있음
• JSON에 앱 모델 타입과 동일한 타입 요소로 구성된 배열이 포함된 경우, 개별 요소의 타입에 Codable프로토콜을 준수하도록 추가해야함
• 전체 배열을 디코드하거나 인코딩하려면 [Element].self문법을 사용
• 예제에서의 GroceryProduct구조체를 선언할 때 Codable프로토콜을채택 했기 때문에 GroceryProduct구조체는 자동으로 디코딩 가능
• 예제의 전체 배열은 decode메서드 호출에 사용된 구문에 기반하여 디코딩됨

import Foundation

let json = """
[
    {
        "name": "Banana",
        "points": 200,
        "description": "A banana grown in Ecuador."
    },
    {
        "name": "Orange",
        "points": 100
    }
]
""".data(using: .utf8)!

struct GroceryProduct: Codable {
    var name: String
    var points: Int
    var description: String?
}

let decoder = JSONDecoder()
let products = try decoder.decode([GroceryProduct].self, from: json)

print("The following products are available:")
for product in products {
    print("\t\(product.name) (\(product.points) points)")
    if let description = product.description {
        print("\t\t\(description)")
    }
}

📌 Change Key Names

• Swift 코드에서 사용하는 이름이 JSON에서 동일한 값을 참조하는 이름과 일치하지 않을 수 있음
• 사용자 정의 매핑을 통해 JSON 키의 이름과 다른 Swift 모델의 속성 이름에 Swift API Design Guidelines를 적용할 수 있음
• Swift에서 JSONEncoder 및 JSONDecoder클래스를 사용할 때, 다른 이름을 사용해야 하는 JSON 데이터와도 쉽게 Swift 데이터 타입의 모델의 속성 이름을 매핑할 수 있음
• 이를 위해 Codable, Encodable, 또는 Decodable을 준수하는 동일한 타입 내에 중첩된 열거형인 CodingKeys를 사용하여 Swift 이름과 JSON 이름 간의 매핑을 정의함

  CodingKeys

  • Swift의 Codable 프로토콜에서 사용되는 중첩된 열거형
  • 이 열거형은 Swift의 속성 이름과 JSON의 키 이름 간의 매핑을 지정하는 역할
  • String 타입을 사용하며, 각 케이스는 매핑할 속성의 이름과 해당하는 JSON 키의 이름을 나타냄
  • 열거형의 케이스 이름은 Swift의 속성 이름을 사용하고, 각 케이스에는 해당 속성에 매핑되는 JSON 키의 이름을 할당

• 이 예제에서는 property인 name, points의 Swift 이름이 product_name, product_cost이라는 JSON 이름과 매핑되는 방법을 보여줌

import Foundation

let json = """
[
    {
        "product_name": "Bananas",
        "product_cost": 200,
        "description": "A banana grown in Ecuador."
    },
    {
        "product_name": "Oranges",
        "product_cost": 100,
        "description": "A juicy orange."
    }
]
""".data(using: .utf8)!

struct GroceryProduct: Codable {
    var name: String
    var points: Int
    var description: String?
    
    private enum CodingKeys: String, CodingKey {
        case name = "product_name"
        case points = "product_cost"
        case description
    }
}

let decoder = JSONDecoder()
let products = try decoder.decode([GroceryProduct].self, from: json)

print("The following products are available:")
for product in products {
    print("\t\(product.name) (\(product.points) points)")
    if let description = product.description {
        print("\t\t\(description)")
    }
}

• 두 표현 사이에 description이라는 이름이 일관되지만, GroceryProduc구조체에서 필요한 값이므로 CodingKeys열거형에 포함시킴
• description열거형 케이스는 rawValue가 필요하지 않으며, 해당하는 프로퍼티 이름과 동일한 이름을 가지고 있음

📌 Access Nested Data

• 코드에서 필요하지 않은 JSON의 구조와 데이터를 무시하는 방법
• 외부 소스나 기존 로컬 형식에서 JSON을 사용하는 코드를 작성할 수 있음
• 앱에서 모델링하는 개념의 구조와 JSON을 모델링하는 개념 사이에 일관성이 없을 수 있음
• 때로는 Swift 프로그램을 위한 논리적인 데이터 번들이 사용하는 JSON의 여러 중첩된 객체나 배열로 퍼져 있을 수 있음
• JSON의 구조적인 격차를 극복하기 위해 읽어들이는 JSON의 구조와 일치하는 decodable타입을 작성해야함
• decodable타입은 안전하게 디코딩할 수 있는 중간 타입 역할을 하며, 나머지 앱에서 사용할 타입의 이니셜라이저에서 데이터 소스 역할을 함
• 중간 타입을 사용하면 자신의 코드에서 가장 자연스러운 타입을 사용하면서도 다양한 형태의 외부 JSON과의 호환성을 유지할 수 있음
• 아래 예제에서는 JSON에서 원하지 않는 데이터와 구조를 건너뛰고 식료품 제품을 추출하는 방법을 보여주기 위해 중간 타입을 사용

import Foundation

struct GroceryStore {
    var name: String
    var products: [Product]
    
    struct Product: Codable {
        var name: String
        var points: Int
        var description: String?
    }
}

• API가 식료품점에 대한 정보를 아래와 같이 구조화된 JSON으로 제공

let json = """
[
    {
        "name": "Home Town Market",
        "aisles": [
            {
                "name": "Produce",
                "shelves": [
                    {
                        "name": "Discount Produce",
                        "product": {
                            "name": "Banana",
                            "points": 200,
                            "description": "A banana that's perfectly ripe."
                        }
                    }
                ]
            }
        ]
    },
    {
        "name": "Big City Market",
        "aisles": [
            {
                "name": "Sale Aisle",
                "shelves": [
                    {
                        "name": "Seasonal Sale",
                        "product": {
                            "name": "Chestnuts",
                            "points": 700,
                            "description": "Chestnuts that were roasted over an open fire."
                        }
                    },
                    {
                        "name": "Last Season's Clearance",
                        "product": {
                            "name": "Pumpkin Seeds",
                            "points": 400,
                            "description": "Seeds harvested from a pumpkin."
                        }
                    }
                ]
            }
        ]
    }
]
""".data(using: .utf8)!

• API에서 반환하는 JSON은 GroceryStore구조체를 채우는 데 필요한 정보보다 더 많은 정보를 포함하고 있고, 제품은 통로와 선반 내에 중첩되어 있음
• JSON을 제공하는 업체(API를 제공)는 추가 정보가 필요할 수 있지만, 이를 사용하는 앱에서는 유용하지 않을 수 있음
• 외부 컨테이너에서 필요한 데이터를 추출하기 위해, JSON과 동일한 구조를 가진 유형을 작성하고 Decodable로 표시함
• 그런 다음, 나머지 앱에서 사용할 유형에 JSON과 유사한 유형의 인스턴스를 취하는 이니셜라이저를 작성
• 아래의 예제에서 GroceryStoreService구조체는 앱에서의 JSON 사용을 위해 GroceryStor구조체 간의 중개자 역할을 함

struct GroceryStoreService: Decodable {
    let name: String
    let aisles: [Aisle]
    
    struct Aisle: Decodable {
        let name: String
        let shelves: [Shelf]
        
        struct Shelf: Decodable {
            let name: String
            let product: GroceryStore.Product
        }
    }
}

• GroceryStoreService구조체는 JSON의 구조(aisles와 shelves 포함)와 일치하기 때문에, Decodable프로토콜의 준수는 자동으로 이루어짐
• GroceryStore구조체의 중첩된 Product구조체는 데이터가 동일한 이름과 타입을 사용하기 때문에 Shelf구조체에서 재사용됨
• GroceryStoreService구조체의 역할을 완료하기 위해 GroceryStore구조체에 확장(extension)을 사용
• 이 확장은 GroceryStoreService인스턴스를 취하는 이니셜라이저를 추가하고, aisle과 shelf을 순회하면서 불필요한 중첩을 제거함

extension GroceryStore {
    init(from service: GroceryStoreService) {
        name = service.name
        products = []
        
        for aisle in service.aisles {
            for shelf in aisle.shelves {
                products.append(shelf.product)
            }
        }
    }
}

• 타입간의 관계를 활용하면 안전하고 간결하게 JSON을 읽어들임
• GroceryStoreService중간 타입을 거쳐 최종적으로 GroceryStore인스턴스를 사용할 수 있음

let decoder = JSONDecoder()
let serviceStores = try decoder.decode([GroceryStoreService].self, from: json)

let stores = serviceStores.map { GroceryStore(from: $0) }

for store in stores {
    print("\(store.name) is selling:")
    for product in store.products {
        print("\t\(product.name) (\(product.points) points)")
        if let description = product.description {
            print("\t\t\(description)")
        }
    }
}

📌 Merge Data at Different Depths

• Encodable 및 Decodable의 프로토콜 요구사항에 대한 사용자 정의 구현을 작성하여 JSON 구조의 다른 깊이에서 데이터를 결합하거나 분리할 수 있음
• JSON 파일이나 API에서 사용하는 데이터 모델이 앱에서 사용하는 모델과 일치하지 않을 때가 있음
• 이런 경우 인코딩 및 디코딩 시 JSON에서 객체를 병합하거나 분리해야 할 수 있음
• 결과적으로 단일 인스턴스의 인코딩 또는 디코딩은 JSON 객체의 계층 구조에서 위로 또는 아래로 도달하는 것을 포함함
• 아래의 예제에서는 이러한 데이터 병합 스타일의 일반적인 예시를 보여주고, 각각의 제품에 대한 이름, 가격 및 기타 세부 정보를 추적하는 식료품 점을 모델링함

import Foundation

let json = """
{
    "Banana": {
        "points": 200,
        "description": "A banana grown in Ecuador."
    },
    "Orange": {
        "points": 100
    }
}
""".data(using: .utf8)!

• JSON에서 제품의 이름이 제품의 나머지 세부 정보를 정의하는 key의 이름과 동일함
• 이 경우 Banana제품의 정보가 제품 이름 자체에 중첩된 객체에 저장되어 있음
• 그러나 제품의 이름이 객체의 식별 키에서 나온다는 것은 관례에 의해만 명확함
• 다른 JSON 구조의 형태에서는 각 제품에 대해 product키와 개별 제품 이름을 저장하는 name키가 있는 경우도 있을 수 있음
• 이 대체 형태는 Swift에서 데이터를 모델링하는 방식과 일치하며, 아래의 예제에서 확인할 수 있음

struct GroceryStore {
    struct Product {
        let name: String
        let points: Int
        let description: String?
    }

    var products: [Product]

    init(products: [Product] = []) {
        self.products = products
    }
}

• 다음예제에서 확장은 GroceryStore구조체를 Encodable프로토콜에 준수하도록 함
• 이를 통해 구조체는 Codable프로토콜을 준수 할 수 있음
• 이 확장은 CodingKey프로토콜에 준수하는 일반적인 열거형 대신에 중첩 구조체인 ProductKey를 사용
• 제품 구조체의 인스턴스(이름 사용)를 사용할 때 일부 고유한 인코딩 키를 처리하기 위해 구조체가 필요

extension GroceryStore: Encodable {
    struct ProductKey: CodingKey {
        var stringValue: String
        init?(stringValue: String) {
            self.stringValue = stringValue
        }

        var intValue: Int? { return nil }
        init?(intValue: Int) { return nil }

        static let points = ProductKey(stringValue: "points")!
        static let description = ProductKey(stringValue: "description")!
    }
    
    func encode(to encoder: Encoder) throws {
        var container = encoder.container(keyedBy: ProductKey.self)
        
        for product in products {
            // Any product's `name` can be used as a key name.
            let nameKey = ProductKey(stringValue: product.name)!
            var productContainer = container.nestedContainer(keyedBy: ProductKey.self, forKey: nameKey)
            
            // The rest of the keys use static names defined in `ProductKey`.
            try productContainer.encode(product.points, forKey: .points)
            try productContainer.encode(product.description, forKey: .description)
        }
    }
}

• Encodable프로토콜을 준수하므로, 아래 예제에서는 JSONEncoder인스턴스를 사용하여 어떤 GroceryStore인스턴스든 JSON으로 인코딩할 수 있음

var encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted

let store = GroceryStore(products: [
    .init(name: "Grapes", points: 230, description: "A mixture of red and green grapes."),
    .init(name: "Lemons", points: 2300, description: "An extra sour lemon.")
])

print("The result of encoding a GroceryStore:")
let encodedStore = try encoder.encode(store)
print(String(data: encodedStore, encoding: .utf8)!)
print()

• Codable프로토콜 준수의 두 번째 부분은 디코딩임
• 아래의 확장은 GroceryStore구조체가 Decodable을 준수함
• JSON 객체를 디코딩하는 일환으로, 이니셜라이저는 객체의 첫 번째 단계의 모든 키를 순회함

extension GroceryStore: Decodable {
    public init(from decoder: Decoder) throws {
        var products = [Product]()
        let container = try decoder.container(keyedBy: ProductKey.self)
        for key in container.allKeys {
            // Note how the `key` in the loop above is used immediately to access a nested container.
            let productContainer = try container.nestedContainer(keyedBy: ProductKey.self, forKey: key)
            let points = try productContainer.decode(Int.self, forKey: .points)
            let description = try productContainer.decodeIfPresent(String.self, forKey: .description)

            // The key is used again here and completes the collapse of the nesting that existed in the JSON representation.
            let product = Product(name: key.stringValue, points: points, description: description)
            products.append(product)
        }

        self.init(products: products)
    }
}

let decoder = JSONDecoder()
let decodedStore = try decoder.decode(GroceryStore.self, from: json)

print("The store is selling the following products:")
for product in decodedStore.products {
    print("\t\(product.name) (\(product.points) points)")
    if let description = product.description {
        print("\t\t\(description)")
    }
}

container

• 일반적으로 디코딩 작업을 수행할 때, 디코딩된 데이터는 컨테이너 형태로 구성됨
• JSON 데이터를 디코딩할 때, JSON 객체는 딕셔너리 형태로 디코딩되고, JSON 배열은 배열 형태로 디코딩됨
• 아래의 메서드를 통해 디코더가 인코딩된 데이터를 해독하고 해당 데이터 컨테이너에 접근할 수 있음
• 아래의 메서드를 통해 컨테이너에 접근하여 디코딩된 데이터를 추출하거나 처리할 수 있는 기능을 제공

container(keyedBy:)

• 딕셔너리 형태의 컨테이너에 접근할 수 있도록 해줌

container(unkeyed:)

• 배열 형태의 컨테이너에 접근할 수 있도록 해줌

---

출처📚

🍎Apple Docs: Using JSON with Custom Types