RxJava-操作符-mergeDelayError使用

于 2024-08-21 09:23:33 发布
阅读量242 收藏 5
点赞数 4
分类专栏： 第三方框架 文章标签： rxjava echarts android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/li1500742101/article/details/141380092
版权

说明

  • 合并多个源Observable的事件，事件不是按照顺序被发射（如需顺序使用concat操作符）。
  • Error事件被延迟发射，针对的是源Observable中的Error事件，多个源Observable都有Error时，会合并Error事件。
  • 执行结束
    • 正常执行所有事件，onComplete()代表执行结束。
    • 有Error事件时，onError()代表执行结束。

Error事件位置以及类型

Error事件需要在源Observable中才会被延迟发射。

一个源Observable 有Error事件，onError()中接收到的是实际的错误类型，不是CompositeException类型。

多个源Observable 有Error事件时，onError()中接收到的CompositeException类型，此类型是个数组。

案例

错误不在源Observable中，不会被延迟发射

Observable<Integer> odds = Observable.just(1, 3, 5);
Observable<Integer> evens = Observable.just(2, 4, 6);

Observable.mergeDelayError(odds, evens)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                //此处会产生错误，错误在mergeDelayError后面，没有在源Observable中（odds，evens）中，
                //Error不会被延迟
                if (integer == 3) return null;
                return integer;
            }
        })
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer);
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "接收到异常");
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

错误在源Observable中，会被延迟发射

Observable<Integer> odds = Observable.just(1, 3, 5)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                //此处会产生错误，错误在源Observable中，会被延迟
                if (integer == 3) return null;
                return integer;
            }
        });
Observable<Integer> evens = Observable.just(2, 4, 6)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer;
            }
        });

Observable.mergeDelayError(odds, evens)
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

多个源Observable中有Error，onError(）中的类型是CompositeException

Observable<Integer> odds = Observable.just(1, 3, 5)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                //此处会产生错误，错误在源Observable中，会被延迟
                if (integer == 3) return null;
                return integer;
            }
        });
Observable<Integer> evens = Observable.just(2, 4, 6)
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                //此处会产生错误，错误在源Observable中，会被延迟
                if (integer == 4) return null;
                return integer;
            }
        });

Observable.mergeDelayError(odds, evens)
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
                if (e instanceof CompositeException) { //源Observable 异常
                    CompositeException compositeException = (CompositeException) e;
                    List<Throwable> execptionList = compositeException.getExceptions();
                    Log.e(TAG, "源Observable 异常数量" +  execptionList.size());
                }
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

线程切换位置

线程切换需要在源Observable中完成。

线程切换不在源Observable中执行，源Observable中没有Error事件时正常，如果放在操作符后，会影响Error事件的延迟。

案例

源Observable中没有Error事件，线程切换在mergeDelayError操作符后。（正常）

Observable<Integer> odds = Observable.just(1, 3, 5)
        .subscribeOn(Schedulers.io()) //子线程执行 源Observable
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                Log.e(TAG, "改变：" + Thread.currentThread());
                return integer+1;
            }
        });
Observable<Integer> evens = Observable.just(2, 4, 6)
        .subscribeOn(Schedulers.io()) //子线程执行 源Observable
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                Log.e(TAG, "改变：" + Thread.currentThread());
                return integer+1;
            }
        });

Observable.mergeDelayError(odds, evens)
        .observeOn(AndroidSchedulers.mainThread()) // 非缘Observable中切换主线程
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

源Observable中有Error事件，线程切换在mergeDelayError操作符后。（异常）

只能接受到一个异常数据，接收不到其他事件的数据

Observable<Integer> odds = Observable.just(1, 3, 5)
        .subscribeOn(Schedulers.io()) //子线程执行 源Observable
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                Log.e(TAG, "改变：" + Thread.currentThread());
                if (integer == 3) return null; //此处发生错误
                return integer+1;
            }
        });
Observable<Integer> evens = Observable.just(2, 4, 6)
        .subscribeOn(Schedulers.io()) //子线程执行 源Observable
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                Log.e(TAG, "改变：" + Thread.currentThread());
                if (integer == 2) return null; //此处发生错误
                return integer+1;
            }
        });

Observable.mergeDelayError(odds, evens)
        .observeOn(AndroidSchedulers.mainThread()) //切换主线程
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

线程切换在源Observable执行，源Observable中无Error事件（正常）

Observable<Integer> odds = Observable.just(1, 3, 5)
                .subscribeOn(Schedulers.io()) //源Observable 切换线程
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
//                        Log.e(TAG, "改变：" + Thread.currentThread());
                        return integer+1;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread());//源Observable 切换线程
        Observable<Integer> evens = Observable.just(2, 4, 6)
                .subscribeOn(Schedulers.io())//源Observable 切换线程
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
//                        Log.e(TAG, "改变：" + Thread.currentThread());
                        return integer+1;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread()); //源Observable 切换线程

        Observable.mergeDelayError(odds, evens)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
                    }
                }, new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
                    }
                });

