Rxjava2(五)错误处理

最新推荐文章于 2025-09-15 01:28:57 发布
转载 最新推荐文章于 2025-09-15 01:28:57 发布 · 3.3k 阅读 · 1

本文详细介绍了RxJava中处理错误的各种方法，包括onErrorReturn、onErrorResumeNext、onExceptionResumeNext等操作符的使用场景及区别，并展示了如何通过retry系列操作符实现错误重试。

1.onErrorReturn

  • 作用
    遇到错误时，发送1个特殊事件 & 正常终止

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("发生错误了"));
    }
}).onErrorReturn(new Function<Throwable, Integer>() {
    @Override
    public Integer apply(Throwable throwable) throws Exception {
        LogUtils.syso("=====在onErrorReturn处理了错误:============"+throwable.getMessage());
        return 666;
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError==========");
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});

2.onErrorResumeNext

  • 作用
    遇到错误时，发送1个新的Observable

注：

  1. onErrorResumeNext（）拦截的错误 = Throwable；若需拦截Exception请用onExceptionResumeNext（）
  2. 若onErrorResumeNext（）拦截的错误 = Exception，则会将错误传递给观察者的onError方法

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("发生错误了"));
    }
}).onErrorResumeNext(new Function<Throwable, ObservableSource<? extends Integer>>() {
    @Override
    public ObservableSource<? extends Integer> apply(Throwable throwable) throws Exception {
        LogUtils.syso("=====onErrorResumeNext============"+throwable.getMessage());
        return Observable.just(5,6);
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError==========");
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});

3. onExceptionResumeNext

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new NullPointerException());
    }
}).onExceptionResumeNext(new Observable<Integer>() {
    @Override
    protected void subscribeActual(Observer<? super Integer> observer) {
        LogUtils.syso("=====onExceptionResumeNext============");
        observer.onNext(10);
        observer.onNext(11);
        observer.onComplete();
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});


4.retry

  • 作用
    重试，即当出现错误时，让被观察者（Observable）重新发射数据
  1. 接收到 onError（）时，重新订阅 & 发送事件
  2. Throwable 和 Exception都可拦截
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new NullPointerException());
    }
})
        //若一直错误，则一直重新发送
        .retry()
        .subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});
Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("出现错误"));
    }
})        //重试次数

        .retry(3)
        .subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("出现错误"));
    }
})
        // 作用：出现错误后，判断是否需要重新发送数据（若需要重新发送& 持续遇到错误，则持续重试）
         // 参数 = 判断逻辑
     .retry(new Predicate<Throwable>() {
         @Override
         public boolean test(Throwable throwable) throws Exception {
             //返回false = 不重新重新发送数据 & 调用观察者的onError结束
             //返回true = 重新发送请求（若持续遇到错误，就持续重新发送）
             return true;
         }
     })
        .subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});
//   5. retry（long time,Predicate predicate）
// 作用：出现错误后，判断是否需要重新发送数据（具备重试次数限制
// 参数 = 设置重试次数 & 判断逻辑
       Observable.create(new ObservableOnSubscribe<Integer>() {
           @Override
           public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Throwable("出现错误"));
           }
       })
               // 拦截错误后，判断是否需要重新发送请求
            .retry(2,new Predicate<Throwable>() {
                @Override
                public boolean test(Throwable throwable) throws Exception {
                    // 捕获异常
                    LogUtils.syso("=====retry错误============"+throwable.toString());
                    //返回false = 不重新重新发送数据 & 调用观察者的onError（）结束
                    //返回true = 重新发送请求（最多重新发送3次）


                    return true;
                }
            })
               .subscribe(new Observer<Integer>() {
           @Override
           public void onSubscribe(Disposable d) {
            LogUtils.syso("=====onSubscribe============");
           }

           @Override
           public void onNext(Integer integer) {
               LogUtils.syso("=======onNext=========="+integer);
           }

           @Override
           public void onError(Throwable e) {
               LogUtils.syso("=======onError=========="+e.getMessage());
           }

           @Override
           public void onComplete() {
               LogUtils.syso("=======onComplete==========");
           }
       });

