iOS Swift4.0 Codable協議：JSON和模型的轉換

阿新 • • 發佈：2018-12-10

簡單說明

在OC中，以及Swift4.0之前，系統一直沒有一套資料解析的方法。在Swift4.0後，終於推出了Codable協議，可實現json資料和資料模型的相互轉換。

首先來下 Codable ，它其實是一個組合協議，有 Decodable 和 Encodable 兩個協議組成。

/// A type that can convert itself into and out of an external representation.
public typealias Codable = Decodable & Encodable

/// A type that can encode itself to an external representation. 

public protocol Encodable {
    public func encode(to encoder: Encoder) throws
}

/// A type that can decode itself from an external representation.
public protocol Decodable {
    public init(from decoder: Decoder) throws
}

Decodable和Encodable分別是用來實現資料模型的解檔和歸檔。

資料模型只要遵循了Codable協議，就可以方便的進行 JSON 資料和資料模型的相互轉換。

使用介紹

JSON 轉模型

核心程式碼：

JSONDecoder().decode(type: '某型別', from: 'Data資料')

例如我們有一個個人資訊的 JSON 資料，我們想要將其轉換為 Person 資料模型。

let jsonString =
"""
{
    "name":"LOLITA0164",
    "age":26,
    "address":"fuzhou"
}
"""

資料模型：

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var 
 age: Int?
    var address: String?
}

轉換過程：

// 將 json 字串轉為 data 型別
if let jsonData = jsonString.data(using: String.Encoding.utf8) {
    if let person = try? JSONDecoder().decode(Person.self, from: jsonData){
        // 轉換成功，我們將資料輸出
        print(person.name!,person.age!,person.address!)
    }
}

輸出結果：

LOLITA0164 26 fuzhou

原理：

一旦資料模型遵循了 Codable 協議，編譯器自動會生成相關編碼和解碼的實現。該協議中還有一個叫 CodingKey 的協議，用來表示編碼和解碼的key。

protocol CodingKey {
    var stringValue: String { get }
    init?(stringValue: String)
    var intValue: Int? { get }
    public init?(intValue: Int)
}

Encoder 和 Decoder 是編碼器和解碼器，類似 OC 中的NSCoder。他們完成了資料的編碼和解碼工作。

當我們的模型遵循 Codable 時，編譯器實際上幫我們完成了下面的工作：

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var age: Int?
    var address: String?
    // 編碼和解碼的所對應的 key，編譯器會自動生成成員變數的列舉形式
    private enum CodingKeys: String, CodingKey {
        case name = "name"
        case age = "age"
        case address = "address"
    }
    // 解碼：JSON -> Model 必須實現這個方法
    required init(from decoder: Decoder) throws {
        // 解碼器提供了一個容器，用來儲存這些變數
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        age = try container.decode(Int.self, forKey: .age)
        address = try container.decode(String.self, forKey: .address)
    }
    // 編碼：Model -> JSON 必須實現這個方法
    func encode(to encoder: Encoder) throws {
        // 編碼器同樣提供了一個容器，用來提供對應變數的值
        var container = encoder.container(keyedBy: CodingKeys.self)
        try container.encode(name, forKey: .name)
        try container.encode(age, forKey: .age)
        try container.encode(address, forKey: .address)
    }
}

上述是編譯器自動幫我們完成遵循 Codable 協議的資料模型的編碼和解碼過程，這些細節部分一般不需要我們關注。但是，在有些情況下，則需要我們自行實現相應的方法。

資料來源和模型的成員變數不一致

在實際開發過程中，經常遇到資料來源和模型的成員變數不一致的情況，這種情況的出現通常是服務端和客戶端未達成統一，各自有不同的想法，又或者是開發的順序不一致，客戶端先於服務端完成導致欄位不統一。無論那種情況，誰去做改動都是不合理的，那麼當客戶端想做相容時，就需要從 CodingKey 協議入手了。

例如服務端給了我們下面一串資料：

sonString =
"""
{
    "NAME":"LOLITA0164",
    "AGE":26,
    "ADDRESS":"fuzhou"
}
"""