线程切换在源Observable执行，源Observable中有Error事件（正常）

 Observable<Integer> odds = Observable.just(1, 3, 5)
                .subscribeOn(Schedulers.io()) //源Observable 切换线程
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
//                        Log.e(TAG, "改变：" + Thread.currentThread());
                        if (integer == 3) return null;//此处发生错误
                        return integer;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread()); //源Observable 切换线程
        Observable<Integer> evens = Observable.just(2, 4, 6)
                .subscribeOn(Schedulers.io())//源Observable 切换线程
                .map(new Function<Integer, Integer>() {
                    @Override
                    public Integer apply(Integer integer) throws Exception {
//                        Log.e(TAG, "改变：" + Thread.currentThread());
                        return integer;
                    }
                })
                .observeOn(AndroidSchedulers.mainThread());//源Observable 切换线程

        Observable.mergeDelayError(odds, evens)
                .subscribe(new Consumer<Integer>() {
                    @Override
                    public void accept(Integer integer) throws Exception {
                        Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
                    }
                }, new Consumer<Throwable>() {
                    @Override
                    public void accept(Throwable throwable) throws Exception {
                        Log.e(TAG, "接收到异常" + " Thread" + Thread.currentThread());
                    }
                }, new Action() {
                    @Override
                    public void run() throws Exception {
                        Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
                    }
                }, new Consumer<Disposable>() {
                    @Override
                    public void accept(Disposable disposable) throws Exception {
                        Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
                    }
                });

异常处理

源Observable的异常，单独处理，使用源Observable的doOnError()，合并处理使用订阅者的doOnError()。

Observable<Integer> odds = Observable.just(1, 3, 5)
        .subscribeOn(Schedulers.io())
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                if (integer == 3) return null;//此处有错误
                return integer;
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .doOnError(new Consumer<Throwable>() { //异常被捕获，该Observable其他事件不会被接收
            @Override
            public void accept(Throwable throwable) throws Exception {
                isError1 = true;
                Log.e(TAG, "接收到异常1");
            }
        });
Observable<Integer> evens = Observable.just(2, 4, 6)
        .subscribeOn(Schedulers.io())
        .map(new Function<Integer, Integer>() {
            @Override
            public Integer apply(Integer integer) throws Exception {
                return integer;
            }
        })
        .observeOn(AndroidSchedulers.mainThread())
        .doOnError(new Consumer<Throwable>() { //此处不会执行，没有异常，所有事件会被正常接收
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e(TAG, "接收到异常2");
            }
        });

Observable.mergeDelayError(odds, evens)
        .subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e(TAG, "接收到数据：" + integer + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Throwable>() {
            @Override
            public void accept(Throwable e) throws Exception {
                //只要源Observable有异常，不管有没有在源Observable中被捕获，此处都有会执行
                Log.e(TAG, "接收到所有异常" + " Thread" + Thread.currentThread());
                Log.e(TAG, "isError1 = " + isError1);
                if (e instanceof CompositeException) { //源Observable 异常
                    CompositeException compositeException = (CompositeException) e;
                    List<Throwable> execptionList = compositeException.getExceptions();
                         Log.e(TAG, "源Observable 异常数量" +  execptionList.size());
                }
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.e(TAG, "接收完成" + " Thread" + Thread.currentThread());
            }
        }, new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.e(TAG, "doOnSubscribe" + " Thread" + Thread.currentThread());
            }
        });

