RxAndroid的基础使用

最新推荐文章于 2025-03-15 17:57:54 发布
最新推荐文章于 2025-03-15 17:57:54 发布
阅读量1k 收藏 3
点赞数
分类专栏： 框架的学习 文章标签： RxAndroid
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yu805894501/article/details/100663038
版权

作为一个android开发者，在开发应用的过程中避免不了异步这个问题。android系统为我们提供了Handler这个类帮助我们进行线程间的通信和切换，但是GitHub上也有很多其他非常优秀的开源框架来帮助我们进行异步处理，比如今天学习的RxAndroid。

简介

GitHub传送门：https://github.com/ReactiveX/RxAndroid
RxAndroid是一套观察者模式、链式调用的异步编程的API，使用RxAndroid编写的程序在逻辑上将会更加的简介、更加的便于理解。

引入框架

首先

在Androidstudio中的build.gradle（project）文件中的dependencies节点下添加代码
classpath ‘me.tatarka:gradle-retrolambda:3.2.5’

buildscript {
    repositories {
        google()
        jcenter()
        
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.5.0'
        
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
        classpath 'me.tatarka:gradle-retrolambda:3.2.5'
    }
}

第二步

在build.gradle（app）文件下的dependencies节点中添加
implementation ‘io.reactivex.rxjava2:rxandroid:2.1.1’
implementation ‘io.reactivex.rxjava2:rxjava:2.2.12’

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'androidx.appcompat:appcompat:1.0.2'
    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'androidx.test:runner:1.1.1'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.1.1'
    //rx
    implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.12'
}

第三步

点击sync now即可
在这里插入图片描述

HelloWord

首先写一个HelloWord，了解一下RxAndroid的简单使用

 public static void helloWord() {
        //创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("Hello RxAndroid");//发送消息
                e.onComplete();//完成消息的发送
            }
        });
        //创建观察者
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("建立连接", "OnSubscribe");
            }

            @Override
            public void onNext(@NonNull Object o) {
                //获取被观察者发送过来的消息
                Log.e("被观察者发送过来的消息", o.toString());
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("错误", e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e("传输完成", "onComplete");
            }
        };
        //建立连接
        observable.subscribe(observer);
    }

在上面的那个方法中，我们可以看到有被观察者：Observable，观察者：Observer，最后通过Observable的subscribe方法订阅连接两者，然后在被观察者中发送一个Hello RxAndroid的字符串，在观察者中的onNext方法中接收到被观察者发送过来的消息。这样一次观察者和被观察者之间的通信就基本完成了。
其中Observer有三个回调方法：onSubscribe、onNext、onError、onComplete，其中onSubscribe是两者在订阅的时候回调，onNext是被观察者调用onNext方法发送消息时的回调，onError是发生异常时的回调，onComplete是被观察者调用onComplete方法时的回调。

-----------------------------------------------说正事专用分割线---------------------------------------------
由以上可以简单的总结一下，RxAndroid有以下三个基本的元素
          1、被观察者(Observable)
          2、观察者（Observer）
          3、订阅（subscribe）

简单使用及常用操作符

我们在HelloWord中在被观察者中向观察者中发送了一个字符串就需要写了这么多，这样是不是太复杂了？不要着急，RxAndroid还为我们提供了一些其他的操作符。

just

通过just操作符创建被观察者，当有一个参数，观察者就会收到一次，两个参数收到两次，以此类推。

 public static void just() {
        //创建被观察者
        Observable<String> observable = Observable.just("你好", "222");
        //创建观察者
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("通过just操作符创建被观察者", s);
            }
        };
        //建立连接
        observable.subscribe(consumer);

    }

有没有发现，通过just创建的被观察者没有onError这个回调，那我应该怎么处理异常呢，这个时候就需要我们手动去抛出异常了，例如;

 public static void justEx() {
        //创建被观察者
        try {
            Observable<Integer> observable = Observable.just(Integer.parseInt("M"));
            //创建观察者
            Consumer<Integer> consumer = new Consumer<Integer>() {
                @Override
                public void accept(Integer s) throws Exception {
                    Log.e("just操作符", s + "");
                }
            };
            //建立连接
            observable.subscribe(consumer);
        } catch (Exception e) {
            Log.e("justEx", e.getMessage());
        }
    }

