java2和,RxJava2的使用与原理浅析（一）

前言

首先，感谢以下作者分享自己对于RxJava的理解

给 Android 开发者的 RxJava 详解

针对RxJava1.×，入门必备

RxJava2 只看这一篇文章就够了 - 掘金

RxJava2的API大全，适合需要使用对应APID时作为资料查看

本文设计源码以及介绍均是基于RxJava2，示例均是为了示例而示例，项目中要使用RxJava，首先在gradle中添加依赖：

implementation 'io.reactivex.rxjava2:rxjava:2.1.4'

implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'

一、RxJava2简介

什么是RxJava

A library for composing asynchronous and event-based programs by using observable sequences.

一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库

引用RxJava Github Readme中的介绍，可能看起来仍然让人感到费解，我的理解是：

使用观察者模式，采用链式编程，基于事件的实现异步的库

到这里，没有使用过RxJava的话，一定还是不知道这个库究竟是做什么的，没关系，我们慢慢道来。首先我们需要知道RxJava究竟解决了什么问题。

RxJava解决了什么问题

即使没有使用过，一定也听说过RxJava，RxJava应用如此广泛，那么它究竟解决了什么问题呢？一个词：异步，但是同样是异步，可以使用的工具有很多，我们为什么偏偏要使用RxJava呢？

为什么使用RxJava

我们知道，Android中实现异步的方式有很多，Handler、AsyncTask、runOnUiThread等，为什么我们就要使用RxJava来实现异步呢？换言之，RxJava相比其他实现异步的方法有什么优势呢？最大的优势就是逻辑清晰。

假设有这样一个需求：界面上有一个自定义的视图 imageCollectorView ，它的作用是显示多张图片，并能使用 add(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在 imageCollectorView 中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在 UI 线程执行。常用的实现方式有多种，我这里贴出其中一种：

new Thread(() -> {

for (File folder : folders) {

File[] files = folder.listFiles();

for (File file : files) {

if (file.getName().endsWith(".png")) {

final Bitmap bitmap = getBitmapFromFile(file);

runOnUiThread(() -> imageCollectorView.add(bitmap));

}

}

}

}).start();

而如果使用RxJava，实现方式是这样的：

Observable.fromArray(folders)

.flatMap((Function>) folder -> Observable.fromArray(folder.listFiles()))

.filter(file -> file.getName().endsWith("png"))

.map((Function) file -> getBitmapFromFile(file))

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe(bitmap -> imageCollectorView.add(bitmap));

一定有人会觉得，这完全没有简洁呀，哪里看出来简洁了，上面所说的简洁只是逻辑简洁，而非代码简洁。

观察一下，你就会发现，使用RxJava，是一条链式调用下来的，完全没有任何嵌套，这种优势在需求变得复杂之后，优势会更加明显，比如我们现在增加一条需求，只需要加载前十张图片，不使用RxJava要怎么去做呢？相信大家都会做，不妨实现去看看，而如果是使用RxJava，修改后的实现如下：

Observable.fromArray(folders)

.flatMap((Function>) folder -> Observable.fromArray(folder.listFiles()))

.filter(file -> file.getName().endsWith("png"))

.map((Function) file -> getBitmapFromFile(file))

.take(LOAD_IMAGE_NUM)

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe(bitmap -> imageCollectorView.add(bitmap));

可以看到，仅仅只增加了一行代码，且未新增任何嵌套。

所以RxJava最大的优势就是简洁，无论逻辑如何复杂，总是一条链式调用的简洁。

二、基本使用

在分析RxJava的原理之前，我们首先要了解一下观察者模式，如果已经熟知观察者模式，可以跳过这段。

观察者模式

先让我们想象一下生活中一个场景：

读者(观察者)发现一个微信公众号(被观察者)很不错，希望长期关注，于是便关注(注册)了这个微信公众号，当这个微信公众号发布了一篇新的文章，关注了该微信公众号的读者就会接收到通知(被观察者发送通知给注册了的观察者)，如果读者不再关注(注销)该微信公众号，就再不会接收到通知了

以上就是一个典型的观察者模式的流程，生活中像这样的场景还有很多，那么什么是观察者模式呢？

概念

引用《Head First设计模式》一书中的原话

观察者模式定义了对象之间一对多的依赖，这样一来，当该对象改变状态时，它的所有依赖者会受到通知并自动更新

——Head First设计模式

以下是观察者模式UML图

观察者模式UML图

我们可以看到，观察者模式首先定义了两个接口类：Observable(被观察者)、Observer(观察者)，

Observable接口中包含三个方法

registerObserver()注册

removeObserver()注销

notifyObservers()发送通知

Observer接口中包含一个方法

update()观察者接收到通知后的行为

以上两个接口，很简单，在这里我就不贴代码了，那么实现类要怎么做呢？

以下是实现类的代码

Observable实现类：

public class ConcreteObservable implements Observable {

private static final String TAG = ConcreteObservable.class.getSimpleName();

List observers;

public ConcreteObservable(){

observers = new ArrayList<>();

}

@Override

public void register(Observer observer) {

if (observer == null) {

throw new NullPointerException("observer cannot be null");

}

if (observers.contains(observer)) {

Log.d("TAG", "you have registered this");

} else {

Log.d("TAG", observer.toString() + " register");

observers.add(observer);

}

}

@Override

public void removeObserver(Observer observer) {

if (observer == null) {

throw new NullPointerException("observer cannot be null");

}

if (observers.contains(observer)) {

Log.d("TAG", observer.toString() + " remove");

observers.remove(observer);

} else {

Log.d("TAG", "you have not registered this");

}

}

@Override

public void notifyObservers() {

for (Observer observer : observers) {

observer.update();

}

}

Observer实现类：

public class TomObserver implements Observer {

private static final String TAG = TomObserver.class.getSimpleName();

@Override

public void update() {

Log.d("TAG", "notify Tom");

}

@Override

public String toString() {

return "Tom";

}

}

public class KittyObserver implements Observer {

@Override

public void update() {

Log.d("TAG", "notify Kitty");

}

@Override

public String toString() {

return "Kitty";

}

}

使用：

public class MainActivity extends AppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

Observer tomObserver = new TomObserver(), kittyObserver = new KittyObserver();

Observable observable = new ConcreteObservable();

observable.register(tomObserver);

observable.register(kittyObserver);

observable.notifyObservers();

observable.removeObserver(tomObserver);

observable.notifyObservers();

}

}

