Moya + RxSwift + ObjectMapper 封装

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的效果。

switchLatest

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

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

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