我在被观察者中发送了一个字符"M"，并且将它转换成int类型，因此就会报错，我们可以在catch中打印错误发现： E/justEx: Invalid int: “M”
在这里插入图片描述
我们也可以根据Observer中的三个状态创建回调，通过action代替onComplete

 public static void action() {
        //创建被观察者
        Observable<String> observable = Observable.just("你好");

        //创建观察者
        //接收onNext发送过来的正常的消息
        Consumer<String> nextConsumer = new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("onNext", s + "");
            }
        };
        //接收异常消息
        Consumer<Throwable> onErrorConsumer = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e("异常", "" + throwable.getMessage());
            }
        };
        //创建action
        Action completeAction = new Action() {
            @Override
            public void run() throws Exception {
                Log.e("actiong", "任务完成");
            }
        };
        //建立连接
        observable.subscribe(nextConsumer, onErrorConsumer, completeAction);
    }

打印log可以看到，依次调用了接收消息、消息完成
在这里插入图片描述

map

变化操作符，对被观察者发送的每一个事件应用一个函数，通过这个函数产生变化

 public static void map() {
        Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("3");
            }
        }).map(new Function<String, Integer>() {
            @Override
            public Integer apply(@NonNull String s) throws Exception {
                return Integer.parseInt(s);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.e("返回值", "" + integer);
            }
        });
    }

zip

将多个被观察者发送的事件结合到一起，然后再发送，并且发送事件的数量和上游事件最少的相同，比如：被观察者A发送了两个事件，被观察者B发送了一个事件，那么观察者只能接受一个事件，被观察者的组合也是严格按照顺序来的

public static void zip() {
        //创建被观察者
        Observable<String> obs1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("我是1");
                e.onNext("我是2");
                e.onComplete();
            }
        });
        Observable<String> obs2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("我是A");
                e.onComplete();
            }
        });
        //创建观察者
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                Log.e("返回值", o);
            }
        };
        //通过zip打包
        Observable.zip(obs1, obs2, new BiFunction<String, String, String>() {
            @Override
            public String apply(@NonNull String s, @NonNull String s2) throws Exception {
                return s + s2;
            }
        }).subscribe(consumer);
    }

merge

将多个被观察者合并成一个，这里和zip不同，zip是和具有最少的发送事件的被观察者的数量相同

public static void merge() {
        //创建被观察者
        Observable<String> obs1 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("我是1");
                e.onNext("我是2");
                e.onComplete();
            }
        });
        Observable<String> obs2 = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("我是A");
                e.onComplete();
            }
        });
        //创建观察者
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String o) throws Exception {
                Log.e("返回值", o);
            }
        };
        //通过merge打包发送
        Observable.merge(obs1, obs2).subscribe(consumer);
    }

filter

操作符用于去除不符合条件的事件。例如下面例子中去掉数组中的空字符串

 public static void filter() {

        Observable.fromArray(new String[]{"123456789", "", "123456789", "1111"}).filter(new Predicate<String>() {
            @Override
            public boolean test(@NonNull String s) throws Exception {
                //返回false表示去除该事件
                return s.length() != 0;
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("接受值", "111" + s);
            }
        });

    }

线程调度

如果说rxandroid只有上面那些功能是远远不会这么火热的，在android中线程间的调度是少不了的。
看一个简单例子

  public static void threadTest() {
        //创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                Log.e("被观察者", "当前线程：" + Thread.currentThread().getName());
                e.onNext("测试");
                e.onError(new Exception("111"));
                e.onComplete();
            }
        });
        //创建观察者
        Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) throws Exception {
                Log.e("观察者", "当前线程：" + Thread.currentThread().getName());
                //  Log.e("消息",""+s);
            }
        };
        //异常
        Consumer<Throwable> error = new Consumer<Throwable>() {
            @Override
            public void accept(Throwable throwable) throws Exception {
                Log.e("异常", "当前线程：" + Thread.currentThread().getName());
            }
        };
        //任务完成
        Action action = new Action() {
            @Override
            public void run() throws Exception {
                Log.e("Action", "当前线程：" + Thread.currentThread().getName());
            }
        };
        //建立连接
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(consumer, error, action);
    }

首先创建一个被观察者、观察者，然后在订阅的时候进行指定观察者和被观察者各自的运行线程即可，通过subscribeOn方法指定被观察者运行的线程，Schedulers.io()代表开启一个新线程，一般用于进行访问网络的操作，通过observeOn指定观察者的线程，AndroidSchedulers.mainThread()代表运行的线程在主线程及UI线程，在该线程中可以进行更新UI的操作。

