iOS RxSwift 如何防止序列被处理（抛出错误）？

Question

我有一个由多个运算符组成的序列。在这个序列处理过程中，总共有 7 个地方会产生错误。我遇到了一个序列不符合我预期的问题，我正在寻找一个优雅的解决方案：

let inputRelay = PublishRelay<Int>()
let outputRelay = PublishRelay<Result<Int>>()

inputRelay
.map{ /*may throw multiple errors*/}
.flatmap{ /*may throw error*/ }
.map{}
.filter{}
.map{ _ -> Result<Int> in ...}
.catchError{}
.bind(to: outputRelay)

我认为catchError 会简单地捕获错误，允许我将其转换为失败结果，但防止序列被释放。但是，我看到第一次发现错误时，整个序列都被释放，不再有事件通过。

如果没有这种行为，我会留下一个令人毛骨悚然的结果，并且必须多次分支我的序列以将Result.failure(Error) 定向到输出。存在不可恢复的错误，所以retry(n) 不是一个选项：

let firstOp = inputRelay
.map{ /*may throw multiple errors*/}
.share()

//--Handle first error results--
firstOp
.filter{/*errorResults only*/}
.bind(to: outputRelay)

let secondOp = firstOp
.flatmap{ /*may throw error*/ }
.share()

//--Handle second error results--
secondOp
.filter{/*errorResults only*/}
.bind(to: outputRelay)

secondOp
.map{}
.filter{}
.map{ _ -> Result<Int> in ...}
.catchError{}
.bind(to: outputRelay)

^ 这很糟糕，因为大约有 7 个地方可能会引发错误，而且我不能每次都继续分支序列。

RxSwift 运算符如何捕获所有错误并在最后发出失败结果，但不处理第一个错误时的整个序列？

Answer 1

是的，这很痛苦。我考虑过创建一个新库的想法，其中语法不需要流以错误结束，但尝试重现整个 Rx 生态系统似乎毫无意义。

有一些响应式库允许您将 Never 指定为错误类型（意味着根本无法发出错误），在 RxCocoa 中您可以使用 Driver（不会出错）但您仍然留下了整个结果舞蹈。 “我的 Monads 中的 Monads！”。

要妥善处理，需要一组Monad transformers。有了这些，你可以做所有你想要的映射/平面映射，而不必担心直到最后才看到错误。

Answer 2

首先想到的技巧是使用materialize。这会将每个Observable<T> 转换为Observable<Event<T>>，因此错误只是.next(.error(Error))，不会导致序列终止。

但是，在这种特定情况下，需要另一个技巧。将你的整个“触发”链也放在一个 flatMap 中，并 materializeing 那个特定的部分。这是必需的，因为物化序列仍然可以完成，这会在常规链的情况下导致终止，但不会终止 flatMapped 链（因为完成 == 在 flatMap 内成功完成）。

inputRelay
    .flatMapLatest { val in
        return Observable.just(val)
            .map { value -> Int in
                if value == 1 { throw SomeError.randomError }
                return value + value
            }
            .flatMap { value in
                return Observable<String>.just("hey\(value)")
            }
            .materialize()
    }
    .debug("k")
    .subscribe()

    inputRelay.accept(1)
    inputRelay.accept(2)
    inputRelay.accept(3)
    inputRelay.accept(4)

这将为k 输出以下内容：

k -> subscribed
k -> Event next(error(randomError))
k -> Event next(next(hey4))
k -> Event next(completed)
k -> Event next(next(hey6))
k -> Event next(completed)
k -> Event next(next(hey8))
k -> Event next(completed)

现在您所要做的就是从具体化序列中过滤“下一个”事件。

如果您有RxSwiftExt，您可以简单地使用errors() 和elements() 运算符：

stream.elements()
    .debug("elements")
    .subscribe()

stream.errors()
    .debug("errors")
    .subscribe()

这将提供以下输出：

errors -> Event next(randomError)
elements -> Event next(hey4)
elements -> Event next(hey6)
elements -> Event next(hey8)

在使用这个策略的时候，别忘了在你的flatMap后面加上share()，这么多订阅不会造成多片处理。

你可以在这里阅读更多关于为什么你应该在这种情况下使用共享：http://adamborek.com/how-to-handle-errors-in-rxswift/

希望这会有所帮助！