provider.rx.request 方法
下面是Moya为对RxSwift提供扩展的源码，它的实现使得我们可以通过provider.rx.request(api)的方式进行网络请求。
request方法的原理是，创建一个 Single 类型对象（只发送一个元素的 Observable），很显然这是一个 Cold Observable，当他被订阅或者由其他事件触发时，provider会执行网络请求方法。当网络请求返回数据时，single通过判断返回结果的类型来发送对应的事件：result为.success时，就发送.success事件（是对.next的封装）；为.failure时，就发送.error事件。
public extension Reactive where Base: MoyaProviderType {
/// Designated request-making method.
///
/// - Parameters:
/// - token: Entity, which provides specifications necessary for a `MoyaProvider`.
/// - callbackQueue: Callback queue. If nil - queue from provider initializer will be used.
/// - Returns: Single response object.
public func request(_ token: Base.Target, callbackQueue: DispatchQueue? = nil) -> Single<Response> {
return Single.create { [weak base] single in
let cancellableToken = base?.request(token, callbackQueue: callbackQueue, progress: nil) { result in
switch result {
case let .success(response):
single(.success(response))
case let .failure(error):
single(.error(error))
}
}
return Disposables.create {
cancellableToken?.cancel()
}
}
}
}
上面的方法返回了一个Single<Response>，然后可以通过mapJSON()方法将Response元素转为字典或数组。
封装 ObjectMapper
mapJSON后获得的字典或数组可以通过map方法，进一步转化为 Mappable 模型或元素为Mappable模型的数组。解析出错时，就抛出error，这里我的做法是，定义一个特殊数值的code，表示服务器的数据返回有误。
extension Observable {
/// 将字典转为model
public func mapObject<T: Mappable>(type: T.Type) -> Observable<T> {
return self.map { response in
guard let dict = response as? [String: Any] else {
throw self.parseError(response: response)
}
guard let model = Mapper<T>().map(JSON: dict) else {
throw self.parseError(response: response)
}
return model
}
}
/// 将字典数组转为model数组
public func mapArray<T: Mappable>(type: T.Type) -> Observable<[T]> {
return self.map { response in
guard let array = response as? [[String: Any]] else {
throw self.parseError(response: response)
}
return Mapper<T>().mapArray(JSONArray: array)
}
}
/// 抛出解析的错误
private func parseError(response: Any) -> MoyaError {
if let _response = response as? Response {
return MoyaError.statusCode(_response)
}
// 解析失败时，作为服务器响应错误处理
let data = try? JSONSerialization.data(withJSONObject: response, options: [])
let _response = Response(statusCode: 555, data: data ?? Data())
return MoyaError.statusCode(_response)
}
}
Single 扩展
如果想在网络请求返回Response以后做些统一的操作，例如后台规定假如返回一个code字段，数值等于4000时，表示用户登录的Token失效，需要退出登录，那么可以模仿mapJSON的做法，对Single<Response>添加一个扩展方法来处理。然后结合上面的mapObject和mapArray方法，就可以愉快地使用moya进行链式地网络操作了。
extension PrimitiveSequence where TraitType == SingleTrait, ElementType == Response {
func mapObjectResponse<T: Mappable>(type: T.Type) -> Observable<T> {
return self.mapResponse(complete: complete).mapObject(type: type)
}
func mapArrayResponse<T: Mappable>(type: T.Type) -> Observable<[T]> {
return self.mapResponse(complete: complete).mapArray(type: type)
}
private func mapResponse() -> Observable<Any> {
return self.map({ (res) in
// 处理Response
handleResponse(response: res)
return res
})
.mapJSON()// Response 转 Foundation 对象
.debug()
.asObservable()
}
}
使用范例：
provider.rx.request(HomeAPI.home)
.mapObjectResponse(type: HomeModel.self)
.subscribe(onNext: { (model) in
print("请求成功", model)
}, onError: { (err) in
print("请求错误", err)
}, onCompleted: {
print("请求结束")
}).disposed(by: disposeBag)
如何取消请求操作？
日常使用中，网络请求一般是由其他事件触发的，例如点击一个搜索按钮：
_ = button.rx.tap
.flapMap { _ in provider.rx.request(MyAPI.search) }
如果在搜索结果未返回之前，搜索条件改变了，我们需要触发新的请求，那么这时候就有必要取消掉上次的网络请求。回头看看rx.request方法，在源码中，返回Disposables时，同时对当前的网络请求进行了cancel操作。
return Disposables.create {
cancellableToken?.cancel()
}
所以我们在新的请求出现时，只需要让上一次的请求事件dispose掉就好了。而这里我们可以使用flatMapLatest来实现。flatMapLatest等于flatMap加switchLatest的效果。
_ = button.rx.tap
.flapMapLatest { _ in provider.rx.request(MyAPI.search) }
有时候我们只需要取消一个请求操作，这时肯定有一个取消的事件，例如cancelEvent = Variable(true)，当这个事件发生时，就表示我们要主动取消请求，使用takeUntil即可。
_ = provider.rx.request(MyAPI.search).
.takeUntil(cancelEvent)
