时间戳

首页 > 解决方案 > Swift Combine：无法重构重复的代码

swift - Swift Combine：无法重构重复的代码

问题描述

我的 API 返回这种格式，其中data可以包含各种响应。

{
    status: // http status
    error?: // error handle
    data?:  // your response data
    meta?:  // meta data, eg. pagination
    debug?: // debuging infos
}

我Codable为可选数据创建了一个带有泛型的响应类型，我们不知道它的类型。

struct MyResponse<T: Codable>: Codable {
    let status: Int
    let error: String?
    let data:  T?
    let meta: Paging?
    let debug: String?
}

我现在正在尝试尽可能简洁地编写 API 便利方法。所以我有一个函数可以返回一个通用发布者，我可以将它用于所有这些响应，即预先解析响应并预先捕获任何错误的发布者。

首先，我得到一个dataTaskPublisher处理参数输入（如果有）的。Endpoint只是String enum为我的端点提供便利，Method是相似的。MyRequest返回URLRequest带有一些必要标题等的 a

注意我定义参数的方式：params: [String:T]. 这是标准的 JSON，所以它可以是字符串、数字等。
这似乎T是问题所在。.

static fileprivate func publisher<T: Encodable>(
        _ path: Endpoint,
        method: Method,
        params: [String:T] = [:]) throws
        -> URLSession.DataTaskPublisher
    {
        let url = API.baseURL.appendingPathComponent(path.rawValue)
        var request = API.MyRequest(url: url)
        if method == .POST && params.count > 0 {
            request.httpMethod = method.rawValue
            do {
                let data = try JSONEncoder().encode(params)
                request.httpBody = data
                return URLSession.shared.dataTaskPublisher(for: request)
            }
            catch let err {
                throw MyError.encoding(description: String(describing: err))
            }
        }
        return URLSession.shared.dataTaskPublisher(for: request)
    }

接下来，我正在解析响应。

static func myPublisher<T: Encodable, R: Decodable>(
        _ path: Endpoint,
        method: Method = .GET,
        params: [String:T] = [:])
        -> AnyPublisher<MyResponse<R>, MyError>
    {
        do {
                
            return try publisher(path, method: method, params: params)
            .map(\.data)
            .mapError { MyError.network(description: "\($0)")}
            .decode(type: MyResponse<R>.self, decoder: self.agent.decoder)
            .mapError { MyError.encoding(description: "\($0)")}             //(2)
            .tryMap {
                if $0.status > 204 {
                    throw MyError.network(description: "\($0.status): \($0.error!)")
                }
                else {
                    return $0 // returns a MyResponse
                }
            }
            .mapError { $0 as! MyError }
                                                                            //(1)
            .eraseToAnyPublisher()
        }
        catch let err {
            return Fail<MyResponse<R>,MyError>(error: err as? MyError ??
                MyError.undefined(description: "\(err)"))
            .eraseToAnyPublisher()
        }
    }

现在我可以轻松编写端点方法了。这里有两个例子。

static func documents() -> AnyPublisher<[Document], MyError> {
    return myPublisher(.documents)
        .map(\.data!)
        .mapError { MyError.network(description: $0.errorDescription) }
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher() as AnyPublisher<[Document], MyError>
}

和

static func user() -> AnyPublisher<User, MyError> {
    return myPublisher(.user)
        .map(\.data!)
        .mapError { MyError.network(description: $0.errorDescription) }
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher() as AnyPublisher<User, MyError>
}

这一切运作良好。请注意，每次，我都必须指定我的确切返回类型两次。我想我可以忍受。

我应该能够简化这一点，这样我就不必每次都以完全相同的方式重复相同的三个运算符（map、mapError、receive）。

但是当我在上面.map(\.data!)的位置插入时，我在location//(1)得到错误。Generic parameter T could not be inferred.//(2)

这真的很令人困惑。为什么输入参数中的泛型类型在这里起任何作用？这必须与上面对.decode运算符的调用有关，其中所讨论的泛型被称为R，而不是T。

