Swift5 不要编码来自第三方的类型

通常我们都用Codable处理App中和model这类概念有关的类型。如果这个类型的属性都兼容Codable，用起来就不会有什么问题。但情况并不总是如此，如果model使用了一些不属于我们自己的类型，这时的编码和解码过程就需要额外注意了。

为了演示这种场景，我们可以用SPM创建两个modules：Libs和SPM。

let package = Package(
  name: "SPM",
  dependencies: [
  ],
  targets: [
    .target(
      name: "Libs",
      dependencies: []
    ),
    .target(
      name: "SPM",
      dependencies: ["Libs"]),
    .testTarget(
      name: "SPMTests",
      dependencies: ["SPM"]),
  ]
)

然后，在Libs中创建一个lib.swift，并在其中添加下面的代码：

import Darwin.C

public struct Point {
  public var x: Double
  public var y: Double

  public init(x: Double, y: Double) {
    self.x = x
    self.y = y
  }
}

现在，假设这个Point就是个来自第三方的类型，我们无法直接修改它的代码。然后，在main.swift里，定义一个使用了Point的类型User：

struct User {
  var name: String
  var pos: Point

  init(name: String, pos: Point) {
    self.name = name
    self.pos = pos
  }
}

接下来，如果我们希望让User支持Codable该怎么办呢？如果直接通过extension完成这件事，编译器会阻止你这么干：

extension User: Codable {}

因为User中的Point并不支持Codable，那如果在main.swift里，也通过extension让Point也遵从Codable呢？答案是，编译器也会阻止你这么干：

extension Point: Codable {}

image

就像图中说的那样，尽管Point的两个属性都支持Codable，但编译器只能在定义Point的文件里，通过extension自动合成Codable方法。

那该怎么办呢？一个最直接的想法就是自己动手写呗。但这时，先来回答一个问题：究竟应该手工实现Point还是User的Codable支持呢？

尽管两种方法事实上都可行。但作为一条最佳实践，最好避免给不属于自己的类型添加Codable支持。因为我们无法预知这个类型的原始作者是否会在未来让它支持Codable，也无法确定这个类型官方的Codable方案会和我们使用的相同。在升级依赖库的时候，这些问题对已有的codebase都是潜在的破坏性风险。因此，我们应该直接手工实现User的Codable支持。

接下来，编码User的时候，也有两种不同的方案。一种是“扁平化编码”：

extension User: Codable {
  private enum CodingKeys: String, CodingKey {
    case name
    case x
    case y
  }

  func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(name, forKey: .name)
    try container.encode(pos.x, forKey: .x)
    try container.encode(pos.y, forKey: .y)
  }

  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    self.name = try container.decode(String.self, forKey: .name)
    self.pos = Point(
      x: try container.decode(Double.self, forKey: .x),
      y: try container.decode(Double.self, forKey: .y)
    )
  }
}

这样一来，编码的结果里，就会隐藏掉Point的存在，变成类似{"name":"11","x":11,"y":10}的形式。

或者，也可以用嵌套容器的方式，把Point编码进来：

extension User: Codable {
  private enum CodingKeys: CodingKey {
    case name
    case pos
  }

  private enum PosCodingKeys: CodingKey {
    case x
    case y
  }

  func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    try container.encode(name, forKey: .name)

    var posContainer = container.nestedContainer(
      keyedBy: PosCodingKeys.self, forKey: .pos)
    try posContainer.encode(pos.x, forKey: .x)
    try posContainer.encode(pos.y, forKey: .y)
  }

  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)
    self.name = try container.decode(String.self, forKey: .name)

    let posContainer = try container.nestedContainer(
      keyedBy: PosCodingKeys.self, forKey: .pos)
    self.pos = Point(
      x: try posContainer.decode(Double.self, forKey: .x),
      y: try posContainer.decode(Double.self, forKey: .y)
    )
  }
}

这样，User对象的编码结果就会变成类似{"name":"11","pos":{"x":11,"y":10}}的形式。虽然问题是解决了，但是回头看看为了支持Codable，我们写的代码可着实不少。更重要的是，这些代码其实没什么“营养”。类的属性少还好，多了之后，这样一个个的去编码和解码的确很麻烦。于是，这样的话就有点儿尴尬了。既不能直接给Point扩展Codable，扩展User又太麻烦，还能怎么办呢？

一个思路就是，给Point单独创建一个支持Codable的包装类。并把这个包装类放到User里，这样编译器就可以自动给User合成Codable了。

首先，仿照着Point里我们需要的属性，创建一个包装类：

struct User: Codable {
  private struct _Point: Codable {
    var x: Double
    var y: Double
  }
}

其次，给User添加一个_Point属性，并修改对应的init方法：

struct User: Codable {
  var name: String
  private var _point: _Point
  var pos: Point

  init(name: String, pos: Point) {
    self.name = name
    self._point = _Point(x: pos.x, y: pos.y)
    self.pos = pos
  }
}

第三，接管pos属性的赋值和读取，读取的时候，用_point属性生成一个新的Point对象；赋值的时候，把Point的值保存回_point。这样就实现了编码数据的时候，使用内部类型_Point，访问API的时候，仍旧使用Point的效果：

struct User: Codable {
  var pos: Point {
    get {
      return Point(x: _point.x, y: _point.y)
    }
    set {
      _point = _Point(x: newValue.x, y: newValue.y)
    }
  }
}

第四，定义编码User时使用的CodingKey，让它使用_point的值，以及pos的名字作为key：

private enum CodingKeys: String, CodingKey {
  case name
  case _point = "pos"
}

这样，Swift就可以自动为User生成Codable方法了。最终，User的定义是这样的：

struct User: Codable {
  var name: String

  private var _point: _Point
  var pos: Point {
    get {
      return Point(x: _point.x, y: _point.y)
    }
    set {
      _point = _Point(x: newValue.x, y: newValue.y)
    }
  }

  private enum CodingKeys: String, CodingKey {
    case name
    case _point = "pos"
  }

  init(name: String, pos: Point) {
    self.name = name
    self._point = _Point(x: pos.x, y: pos.y)
    self.pos = pos
  }

  private struct _Point: Codable {
    var x: Double
    var y: Double
  }
}

但相比之前手工实现Codable的方式，代码量明显要少一些。