打印日志

D/TAG: Tom register

D/TAG: Kitty register

D/TAG: notify Tom

D/TAG: notify Kitty

D/TAG: Tom remove

D/TAG: notify Kitty

观察者模式在RxJava中的应用

RxJava中有四个概念，Observable(被观察者)、Observer(观察者)、subscribe(订阅)、事件，

Observer和Observable通过subscribe方法实现订阅，从而Observable发送事件时，Observer可以收到相关通知。

与标准观察者模式不同的是，RxJava除了onNext(对应标准观察者模式的notifyObservers())事件以外，还有onError()和onComplete()，当Observable发送完一系列onNext()事件后，必须调用onComplete()标志着事件序列的结束，中间如果出现错误，便会走到onError()事件，这两个事件均只会被调用一次，且是相互排斥的，即走到了onComplete()就不会走到onError()，反之亦然。

基本实现

Observable(被观察者)

Observable observable = Observable.create(emitter -> {

emitter.onNext("Hello, observer");

emitter.onComplete();

});

可以看到通过Observable.create()方法创建了Observable对象，方法中传入了ObservableOnSubscribe对象，这个类中使用了泛型，这里的泛型就对应着onNext()事件传入的参数类型，以上例子这里的数据类型是String，在传入的ObservableOnSubscribe对象中，重写了subscribe方法，上述例子发送了一个onNext()事件，又发送了一个onComplete()事件，告诉Observer事件序列结束，不会再有新的onNext()事件。

当然，Observable对象并不止这一种创建方式，RxJava提供了很多相关的API，例如fromArray()、just()等等，暂且按下不表。

Observer(观察者)

Observer observer = new Observer() {

@Override

public void onSubscribe(Disposable d) {

Log.d("TAG", "onSubscribe");

}

@Override

public void onNext(String o) {

Log.d("TAG", o);

}

@Override

public void onError(Throwable e) {

Log.d("TAG", "onError");

}

@Override

public void onComplete() {

Log.d("TAG", "onComplete");

}

};

创建Observer对象需要重写四个方法，可以看到其中三个重写的方法刚好对应三个事件，可以猜测，Observable发送的事件应该是交由对应的方法处理，但是多出来的onSubscribe()方法是做什么的呢？onSubscribe()方法是在Observable发送事件前被调用的，稍后会说到这点。

