Swift Moya实践与提升

Moya是什么就不再介绍了，因为网上已经有很多关于Moya的基础使用方法。
Swift：4.1
Moya: 11.0.2
RxSwift: 4.1.2
demo地址：https://github.com/hellolad/RxMoyaDemo

1. Moya TargetType: headers

在以前的Moya版本中，我们要给Reqeust提供Header的时候，TargetType里没有提供给我们直接使用的，所以我们需要使用Endpoint来给Request加上Header

let publicParamEndpointClosure = { (target: AccountService) -> Endpoint in
    let url = target.baseURL.appendingPathComponent(target.path).absoluteString
    let endpoint = Endpoint(url: url, sampleResponseClosure: { .networkResponse(200, target.sampleData) }, method: target.method, parameters: target.parameters, parameterEncoding: target.parameterEncoding)
    return endpoint.adding(newHTTPHeaderFields: ["x-platform" : "iOS", "x-interface-version" : "1.0"])
}

这是以前的老版本中，需要提供Header的时候就需要这样写，非常的复杂和不方便。现在TargetType提供了headers，所以我们可以摆脱这种写法了。

2. RxMoya

Moya支持RxSwift，改变以前的方式也非常的简单，只要在provider后面跟上.rx基本上就可以了.

provider.rx.request(.ip)
    .map(HTTBin.self)
    .subscribe { result in
        switch result {
        case .success(let element):
            guard let bin = element else { return }
            print("useage RxSwift: ", bin.ip)
        case .error(let error):
            print(error.localizedDescription)
        }
    }.disposed(by: bag)

3. Endpoint

在我们的MoyaProvider中提供了三种在初始化Provider的时候的回调参数：

EndpointClosure
RequestResultClosure
RequestClosure
这三种文章上面给Request提供Headers的时候已经用到了，第二种在项目里，暂时没有用到。下面介绍一下第三种的用法：
Moya的请求大致可以看做是：Request->Endpoint->Response的过程，中间的Endpoint是给我们开发者留下的最后的可以修改Reqeust的地方，如果你错过了，你就修改不了，下面我们简单的介绍一下，如果在RequestClousre里提供给Request增加超时的操作：

let requestClosure = { (endpoint: Endpoint, closure: @escaping MoyaProvider.RequestResultClosure) in
    do {
        var request = try endpoint.urlRequest()
        request.timeoutInterval = 30
        closure(.success(request))
    } catch {
        print("error:", error)
    }
}
let provider = MoyaProvider(requestClosure: requestClosure)

然后调用的时候初始化Provider就可以了，这种方式真的是...我感觉写起来很不方便，正好，Moya给我们提供了另一种好东西：Plugin.

4. Plugin

Moya的插件机制非常的好，好在哪里？

捕获Request的准备
捕获Request的发送
捕获Response
捕获整个从请求到收到结果的过程

如何使用在网上也有很多，我们现在把增加超时的地方从Endpoint的回调里删掉，放在Plugin里

final class Plugin: PluginType {
    func prepare(_ request: URLRequest, target: TargetType) -> URLRequest {
        print("prepare")
        var mRequest = request
        mRequest.timeoutInterval = 10
        return mRequest
    }
}
let provider = MoyaProvider(plugins: [Plugin()])

感觉一下子清爽很多，可能我还不太够Swifty。
插件机制是一个数组，所以你可以放入多种插件。还有三个函数我就不介绍了。

5. Moya扩展配合 Rx 和 SwiftyJSON 以及 ObjectMapper写出优雅的网络请求

通常我们使用Moya来获取网络请求是这样的：

let provider = MoyaProvider()
provider.request(.ip) { (result) in
    switch result {
    case .success(let response):
        do {
            let any = try JSONSerialization.jsonObject(with: response.data, options: .allowFragments)
            guard let obj = any as? [String: Any] else {
                return
            }
            /// 解析数据
        } catch {
            print(error)
        }
    case .failure(let error):
        print(error)
    }
}

这种操作在很多项目里真的好多好多，这样写的缺点是代码耦合性太强，维护起来很难，没有进行封装。有些时候我们可以到Github上找一些大佬封装好的，我们自己看一下源码学习一下，然后实践一下，你会发现我们的代码不管是质量还是可读性都会变强。
两个库：SwiftyJSON(4.1.0), ObjectMapper(3.1.0)写这篇文章的时候，我用的版本。

使用RxMoya提供的函数进行过滤操作

provider.rx.request(.ip)
    .mapJSON()
    .subscribe { result in
        switch result {
        case .success(let element):
            print("element :", element)
        case .error(let error):
            print(error.localizedDescription)
        }
    }.disposed(by: bag)

    }
}
打印：
element : {
    origin = "101.81.57.239";
}

我们使用了RxMoya为我们提供的mapJSON我们很容易就转换成了JSON并且打印出来，非常方便，那我们有没有更快的转换方式，把这个JSON直接转换成Model发送出来，下面我们介绍一下ObjectMapper。

使用ObjectMapper
我现在进行的api都是从http://httpbin.org上进行的测试.
ObjectMapper相信大家也都使用过了，看看我们的HTTBin的这个结构体：

struct HTTBin: Mappable {
    var ip: String = ""
    
    init?(map: Map) {}
    mutating func mapping(map: Map) {
        ip <- map["origin"]
    }
}

封装map转换成Model
现在我们有了SwiftyJSON也有了ObjectMapper两个神器，然后我们就可以去偷学怎么使用了，我们看一下mapJSON的实现

public func mapJSON(failsOnEmptyData: Bool = true) -> Single {
    return flatMap { response -> Single in
        return Single.just(try response.mapJSON(failsOnEmptyData: failsOnEmptyData))
    }
}

我只想说三个字：666
通过Single的方式发送出来（还有Observable的方式暂不讨论），发的是Any类型的数据，那我们就可以发出来Mappable的数据，动手：

extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
    func map(_ type: T.Type) -> Single {
        return flatMap { response -> Single in
            do {
                let any = try response.mapJSON()
                guard let dic = any as? [String: Any] else {
                    return Single.just(nil)
                }
                let mapper = T(JSON: dic)
                return Single.just(mapper)
                
            } catch {
                return Single.just(nil)
            }
        }
    }
}

我们通过扩展PrimitiveSequence ,然后定义函数map(_ type:)来实现发送Mappable的函数，具体实现其实就是拿到response转换成mapJSON,然后转换成字典，最后通过ObjectMapper拿到数据。
具体使用：

provider.rx.request(.ip)
    .map(HTTBin.self)
    .subscribe { result in
        switch result {
        case .success(let element):
            guard let bin = element else { return }
            print("ip :", bin.ip)
        case .error(let error):
            print(error.localizedDescription)
        }
    }.disposed(by: bag)
打印：
ip : 101.81.57.239

这样以来就方便并且快捷很多，非常容易扩展以及维护。

--以此来记录 Swift Moya ^ _^ --