如何使用动态类型的Swift JSONDecode？

问题描述 投票：5回答：4

我的应用程序具有本地缓存​​，并从/向服务器发送/接收模型。所以我决定构建一个map [String：Codable.Type]，基本上能够解码我在本地创建或从服务器接收的通用缓存上的任何内容。

let encoder = JSONEncoder()
let decoder = JSONDecoder()
var modelNameToType = [String : Codable.Type]()
modelNameToType = ["ContactModel": ContactModel.Self, "AnythingModel" : AnythingModel.Self, ...]

无论我在App上创建什么，我都可以成功编码并存储在缓存中，如下所示：

let contact = ContactModel(name: "John")
let data = try! encoder.encode(contact)
CRUD.shared.storekey(key: "ContactModel$10", contact)

我想像这样解码：

let result = try! decoder.decode(modelNameToType["ContactModel"]!, from: data)

但我得到错误：

无法使用类型的参数列表（Codable.Type，from：Data）调用'decode'

我究竟做错了什么？任何帮助表示赞赏

修复类型有效，并解决任何本地请求，但不能解决远程请求。

let result = try! decoder.decode(ContactModel.self, from: data)

联系型号：

struct ContactModel: Codable {
    var name : String
}

对于远程请求，我会有这样的函数：

    func buildAnswer(keys: [String]) -> Data {

        var result = [String:Codable]()
        for key in keys {
            let data = CRUD.shared.restoreKey(key: key)
            let item = try decoder.decode(modelNameToType[key]!, from: data)
            result[key] = item
        }
        return try encoder.encode(result)
    }

...如果我解决了解码问题。任何帮助赞赏。

json swift decode encode
4个回答
6
投票

Codable API围绕编码和解码为具体类型而构建。但是，你想要的往返不应该知道任何具体的类型;它只是将异构JSON值连接成一个JSON对象。

因此，在这种情况下，JSONSerialization是一个更好的工具，因为它涉及Any：

import Foundation

// I would consider lifting your String keys into their own type btw.
func buildAnswer(keys: [String]) throws -> Data {

  var result = [String: Any](minimumCapacity: keys.count)

  for key in keys {
    let data = CRUD.shared.restoreKey(key: key)
    result[key] = try JSONSerialization.jsonObject(with: data)
  }
  return try JSONSerialization.data(withJSONObject: result)
}

话虽这么说，你仍然可以使用JSONDecoder / JSONEncoder制作它 - 但它需要相当多的类型擦除样板。

例如，我们需要一个符合Encodable的包装类型，如Encodable doesn't conform to itself：

import Foundation

struct AnyCodable : Encodable {

  private let _encode: (Encoder) throws -> Void

  let base: Codable
  let codableType: AnyCodableType

  init<Base : Codable>(_ base: Base) {
    self.base = base
    self._encode = {
      var container = $0.singleValueContainer()
      try container.encode(base)
    }
    self.codableType = AnyCodableType(type(of: base))
  }

  func encode(to encoder: Encoder) throws {
    try _encode(encoder)
  }
}

我们还需要一个包装器来捕获可用于解码的具体类型：

struct AnyCodableType {

  private let _decodeJSON: (JSONDecoder, Data) throws -> AnyCodable
  // repeat for other decoders...
  // (unfortunately I don't believe there's an easy way to make this generic)
  //

  let base: Codable.Type

  init<Base : Codable>(_ base: Base.Type) {
    self.base = base
    self._decodeJSON = { decoder, data in
      AnyCodable(try decoder.decode(base, from: data))
    }
  }

  func decode(from decoder: JSONDecoder, data: Data) throws -> AnyCodable {
    return try _decodeJSON(decoder, data)
  }
}

我们不能简单地将Decodable.Type传递给JSONDecoder

func decode<T : Decodable>(_ type: T.Type, from data: Data) throws -> T

当T是一种协议类型时，type:参数采用.Protocol元型，而不是.Type元型（更多信息请参见this Q&A）。

我们现在可以为我们的键定义一个类型，使用modelType属性返回一个AnyCodableType，我们可以使用它来解码JSON：

enum ModelName : String {

  case contactModel = "ContactModel"
  case anythingModel = "AnythingModel"

  var modelType: AnyCodableType {
    switch self {
    case .contactModel:
      return AnyCodableType(ContactModel.self)
    case .anythingModel:
      return AnyCodableType(AnythingModel.self)
    }
  }
}

然后为往返做这样的事情：

func buildAnswer(keys: [ModelName]) throws -> Data {

  let decoder = JSONDecoder()
  let encoder = JSONEncoder()

  var result = [String: AnyCodable](minimumCapacity: keys.count)

  for key in keys {
    let rawValue = key.rawValue
    let data = CRUD.shared.restoreKey(key: rawValue)
    result[rawValue] = try key.modelType.decode(from: decoder, data: data)
  }
  return try encoder.encode(result)
}

这可能更好地设计用于Codable而不是它（可能是一个结构来表示你发送到服务器的JSON对象，并使用关键路径与缓存层交互），但不知道更多关于CRUD.shared以及你如何用它;很难说。

1
投票

我想像这样解码：

let result = try! decoder.decode(modelNameToType["ContactModel"]!, from: data)

但我得到错误：

Cannot invoke 'decode' with an argument list of type (Codable.Type, from: Data)

您正在使用decode错误。 decoder.decode的第一个参数不能是对象;它必须是一种类型。您无法传递表达式中包含的元类型。

但是，您可以传递一个对象并获取其类型。所以你可以通过一个通用来解决这个问题，保证我们是一个可解码的采用者。这是一个最小的例子：

func testing<T:Decodable>(_ t:T, _ data:Data) {
    let result = try! JSONDecoder().decode(type(of:t), from: data)
    // ...
}

如果您将ContactModel实例作为第一个参数传递，那是合法的。

0
投票

我相信这是您正在寻找的解决方案。

import Foundation

struct ContactModel: Codable {
    let name: String
}

let encoder = JSONEncoder()
let decoder = JSONDecoder()

var map = [String: Codable]()

map["contact"] = ContactModel(name: "John")
let data = try! encoder.encode(map["contact"] as! ContactModel)

let result = try! decoder.decode(ContactModel.self, from: data)

debugPrint(result)

这将打印以下内容。

ContactModel(name: "John")
0
投票

您可以考虑的一种方法是定义两个不同的结构，每个结构对于更改的字段具有不同的数据类型。如果第一次解码失败，则尝试使用第二种数据类型解码，如下所示：

struct MyDataType1: Decodable {
    let user_id: String
}

struct MyDataType2: Decodable {
    let user_id: Int
}

do {
    let myDataStruct = try JSONDecoder().decode(MyDataType1.self, from: jsonData)

} catch let error {
    // look at error here to verify it is a type mismatch
    // then try decoding again with type MyDataType2
}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.