当然，RxJava中的观察者对象并不止Observer这一个类，RxJava还提供了一些其他的类供实现，例如Consumer等。

subscribe(订阅)

observable.subscribe(observer);

这一步就非常简单，但是会发现这里有个奇怪的地方，正常流程应该是观察者订阅被观察者，但是这里却是被观察者订阅观察者，显然，observer.subscribe(observable)这样的写法更加容易让读者接受

过如果把 API 设计成 observer.subscribe(observable) / subscriber.subscribe(observable) ，虽然更加符合思维逻辑，但对流式 API 的设计就造成影响了，比较起来明显是得不偿失的。

以上引用扔物线的一段话

RxJava中线程控制

有一些读者一定好奇，说了半天，好像也没有看到实现了异步呀，别着急，这就介绍RxJava是如何在这个链式编程中实现异步的。

我们看一下下面的示例代码

Observable

.create((ObservableOnSubscribe) emitter -> {

//模拟网络访问流程

Log.d("TAG", "subscribe " + Thread.currentThread().getName());

Thread.sleep(200);

emitter.onNext("json ");

emitter.onComplete();

})

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

Log.d("TAG", "onSubscribe " + Thread.currentThread().getName());

}

@Override

public void onNext(String s) {

Log.d("TAG", s + Thread.currentThread().getName());

}

@Override

public void onError(Throwable e) {

Log.d("TAG", "onError " + Thread.currentThread().getName());

}

@Override

public void onComplete() {

Log.d("TAG", "onComplete " + Thread.currentThread().getName());

}

});

以下是日志

D/TAG: onSubscribe main

D/TAG: subscribe RxCachedThreadScheduler-1

D/TAG: json main

D/TAG: onComplete main

我们发现，Observable发送事件的方法是运行在子线程的，而Observer处理事件的方法均是运行在主线程(UI线程)，而我们仅仅只是增加了两行代码，就实现了异步编程，是不是很方便呢？但是有一个例外，onSubscribe()方法根据日志打印，是运行在主线程的，那么它真的就是和其他的事件一样，由于增加了两行代码，运行在了主线程吗？我们让这个任务在子线程运行，再看看打印的日志

D/TAG: onSubscribe Thread-4

D/TAG: subscribe RxCachedThreadScheduler-1

D/TAG: json main

D/TAG: onComplete main

由此我们知道，onSubscribe()既不是运行在发送事件的线程，也不是运行在处理事件的线程，而是运行在当前线程，具体这是为什么呢，我们后面会介绍。现在我们先来看一下，增加的两行代码究竟是什么意思呢？

.subscribeOn(Schedulers.io())

.observeOn(AndroidSchedulers.mainThread())

subscribeOn(Scheduler scheduler)方法定义了发送事件运行的线程，而observeOn(Scheduler scheduler)方法则是指定处理事件运行的线程，RxJava中也指定了一些可以直接使用的Scheduler

AndroidSchedulers.mainThread()

Android主线程，即UI线程

Schedulers.newThread()

创建一个新的线程

Schedulers.io()

用于 IO 密集型任务，如果异步阻塞 IO 操作。

Schedulers.computation()

用于使用计算任务，如事件循环和回调处理

Schedulers.trampoline()

当前线程

Schedulers.single()

单线程，如果线程中有正在处理的任务，新来的任务会进入等待队列

Schedulers.from(Executor executor)

指定一个线程池

常用Api

创建操作符

1. create()

有什么用

创建一个Observable

怎么用

Observable

.create((ObservableOnSubscribe) emitter -> {

emitter.onNext("1");

emitter.onNext("2");

emitter.onNext("3");

emitter.onComplete();

})

.subscribe((s -> Log.d(TAG, "onNext: " + s)));

日志打印

D/MainActivity: onNext: 1

D/MainActivity: onNext: 2

D/MainActivity: onNext: 3

2. just()

有什么用

传入不超过十个对象，依次发送

怎么用

Observable.just(1, 3, 5)

.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "onNext: " + integer);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

Log.d(TAG, "onComplete");

}

});

日志打印

D/MainActivity: onNext: 1

D/MainActivity: onNext: 3

D/MainActivity: onNext: 5

D/MainActivity: onComplete

3. fromArray()

有什么用