你能解释一下吗？如何在上游重构这些运算符？

标签： swiftdictionarygenericscombine

解决方案

这段代码有很多小问题。你是对的，一个是[String: T]。这意味着对于给定的一组参数，所有值必须属于同一类型。那不是“JSON”。这将接受 a[String: String]或 a [String: Int]，但如果你这样做，你不能在同一个字典中同时拥有 Int 和 String 值。它也会接受[String: Document]，而且看起来你并不是真的想要那样。

我建议将其切换为仅 Encodable，如果方便的话，它可以让你传递结构，或者如果方便的话，可以传递字典：

func publisher<Params: Encodable>(
    _ path: Endpoint,
    method: Method,
    params: Params?) throws
-> URLSession.DataTaskPublisher

func myPublisher<Params: Encodable, R: Decodable>(
    _ path: Endpoint,
    method: Method = .GET,
    params: Params?)
-> AnyPublisher<MyResponse<R>, MyError>

然后修改您params.count以检查 nil 。

请注意，我没有params = nil设置默认参数。那是因为这会重现您遇到的第二个问题。T（和参数）在默认情况下无法推断。对于= [:]，是什么T？斯威夫特必须知道，即使它是空的。因此，您使用重载而不是默认值：

func myPublisher<R: Decodable>(
    _ path: Endpoint,
    method: Method = .GET)
-> AnyPublisher<MyResponse<R>, MyError> {
    let params: String? = nil // This should be `Never?`, see https://twitter.com/cocoaphony/status/1184470123899478017
    return myPublisher(path, method: method, params: params)
}

现在，当您不传递任何参数时，Params 会自动变为 String。

as所以现在你的代码很好，最后你不需要

func documents() -> AnyPublisher<[Document], MyError> {
    myPublisher(.documents)
        .map(\.data!)
        .mapError { MyError.network(description: $0.errorDescription) }
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher() // <== Removed `as ...`
}

现在，这.map(\.data!)让我很难过。如果您从服务器取回损坏的数据，应用程序将崩溃。崩溃应用程序有很多充分的理由；糟糕的服务器数据绝不是其中之一。但是解决这个问题与这个问题并没有真正的关系（并且有点复杂，因为除了 Error 之外的故障类型目前使事情变得困难），所以我现在就留下它。我的一般建议是使用 Error 作为您的失败类型，并允许意外错误冒出而不是将它们包装在一个.undefined案例中。如果您无论如何都需要一些包罗万象的“其他”，那么您最好使用类型（“is”）而不是额外的枚举案例（它只是将“is”移动到开关）。至少，我会尽可能晚地移动 Error->MyError 映射，这将使处理变得更容易。

再做一个调整，让后面的事情更通用一点，我怀疑 MyResponse 只需要是可解码的，而不是可编码的（其余的都可以工作，但它使它更灵活一点）：

struct MyResponse<T: Decodable>: Decodable { ... }

对于您最初关于如何使其可重用的问题，您现在可以提取一个通用函数：

func fetch<DataType, Params>(_: DataType.Type,
                             from endpoint: Endpoint,
                             method: Method = .GET,
                             params: Params?) -> AnyPublisher<DataType, MyError>
where DataType: Decodable, Params: Encodable
{
    myPublisher(endpoint, method: method, params: params)
        .map(\.data!)
        .mapError { MyError.network(description: $0.errorDescription) }
        .receive(on: DispatchQueue.main)
        .eraseToAnyPublisher()
}

// Overload to handle no parameters
func fetch<DataType>(_ dataType: DataType.Type,
                     from endpoint: Endpoint,
                     method: Method = .GET) -> AnyPublisher<DataType, MyError>
where DataType: Decodable
{
    fetch(dataType, from: endpoint, method: method, params: nil as String?)
}


func documents() -> AnyPublisher<[Document], MyError> {
    fetch([Document].self, from: .documents)
}

推荐阅读