Rxjava总结

最新推荐文章于 2025-11-12 17:51:33 发布
原创 最新推荐文章于 2025-11-12 17:51:33 发布 · 361 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#移动开发 #android #rxjava

Rxjava定义
基于事件流的链式调用,逻辑简洁,使用简单,功能强大的异步库

Rxjava描述
被观察者Observable在子线程中生产事件(耗时操作)
观察者Observer在主线程接收&响应事件(UI操作)

Rxjava原理(Observable.subscribe(observer))
被观察者通过订阅按顺序发送事件给观察者,观察者按顺序接收事件&作出对应的响应动作

Rxjava常见使用:
普通异步操作
retrofit+Rxjava网络请求
timer定时和interval周期性操作
throttleFirst按钮重复点击

Rxjava背压
在异步场景中，被观察者发送速度远快于观察者的处理速度，告诉被观察者降低发送速度的策略

Rxjava举例


  /*1,Observable快速创建和遍历*/

//            //快速创建被观察者对象（Observable） & 发送10个以下事件
//            Observable observable000 = Observable.just("A", "B", "C");
//            //快速创建被观察者对象（Observable） & 发送10个以上事件（数组形式）--数组遍历
//            String[] words = {"A", "B", "C"};
//            Observable observable001 = Observable.fromArray(words);
//            //快速创建被观察者对象（Observable） & 发送10个以上事件（集合形式）-集合遍历
//            List<String> list = new ArrayList<>();
//            list.add("A");
//            list.add("B");
//            list.add("C");
//            Observable observable002 = Observable.fromIterable(list);
//            //发送Complete事件，直接通知完成
//            Observable observable003 = Observable.empty();
//            //发送Error事件，直接通知异常
//            Observable observable004 = Observable.error(new RuntimeException());

            /*2,Observable事件变换--关联性*/

//            //完整创建1个被观察者对象
//            Observable observable00 = Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
//                emitter.onNext(1);
//                emitter.onNext(2);
//                emitter.onNext(3);
//                emitter.onComplete();
//            }).map(new Function<Integer, String>() {//通过指定方法转换,比如int->string
//                @Override
//                public String apply(Integer integer) throws Exception {
//                    return "使用Map变换操作符将事件" + integer + "的参数从整型" + integer + "变换成字符串类型" + integer;
//                }
//            });
//
//            //flatMap无序的将被观察者发送的整个事件序列进行变换
//            Observable observable01 = Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
//                emitter.onNext(1);
//                emitter.onNext(2);
//                emitter.onNext(3);
//            }).flatMap(new Function<Integer, ObservableSource<String>>() {
//                @Override
//                public ObservableSource<String> apply(Integer integer) throws Exception {
//                    final List<String> list = new ArrayList<>();
//                    for (int i = 0; i < 3; i++) {
//                        list.add("我是事件 " + integer + "拆分后的子事件" + i);
//                    }
//                    return Observable.fromIterable(list);
//                }
//            });
//
//            //concatMap有序的将被观察者发送的整个事件序列进行变换
//            Observable observable02 = Observable.create((ObservableOnSubscribe<Integer>) emitter -> {
//                emitter.onNext(1);
//                emitter.onNext(2);
//                emitter.onNext(3);
//            }).concatMap(new Function<Integer, ObservableSource<String>>() {
//                @Override
//                public ObservableSource<String> apply(Integer integer) throws Exception {
//                    final List<String> list = new ArrayList<>();
//                    for (int i = 0; i < 3; i++) {
//                        list.add("我是事件 " + integer + "拆分后的子事件" + i);
//                    }
//                    return Observable.fromIterable(list);
//                }
//            });

            /*3,多Observable串,并行执行--有序性*/

//            //组合多个被观察者,使用
//            //concatArray（）：组合多个被观察者一起发送数据（可＞4个）,串行执行
//            Observable observable11 = Observable.concatArray(
//                    Observable.just("1", "2", "3"),
//                    Observable.just("4", "5", "6"),
//                    Observable.just("7", "8", "9"),
//                    Observable.just("10", "11", "12"),
//                    Observable.just("13", "14", "15"));
//            //mergeArray（）：组合多个被观察者一起发送数据（可＞4个）,并行执行
//            Observable observable12 = Observable.mergeArray(
//                    Observable.just("1", "2", "3"),
//                    Observable.just("4", "5", "6"),
//                    Observable.just("7", "8", "9"),
//                    Observable.just("10", "11", "12"),
//                    Observable.just("13", "14", "15"));
//            //concatArrayDelayError（） / mergeArrayDelayError（）,其中任意一个Observable出现异常,都会继续执行其他Observable
//            Observable observable13 = Observable.mergeArrayDelayError(
//                    Observable.just("1", "2", "3"),
//                    Observable.create(new ObservableOnSubscribe<String>() {
//                        @Override
//                        public void subscribe(ObservableEmitter<String> emitter) throws Exception {
//                            emitter.onNext("4");
//                            emitter.onError(new NullPointerException());
//                            emitter.onNext("5");
//                            emitter.onNext("6");
//                            emitter.onComplete();
//                        }
//                    }),
//                    Observable.just("7", "8", "9"),
//                    Observable.just("10", "11", "12"),
//                    Observable.just("13", "14", "15"));

            /*4,合并Observable,组合数据源*/

