RxJava2.0简介
[toc]
1.定义 RxJava是响应式编程(Reactive Extensions)在JVM平台上的实现，即用Java语言实现的一套基于观察者模式的异步编程接口。
响应式编程是一种基于异步数据流概念的编程模式。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。
响应式编程的一个关键概念是事件。事件可以被等待，可以触发过程，也可以触发其它事件。事件是唯一的以合适的方式将我们的现实世界映射到我们的软件中：如果屋里太热了我们就打开一扇窗户。同样的，当我们的天气app从服务端获取到新的天气数据后，我们需要更新app上展示天气信息的UI；汽车上的车道偏移系统探测到车辆偏移了正常路线就会提醒驾驶者纠正，就是是响应事件。
今天，响应式编程最通用的一个场景是UI：我们的移动App必须做出对网络调用、用户触摸输入和系统弹框的响应。在这个世界上，软件之所以是事件驱动并响应的是因为现实生活也是如此。
2.引用 在app的gradle文件中添加这两行代码即可。
implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'
3.使用 3.1 Observable和Observer
这两根水管连接起来，上游发送事件1，2，3，而下游则依次接受到事件1，2，3。
在RxJava中，上游被称为Observable（观察得到的），下游被称为Observer（观察者），连接Observable与Observer的方法被称为subscribe()，用RxJava写的话就是这样：
Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
e.onComplete();
}
});
Observer<Integer> observer = new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
}
@Override
public void onNext(Integer value) {
Log.i(TAG, "onNext: " + value);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
};
observable.subscribe(observer);
2020-03-27 01:25:10.920 7786-7786/com.example.uitestdemo I/TestRxActivity: onSubscribe:
2020-03-27 01:25:10.920 7786-7786/com.example.uitestdemo I/TestRxActivity: emitter1:
2020-03-27 01:25:10.920 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: 1
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: emitter2:
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: 2
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: emitter3:
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: 3
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: onComplete:
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: onComplete:
2020-03-27 01:25:10.921 7786-7786/com.example.uitestdemo I/TestRxActivity: emitter4:
3.2 ObservableEmitter和Disposable
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
Log.i(TAG, "subscribe: 1");
e.onNext(1);
Log.i(TAG, "subscribe: 2");
e.onNext(2);
Log.i(TAG, "subscribe: 3");
e.onNext(3);
Log.i(TAG, "subscribe: complete");
e.onComplete();
Log.i(TAG, "subscribe: 4");
e.onNext(4);
}
}).subscribe(new Observer<Integer>() {
private Disposable disposable;
private int count;
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "onSubscribe: ");
disposable = d;
}
@Override
public void onNext(Integer value) {
Log.i(TAG, "onNext: " + value);
count++;
if (count == 2) {
disposable.dispose();
Log.i(TAG, "onNext: dispose");
Log.i(TAG, "onNext: " + disposable.isDisposed());
}
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError: ");
}
@Override
public void onComplete() {
Log.i(TAG, "onComplete: ");
}
});
2020-03-27 01:24:56.928 7786-7786/com.example.uitestdemo I/TestRxActivity: onSubscribe:
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: subscribe: 1
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: 1
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: subscribe: 2
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: 2
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: dispose
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: onNext: true
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: subscribe: 3
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: subscribe: complete
2020-03-27 01:24:56.929 7786-7786/com.example.uitestdemo I/TestRxActivity: subscribe: 4
在上面的代码中，除过Observable与Observer外，还混入了两个奇怪的东西，ObservableEmitter和Disposable。
Emitter是发射器的意思，而ObservableEmiiter的含义便可想而知了，用来发射事件的。 ObservableEmitter可以发送三种类型的事件，通过调用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是可以正常运行的, 依然是收到第一个onComplete就不再接收了, 但若是发送多个onError, 则收到第二个onError事件会导致程序会崩溃。
3.3 RxJava中的线程操作 在默认情况下，RxJava中的Observable与Observer都运行在主线程中，试一下。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
Log.i(TAG, "subscribe: " + Thread.currentThread().getName());
}
}).subscribeOn(Schedulers.io())
.subscribeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.i(TAG, "accept: " + integer);
Log.i(TAG, "accept: " + Thread.currentThread().getName());
}
});
2020-03-27 01:24:41.831 7786-8259/com.example.uitestdemo I/TestRxActivity: subscribe: RxCachedThreadScheduler-4
2020-03-27 01:24:41.832 7786-7786/com.example.uitestdemo I/TestRxActivity: accept: 1
2020-03-27 01:24:41.832 7786-7786/com.example.uitestdemo I/TestRxActivity: accept: main
先看两个方法。
subscribeOn() 指定的是上游发送事件的线程,，observeOn() 指定的是下游接收事件的线程。
多次指定上游的线程只有第一次指定的有效,，也就是说多次调用subscribeOn() 只有第一次的有效， 其余的会被忽略。
多次指定下游的线程是可以的,，也就是说每调用一次observeOn() , 下游的线程就会切换一次。
当然，在RxJava中也内置了多种线程选线供我们使用。这些内置的Scheduler已经足够满足我们开发的需求， 因此我们应该使用内置的这些选项,，在RxJava内部使用的是线程池来维护这些线程, 所以效率也比较高。
名称 含义 Schedulers.io() 代表io操作的线程, 通常用于网络,读写文件等io密集型的操作 Schedulers.computation() 代表CPU计算密集型的操作, 例如需要大量计算的操作 Schedulers.newThread() 代表一个常规的新线程 AndroidSchedulers.mainThread() 代表Android的主线程
RxJava2.0操作符
Map与FlatMap 那什么是操作符？
RxJava中的操作符就是为了提供函数式的特性，函数式最大的好处就是使得数据处理简洁易懂。操作符实质上就是RxJava函数式编程模式的体现。在我看来，函数就是变换关系的简称，比如在有一个数字集合A，又有一个数字集合B，从数字集合A变换到数字集合B的的这种关系，可以将其称为函数。
RxJava创建型操作符
create操作符
just()操作符
timer()操作符
interval()操作符
fromArray()操作符
fromIterable()操作符
differ()操作符
intervalRange()操作符
range()操作符
rangeLong()操作符
其他
RxJava变换操作符
map()操作符
flatMap()操作符
concatMap()操作符
buffer()操作符
RxJava组合/合并操作符
concat()操作符
concatArray()操作符
merge()操作符
mergeArray()操作符
concatDelayError()操作符
mergeDelayError()操作符
zip()操作符
combineLatest()操作符
combineLatestDelayError()操作符
reduce()操作符
collect()操作符
startWith()操作符
count()操作符
RxJava功能型操作符
subscribe()操作符
subscribeOn() & observeOn()操作符
delay()操作符
do操作符
onErrorReturn()操作符
onErrorResumeNext()
onExceptionResumeNext()操作符
retry()操作符
retryUntil()操作符
retryWhen()操作符
repeat()操作符
repeatWhen()操作符
debounce()操作符
RxJava过滤操作符
filter()操作符
ofType()操作符
skip() / skipLast()操作符
distinct() / distinctUntilChanged()操作符
take() & takeLast()操作符
throttleFirst() / throttleLast()操作符
sample()操作符
throttleWithTimeout()操作符
firstElement() / lastElement()操作符
elementAt()操作符
elementAtOrError()操作符
ignoreElements() 操作符
RxJava条件/布尔操作符
all()操作符
takeWhile()操作符
skipWhile()操作符
takeUntil()操作符
skipUntil()操作符
sequenceEqual()操作符
contains()操作符
isEmpty()操作符
amb()操作符
defaultIfEmpty()操作符
RxJava创建型操作符
create
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();
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "这是:" + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, s);
}
});
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:1
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:2
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:3
可以看到，我们在Observable中输入的是int类型，但是到了Consumer上，却变为了String类型，起作用的就是中间的map函数，它将String类型变为了int类型。
just()操作符
Observable.just(1, 2, 3, 4).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe（）
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
。。。。。
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 开始采用subscribe连接
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 接收到了事件1
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 接收到了事件2
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 接收到了事件3
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 接收到了事件4
2020-03-31 19:00:16.736 3203-3203/com.example.uitestdemo I/TestRxActivity: 对Complete事件作出响应
fromArray()操作符
作用：快速创建1个被观察者对象，直接发送传入的数组数据，可以发送10个以上事件，可用于数组遍历 示例代码：
public void fromArray() {
// 1. 设置需要传入的数组, 快速创建被观察者对象（Observable） & 可发送10个以上事件（数组形式）
// 可用于对数组进行遍历
// 注：若直接传递一个list集合进去，否则会直接把list当做一个数据元素发送
Integer[] items = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Observable.fromArray(items).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
2020-03-31 19:02:41.758 4014-4014/com.example.uitestdemo D/TestRxActivity: 开始采用subscribe连接
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件0
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件1
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件2
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件3
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件4
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件5
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件6
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件7
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件8
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件9
2020-03-31 19:02:41.759 4014-4014/com.example.uitestdemo D/TestRxActivity: 接收到了事件10
2020-03-31 19:02:41.760 4014-4014/com.example.uitestdemo D/TestRxActivity: 对Complete事件作出响应
timer()操作符
作用：快速创建1个被观察者对象，直接发送传入的数组数据，可以发送10个以上事件，可用于数组遍历 示例代码：
public void timer() {
//延时2s发送一个事件, 会发送一个long类型数值0，等同于延时2s后调用一次onNext(0)触发事件
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
2020-03-31 19:06:05.788 4504-4705/com.example.uitestdemo D/TestRxActivity: 接收到了事件0
2020-03-31 19:06:05.791 4504-4705/com.example.uitestdemo D/TestRxActivity: 对Complete事件作出响应
interval()操作符
作用：快速创建1个被观察者对象，每隔指定时间发送1个事件（从0开始无限递增1的整数序列） 示例代码：
public void interval() {
// 延迟3s后，每隔1秒发送1个事件, 产生1个数字（从0开始递增1，无限个）
Observable.interval(3, 1, TimeUnit.SECONDS)
//.interval(300, TimeUnit.MILLISECONDS) //每个0.3秒发送一个事件
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
2020-03-31 19:06:12.793 4504-4706/com.example.uitestdemo D/TestRxActivity: 接收到了事件6
2020-03-31 19:06:13.758 1911-2393/? D/NetworkController.MobileSignalController(1): 4G level = 5
2020-03-31 19:06:13.792 4504-4706/com.example.uitestdemo D/TestRxActivity: 接收到了事件7
2020-03-31 19:06:14.793 4504-4706/com.example.uitestdemo D/TestRxActivity: 接收到了事件8
2020-03-31 19:06:15.793 4504-4706/com.example.uitestdemo D/TestRxActivity: 接收到了事件9
interval()操作符
作用：快速创建1个被观察者对象，每隔指定时间发送1个事件（从0开始无限递增1的整数序列） 示例代码：
public void interval() {
// 延迟3s后，每隔1秒发送1个事件, 产生1个数字（从0开始递增1，无限个）
Observable.interval(3, 1, TimeUnit.SECONDS)
//.interval(300, TimeUnit.MILLISECONDS) //每个0.3秒发送一个事件
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
intervalRange()操作符
作用：快速创建1个被观察者对象，每隔指定时间发送1个事件，可指定发送数据的起始值和数量 示例代码：
public void intervalRange() {
//延时3s后，每隔2s发送一个事件，事件序列：从5开始递增，总共发送10个事件
//前四个参数含义为：long start, long count, long initialDelay, long period
Observable.intervalRange(5, 10, 3, 2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
range()操作符
作用：快速创建1个被观察者对象, 连续发送 1个指定范围的事件序列（无延时） 示例代码：
public void range() {
// 从2开始发送10个事件, 每次发送的事件递增1
// final int start, final int count
// 注意：参数是int型的，count必须大于0，且满足start + (count - 1) <= Integer.MAX_VALUE
Observable.range(2, 10)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
RxJava变换操作符
map变换操作符
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();
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "这是:" + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, s);
}
});
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:1
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:2
2020-03-27 01:32:03.263 8792-8792/com.example.uitestdemo I/TestRxActivity: 这是:3
可以看到，我们在Observable中输入的是int类型，但是到了Consumer上，却变为了String类型，起作用的就是中间的map函数，它将String类型变为了int类型。
flatmap
接下来是FlatMap操作符，这是一个很强大的操作符。
FlatMap将一个发送事件的上游的Observable，变为多个发送事件的Observable，然后将它们发射的事件合并后放进一个单独的Observable中。
上游的Observable每发送一个事件，faltMap都会创建一个新的水管，发送转换之后的事件，但是flatMap并不保证转换后事件的顺序性，并不能一定保证事件1在事件2的前面，如果需要顺序保证可以使用concatMap。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).flatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
final List<String> list = new ArrayList<>();
for (int i = 0; i < 15; i++) {
list.add("Value is:" + integer + " " + i);
}
return Observable.fromIterable(list).delay(1000, TimeUnit.MILLISECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: " + s);
}
});
2020-03-27 01:38:53.241 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 0
2020-03-27 01:38:53.242 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 1
2020-03-27 01:38:53.242 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 2
2020-03-27 01:38:53.243 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 3
2020-03-27 01:38:53.245 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 4
2020-03-27 01:38:53.246 9715-9810/com.example.uitestdemo I/TestRxActivity: accept: Value is:2 0
2020-03-27 01:38:53.246 9715-9810/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 5
2020-03-27 01:38:53.247 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 6
2020-03-27 01:38:53.248 9715-9810/com.example.uitestdemo I/TestRxActivity: accept: Value is:2 1
2020-03-27 01:38:53.248 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 7
2020-03-27 01:38:53.249 9715-9810/com.example.uitestdemo I/TestRxActivity: accept: Value is:2 2
2020-03-27 01:38:53.249 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 8
2020-03-27 01:38:53.250 9715-9810/com.example.uitestdemo I/TestRxActivity: accept: Value is:2 3
2020-03-27 01:38:53.250 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:1 9
2020-03-27 01:38:53.250 9715-9809/com.example.uitestdemo I/TestRxActivity: accept: Value is:3 0
concatMap操作符
concatMap，它和flatMap几乎是一模一的，只不过concatMap是严格按照上游发送的顺序来发送的。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
}).concatMap(new Function<Integer, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(Integer integer) throws Exception {
List<String> stringList = new ArrayList<>();
for (int i = 0; i < 5; i++) {
stringList.add("Value is" + integer + " " + i);
}
return Observable.fromIterable(stringList).delay(100, TimeUnit.MILLISECONDS);
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
Log.i(TAG, "accept: " + s);
}
});
2020-03-27 01:44:36.816 10168-10239/com.example.uitestdemo I/TestRxActivity: accept: Value is1 0
2020-03-27 01:44:36.817 10168-10239/com.example.uitestdemo I/TestRxActivity: accept: Value is1 1
2020-03-27 01:44:36.818 10168-10239/com.example.uitestdemo I/TestRxActivity: accept: Value is1 2
2020-03-27 01:44:36.819 10168-10239/com.example.uitestdemo I/TestRxActivity: accept: Value is1 3
2020-03-27 01:44:36.819 10168-10239/com.example.uitestdemo I/TestRxActivity: accept: Value is1 4
2020-03-27 01:44:36.849 6767-7737/? I/SmartThreadExecutor: handleMessage: start check 0
2020-03-27 01:44:36.850 6767-7737/? I/SmartThreadExecutor: handleMessage: check end 0 -275 false
2020-03-27 01:44:36.924 10168-10240/com.example.uitestdemo I/TestRxActivity: accept: Value is2 0
2020-03-27 01:44:36.926 10168-10240/com.example.uitestdemo I/TestRxActivity: accept: Value is2 1
2020-03-27 01:44:36.927 10168-10240/com.example.uitestdemo I/TestRxActivity: accept: Value is2 2
2020-03-27 01:44:36.927 10168-10240/com.example.uitestdemo I/TestRxActivity: accept: Value is2 3
2020-03-27 01:44:36.928 10168-10240/com.example.uitestdemo I/TestRxActivity: accept: Value is2 4
2020-03-27 01:44:37.035 10168-10241/com.example.uitestdemo I/TestRxActivity: accept: Value is3 0
2020-03-27 01:44:37.037 10168-10241/com.example.uitestdemo I/TestRxActivity: accept: Value is3 1
2020-03-27 01:44:37.038 10168-10241/com.example.uitestdemo I/TestRxActivity: accept: Value is3 2
2020-03-27 01:44:37.038 10168-10241/com.example.uitestdemo I/TestRxActivity: accept: Value is3 3
2020-03-27 01:44:37.039 10168-10241/com.example.uitestdemo I/TestRxActivity: accept: Value is3 4
RxJava组合/合并操作符
concatArray()操作符
作用：同contact, 组合多个被观察者一起发送数据，合并后按发送顺序串行执行（可超过4个参数） 示例代码：
public void concatArray() {
// concatArray（）：组合多个被观察者一起发送数据（可＞4个）
// 注：串行执行
Observable.concatArray(Observable.just(1, 2),
Observable.just(3, 4),
Observable.just(5, 6),
Observable.just(7, 8),
Observable.just(9, 10))
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件1
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件2
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件3
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件4
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件5
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件6
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件7
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件8
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件9
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 接收到了事件10
2020-03-31 19:16:54.711 6377-6377/com.example.uitestdemo D/TestRxActivity: 对Complete事件作出响应
zip()操作符
作用：合并 多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列）进行发送 新的事件序列的长度由长度较短的那个Observable决定 示例代码：
public void zip() {
Observable<Integer> observable1 = Observable.just(1, 2, 3, 4);
Observable<String> observable2 = Observable.just("A", "B", "C");
Observable.zip(observable1, observable2, new BiFunction<Integer, String, String>() {
@Override
public String apply(Integer integer, String s) throws Exception {
return s + integer;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(String value) {
Log.d(TAG, "最终接收到的事件 = " + value);
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "onError");
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete");
}
});
}
2020-04-02 10:55:04.563 11601-11601/com.example.uitestdemo D/TestRxActivity: 最终接收到的事件 = A1
2020-04-02 10:55:04.563 11601-11601/com.example.uitestdemo D/TestRxActivity: 最终接收到的事件 = B2
2020-04-02 10:55:04.564 11601-11601/com.example.uitestdemo D/TestRxActivity: 最终接收到的事件 = C3
2020-04-02 10:55:04.564 11601-11601/com.example.uitestdemo D/TestRxActivity: onComplete
RxJava功能型操作符
subscribe()操作符
作用： 被观察者订阅观察者，即连接观察者和被观察者形成订阅关系 示例代码：
public void subscribe() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onComplete();
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "对Next事件"+ value +"作出响应" );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
subscribeOn() & observeOn()操作符 作用：线程调度，subscribeOn()指定被观察者发送事件的工作线程，observeOn()指定观察者响应事件的工作线程。
在 RxJava模型中，被观察者 （Observable） / 观察者（Observer）的工作线程 = 创建自身的线程，即，若被观察者 （Observable） / 观察者（Observer）在主线程被创建，那么他们的工作（生产事件 / 接收& 响应事件）就会发生在主线程。所以在在Android中默认被观察者和观察者是运行在相同的工作线程（即定义他们的线程，也就是默认的UI主线程中）。
在Android中，要实现在子线程中实现耗时的网络操作等，然后回到主线程实现 UI操作，那么对应的RxJava中，可理解为：
被观察者 （Observable） 在 子线程 中生产事件（如实现耗时操作等等） 观察者（Observer）在 主线程 接收 & 响应事件（即实现UI操作） 在 RxJava中，内置了多种用于调度的线程类型
类型 含义 应用场景 Schedulers.immediate() 当前线程 = 不指定线程 默认 AndroidSchedulers.mainThread() Android主线程 操作UI Schedulers.newThread() 常规新线程 耗时等操作 Schedulers.io() io操作线程 网络请求、文件读写等io密集型操作 Schedulers.computation() CPU计算操作线程 大量计算操作 Schedulers.single() 共享单线程实例 在单线程中排队按顺序执行任务 Schedulers.trampoline() 以FIFO的队列执行 暂停当前任务，执行新插入进来的任务完之后，再将未完成的任务接着执行 注：RxJava内部使用 线程池 来维护这些线程，所以线程的调度效率非常高。
public void subscribOn() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "被观察者 Observer的工作线程是: " + Thread.currentThread().getName());
emitter.onNext(1);
emitter.onComplete();
}
}).subscribeOn(Schedulers.io())
//.subscribeOn(Schedulers.newThread())
//.subscribeOn(Schedulers.computation())
//.subscribeOn(Schedulers.single())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "观察者 Observer的工作线程是: " + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
}
2020-03-31 19:54:11.169 14942-14942/com.example.uitestdemo D/TestRxActivity: 开始采用subscribe连接
2020-03-31 19:54:11.174 14942-15071/com.example.uitestdemo D/TestRxActivity: 被观察者 Observer的工作线程是: RxCachedThreadScheduler-2
2020-03-31 19:54:11.175 14942-14942/com.example.uitestdemo D/TestRxActivity: 观察者 Observer的工作线程是: main
注意的地方：
若Observable.subscribeOn()多次调用，则只有第一次指定有效，其余的指定线程无效
observable.subscribeOn(Schedulers.newThread()) // 第一次指定被观察者线程 = 新线程
.subscribeOn(AndroidSchedulers.mainThread()) // 第二次指定无效
.observeOn(AndroidSchedulers.mainThread())
.subscribe(observer);
若Observable.observeOn()多次调用，则每次指定均有效，即每指定一次，就会进行一次线程的切换
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
Log.d(TAG, "被观察者Observable的工作线程是: " + Thread.currentThread().getName());
emitter.onNext(1);
emitter.onComplete();
}
}).subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())// 第一次指定观察者为主线程
.doOnNext(new Consumer<Integer>() { // 生产事件
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "第一次观察者Observer的工作线程是： " + Thread.currentThread().getName());
}
})
.observeOn(Schedulers.newThread()) // 第二次指定观察者为新的工作线程 有效
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "第二次观察者Observer的工作线程是: " + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
do操作符
作用：在某个事件的生命周期中调用 do操作符有一系列： 方法 含义 doOnEach() Observable每次发送事件前调用1次（包括完成和错误的事件） doOnNext() 执行Next事件前调用 doAfterNext() 执行Next事件后调用 doOnError() 发送错误事件前调用 doOnCompleted() 正常发送事件完毕调用 doOnTerminate() 执行终止前调用(包括正常和异常终止的情况) doAfterTerminate() 执行终止后调用 doFinally() 最后执行 doOnSubscribe 观察者订阅时调用
public void doOn() {
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onError(new Throwable("发生错误了"));
e.onComplete();
}
}).doOnEach(new Consumer<Notification<Integer>>() {
@Override
public void accept(Notification<Integer> integerNotification) throws Exception {
Log.d(TAG, "doOnEach: " + integerNotification.getValue());
}
}).doOnNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doOnNext: " + integer);
}
}).doAfterNext(new Consumer<Integer>() {
@Override
public void accept(Integer integer) throws Exception {
Log.d(TAG, "doAfterNext: " + integer);
}
}).doOnComplete(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doOnComplete: ");
}
}).doOnError(new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) throws Exception {
Log.d(TAG, "doOnError: " + throwable.getMessage());
}
}).doOnSubscribe(new Consumer<Disposable>() {
@Override
public void accept(@NonNull Disposable disposable) throws Exception {
Log.e(TAG, "doOnSubscribe: ");
}
}).doOnTerminate(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doOnTerminate: ");
}
}).doAfterTerminate(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doAfterTerminate: ");
}
}).doFinally(new Action() {
@Override
public void run() throws Exception {
Log.e(TAG, "doFinally: ");
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "onSubscribe");
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
}
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo E/TestRxActivity: doOnSubscribe:
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: onSubscribe
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnEach: 1
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnNext: 1
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: 接收到了事件1
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: doAfterNext: 1
2020-03-31 20:24:20.188 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnEach: 2
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnNext: 2
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: 接收到了事件2
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: doAfterNext: 2
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnEach: null
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: doOnError: 发生错误了
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo E/TestRxActivity: doOnTerminate:
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo D/TestRxActivity: 对Error事件作出响应
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo E/TestRxActivity: doFinally:
2020-03-31 20:24:20.189 20394-20394/com.example.uitestdemo E/TestRxActivity: doAfterTerminate:
RXjava 源码分析
订阅接收源码解析
线程切换解析
一、observeOn() 的线程切换原理
根据运行流程来看 observeOn() 执行后是得到 ObservableObserveOn 对象，那么当 ObservableObserveOn 绑定监听者的时候要运行 subscribe() 方法
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
//调用 subscribeActual()
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
...
}
}
接下来我们看一下 subscribeActual() 方法
protected void subscribeActual(Observer<? super T> observer) {
if (scheduler instanceof TrampolineScheduler) {
source.subscribe(observer);
} else {
//scheduler 是传进来的线程调度对象，如 Schedulers.io() 、AndroidSchedulers.mainThread() 等,这里调用了 createWorker() 方法暂时看一下就好稍后分析 RxAndroid 会说明
Scheduler.Worker w = scheduler.createWorker();
//我们看到他把 w 参数传进去了
source.subscribe(new ObserveOnObserver<T>(observer, w, delayError, bufferSize));
}
}
从上述代码我们可以看到 ObservableObserveOn 是被 ObserveOnObserver 监听的，所以收到通知也是由 ObserveOnObserver 作出响应，接下来我们假设当 Rxjava 发送 onNext 通知时会调用 ObserveOnObserver 的 onNext() 方法 ( PS:当然如果是 onComplete()、onError() 等也是一样的逻辑 )，然后我们来看一看 ObserveOnObserver 的 onNext() 方法，
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != QueueDisposable.ASYNC) {
queue.offer(t);
}
//切换线程
schedule();
}
void schedule() {
if (getAndIncrement() == 0) {
//直接调用了 worker 的 schedule 方法，需要注意的是这里他把自己传了进去
worker.schedule(this);
}
}
现在我先把把 schedule(Runnable run) 贴出来
public Disposable schedule(@NonNull Runnable run) {
return schedule(run, 0L, TimeUnit.NANOSECONDS);
}
我们看到这个他接收的参数是一个 Runnable，这是怎么回事呢，我们看一下 ObserveOnObserver 对象，他不但实现了 Observer 接口并且也实现了 Runnable 接口 接下看，继续调用 schedule( Runnable action, long delayTime, TimeUnit unit) 方法，但是这个方法是个抽象方法，这里我们就假设这里这个 worker 是 IO 线程，所以我直接贴 IoScheduler 的代码了
public Disposable schedule(@NonNull Runnable action, long delayTime, @NonNull TimeUnit unit) {
if (tasks.isDisposed()) {
// don't schedule, we are unsubscribed
return EmptyDisposable.INSTANCE;
}
return threadWorker.scheduleActual(action, delayTime, unit, tasks);
}
然后再贴一下 scheduleActual 的方法
public ScheduledRunnable scheduleActual(final Runnable run, long delayTime, @NonNull TimeUnit unit, @Nullable DisposableContainer parent) {
Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
//就是个 Runnable
ScheduledRunnable sr = new ScheduledRunnable(decoratedRun, parent);
if (parent != null) {
if (!parent.add(sr)) {
return sr;
}
}
Future<?> f;
try {
//判断延迟时间，然后使用线程池运行 Runnable
if (delayTime <= 0) {
f = executor.submit((Callable<Object>)sr);
} else {
f = executor.schedule((Callable<Object>)sr, delayTime, unit);
}
sr.setFuture(f);
} catch (RejectedExecutionException ex) {
if (parent != null) {
parent.remove(sr);
}
RxJavaPlugins.onError(ex);
}
return sr;
}
这样一来就会在相应的线程中运行 ObserveOnObserver 的 run 方法
public void run() {
if (outputFused) {
drainFused();
} else {
drainNormal();
}
}
subscribeOn() 的线程切换原理
跟 observeOn() 一样，只不过这个操作的对象是 ObservableSubscribeOn， 这个对象也是同样的代码逻辑，运行 subscribe() 方法，然后调用 subscribeActual() 方法，所以就直接贴 subscribeActual() 的代码
public void subscribeActual(final Observer<? super T> s) {
//创建与之绑定的 SubscribeOnObserver
final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(s);
s.onSubscribe(parent);
//1. 创建 SubscribeTask 实际上就是个 Runnable
//2. 然后调用 scheduler.scheduleDirect 方法
parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
我们看一下 scheduleDirect 的方法
public Disposable scheduleDirect(@NonNull Runnable run) {
return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS);
}
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) {
final Worker w = createWorker();
final Runnable decoratedRun = RxJavaPlugins.onSchedule(run);
//一个 Runnable 具体作用没分析
DisposeTask task = new DisposeTask(decoratedRun, w);
//这个代码看着熟悉吗 没错上面 observeOn 提到过，知道它是运行 Runnable 我们就直接看 Runnable 里面的 run() 了
w.schedule(task, delay, unit);
return task;
}
我们看一下 DisposeTask 的 run()
public void run() {
runner = Thread.currentThread();
try {
decoratedRun.run();
} finally {
dispose();
runner = null;
}
}
调来调去我们又回到了 SubscribeTask 的 run()
public void run() {
source.subscribe(parent);
}
这个地方的运行线程已经被切换了，他又开始往上一层层的去订阅，所以 create(new ObservableOnSubscribe(){}）这个匿名实现接口运行 subscribe 的线程运行环境都被改变了，再去调用 onNext() 等方法线程环境也是被改变的
为什么 subscribeOn() 只有第一次切换有效
写到这里我们这个问题也就能回答了 因为 RxJava 最终能影响 ObservableOnSubscribe 这个匿名实现接口的运行环境的只能是最后一次运行的 subscribeOn() ， 又因为 RxJava 订阅的时候是从下往上订阅 ，所以从上往下第一个 subscribeOn() 就是最后运行的，这就造成了写多个 subscribeOn() 并没有什么乱用的现象。
操作符原理（map flatmap）
map 原理
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper)); // this 代表上一个创建者 对应下面的source
}
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
downstream.onNext(v); // downstream 其实就是传入的原始observe
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@Nullable
@Override
public U poll() throws Exception {
T t = qd.poll();
return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
}
flatMap 原理
ObservableFlatMap 类
@Override
public void subscribeActual(Observer<? super U> t) {
if (ObservableScalarXMap.tryScalarXMapSubscribe(source, t, mapper)) {
return;
}
source.subscribe(new MergeObserver<T, U>(t, mapper, delayErrors, maxConcurrency, bufferSize));
}
static final class MergeObserver<T, U> extends AtomicInteger implements Disposable, Observer<T> {
private static final long serialVersionUID = -2117620485640801370L;
final Observer<? super U> downstream;
final Function<? super T, ? extends ObservableSource<? extends U>> mapper;
final boolean delayErrors;
final int maxConcurrency;
final int bufferSize;
volatile SimplePlainQueue<U> queue;
volatile boolean done;
final AtomicThrowable errors = new AtomicThrowable();
volatile boolean cancelled;
final AtomicReference<InnerObserver<?, ?>[]> observers;
static final InnerObserver<?, ?>[] EMPTY = new InnerObserver<?, ?>[0];
static final InnerObserver<?, ?>[] CANCELLED = new InnerObserver<?, ?>[0];
Disposable upstream;
long uniqueId;
long lastId;
int lastIndex;
Queue<ObservableSource<? extends U>> sources;
int wip;
MergeObserver(Observer<? super U> actual, Function<? super T, ? extends ObservableSource<? extends U>> mapper,
boolean delayErrors, int maxConcurrency, int bufferSize) {
this.downstream = actual;
this.mapper = mapper;
this.delayErrors = delayErrors;
this.maxConcurrency = maxConcurrency;
this.bufferSize = bufferSize;
if (maxConcurrency != Integer.MAX_VALUE) {
sources = new ArrayDeque<ObservableSource<? extends U>>(maxConcurrency);
}
this.observers = new AtomicReference<InnerObserver<?, ?>[]>(EMPTY);
}
@Override
public void onSubscribe(Disposable d) {
if (DisposableHelper.validate(this.upstream, d)) {
this.upstream = d;
downstream.onSubscribe(this);
}
}
@Override
public void onNext(T t) {
// safeguard against misbehaving sources
if (done) {
return;
}
ObservableSource<? extends U> p;
try {
p = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper returned a null ObservableSource");
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
upstream.dispose();
onError(e);
return;
}
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
if (wip == maxConcurrency) {
sources.offer(p);
return;
}
wip++;
}
}
subscribeInner(p);
}
@SuppressWarnings("unchecked")
void subscribeInner(ObservableSource<? extends U> p) {
for (;;) {
if (p instanceof Callable) {
if (tryEmitScalar(((Callable<? extends U>)p)) && maxConcurrency != Integer.MAX_VALUE) {
boolean empty = false;
synchronized (this) {
p = sources.poll();
if (p == null) {
wip--;
empty = true;
}
}
if (empty) {
drain();
break;
}
} else {
break;
}
} else {
InnerObserver<T, U> inner = new InnerObserver<T, U>(this, uniqueId++);
if (addInner(inner)) {
p.subscribe(inner);
}
break;
}
}
}
boolean addInner(InnerObserver<T, U> inner) {
for (;;) {
InnerObserver<?, ?>[] a = observers.get();
if (a == CANCELLED) {
inner.dispose();
return false;
}
int n = a.length;
InnerObserver<?, ?>[] b = new InnerObserver[n + 1];
System.arraycopy(a, 0, b, 0, n);
b[n] = inner;
if (observers.compareAndSet(a, b)) {
return true;
}
}
}
void removeInner(InnerObserver<T, U> inner) {
for (;;) {
InnerObserver<?, ?>[] a = observers.get();
int n = a.length;
if (n == 0) {
return;
}
int j = -1;
for (int i = 0; i < n; i++) {
if (a[i] == inner) {
j = i;
break;
}
}
if (j < 0) {
return;
}
InnerObserver<?, ?>[] b;
if (n == 1) {
b = EMPTY;
} else {
b = new InnerObserver<?, ?>[n - 1];
System.arraycopy(a, 0, b, 0, j);
System.arraycopy(a, j + 1, b, j, n - j - 1);
}
if (observers.compareAndSet(a, b)) {
return;
}
}
}
boolean tryEmitScalar(Callable<? extends U> value) {
U u;
try {
u = value.call();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
errors.addThrowable(ex);
drain();
return true;
}
if (u == null) {
return true;
}
if (get() == 0 && compareAndSet(0, 1)) {
downstream.onNext(u);
if (decrementAndGet() == 0) {
return true;
}
} else {
SimplePlainQueue<U> q = queue;
if (q == null) {
if (maxConcurrency == Integer.MAX_VALUE) {
q = new SpscLinkedArrayQueue<U>(bufferSize);
} else {
q = new SpscArrayQueue<U>(maxConcurrency);
}
queue = q;
}
if (!q.offer(u)) {
onError(new IllegalStateException("Scalar queue full?!"));
return true;
}
if (getAndIncrement() != 0) {
return false;
}
}
drainLoop();
return true;
}
void tryEmit(U value, InnerObserver<T, U> inner) {
if (get() == 0 && compareAndSet(0, 1)) {
downstream.onNext(value);
if (decrementAndGet() == 0) {
return;
}
} else {
SimpleQueue<U> q = inner.queue;
if (q == null) {
q = new SpscLinkedArrayQueue<U>(bufferSize);
inner.queue = q;
}
q.offer(value);
if (getAndIncrement() != 0) {
return;
}
}
drainLoop();
}
@Override
public void onError(Throwable t) {
if (done) {
RxJavaPlugins.onError(t);
return;
}
if (errors.addThrowable(t)) {
done = true;
drain();
} else {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (done) {
return;
}
done = true;
drain();
}
@Override
public void dispose() {
if (!cancelled) {
cancelled = true;
if (disposeAll()) {
Throwable ex = errors.terminate();
if (ex != null && ex != ExceptionHelper.TERMINATED) {
RxJavaPlugins.onError(ex);
}
}
}
}
@Override
public boolean isDisposed() {
return cancelled;
}
void drain() {
if (getAndIncrement() == 0) {
drainLoop();
}
}
void drainLoop() {
final Observer<? super U> child = this.downstream;
int missed = 1;
for (;;) {
if (checkTerminate()) {
return;
}
SimplePlainQueue<U> svq = queue;
if (svq != null) {
for (;;) {
U o;
for (;;) {
if (checkTerminate()) {
return;
}
o = svq.poll();
if (o == null) {
break;
}
child.onNext(o);
}
if (o == null) {
break;
}
}
}
boolean d = done;
svq = queue;
InnerObserver<?, ?>[] inner = observers.get();
int n = inner.length;
int nSources = 0;
if (maxConcurrency != Integer.MAX_VALUE) {
synchronized (this) {
nSources = sources.size();
}
}
if (d && (svq == null || svq.isEmpty()) && n == 0 && nSources == 0) {
Throwable ex = errors.terminate();
if (ex != ExceptionHelper.TERMINATED) {
if (ex == null) {
child.onComplete();
} else {
child.onError(ex);
}
}
return;
}
boolean innerCompleted = false;
if (n != 0) {
long startId = lastId;
int index = lastIndex;
if (n <= index || inner[index].id != startId) {
if (n <= index) {
index = 0;
}
int j = index;
for (int i = 0; i < n; i++) {
if (inner[j].id == startId) {
break;
}
j++;
if (j == n) {
j = 0;
}
}
index = j;
lastIndex = j;
lastId = inner[j].id;
}
int j = index;
sourceLoop:
for (int i = 0; i < n; i++) {
if (checkTerminate()) {
return;
}
@SuppressWarnings("unchecked")
InnerObserver<T, U> is = (InnerObserver<T, U>)inner[j];
for (;;) {
if (checkTerminate()) {
return;
}
SimpleQueue<U> q = is.queue;
if (q == null) {
break;
}
U o;
for (;;) {
try {
o = q.poll();
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
is.dispose();
errors.addThrowable(ex);
if (checkTerminate()) {
return;
}
removeInner(is);
innerCompleted = true;
i++;
continue sourceLoop;
}
if (o == null) {
break;
}
child.onNext(o);
if (checkTerminate()) {
return;
}
}
if (o == null) {
break;
}
}
boolean innerDone = is.done;
SimpleQueue<U> innerQueue = is.queue;
if (innerDone && (innerQueue == null || innerQueue.isEmpty())) {
removeInner(is);
if (checkTerminate()) {
return;
}
innerCompleted = true;
}
j++;
if (j == n) {
j = 0;
}
}
lastIndex = j;
lastId = inner[j].id;
}
if (innerCompleted) {
if (maxConcurrency != Integer.MAX_VALUE) {
ObservableSource<? extends U> p;
synchronized (this) {
p = sources.poll();
if (p == null) {
wip--;
continue;
}
}
subscribeInner(p);
}
continue;
}
missed = addAndGet(-missed);
if (missed == 0) {
break;
}
}
}
boolean checkTerminate() {
if (cancelled) {
return true;
}
Throwable e = errors.get();
if (!delayErrors && (e != null)) {
disposeAll();
e = errors.terminate();
if (e != ExceptionHelper.TERMINATED) {
downstream.onError(e);
}
return true;
}
return false;
}
boolean disposeAll() {
upstream.dispose();
InnerObserver<?, ?>[] a = observers.get();
if (a != CANCELLED) {
a = observers.getAndSet(CANCELLED);
if (a != CANCELLED) {
for (InnerObserver<?, ?> inner : a) {
inner.dispose();
}
return true;
}
}
return false;
}
}
rxjava 和retrofit 结合中的 适配器原理分析
RxJava2CallAdapterFactory 中的get方法
@Override
public CallAdapter<?, ?> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
Class<?> rawType = getRawType(returnType);
if (rawType == Completable.class) {
// Completable is not parameterized (which is what the rest of this method deals with) so it
// can only be created with a single configuration.
return new RxJava2CallAdapter(Void.class, scheduler, isAsync, false, true, false, false,
false, true);
}
boolean isFlowable = rawType == Flowable.class;
boolean isSingle = rawType == Single.class;
boolean isMaybe = rawType == Maybe.class;
if (rawType != Observable.class && !isFlowable && !isSingle && !isMaybe) {
return null;
}
boolean isResult = false;
boolean isBody = false;
Type responseType;
if (!(returnType instanceof ParameterizedType)) {
String name = isFlowable ? "Flowable"
: isSingle ? "Single"
: isMaybe ? "Maybe" : "Observable";
throw new IllegalStateException(name + " return type must be parameterized"
+ " as " + name + "<Foo> or " + name + "<? extends Foo>");
}
Type observableType = getParameterUpperBound(0, (ParameterizedType) returnType);
Class<?> rawObservableType = getRawType(observableType);
if (rawObservableType == Response.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Response must be parameterized"
+ " as Response<Foo> or Response<? extends Foo>");
}
responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
} else if (rawObservableType == Result.class) {
if (!(observableType instanceof ParameterizedType)) {
throw new IllegalStateException("Result must be parameterized"
+ " as Result<Foo> or Result<? extends Foo>");
}
responseType = getParameterUpperBound(0, (ParameterizedType) observableType);
isResult = true;
} else {
responseType = observableType;
isBody = true;
}
return new RxJava2CallAdapter(responseType, scheduler, isAsync, isResult, isBody, isFlowable,
isSingle, isMaybe, false);
}
RxJava2CallAdapter 中的adapter方法
@Override public Object adapt(Call<R> call) {
Observable<Response<R>> responseObservable = isAsync
? new CallEnqueueObservable<>(call)
: new CallExecuteObservable<>(call);
Observable<?> observable;
if (isResult) {
observable = new ResultObservable<>(responseObservable);
} else if (isBody) {
observable = new BodyObservable<>(responseObservable);
} else {
observable = responseObservable;
}
if (scheduler != null) {
observable = observable.subscribeOn(scheduler);
}
if (isFlowable) {
return observable.toFlowable(BackpressureStrategy.LATEST);
}
if (isSingle) {
return observable.singleOrError();
}
if (isMaybe) {
return observable.singleElement();
}
if (isCompletable) {
return observable.ignoreElements();
}
return observable;
}
CallExecuteObservable 中的subscribeActual 最后肯定会调用这个方法 这个方法源码如下
@Override protected void subscribeActual(Observer<? super Response<T>> observer) {
// Since Call is a one-shot type, clone it for each new observer.
Call<T> call = originalCall.clone();
observer.onSubscribe(new CallDisposable(call));
boolean terminated = false;
try {
Response<T> response = call.execute();
if (!call.isCanceled()) {
observer.onNext(response);
}
if (!call.isCanceled()) {
terminated = true;
observer.onComplete();
}
} catch (Throwable t) {
Exceptions.throwIfFatal(t);
if (terminated) {
RxJavaPlugins.onError(t);
} else if (!call.isCanceled()) {
try {
observer.onError(t);
} catch (Throwable inner) {
Exceptions.throwIfFatal(inner);
RxJavaPlugins.onError(new CompositeException(t, inner));
}
}
}
}
rxjava运用之 rxbus
rxbus工具类
public class RxBusManager {
private static RxBusManager instance;
private Subject<Object> mSubject;
private Map<String, CompositeDisposable> mSubscriptionMap;
public static RxBusManager getInstance() {
if (instance == null) {
synchronized (RxBusManager.class) {
if (instance == null) {
instance = new RxBusManager();
}
}
}
return instance;
}
private RxBusManager() {
mSubject = PublishSubject.create().toSerialized();
mSubscriptionMap = new HashMap<>();
}
//for (PublishSubject.PublishDisposable<T> s : subscribers.get()) { 最后会调用这个
// s.onNext(t);
// }
public void post(Object object) {
mSubject.onNext(object);
}
private <T> Flowable<T> getObservable(Class<T> type) {
return mSubject.toFlowable(BackpressureStrategy.BUFFER).ofType(type);
}
public <T> Disposable registerEvent(Class<T> type, Consumer<T> action1, Consumer<Throwable> error) {
return getObservable(type)
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(action1, error);
}
public void addSubscription(Object object, Disposable disposable) {
if (mSubscriptionMap == null) {
mSubscriptionMap = new HashMap<>();
}
String key = object.getClass().getName();
if (mSubscriptionMap.get(key) != null) {
mSubscriptionMap.get(key).add(disposable);
} else {
//一次性容器,可以持有多个并提供 添加和移除。
CompositeDisposable disposables = new CompositeDisposable();
disposables.add(disposable);
mSubscriptionMap.put(key, disposables);
}
}
public void unSubscrible(Object object) {
if (mSubscriptionMap == null) {
return;
}
String key = object.getClass().getName();
if (!mSubscriptionMap.containsKey(key)) {
return;
}
if (mSubscriptionMap.get(key) != null) {
mSubscriptionMap.get(key).dispose();
}
mSubscriptionMap.remove(key);
}
}
事件实体
public class Event {
public Event(int action) {
this.action = action;
}
public Event(int action, Object object) {
this.action = action;
this.object = object;
}
public Event(int action, Object[] object) {
this.action = action;
this.objectArr = object;
}
public int action;
public Object object;
public Object[] objectArr;
public Object[] getObjectArr() {
return objectArr;
}
public <T extends Object> T getObject() {
return (T) object;
}
public int position;
}
注册代码
RxBusManager.getInstance().registerEvent(Event.class, new Consumer<Event>() {
@Override
public void accept(Event event) {
dealWithRxEvent(event.action, event);
}
}, new Consumer<Throwable>() {
@Override
public void accept(Throwable throwable) {
Logger.e("rxbus传递出现异常");
if (throwable != null) {
Logger.e(throwable.getMessage());
}
}
});
发送事件代码
RxBusManager.getInstance().post(new Event(UPDATELIST,data));