璐璐丫头
关注
  • 4
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rxjava-3.0.0.rar
02-21
RxJava的核心概念包括观察者（Observer）、被观察者（Observable）和操作符（Operator）。观察者订阅被观察者，当被观察者发生变化时，会通知观察者。操作符则用于对数据流进行变换、过滤、合并等操作，提供了丰富的...
RxOperators:RxJava使用整理-操作符、使用方式
05-09
操作符预览图创建操作符变换操作符组合/合并操作符功能性操作符常用功能操作符-【subscribe】【subscribeOn】【observeOn】其他功能操作符-【delay】【repeat】【repeatWhen】【do】错误处理功能
rxjava-sandbox:rxjava-沙盒
04-28
RxJava 提供了一系列的操作符，用于对数据序列进行转换、过滤、合并等操作。例如： - `map` 操作符可以将一个数据流中的每个元素映射成另一个值。 - `filter` 用于筛选满足条件的元素。 - `concatMap` 和 `flatMap` ...
RxJava2-Samples-master_ThisIsIt_rxjava-samples_
09-30
1. **基本操作符的使用**：包括创建Observable、订阅Observer、使用各种操作符（如`map`、`filter`、`reduce`等）来转换和处理数据流。 2. **线程控制**：如何使用`.observeOn()`和`.subscribeOn()`操作符切换线程...
rxjava-training:rxjava-培训
05-30
RxJava 的核心概念是观察者模式和函数式编程思想的融合，它提供了丰富的操作符来简化复杂的数据处理逻辑。 **观察者模式** 观察者模式是一种设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生...
Android TabLayout+ViewPager2如何优雅的实现联动详解
07-14 724
Android开发过程中，我们经常会遇到滑动+导航栏的做法，之前的做法就是我们通过ViewGroup来转动，然后通过大量的自定义来完成，将导航栏item与viewpage滑动，达到业务需求。
安卓sdk manager下载安装
最新发布
qq_27933251的博客
08-20 297
通过android sdk manager安装android sdk
RabbitMQ-消息队列之routing使用
龙哥·三年风水从2011年开始做IT工作，从ps画图到前端开发->后端开发->框架开发->业务架构设计及开发->业务需求整理、开发->技术经理->技术总监
08-17 416
RabbitMQ-消息队列之routing使用
2024-08-16升级记录：使用Android RecyclerView控件显示列表型信息
sig321的专栏
08-16 768
在页面上使用RecyclerView实现一个列表型信息展示： 步骤如下： 二、添加单行显示的item布局文件 layout_gnss_counrty_item.xml 三、逻辑实现代码 实体类： Adapter类和ViewHolder类： 调用： 注意：一定要设置：LinearLayoutManager layoutManager = new LinearLayoutManager(this); mRecyclerView.setLayoutManager(layoutMan
wordpress二次开发 在Woocommerce相关产品中显示产品变体的方法
withkai44的博客
08-15 353
在Woocommerce中，相关产品的展示是一个很好的促销策略。但有时候，你可能希望在这些相关产品中显示产品的不同变体，以提供更多选择给客户。这段代码首先初始化了一个新的WP_Query对象来获取每个相关产品的所有变体。然后，在循环内，你可以按需自定义显示这些变体的代码。这意味着它获取了当前产品的ID，并调用了与之相关的产品。要显示这些相关产品的变体，你需要对这部分代码进行修改。接下来，你需要一个循环来显示每个相关产品的变体。在这个文件中，你可以看到相关产品是如何被调用的。
SQL-多表查询
Broken_x的博客
08-20 726
多表查询是数据库操作中不可或缺的一部分，通过合理使用连接查询和子查询，能够有效地提取和分析数据。理解多表关系及其查询方式，将有助于更高效地进行数据管理和分析。
[Zer0pts2020]Can you guess it?1
kw741951的博客
08-17 420
打开题目看到信息随便输入一个数，显示错误查看源代码看到php代码，代码审计phpexit();} else {?= $message?>php }?
[PHP]-Laravel中Group By引发的问题思考
hmx224_2014的专栏
08-16 540
Laravel 和 ThinkPHP 是两个不同的 PHP 框架，它们在底层使用了相同的 SQL 查询语言来与数据库交互。然而，由于框架的设计和实现方式不同，它们在生成 SQL 查询时可能会表现出一些细微的差异，包括对GROUP BY 子句的处理。在调用查询公司在线报告接口时，发现我请求的数据室20条每页，但是经查询存在16,17条的都有，并且后几页也不稳定，就一直查询问题。
android13布局查看工具 无源码查看布局 在线查找ui布局id
zhutoubenben的专栏
08-20 125
Android 13提供了一些工具来帮助开发人员查看和优化应用的布局。方便的让我们找到具体应用的布局文件等信息。老版本DDMS，的hierarchy view。
hyperf 协程上下文
xxpxxpoo8的专栏
08-20 293
由于同一个进程内协程间是内存共享的，但协程的执行/切换是非顺序的，也就意味着我们很难掌控当前的协程是哪一个（事实上可以，但通常没人这么干），所以我们需要在发生协程切换时能够同时切换对应的上下文。以hyperf 2.2版本为例。
【Android】adb devices 出现devices offline的问题
静谧、淡雅
08-20 135
adb devices 出现devices offline的问题
Android持久化技术—SharedPreferences存储
m0_63526467的博客
08-17 1125
Android持久化技术—SharedPreferences存储
Android强大的滚动控件RecyclerView
m0_63526467的博客
08-20 500
Android强大的滚动控件RecyclerView
Android声音播放与录制
轻口味的专栏
08-16 744
例如你在听music的时候接到电话，这个时候music播放肯定会停止，此时你只能听到电话，如果你调节音量的话，这个调节肯定只对电话起作用。当电话打完了，再回到music，你肯定不用再调节音量了。而STATIC的意思是一开始创建的时候，就把音频数据放到一个固定的buffer，然后直接传给audiotrack，后续就不用一次次得write了。其实系统将这几种声音的数据分开管理，所以，这个参数对AudioTrack来说，它的含义就是告诉系统，我现在想使用的是哪种类型的声音，这样系统就可以对应管理他们了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值