//            //通过zip合并多个Observable发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送--1对1合并,按个数合并,combineLatest是按时间合并
//            Observable observable14 = Observable.zip(
//                    Observable.just("1", "2", "3"),
//                    Observable.just("A", "B", "C"), new BiFunction<String, String, String>() {
//                        @NotNull
//                        @Override
//                        public String apply(@NotNull String s1, @NotNull String s2) throws Exception {
//                            return s1 + "_" + s2;
//                        }
//                    });
//
//            //startWithArray发送事件前追加发送事件
//            Observable observable15 = Observable.just("4", "5", "6").startWithArray("1", "2", "3");

            /*5,延迟,重发*/

//            //delay延迟发送
//            Observable observable16 = Observable.just("1", "2", "3").delay(2, TimeUnit.SECONDS);
//
//            //出现异常后重复请求
//            Observable observable17 = Observable.create(new ObservableOnSubscribe<String>() {
//                @Override
//                public void subscribe(ObservableEmitter<String> e) throws Exception {
//                    e.onNext("1");
//                    e.onNext("2");
//                    e.onError(new Exception("发生错误了"));
//                    e.onNext("3");
//                }
//            }).retry(2);
//
//            //repeat,无条件重复请求
//            Observable observable18 = Observable.just("1", "2", "3").repeat(3);

            /*6,线程调度,订阅,取消订阅*/

//            //subscribe（）使得被观察者&观察者形成订阅关系
//            observable18
//                    //多次指定Observable的线程，则只有第一次指定有效
//                    .subscribeOn(Schedulers.io())
//                    //多次指定Observer的线程，则每次指定均有效
//                    .observeOn(AndroidSchedulers.mainThread())
//                    .subscribe(new Observer<String>() {
//                        private Disposable mDisposable;
//
//                        @Override
//                        public void onSubscribe(Disposable d) {
//                            mDisposable = d;
//                            Log.d(TAG, "开始采用subscribe连接");
//                        }
//
//                        @Override
//                        public void onNext(String value) {
//                            if (value.equals("B")) {
//                                //切断链接
//                                mDisposable.dispose();
//                                Log.d(TAG, "已经切断了连接：" + mDisposable.isDisposed());
//                            }
//                            Log.d(TAG, "对Next事件" + value + "作出响应");
//                        }
//
//                        @Override
//                        public void onError(Throwable e) {
//                            Log.d(TAG, "对Error事件作出响应");
//                        }
//
//                        @Override
//                        public void onComplete() {
//                            Log.d(TAG, "对Complete事件作出响应");
//                        }
//                    });

            //简洁观察者写法
//            observable002.subscribe(new Consumer<String>() {
//                @Override
//                public void accept(String s) throws Exception {
//                    Log.d(TAG, s);
//                }
//            });

//常规异步操作
CompositeDisposable mCompositeDisposable = new CompositeDisposable()
 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                //该部分执行耗时操作,并将结果result通过onNext传输
                emitter.onNext(result);
                emitter.onComplete();
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                      mCompositeDisposable.add(d);
                    }

                    @Override
                    public void onNext(String str) {
                        mTvBa.setText(str);
                    }

                    @Override
                    public void onError(Throwable e) {
                        mTvBa.setText("error");
                    }

                    @Override
                    public void onComplete() {
                        mTvBa.setText("complete");
                    }
                });
                
mCompositeDisposable.clear();

