Android从零开始学习Rxjava2（八）—— 错误处理运算符

最新推荐文章于 2020-08-12 22:20:19 发布
最新推荐文章于 2020-08-12 22:20:19 发布
阅读量389 收藏
点赞数
分类专栏： rxjava2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dyjaly/article/details/86518669
版权

错误处理运算符

有助于从Observable中恢复错误通知的操作符。Rx错误处理有两个类别的运算符：

Catch类：Catch运算符拦截来自源Observable的onError通知，而不是将其传递给任何观察者，将其替换为其他项目或项目序列，可能允许生成的Observable正常终止或根本不终止；

Retry类：如果源Observable发出错误，请重新订阅它，希望它能完成而不会出错。重试操作符通过不将该调用传递给其观察者来响应来自源Observable的onError通知，而是通过重新订阅源Observable并为其提供另一个机会来完成其序列而不会出现错误。 重试始终将下一个通知传递给其观察者，即使是以错误终止的序列，因此这会导致重复发射

Rx中有几个常见的Catch类的操作符：onErrorReturn，onErrorResumeNext，onExceptionResumeNext。
Rx中也有几个常见的Retry类的操作符：retry，retryWhen。

我们这里来一一看下：

onErrorReturn

指示Observable在遇到错误时发出特定项，然后正常终止。
Catch运算符拦截来自源Observable的onError通知，而不是将其传递给任何观察者，将其替换为其他项目或项目序列，可能允许生成的Observable正常终止或根本不终止。
onErrorReturn运算符，当源Observable发射出onError时，拦截异常并返回一个自定义的值之后正常的结束发射。
举个例子

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("1");
                observableEmitter.onNext("2");
                observableEmitter.onError(new Throwable("error"));
                observableEmitter.onNext("3");
                observableEmitter.onComplete();

            }
        }).onErrorReturn(new Function<Throwable, String>() {
            @Override
            public String apply(Throwable throwable) throws Exception {
                Log.d(TAG, " apply : " + throwable.getMessage());
                return "onErrorReturn";
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable disposable) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, " onNext : s : " + s);
            }

            @Override
            public void onError(Throwable throwable) {
                Log.d(TAG, " onError : " + throwable.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, " onComplete ");
            }
        });
    }

当源发射2后发射了error，会先触发onErrorReturn里的方法，所以打印了error，onErrorReturn拦截并通过Func返回一个值后正常结束发射，所以打印结果

onNext : s : 1
onNext : s : 2
apply : error
onNext : s : onErrorReturn
onComplete

onErrorResumeNext

源Observable在遇到错误时开始发出第二个Observable序列。
在这里插入图片描述
onErrorResumeNext方法与onErrorReturn()方法类似，都是拦截源Observable发射的onError通知。不同的是onErrorReturn拦截并返回一个自定义的值，而onErrorResumeNext拦截并返回一个新的Observable，并继续接收新的Observable发射的数据。

将上方例子稍作更改：

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("1");
                observableEmitter.onNext("2");
                observableEmitter.onError(new Throwable("error"));
                observableEmitter.onNext("3");
                observableEmitter.onComplete();

            }
        }).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> apply(Throwable throwable) throws Exception {
                Log.d(TAG, " apply : " + throwable.getMessage());
                return Observable.just("new Observable");
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable disposable) {

            }

            @Override
            public void onNext(String s) {
                Log.d(TAG, " onNext : s : " + s);
            }

            @Override
            public void onError(Throwable throwable) {
                Log.d(TAG, " onError : " + throwable.getMessage());
            }

            @Override
            public void onComplete() {
                Log.d(TAG, " onComplete ");
            }
        });
    }

打印结果：

onNext : s : 1
onNext : s : 2
apply : error
onNext : s : new Observable
onComplete

onExceptionResumeNext

指示Observable在遇到异常后继续发出项目（但不是另一种类型的throwable）
在这里插入图片描述
onExceptionResumeNext和onErrorResumeNext类似，不同的是，onExceptionResumeNext如果onError收到的Throwable不是一个Exception，它会将错误传递给观察者的onError方法，不会使用新的Observable。
举个例子

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("1");
                observableEmitter.onNext("2");
                observableEmitter.onError(new Throwable("error"));
