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。

请注意我定义参数的方式：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!)的位置插入//(1)时，在Generic parameter T could not be inferred.的位置出现了错误//(2)。

这真是令人困惑。为什么 input 参数中的泛型在这里起什么作用？这必须与对上面.decode运算符的调用有关，在该运算符中，所涉及的泛型称为R，而不是T。

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

解决方法

此代码有许多小问题。您说对了，就是TypeError: Cannot read property 'classList' of undefined 。这意味着对于一组给定的参数，所有值都必须是同一类型。那不是“ JSON”。这将接受[String: T]或[String: String]，但是如果您这样做，则不能在同一字典中同时具有Int和String值。而且它也将接受[String: Int]，但这似乎并不是您真正想要的。

我建议将其切换为仅可编码，这将允许您在方便的情况下传递结构，或在方便的情况下传递字典：

[String: Document]

然后修改您的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设置为默认参数。那是因为这会重现您遇到的第二个问题。在默认情况下，无法推断params = nil（和Params）。对于T，= [:]是什么？ Swift必须知道，即使它是空的。因此，您可以使用重载代替默认值：

T

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

所以现在您的代码很好，并且您不需要最后的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) }

as

现在，func documents() -> AnyPublisher<[Document],MyError> { myPublisher(.documents) .map(\.data!) .mapError { MyError.network(description: $0.errorDescription) } .receive(on: DispatchQueue.main) .eraseToAnyPublisher() // <== Removed `as ...` } 使我难过。如果您从服务器取回损坏的数据，则该应用程序将崩溃。导致应用崩溃的原因有很多。错误的服务器数据绝不是其中之一。但是解决这个问题与这个问题并没有真正的联系（并且有点复杂，因为除Error之外的其他失败类型目前使事情变得很难），所以我暂时将其保留。我的一般建议是使用“错误”作为“失败”类型，并允许意外的错误冒出来，而不是将它们包装在.map(\.data!)中。如果仍然需要一些通用的“其他”，则最好使用类型（“ is”）而不是额外的枚举（将“ is”移至开关）。至少，我将尽可能晚地移动Error-> MyError映射，这将使处理起来更加容易。

需要再做一些调整以使以后的事情变得更通用，我怀疑MyResponse只需要是可解码的，而不是可编码的（其余的方法都可以，但是使它更加灵活）：

.undefined

关于如何使其可重用的原始问题，现在可以使用通用函数：

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