异常处理

如果被观察者中运行的方法抛出异常，观察者则会回调onError方法，并且被观察者中的代码不会继续执行

 public static void onError1() {
        //创建被观察者
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
                e.onNext(2);
                int i = Integer.parseInt("l");
                e.onNext(i);
                int w = Integer.parseInt("e");
                e.onNext(w);
                e.onNext(3);
                Log.e("Observable", "我走到这里啦");
                e.onComplete();
            }
        });
        //创建观察者
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("建立连接", "onSubscribe");
            }

            @Override
            public void onNext(@NonNull Integer integer) {
                Log.e("获取返回值", integer + "");
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("异常", e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e("传输完成", "onComplete");
            }
        };
        //建立连接
        observable.subscribe(observer);
    }

被观察中只能调用一次onError方法，如果多次调用，将在第二次调用时抛出异常，并且一旦调用了onError方法，将不能调用onComplete方法报完成

 public static void onError2() {
        //创建被观察者
        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onError(new Exception("错误1"));
                e.onNext("111");
                e.onError(new Exception("错误2"));
                e.onComplete();
            }
        });

        //创建观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("建立连接", "onSubscribe");
            }

            @Override
            public void onNext(@NonNull String integer) {
                Log.e("获取返回值", integer + "");
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("异常", e.getMessage());
            }

            @Override
            public void onComplete() {
                Log.e("传输完成", "onComplete");
            }
        };
        //建立连接
        observable.subscribe(observer);
    }

参考链接：
https://www.jianshu.com/p/7eb5ccf5ab1e
https://juejin.im/post/5b17560e6fb9a01e2862246f
https://www.jianshu.com/p/c66951952c74

结语

嗯~，目前我学习到这的也只有这么多了，如果哪里有误还烦请指正呀
点击这里获取找到我，获取更多哦

QQ群：

image.png

微信公众号

分享小知识，记录你的小故事呀
微信公众号.jpg

