围绕网络创建反应式包装器答案

【问题标题】：Creating reactive wrapper around networking围绕网络创建反应式包装器
【发布时间】：2016-08-17 20:43:00
【问题描述】：

在为我的网络层创建响应式扩展时，我注意到了一些模式，我想提取这些模式只是为了简化我的逻辑以供未来实现...所以我现在拥有的是与此类似的几种方法：

static func create(params: [ String: AnyObject ]) -> Observable<Type> {
    return Observable<Type>.create { observer -> Disposable in
        let request = Alamofire.request(TypeAPI.Create(params: params).responseJSON { response in
            switch response.result {
            case .Success(let value):
                guard response.response?.statusCode != 409 else {
                    observer.onError(RequestError.TypeAlreadyExists)
                    return
                }

                guard let dict = value as? [ String: AnyObject ] else {
                    observer.onError(RequestError.ParsingError)
                    return
                }

                guard let parsedType: Type = try? Unbox(dict) else {
                    observer.onError(RequestError.MappingError)
                    return
                }

                observer.onNext(parsedType)
            case .Failure(let error):
                observer.onError(RequestError.convert(error))
            }
        }

        return AnonymousDisposable {
            request.cancel()
        }
    }
}

例如AnonymousDisposable 事情总是在重复。我查看了RxAlamofire 实现，他们的rx_request method 基本上遵循非常熟悉的模式，但是当我尝试将RxAlamofire 与我当前的包装器一起使用时，我有点卡住了。到目前为止，我已经结束了类似的内容：

static func rx_create(params: [ String: AnyObject ]) -> Observable<Type> {
    let manager: Manager = Manager.sharedInstance
    manager.rx_request { manager -> Request in
        return Alamofire.request(TypeAPI.Create(params: params))
    }
}

但是rx_request 返回Observable<Request> 而我需要Observable<Type>。如果我去添加.flatMap，那么我将再次添加AnonymousDisposable...

任何建议什么是正确的方法？我至少在附近吗？还是我走错了方向？

【问题讨论】：

标签： swift alamofire reactive-programming rx-swift reactivex

【解决方案1】：

得到了一些东西……至少我想我得到了一些东西。它有效，现在我对这个解决方案很满意，所以让我们跳到结论。

.flatMap 的路径是正确的，但为了避免额外的 Observable.create，我不得不深入了解 RxAlamofire 并从这个不错的 rx_responseJSON 方法中受益?

但后来我意识到我可以更进一步并提取这个过程，所以我已经完成了所有请求包装类通用的通用方法，如下所示：

static func rx_request<T>(requestConvertible: URLRequestConvertible, completion: (Request) -> Observable<T> ) -> Observable<T> {
    let manager: Manager = Manager.sharedInstance
    return manager
        .rx_request { manager -> Request in
            return Alamofire.request(requestConvertible)
        }
        .flatMap { request -> Observable<T> in
            return completion(request)
        }
        .shareReplay(1)
}

现在我可以像这里一样使用这种方法了：

static func rx_create(options: String) -> Observable<Type> {
    return rx_request(TypesAPI.Create(options: options)) { request -> Observable<Type> in
        request
            .validate()
            .rx_responseJSON()
            .flatMap{ (request, json) -> Observable<Type> in
                guard
                    let dict = json as? [ String: AnyObject ],
                    let parsedType: Type = try? Unbox(dict) else {
                        return Observable.error(RequestError.ParsingError)
                }

                return Observable.just(parsedType)
            }
    }
}

在我看来，这看起来更干净一些☺️

【讨论】：