Rxjava案例
1, 案例1,login的结果给rainCountToMap参数,rainCountToMap的结果给newAllWaterLevel参数–关联性


            ApiService mApiService = Api.getDefault(HostType.BASE_URL);
            mApiService.login(body)
                    .subscribeOn(Schedulers.io())
                    .observeOn(Schedulers.io())
                    .concatMap(new Function<UserData, Observable<SSYLBean>>() {
                        @Override
                        public Observable<SSYLBean> apply(@NotNull UserData userData) throws Exception {
                            //login的参数给rainCountToMap
                            return mApiService.rainCountToMap(userData.getToken);
                        }
                    })
                    .observeOn(Schedulers.io())
                    .concatMap(new Function<SSYLBean, Observable<JXYWBean>>() {
                        @Override
                        public Observable<JXYWBean> apply(@NotNull SSYLBean s) throws Exception {
                            //rainCountToMap的参数给newAllWaterLevel
                            return mApiService.newAllWaterLevel(s.getRainId);
                        }
                    })
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new RxSubscriber<JXYWBean>(this, "登录中...", true) {
                        @Override
                        protected void _onNext(JXYWBean t) {

                        }

                        @Override
                        protected void _onError(String message) {
                        }
                    });

2,案例2,串,并行混合执行–顺序性(mergeArray/concatArray)


            ApiService mApiService = Api.getDefault(HostType.BASE_URL);
            Observable<UserData> userDataObservable = mApiService.login(body);
            Observable<SSYLBean> ssylBeanObservable = mApiService.rainCountToMap();
            Observable<JXYWBean> jxywBeanObservable = mApiService.newAllWaterLevel();
            Observable observable = Observable.mergeArray(
                    Observable.concatArray(userDataObservable, ssylBeanObservable),
                    jxywBeanObservable);

            observable
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new RxSubscriber<T>(this, "登录中...", true) {
                        @Override
                        protected void _onNext(T t) {
                            if (t instanceof UserData) {
                                i("adfsafds", "UserData");
                            } else if (t instanceof SSYLBean) {
                                i("adfsafds", "SSYLBean");
                            } else if (t instanceof JXYWBean) {
                                i("adfsafds", "JXYWBean");
                            }
                        }

                        @Override
                        protected void _onError(String message) {
                        }
                    });

3,案例3,合并login和rainCountToMap请求结果数据源—合并(zip)


            ApiService mApiService = Api.getDefault(HostType.BASE_URL);
            Observable<UserData> userDataObservable = mApiService.login(body);
            Observable<SSYLBean> ssylBeanObservable = mApiService.rainCountToMap();
            Observable<String> observable = Observable.zip(
                    userDataObservable,
                    ssylBeanObservable, new BiFunction<UserData, SSYLBean, String>() {
                        @NotNull
                        @Override
                        public String apply(@NotNull UserData userData, @NotNull SSYLBean ssylBean) throws Exception {
                            return userData.getData().getUser().getSName() + "_" + ssylBean.getData().get(0).getDate();
                        }
                    });
            observable
                    .subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new RxSubscriber<String>(this, "登录中...", true) {
                        @Override
                        protected void _onNext(String str) {
                            i("adfsafds", str);
                        }

                        @Override
                        protected void _onError(String msg) {
                        }
                    });

4,案例4,融合关联(变换concatMap),顺序(组合mergeArray),合并(zip)


 //login提供参数给newAllWaterLevel(concatMap),rainCountToMap和newAllWaterLevel并行执行(mergeArray),再合并rainCountToMap和waterLeverToMap(zip)
            Api.getDefault(HostType.BASE_URL)
                    .login(body)
                    .subscribeOn(Schedulers.io())
                    .observeOn(Schedulers.io())
                    .concatMap(new Function<UserData, Observable<T>>() {
                        @Override
                        public Observable<T> apply(@NotNull UserData userData) throws Exception {
                            return (Observable<T>) Observable.zip(
                                    (Observable<T>) Observable.mergeArray(
                                            Api.getDefault(HostType.BASE_URL).rainCountToMap(),
                                            Api.getDefault(HostType.BASE_URL).newAllWaterLevel(userData.getToken())),
                                    Api.getDefault(HostType.BASE_URL).waterLeverToMap(), new BiFunction<T, SSSWBean, String>() {
                                        @NotNull
                                        @Override
                                        public String apply(@NotNull T t, @NotNull SSSWBean ssswBean) throws Exception {
                                            return ((SSYLBean) t).getData().get(0).getDate() + "_" + ssswBean.getData().get(0).getSenid();
                                        }
                                    });
                        }
                    })
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new RxSubscriber<T>(this, "加载中...", true) {
                        @Override
                        protected void _onNext(T str) {
                            i("OkHttp", str + "");
                        }

                        @Override
                        protected void _onError(String message) {
                        }
                    });

本文结束,只是参考

