解析动态 JSON 的模型

Question

我遇到的端点可能会返回两种不同 JSON 之一，具体取决于用户是否需要回答安全问题：

// possible response (payload) #1
{
    "token": "123lknk123kj1n13132"
}

// possible response (payload) #2
{
    "securityQuestion": "What is your mother's maiden name?"
}

我的目标是创建一个模型，该模型将根据有效负载中存在的密钥（即"token" 或"securityQuestion"）对 JSON 进行不同的解码。 目前，我遇到了一个解析错误，我不知道为什么。

我的灵感来自对 SO 上一个问题的精心设计的回答。我当前的代码是它的修改版本，（理论上）符合我的需要。我希望我的代码的最终版本保留这种结构。我的代码如下：

/**
Enumerates the possible payloads received from Server

- success: Successful payload that contains the user's access token
- securityQuestion: Payload that contains the security question that the user has to answer to receive a token
*/
enum PayloadType: String, Decodable {
    case success
    case securityQuestion
}

protocol Payload: Decodable { static var payloadType: PayloadType { get } }

/// Model for successful response sent by the server.
struct SuccessfulResponse: Payload {
    static let payloadType = PayloadType.success
    let token: String
}

/// Model for response sent by the server which includes a security question
struct SecurityQuestionResponse: Payload {
    static let payloadType = PayloadType.securityQuestion
    let securityQuestion: String
}

/// Model for building a response sent by the server.
struct Response: Decodable {
    let data: Payload
    let payloadType: PayloadType

    init(from decoder: Decoder) throws {
        // NOTE*: This part is a little shaky, maybe this is where I am going wrong
        let values = try decoder.container(keyedBy: CodingKeys.self)
        self.payloadType = try values.decode(PayloadType.self, forKey: .payloadType)

        // payloadType will determine how the JSON is decoded
        switch self.payloadType
        {

        case .success:
            self.data = try values.decode(SuccessfulResonse.self, forKey: .data)

        case .securityQuestion:
            self.data = try values.decode(SecurityQuestionResponse.self, forKey: .data)
        }
    }

    private enum CodingKeys: String, CodingKey {
        case data
        case payloadType
    }
}

在发布这个问题之前，我查看了各种类似的帖子（1、2、3），但没有一个真正符合需求。

Answer 1

我想建议一种不同的方法，不是更简单而是易于使用，至少对我来说更清楚。

struct Token: Codable { 
   let token: String?
}

struct SecurityQuestion:Codable {
    let securityQuestion: String?
}

在请求函数中添加以下内容

URLSession.shared.dataTask(with: url, completionHandler: {data,response,error in

    do {
        let responseObject = try JSONDecoder().decode(Token.self, from: data!)

        let token = responseObject.token
        print(token)
    } catch let parseError {
        print(parseError)
        do{
            let responseObject = try JSONDecoder().decode(SecurityQuestion.self, from: data!)
            let securityQuestion = responseObject.securityQuestion
            print(securityQuestion)
        }catch{
            print(error)
        }
    }
})

主要的想法是使用 catch 块尝试另一种解码类型，因为第一个失败了，如果你有许多不同的响应，你可以做更多的 catch 块来做一个新的解码类型，