我們的資料模型依舊不變，這時我們調整一下 CodingKey ：

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var age: Int?
    var address: String?

    /*
    注：
    1、一旦寫了CodingKey，需要將所有的成員都列出來（除非你只想解析其中部分欄位），並且不能重複。
    2、CodingKeys是固定的列舉的名稱，不能自定義。
     */
    private enum CodingKeys: String, CodingKey {
        case name = "NAME"
        case age = "AGE"
        case address = "ADDRESS"
    }
}

這樣，我們就可以正常解析 JSON 資料了。

派生類

首先看個例子：

class Dog: Codable {
    var name: String?
}

class GoldenRetriever: Dog {
    var age: Float?
}

派生類的資料解析：

let jsonString =
"""
{
    "name":"kitty",
    "age":2.5,
}
"""
if let jsonData = jsonString.data(using: String.Encoding.utf8) {
    if let dog = try? JSONDecoder().decode(GoldenRetriever.self, from: jsonData){
        dump(dog)
    }
}

結果：

▿ JSONToModelSwift.GoldenRetriever #0
  ▿ super: JSONToModelSwift.Dog
    ▿ name: Optional("kitty")
      - some: "kitty"
  - age: nil

我們發現，GoldenRetriever 類的例項只解析出了父類中的 name 欄位，而本類中的 age 未能解析。這說明，Codable 在繼承中是無效的，當你在派生類中宣告遵循該協議時，則會報錯：

Redundant conformance of 'GoldenRetriever' to protocol 'Decodable'
Redundant conformance of 'GoldenRetriever' to protocol 'Encodable'

這時候，就需要我們自行實現 Codable 協議了。

class Dog: Codable {
    var name: String?
}

class GoldenRetriever: Dog {
    var age: Float?

    private enum CodingKeys: String, CodingKey {
        case name
        case age
    }
    // 這裡只實現瞭解碼，需要編碼時，請自行參考之前的例子
    required init(from decoder: Decoder) throws {
        super.init()
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        age = try container.decode(Float.self, forKey: .age)
    }
}

結果：

▿ JSONToModelSwift.GoldenRetriever #0
  ▿ super: JSONToModelSwift.Dog
    ▿ name: Optional("kitty")
      - some: "kitty"
  ▿ age: Optional(2.5)
    - some: 2.5

模型轉 JSON

核心程式碼：

JSONEncoder().encode('遵循 Encodable 的物件')

當我們某個遵循 Codable 協議的物件想要轉為 JOSN 資料時，我們則可以藉助 JSONEncoder 編碼器來實現。

let p = Person()
p.name = "LOLITA0164"
p.age = 26
p.address = "fuzhou"
if let jsonData = try? JSONEncoder().encode(p) {
    // 編碼成功，將 jsonData 轉為字元輸出檢視
    if let jsonString = String.init(data: jsonData, encoding: String.Encoding.utf8) {
        print("jsonString:" + "\(jsonString)")
    }
}

輸出結果：

jsonString:{"name":"LOLITA0164","age":26,"address":"fuzhou"}

JSON 轉複雜資料模型

實際上，除了簡單的資料模型，Codable 協議是能夠完成巢狀資料模型的轉換的。需要注意的是，巢狀的資料模型以及巢狀的子模型都必須遵循 Codable 協議。下面舉個例子來說明。

假如我們有一個關於部門的資料模型，部門中有成員若干，可擁有管理者一名，其中的每一個人可能有養一隻寵物狗。資料模型組成如下：

/// Department模型，也遵循 Codable 協議
class Department: Codable {
    var name: String
    var id: Int
    var members: [Person] = []
    var manager: Person?
}

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var age: Int?
    var address: String?
    var aDog:Dog?
    private enum CodingKeys: String, CodingKey {
        case name = "NAME"
        case age = "AGE"
        case address = "ADDRESS"
        case aDog = "dog"
    }
}

/// Dog模型
class Dog: Codable {
    var name: String?
}

解析複雜資料模型

let jsonString =
    """
    {
        "name":"技術部",
        "id":123,
        "members":[
            {
                "NAME":"xiaoming",
                "AGE":24,
                "ADDRESS":"nanjing",
                "dog":{
                    "name":"Tom"
                }
            },
            {
                "NAME":"LOLITA0164",
                "AGE":26,
                "ADDRESS":"nanjing",
                "dog":{
                    "name":"Tonny"
                }
            },
        ],
        "manager":{
            "NAME":"ZHANG",
            "AGE":33,
            "ADDRESS":"nanjing",
        }
    }
    """
