用 RxSwift + Moya 写出优雅的网络请求代码

sendRequestButton
    .rx_tap
    .flatMap(viewModel.loadData)
    .throttle(0.3, scheduler: MainScheduler.instance)
    .map { "/($0.debugDescription)" }
    .bindTo(self.resultLabel.rx_text)
    .addDisposableTo(disposeBag)

button
    .rx_tap // 点击登录
    .flatMap(provider.login) // 登录请求
    .map(saveToken) // 保存 token
    .flatMap(provider.requestInfo) // 获取用户信息
    .subscribe(handleResult) // 处理结果

enum DataAPI {
    case Data
}

extension DataAPI: TargetType {
    var baseURL: NSURL { return NSURL(string: "http://localhost:3000")! }
    
    var path: String {
        return "/data"
    }
    
    var method: Moya.Method {
        return .GET
    }
    
    var parameters: [String : AnyObject]? {
        return nil
    }
    
    var sampleData: NSData {
        return stubbedResponseFromJSONFile("stub_data")
    }
    
    var multipartBody: [Moya.MultipartFormData]? {
        return nil
    }
}

struct DataModel: ALSwiftyJSONAble {
    
    var title: String?
    var content: String?
    
    init?(jsonData: JSON) {
        self.title = jsonData["title"].string
        self.content = jsonData["content"].string
    }
}

class ViewModel {
    
    private let provider = RxMoyaProvider<DataAPI>() // 创建为 RxSwift 扩展的 MoyaProvider
    
    func loadData() -> Observable<DataModel> {
        return provider
            .request(.DataRequest) // 通过某个 Target 来指定发送哪个请求
            .debug() // 打印请求发送中的调试信息
            .mapObject(DataModel) // 请求的结果映射为 DataModel 对象
    }
}

sendRequestButton
    .rx_tap // 观察按钮点击信号
    .flatMap(viewModel.loadData) // 调用 loadData
    .map { "/($0.title) /($0.content)" } // 格式化显示内容 
    .bindTo(self.resultLabel.rx_text) // 绑定到 UILabel 上
    .addDisposableTo(disposeBag) // 添加到 disposeBag，当 disposeBag 释放时，这个绑定关系也会被释放

extension RxMoyaProvider {
    func tryUseOfflineCacheThenRequest(token: Target) -> Observable<Moya.Response> {
        return Observable.create { [weak self] observer -> Disposable in
            let key = token.cacheKey // 缓存 Key，可以根据自己的需求来写，这里采用的是 BaseURL + Path + Parameter转化为JSON字符串
            
            // 先读取缓存内容，有则发出一个信号（onNext），没有则跳过
            if let response = HSURLCache.sharedInstance.cachedResponseForKey(key) {
                observer.onNext(response)
            }
            
            // 发出真正的网络请求
            let cancelableToken = self?.request(token) { result in
                switch result {
                case let .Success(response):
                    observer.onNext(response)
                    observer.onCompleted()
                    
                    HSURLCache.sharedInstance.cacheResponse(response, forKey: key)
                case let .Failure(error):
                    observer.onError(error)
                }
            }
            
            return AnonymousDisposable {
                cancelableToken?.cancel()
            }
        }
    }
}

上面的 HSURLCache 是我自己写的一个缓存类，通过 SQLite 把 Moya 的 Response 对象保存到数据库中。  
由于 Moya 的 Response 对象是被 `final` 修饰的，无法通过继承方式为其添加 NSCoder 实现。所以就将 Response 的三个属性分别保存。  
读缓存数据时也是读出三个属性的数据，再用他们创建成 Response 对象。

func loadData() -> Observable<DataModel> {
    return provider
        .tryUseOfflineCacheThenRequest(.DataRequest)
        .debug()
        .distinctUntilChanged()
        .mapObject(DataModel)
}

sendRequestButton
    .rx_tap
    .flatMap(viewModel.loadData)
    .throttle(0.3, scheduler: MainScheduler.instance)
    .map { "/($0.title) /($0.content)" }
    .subscribe { event in
        switch event {
        case .Next(let data):
            print(data)
        case .Error(let error):
            print(error)
        case .Completed:
            break
        }
    }
    .addDisposableTo(disposeBag)

RxMoyaProvider<DataAPI>(stubClosure: MoyaProvider.ImmediatelyStub)

RxMoyaProvider<DataAPI>(stubClosure: MoyaProvider.NeverStub)

RxMoyaProvider<DataAPI>(stubClosure: MoyaProvider.DelayedStub(3))

let commonEndpointClosure = { (target: Target) -> Endpoint<Target> in
    var URL = target.baseURL.URLByAppendingPathComponent(target.path).absoluteString
    
    let endpoint = Endpoint<Target>(URL: URL,
                                    sampleResponseClosure: {.NetworkResponse(200, target.sampleData)},
                                    method: target.method,
                                    parameters: target.parameters)
    
    // 添加 AccessToken
    if let accessToken = currentUser.accessToken {
        return endpoint.endpointByAddingHTTPHeaderFields(["access-token": accessToken])
    } else {
        return endpoint
    }
}

internal final class AccessTokenPlugin: PluginType {
    
    func willSendRequest(request: RequestType, target: TargetType) {
        
    }
    
    func didReceiveResponse(result: Result<RxMoya.Response, RxMoya.Error>, target: TargetType) {
        switch result {
        case .Success(let response):
            do {
                let jsonObject = try response.mapJSON()
                let json = JSON(jsonObject)
                if json["status"].intValue == InvalidStatus {
                    NSNotificationCenter.defaultCenter().postNotificationName("InvalidTokenNotification", object: nil)
                }
            } catch {
                
            }
        case .Failure(_):
            break
        }
    }
}

private let provider = RxMoyaProvider<DataAPI>(stubClosure: MoyaProvider.NeverStub, plugins: [AccessTokenPlugin()])