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<AccountService> in
let url = target.baseURL.appendingPathComponent(target.path).absoluteString
let endpoint = Endpoint<AccountService>(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的时候的回调参数：
EndpointClosureRequestResultClosure-
RequestClosure
这三种文章上面给Request提供Headers的时候已经用到了，第二种在项目里，暂时没有用到。下面介绍一下第三种的用法：
Moya的请求大致可以看做是：Request->Endpoint->Response的过程，中间的Endpoint是给我们开发者留下的最后的可以修改Reqeust的地方，如果你错过了，你就修改不了，下面我们简单的介绍一下，如果在RequestClousre里提供给Request增加超时的操作：
let requestClosure = { (endpoint: Endpoint, closure: @escaping MoyaProvider<HttpbinService>.RequestResultClosure) in
do {
var request = try endpoint.urlRequest()
request.timeoutInterval = 30
closure(.success(request))
} catch {
print("error:", error)
}
}
let provider = MoyaProvider<HttpbinService>(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<HttpbinService>(plugins: [Plugin()])
感觉一下子清爽很多，可能我还不太够Swifty。
插件机制是一个数组，所以你可以放入多种插件。还有三个函数我就不介绍了。
5. Moya扩展配合 Rx 和 SwiftyJSON 以及 ObjectMapper写出优雅的网络请求
通常我们使用Moya来获取网络请求是这样的：
let provider = MoyaProvider<HttpbinService>()
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<Any> {
return flatMap { response -> Single<Any> in
return Single.just(try response.mapJSON(failsOnEmptyData: failsOnEmptyData))
}
}
我只想说三个字：666
通过Single的方式发送出来（还有Observable的方式暂不讨论），发的是Any类型的数据，那我们就可以发出来Mappable的数据，动手：
extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
func map<T: BaseMappable>(_ type: T.Type) -> Single<T?> {
return flatMap { response -> Single<T?> in
do {
let any = try response.mapJSON()
guard let dic = any as? [String: Any] else {
return Single<T?>.just(nil)
}
let mapper = T(JSON: dic)
return Single<T?>.just(mapper)
} catch {
return Single<T?>.just(nil)
}
}
}
}
我们通过扩展PrimitiveSequence ,然后定义函数map<T: BaseMappable>(_ 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 ^ _^ --
