通常我们都用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 {}
就像图中说的那样，尽管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的方式，代码量明显要少一些。
