一、swift下使用OC框架

在OC下面字典和模型的轉(zhuǎn)換有些非常好用的第三方框架，如（YYMode， MJExtension等），當(dāng)然Swift也可以借鑒這兩個框架，只是需要創(chuàng)建模型的時候繼承自NSObject，并且加上關(guān)鍵字@objcMembers既可。

@objcMembers class CDBaseModel: NSObject, YYModel {
    //swift 借鑒YYModel
    var name:String = ""
    var age:Int = 0
    var uid:String = ""
    
    static func modelCustomPropertyMapper() -> [String : Any]? {
        return [
            "uid":"id",
        ]
    }
}

swift使用原生Codable 協(xié)議

1、在用原生Codable協(xié)議的時候，需要當(dāng)前類繼承協(xié)議Codable，只是swift的枚舉、結(jié)構(gòu)體和類都可以繼承該協(xié)議。這點(diǎn)事OC無法做到的。

enum Gender:String, Decodable {
    case male
    case female
    case other
}

struct BookModel:Codable {
    
    var name:String = ""
    var price:Float = 0
    
}

class PersonModel: NSObject, Codable {
    
    var name:String = ""
    
}

2、在使用Codable協(xié)議的時候，一定要確保模型和原始json數(shù)據(jù)之間的key值的一致性。
列入有一段json字典如下（這里我用的字典）

private var dictionary:[String:Any] = [:]

        self.dictionary["name"] = "天王"
        self.dictionary["age"] = 9
        self.dictionary["sex"] = true

那么你的模型就需要如下實(shí)現(xiàn)(當(dāng)然這是理想狀態(tài))

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
}

3、如果你的模型里面有一個字段如（name_op）并且原始json數(shù)據(jù)里面沒有該值，此時你的模型如果如下。

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var name_op:    String = ""
}

那么你解析成模型的時候會失敗，此時需要把不確定的值定義為可選類型。那么不管原始json數(shù)據(jù)有沒有這個字段，都可以解析成功，如果沒有，那么該屬性為nil。

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var name_op:    String?
}

4、如果你的模型已經(jīng)設(shè)計好了，但是原始json數(shù)據(jù)里面有個字段和你的字段事沖突的（如你的屬性叫 nick 而原始數(shù)據(jù)為 nick_name ），那么該值是解析不成功的，如果是可選還好，至少能成功，否則就失敗。
解決的辦法是實(shí)現(xiàn) enum CodingKeys: String, CodingKey {}這個映射關(guān)系

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var name_op:    String?
    var nick: String?
      enum CodingKeys: String, CodingKey {
        case name
        case age
        case sex
        case name_op 
        case nick = "nick_name" 
    }
}

5、如果你的模型里面帶有嵌套關(guān)系，比如你的模型里面有個其他模型或者模型數(shù)組，那么只要保證嵌套的模型里面依然實(shí)現(xiàn)了對應(yīng)的協(xié)議，和當(dāng)前模型一樣即可。

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var name_op:    String?
    var nick: String?
    //嵌套關(guān)系（保證嵌套模型里面同樣實(shí)現(xiàn)了Codable協(xié)議即可）
    var animo_op:   AnimalModel?
    var books_op:   [BookModel]?

      enum CodingKeys: String, CodingKey {
        case name
        case age
        case sex
        case name_op 
        case nick = "nick_name" 
    }
}

6、如果模型里面和原始數(shù)據(jù)里面的類型不統(tǒng)一，那么這個解析也會以失敗告終。而這種情況需要自定義一個類去適配當(dāng)前屬性。最常見的有（Bool和Int，Int和String）這些在后臺若類型語言上是不加區(qū)分的。所以不確定到底是什么類型，如果隨意定義一個那么會失敗。
如下：定義了一個可能是Bool或者Int的類型

struct TIntBool:Codable { 
    var int:Int {
        didSet {
            if int == 0 { self.bool = false
            } else { self.bool = true }
        }
    } 
    var bool:Bool {
        didSet {
            if bool { self.int = 1
            } else { self.int = 0 }
        }
    } 
    //自定義解碼(通過覆蓋默認(rèn)方法實(shí)現(xiàn))
    init(from decoder: Decoder) throws {
        let singleValueContainer = try decoder.singleValueContainer()
        if let intValue = try? singleValueContainer.decode(Int.self) {
            self.int = intValue
            self.bool = (intValue != 0)
        } else if let boolValue = try? singleValueContainer.decode(Bool.self) {
            self.bool = boolValue
            if boolValue { self.int = 1
            } else { self.int = 0 }
        } else {
            self.bool = false
            self.int = 0
        }
    } 
}

