ios - retryWhen 未按预期重新订阅源

Question

我正在编写逻辑，用于每 t 秒检查一个对象的状态，直到它完成。我决定使用 retryWhen 运算符。

getObjectStatus(someObject: someObjectInstance)
    .flatMap { someObject -> Observable<SomeObject> in
        if someObject.status == .notProcessed {
            return .error(SomeObjectNotProcessed())
        } else {
            return .just(someObject)
        }
    }
    .retryWhen { errors -> Observable<Void> in
        let retry = errors.enumerated().flatMap { retryCount, error -> Observable<Void> in
            guard retryCount < statusRequestCount else {
                print("The maximum number of request has been reached.")
                return .error(error)
            }

            if error is SomeObjectNotProcessed {
                return Observable.just(Void())
                        .delay(statusRequestDelay, scheduler: BackgroundScheduler.instance)
            } else {
                return .error(error)
            }
        }

        return retry
    }
    .subscribeOn(BackgroundScheduler.instance)
    .observeOn(MainScheduler.instance)
    .subscribe(onNext: { [weak self] someObject in
        self?.someObjectProcessingSucceeded()
    }, onError: { [weak self] error in
        self?.someObjectProcessingFailed(error: error)
    })
    .disposed(by: disposeBag)

其中getObjectStatus方法创建对服务器的请求。

现在的问题是，每 t 秒使用此代码(实际上是 statusRequestDelay)，我没有向服务器发出请求。每 t 秒它都会返回相同的 someObject 实例。如果我将 getObjectStatus 替换为:

Observable.just(Void())
    .flatMap { _ in self.getObjectStatus(someObject: someObjectInstance) }

它工作得很好，这意味着它每 t 秒就向服务器发出一次请求。看起来第一个原始的 Observable 没有重复。

Answer 1

问题在于您的 getObjectStatus 函数是如何编写的。显然，它返回一个 .just 或其他一些实际上并不重试网络调用的可观察值。如果没有看到该代码，我无法给出明确的答案。

但是请注意这一点:

func getObjectStatus(someObject: Int) -> Observable<SomeObject> {
    var count = 0
    return Observable.create { observer in
        print("called getObjectStatus")
        if count < 3 {
            observer.onNext(SomeObject(status: .notProcessed))
            observer.onCompleted()
            count += 1
        }
        else {
            observer.onNext(SomeObject(status: .processed))
            observer.onCompleted()
        }
        return Disposables.create()
    }
}

将上述内容与您的链一起使用将导致“used getObjectStatus”打印 3 次。

同时:

var count = 0
func getObjectStatus(someObject: Int) -> Observable<SomeObject> {
    print("called getObjectStatus")
    if count < 3 {
        count += 1
        return Observable.just(SomeObject(status: .notProcessed))
    }
    else {
        return Observable.just(SomeObject(status: .processed))
    }
}

不会。

此处的区别在于，在后一种情况下，.just(SomeObject(status: .notProcessed)) 是重新订阅的内容，因此每次都会返回相同的内容。

将调用隐藏在 flatMap 中是可行的，因为它是被重新订阅的 .just(Void())，这意味着 flatMap 的内容被再次调用。