RxSwift - 如何使用 Observable.zip 处理不同的错误场景

Question

我有这段代码：

    ...
    let minMaxReq = networkProvider.getMinMaxAmortization(id: id)
    let emitExtractReq = networkProvider.getEmitExtract(id: id)

    self.isLoading.accept(true)

    Observable.zip(minMaxReq.asObservable(), emitExtractReq.asObservable()) { (minMaxResp, emitExtractResp) in
            return (minMaxResp, emitExtractResp)
        }.subscribe(onNext: { [weak self] responses in

            let minMaxResp = responses.0
            let emitExtractResp = responses.1

            guard let self = self else { return }

            self.isLoading.accept(false)
            self.getMinMaxAmortizationResponse.accept(minMaxResp)
            self.receiptsCNH.accept(emitExtractResp)

        }, onError: { [weak self] error in

            self?.isLoading.accept(false)
            self?.receivedError.accept(error)

        }).disposed(by: disposeBag)

在这种情况下，来自两个请求的所有错误都将在 onError 闭包中结束，我如何在不同的 onError 闭包中处理来自 minMaxReq 的错误？

我的目标是同时发出 2 个请求，但使用不同的闭包处理它们的错误。 我怎样才能做到这一点？ 谢谢

Answer 1

您是否尝试过物化运算符？ 也许它对您需要的实现很有用。 附上一个通常如何使用的例子：

let valid = network.getToken(apikey)
            .flatMap{ token in self.verifyToken(token).materialize()}
            .share()

valid
    .compactMap { $0.element }
    .subscribe(onNext: { data in print("token is valid:", data) })
    .disposed(by: disposeBag)

valid
    .compactMap { $0.error?.localizedDescription }
    .subscribe(onNext: { data in print("token is not valid:", data) })
    .disposed(by: disposeBag)

这样，您可以将 stream 分成两部分并给予适当的处理。

另一种选择可能是在 minMaxReq 操作中操纵错误事件。 类似于：

let minMaxReq = networkProvider.getMinMaxAmortization(id: id)
                        .catchError({ error in Observable.empty()
                        .do(onCompleted: { /* Do anything with no side effect*/  }) })

let emitExtractReq = networkProvider.getEmitExtract(id: id)

Observable.zip(...)

这是一篇文章，详细解释了RxSwift 中的处理错误

Answer 2

我发现这个解决方案对我有帮助RxSwift zip operator when one observable can fail

添加到 zip 之前需要捕获错误

let request1 = usecase.request1().asObservable()
let request2 = usecase.request2().catchErrorJustReturn([]).asObservable() // fetching some not so important data which are just good to have.Return empty array on error
Observable.zip(request1,request2)..observeOn(MainScheduler.instance)
   .subscribe(
      onNext: { //success code },
      onError: { _ in //error code}).disposeBy(bag:myDisposeBag)

但我改变了一点最后：

let request2 = usecase.request2().catchError { _ in
            return .just([])
        }