下面是一個Int 或者String類型的

struct TStrInt: Codable {
    var int:Int {
        didSet {
            let stringValue = String(int)
            if  stringValue != string {
                string = stringValue
            }
        }
    } 
    var string:String {
        didSet {
            if let intValue = Int(string), intValue != int {
                int = intValue
            }
        }
    } 
    //自定義解碼(通過覆蓋默認(rèn)方法實(shí)現(xiàn))
    init(from decoder: Decoder) throws {
        let singleValueContainer = try decoder.singleValueContainer() 
        if let stringValue = try? singleValueContainer.decode(String.self)
        {
            string = stringValue
            int = Int(stringValue) ?? 0
            
        } else if let intValue = try? singleValueContainer.decode(Int.self)
        {
            int = intValue
            string = String(intValue);
        } else
        {
            int = 0
            string = ""
        }
    }
}

在設(shè)計模型的時候，如下賦值

struct UserModel:Codable {
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var name_op:    String?
    var nick: String?
    //嵌套關(guān)系（保證嵌套模型里面同樣實(shí)現(xiàn)了Codable協(xié)議即可）
    var animo_op:   AnimalModel?
    var books_op:   [BookModel]?
  
    //數(shù)據(jù)類型不一樣（如果原始數(shù)據(jù)為Int，模型里面卻是String，這個需要單獨(dú)定義一種數(shù)據(jù)類型這種數(shù)據(jù)類型可能是整型、浮點(diǎn)型、布爾型或者字符串）
    var stringInt:  TStrInt?
    var boolInt:    TIntBool?

      enum CodingKeys: String, CodingKey {
        case name
        case age
        case sex
        case name_op 
        case nick = "nick_name" 
        case  animo_op
        case  animo_op
        case  stringInt
        case boolInt
    }
}

若是完成上面幾步，基本可以解決字典模型轉(zhuǎn)換的巨大部分問題。貼上我設(shè)計的模型。

struct UserModel:Codable {
    
    //1、必選值（這里的聲明需要和原始數(shù)據(jù)對應(yīng)的類型和字段完全一樣，否則解析失敗）
    var name:   String = ""
    var age:    Int = 0
    var sex:    Bool = false
    var weight: Double = 0
    var height: Float = 0
    var animo:  AnimalModel = AnimalModel.init()
    var books:  [BookModel] = []
    
    //2、可選值（這里的類型一定要和原始數(shù)據(jù)一樣，原始數(shù)據(jù)可以不存在，那么解析為空即可）
    var name_op:    String?
    var age_op:     Int?
    var sex_op:     Bool?
    var weight_op:  Double?
    var height_op:  Float?
    var animo_op:   AnimalModel?
    var books_op:   [BookModel]?
    
    //3、key不一樣的情況（如果原始數(shù)據(jù)和模型的key不一樣，那么需要實(shí)現(xiàn)一個協(xié)議‘CodingKeys’自定義映射關(guān)系）
    var nick:       String = ""     //對應(yīng)原始數(shù)據(jù)的nick_name
    var nick_op:    String?         //對應(yīng)原始數(shù)據(jù)的nick_optional
    
    //4、數(shù)據(jù)類型不一樣（如果原始數(shù)據(jù)為Int，模型里面卻是String，這個需要單獨(dú)定義一種數(shù)據(jù)類型這種數(shù)據(jù)類型可能是整型、浮點(diǎn)型、布爾型或者字符串）
    var birthday:   TStrInt?
    var stringInt:  TStrInt?
    var birthday_op:TStrDou?
    var stringDou:  TStrDou?
    var boolInt:    TIntBool?
    var intBool:    TIntBool?
    
    
    //自定義key的映射關(guān)系。
    enum CodingKeys: String, CodingKey {
        case name
        case age
        case sex
        case weight
        case height
        case animo
        case books
        
        case name_op
        case age_op
        case sex_op
        case weight_op
        case height_op
        case animo_op
        case books_op
        