if let jsonData = jsonString.data(using: String.Encoding.utf8) {
    if let group = try? JSONDecoder().decode(Department.self, from: jsonData) {
        dump(group)
    }
}

結果：

▿ JSONToModelSwift.Department #0
  ▿ name: Optional("技術部")
    - some: "技術部"
  ▿ id: Optional(123)
    - some: 123
  ▿ members: 2 elements
    ▿ JSONToModelSwift.Person #1
      ▿ name: Optional("xiaoming")
        - some: "xiaoming"
      ▿ age: Optional(24)
        - some: 24
      ▿ address: Optional("nanjing")
        - some: "nanjing"
      ▿ aDog: Optional(JSONToModelSwift.Dog)
        ▿ some: JSONToModelSwift.Dog #2
          ▿ name: Optional("Tom")
            - some: "Tom"
    ▿ JSONToModelSwift.Person #3
      ▿ name: Optional("LOLITA0164")
        - some: "LOLITA0164"
      ▿ age: Optional(26)
        - some: 26
      ▿ address: Optional("nanjing")
        - some: "nanjing"
      ▿ aDog: Optional(JSONToModelSwift.Dog)
        ▿ some: JSONToModelSwift.Dog #4
          ▿ name: Optional("Tonny")
            - some: "Tonny"
  ▿ manager: Optional(JSONToModelSwift.Person)
    ▿ some: JSONToModelSwift.Person #5
      ▿ name: Optional("ZHANG")
        - some: "ZHANG"
      ▿ age: Optional(33)
        - some: 33
      ▿ address: Optional("nanjing")
        - some: "nanjing"
      - aDog: nil

我們可以看到，從使用上，無論解析簡單的資料模型還是複雜的巢狀模型，在 JSON 轉 Model 的使用方面都是一樣的，實際上，Model 轉 JSON 也是一致的，大家可以嘗試一下。

問題和改進

雖然自定義 CodingKey 可以完成資料來源和資料模型不一致的問題（這和 OC 下的一些資料模型轉換採用的方式非常相似），但是在實際情況下，我們經常遇到：資料模型相同，資料來源卻可能不一致，這導致一套 CodingKey 無法完成多種不同的編碼和解碼。那麼一定要提前完成對映嗎？能否在拿到資料之後，進行一次加工，將資料來源處理成完全符合我們資料模型的標準再進行資料轉換呢？答案是肯定的。在 OC 的資料模型轉換中，筆者通過 runtime 和 KVC 方式給資料模型賦值，以達到資料轉模型的目的，其中，對映字典是其中關鍵的一環，目的就是通過對映字典將資料處理成標準的可直接 KVC 賦值的資料，以此將資料轉模型變得更靈活。

我們先看下使用過程：

字典轉簡單資料模型

首先依舊是 Person 類和其資料來源

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var age: Int?
    var address: String?
}
// 資料字典
let dic_p:[String:Any] = [
    "Name":"LOLITA0164",
    "Age":26,
    "address":"fuzhou",
]

使用：

// 對映字典
// '模型欄位':'資料來源欄位'
let dic_hint = [
    "name":"Name",
    "age":"Age"
]
// 轉換
if let p = try? LLModelTool.decode(Person.self, resDic: dic_p, hintDic: dic_hint) {
    dump(p)
}

結果：

▿ JSONToModelSwift.Person #0
  ▿ name: Optional("LOLITA0164")
    - some: "LOLITA0164"
  ▿ age: Optional(26)
    - some: 26
  ▿ address: Optional("fuzhou")
    - some: "fuzhou"

字典轉巢狀資料模型

依舊是上面的例子：假如我們有一個關於部門的資料模型，部門中有成員若干，可擁有管理者一名，其中的每一個人可能有養一隻寵物狗。

/// Department模型，也遵循 Codable 協議
class Department: Codable {
    var name: String?
    var id: Int?
    var members: [Person] = []
    var manager: Person?
}