//   5. retry（long time,Predicate predicate）
// 作用：出现错误后，判断是否需要重新发送数据（具备重试次数限制
// 参数 = 设置重试次数 & 判断逻辑
       Observable.create(new ObservableOnSubscribe<Integer>() {
           @Override
           public void subscribe(ObservableEmitter<Integer> e) throws Exception {
                e.onNext(1);
                e.onNext(2);
                e.onError(new Throwable("出现错误"));
           }
       })
            .retry(new BiPredicate<Integer, Throwable>() {
                @Override
                public boolean test(Integer integer, Throwable throwable) throws Exception {
                    // 捕获异常
                    LogUtils.syso("=====异常错误============"+throwable.toString());
                    // 获取当前重试次数
                    LogUtils.syso("=====当前重试次数============"+integer);
                    //返回false = 不重新重新发送数据 & 调用观察者的onError结束
                    //返回true = 重新发送请求（若持续遇到错误，就持续重新发送）

                    return true;
                }
            })
               .subscribe(new Observer<Integer>() {
           @Override
           public void onSubscribe(Disposable d) {
            LogUtils.syso("=====onSubscribe============");
           }

           @Override
           public void onNext(Integer integer) {
               LogUtils.syso("=======onNext=========="+integer);
           }

           @Override
           public void onError(Throwable e) {
               LogUtils.syso("=======onError=========="+e.getMessage());
           }
                
           @Override
           public void onComplete() {
               LogUtils.syso("=======onComplete==========");
           }
       });

retryUntil

  • 作用
    出现错误后，判断是否需要重新发送数据
  1. 若需要重新发送 & 持续遇到错误，则持续重试
  2. 作用类似于retry（Predicate predicate）
  • 具体使用
    具体使用类似于retry（Predicate predicate），唯一区别：返回 true 则不重新发送数据事件

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("出现错误"));
    }
})
        //具体使用类似于retry（Predicate predicate），唯一区别：返回 true 则不重新发送数据事件
    .retryUntil(new BooleanSupplier() {
        @Override
        public boolean getAsBoolean() throws Exception {
            return true;
        }
    })
        .subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});

retrywhen

  • 作用
    遇到错误时，将发生的错误传递给一个新的被观察者（Observable），并决定是否需要重新订阅原始被观察者（Observable）& 发送事件
retryWhen 是在抛出异常的情况下调用的，上面的代码也告诉了我们，在 retryWhen 里面是将 throwable 传进去了了。那应该怎么取这个异常呢？我们可以通过 flatmap 做个转换。

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> e) throws Exception {
         e.onNext(1);
         e.onNext(2);
         e.onError(new Throwable("出现错误"));
        e.onNext(3);
    }
})
     .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 {
                     return Observable.error(new Throwable("retryWhen终止啦"));
                 }
             });
         }
     })
        .subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable d) {
     LogUtils.syso("=====onSubscribe============");
    }

    @Override
    public void onNext(Integer integer) {
        LogUtils.syso("=======onNext=========="+integer);
    }

    @Override
    public void onError(Throwable e) {
        LogUtils.syso("=======onError=========="+e.getMessage());
    }

    @Override
    public void onComplete() {
        LogUtils.syso("=======onComplete==========");
    }
});

  1. source.retryWhen(new Func1<Observable<? extends Throwable>, Observable<?>>() {
  2. @Override
  3. public Observable<?> call(Observable<? extends Throwable> observable) {
  4. return observable.flatMap(new Func1<Throwable, Observable<?>>() {
  5. @Override
  6. public Observable<?> call(Throwable throwable) {
  7. ......//在这处我们可以针对不同的异常做一些处理，比如中断重试
  8. return Observable.error(throwable);
  9. }
  10. });
  11. }
  12. });

