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);
}
});
}
}
下一篇文章将针对订阅流程以及线程管理的源码进行分析