与just()类似，只不过fromArray()可以传入超过10个item，也可以传入数组、集合等

怎么用

Integer[] array = {1, 3, 5};

Observable.fromArray(array)

.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "onNext: " + integer);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

Log.d(TAG, "onComplete");

}

});

日志打印

D/MainActivity: onNext: 1

D/MainActivity: onNext: 3

D/MainActivity: onNext: 5

D/MainActivity: onComplete

注意：这里的数组必须是对象数组，而不能是基本类型数组

4. fromCallable()

有什么用

这里的 Callable 是 java.util.concurrent 中的 Callable，Callable 和 Runnable 的用法基本一致，只是它会返回一个结果值，这个结果值就是发给观察者的。

怎么用

Observable.fromCallable(() -> 1)

.subscribe(integer -> Log.d(TAG, "accept" + integer));

日志打印

D/MainActivity: accept: 1

5. timer()

有什么用

指定时间倒计时结束后，会发送一个0L的值给观察者

怎么用

Observable.timer(5, TimeUnit.SECONDS)

.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "onSubscribe");

}

@Override

public void onNext(Long aLong) {

Log.d(TAG, "onNext: " + aLong);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

});

日志打印

2019-05-20 21:59:42.912 5248-5248/com.danc.calendartext D/MainActivity: onSubscribe

2019-05-20 21:59:47.918 5248-5302/com.danc.calendartext D/MainActivity: onNext: 0

可以看到，onSubscribe之后隔了5s中，接收到onNext事件

6. interval()

有什么用

每隔指定时间发送一个事件，这个事件包含一个数字，从0开始，每次自增1

怎么用

Observable.interval(0, 1, TimeUnit.SECONDS)

.subscribe(aLong -> {

Log.d(TAG, "计时(s): " + aLong);

});

日志打印

2019-05-20 22:03:29.786 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 0

2019-05-20 22:03:30.786 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 1

2019-05-20 22:03:31.786 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 2

2019-05-20 22:03:32.787 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 3

2019-05-20 22:03:33.786 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 4

2019-05-20 22:03:34.786 5375-5420/com.danc.calendartext D/MainActivity: 计时(s): 5

转化操作符

1. map()

有什么用

将被观察者发送的数据类型转换为其他类型

怎么用

以下实例将Integer类型转换为String

Observable.just(1, 3, 5)

.map(integer -> "--" + integer)

.subscribe(s -> Log.d(TAG, "accept: " + s));

日志打印

2019-05-20 22:05:58.079 5494-5494/com.danc.calendartext D/MainActivity: accept: --1

2019-05-20 22:05:58.079 5494-5494/com.danc.calendartext D/MainActivity: accept: --3

2019-05-20 22:05:58.079 5494-5494/com.danc.calendartext D/MainActivity: accept: --5

2. flatMap()

有什么用

这个方法可以将事件序列中的元素进行整合加工，返回一个新的被观察者。

怎么用

flatMap() 其实与 map() 类似，但是 flatMap() 返回的是一个 Observerable。现在用一个例子来说明 flatMap() 的用法。

假设一个有一个 Person 类，这个类的定义如下：

