Question

这是一个非常简单的样本：

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");

        }
    });
}

控制台输出为：1,2,3，onError。但是我的预期：1,2,3,1,2,3,1,2,3，onError。

Answer 1

一旦错误发生，订阅者取消订阅者来自observable，并且如果您使用运算符重试，它将仅在运算符未在主管道中使用但在flatMap运算符中重试

这个，因为重试是在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));
}

如果您想查看更多示例，请查看https://github.com/politrons/reactive

Answer 2

retry()运算符在observable发出错误时重新订阅并执行上述过程。请参阅this。

我写了示例代码。

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

RxJava重试不使用Observer

2 个答案: