RxSwift 定制重试逻辑

虽然 RxSwift 提供了丰富的处理错误操作符，如 retry retryWhen catchError ，但做一些定制化的处理机制直接使用这几个操作符可能是不够的，本文介绍了如何定制一些更友好的处理方案，比如，在网络错误时，由用户决定是否需要重新请求。

阅读本文前建议先阅读 RxSwift - 为什么存在 catchError。

本节内容灵感来自：https://github.com/ReactiveX/RxSwift/blob/4b0c77246330ec45fe03beef9ea4f5624085d8a0/RxExample/RxExample/Services/ReachabilityService.swift#L78-L92 (opens new window)

# retryWhen

直接使用 retry 通常不是我们想要的，我们可不想在手机没有网络情况下，一直尝试网络请求是不够友好的。

针对上述情况，我们可能采取下面两种方案解决：

结束本次操作，展示错误信息；
结束本次操作，展示错误信息，并给出弹窗由用户决定是否重试。

这里我们来用 retryWhen 完成第二种方案。

为了更好的展示 retry 的效果，本次 demo 引入了框架 [SwiftRandom][https://github.com/thellimist/SwiftRandom]。

/// 自定义的错误
///
/// - notPositive: 不是正数
/// - oversize: 数字过大
enum MyError: Swift.Error {
    case notPositive(value: Int)
    case oversize(value: Int)
}

Observable<Int>
    .deferred { () -> Observable<Int> in
        return Observable.just(Int.random(within: -100...200))
    }
    .map { value -> Int in
        if value <= 0 {
            throw MyError.notPositive(value: value)
        } else if value > 100 {
            throw MyError.oversize(value: value)
        } else {
            return value
        }
    }

上述代码中我们使用 deferred 确保每次订阅都是一个随机值。

当小于 0 时，抛出一个小于 0 的错误；当大于 100 时，抛出一个数值过大的错误。

在后面接入我们的 retryWhen 方法：

.retryWhen { [unowned self] (errorObservable: Observable<MyError>) -> Observable<()> in
    errorObservable
        .flatMap { error -> Observable<()> in
            switch error {
            case let .notPositive(value):
                return showAlert(title: "遇到了一个错误，是否重试？", message: "错误信息\(value) 小于 0", for: self)
                    .map { isEnsure in
                        if isEnsure {
                            return ()
                        } else {
                            throw error
                        }
                }
            case .oversize:
                return Observable.error(error)
            }
    }
}

这次采取的方案是：

当遇到小于 0 时，弹出弹窗，由用户决定是否进行重试；
当大于 100 时，不进行重试。

你可以看到我在这里指明了具体类型 (errorObservable: Observable<MyError>) ，如果遇到的是其他 Error 类型，我们将直接忽略掉。

为了获取所有的 Error ，你可以使用 Observable<Swift.Error> 。

# `catchError`

使用 catchError 也能完成类似的需求。

上层事件传递和上一小结完全一样，为了处理通用 Error ，我添加了 LocalizedError ：

/// 自定义的错误
///
/// - notPositive: 不是正数
/// - oversize: 数字过大
enum MyError: Swift.Error, LocalizedError {
    case notPositive(value: Int)
    case oversize(value: Int)

    var errorDescription: String? {
        switch self {
        case let .notPositive(value):
            return "\(value)不是正数"
        case let .oversize(value):
            return "\(value)过大"
        }
    }
}

Observable<Int>
    .deferred { () -> Observable<Int> in
        return Observable.just(Int.random(within: -100...200))
    }
    .map { value -> Int in
        if value <= 0 {
            throw MyError.notPositive(value: value)
        } else if value > 100 {
            throw MyError.oversize(value: value)
        } else {
            return value
        }
    }

我们在后面接上 catchError 和 retry ：

.catchError { (error) -> Observable<Int> in
    return Observable.create { [unowned self] observer in
        let alert = UIAlertController(title: "遇到了一个错误，重试还是使用默认值 1 替换？", message: "错误信息：\(error.localizedDescription)", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "重试", style: .cancel, handler: { _ in
            observer.on(.error(error))
        }))
        alert.addAction(UIAlertAction(title: "替换", style: .default, handler: { _ in
            observer.on(.next(1))
            observer.on(.completed)
        }))
        self.present(alert, animated: true, completion: nil)
        return Disposables.create {
            alert.dismiss(animated: true, completion: nil)
        }
    }
}
.retry()

我们在 catchError 中返回了一个弹窗 Observable ，在重试的逻辑中向下发射了 Error ，替换的逻辑中向下发射了 1 。

并在后面接上了一个 retry 。

当选择重试的时候， retry 会接到这个错误，并重新订阅。这里需要注意的是，将 retry 直接接到弹窗O bservable 后面是错误的，此时将重新订阅弹窗 Observable ，永远触发不到最上层的随机数 Observable ，你将永远收到同一个错误。

此处错误代码示例如下：

.catchError { (error) -> Observable<Int> in
    return Observable.create { [unowned self] observer in
        let alert = UIAlertController(title: "遇到了一个错误，重试还是使用默认值 1 替换？", message: "错误信息：\(error.localizedDescription)", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "重试", style: .cancel, handler: { _ in
            observer.on(.error(error))
        }))
        alert.addAction(UIAlertAction(title: "替换", style: .default, handler: { _ in
            observer.on(.next(1))
            observer.on(.completed)
        }))
        self.present(alert, animated: true, completion: nil)
        return Disposables.create {
            alert.dismiss(animated: true, completion: nil)
        }
    }
    .retry()
}

这里我还实现了一个二进制指数退避算法的错误处理，代码如下：

extension ObservableType {

    public func retryWithBinaryExponentialBackoff(maxAttemptCount: Int, interval: TimeInterval) -> Observable<Self.E> {
        return self.asObservable()
            .retryWhen { (errorObservable: Observable<Swift.Error>) -> Observable<()> in
                errorObservable
                    .scan((currentCount: 0, error: Optional<Swift.Error>.none), accumulator: { a, error in
                        return (currentCount: a.currentCount + 1, error: error)
                    })
                    .flatMap({ (currentCount, error) -> Observable<()> in
                        return ((currentCount > maxAttemptCount) ? Observable.error(error!) : Observable.just(()))
                            .delay(pow(2, Double(currentCount)) * interval, scheduler: MainScheduler.instance)
                    })
            }
    }

}

# 总结

RxSwift 为我们提供了基本的错误处理方法，我们还可以进行一定的组合得到我们特定的错误处理方案。

在使用处理各种错误时，但需要明确的是，我们想要 retry 或许 catch 哪个 Observable 的错误。

RxSwift 定制重试逻辑

# retryWhen

# catchError

# 总结

# `catchError`