使用协议的JSONDecoder

Question

我使用一个协议来创建几个结构，我使用这些结构来使用JSONDecoder进行解码。下面是一个代码示例，说明我正在努力实现的目标。

protocol Animal: Codable
{
   var name: String { get }
   var age: Int { get }
}

struct Dog: Animal
{
   let name: String
   let age: Int
   let type: String
}

struct Cat: Animal
{
   let name: String
   let age: Int
   let color: String
}

下面是分别包含狗和猫的JSON有效载荷：

{
    "name": "fleabag",
    "age": 3,
    "type": "big"
}

{
    "name": "felix",
    "age": 2,
    "color": "black"
}

所以当我解码JSON时，我不知道我会有什么JSON，狗还是猫。我试过这样做：

let data = Data(contentsOf: url)
let value = JSONDecoder().decode(Animal.self, from: data)

但最后却出现了以下错误：

在参数类型“动物.协议”中，“动物”不符合预期类型“可解码”

关于解析返回Animal实例的狗或猫的最佳方法的任何想法

谢谢

Answer 1

更好的方法是使用类而不是协议，使用类而不是结构。Dog和Cat类将是Animal的子类。

class Animal: Codable {
    let name: String
    let age: Int

    private enum CodingKeys: String, CodingKey {
        case name
        case age
    }
}

class Dog: Animal {
    let type: String

    private enum CodingKeys: String, CodingKey {
        case type
    }

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

class Cat: Animal {
    let color: String

    private enum CodingKeys: String, CodingKey {
        case color
    }

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

let data = Data(contentsOf: url)
let animal = JSONDecoder().decode(Animal.self, from: data)

Answer 2

你不能用这个：

let animal = try? JSONDecoder().decode(Animal.self, from: data)

解码狗或猫。永远都是动物。

如果您想要将这两个JSON对象解码为，那么就像下面这样定义：

struct Animal: Codable {
    var name: String
    var age: Int
}

当然，您将失去使它们成为狗(type)或猫(color)的独特元素。

Answer 3

你在这里开了一罐有点丑的虫子。我明白你想做什么，但不幸的是，它在许多方面失败了。通过以下游乐场，您可以得到一些您想要的东西：

import Cocoa

let dogData = """
{
    "name": "fleabag",
    "age": 3,
    "type": "big"
}
""".data(using: .utf8)!

let catData = """
{
    "name": "felix",
    "age": 2,
    "color": "black"
}
""".data(using: .utf8)!

protocol Animal: Codable
{
    var name: String { get }
    var age: Int { get }
}

struct Dog: Animal
{
    let name: String
    let age: Int
    let type: String
}

struct Cat: Animal
{
    let name: String
    let age: Int
    let color: String
}

do {
    let decoder = JSONDecoder()
    let dog = try decoder.decode(Dog.self, from: dogData)
    print(dog)
    let cat = try decoder.decode(Cat.self, from: catData)
    print(cat)
}

extension Animal {
    static func make(fromJSON data: Data) -> Animal? {
        let decoder = JSONDecoder()
        do {
            let dog = try decoder.decode(Dog.self, from: data)
            return dog
        } catch {
            do {
                let cat = try decoder.decode(Cat.self, from: data)
                return cat
            } catch {
                return nil
            }
        }
    }
}

if let animal = Dog.make(fromJSON: dogData) {
    print(animal)
}
if let animal2 = Dog.make(fromJSON: catData) {
    print(animal2)
}

但是，您会注意到，有些更改确实有其原因。事实上，您不能实现Decodable方法init(from: Decoder) throws，因为它应该是chain到init方法，该方法.并不适用于协议。相反，我选择在Animal.make方法中实现您最喜欢的dispatcher，但这也是一个半成品解决方案。由于protocols是元类型(可能也有很好的原因)，所以您无法在元类型上调用它们的静态方法，而必须使用具体的方法。正如Dog.make(fromJSON: catData)所显示的那样，至少可以说，这看起来很奇怪。最好将其烘焙成顶级函数，如

func parseAnimal(from data:Data) {
    ...
}

但是，这从另一个方面看上去并不令人满意，因为它污染了全局名称空间。也许我们仍然能用现有的手段做最好的事情。

考虑到dispatcher的丑陋，没有直接指示类型的JSON似乎是个坏主意，因为它使解析变得非常困难。但是，我不认为有一种很好的方式可以在JSON中通信一个子类型，这样可以使解析变得非常容易。没有做任何研究，但这可能是你的下一次尝试。