Swift5 如何编码包含多态对象的集合

我们先定义一组用于演示的支持Codable的派生类：

public class Shape: Codable {
  public required init() {}
  public required init(from decoder: Decoder) throws {}

  public func getName() {
    fatalError("Shape is a general base.")
  }
}

public class Triangle: Shape {
  public required init() {
    super.init()
  }
  public required init(from decoder: Decoder) throws {
    try super.init(from: decoder)
  }

  public override func getName() {
    print("Triangle")
  }
}

public class Rectangle: Shape {
  public required init() {
    super.init()
  }
  public required init(from decoder: Decoder) throws {
    try super.init(from: decoder)
  }

  public override func getName() {
    print("Rectangle")
  }
}

public class Circle: Shape {
  public required init() {
    super.init()
  }
  public required init(from decoder: Decoder) throws {
    try super.init(from: decoder)
  }

  public override func getName() {
    print("Circle")
  }
}

接下来，定义一个包含这些类对象的数组：

let shapes = [Triangle(), Rectangle(), Circle()]

现在，如果编码再解码shapes会发生什么呢？

let collData = try JSONEncoder().encode(shapes)
let collString = String(decoding: collData, as: UTF8.self)
let decoded = try JSONDecoder().decode([Shape].self, from: collData)

decoded.forEach {
  $0.getName()
}

执行一下就会在控制台看到Shape is a general base.的运行时错误了。也就是说，在编码和解码的过程里，shapes中对象的类型信息会丢掉。decoded只是一个普通的[Shape]。因此，调用getName的时候，就发生错误了。

于是，接下来的问题就变成了，该如何在编码和解码的过程中，保留住类型信息呢？一个可行的办法，就是通过enum的关联值，把每个类型的对象单独保存起来。为此，我们可以给Shape添加这样一个扩展：

extension Shape {
  enum CodableShape: Codable {
    case triganle(Triangle)
    case rectangle(Rectangle)
    case circle(Circle)

    private enum CodingKeys: String, CodingKey {
      case triangle
      case rectangle
      case circle
    }
  }
}

CodableShape的每一个case对应类继承体系中的一个类型。这样，在编码CodableShape的时候，我们就可以通过CodingKeys记录对象的类型了：

enum CodableShape: Codable {
  /// ...

  func encode(to encoder: Encoder) throws {
    var container = encoder.container(keyedBy: CodingKeys.self)
    switch self {
    case .triganle(let s):
      try container.encode(s, forKey: .triangle)
    case .rectangle(let s):
      try container.encode(s, forKey: .rectangle)
    case .circle(let s):
      try container.encode(s, forKey: .circle)
    }
  }
}

类似地，解码的时候，我们可以根据CodingKeys，还原出CodableShape：

enum CodableShape: Codable {
  /// ...

  init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: CodingKeys.self)

    if let data =
      try container.decodeIfPresent(Triangle.self, forKey: .triangle) {
      self = .triganle(data)
    }
    else if let data =
      try container.decodeIfPresent(Rectangle.self, forKey: .rectangle) {
      self = .rectangle(data)
    }
    else {
      let data = try container.decode(Circle.self, forKey: .circle)
      self = .circle(data)
    }
  }
}

剩下的任务，就是把Shape和CodableShape关联起来就好了。我们先给CodableShape添加一个还原成Shape的方法。它的实现很简单，就是根据Codable Shape的值，提取出对应case关联的对象：

enum CodableShape: Codable {
  /// ...

  func toShape() -> Shape {
    switch self {
    case .triganle(let s):
      return s
    case .rectangle(let s):
      return s
    case .circle(let s):
      return s
    }
  }
}

再给Shape添加一个加工成CodableShape的方法。它的实现，就是把特定类型的Shape，装进CodableShape的case里：

extension Shape {
  func toCodable() -> CodableShape {
    if let s = self as? Circle {
      return .circle(s)
    }
    else if let s = self as? Rectangle {
      return .rectangle(s)
    }
    else if let s = self as? Triangle {
      return .triganle(s)
    }
    else {
      fatalError("Unrecoginzed shape.")
    }
  }
}

有了这些准备之后，当我们再要编码[Shape]的时候，就可以这样：

let shapes =
  [Triangle(), Rectangle(), Circle()]
    .map { $0.toCodable() }

这样，编码后的Data对象里，就是CodableShape。而解码的时候，再像下面这样还原回来就好了：

let decoded = try JSONDecoder().decode(
  [Shape.CodableShape].self, from: collData)
decoded
  .map { $0.toShape() }
  .forEach {
    $0.getName()
  }

现在，重新执行，getName就会以多态的方式正常工作了。

image