RxJava现学现用下（应用场景）
DDUP的博客
11-08 884
前言 之前两篇文章介绍了RxJava常用的操作符，本文将从实际开发着手，来聊聊RxJava的应用场景。再聊这个之前，先回顾一下RxJava的操作符： 如上图所示，RxJava基本分为这6类操作符，下面针对这6类操作符，具体介绍一下应用场景。 学习内容： 提示：这里可以添加要学的内容 例如： 1、 搭建 Java 开发环境 2、 掌握 Java 基本语法 3、 掌握条件语句 4、 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 1、 周一至周五晚上 7 点—晚上9点 2、
Android 日常开发(31) 如何使用Rxjava做集合遍历转换
ZPCrobot的博客
01-03 918
前言 我们知道jdk1.8增加了stream，可以对集合做变换操作。但是android上如果想使用这个特性的话，需要讲sdk最小版本设置到24也就是android7.0设备。这个看起来不是很合适，那么有什么好的替代办法吗？ Rxjava可以帮助你解决这个困境 代码 jdk1.8的写法 List<String> strings= checkTypeBeans.stream().map(C...
安卓进阶——RxJava
最新发布
Meteors.的博客
11-12 1091
RxJava是由Netflix开发的响应式编程框架，基于观察者模式简化异步编程。核心组件包括Observable（数据发射源）、Observer（数据处理者）、Subject（双向桥梁）和Subscription（订阅管理）。框架提供创建、转换、过滤、组合等丰富操作符，支持线程调度控制（如subscribeOn/observeOn）。典型应用场景包括网络请求链式调用、UI事件防抖、生命周期管理等。需注意内存泄漏防护（CompositeDisposable）、合理选择操作符及错误处理机制。其流式...
rxjava操作符结合使用场景简介
朱利源的博客
06-26 1213
rxjava操作符结合使用场景简介 前言 本文将通过实际的例子来介绍rx相关的操作符,如果对rxjava还不熟悉的同学请先查看rxjava相关基础姿势再来查看本文 准备 本文依赖rxjava版本如下 implementation 'io.reactivex.rxjava2:rxjava:2.1.15' implementation 'io.reactivex....
RxJava总结
咖啡店小二
12-26 146
RxJava总结 RxJava的执行过程
RxJava 2.x新特性总结整理
08-30
RxJava 是一个在 Java VM 上使用可观测的序列来组成异步或基于事件的程序的库。它将函数式编程和反应式编程的概念融合在一起，适用于 Android 开发和其他 Java 应用场景。RxJava 2.x 是其重要的升级版本，引入了一些...
RxJava2配置及使用详解
08-30
RxJava2 配置及使用详解 ...总结 RxJava2 是一个功能强大且流行的响应式编程库，广泛应用于多个领域。它提供了多种功能，包括异步编程、数据处理等。然而，它也有一些缺点，需要开发者认真学习和掌握。
RxJavaNotes:RxJava2 应用场景总结及源码学习笔记
04-30
RxJava2 Learning Notes 原理 一系列的事件序列，通过上下游链接，使得上游没产生一个事件，下游就能接收到该事件。 上游和下游就分别对应着RxJava中的Observable和Observer;两者之间的连接就对应着subscribe() 只有...
RxJava中多种场景的实现总结
09-01
总结，RxJava提供了丰富的工具来处理各种异步场景，如延迟执行、同步不同源的发射以及线程控制。熟练掌握这些用法能够帮助开发者更高效地编写并发和事件驱动的代码。通过深入理解并应用`timer`、`zip`和`defer`，你...
RxJava2.0（初学者教程+实用操作符总结及原理简析）
06-21
RxJava2.0 是一个强大的响应式编程库，尤其在Android开发中被广泛使用。它引入了一种新的处理异步数据流的方式，通过观察者模式和一系列操作符，简化了事件处理和数据管理。本教程将针对初学者，详细介绍如何入门...
RxJava多种常用场景使用方法
陈宇明
12-31 2369
一、Scheduler线程切换这种场景经常会在“后台线程取数据，主线程展示”的模式中看见[html] view plaincopyObservable.just(1, 2, 3, 4)              .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程              .observeOn(AndroidSched
rxjava
永远是死循环
01-29 340
package com.example.wangmutian.rxjavastudy; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import io.reactivex.Observable; import io.reactivex.Ob
RxJava
binbinbintony的博客
04-06 292
RxJava 已经内置了几个 Scheduler : Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。 Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io...
RxJava中Single使用方法的完全总结
RxJava是一种基于响应式编程（Reactive Programming）的Java库，由Reactive Extensions演变而来，最初由Netty的作者Johan Vos等人开发。它的核心思想是利用可观察序列（Observable Sequences）和声明式的数据变换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值