//                observableEmitter.onError(new Exception("error"));
                observableEmitter.onNext("3");
                observableEmitter.onComplete();

            }
        }).onExceptionResumeNext(Observable.just("new Observable"))
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable disposable) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, " onNext : s : " + s);
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        Log.d(TAG, " onError : " + throwable.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, " onComplete ");
                    }
                });
    }

onError发射的是个非Exception的Error，onExceptionResumeNext不会使用新的Observable，所以打印结果

onNext : s : 1
onNext : s : 2
onError : error

如果将上方例子中此段代码按如下更改

//                observableEmitter.onError(new Throwable("error"));
                observableEmitter.onError(new Exception("error"));

onError发射的是个Exception的Error，打印结果

onNext : s : 1
onNext : s : 2
onNext : s : new Observable
onComplete

retry

在遇到错误时应尝试重新订阅源Observable。
在这里插入图片描述
retry顾名思义就是重试，遇到Error后让源Observable重新从头发射。
举个例子：

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("1");
                observableEmitter.onNext("2");
                int random = new Random().nextInt(10);
                Log.d(TAG, " subscribe : random : " + random);
                if (random >= 5)
                    observableEmitter.onError(new Throwable("error"));
                observableEmitter.onNext("3");
                observableEmitter.onComplete();

            }
        }).retry(2)
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable disposable) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, " onNext : s : " + s);
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        Log.d(TAG, " onError : " + throwable.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, " onComplete ");
                    }
                });
    }

打印结果

onNext : s : 1
onNext : s : 2
subscribe : random : 9
onNext : s : 1
onNext : s : 2
subscribe : random : 8
onNext : s : 1
onNext : s : 2
subscribe : random : 2
onNext : s : 3
onComplete

retryWhen

在这里插入图片描述
retryWhen和retry类似， 他的区别根据名字也可以知道，他可以让我们控制当xxx时才重试，retryWhen的参数是个Func，我们可以在里面做逻辑处理，如果需要重试，只需要发射一个正常的项即可触发源Observable重试，否则可以发射Error结束。
举个例子：

private void doSomeWork() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) throws Exception {
                observableEmitter.onNext("1");
                observableEmitter.onNext("2");
                int random = new Random().nextInt(10);
                Log.d(TAG, " subscribe : random : " + random);
                if (random >= 5)
                    observableEmitter.onError(new Exception("error"));
                observableEmitter.onNext("3");
                observableEmitter.onComplete();

            }
        }).retryWhen(new Function<Observable<Throwable>, ObservableSource<?>>() {
            @Override
            public ObservableSource<?> apply(Observable<Throwable> throwableObservable) throws Exception {
                return throwableObservable.flatMap(new Function<Throwable, ObservableSource<?>>() {
                    @Override
                    public ObservableSource<?> apply(Throwable throwable) throws Exception {
                        if (throwable instanceof Exception)
                            return Observable.just("4");
                        else
                            return Observable.just(throwable);
                    }
                });
            }
        })
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable disposable) {

                    }

                    @Override
                    public void onNext(String s) {
                        Log.d(TAG, " onNext : s : " + s);
                    }

                    @Override
                    public void onError(Throwable throwable) {
                        Log.d(TAG, " onError : " + throwable.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.d(TAG, " onComplete ");
                    }
                });
    }

打印结果

onNext : s : 1
onNext : s : 2
subscribe : random : 5
onNext : s : 1
onNext : s : 2
subscribe : random : 2
onNext : s : 3
onComplete

日常在处理错误异常的时候，我们可能还需要配合do操作符的方法，在某些合适的节点进行处理。这个以后再说吧。

参考资料，参考但不局限以下链接
http://reactivex.io/documentation/operators.html#transforming

