JustNetworking 2.0.0

JustNetworking 2.0.0

×

由 Gustavo Campos 维护。

JustNetworking 2.0.0

  • 由
  • Gustavo Campos

JustNetworking

是一个用于简化网络层的精小架构库。该库的主要目标是提供一个简单抽象的网络层，便于使用和测试。

此库不提供任何自定义实现进行 API 调用，您必须使用自己的实现或使用类似 Alamofire 这样的库。

如何使用它？

此库有三个主要协议。

  1. Router
  2. Request
  3. Requester

Router

此协议用于获取请求的完整 URL 和 HTTPMethod。默认情况下使用全局配置中设置的 URL。

首先设置全局 URL

NetworkConfiguration.setCurrentURL(URL(string:"https://www.myApi.com")!)

实现 Router 协议

enum UserRouter: Router {
    case user(id: String)

    var route: Route {
        switch self {
            case .user(let id):
                return Route(path: "user\(id)", method: .get)
            }
      }
}

如果您不想使用全局 URL，则可以修改实现 baseURL 属性

enum UserRouter: Router {
    case user(id: String)

        var route: Route {
            switch self {
            case .user(let id):
            return Route(path: "user/\(id)", method: .get)
            }
  }

var baseURL: URL {
    return URL(string:"https://www.anotherapi.com")
    }
}

不建议使用单个枚举来表示所有可能的路由路径，最好是每个域名使用一个枚举，因此如果您有 user 和 packages 路由，您可能需要创建两个枚举，一个用于用户路由，另一个用于包路由。

Request

本协议及其关联类型用于抽象请求的配置。有三个关键参数：

  1. responseQueue

回调响应所在的队列。

  1. requestParser

属性，包含一个将数据解析为相关类型的函数。

  1. requestFactory

该类型 RequestFactory 的属性，这是一个结构体，用于初始化Router 实现和接收一个 URLRequest 并返回另一个的函数。此函数的目的是创建能够添加任何想对 URLRequest 进行配置的复合结构。

该库为此协议提供了一个默认实现。

    public struct RequestType<Response>: Request {

    public let responseQueue: DispatchQueue

    public let requestParser: RequestParser<Response>

    public let requestFactory: RequestFactory

    public init(responseQueue: DispatchQueue = .global(qos: .default),
            requestFactory: RequestFactory,
            requestParser: @escaping RequestParser<Response>) {
            self.responseQueue = responseQueue
            self.requestParser = requestParser
            self.requestFactory = requestFactory
            }
}

此库具有自定义扩展，当响应类型为 Decodable 时。

extension RequestType where Response: Decodable {

    init(responseQueue: DispatchQueue = .global(qos: .default),
        requestFactory: RequestFactory,
        decoder: JSONDecoder = JSONDecoder()) {
        self.init(responseQueue: responseQueue, requestFactory: requestFactory) {
            return try decoder.decode(Response.self, from: $0)
            }
      }
}

当响应为 Void 时。

extension RequestType where Response ==  Void {

    init(responseQueue: DispatchQueue = .global(qos: .default),
        requestFactory: RequestFactory) {
        self.init(responseQueue: responseQueue, requestFactory: requestFactory) {
            return ()
        }
    }
}

大多数情况下，您将使用此实现来构建请求，但如果您需要处理某些边缘情况，则可以实施此协议并应用您的自定义配置。

构建 URLRequest 的组合

库提供了一个名为 compose 的免费函数，它接受多种类型的 RequestBuilder 参数，它实际上是一个类型别名，其签名是 (URLRequest) -> URLRequest，该函数接受满足此签名的多个函数，将它们减少为一个 URLRequest。此函数返回一个 RequestBuilder。

示例

    let requestBuilder = compose(addURLParams(["years": "2015"]), addHeaders(["Authorization":"Bearer...."]))
    RequestFactory(router: UserRouter.user(id: "12"), requestBuilder: requestBuilder)

库还提供了一个用于使用可写入键的特性的免费函数，以变异地使用 URLRequest。

set(to: \.cachePolicy, .reloadIgnoringCacheData)

这与 compose 完全兼容，这意味着你可以这样做：

compose(set(to: \.cachePolicy, .reloadIgnoringCacheData), set(to: \.networkServiceType, .background))

请求者

此协议用于抽象网络客户端，仅包含一个接受一个 Request 和一个作为回调响应的闭包的函数（该闭包有一个类型别名 Response<T> 并接受一个 Result 类型作为参数）。

使用 Alamofire 的示例

public func execute<T: Request>(_ request: T, response: @escaping Response<T.Response>)  {

    let urlRequest = request.urlRequest
    Alamofire.request(urlRequest)
            .responseData(queue: request.responseQueue) {
                switch $0.result {
                 case .success(let data):
                do {
                    response(.success(try request.parser(data)))
                } catch {
                    response(.failure(error))
                }
                  case .failure(let error):
                     response(.failure(error))
                  }
             }
        }
}

安装

CocoaPods

只需在 podfile 中添加以下行

pod `JustNetworking`, `~> 2.0`

许可证

JustNetworking 在 MIT 许可下发布。详情见 LICENSE 文件。