RxJava是什么？
响应式编程框架，响应式编程是一种通过异步和数据流来构建事务关系的编程模型。能够由事件来驱动事务RxJava利用响应式编程的优点，可以实现：
- ①可以通过一系列链式调用，规范代码
- ②能够通过subscribeOn和observeOn两个方法实现线程切换，通过Map，FlatMap等操作符实现中间事件的转换。
- ③与Retrofit框架配合使用较多
原理
-
RxJava： 基于 一种扩展的观察者模式
-
RxJava的扩展观察者模式中有4个角色：
| 角色 | 作用 |
|---|---|
| 被观察者（Observable） | 产生事件 |
| 观察者（Observer） | 接收事件，并给出响应动作 |
| 订阅（Subscribe） | 连接 被观察者 & 观察者， 相当于注册监听 |
| 事件（Event） | 被观察者 & 观察者 沟通的载体 |
- 这里用两根水管代替观察者和被观察者, 用通俗易懂的话把它们的关系解释清楚, 在这里我将从事件流这个角度来说明RxJava的基本工作原理。
先假设有两根水管：上面一根水管为事件产生的水管，叫它上游吧，下面一根水管为事件接收的水管叫它下游吧。
两根水管通过一定的方式连接起来，使得上游每产生一个事件，下游就能收到该事件。
这里的上游和下游就分别对应着RxJava中的Observable和Observer，它们之间的连接就对应着subscribe()，因此这个关系用RxJava来表示就是：
ChapterOne：
public static void case1() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "onNext: value = " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
打印结果如下：
08-05 17:00:05.072 24086 24086 D ChapterOne: onSubscribe
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 1
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 2
08-05 17:00:05.073 24086 24086 D ChapterOne: onNext: value = 3
08-05 17:00:05.073 24086 24086 D ChapterOne: onComplete
注意: 只有当上游和下游建立连接之后, 上游才会开始发送事件. 也就是调用了subscribe() 方法之后才开始发送事件.
- 接下来解释一下其中两个陌生的玩意：ObservableEmitter和Disposable.
ObservableEmitter： Emitter是发射器的意思，那就很好猜了，这个就是用来发出事件的，它可以发出三种类型的事件，通过调用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分别发出next事件、complete事件和error事件。
但是，请注意，并不意味着你可以随意乱七八糟发射事件，需要满足一定的规则：
(1) 上游可以发送无限个onNext, 下游也可以接收无限个onNext.
(2) 当上游发送了一个onComplete后, 上游onComplete之后的事件将会继续发送, 而下游收到onComplete事件之后将不再继续接收事件.
(3) 当上游发送了一个onError后, 上游onError之后的事件将继续发送, 而下游收到onError事件之后将不再继续接收事件.
(4) 上游可以不发送onComplete或onError.
(5) 最为关键的是onComplete和onError必须唯一并且互斥, 即不能发多个onComplete, 也不能发多个onError, 也不能先发一个onComplete, 然后再发一个onError, 反之亦然
注: 关于onComplete和onError唯一并且互斥这一点, 是需要自行在代码中进行控制, 如果你的代码逻辑中违背了这个规则, **并不一定会导致程序崩溃.
** 比如发送多个onComplete是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃.
- 介绍了ObservableEmitter, 接下来介绍Disposable, 这个单词的字面意思是一次性用品,用完即可丢弃的. 那么在RxJava中怎么去理解它呢, 对应于上面的水管的例子, 我们可以把它理解成两根管道之间的一个机关, 当调用它的dispose()方法时, 它就会将两根管道切断, 从而导致下游收不到事件. 相当于我们平时注册监听后，用完了，要反注册监听。
注意: 调用dispose()并不会导致上游不再继续发送事件, 上游会继续发送剩余的事件.
ChapterOne：
public static void case2() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "emit 1");
emitter.onNext(1);
Log.d(TAG, "emit 2");
emitter.onNext(2);
Log.d(TAG, "emit 3");
emitter.onNext(3);
Log.d(TAG, "emit onComplete");
emitter.onComplete();
Log.d(TAG, "emit 4");
emitter.onNext(4);
}
}).subscribe(new Observer<Integer>() {
private Disposable mDisposable;
private int mCount = 0;
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
mDisposable = d;
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "onNext: value = " + value);
mCount++;
if (mCount == 2) {
Log.d(TAG, "dispose");
mDisposable.dispose();
Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
}
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError: " + e.toString());
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
打印结果如下：
08-05 17:06:53.809 24399 24399 D ChapterOne: onSubscribe
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 1
08-05 17:06:53.809 24399 24399 D ChapterOne: onNext: value = 1
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 2
08-05 17:06:53.809 24399 24399 D ChapterOne: onNext: value = 2
08-05 17:06:53.809 24399 24399 D ChapterOne: dispose
08-05 17:06:53.809 24399 24399 D ChapterOne: isDisposed : true
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 3
08-05 17:06:53.809 24399 24399 D ChapterOne: emit onComplete
08-05 17:06:53.809 24399 24399 D ChapterOne: emit 4
- 另外, subscribe()有多个重载的方法:
public final Disposable subscribe() {}
public final Disposable subscribe(Consumer<? super T> onNext) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
public final void subscribe(Observer<? super T> observer) {}
线程调度
- 正常情况下, 上游和下游是工作在同一个线程中的, 也就是说上游在哪个线程发事件, 下游就在哪个线程接收事件.
ChapterOne：
public static void case3() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
emitter.onNext(1);
emitter.onComplete();
}
}).subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "accept: thread = " + Thread.currentThread());
}
});
}
打印结果如下：
08-05 19:27:09.926 29640 29640 D ChapterOne: subscribe: thread = Thread[main,5,main]
08-05 19:27:09.926 29640 29640 D ChapterOne: accept: thread = Thread[main,5,main]
- 对于一般的需求场景，需要在子线程中实现耗时的操作；然后回到主线程实现 UI操作。怎么办？
解决方案：采用 RxJava内置的线程调度器（ Scheduler ），即通过 功能性操作符subscribeOn（） & observeOn（）实现。
作用：线程控制，即指定 被观察者 （Observable） / 观察者（Observer） 的工作线程类型
线程类型：
| 类型 | 含义 | 应用场景 |
|---|---|---|
| Schedulers.immediate() | 当前线程 = 不指定线程 | 默认 |
| AndroidSchedulers.mainThread() | Android主线程 | 操作UI |
| Schedulers.newThread() | 常规新线程 | 耗时等操作 |
| Schedulers.io() | io操作线程 | 网络请求、读写文件等io密集型操作 |
| Schedulers.computation() | CPU计算操作线程 | 大量计算操作 |
- 具体使用
public static void case4() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
emitter.onNext(1);
emitter.onComplete();
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "accept: thread = " + Thread.currentThread());
}
});
}
特殊注意：
- （1） 若Observable.subscribeOn（）多次指定被观察者 生产事件的线程，则只有第一次指定有效，其余的指定线程无效。
- （2） 若Observable.observeOn（）多次指定观察者 接收 & 响应事件的线程，则每次指定均有效，即每指定一次，就会进行一次线程的切换。
ChapterOne：
public static void case5() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "subscribe: thread = " + Thread.currentThread());
emitter.onNext(1);
emitter.onComplete();
}
})
.subscribeOn(Schedulers.io())
.subscribeOn(Schedulers.newThread())
.doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doOnNext accept: thread = " + Thread.currentThread());
}
})
.observeOn(Schedulers.computation())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "onNext: accept: thread = " + Thread.currentThread());
}
});
}
- 实例：读写数据库
public Observable<List<Record>> readAllRecords() {
return Observable.create(new ObservableOnSubscribe<List<Record>>() {
@Override
public void subscribe(ObservableEmitter<List<Record>> emitter) throws Exception {
Cursor cursor = null;
try {
cursor = getReadableDatabase().rawQuery("select * from " + TABLE_NAME, new String[]{});
List<Record> result = new ArrayList<>();
while (cursor.moveToNext()) {
result.add(Db.Record.read(cursor));
}
emitter.onNext(result);
emitter.onComplete();
} finally {
if (cursor != null) {
cursor.close();
}
}
}
}).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread());
}
readAllRecords().subscribe(new Consumer<List<Record>>() {
@Override
public void accept(List<Record> recordList) throws Exception {
}
})
以上是Android开发中-rxjava的一些原理浅析，Android的知识学习还有许多，可以前往以下链接：
传送直达↓↓↓ docs.qq.com/doc/DUkNRVF…
文末
RxJava的整体结构是一条链，其中有这三个角色。
- 链的上游：生产者 Observable
- 链的下游：观察者 Observer
- 链的中间：各个中介节点，既是下游的Observable，又是上游的Observer