YongjunDong
关注
专栏目录
PyTorch深度学习实战（2）——PyTorch基础
盼小辉丶的博客
06-04 4万+
PyTorch 是广泛应用于机器学习领域中的强大开源框架，因其易用性和高效性备受青睐。在本节中，将介绍使用 PyTorch 构建神经网络的基础知识。首先了解 PyTorch 的核心数据类型——张量对象。然后，我们将深入研究用于张量对象的各种操作。PyTorch 提供了许多帮助构建神经网络的高级方法及组件，并提供了利用 GPU 更快地训练神经网络的张量对象。
java rx.observable_Rxjava2 Observable的错误处理操作详解及实例
weixin_34786066的博客
02-26 815
简要：需求了解：Rxjava 中当数据处理派发中发生了异常 ，观察者会接受到一个 Error 的通知，那如果不想发射这个异常的通知，自己处理掉呢？答案当然是可以的，在 Rxjava 中很多操作符可用于对 Observable 发射的 onError 通知做出响应或者从错误中恢复。例如：吞掉这个错误，切换到一个备用的Observable继续发射数据吞掉这个错误然后发射默认值吞掉这个错误并立即尝试重启...
Android从零开始学习Rxjava2（七）—— 组合运算符
DYJALY的专栏
01-16 424
rxjava2组合运算符 使用多个源Observable创建单个Observable的运算符 Merge 通过合并它们的排放，将多个Observable组合成一个。合并可以交错合并的Observables发出的项目。并且任何源Observable的onError通知将立即传递给观察者并终止合并的Observable。 merge合并，就像多个进水管往水池注水，最终合成一个Observable。简...
RxJava2 系列 -1：一篇的比较全面的 RxJava2 方法总结
疾风剑豪
08-12 665
RxJava2 系列 -1：一篇的比较全面的 RxJava2 方法总结 看了许多讲解RxJava的文章，有些文章讲解的内容是基于第一个版本的，有些文章的讲解是通过比较常用的一些API和基础的概念进行讲解的。 但是每次看到RxJava的类中的几十个方法的时候，总是感觉心里没底。所以，我打算自己去专门写篇文章来从API的角度系统地梳理一下RxJava的各种方法和用法。 1、RxJava 基本 1.1 RxJava 简介 RxJava是一个在Java VM上使用可观测的序列来组成异步的、基于事件的程...
RxJava2最全面、最详细的讲解（三）
https://juejin.cn/user/1654096907477549/posts
10-22 2667
前言：不要在该奋斗的年纪去选择安逸享乐，不是每个人都能成为自己想要的样子，但是每个人都能努力成为自己想要的样子，相信自己，你能作茧自缚，最终也能破茧成蝶。 —— 致正在努力奋斗打拼的人 一、概述 RxJava如此受欢迎，是因为提供了丰富且功能强大的操作符，几乎能完成所有...
RxJava2最全面、最详细的讲解（四）
https://juejin.cn/user/1654096907477549/posts
10-24 1624
前言：及时当勉励，岁月不饶人，生命不止，奋斗不息，比自己差的人还没有放弃，比自己强的人还在努力！ 一、概述 RxJava2在第一篇文章作了详细的介绍，第二篇文章中讲解了RxJava的变换操作符，组合操作符，合并操作符；第三篇讲解了延迟、do相关、错误处理等操作符的使用，如果英文比较好而且有兴趣的可以到官网学习：ReactiveX的官方网站。下面开始继续讲解RxJava2的其他用法。（链接和...
javascript从入门到跑路—–小文的js学习笔记（5）——–js运算符—-算数、赋值、比较、一元、二元、三元运算符
01-08
javascript从入门到跑路—–小文的js学习笔记（1）———script、alert、document。write() 和 console.log 标签 … … javascript从入门到跑路—–小文的js学习笔记目录 ** 1、算术运算符：+（加） -（减）*（乘） ...
Python学习笔记——运算符
12-10
Python学习笔记——运算符 运算符: 赋值运算符 算术运算符 关系运算符 逻辑运算符 位运算
C语言—— 数据类型运算符与表达式PPT课件.pptx
10-06
C语言——数据类型运算符与表达式PPT课件 本课程主要讲解C语言中数据类型、运算符与表达式的知识点。通过本课程的学习，学生将了解C语言中各种数据类型的特点、进制转换、数值表示方法、常量与变量的定义和使用等...
javascript运算符——位运算符全面介绍
01-19
本文将介绍javascript中常常被忽视的运算符——位运算符 二进制表示　 ECMAScript中的所有数值都以IEEE-754 64位格式存储，但位操作符并不直接操作64位的值，而是以32位带符号的整数进行运算的，并且返回值也是一个...
Android从零开始学习Rxjava2（六）—— 过滤运算符
DYJALY的专栏
01-15 346
rxjava2过滤运算符 筛选源Observable发出的项的运算符。 Debounce 如果特定的时间跨度已经过去而没有发出另一个项目，则从Observable中发出这一个项目。 debounce主要是防抖。如果在短时间内连续更改并且我们只要最终结果，中间更改的数据对我们来说没有用，需要忽略掉，则debounce是很有效的一个运算符。 debounce的防抖动时间片段是在元素发射之后重新计算的...
Android从零开始学习Rxjava2（三）—— Buffer
DYJALY的专栏
11-26 677
rxjava2变换运算符 rxjava一样提供了很多变换运算符帮助我们更简单的转转发出的Observable。这些变换运算符也是我们相对来说比较常用到的，所以对于每个变换运算符我们都单独拿出来简单记录下。 Buffer 定期将Observable发出的项目收集到束中并发出这些束，而不是一次发送一个项目。 上面这句话可能难以直接理解，其实buffer顾名思义就是缓冲，rxjava提供buffer可以...
不要打破链式调用！一个极低成本的RxJava全局Error处理方案
却把清梅嗅的博客
09-23 7292
RxJava与CallbackHell 在正式铺展开本文内容之前，我们先思考一个问题： 你认为 RxJava 真的好用吗,它好用在哪？ CallbackHell，中文翻译为 回调地狱，在以往没有依赖RxJava + Retrofit进行网络请求的代码中，这种代码并不少见（比如AsyncTask），我曾有幸见识并维护了各种3层4层AsyncTask回调嵌套的项目——后来我一直拒绝阅读Async...
Rxjava2(五)错误处理
oneblue123的博客
06-06 3312
1.onErrorReturn作用遇到错误时，发送1个特殊事件 &amp; 正常终止Observable.create(new ObservableOnSubscribe&lt;Integer&gt;() { @Override public void subscribe(ObservableEmitter&lt;Integer&gt; e) throws Exception { ...
RxJava2 错误处理详解
热门推荐
刘敬兴的博客
01-28 1万+
熟悉RxJava的知道，onError跟onComplete是互斥的，出现其中一个，观察者与被观察者的关系就被中断(以下简称：管道中断)，观察者就永远不会收到来自被观察者发出的事件。 然后有些情况下，出现了错误，我们希望可以进行一些补救措施，例如： 由于网络原因或者其他原因，Http请求失败了，这个时候我们希望进行重试，又或者去读取本地的缓存数据 在使用RxJava的组合操作符进行Http并发请...
RxJava2从入门到精通-初级篇
11-08
适合所有初中级工程师，从RxJava的每个知识点进行讲解，并在每个知识点中都带有文字说明和代码例子说明。通过这次系统化的学习，您将可以完整的学习到RxJava家族的所有特性和常用的操作符，掌握操作符的使用，掌握RxJava与Rx其他第三方库的使用。可以用三句简单的话进行概括面试加分利器 = 加大录取机会加快工作效率 = 早点下班回家系统化的学习 = 能力全面提升
[Android开发] RxJava2之路七 - 错误处理操作符例子Demo
KeepStudy
02-21 9619
一、错误处理操作符列表用于对Observable发射的 onError 通知做出响应或者从错误中恢复，例如，你 可以： 吞掉这个错误，切换到一个备用的Observable继续发射数据 吞掉这个错误然后发射默认值 吞掉这个错误并立即尝试重启这个Observable 吞掉这个错误，在一些回退间隔后重启这个Observable 名称 解析 onErrorResumeNext() 指示Obs
RxJava2的错误处理（错误异常操作符）
The blog of CSDN in 杨天福
09-05 8487
onErrorReturn onErrorResumeNext（） onExceptionResumeNext（） retry（） retryUntil（） repeatWhen（） retryWhen（） onErrorReturn 遇到错误时，发送1个特殊事件 &amp; 正常终止 可捕获在它之前发生的异常 Observable.create(new O...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值