Swift 4之Codable全面解析

Swift 4中苹果引入了全新的编码与解码支持，开发者可以更加方便地将数据转化为JSON或存入本地磁盘。这个功能的核心是Codable协议，其定义如下：

typealias Codable = Decodable & Encodable

public protocol Decodable {
    public init(from decoder: Decoder) throws
}
public protocol Encodable {
    public func encode(to encoder: Encoder) throws
}

编码及解析

本文主要介绍JSON的编码和解析，使用JSONEncoder用于编码，使用JSONDecoder用于解析。

let data = try! JSONEncoder().encode([1: 3])
let dict = try! JSONDecoder().decode([Int: Int].self, from: data)
print(dict)

需要注意传入的数据必须是JSON格式的，所以model本身也必须是遵循JSON的规范的。比如基本类型本身并不是Object/Array，是不可以编码或解析的。经实测，key可以不严格遵循JSON规定的String类型。了解JSON

基本类型

Swift的Enum，Struct和Class都支持Codable，先看一个简单的示例。

// Enum的原始值一定要是Codable，一般使用的String/Int都是可以的
enum Level: String, Codable {
    case large
    case medium
    case small
}

struct Location: Codable {
    let latitude: Double
    let longitude: Double
}

// CustomDebugStringConvertible只是为了更好打印
class City: Codable, CustomDebugStringConvertible {
    
    let name: String
    let pop: UInt
    let level: Level
    let location: Location
    
    var debugDescription: String {
        return """
        {
        "name": \(name),
        "pop": \(pop),
        "level": \(level.rawValue),
        "location": {
        "latitude": \(location.latitude),
        "longitude": \(location.longitude)
        }
        }
        """
    }
}

let jsonData = """
        {
        "name": "Shanghai",
        "pop": 21000000,
        "level": "large",
        "location": {
          "latitude": 30.40,
          "longitude": 120.51
        }
        }
        """.data(using: .utf8)!
do {
    let city = try JSONDecoder().decode(City.self, from: jsonData)
    print("city:", city)
} catch {
    print(error.localizedDescription)
}

上述例子中一次性展示了三种基本类型的基本用法，需要注意的是所有存储属性的类型都需遵循Codable才可以推断，计算属性不受此限制。如有存储属性不遵循Codable，需要自行实现本文开头协议中的方法。另外，class继承的父类也需遵循Codable才可以自动推断，否则也需自行实现。

自定义Key

由于Codable的key是直接用属性名匹配的，所以当key不匹配时需要我们自定义并实现协议方法。比如上述的的name字段变成了short_name。我们需要：

• 定义一个枚举遵循CodingKey协议且原始值为String（定义的最佳位置为嵌套在相应的model内）
• 实现Decodable的协议方法
  代码如下：

let jsonData = """
        {
        "short_name": "Shanghai",  // 这里的key与model不再吻合
        "pop": 21000000,
        "level": "large",
        "location": {
          "latitude": "30.40",
          "longitude": 120.51
        }
        }
        """.data(using: .utf8)!

class City: Codable, CustomDebugStringConvertible {
   //...其余代码与上例一致，这里不重复
    
    enum CodingKeys: String, CodingKey {
        case name = "short_name"
        case pop
        case level
        case location
    }
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        pop = try container.decode(UInt.self, forKey: .pop)
        level = try container.decode(Level.self, forKey: .level)
        location = try container.decode(Location.self, forKey: .location)
    }
}

进阶篇

第一式：善用嵌套

如果JSON格式比较奇怪，比如一个和时间相关的model分组，其key为日期。JSON格式如下：

{
  "2016-10-01": [Objects],
  "2017-09-30": [Objects],
  ...
}

我们可以使用[String: [Object]]解析，这样就可以避免key不整齐的尴尬。

第二式：巧用泛型

如果模型封装得比较好，其实大部分属性是可以复用的，我们可以通过泛型（继承也可以实现，只是层级比较复杂，且不支持struct）来实现模型的部分复用。

struct Resource<Attributes>: Codable where Attributes: Codable {
    let name: String
    let url: URL
    let attributes: Attributes
}

struct ImageAttributes: Codable {
    let size: CGSize
    let format: String
}

Resource<ImageAttributes> // 可以添加更多的Attributes，实现了多态

第三式：剥离麻烦

上文中提到Codable要求存储属性都遵循Codable才可以自动推断，如果只有极少属性不支持Codable的话，实现协议方法就显得十分麻烦。我们可以将部分属性剥离到子类或父类中（此方法仅限于class）。如下例所示：

let jsonData = """
{
  "name": "_name",
  "length": 4,
  "uncodableNumber": 6
}
""".data(using: .utf8)!

class CodablePart: Codable {
    let name: String
    let length: UInt
    
}

class WholeModel: CodablePart {
    
    enum CodingKeys: String, CodingKey {
        case uncodableNumber
    }

    let uncodableNumber: NSNumber
    
    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        let number = try container.decode(Int.self, forKey: .uncodableNumber)
        uncodableNumber = NSNumber(value: number)
        try super.init(from: decoder)
    }

}

do {
    let model = try JSONDecoder().decode(WholeModel.self, from: jsonData)
    print(model.name)
    print(model.length)
    print(model.uncodableNumber)
} catch {
    print(error.localizedDescription)
}

第四式：偷天换日

有时候JSON中的格式并非我们所要，比如String格式的浮点型数字，我们希望直接在转model时转换为Double类型。我们可以使用中间类转化类型。如下：

struct StringToDoubleConverter: Codable { // 此类将获取的String转化为Double
    
    let value: Double?
    
    init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let string = try container.decode(String.self)
        value = Double(string)
    }
}

这样我们就可以将希望转化为Double的String字段类型指定为StringToDoubleConverter。不过访问时层级多了.value一层，且类型为可选型（因String转Double本来就可能失败）。

后记

Codable提供了简洁的API，使Swift的编码与解析焕然一新。本来打算在本文阐述JSONEncoder，JSONDecoder，NSKeyedArchiver，NSKeyedUnarchiver与Codable结合的用法。但鉴于长度问题，将另开一篇介绍。本文基本用法参照了Medium上的两篇博文，进阶用法来自于自己探索的心得。