public class Person {

private String name;

private List planList = new ArrayList<>();

public Person(String name, List planList) {

this.name = name;

this.planList = planList;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public List getPlanList() {

return planList;

}

public void setPlanList(List planList) {

this.planList = planList;

}

}

Person 类有一个 name 和 planList 两个变量，分别代表的是人名和计划清单。

Plan 类的定义如下：

public class Plan {

private String time;

private String content;

private List actionList = new ArrayList<>();

public Plan(String time, String content) {

this.time = time;

this.content = content;

}

public String getTime() {

return time;

}

public void setTime(String time) {

this.time = time;

}

public String getContent() {

return content;

}

public void setContent(String content) {

this.content = content;

}

public List getActionList() {

return actionList;

}

public void setActionList(List actionList) {

this.actionList = actionList;

}

}

现在有一个需求就是要将 Person 集合中的每个元素中的 Plan 的 action 打印出来。

首先用 map() 来实现这个需求看看：

Observable.fromIterable(personList)

.map(new Function < Person, List < Plan >> () {

@Override

public List < Plan > apply(Person person) throws Exception {

return person.getPlanList();

}

})

.subscribe(new Observer < List < Plan >> () {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(List < Plan > plans) {

for (Plan plan: plans) {

List < String > planActionList = plan.getActionList();

for (String action: planActionList) {

Log.d(TAG, "==================action " + action);

}

}

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

});

可以看到 onNext() 用了嵌套 for 循环来实现，如果代码逻辑复杂起来的话，可能需要多重循环才可以实现。

现在看下使用 flatMap() 实现：

Observable.fromIterable(personList)

.flatMap(new Function < Person, ObservableSource < Plan >> () {

@Override

public ObservableSource < Plan > apply(Person person) {

return Observable.fromIterable(person.getPlanList());

}

})

.flatMap(new Function < Plan, ObservableSource < String >> () {

@Override

public ObservableSource < String > apply(Plan plan) throws Exception {

return Observable.fromIterable(plan.getActionList());

}

})

.subscribe(new Observer < String > () {

@Override

public void onSubscribe(Disposable d) {

}

@Override

public void onNext(String s) {

Log.d(TAG, "==================action: " + s);

}

@Override

public void onError(Throwable e) {

}

@Override

public void onComplete() {

}

});

从代码可以看出，只需要两个 flatMap() 就可以完成需求，并且代码逻辑非常清晰。

组合操作符

1. zip()

有什么用

将两个被观察者事件整合发送给观察者，事件数量与两个观察这种事件数量较小的相同

怎么用

Observable.zip(Observable.intervalRange(1, 5, 1, 2, TimeUnit.SECONDS)

.map(aLong -> {

String s1 = "A" + aLong;

Log.d(TAG, "===================A 发送的事件 " + s1);

return s1;

}).subscribeOn(Schedulers.io()),

Observable.intervalRange(1, 6, 1, 1, TimeUnit.SECONDS)

.map(aLong -> {

String s2 = "B" + aLong;

Log.d(TAG, "===================B 发送的事件 " + s2);

return s2;

}).subscribeOn(Schedulers.io()),

(s, s2) -> {

String res = s + s2;

return res;

})

.subscribe(new Observer() {

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "===================onSubscribe ");

}

@Override

public void onNext(String s) {

Log.d(TAG, "===================onNext " + s);

}

@Override

public void onError(Throwable e) {

Log.d(TAG, "===================onError ");

}

@Override

public void onComplete() {

Log.d(TAG, "===================onComplete ");

}

});

日志打印：

2019-05-20 22:19:10.293 6183-6183/com.danc.calendartext D/MainActivity: ===================onSubscribe

2019-05-20 22:19:11.308 6183-6210/com.danc.calendartext D/MainActivity: ===================A 发送的事件 A1

2019-05-20 22:19:11.308 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B1

2019-05-20 22:19:11.308 6183-6209/com.danc.calendartext D/MainActivity: ===================onNext A1B1

2019-05-20 22:19:12.307 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B2

2019-05-20 22:19:13.307 6183-6210/com.danc.calendartext D/MainActivity: ===================A 发送的事件 A2

2019-05-20 22:19:13.307 6183-6210/com.danc.calendartext D/MainActivity: ===================onNext A2B2

2019-05-20 22:19:13.307 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B3

2019-05-20 22:19:14.308 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B4

2019-05-20 22:19:15.306 6183-6210/com.danc.calendartext D/MainActivity: ===================A 发送的事件 A3

2019-05-20 22:19:15.307 6183-6210/com.danc.calendartext D/MainActivity: ===================onNext A3B3

2019-05-20 22:19:15.307 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B5

2019-05-20 22:19:16.307 6183-6209/com.danc.calendartext D/MainActivity: ===================B 发送的事件 B6

2019-05-20 22:19:17.307 6183-6210/com.danc.calendartext D/MainActivity: ===================A 发送的事件 A4

2019-05-20 22:19:17.308 6183-6210/com.danc.calendartext D/MainActivity: ===================onNext A4B4

2019-05-20 22:19:19.307 6183-6210/com.danc.calendartext D/MainActivity: ===================A 发送的事件 A5

2019-05-20 22:19:19.307 6183-6210/com.danc.calendartext D/MainActivity: ===================onNext A5B5

2019-05-20 22:19:19.307 6183-6210/com.danc.calendartext D/MainActivity: ===================onComplete

功能操作符

1. delay()

有什么用

订阅后，延迟一段时间发送事件

怎么用

Observable.just(1, 3, 5)

