RxJava 学习笔记（九） --- Error Handling 错误处理操作

最新推荐文章于 2021-09-05 20:41:24 发布
最新推荐文章于 2021-09-05 20:41:24 发布
阅读量1.8k 收藏
点赞数 2
分类专栏： 响应式编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/urrjdg/article/details/51919947
版权

1. onErrorReturn —> 指示Observable在遇到错误时发射一个特定的数据

onErrorReturn方法返回一个镜像原有Observable行为的新Observable，后者会忽略前者的onError调用，不会将错误传递给观察者，作为替代，它会发发射一个特殊的项并调用观察者的onCompleted方法。

            enter image description here

示例代码：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onErrorReturn(new Func1<Throwable, Integer>() {
            @Override
            public Integer call(Throwable throwable) {
                return 1004;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

输出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:1004 
Sequence complete.

2. onErrorResumeNext —> 指示Observable在遇到错误时发射一个数据序列

            enter image description here

onErrorResumeNext方法返回一个镜像原有Observable行为的新Observable，后者会忽略前者的onError调用，不会将错误传递给观察者，作为替代，它会开始镜像另一个，备用的Observable。

示例代码：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onErrorResumeNext(new Func1<Throwable, Observable<? extends Integer>>() {
            @Override
            public Observable<? extends Integer> call(Throwable throwable) {
                return Observable.just(100,101, 102);
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

输出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.

3. onExceptionResumeNext —> 指示Observable遇到错误时继续发射数据

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

            enter image description here

示例代码：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.onExceptionResumeNext(Observable.just(100, 101, 102)).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

输出：

Next:0 
Next:1 
Next:2 
Next:3 
Next:100 
Next:101 
Next:102 
Sequence complete.

4. retry —> 指示Observable遇到错误时重试

如果原始Observable遇到错误，重新订阅它期望它能正常终止

            enter image description here

Retry操作符不会将原始Observable的onError通知传递给观察者，它会订阅这个Observable，再给它一次机会无错误地完成它的数据序列。Retry总是传递onNext通知给观察者，由于重新订阅，可能会造成数据项重复，如上图所示。

RxJava中的实现为retry和retryWhen。

无论收到多少次onError通知，无参数版本的retry都会继续订阅并发射原始Observable。

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

还有一个版本的retry接受一个谓词函数作为参数，这个函数的两个参数是：重试次数和导致发射onError通知的Throwable。这个函数返回一个布尔值，如果返回true，retry应该再次订阅和镜像原始的Observable，如果返回false，retry会将最新的一个onError通知传递给它的观察者。

retry操作符默认在trampoline调度器上执行。

示例代码：retry(long)

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Throwable e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.retry(2).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

输出：

Next:0 
Next:1 
Next:2 
Next:3

Next:0 
Next:1 
Next:2 
Next:3

Next:0 
Next:1 
Next:2 
Next:3 
Error: this is number 4 error！

示例代码：retry(Func2)

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                if (subscriber.isUnsubscribed()) return;
                //循环输出数字
                try {
                    for (int i = 0; i < 10; i++) {
                        if (i == 4) {
                            throw new Exception("this is number 4 error！");
                        }
                        subscriber.onNext(i);
                    }
                    subscriber.onCompleted();
                } catch (Exception e) {
                    subscriber.onError(e);
                }
            }
        });

        observable.retry(new Func2<Integer, Throwable, Boolean>() {
            @Override
            public Boolean call(Integer integer, Throwable throwable) {
                return integer < 3;
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next--:" + value);
            }
        });

输出：

Next--:0
Next--:1
Next--:2
Next--:3
Next--:0
Next--:1
Next--:2
Next--:3
Next--:0
Next--:1
Next--:2
Next--:3
Error: this is number 4 error！

5. retryWhen —> 指示Observable遇到错误时，将错误传递给另一个Observable来决定是否要重新给订阅这个Observable

retryWhen和retry类似，区别是，retryWhen将onError中的Throwable传递给一个函数，这个函数产生另一个Observable，retryWhen观察它的结果再决定是不是要重新订阅原始的Observable。如果这个Observable发射了一项数据，它就重新订阅，如果这个Observable发射的是onError通知，它就将这个通知传递给观察者然后终止。

retryWhen默认在trampoline调度器上执行，你可以通过参数指定其它的调度器。

            enter image description here

示例代码：

Observable<Integer> observable = Observable.create(new Observable.OnSubscribe<Integer>() {
            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                System.out.println("subscribing");
                subscriber.onError(new RuntimeException("always fails"));
            }
        });

        observable.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
            @Override
            public Observable<?> call(Observable<? extends Throwable> observable) {
                return observable.zipWith(Observable.range(1, 3), new Func2<Throwable, Integer, Integer>() {
                    @Override
                    public Integer call(Throwable throwable, Integer integer) {
                        return integer;
                    }
                }).flatMap(new Func1<Integer, Observable<?>>() {
                    @Override
                    public Observable<?> call(Integer integer) {
                        System.out.println("delay retry by " + integer + " second(s)");
                        //每一秒中执行一次
                        return Observable.timer(integer, TimeUnit.SECONDS);
                    }
                });
            }
        }).subscribe(new Subscriber<Integer>() {
            @Override
            public void onCompleted() {
                System.out.println("Sequence complete.");
            }

            @Override
            public void onError(Throwable e) {
                System.err.println("Error: " + e.getMessage());
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Next:" + value);
            }
        });

