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)
网友评论