/// Persion模型，遵循 Codable 協議
class Person: Codable {
    var name: String?
    var age: Int?
    var address: String?
    var aDog:Dog?
}

/// Dog模型
class Dog: Codable {
    var name: String?
}


// 資料來源
let dic_group: [String:Any] = [
    "NAME":"技術部",
    "ID":123,
    "MEMBERS":[
        [
            "Name":"小熊",
            "Age":25,
            "Address":"南京",
            "Dog":[
                "NameString":"kitty"
            ],
        ],
        [
            "Name":"LOLITA0164",
            "Age":26,
            "Address":"fuzhou"
        ]
    ],
    "Manager":[
        "name":"管理者",
        "age":33
    ]
]

使用：

// 對映字典
// '模型欄位':'資料來源欄位'
let dic_hint2: [String:Any] = [
    // Department資料模型的對映關係
    "name":"NAME",
    "id":"ID",
    "members":"MEMBERS",
    // 巢狀模型的對映關係（key 對應資料來源中的 key）
    "MEMBERS":[
        // Person資料模型的對映關係
        "name":"Name",
        "age":"Age",
        "address":"Address",
        "aDog":"Dog",
        // 巢狀模型的對映關係（key 對應資料來源中的 key）
        "Dog":[
            // Dog資料模型的對映關係
            "name":"NameString"
        ]
    ],
    "manager":"Manager"
]

if let group = try? LLModelTool.decode(Department.self, resDic: dic_group, hintDic: dic_hint2) {
    dump(group)
}

結果：

▿ JSONToModelSwift.Department #0
  ▿ name: Optional("技術部")
    - some: "技術部"
  ▿ id: Optional(123)
    - some: 123
  ▿ members: 2 elements
    ▿ JSONToModelSwift.Person #1
      ▿ name: Optional("小熊")
        - some: "小熊"
      ▿ age: Optional(25)
        - some: 25
      ▿ address: Optional("南京")
        - some: "南京"
      ▿ aDog: Optional(JSONToModelSwift.Dog)
        ▿ some: JSONToModelSwift.Dog #2
          ▿ name: Optional("kitty")
            - some: "kitty"
    ▿ JSONToModelSwift.Person #3
      ▿ name: Optional("LOLITA0164")
        - some: "LOLITA0164"
      ▿ age: Optional(26)
        - some: 26
      ▿ address: Optional("fuzhou")
        - some: "fuzhou"
      - aDog: nil
  ▿ manager: Optional(JSONToModelSwift.Person)
    ▿ some: JSONToModelSwift.Person #4
      ▿ name: Optional("管理者")
        - some: "管理者"
      ▿ age: Optional(33)
        - some: 33
      - address: nil
      - aDog: nil

實現過程：

首先，我們將 JSONDecoder().decode()進行再次封裝：

/// 字典 轉 模型
static func decode<T>(_ type: T.Type, resDic: [String:Any] , hintDic:[String:Any]?) throws -> T where T: Decodable {
    var transformDic = resDic
    if (hintDic != nil) {
        // 將對映字典轉換成模型所需的字典
        transformDic = self.setUpResourceDic(resDic: resDic, hintDic: hintDic!)
    }
    guard let jsonData = self.getJsonData(param: transformDic) else {
        throw LLModelToolError.message("轉成 Data 時出錯!!!")
    }
    guard let model = try? JSONDecoder().decode(type, from: jsonData)
        else {
        throw LLModelToolError.message("轉成 資料模型 時出錯!!!")
    }
    return model
}

我們可以看到，該方法的核心依舊是系統的轉換方法，我們要做的就是將對映字典轉換成模型所需的字典，然後的處理一切照舊。

核心的轉換方法如下：