输出:

subscribing 
delay retry by 1 second(s) 
subscribing 
delay retry by 2 second(s) 
subscribing 
delay retry by 3 second(s) 
subscribing 
Sequence complete.

可以参考 repeatWhen 和 retryWhen 操纵符 的思考， 第一篇是原文，第二篇是译文
RxJava’s repeatWhen and retryWhen, explained
【译】对RxJava中.repeatWhen()和.retryWhen()操作符的思考

李樟清
关注
专栏目录
ChatGPT和GPT-4带你选笔记本电脑
herosunly的博客
04-11 14万+
本文介绍核心内容为用好ChatGPT之准确分配角色，希望对学习和使用ChatGPT的同学们有所帮助。为了兼顾质量和速度，本专栏的更新频率为一周一到两更。 文章目录 1. 前言 2. 使用ChatGPT给出选择建议 3. 使用GPT-4给出选择建议
PS学习笔记------运用脚本及自动化批量处理
AbuXiL的博客
05-30 7293
PS学习笔记------运用脚本及自动化批量处理简单脚本运行+自动批处理多图片简单脚本运行自动批处理图片 简单脚本运行+自动批处理多图片 本次实现的功能是： 1.运用脚本在ps中将图片的文档名称到插入图片中； 2.批量在图片中加上文档名称的文字，最后自动存储。 简单脚本运行 ps中有脚本的运行方式，我们首先要编辑好脚本，在ps中打开你要进行操作的图片，运行脚本即可。 脚本编写 ，可以用自带的ExtendScript进行编写，有装ps直接在电脑搜就好； 本脚本功能是给图片加上所对应的图片名称文字，并指定了插
RxJava操作符（五）Error Handling
muximus3的博客
11-04 571
RxJava操作符（五）Error Handling  原文链接 http://blog.chinaunix.net/uid-20771867-id-5201914.html 我们知道Rxjava对错误的处理很方便，就是当有错误出现的时候就会调用Subscriber的onError方法将错误分发出去，由Subscriber自己来处理错误。这种处理的错误有其优点，也有其缺点，就是每个Subscr
Rxjava Error Handling
翟锐的博客
07-27 420
在Rxjava的使用过程中我们有时候会遇到Observable层的error or exception。当然了，对于这些错误，Rxjava给我们提供了一些方法来处理这些事情，来避免我们的业务逻辑发生混乱。所以这篇博文就给大家带来这些错误处理的机制是啥样的，其实就是几个方法的使用。 onExceptionResumeNext Instructs an ObservableSource to p...
对照Java学习Swift--错误处理（Error Handling）
谁与争锋的专栏
05-11 2749
简介在异常处理方面，Java跟Swift很相似，要么抛出异常，要么自己处理异常，但是语法有些不太一样。 抛出异常Java跟Swift都是用throws关键字，Java在小括号的后面，大括号的前面，Swift在返回值箭头的前面。 自己处理异常Java使用try catch结构，Swift使用do-catch结构，同样可以匹配多个catch块。 java中的catch块要么是系统提供的，要么是自定义的异
Rxjava 操作符之错误处理 Error Handling
sjh_389510506的博客
08-14 288
后续出一系列关于rxJava的操作符的详细教程和文档说明。参考资料有 https://github.com/ReactiveX/RxJava https://github.com/ReactiveX/RxJava/wiki/Writing-operators-for-2.0 http://reactivex.io/documentation/operators.html http://...
error handing
qq_44271529的博客
05-23 311
# Define shout_echo def shout_echo(word1, echo=1): """Concatenate echo copies of word1 and three exclamation marks at the end of the string.""" # Initialize empty strings: echo_word, shou...
RxJava之错误处理
行云间
09-05 9231
在Observable发射数据时，有时发送onError通知，导致观察者不能正常接收数据。可是，有时我们希望对Observable发射的onError通知做出响应或者从错误中恢复。此时我们该如何处理呢？下面我们了解下RxJava错误处理相关的操作符。catch流程图概述catch操作符拦截原Observable的onError通知，将它替换为其它的数据项或数据序列，让产生的Observable能够正
冰河的渗透实战笔记-冰河.pdf
05-18
冰河整理的全网首个开源的以实战案例为背景的渗透实战笔记，全书共442页，共计37万字（不计空格）。整本书的内容涵盖：Kali基础、渗透工具、木马制作、钓鱼链接生成、爆破密码、内存溢出攻击、web渗透、数据提权、...
Java JDK7学习笔记-光盘
08-20
《Java JDK7学习笔记》是作者多年来教学实践经验的总结，汇集了教学过程中学生在学习java时遇到的概念、操作、应用或认证考试等问题及解决方案。《Java JDK7学习笔记》针对java se 7新功能全面改版，无论是章节架构...
caffe学习笔记1-7-完整版-薛开宇
11-18
caffe学习笔记1-7-完整版-薛开宇
[译]RxJava 的全面介绍：Observable 类型、背压、错误处理
weixin_34026276的博客
01-28 216
原文：www.ericdecanini.com/2019/01/07/… 作者：www.ericdecanini.com/about/ 前言 RxJava 是一个不断更新的工具库，适用于除 Android 以外的许多平台的开发人员（如：RxSwift）。RxJava 最大的优势是 以不使用回调的方式处理异步操作。 相反，Observables 和 Observers 结合使用来发射数据（一次或...
Rxjava2 Observable的错误处理操作详解及实例
JiangMing-JIM的博客
12-30 1848
文章目录简要：1. Catch1.1 onErrorReturn1.2 onErrorResumeNext1.3 onExceptionResumeNext小结 简要： 需求了解： Rxjava 中当数据处理派发中发生了异常 ，观察者会接受到一个 Error 的通知，那如果不想发射这个异常的通知，自己处理掉呢？答案当然是可以的，在 Rxjava 中很多操作符可用于对 Observable 发射的 ...
RxJava的错误处理库——RxErrorHandler
weixin_38196407的博客
02-18 2482
RxJava的错误处理库——RxErrorHandler RxJava使用过程中会抛出异常以及错误，那么RxJava会结束事件处理序列，直接进入onError()对错误进行处理，而RxErrorHandler则是一个错误处理库，其使用十分的简单，只需要对RxErrorHandler进行初始化即可使用。 一、初始化 在初始化之前需要注意的一点是引用库的时候，使用的RxJava库版本不同，那么使用的R...
关于error handling的一些理解
BLSpan的博客
09-05 2420
一晃四五个月过去，发现好久没写博客了。一是因为最近这几个月事情比较多，二可能是因为懒了吧（毕竟动脑子的东西，相当耗能量和脑细胞），╮(╯▽╰)╭。不过还是要克服一下，尤其是还在段位比较低，还需要持续成长的过程中。对于程序员来说，错误处理是不可避免的，这次简单谈谈实际编程过程中的Error Handling。最后，以【5】中@大宽宽的回答作为一个总结吧。对于“正确的处理错误”？有两种不同的目标：要编写正确的代码。这里“正确”是指对任何设计上要处理的错误都必须设计处理流程。
RxJava错误处理
BoBoMEe
05-01 6685
概述Rxjava中，在错误出现的时候就会调用Subscriber的onError方法将错误分发出去，由Subscriber自己来处理错误。 但是如果每个Subscriber都处理一遍的话，工作量就会有点大了，这时候可以使用Error handling相关的操作符来集中统一地处理错误。 RxJava中错误处理的操作符为 Catch和 Retry。Catch类似于java 中的try/catch，拦
RxJava常用操作符
weixin_34198583的博客
09-19 126
RxJava 操作符 阅读本文前请先了解 RxJava 的基本使用。 参考文档： RxJava JavaDoc ReactiveX文档中文翻译 1 Observable 的创建 1.1 from( ) 转换集合为一个每次发射集合中一个元素的 Observable 对象。可用来遍历集合。 方法列表： public static &lt;T&gt; Observable&lt;T&gt;...
Error Handling 错误处理
东子的博客 细节决定成败，点滴铸就辉煌。
03-21 2375
很多操作符可用于对Observable发射的onError通知做出响应或者从错误中恢复，例如，你可以： 吞掉这个错误，切换到一个备用的Observable继续发射数据 吞掉这个错误然后发射默认值 吞掉这个错误并立即尝试重启这个Observable 吞掉这个错误，在一些回退间隔后重启这个Observable 这是操作符列表： onErrorResumeNext( ) — 指示Observable在遇到
Error and Exception Handling in Java
qq_43614606的博客
05-13 598
Error类描 述Java虚拟机内部错误(资源耗尽和系统错误等)，多数情况下无需处 理，也无法处理 Exception类描述程序 导致的错误，需要处理 异常是在程序执行过程中出现的异常事件，它会破坏程序的正常流程。 异常处 理机制将允许代码将错误或者异常事件传递给调用它的代码。 发生RuntimeException是因为您犯了一个编程错误。 任何其他异常的发生都是因为坏的事情(比如I/O错误)发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值