Rxandroid2.0 使用记录
weixin_39821531的博客
03-29 1389
简单记录一些基础知识和使用方法，目标——简单！能用！ Github地址： https://github.com/ReactiveX/RxJava https://github.com/ReactiveX/RxAndroid 依赖库： implementation 'io.reactivex.rxjava2:rxjava:2.2.2' implementation 'io.rea...
Rx使用示例（RxJava&RxAndroid）
06-23
RxJava&RxAndroid使用示例，内附使用说明手册
RxAndroid 的基本使用
wc0000000的博客
02-26 216
&#13; 1．基本概念 Rx是RxJava针对Android的定制版本。这个版本中通过增加最少的类使在Android应用中编写响应式组件简单而且无障碍，特别之处在与它还提供了一个Scheduler，可以在主线程或任何给定的Handler上进行调度。Rx编程方式基于三个基本概念：观察者模式、迭代器模式、函数式编程。下面通过几个例子，描述在Android上面Rx方式进行编程的基...
Android开源库——RxJava和RxAndroid
最新发布
松仔Log的博客
03-15 1232
RxJava是基于JVM的响应式扩展，用于编写异步代码RxAndroid是关于Android的RxJava绑定。
Android RxAndroid使用
mazaiting的博客
08-22 188
实现类似定时器功能 依赖 compile 'io.reactivex.rxjava2:rxandroid:2.0.1' compile 'io.reactivex.rxjava2:rxjava:2.1.3' 2.布局文件中只是简单的TextView控件来显示文本。目前涉及到及所了解的RxAndroid与RxJava中多用到的是 .observeOn(...
详细解析 RxAndroid 的使用方式
weixin_30733003的博客
03-24 242
RxAndroid是RxJava的扩展, 优雅地处理异步请求. RxAndroid配合Lambda表达式, 精简处理回调, 使程序更具有可读性. Rx作为Android最优秀的开源库之一, 极大地提高生产力, 我们需要掌握. 本文由浅入深, 介绍一些常见的使用方法, 并附有源码. 更多:http://www.wangchenlong.org/ 本文代码的GitHub下载地址. ...
RxAndroid的使用
qq_30240953的博客
12-07 695
RxAndroid的使用 1.使用背景 在项目中使用EventBus，进行线程之间事件的传递，后来，在同事之间的技术分享中，了解到RxJava，想弄清楚RxJava与EventBus有什么不同？ github上关于RxAndroid开源 EventBus: 1.不能混淆，否则不能找到OnEvent方法； 2.要考虑activity和fragment的生命周期； 3.在Android中
RxAndroid基础使用_测试工程
04-11
RxAndroid的基础使用测试代码，可以参考博客http://blog.youkuaiyun.com/yaodong379/article/details/51116367。 使用基础语法进行测试而非lambda，方便初学者参考。
RxAndroid基础实践及测试工程解析
标题“RxAndroid基础使用_测试工程”说明了文档将提供RxAndroid使用的基础知识和测试用例。文档中提供的博客链接（http://blog.youkuaiyun.com/yaodong379/article/details/51116367）可能是一个参考资源，用于进一步解释...
MVP+Retrofit+RxAndroid使用
05-16
4. **使用RxAndroid处理异步**：将Retrofit的Call对象转换为Observable，然后通过subscribeOn和observeOn来指定线程切换规则。 5. **在Observer中处理结果**：在onNext方法中处理成功响应，在onError方法中处理错误...
RXAndroid基础演示教程详解
1. RxJava基础： RxJava是ReactiveX库的Java实现，它提供了创建和操作异步事件流的一系列操作符。在Android开发中，RxJava常用于网络请求、数据处理等异步操作。 2. 观察者模式（Observer Pattern）：响应式编程的...
RxAndroid 使用教程
gitblog_01139的博客
08-09 403
RxAndroid 使用教程 RxAndroidRxJava bindings for Android项目地址:https://gitcode.com/gh_mirrors/rx/RxAndroid 项目介绍 RxAndroid 是 RxJava 针对 Android 平台的扩展，提供响应式扩展组件，快速开发 Android 程序。RxJava 是一个用于处理异步数据流的 Java 库，而 Rx...
RxAndroid使用详解
halong99的专栏
02-21 586
接着，我们订阅了subject，并指定了两个调度器：Schedulers.io()用于在IO线程执行异步任务（例如网络请求），AndroidSchedulers.mainThread()用于在主线程更新UI。最后，在subscribe方法中，我们定义了三个Lambda表达式，分别处理发射的数据（onNext），错误情况（onError），以及完成情况（onComplete）。() -> { /* 处理完成 */ } // onComplete：处理完成情况。// 订阅subject，处理异步任务。
android rxandroid 使用,使用RxAndroid安排
weixin_35198152的博客
05-27 208
我正在使用RxAndroid observable来检索一些对象(在本例中为String).我的服务如下：public Observable getRandomString() {return Observable.create(new Observable.OnSubscribe() {@Overridepublic void call(Subscriber super String> s...
RxAndroid的基本使用
lxrlxr888的博客
01-05 384
compile 'io.reactivex:rxandroid:1.2.1' compile 'io.reactivex:rxjava:1.1.9' compile 'com.jakewharton.rxbinding:rxbinding:0.4.0' private Subscribersuper View> msubscriber; private Button btn; private I
RxAndroid 使用
qq_25040199的博客
11-20 221
  RxAndroid GitHub地址：          https://github.com/ReactiveX/RxAndroid 环境搭建 RxAndroid环境只需求要引入如下项目即可，我们不但需要RxAndroid项目还需要RxJava项目。 implementation 'io.reactivex.rxjava2:rxandroid:2.1.0' implementati...
RxAndroid使用初探；简洁、优雅、高效
测试0901-1
01-16 763
引言 RxAndroid是一个开发库、是一种代码风格、也是一种思维方式。 正如标题所言，RxAndroid的特点是简洁、优雅、高效，它的优点是多线程切换简单、数据变换容易、代码简洁可读性好、第三方支持丰富易于开发；缺点是学习成本较高、出错难以排查。 用途与优势 ·起源...
分分钟学会RxAndroid的使用（一）
onResume的博客
09-07 900
最近mvp+retrofit+RxAnroid的模式开发应用灰常之火，笔者也觉得是时候学习一波了。花了几天的时间学习了一下RxAndroid，RxAndroid是基于Rxjava的拓展，与RxJava相比，除了多了一个线程调度比较常用，与RxJava无异。但是值得一提的是，相对老一点版本的RxAndroid，新版本中少了一些东西，比如生命周期（bindactivity），与ViewObservab
给 Android 开发者的 RxJava 详解
weixin_34204722的博客
10-12 839
2019独角兽企业重金招聘Python工程师标准>>> ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值