我正在尝试根据 API 端点返回的数据呈现 View 。我的 JSON 看起来(大致)像这样:

{
  "sections": [
    {
      "title": "Featured",
      "section_layout_type": "featured_panels",
      "section_items": [
        {
          "item_type": "foo",
          "id": 3,
          "title": "Bisbee1",
          "audio_url": "http://example.com/foo1.mp3",
          "feature_image_url" : "http://example.com/feature1.jpg"
        },
        {
          "item_type": "bar",
          "id": 4,
          "title": "Mortar8",
          "video_url": "http://example.com/video.mp4",
          "director" : "John Smith",
          "feature_image_url" : "http://example.com/feature2.jpg"
        }
      ]
    }    
  ]
}

我有一个表示如何在我的 UI 中布局 View 的对象。它看起来像这样:

public struct ViewLayoutSection : Codable {
    var title: String = ""
    var sectionLayoutType: String
    var sectionItems: [ViewLayoutSectionItemable] = []
}

ViewLayoutSectionItemable 是一种协议(protocol)，其中包括要在布局中使用的图像的标题和 URL。

但是，sectionItems 数组实际上是由不同的类型组成的。我想要做的是将每个部分项目实例化为它自己的类的实例。

如何为 ViewLayoutSection 设置 init(from decoder: Decoder) 方法，让我遍历该 JSON 数组中的项目并创建一个实例在每种情况下都适合上课吗？

最佳答案

多态设计是一件好事:许多设计模式都表现出多态性，使整个系统更加灵活和可扩展。

不幸的是，Codable 没有对多态性的“内置”支持，至少现在还没有……还有关于是否 this is actually a feature or a bug 的讨论。 .

幸运的是，您可以使用 enum 作为中间“包装器”轻松创建多态对象。

首先，我建议将 itemType 声明为 static 属性，而不是实例属性，以便以后更容易打开它。因此，您的协议(protocol)和多态类型将如下所示:

import Foundation

public protocol ViewLayoutSectionItemable: Decodable {
  static var itemType: String { get }

  var id: Int { get }
  var title: String { get set }
  var imageURL: URL { get set }
}

public struct Foo: ViewLayoutSectionItemable {
  
  // ViewLayoutSectionItemable Properties
  public static var itemType: String { return "foo" }
  
  public let id: Int
  public var title: String
  public var imageURL: URL
  
  // Foo Properties
  public var audioURL: URL
}

public struct Bar: ViewLayoutSectionItemable {
  
  // ViewLayoutSectionItemable Properties
  public static var itemType: String { return "bar" }
  
  public let id: Int
  public var title: String
  public var imageURL: URL
  
  // Bar Properties
  public var director: String
  public var videoURL: URL
}

接下来，为“包装器”创建一个枚举:

public enum ItemableWrapper: Decodable {
  
  // 1. Keys
  fileprivate enum Keys: String, CodingKey {
    case itemType = "item_type"
    case sections
    case sectionItems = "section_items"
  }
  
  // 2. Cases
  case foo(Foo)
  case bar(Bar)
  
  // 3. Computed Properties
  public var item: ViewLayoutSectionItemable {
    switch self {
    case .foo(let item): return item
    case .bar(let item): return item
    }
  }
  
  // 4. Static Methods
  public static func items(from decoder: Decoder) -> [ViewLayoutSectionItemable] {
    guard let container = try? decoder.container(keyedBy: Keys.self),
      var sectionItems = try? container.nestedUnkeyedContainer(forKey: .sectionItems) else {
        return []
    }
    var items: [ViewLayoutSectionItemable] = []
    while !sectionItems.isAtEnd {
      guard let wrapper = try? sectionItems.decode(ItemableWrapper.self) else { continue }
      items.append(wrapper.item)
    }
    return items
  }
  
  // 5. Decodable
  public init(from decoder: Decoder) throws {
    let container = try decoder.container(keyedBy: Keys.self)
    let itemType = try container.decode(String.self, forKey: Keys.itemType)
    switch itemType {
    case Foo.itemType:  self = .foo(try Foo(from: decoder))
    case Bar.itemType:  self = .bar(try Bar(from: decoder))
    default:
      throw DecodingError.dataCorruptedError(forKey: .itemType,
                                             in: container,
                                             debugDescription: "Unhandled item type: \(itemType)")
    }
  }
}

上面的内容是这样的:

1. 您声明与响应结构相关的 Keys。在给定的 API 中，您对 sections 和 sectionItems 感兴趣。您还需要知道哪个键代表类型，您在此处声明为 itemType。

2. 然后您明确列出所有可能的情况:这违反了Open Closed Principle ，但这样做“没问题”，因为它充当创建项目的“工厂”....

   本质上，您在整个应用程序中只会一次，就在这里。

3. 您为 item 声明了一个计算属性:这样，您就可以展开底层的 ViewLayoutSectionItemable 而无需关心实际案例。

4. 这是“包装器”工厂的核心:您将 items(from:) 声明为能够返回 [ ViewLayoutSectionItemable]，这正是您想要做的:传入一个 Decoder 并返回一个包含多态类型的数组!这是您实际使用的方法，而不是直接解码 Foo、Bar 或这些类型的任何其他多态数组。

5. 最后，您必须让ItemableWrapper 实现Decodable 方法。这里的技巧是 ItemWrapper 总是 解码一个 ItemWrapper:因此，这按照 Decodable 的预期工作。

因为它是一个枚举，所以它允许有关联的类型，这正是您对每种情况所做的。因此，您可以间接创建多态类型!

由于您已经在 ItemWrapper 中完成了所有繁重的工作，现在非常很容易从 Decoder 转到 `[ViewLayoutSectionItemable] ]，你可以像这样简单地做:

let decoder = ... // however you created it
let items = ItemableWrapper.items(from: decoder)

关于json - 如何在 Swift 4 中实现 JSON 数据的多态解码？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46595246/