Carson带你学Android：面向初学者的RxJava使用指南

前言

• Rxjava由于其基于事件流的链式调用、逻辑简洁 & 使用简单的特点，深受各大 Android开发者的欢迎。

今天，我将为初学者带来 RxJava的基本使用，希望大家会喜欢。

Carson带你学RxJava系列文章，包括 原理、操作符、应用场景、背压等等，请看文章：Android：这是一份全面 & 详细的RxJava学习指南

目录

1. RxJava简介

此处简单介绍RxJava

若还不了解RxJava，请看文章：Android：这是一篇 清晰 & 易懂的Rxjava 入门教程

2. 基本使用

• 本文只关注 RxJava的基本使用，更深入的RxJava使用请继续关注Carson_Ho的RxJava系列
• Rxjava的使用方式有两种：
  1. 分步骤实现：该方法主要为了深入说明Rxjava的原理 & 使用，主要用于演示说明
  2. 基于事件流的链式调用：主要用于实际使用

2.1 方式1：分步骤实现

2.1.1 使用步骤

2.1.2 步骤详解

步骤1：创建被观察者 （Observable ）& 生产事件

• 即 顾客入饭店 - 坐下餐桌 - 点菜
• 具体实现

        // 1. 创建被观察者 Observable 对象Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {// create() 是 RxJava 最基本的创造事件序列的方法// 此处传入了一个 OnSubscribe 对象参数// 当 Observable 被订阅时，OnSubscribe 的 call() 方法会自动被调用，即事件序列就会依照设定依次被触发// 即观察者会依次调用对应事件的复写方法从而响应事件// 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式// 2. 在复写的subscribe（）里定义需要发送的事件@Overridepublic void subscribe(ObservableEmitter<Integer> emitter) throws Exception {// 通过 ObservableEmitter类对象产生事件并通知观察者// ObservableEmitter类介绍// a. 定义：事件发射器// b. 作用：定义需要发送的事件 & 向观察者发送事件emitter.onNext(1);emitter.onNext(2);emitter.onNext(3);emitter.onComplete();}});<--扩展：RxJava 提供了其他方法用于 创建被观察者对象Observable -->
// 方法1：just(T...)：直接将传入的参数依次发送出来Observable observable = Observable.just("A", "B", "C");// 将会依次调用：// onNext("A");// onNext("B");// onNext("C");// onCompleted();// 方法2：from(T[]) / from(Iterable<? extends T>) : 将传入的数组 / Iterable 拆分成具体对象后，依次发送出来String[] words = {"A", "B", "C"};Observable observable = Observable.from(words);// 将会依次调用：// onNext("A");// onNext("B");// onNext("C");// onCompleted();

步骤2：创建观察者 （Observer ）并 定义响应事件的行为

• 即 开厨房 - 确定对应菜式
• 发生的事件类型包括：Next事件、Complete事件 & Error事件。具体如下：

• 具体实现

