如何在 Swift4 中验证这个 JSON？

Question

有一个 API，它用一个 status 值和一个 data 值将其响应包装在一个关联数组中，其中 data 包含一个错误对象，或期望值：

不良反应：

{
   "status":"error",
   "data":{  
      "errormessage":"Duplicate entry '101' for key 'PRIMARY'",
      "errorcode":1062
   }
}

成功回复：

{
   "status":"success",
   "data":{  
      "user": {
        "id": 1,
      }
   }
}

我想验证这些回复：

public class func validateResponse(_ data : Data) -> WebServicesError?
{
    struct WTPResponse : Decodable
    {
        let status : String
        let data : Data
    }

    do {
        let response = try JSONDecoder().decode(WTPResponse.self, from: data) // FAILS HERE
        if let wtpError = try? JSONDecoder().decode(WTPAPIError.self, from: response.data) {
            return WebServicesError.wtpError(WTPAPIError(code: wtpError.code, message: wtpError.message))
        }
    }
    catch let error {
        return WebServicesError.init(error: error)
    }

    return nil
}

尝试解码响应对象时总是失败，错误为：Expected to decode Data but found a dictionary instead. 我在想我可以将 data 对象解码为 Swift 类型 Data, 但它实际上是一个 [String: Any] 字典。

1) 如何验证从 API 收到的 Data？

2) 有没有办法只提取 JSON 响应的“data”部分作为 Data 类型，以便我可以解码 User 对象而不必给它一个 status 和 data 属性？

Answer 1

这是 Swift4 Codable 不起作用的情况。您必须手动解析 JSON 并处理这些情况。 https://github.com/SwiftyJSON/SwiftyJSON

Answer 2

我不确定您将如何使用新的 Codable 功能来执行此操作，如 shayegh 所说。

您可以改用 JSONSerialization class。这会将您的 JSON 数据转换为包含其他词典的词典。然后你可以通过代码自己查询字典。

那会很容易。

Answer 3

正如其他答案所述，您基本上无法使用 JSONDecoder 执行此操作，因为您无法为 "data" 密钥解码 Data。您需要将其解码为 Dictionary<String, Any> 或其他内容。我可以想办法做到这一点，但它很麻烦，即使那样，你最终得到的是 Dictionary，而不是 Data，所以你必须重新编码才能得到Data 稍后传递给 JSONDecoder。

也许这意味着您必须下降到较低级别 JSONSerialization 并“手动”查找字典。但是如果你在解码时确切地知道你正在寻找什么样的响应，那么我建议你使用 Swift Decodable 系统而不是绕过它。

在顶层，您有一个响应，可以是失败也可以是成功，并且在每种情况下都携带不同的数据负载。这听起来像一个 Swift enum 和关联值：

enum WTPResponse {
    case failure(WTPFailure)
    case success(WTPSuccess)
}

我们希望它可以直接从 JSON 解码，但我们必须手动编写 Decodable 一致性。编译器无法为具有关联值的 enum 自动执行此操作。在我们编写 Decodable 一致性之前，让我们定义我们需要的所有其他类型。

响应类型由字符串 "error" 或字符串 "success" 标识，这听起来像另一个 Swift enum。我们可以把这个 enum 变成 String 的 RawRepresentable，然后 Swift 可以为我们把它变成 Decodable:

enum WTPStatus: String, Decodable {
    case error
    case success
}

对于失败响应类型，数据负载有两个字段。这听起来像 Swift struct，并且由于字段是 String 和 Int，Swift 可以使我们成为 Decodable：

struct WTPFailure: Decodable {
    var errormessage: String
    var errorcode: Int
}

对于成功响应类型，数据负载是一个用户，它有一个 id: Int 字段。这听起来像两个 Swift struct，Swift 可以让我们 Decodable:

struct WTPSuccess: Decodable {
    var user: WTPUser
}

struct WTPUser: Decodable {
    var id: Int
}

这涵盖了您的示例 JSON 中出现的所有内容。现在我们可以手动让 WTPResponse 符合 Decodable，像这样：

extension WTPResponse: Decodable {
    enum CodingKeys: String, CodingKey {
        case status
        case data
    }

    init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        switch try container.decode(WTPStatus.self, forKey: .status) {
        case .error: self = .failure(try container.decode(WTPFailure.self, forKey: .data))
        case .success: self = .success(try container.decode(WTPSuccess.self, forKey: .data))
        }
    }
}

这是一个测试：

let failureJsonString = """
    {
       "status":"error",
       "data":{
          "errormessage":"Duplicate entry '101' for key 'PRIMARY'",
          "errorcode":1062
       }
    }
"""

let successJsonString = """
    {
       "status":"success",
       "data":{
          "user": {
            "id": 1,
          }
       }
    }
"""

let decoder = JSONDecoder()
do {
    print(try decoder.decode(WTPResponse.self, from: failureJsonString.data(using: .utf8)!))
    print(try decoder.decode(WTPResponse.self, from: successJsonString.data(using: .utf8)!))
} catch {
    print(error)
}

这是输出：

failure(test.WTPFailure(errormessage: "Duplicate entry \'101\' for key \'PRIMARY\'", errorcode: 1062))
success(test.WTPSuccess(user: test.WTPUser(id: 1)))

Answer 4

我使用 quicktype's multi-source mode 为每种响应类型生成单独的 Codable 模型：

这是代码。您可以先尝试解码 Response，如果失败，您可以尝试解码 BadResponse.

// let response = try? JSONDecoder().decode(Response.self, from: jsonData)
// let badResponse = try? JSONDecoder().decode(BadResponse.self, from: jsonData)

import Foundation

struct Response: Codable {
    let status: String
    let data: ResponseData
}

struct ResponseData: Codable {
    let user: User
}

struct BadResponse: Codable {
    let status: String
    let data: BadResponseData
}

struct BadResponseData: Codable {
    let errormessage: String
    let errorcode: Int
}

struct User: Codable {
    let id: Int
}

我认为这比尝试将其表示为单一类型要简洁一些。我还建议不要选择性地解码 JSON，而是解码所有这些，然后从这些类型中挑选出你想要的数据。

如何在 Swift4 中验证这个 JSON？

How to validate this JSON in Swift4?

ios

json

swift

codable

decodable