rxjava-重试 - 繁殖重试的易曲误差

Question

我正在努力理解 retryWhen。

我的用例就是以下内容：

• 我有一个主要可观察的
• 如果发生错误，我想执行
之间的不同可观察到的（也有不同的结果）
• 如果第二个可观察到的成功，我想重新执行原件可观察的一次（如果在第一次重试期间发生错误，我不想再重试）
• 如果第二个可观察到的不成功，我想传播主要可观察的订阅者的误差

我该怎么做？

已经谢谢你！

---

更新
到目前为止，我尝试的是

public class RetryTest {
  private int i = 0;
  @Test
  public void testRetry() {
      Observable
              .create((Observable.OnSubscribe<String>) subscriber -> {
                  if (i == 0) {
                      i++;
                      throw new RuntimeException("Main error");
                  } else {
                      subscriber.onNext("Main success");
                      subscriber.onCompleted();
                  }
              })
              .retryWhen(observable -> {
                  // HERE IS WHERE I NEED HELP, i need something like:
                  Observable.just("Error handling observable")
                          .subscribe(new Subscriber<String>() {
                              @Override
                              public void onCompleted() {
                                  // Do retry ONCE
                              }
                              @Override
                              public void onError(Throwable e) {
                                  // Propagate error
                              }
                              @Override
                              public void onNext(String s) {
                                  // Nothing to do here
                              }
                          });
              })
              .subscribe(new Subscriber<String>() {
                  @Override
                  public void onCompleted() {
                      System.out.println("onCompleted");
                  }
                  @Override
                  public void onError(Throwable e) {
                      System.out.println("onError: " + e);
                  }
                  @Override
                  public void onNext(String s) {
                      System.out.println("onNext: " + s);
                  }
              });
  }
}

Answer 1

有更简单的解决方案。在您的情况下，您不需要retryWhen操作员，请改用onErrorResumeNext：

Observable mainObservable = Observable.just("Your main Observable");
Observable secondObservable = Observable.just("Your second Observable");
mainObservable
        .onErrorResumeNext(o1 -> secondObservable.flatMap(o2 -> mainObservable))
        .subscribe();

此处onErrorResumeNext拦截了错误并执行第二个可观察的可观察，然后可观察到。如果有错误 - 它将在下游传播。所有符合您的标准。