<--方式1：采用Observer 接口 -->// 1. 创建观察者 （Observer ）对象Observer<Integer> observer = new Observer<Integer>() {// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件// 观察者接收事件前，默认最先调用复写 onSubscribe（）@Overridepublic void onSubscribe(Disposable d) {Log.d(TAG, "开始采用subscribe连接");}// 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件作出响应" + value);}// 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}// 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}};<--方式2：采用Subscriber 抽象类 -->
// 说明：Subscriber类 = RxJava 内置的一个实现了 Observer 的抽象类，对 Observer 接口进行了扩展// 1. 创建观察者 （Observer ）对象
Subscriber<String> subscriber = new Subscriber<Integer>() {// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件// 观察者接收事件前，默认最先调用复写 onSubscribe（）@Overridepublic void onSubscribe(Subscription s) {Log.d(TAG, "开始采用subscribe连接");}// 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件作出响应" + value);}// 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}// 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}};<--特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别 -->
// 相同点：二者基本使用方式完全一致（实质上，在RxJava的 subscribe 过程中，Observer总是会先被转换成Subscriber再使用）
// 不同点：Subscriber抽象类对 Observer 接口进行了扩展，新增了两个方法：// 1. onStart()：在还未响应事件前调用，用于做一些初始化工作// 2. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件// 调用该方法前，先使用 isUnsubscribed() 判断状态，确定被观察者Observable是否还持有观察者Subscriber的引用，如果引用不能及时释放，就会出现内存泄露

步骤3：通过订阅（Subscribe）连接观察者和被观察者

• 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调
• 具体实现

observable.subscribe(observer);// 或者 observable.subscribe(subscriber)；

• 扩展说明

<-- Observable.subscribe(Subscriber) 的内部实现 -->public Subscription subscribe(Subscriber subscriber) {subscriber.onStart();// 步骤1中 观察者  subscriber抽象类复写的方法，用于初始化工作onSubscribe.call(subscriber);// 通过该调用，从而回调观察者中的对应方法从而响应被观察者生产的事件// 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式// 同时也看出：Observable只是生产事件，真正的发送事件是在它被订阅的时候，即当 subscribe() 方法执行时
}

2.2 方式2：优雅的实现方法 - 基于事件流的链式调用

• 上述的实现方式是为了说明Rxjava的原理 & 使用
• 在实际应用中，会将上述步骤&代码连在一起，从而更加简洁、更加优雅，即所谓的 RxJava基于事件流的链式调用

// RxJava的链式操作Observable.create(new ObservableOnSubscribe<Integer>() {// 1. 创建被观察者 & 生产事件@Overridepublic void subscribe(ObservableEmitter<Integer> emitter) throws Exception {emitter.onNext(1);emitter.onNext(2);emitter.onNext(3);emitter.onComplete();}}).subscribe(new Observer<Integer>() {// 2. 通过通过订阅（subscribe）连接观察者和被观察者// 3. 创建观察者 & 定义响应事件的行为@Overridepublic void onSubscribe(Disposable d) {Log.d(TAG, "开始采用subscribe连接");}// 默认最先调用复写的 onSubscribe（）@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件"+ value +"作出响应"  );}@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}});}
}注：整体方法调用顺序：观察者.onSubscribe（）> 被观察者.subscribe（）> 观察者.onNext（）>观察者.onComplete() 

这种 基于事件流的链式调用，使得RxJava：

• 逻辑简洁
• 实现优雅
• 使用简单

更重要的是，随着程序逻辑的复杂性提高，它依然能够保持简洁 & 优雅。所以，一般建议使用这种基于事件流的链式调用方式实现RxJava。

特别注意

RxJava 2.x 提供了多个函数式接口 ，用于实现简便式的观察者模式。具体如下：

以 Consumer为例：实现简便式的观察者模式

