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()
    }
}

将以上内容与您的链一起使用将导致“被称为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的内容。

retryWhen未按预期重新订阅源

1 个答案: