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多种常用场景使用方法
陈宇明
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...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值