/// 根據對映字典設定當前字典內容
private static func setUpResourceDic(resDic: [String:Any] , hintDic:[String:Any]) -> [String:Any]{
    var transformDic = resDic
    for (key,value) in hintDic {
        let valueNew: AnyObject = value as AnyObject
        if valueNew.classForCoder == NSDictionary.classForCoder(){      // 模型對映
            let res_value = resDic[key] as AnyObject    // 為了獲取資料型別
            if res_value.classForCoder == NSArray.classForCoder(){  // 資料型別為陣列（模型陣列）
                let res_value_array = res_value as! [[String:Any]]
                var resArray: [Any] = []
                for item in res_value_array {
                    // 遞迴呼叫，尋找子模型
                    let res = self.setUpResourceDic(resDic: item , hintDic: valueNew as! [String : Any])
                    resArray.append(res)
                }
                let realKey = self.getRealKey(key: key, dic: hintDic)
                transformDic[realKey] = resArray
                // 移除舊的資料
                if realKey != key {
                    transformDic.removeValue(forKey: key)
                }
            }
            else if res_value.classForCoder == NSDictionary.classForCoder(){    // 資料型別為字典（模型）
                // 遞迴呼叫，尋找子模型
                let res = self.setUpResourceDic(resDic: res_value as! [String : Any] , hintDic: valueNew as! [String : Any])
                let realKey = self.getRealKey(key: key, dic: hintDic)
                transformDic[realKey] = res
                // 移除舊的資料
                if realKey != key {
                    transformDic.removeValue(forKey: key)
                }
            }
        }else if valueNew.classForCoder == NSString.classForCoder(){    // 普通對映
            // 去掉
            if !hintDic.keys.contains(valueNew as! String){
                transformDic[key] = resDic[valueNew as! String]
            }
            // 移除舊的資料
            if key != valueNew as! String {
                transformDic.removeValue(forKey: valueNew as! String)
            }
        }
    }
    return transformDic
}

轉換的思路為：

1、中心思想無非就是進行 key 的替換

2、遍歷對映字典，如果對映字典中是 "String":"String" 我們直接進行替換（先新增資料，再將就資料刪除），如果是 "String":"Dictionary" ，則表示該欄位中的 Dictionary 是一個數據模型，此時我們需要取出該字典，採用遞迴的方式深層次的尋找和替換。

缺點建議

複雜的資料模型在使用起來不是非常的順手，因為我們需要為其集中編寫複雜的對應關係，因此不如將資料拆成簡單的資料模型，再賦值給複雜模型，這樣對映字典變得簡單很多，也更易閱讀。

完整的程式碼為：

import Foundation

enum LLModelToolError: Error {
    case message(String)
}

struct LLModelTool {

    /// 字典 轉 模型
    static func decode<T>(_ type: T.Type, resDic: [String:Any] , hintDic:[String:Any]?) throws -> T where T: Decodable {
        // 將對映字典轉換成模型所需的字典
        var transformDic = resDic
        if (hintDic != nil) {
            transformDic = self.setUpResourceDic(resDic: resDic, hintDic: hintDic!)
        }
        guard let jsonData = self.getJsonData(param: transformDic) else {
            throw LLModelToolError.message("轉成 Data 時出錯!!!")
        }
        guard let model = try? JSONDecoder().decode(type, from: jsonData)
            else {
            throw LLModelToolError.message("轉成 資料模型 時出錯!!!")
        }
        return model
    }


    /// json 轉模型
    static func decode<T>(_ type: T.Type, jsonData: Data , hintDic:[String:Any]?) throws -> T where T: Decodable {
        guard let resDic: [String:Any] = try? JSONSerialization.jsonObject(with: jsonData, options: JSONSerialization.ReadingOptions.mutableContainers) as! [String : Any] else {
            throw LLModelToolError.message("轉成 字典 時出錯!!!")
        }
        return try! self.decode(type, resDic: resDic, hintDic: hintDic)
    }

    // 模型轉字典
    static func reflectToDict<T>(model: T) -> [String:Any] {
        let mirro = Mirror(reflecting: model)
        var dict = [String:Any]()
        for case let (key?, value) in mirro.children {
            dict[key] = value
        }
        return dict
    }



    /// 獲取 json 資料，data型別
    static func getJsonData(param: Any) -> Data? {
        if !JSONSerialization.isValidJSONObject(param) {
            return nil
        }
        guard let data = try? JSONSerialization.data(withJSONObject: param, options: []) else {
            return nil
        }
        return data
    }


