RX操作符之错误处理（catch[onErrorReturn、onErrorResumeNext、onExceptionResumeNext]、retry、retryWhen）

最新推荐文章于 2023-09-17 15:37:42 发布
最新推荐文章于 2023-09-17 15:37:42 发布
阅读量1.2w 收藏 5
点赞数 2
分类专栏： RX
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nicolelili1/article/details/52152155
版权

一、catch

从onError通知中恢复发射数据。Catch操作符拦截原始Observable的onError通知，将它替换为其它的数据项或数据序列，让产生的Observable能够正常终止或者根本不终止。

1.onErrorReturn

让Observable遇到错误时发射一个特殊的项并且正常终止。

        Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if(i == 3) {
                        subscriber.onError(new Throwable("ERROR"));
                    }else{
                        subscriber.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<String> mySubscriber =new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext................."+s);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable
                .onErrorReturn(new Func1<Throwable, String>() {
                    @Override
                    public String call(Throwable throwable) {
                        return "this is an error observable";
                    }
                })
                .subscribe(mySubscriber);
运行结果：


2.onErrorResumeNext

让Observable在遇到错误时开始发射第二个Observable的数据序列。

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if(i == 3) {
                        subscriber.onError(new Throwable("ERROR"));
                    }else{
                        subscriber.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<String> mySubscriber =new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext................."+s);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable
                .onErrorResumeNext(Observable.just("this is an error observable","error2"))
                .subscribe(mySubscriber);

运行结果：


3.onExceptionResumeNext

和onErrorResumeNext类似，onExceptionResumeNext方法返回一个镜像原有Observable行为的新Observable，也使用一个备用的Observable，不同的是，如果onError收到的Throwable不是一个Exception，它会将错误传递给观察者的onError方法，不会使用备用的Observable。

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if(i == 3) {
                        subscriber.onError(new Throwable("ERROR"));
                    }else{
                        subscriber.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<String> mySubscriber =new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext................."+s);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable
                .onExceptionResumeNext(Observable.just("occur an error1","occur an error2"))
                .subscribe(mySubscriber);

运行结果：



二、retry

如果原始Observable遇到错误，重新订阅它期望它能正常终止。Retry操作符不会将原始Observable的onError通知传递给观察者，它会订阅这个Observable，再给它一次机会无错误地完成它的数据序列。Retry总是传递onNext通知给观察者，由于重新订阅，可能会造成数据项重复。无论收到多少次onError通知，无参数版本的retry都会继续订阅并发射原始Observable。

接受单个count参数的retry会最多重新订阅指定的次数，如果次数超了，它不会尝试再次订阅，它会把最新的一个onError通知传递给它的观察者。

 Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if(i == 3) {
                        subscriber.onError(new Throwable("ERROR"));
                    }else{
                        subscriber.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<String> mySubscriber =new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext................."+s);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable
                .retry(2)
                .subscribe(mySubscriber);

运行结果：

三、retryWhen

retryWhen和retry类似，区别是，retryWhen将onError中的Throwable传递给一个函数，这个函数产生另一个Observable，retryWhen观察它的结果再决定是不是要重新订阅原始的Observable。如果这个Observable发射了一项数据，它就重新订阅，如果这个Observable发射的是onError通知，它就将这个通知传递给观察者然后终止。retryWhen默认在trampoline调度器上执行，你可以通过参数指定其它的调度器。

  Observable<String> observable =  Observable.create(new Observable.OnSubscribe<String>() {

            @Override
            public void call(Subscriber<? super String> subscriber) {
                for (int i = 0; i < 5; i++) {
                    if(i == 3) {
                        subscriber.onError(new Throwable("ERROR"));
                    }else{
                        subscriber.onNext(i + "");
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (Exception e) {

                    }
                }
                subscriber.onCompleted();
            }
        });

        Subscriber<String> mySubscriber =new Subscriber<String>() {
            @Override
            public void onNext(String s) {
                Log.e(TAG,"onNext................."+s);
            }

            @Override
            public void onCompleted() {
                Log.e(TAG, "onCompleted.................");
            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, "onError.....................");
            }
        };

        observable
                .retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
                    @Override public Observable<?> call(Observable<? extends Throwable> errors) {

                        return errors.flatMap(new Func1<Throwable, Observable<?>>() {
                            @Override public Observable<?> call(Throwable error) {

                                // For IOExceptions, we  retry
                                if (error instanceof IOException) {
                                    return Observable.just(null);
                                }

                                // For anything else, don't retry
                                return Observable.error(error);
                            }
                        });
                    }
                })
                .subscribe(mySubscriber);

运行结果：



nicolelili1
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rxjava：错误处理操作符（2）： onErrorReturn 、 onErrorResumeNext 、onExceptionResumeNext
火星男孩的分享空间
09-24 5369
//让Observable遇到错误时发射一个特殊的项并且正常终止， // onErrorRetrun能够捕获在它之前发生的异常，它之后流中的操作发生的异常就它就不会管了。 public void onErrorReturn() { Observable.create(getObservableOnSubscribe()) .subscribeOn(Scheduler...
七、RxJava异常处理onErrorReturn,onErrorResumeNext,onErrorResumeWith,retry
sunweihao2019的博客
11-26 3513
1.项目地址 在MainActivity7 2.讲解 需要在emitter.onError里面执行抛异常，这样才能抛异常，不报错。如 emitter.onError(new IllegalAccessException("我要报错了，你小心点，哈哈哈！")); 1.onErrorReturn 这个报错后，下游不会接收到消息，可以发射一个错误提示给下游，如发射一个404 // 用emitter.onError抛出异常的话，上游（观察者）还是会执行完。onErrorReturn会使下游（观察者）
WebFlux异常处理：onErrorReturn和onErrorResume
天然玩家的博客
09-17 1939
WebFlux捕获异常：onErrorReturn和onErrorResume，使用时需要注意异常的包装。
详解 Webflux 中的 onErrorResume 和 onErrorReturn
ywb201314的专栏
05-15 8281
webflux 并不算一门新技术，它出自 Spring，所以 Spring 中的一些特性它都有，包括 SpringMVC 中的一些注解它也可以沿用。没看过 webflux 教程的，可以参考我前面关于 webflux 教程的一些文章。本文我们来学习 webflux 中两个比较特独的方法 onErrorResume 和 onErrorReturn。 先回忆一下，我们在 SpringMVC 或者 SpringBoot 中常用的处理异常的方式有：@RestControllerAdvice、@ExceptionHa
rxjava : onErrorReturn / doOnNext / doOnEach / doFinally
火星男孩的分享空间
09-21 1471
private void doTest() { Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() { @Override public void subscribe(ObservableEmitter<...
Python pip install之SSL异常处理操作
12-17
Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by ‘SSLError(SSLError(1, ‘[SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed (_ssl.c:...
RxJava 操作符 图片
03-31
8. **Retry** 操作符：如果 Observable 在执行过程中遇到错误，它可以自动重试。 9. **Delay** 操作符：它可以延迟 Observable 的发射时间，或者仅在特定延迟后开始发射。 10. **Buffer** 操作符：它将连续的数据...
kotlin-retry：用于重试可能失败的操作的高阶函数
02-04
对于可能出现异常的IO操作，如网络请求、文件读写，`kotlin-retry`可以很好地处理这些情况。通过将IO操作封装在一个函数中，然后传递给`retry`，就可以在出现异常时自动重试。 5. **自定义重试条件**： `kotlin-...
message：自动真机调试 Error: Aborted. Please retry appid: wxcc22649cfe0
最新发布
02-07
message：自动真机调试 Error: Aborted. Please retry appid: wxcc22649cfe0db7b5 openid: o6zAJs9SgDdvm3T5BkTODqbUIJB4 ideVersion: 1.06.2401020 osType: win32-x64 time: 2024-02-07 23:12:31
重试框架spring-retry以及guava-retry的使用
08-14
重试框架在IT行业中扮演着重要的角色，尤其是在网络通信、数据处理等易受不稳定因素影响的场景下。本文将深入探讨两个常用的重试框架：Spring Retry和Guava Retry，并通过一个名为`retry-starter`的Spring Boot项目...
on error resume next用法
热门推荐
博客
08-11 2万+
on error resume next用法 转载源 作者：xuxujian VBScript语言提供了两个语句和一个对象来处理"运行时错误"，如下所示： On Error Resume Next语句 On Error Goto 0语句 Err对象 简单介绍一下On Error Resume Next，On Error Goto 0，Err这三者 On Error Resume Next语句和On Error Goto 0语句指明了当出现"运行时错误"时的处理方式。 当加上On Error Resume
Reactor 之 onErrorContinue 和 onErrorResume
伍六七的博客
08-22 1054
发生错误了，怎么办？继续呗~
java rx.observable_Rxjava2 Observable的错误处理操作详解及实例
weixin_34786066的博客
02-26 785
简要：需求了解：Rxjava 中当数据处理派发中发生了异常 ，观察者会接受到一个 Error 的通知，那如果不想发射这个异常的通知，自己处理掉呢？答案当然是可以的，在 Rxjava 中很多操作符可用于对 Observable 发射的 onError 通知做出响应或者从错误中恢复。例如：吞掉这个错误，切换到一个备用的Observable继续发射数据吞掉这个错误然后发射默认值吞掉这个错误并立即尝试重启...
RxJava（五）onErrorResumeNext 操作符实现 app 与服务器间 token 机制
Chiclaim
05-29 2万+
RxJava系列文章目录导读： 一、RxJava create操作符的用法和源码分析 二、RxJava map操作符用法详解 三、RxJava flatMap操作符用法详解 四、RxJava concatMap操作符用法详解 五、RxJava onErrorResumeNext操作符实现app与服务器间token机制 六、RxJava retryWhen操作符...
RxJava（五）RxJava onErrorResumeNext操作符实现app与服务器间token机制
android开发笔记
06-18 732
一、需求场景： 在开发App的时候, 很多公司的提api接口, 请求的的时候都需要带有token, 该token在用户第一次启动app或者登陆的时候去获取. 以后的所有请求都需要带该Token 如果token过期, 服务器将返回401, 这时候就需要去请求获取token的接口, 如果获取成功接着在请求原来的接口. 这个时候就两个回调的嵌套了. 实现起来比较费劲, 而且也不够优雅. 代码的可维护...
On Error Resume Next是什么意思
小发猫
07-08 5074
   On Error Resume Next的意思是如果发生错误就继续直接执行出错语句下面的那句。一般的，如果出错，VB会报告并停止运行，但有时错误并不严重，不会产生严重影响，你可以在可能出错的语句前面加上这句。但是如果错误很严重，会影响到后续语句，就不要使用这个方法了。
RXJava 全面学习笔记(中)
Sincerity_的博客
12-20 259
目录 文章目录线程控制(切换/调度)功能性的操作符过滤操作符功能防抖联想搜索功能条件/布尔操作符 线程控制(切换/调度) 线程控制的作用: 指定被观察者(observable) 和observer(观察者)的工作线程类型 线程控制的背景: 在RxJava模型中,被观察者(observable)和观察者(observer)的工作线程=创建自身的线程 即若被观察者在主线程中被创建,那么他们的...
RxJava2从入门到精通-初级篇
11-08
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
Android-学习笔记-RxJava操作符(二)
zuochunsheng的博客
11-15 209
5 错误处理 onErrorResumeNext( ) — 指示Observable在遇到错误时发射一个数据序列 onErrorReturn( ) — 指示Observable在遇到错误时发射一个特定的数据 onExceptionResumeNext( ) — 指示Observable遇到错误时继续发射数据 retry( ) — 指示Observable遇到错误时重试。Retry操作符不会将原始...
try catch retry
02-02
在PHP中，try-catch-retry是一种处理异常的常见模式。它允许我们在捕获异常后重新尝试执行代码块。以下是一个示例： ```php $attempts = 0; $maxAttempts = 3; do { try { executeCode(); break; // 如果执行成功，跳出循环 } catch (Exception $e) { $attempts++; sleep(1); if ($attempts >= $maxAttempts) { throw $e; // 如果达到最大尝试次数，抛出异常 } continue; // 如果捕获到异常，继续循环 } } while ($attempts < $maxAttempts); ``` 在上面的示例中，我们使用了一个do-while循环来重试执行代码块。在每次循环中，我们尝试执行代码，如果成功则跳出循环。如果捕获到异常，我们增加尝试次数并等待1秒钟，然后继续循环。如果达到最大尝试次数，我们抛出异常。 请注意，上述示例中的`executeCode()`是一个占位符，你需要将其替换为你要执行的实际代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值