1

有一个 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) 如何验证Data我从 API 收到的信息？

2）有没有一种方法可以只提取dataJSON响应的“”部分作为Data类型，这样我就可以解码User对象而不必给它一个status和data属性？

4

4 回答 4

3

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

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

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

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

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

响应的类型由 string"error"或 string标识"success"，这听起来像另一个 Swift enum。我们可以把它enum变成 a RawRepresentableof String，然后 Swift 可以Decodable为我们制作它：

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

对于失败响应类型，数据负载有两个字段。这听起来像 Swift struct，因为字段是Stringand 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)))
于 2018-02-03T04:00:17.253 回答
1

我使用quicktype 的多源模式Codable为每种响应类型生成单独的模型：

多模式

这是代码。您可以尝试先解码 a 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，而是将其全部解码，然后从这些类型中挑选出您想要的数据。

于 2018-02-04T04:04:45.297 回答
0

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

于 2018-02-03T02:56:03.573 回答
0

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

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

那会很容易。

于 2018-02-03T03:25:52.163 回答