.delay(2, TimeUnit.SECONDS)

.subscribe(integer -> Log.d(TAG, "accept: " + integer));

打印日志

2019-05-20 22:24:53.879 6430-6430/com.danc.calendartext D/MainActivity: onSubscribe

2019-05-20 22:24:55.881 6430-6475/com.danc.calendartext D/MainActivity: accept: 1

2019-05-20 22:24:55.881 6430-6475/com.danc.calendartext D/MainActivity: accept: 3

2019-05-20 22:24:55.882 6430-6475/com.danc.calendartext D/MainActivity: accept: 5

从日志可以暗处，订阅之后延迟2s开始发送事件

2. doOnNext()

有什么用

每次收到onNext()事件，先执行doOnNext()

怎么用

Observable.create((ObservableOnSubscribe) e -> {

e.onNext(1);

e.onNext(2);

e.onNext(3);

e.onComplete();

})

.doOnNext(integer -> Log.d(TAG, "doOnNext " + integer))

.subscribe(new Observer < Integer > () {

@Override

public void onSubscribe(Disposable d) {

Log.d(TAG, "onSubscribe ");

}

@Override

public void onNext(Integer integer) {

Log.d(TAG, "onNext " + integer);

}

@Override

public void onError(Throwable e) {

Log.d(TAG, "onError ");

}

@Override

public void onComplete() {

Log.d(TAG, "onComplete ");

}

});

日志打印

D/MainActivity: onSubscribe

D/MainActivity: doOnNext 1

D/MainActivity: onNext 1

D/MainActivity: doOnNext 2

D/MainActivity: onNext 2

D/MainActivity: doOnNext 3

D/MainActivity: onNext 3

D/MainActivity: onComplete

想要查看更多的RxJava2的API，可以看下面这篇文章。这篇文章更像是查阅的资料，只需要通览了解一遍即可，熟悉常用的API，其余有个印象，需要的时候再查阅

RxJava2 只看这一篇文章就够了 - 掘金

生命周期管理

RxJava固然很好用，但是使用不当，很容易造成内存泄漏。

比如，使用RxJava发布一个订阅后，当Activity被finish，此时订阅逻辑还未完成，如果没有及时取消订阅，就会导致Activity无法被回收，从而引发内存泄漏。

目前，针对以上这种情况，主流的有两种解决方案：

通过封装，手动控制每一次订阅，在合适的时机取消订阅

使用RxLifecycle，关注Fragment、Activity的生命周期，在onDestroy()生命周期中自动取消订阅

手动实现

以下是基于MVP架构封装的

protected CompositeDisposable compositeDisposable;

@UiThread

public void attachView(V view) {

mView = view;

compositeDisposable = new CompositeDisposable();

}

@UiThread

public void detachView() {

mView = null;

if (compositeDisposable != null) {

compositeDisposable.clear();

compositeDisposable = null;

}

}

如何使用

在每次发生订阅关系时，将返回的Disposable实例保存在CompositeDisposable中，在onDestroy()生命周期解除所有的订阅关系

RxLifecycle

1. 添加依赖

在项目中添加以下依赖

implementation 'com.trello.rxlifecycle2:rxlifecycle:2.2.1'

implementation 'com.trello.rxlifecycle2:rxlifecycle-android:2.2.1'

implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.2.1'

2. 绑定生命周期

RxLifecycle提供了大量的Activity、Fragment以供继承

RxLifecycle支持的Component、

代码如下：

public class MainActivity extends RxAppCompatActivity {

...

...

}

使用bindToLifecycle()

以Activity为例，在Activity中使用bindToLifecycle()方法，完成Observable发布的事件和当前的组件绑定，实现生命周期同步。从而实现当前组件生命周期结束时，自动取消对Observable订阅，代码如下：

public class MainActivity extends RxAppCompatActivity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

// 当执行onDestory()时， 自动解除订阅

Observable.interval(1, TimeUnit.SECONDS)

.doOnDispose(new Action() {

@Override

public void run() throws Exception {

Log.i(TAG, "Unsubscribing subscription from onCreate()");

}

})

.compose(this.bindToLifecycle())

.subscribe(new Consumer() {

@Override

public void accept(Long num) throws Exception {

Log.i(TAG, "Started in onCreate(), running until onDestory(): " + num);

}

});

}

}

下一篇文章将针对订阅流程以及线程管理的源码进行分析