Observable.just("hello").subscribe(new Consumer<String>() {// 每次接收到Observable的事件都会调用Consumer.accept（）@Overridepublic void accept(String s) throws Exception {System.out.println(s);}});

3. 实例讲解

我将用一个实际工程实例来演示 Rxjava的使用

3.1 方式1：分步骤实现

步骤1：加入依赖

    compile 'io.reactivex.rxjava2:rxjava:2.0.1'compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

步骤2：直接在MainActivity.java中实现下述步骤

1. 创建被观察者 （Observable ）& 生产事件
2. 创建观察者 （Observer ）并 定义响应事件的行为
3. 通过订阅（Subscribe）连接观察者和被观察者

public class MainActivity extends AppCompatActivity {private static final String TAG = "Rxjava";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 步骤1：创建被观察者 Observable & 生产事件
// 即 顾客入饭店 - 坐下餐桌 - 点菜//  1. 创建被观察者 Observable 对象Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {// 2. 在复写的subscribe（）里定义需要发送的事件@Overridepublic void subscribe(ObservableEmitter<Integer> emitter) throws Exception {// 通过 ObservableEmitter类对象产生事件并通知观察者// ObservableEmitter类介绍// a. 定义：事件发射器// b. 作用：定义需要发送的事件 & 向观察者发送事件emitter.onNext(1);emitter.onNext(2);emitter.onNext(3);emitter.onComplete();}});// 步骤2：创建观察者 Observer 并 定义响应事件行为
// 即 开厨房 - 确定对应菜式Observer<Integer> observer = new Observer<Integer>() {// 通过复写对应方法来 响应 被观察者@Overridepublic void onSubscribe(Disposable d) {Log.d(TAG, "开始采用subscribe连接");}// 默认最先调用复写的 onSubscribe（）@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件"+ value +"作出响应"  );}@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}};// 步骤3：通过订阅（subscribe）连接观察者和被观察者// 即 顾客找到服务员 - 点菜 - 服务员下单到厨房 - 厨房烹调observable.subscribe(observer);

• 测试结果

3.2 方式2：基于事件流的链式调用方式

public class MainActivity extends AppCompatActivity {private static final String TAG = "Rxjava";@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// RxJava的流式操作Observable.create(new ObservableOnSubscribe<Integer>() {// 1. 创建被观察者 & 生产事件@Overridepublic void subscribe(ObservableEmitter<Integer> emitter) throws Exception {emitter.onNext(1);emitter.onNext(2);emitter.onNext(3);emitter.onComplete();}}).subscribe(new Observer<Integer>() {// 2. 通过通过订阅（subscribe）连接观察者和被观察者// 3. 创建观察者 & 定义响应事件的行为@Overridepublic void onSubscribe(Disposable d) {Log.d(TAG, "开始采用subscribe连接");}// 默认最先调用复写的 onSubscribe（）@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件"+ value +"作出响应"  );}@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}});}
}

• 测试效果
  实现效果同上
  

• Demo 下载地址
  Carson_Ho的Github地址 = RxJava2系列：基础使用

喜欢的麻烦点个star！

4. 额外说明

4.1 观察者 Observer的subscribe()具备多个重载的方法

    public final Disposable subscribe() {}// 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）public final Disposable subscribe(Consumer<? super T> onNext) {}// 表示观察者只对被观察者发送的Next事件作出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} // 表示观察者只对被观察者发送的Next事件 & Error事件作出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}// 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应public final void subscribe(Observer<? super T> observer) {}// 表示观察者对被观察者发送的任何事件都作出响应

4.2 可采用 Disposable.dispose() 切断观察者 与 被观察者 之间的连接

• 即观察者 无法继续 接收 被观察者的事件，但被观察者还是可以继续发送事件
• 具体使用

// 主要在观察者 Observer中 实现Observer<Integer> observer = new Observer<Integer>() {// 1. 定义Disposable类变量private Disposable mDisposable;@Overridepublic void onSubscribe(Disposable d) {Log.d(TAG, "开始采用subscribe连接");// 2. 对Disposable类变量赋值mDisposable = d;}@Overridepublic void onNext(Integer value) {Log.d(TAG, "对Next事件"+ value +"作出响应"  );if (value == 2) {// 设置在接收到第二个事件后切断观察者和被观察者的连接mDisposable.dispose();Log.d(TAG, "已经切断了连接：" + mDisposable.isDisposed());}}@Overridepublic void onError(Throwable e) {Log.d(TAG, "对Error事件作出响应");}@Overridepublic void onComplete() {Log.d(TAG, "对Complete事件作出响应");}};

• 效果图

至此，关于RxJava的基础使用讲解完毕。

5. 总结

• 本文主要讲解 Rxjava 的基础使用，更多实例应用请看文章：Android RxJava实际应用教学：你该什么时候使用RxJava？
• Carson带你学RxJava系列文章：

入门
Carson带你学Android：这是一篇清晰易懂的Rxjava入门教程
Carson带你学Android：这是一份面向初学者的RxJava使用指南
Carson带你学Android：RxJava2.0到底更新了什么？(含使用建议)
原理
Carson带你学Android：图文解析RxJava原理
Carson带你学Android：手把手带你源码分析RxJava
使用教程(操作符)
Carson带你学Android：RxJava操作符教程
Carson带你学Android：RxJava创建操作符
Carson带你学Android：RxJava功能性操作符
Carson带你学Android：RxJava过滤操作符
Carson带你学Android：RxJava组合/合并操作符
Carson带你学Android：RxJava变换操作符
Carson带你学Android：RxJava条件/布尔操作符
应用
Carson带你学Android：什么时候应该使用Rxjava？(开发场景汇总)
Carson带你学Android：RxJava线程控制(含实例讲解)
Carson带你学Android：图文详解RxJava背压策略
Carson带你学Android：RxJava、Retrofit联合使用汇总(含实例教程)
Carson带你学Android：优雅实现网络请求嵌套回调
Carson带你学Android：网络请求轮询(有条件)
Carson带你学Android：网络请求轮询(无条件)
Carson带你学Android：网络请求出错重连(结合Retrofit)
Carson带你学Android：合并数据源
Carson带你学Android：联想搜索优化
Carson带你学Android：功能防抖
Carson带你学Android：从磁盘/内存缓存中获取缓存数据
Carson带你学Android：联合判断

欢迎关注Carson_Ho的CSDN博客 与 公众号！

请帮顶 / 评论点赞！因为你的鼓励是我写作的最大动力！