Rx java RxJava重试不使用观察者

这是一个非常简单的示例：

public static void main(String[] args) {
    Observable.from(ListUtils.asList(1, 2, 3)).retry(3).subscribe(new Observer<Integer>() {
        @Override
        public void onCompleted() {
            System.out.println("onCompleted");
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("onError");
        }

        @Override
        public void onNext(Integer integer) {
            System.out.println(integer);
            if (integer == 3)
                throw new RuntimeException("onNext exception");

        }
    });
}

publicstaticvoidmain（字符串[]args）{
从（ListUtils.asList（1,2,3））.retry（3）.订阅（newobserver（））{
@凌驾
未完成的公共无效（）{
System.out.println（“未完成”）；
}
@凌驾
公共无效申报人（可丢弃的e）{
System.out.println（“onError”）；
}
@凌驾
public void onNext（整数）{
System.out.println（整数）；
如果（整数==3）
抛出新的运行时异常（“onNext异常”）；
}
});
}

控制台输出为：1,2,3，onError。

---

但我的预期是：1,2,3,1,2,3,1,2,3，onError。

一旦发生错误，订阅者将从observable取消订阅，如果您使用operator retry，则只有在主管道中未使用该运算符，而是在flatMap运算符中使用该运算符时，才会重试

这是因为重试是在平面映射之后进行的，所以它可以工作

@Test
public void retryInFlatMap() {
    Observable.from(Arrays.asList(1, 2, 3, 4))
            .flatMap(number -> Observable.just(number)
                    .doOnNext(n -> {
                        if (n == 2) {
                            throw new NullPointerException();
                        }
                    }))
                    .retry(3)
            .subscribe(n-> System.out.println("number:"+n));
}

这张，因为是在地图后面，它不会

int cont=0;
@Test
public void retryInMap() {
    Observable.from(Arrays.asList(1, 2, 3, 4))
            .map(number ->{
                        if (cont == 2) {
                            throw new NullPointerException();
                        }
                        cont++;
                        return number;
                    })
            .retry(3)
            .subscribe(n-> System.out.println("number:"+n));
}

如果您想看到更多示例，请查看此处

retry（）

操作员在observable发出错误时重新订阅并执行上述过程。 请参阅

我编写了示例代码

Observable.from(Arrays.asList(1, 2, 3, 4))
    .flatMap(new Func1<Integer, Observable<Integer>>() {
        @Override public Observable<Integer> call(Integer integer) {
            if(integer == 4) {
                return Observable.error(new Exception());
            }
            return Observable.just(integer);
        }
    })
    // When error occurred, re-subscribe and execute above process
    // If error occurred over 2 times, Observer.onError occurred
    .retry(2)
    .subscribe(new Observer<Integer>() {
        @Override public void onCompleted() {
            System.out.println("onCompleted");
        }

        @Override public void onError(Throwable e) {
            System.out.println("onError");
        }

        @Override public void onNext(Integer integer) {
            System.out.println(integer);
        }
    });

Observable.from（Arrays.asList（1,2,3,4））
.flatMap（新函数1（）{
@覆盖公共可观察调用（整数）{
如果（整数==4）{
返回Observable.error（新异常（））；
}
返回可观测值。just（整数）；
}
})
//出现错误时，重新订阅并执行上述过程
//如果错误发生超过2次，则发生Observer.onError
.重试（2）
.订阅（新观察员）{
@覆盖已完成的公共void（）{
System.out.println（“未完成”）；
}
@覆盖公共无效onError（可丢弃的e）{
System.out.println（“onError”）；
}
@重写公共void onNext（整数）{
System.out.println（整数）；
}
});