美文网首页RxSwift学习
Moya + RxSwift + ObjectMapper 封装

Moya + RxSwift + ObjectMapper 封装

作者: ATrucouradentor | 来源:发表于2018-09-08 21:15 被阅读60次

    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>添加一个扩展方法来处理。然后结合上面的mapObjectmapArray方法,就可以愉快地使用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等于flatMapswitchLatest的效果。

    switchLatest
    _ = button.rx.tap
           .flapMapLatest { _ in provider.rx.request(MyAPI.search) }
    

    有时候我们只需要取消一个请求操作,这时肯定有一个取消的事件,例如cancelEvent = Variable(true),当这个事件发生时,就表示我们要主动取消请求,使用takeUntil即可。

    _ = provider.rx.request(MyAPI.search).
            .takeUntil(cancelEvent)
    

    相关文章

      网友评论

        本文标题:Moya + RxSwift + ObjectMapper 封装

        本文链接:https://www.haomeiwen.com/subject/bnrlgftx.html