RxJava：以不断增加的延迟多次调用网络，忽略错误

我想为网络呼叫创建一种指数退避。 但是，与通常的退避间隔不同，我的网络呼叫应该重复几次（延迟增加），然后完成-无论网络呼叫的结果如何

例如，默认情况应如下所示：

    → wait 1s → network call → onNext(result)
    → wait 3s → network call → onNext(result)
    → wait 10s → network call → onNext(result)
    → onCompleted

    → wait 1s → network call → onNext(result)
    → wait 3s → network call error → log error
    → wait 10s → network call → onNext(result)
    → onCompleted

public Observable<Stuff> loadStuff() {
    Request request = new Request.Builder()
        .url("http://example.com/stuff").build();
    return myCall(request, Stuff.class);
}

public <T> Observable<T> myCall(Request request, Class<T> resultClass) {
    // calls OkHttp3 and parses the result
    return okhttp(request)
            .flatMap(parseResponse(resultClass));
}

当某些网络调用出现错误时，应记录这些错误，但不能中止任务本身。假设第二次网络呼叫有错误，那么它应该如下所示：

    → wait 1s → network call → onNext(result)
    → wait 3s → network call → onNext(result)
    → wait 10s → network call → onNext(result)
    → onCompleted

    → wait 1s → network call → onNext(result)
    → wait 3s → network call error → log error
    → wait 10s → network call → onNext(result)
    → onCompleted

public Observable<Stuff> loadStuff() {
    Request request = new Request.Builder()
        .url("http://example.com/stuff").build();
    return myCall(request, Stuff.class);
}

public <T> Observable<T> myCall(Request request, Class<T> resultClass) {
    // calls OkHttp3 and parses the result
    return okhttp(request)
            .flatMap(parseResponse(resultClass));
}

当所有呼叫都有错误时：

    → wait 1s → network call error → log error
    → wait 3s → network call error → log error
    → wait 10s → network call error → log error
    → onCompleted

我已经有了一个可以调用网络的Observable，代码如下所示：

    → wait 1s → network call → onNext(result)
    → wait 3s → network call → onNext(result)
    → wait 10s → network call → onNext(result)
    → onCompleted

    → wait 1s → network call → onNext(result)
    → wait 3s → network call error → log error
    → wait 10s → network call → onNext(result)
    → onCompleted

public Observable<Stuff> loadStuff() {
    Request request = new Request.Builder()
        .url("http://example.com/stuff").build();
    return myCall(request, Stuff.class);
}

public <T> Observable<T> myCall(Request request, Class<T> resultClass) {
    // calls OkHttp3 and parses the result
    return okhttp(request)
            .flatMap(parseResponse(resultClass));
}

public observeable loadStuff（）{
Request Request=newrequest.Builder（）
.url（“http://example.com/stuffbuild（）；
返回myCall（请求、Stuff.class）；
}
公共可观察myCall（请求、类resultClass）{
//调用OkHttp3并解析结果
返回okhttp（请求）
.flatMap（parseResponse（resultClass））；
}

---

我如何反复使用loadStuff（）中的Observable来实现我想要的退避间隔？

似乎可以使用RetryWhen和onErrorResumeNext来避免管道中断，在RetryWhen中，您可以返回一个具有指数延迟的可观测值，以实现您想要的结果

      @Test
public void observableOnErrorResumeNext() {
    Subscription subscription = Observable.just(null)
                                          .map(Object::toString)
                                          .doOnError(failure -> System.out.println("Error:" + failure.getCause()))
                                          .retryWhen(errors -> errors.doOnNext(o -> count++)
                                                                     .flatMap(t -> count > 3 ? Observable.error(t) : Observable.just(null)),
                                                     Schedulers.newThread())
                                          .onErrorResumeNext(t -> {
                                              System.out.println("Error after all retries:" + t.getCause());
                                              return Observable.just("I save the world for extinction!");
                                          })
                                          .subscribe(s -> System.out.println(s));
    new TestSubscriber((Observer) subscription).awaitTerminalEvent(500, TimeUnit.MILLISECONDS);
}

如果您需要查看更多示例，请查看以下内容：