    /// 根據對映字典設定當前字典內容
    private static func setUpResourceDic(resDic: [String:Any] , hintDic:[String:Any]) -> [String:Any]{
        var transformDic = resDic
        for (key,value) in hintDic {
            let valueNew: AnyObject = value as AnyObject
            if valueNew.classForCoder == NSDictionary.classForCoder(){      // 模型對映
                let res_value = resDic[key] as AnyObject    // 為了獲取資料型別
                if res_value.classForCoder == NSArray.classForCoder(){  // 資料型別為陣列（模型陣列）
                    let res_value_array = res_value as! [[String:Any]]
                    var resArray: [Any] = []
                    for item in res_value_array {
                        // 遞迴呼叫，尋找子模型
                        let res = self.setUpResourceDic(resDic: item , hintDic: valueNew as! [String : Any])
                        resArray.append(res)
                    }
                    let realKey = self.getRealKey(key: key, dic: hintDic)
                    transformDic[realKey] = resArray
                    // 移除舊的資料
                    if realKey != key {
                        transformDic.removeValue(forKey: key)
                    }
                }
                else if res_value.classForCoder == NSDictionary.classForCoder(){    // 資料型別為字典（模型）
                    // 遞迴呼叫，尋找子模型
                    let res = self.setUpResourceDic(resDic: res_value as! [String : Any] , hintDic: valueNew as! [String : Any])
                    let realKey = self.getRealKey(key: key, dic: hintDic)
                    transformDic[realKey] = res
                    // 移除舊的資料
                    if realKey != key {
                        transformDic.removeValue(forKey: key)
                    }
                }
            }else if valueNew.classForCoder == NSString.classForCoder(){    // 普通對映
                // 去掉
                if !hintDic.keys.contains(valueNew as! String){
                    transformDic[key] = resDic[valueNew as! String]
                }
                // 移除舊的資料
                if key != valueNew as! String {
                    transformDic.removeValue(forKey: valueNew as! String)
                }
            }
        }
        return transformDic
    }


    /// 從對映字典中獲取到模型中對應的key
    private static func getRealKey(key:String, dic:[String:Any]) -> String {
        for (k,v) in dic {
            let value: AnyObject = v as AnyObject
            if value.classForCoder == NSString.classForCoder(){
                let valueNew = value as! String
                if valueNew == key{
                    return k
                }
            }
        }
        return key
    }

}

參考

三方轉換庫

這些庫我都沒有使用過，僅僅是從其他人那邊摘抄過來做備份，讀者有興趣可以試一試。

iOS Swift4.0 Codable協議：JSON和模型的轉換

簡單說明

使用介紹

問題和改進

參考

三方轉換庫

iOS Swift4.0 Codable協議：JSON和模型的轉換

vue2.0中的：is和is的區別

python網路爬蟲（web spider）系統化整理總結（二）：爬蟲python程式碼示例(兩種響應格式：json和html)

iOS App提交指南-協議、稅務和銀行業務

ios菜鳥之路：uiscrollview和pagecontrol的使用方法

Swift 4.0學習之：陣列和字典

不惑之年的硬體牛人轉到軟體自學之netty框架（六）Netty的網路協議：WebSocket和UDP

轉：json和list、bean之間轉換總結

兩種乙太網 RDMA 協議： iWARP 和 RoCE

2：Bitmap和Base64轉換

fastJson API 最快的Json和物件轉換工具

FastJson--阿里巴巴公司開源的速度最快的Json和物件轉換工具

iOS 5.0 後UIViewController新增：willMoveToParentViewController和didMoveToParentViewCon

vsphere6.0故障：關於linux版本的vcenter6.0磁盤爆滿問題和503錯誤問題[下]

Flask：cookie 和 session （0.1）

C#本質論6.0第四章：方法和參數

case5：繼承和派生的作用舉例_2.0版本（使用繼承）

case5：繼承和派生的作用舉例_1.0版本（不使用繼承）

IOS UIAlertController 彈框 (ios 9.0 後代替了UIAlertView彈框和 UIActionSheet下彈框)

Google 的 QUIC 華麗轉身成為下一代網路協議： HTTP/3.0

iOS Swift4.0 Codable協議：JSON和模型的轉換

簡單說明

使用介紹

問題和改進

參考

三方轉換庫

相關推薦