RxJava之错误处理
行云间
09-05 9426
在Observable发射数据时，有时发送onError通知，导致观察者不能正常接收数据。可是，有时我们希望对Observable发射的onError通知做出响应或者从错误中恢复。此时我们该如何处理呢？下面我们了解下RxJava错误处理相关的操作符。catch流程图概述catch操作符拦截原Observable的onError通知，将它替换为其它的数据项或数据序列，让产生的Observable能够正
RxJava2配置及使用详解
08-30
RxJava2 是一个功能强大且流行的响应式编程库，用于处理异步数据流。它基于观察者模式，实现了事件的异步处理。RxJava2 的配置和使用涉及到多个方面，包括 Observable、Observer、Emitter、Disposable 等概念。 ...
Retrofit2+Rxjava2网络请求异常统一封装处理
04-15
该工具类是对Retrofit2+Rxjava2网络请求异常统一封装处理，将onError(Throwable e)中得异常转化成具体的错误信息。除了提示用户以外，还方便开发者准确定位Bug的所在。
RxJava2的错误处理（错误异常操作符）
The blog of 优快云 in 杨天福
09-05 8567
onErrorReturn onErrorResumeNext（） onExceptionResumeNext（） retry（） retryUntil（） repeatWhen（） retryWhen（） onErrorReturn 遇到错误时，发送1个特殊事件 &amp; 正常终止 可捕获在它之前发生的异常 Observable.create(new O...
Java异常：从编译错误到运行时异常
最新发布
m0_74816372的博客
09-15 954
编译时错误是指在源代码编译成字节码过程中发现的错误。这些错误阻止了.java文件成功编译为.class文件，通常是由于语法违规或基本的语义问题导致的。逻辑错误是最难以发现的错误类型，程序能够正常运行且不抛出异常，但产生的结果与预期不符。典型场景数据处理算法错误业务逻辑条件判断错误数据清洗规则错误数据库查询条件错误// 逻辑错误示例：字符串处理// 错误逻辑：忽略了空格处理// 如果输入是"123 4567 8901"就会验证失败// 修正版本// 移除所有空格后再验证编译时错误。
RxJava处理业务异常的几种方式
Java与Android技术栈
11-09 572
关于异常Java的异常可以分为两种：运行时异常和检查性异常。运行时异常： RuntimeException类及其子类都被称为运行时异常，这种异常的特点是Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过。检查性异常： 除了RuntimeException及其子类以外，其他的Exception
java rxjava zip_RxJava2问题：Zip并行处理多个服务时如何处理错误？
weixin_39582708的博客
02-28 603
假设我们有3个服务，employeeTitle，employeeName，employeeLocation . 如果所有服务三个服务抛出employeeTitle错误，employeeName和employeeLocation只会抛出1个错误？根据文档，这应该是行为是正确的吗？如果只有employeeTitle抛出错误而其他服务成功，会发生什么？根据我的理解，如果employeeTitle抛出异常...
谈谈RxJava2中的异常及处理方法
08-25
确保为每个`Observer`提供`onError()`回调，或者使用适当的错误处理操作符，同时考虑线程上下文，这样能有效地管理和防止异常导致的程序崩溃。在实际开发中，良好的异常处理不仅能够提高应用的稳定性，还能提供更好...
Retrofit2+Rxjava2+MVP demo
12-01
RxJava2与Retrofit结合使用时，可以实现复杂的网络请求调度和错误处理，如线程切换、订阅/取消订阅管理、错误处理等，使代码更加简洁和易于维护。 【MVP（Model-View-Presenter）架构】 MVP是一种软件设计模式，常...
rxjava2pdf
11-27
**错误处理** RxJava2通过`onError()`方法处理异常，如果未处理，异常会终止整个数据流。可以使用`onErrorResumeNext()`或`onErrorReturn()`来捕获并处理错误，或者使用`Observable.onErrorThrow()`将错误转换为另...
rxjava：错误处理操作符（2）： onErrorReturn 、 onErrorResumeNext 、onExceptionResumeNext
火星男孩的分享空间
09-24 5718
//让Observable遇到错误时发射一个特殊的项并且正常终止， // onErrorRetrun能够捕获在它之前发生的异常，它之后流中的操作发生的异常就它就不会管了。 public void onErrorReturn() { Observable.create(getObservableOnSubscribe()) .subscribeOn(Scheduler...
Rxjava的onError方法定位空指针
liangfeng093的博客
01-31 787
Rxjava的onError方法定位空指针　　最近一直在使用kotlin+Rxjava写项目。碰到一个空指针（那个null是后来定位到了打印出来的）。情况如下：override fun onError(e: Throwable) { Log.e(TAG, "onError:" + e) }　　空指针？小意思。仔细一看：没有定位？ 　　没有定位！！！ 　　没有定位！！！
rxjava2代码实战2--zip操作符
秦时明月
12-04 1833
zip操作符将两个或多个Observable合并为一个并将最后的结果返回代码实战：网络请求1得到用户的ID 网络请求2得到用户的头像 ID和头像都得到之后返回给客户端效果图：这里使用了我的一个网络访问框架：请先理解这个网络访问框架再往下看哦(^__^) retrofit2.0+okhttp3+rxjava的封装（简单好用） - 优快云博客 http://blog.csdn.net/baidu
RxJava2.0
riqthen的博客
06-05 993
两个对象，一个行为： Observable的构造（静态方法）： 操作符 其他操作符 注意 实践 参考： RxJava 只看这一篇文章就够了 (上) 这可能是最好的RxJava 2.x 入门教程（一） 两个对象，一个行为： Observable Observer subscribe Disposable subscribe = observable.subscribe(o...
RxJava中的错误处理
燧木博客
03-31 1447
在RxJava中我们可以很方便地处理异常，只要加上onError即可。不过，如果异常发生在操作符内部，比如flatMap，那我们怎么把这个异常传递给onError呢。
Rxjava(结合类)-Zip
new_abc的专栏
11-01 3908
通过一个函数将多个Observables的发射物结合到一起，基于这个函数的结果为每个结合体发 射单个数据项。 Zip 操作符返回一个Obversable，它使用这个函数按顺序结合两个或多个Observables发射 的数据项，然后它发射这个函数返回的结果。它按照严格的顺序应用这个函数。它只发射与 发射数据项最少的那个Observable一样多的数据 demo
java rxjava zip_RxJava操作符---zip
weixin_42521558的博客
02-28 547
简介zip操作符用于将多个数据源合并，并生成一个新的数据源。新生成的数据源严格按照合并前的数据源的数据发射顺序，并且新数据源的数据个数等于合并前发射数据个数最少的那个数据源的数据个数。zip(图片来源于官方文档).png举个例子测试场景@Testfun zip() {val observable_1 = Observable.fromIterable(listOf(1, 2))val observ...
对于RxJava的map操作符的源码解读
chenjimou的博客
12-06 305
map操作符在RxJava中是经常被使用的一个操作符，那么在使用map操作符的时候源码是怎么实现这一功能的呢？ 先上一段代码 Observable.create(new ObservableOnSubscribe<String>() { @Override public void subscribe(ObservableEmitter<String> emitter) throws Exception {
Android RxJava2(五)功能操作符
好好学习 天天向上
06-07 1061
Rxjava由于其基于事件流的链式调用、逻辑简洁 &amp;amp;amp;amp; 使用简单的特点，深受各大 Android开发者的欢迎。因此在学习过程中全面的了解了下RxJava的功能操作符 delay() doOnEach() doOnNext() doAfterNext() doOnComplete() doOnEach() doOnEach() doOnEach() doOnEach() doOn...
RxJava2异常处理深度解析
3. `subscribe(Consumer<T> onNext, Consumer<Throwable> onError)`: 添加了错误处理回调，当出现异常时，会调用 `onError` 方法。 4. `subscribe(Consumer<T> onNext, Consumer<Throwable> onError, Action ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值