        case nick = "nick_name"
        case nick_op = "nick_optional"
         
        case birthday
        case stringInt
        case birthday_op
        case stringDou
        case boolInt
        case intBool
        
    }
     
}

struct AnimalModel:Codable {
    
    var name:String = ""
    
}

struct BookModel:Codable {
    
    var name:String = ""
    var price:Float = 0
    
}

以及創(chuàng)建的字典

    func setupData() {
        self.dictionary["name"] = "天王"
        self.dictionary["age"] = 9
        self.dictionary["sex"] = true
        self.dictionary["weight"] = 177.7
        self.dictionary["height"] = 77.7
        self.dictionary["animo"] = ["name":"小狗"]
        self.dictionary["books"] = [["name":"語文", "price":22],["name":"數(shù)學(xué)", "price":33]]
        
        self.dictionary["name_op"] = "tiangwang"
        self.dictionary["age_op"] = 11
        self.dictionary["sex_op"] = false
        self.dictionary["weight_op"] = 22.2
        self.dictionary["height_op"] = 22.2
        self.dictionary["animo_op"] = ["name":"阿毛"]
        self.dictionary["books_op"] = [["name":"社會", "price":11.5],["name":"自然", "price":11.6]]
        
        self.dictionary["nick_name"] = "這是一個昵稱"
        self.dictionary["nick_optional"] = "這是可選小名"
        
        self.dictionary["birthday"] = 20000102
        self.dictionary["stringInt"] = "123"
        self.dictionary["birthday_op"] = 123456.5
        self.dictionary["stringDou"] = "321"
        self.dictionary["boolInt"] = true
        self.dictionary["intBool"] = 1
    }

三、模型轉(zhuǎn)化用 JSONDecoder，由于 JSONDecoder 需要的是Data類型，所以先要將json轉(zhuǎn)化為Data。

guard let data = try? JSONSerialization.data(withJSONObject: self.dictionary, options: JSONSerialization.WritingOptions.init()) else {
            print("獲取JSON失敗")
            return
        }
        guard let model = try? JSONDecoder.init().decode(UserModel.self, from: data)  else {
            print("model轉(zhuǎn)化失敗,)")
            return
        }
        print("model = \(model)")

四、為了可以通用，設(shè)計一個字典模型轉(zhuǎn)化的工具類

struct CDModel {
    
    //單獨(dú)的字典（json）轉(zhuǎn)模型
    static public func jsonToModel<T>(type:T.Type, json:Any) -> T? where T:Codable {
        
        guard let jsonData = try? JSONSerialization.data(withJSONObject: json, options: []) else {
            return nil
        }
        guard let model = try? JSONDecoder.init().decode(type, from: jsonData) else {
            return nil
        }
        return model
    }
    
    //json數(shù)組轉(zhuǎn)模型數(shù)組
    static public func jsonToModel<T>(type:T.Type, array:[[String:Any]]) -> [T]? where T:Codable {
        
        guard let jsonData = try? JSONSerialization.data(withJSONObject: array, options: []) else {
            return nil
        }
        guard let result = try? JSONDecoder.init().decode([T].self, from: jsonData) else {
            return nil
        }
        return result
    }
    
    //單個模型轉(zhuǎn)json字符串
    public static func modelToJson<T>(toString model:T) -> String? where T:Encodable {

        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        guard let data = try? encoder.encode(model)else{
            return nil
        }
        guard let jsonStr = String(data: data, encoding: .utf8)else{
            return nil
        }
        return jsonStr
    }
    
    //單個模型轉(zhuǎn)json字典
    public static func modelToJson<T>(toDictionary model:T) -> [String:Any]? where T:Encodable{

        let encoder = JSONEncoder()
        encoder.outputFormatting = .prettyPrinted
        guard let data = try? encoder.encode(model) else {
            return nil
        }
        guard let dict = try? JSONSerialization.jsonObject(with: data, options: .mutableLeaves)as? [String:Any] else {
            return nil
        }
        return dict
    }

}

使用

        guard let model = CDModel.jsonToModel(type: UserModel.self, json: self.dictionary) else {
            return
        }
        print("model = \(model)")
        
        let array = CDModel.jsonToModel(type: UserModel.self, array: [self.dictionary])
        print("array = \(array ?? [])")