Android源码分析之RxJava框架
1 RxJava简介
1.1 定义
RxJava：a library for composing asynchronous and event-based programs using observable sequences for the Java VM
// 翻译：RxJava是一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库。
总结：RxJava是一个 基于事件流、实现异步操作的库。
1.2 作用
实现异步操作，类似于Android中的AsyncTask 、Handler作用。
1.3 优点
RxJava是基于事件流的链式调用，可以避免回调嵌套，更优雅地切换线程实现异步处理数据。配合一些操作符，可以让处理事件流的代码更加简洁，逻辑更加清晰。
2 RxJava原理
2.1 用一个生活例子引入&讲解Rxjava原理：顾客到饭店吃饭
2.2 Rxjava原理介绍
（1）Rxjava原理是基于一种扩展的观察者模式；
（2）Rxjava的扩展观察者模式中有4个角色：
（3）具体原理（结合上述 顾客到饭店吃饭 的生活例子理解：）
（4）RxJava原理可总结为：被观察者Observable通过订阅subscribe按顺序发送事件流给观察者Observer， 观察者按顺序接收事件并按顺序响应事件。具体如下图：
2.4 补充：什么叫响应式编程呢？
你烧水呢，水烧开了，水壶会叫，这就是一下响应了。响应式它是依赖于事件的，响应式的代码它的运行不是按代码的顺序，而是跟多个按时间发生的事件有关。依赖事件就是“回调”，但在响应式编程里，这些按时间排列的事件，被称为“流–stream”，它里面包含的是事件的时间值，这些时间值就是数据。可以说，响应式编程就是：异步的数据流的开发。
3 造轮子的方式分析Rxjava原理
3.1 搭建大体的框架：create
（1）订阅者（观察者）Observer
public interface Observer<T> {
void onSubscribe();
void onNext(T var1);
void onError(Throwable t);
void onComplete();
}
（2）订阅源（被观察者）Observable
Observable（订阅源）在 RxJava 里面是一个大而杂的类，拥有很多工厂方法和各式各样的操作符。
public abstract class Observable<T> {
public static final String TAG = "RxJavaObservable";
/**
* 订阅（subscribe）连接观察者和被观察者的具体实现
*/
protected abstract void subscribeActual(Observer<? super T> observer);
/**
* 创建操作符
* @param source
* @param
* @return
*/
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
// 创建ObservableCreate对象
Log.e(Observable.TAG, "调用create创建ObservableCreate对象");
return new ObservableCreate<T>(source);
}
/**
* 通过订阅（subscribe）连接观察者和被观察者
* @param observer
*/
public void subscribe(Observer<? super T> observer) {
Log.e(Observable.TAG, "调用订阅subscribe(observer)连接观察者和被观察者，observer：" + observer);
// 当Observable.subscribe被调用时，回调subscribeActual(observer)
subscribeActual(observer);
}
}
回调接口ObservableOnSubscribe只有一个方法，用来产生数据流，这是典型的命令模式
public interface ObservableOnSubscribe<T> {
/**
* 调用订阅的每个观察者，{@code subscribe()}方法来接收一个允许推送的实例
* @param observer 观察者
* @throws Exception on error
*/
void subscribe(Observer<? super T> observer);
}
（3）订阅源-创建操作符
public class ObservableCreate<T> extends Observable<T> {
private ObservableOnSubscribe<T> source;
// 传入的source对象 = 手动创建的ObservableOnSubscribe对象
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super T> observer) {
Log.e(Observable.TAG, "回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)");
Log.e(Observable.TAG, "调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)");
observer.onSubscribe();
source.subscribe(observer);
}
}
（4） 实践：到此，一个小型的 RxJava 的雏形就出来了
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> observer) {
Log.d(Observable.TAG, "回调create操作符的subscribe()");
for (int i = 0; i < 3; i++) {
observer.onNext(i);
}
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value);
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
});
/**
* 调用create创建ObservableCreate对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$1@b6c1a61
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 开始采用subscribe连接
* 回调create操作符的subscribe()
* onNext接收到了事件：0
* onNext接收到了事件：1
* onNext接收到了事件：2
*/
3.2 添加操作符：map
强大的 RxJava 的核心原理并没有想象中那么复杂和神秘，运用的就是典型的观察者模式。有了基本雏形之后，我们继续为这个框架添砖加瓦吧。RxJava 之所以强大好用，与其拥有丰富灵活的操作符是分不开的。
RxJava是如何实现操作符的呢？其实，每调用一次操作符的方法，就相当于在前一个Observerable对象和下层观察者之间桥接了一个新的 Observerable，以及新的 Observer 等。
（1）订阅源（被观察者）Observable
public abstract class Observable<T> {
/**
* map 操作符
* @param func
* @param
* @return
*/
public <R> Observable<R> map(Function<? super T, ? extends R> func) {
// 创建一个桥接前一个操作符和当前操作符的Observable子类-ObservableMap对象
Log.e(Observable.TAG, "调用map创建ObservableMap对象");
return new ObservableMap<>(this, func);
}
}
（2）订阅源-map操作符
public class ObservableMap<T, R> extends Observable<R> {
private final Observable<T> source;
private final Function<? super T, ? extends R> function;
// 传入的source对象 = 前一个操作符返回的Observerable对象（Observable implements ObservableSource）
// 传入的function对象 = Map变换操作符中的Function函数对象
public ObservableMap(Observable<T> source, Function<? super T, ? extends R> function) {
this.source = source;
this.function = function;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用前一个操作符返回的Observerable对象的subscribe(observer)
*
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super R> observer) {
Log.e(Observable.TAG, "回调ObservableMap的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)");
// 创建一个桥接下层观察者和Map的Function函数对象的Observer子类-MapObserver对象
source.subscribe(new MapObserver<>(observer, function));
}
private class MapObserver<T, R> implements Observer<R> {
final Observer<? super T> observer;
final Function<? super R, ? extends T> function;
private MapObserver(Observer<? super T> observer, Function<? super R, ? extends T> function) {
this.observer = observer;
this.function = function;
}
@Override
public void onSubscribe() {
}
@Override
public void onNext(R var1){
// 进行转换和处理，再把结果返回给下层观察者
T t = null;
try {
Log.e(Observable.TAG, "回调MapObserver的onNext()，作用:进行转换和处理后，准备调用map操作符的apply()");
// 调用map的apply()
t = function.apply(var1);
} catch (Exception e) {
e.printStackTrace();
return;
}
// 调用下层观察者的onNext()
observer.onNext(t);
}
@Override
public void onError(Throwable t) {
observer.onError(t);
}
@Override
public void onComplete() {
observer.onComplete();
}
}
}
（3）实践
// map操作符的作用是将T类型的Event转化成R类型
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，初始值是：" + 10);
subscriber.onNext(10);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
String str = "事件" + integer + "的参数从整型：" + integer + "，变换成字符串类型：" + (integer + "s");
Log.d(Observable.TAG, "回调map操作符的apply()，将" + str);
return str;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(String value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value);
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
});
/**
* 调用create创建ObservableCreate对象
* 调用map创建ObservableMap对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$3@516f986
* 回调ObservableMap的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableMap$MapObserver@e734247
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 回调create操作符的subscribe()，初始值是：10
* 回调MapObserver的onNext()，作用:进行转换和处理后，准备调用map操作符的apply()
* 回调map操作符的apply()，将事件10的参数从整型：10，变换成字符串类型：10s
* onNext接收到了事件：事件10的参数从整型：10，变换成字符串类型：10s
*/
3.3 添加线程切换功能1-subscribeOn()操作符
RxJava中最激动人心的功能是异步处理，能够自如地切换线程。利用subscribeOn()结合observeOn()来实现线程控制，让事件的产生和消费发生在不同的线程。 RxJava是如何实现完成线程的切换的呢？除了前一个Observerable对象和下层观察者之间桥接了一个新的 Observerable 以外，RxJava还用到一个很关键的类-Scheduler（调度器）等。
（1）Scheduler（线程调度器）：进行任务的调度的一个东西
// 线程调度器
public class Scheduler {
// 执行线程池
private final Executor executor;
public Scheduler(Executor executor) {
this.executor = executor;
}
public Worker createWorker() {
return new Worker(executor);
}
/**
* 直接调度线程池执行Runnable任务
* @param runnable
*/
public void scheduleDirect(Runnable runnable) {
final Worker worker = createWorker();
worker.schedule(runnable);
}
/**
* Scheduler的内部类，它是具体任务的执行者
*/
public class Worker {
final Executor executor;
public Worker(Executor executor) {
this.executor = executor;
}
/**
* 调度线程池执行Runnable任务
* @param runnable
*/
public void schedule(Runnable runnable) {
executor.execute(runnable);
}
}
}
// 线程调度器管理
public class Schedulers {
private volatile static Schedulers current;
// newSingleThreadExecutor创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，
private final Scheduler ioScheduler;
private final Scheduler newThreadScheduler;
private Schedulers() {
ioScheduler = new Scheduler(Executors.newSingleThreadExecutor());
newThreadScheduler = new Scheduler(Executors.newSingleThreadExecutor());
}
private static Schedulers getInstance() {
if (current == null) {
synchronized (Schedulers.class) {
if (current == null) {
current = new Schedulers();
}
}
}
return current;
}
/**
* io操作线程，执行网络请求、读写文件等io密集型操作
* @return
*/
public static Scheduler io() {
return getInstance().ioScheduler;
}
/**
* 常规新线程，执行耗时等操作
* @return
*/
public static Scheduler newThread() {
return getInstance().newThreadScheduler;
}
}
// Android线程调度器
public final class HandlerScheduler extends Scheduler {
private final Executor executor;
private final Handler handler;
public HandlerScheduler(Executor executor, Handler handler) {
super(executor);
this.executor = executor;
this.handler = handler;
}
public Worker createWorker() {
return new HandlerScheduler.HandlerWorker(executor, handler);
}
private class HandlerWorker extends Worker {
private final Handler handler;
private HandlerWorker(Executor executor, Handler handler) {
super(executor);
this.handler = handler;
}
public void schedule(Runnable runnable) {
handler.post(runnable);
}
}
}
// Android线程调度器管理
public class AndroidSchedulers {
private AndroidSchedulers() {
}
/**
* Android主线程：操作UI
* @return
*/
public static Scheduler mainThread() {
return MainThreadSchedulerHolder.MAIN_THREAD_SCHEDULER;
}
private static class MainThreadSchedulerHolder {
private static final Scheduler MAIN_THREAD_SCHEDULER = new HandlerScheduler(
Executors.newSingleThreadExecutor(), new Handler(Looper.getMainLooper()));
}
}
（2）订阅源（被观察者）Observable
public abstract class Observable<T> {
/**
* subscribeOn()操作符，作用的是OnSubscribe
* @param scheduler
* @return
*/
public Observable<T> subscribeOn(final Scheduler scheduler) {
// 创建一个桥接前一个操作符和当前操作符的Observable子类-ObservableSubscribeOn对象
Log.d(Observable.TAG, "调用subscribeOn创建ObservableSubscribeOn对象");
return new ObservableSubscribeOn<>(this, scheduler);
}
}
（3）订阅源-subscribeOn操作符：切换Observerable对象执行线程
public class ObservableSubscribeOn<T> extends Observable<T> {
private final Observable<T> source;
private final Scheduler scheduler;
// 传入的source对象 = 前一个操作符返回的Observerable对象（Observable implements ObservableSource）
// 传入的scheduler对象 = SubscribeOn变换操作符中的scheduler对象
public ObservableSubscribeOn(Observable<T> source, Scheduler scheduler) {
this.source = source;
this.scheduler = scheduler;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用前一个操作符返回的Observerable对象的subscribe(observer)
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super T> observer) {
Log.e(Observable.TAG, "回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)");
// 创建一个桥接 下层观察者 和 前一个操作符返回的Observerable对象 的 线程切换任务Runnable对象
scheduler.scheduleDirect(new SubscribeTask(observer));
}
/**
* 线程切换任务
*/
final class SubscribeTask implements Runnable {
private final Observer<? super T> observer;
SubscribeTask(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void run() {
// 让前一个操作符返回的Observerable对象的subscribe()在新线程中执行
Log.d(Observable.TAG, "调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：" + Thread.currentThread().getName());
source.subscribe(observer);
}
}
}
（4）实践
// 只有调用1次subscribeOn()
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，Observable执行的线程是：" + Thread.currentThread().getName());
subscriber.onNext(1);
}
})
.subscribeOn(Schedulers.io())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value + "， Observer执行的线程是：" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
/**
* 调用create创建ObservableCreate对象
* 调用subscribeOn创建ObservableSubscribeOn对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：pool-1-thread-1
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：pool-1-thread-1
* 开始采用subscribe连接
* 回调create操作符的subscribe()，Observable执行的线程是：pool-1-thread-1
* onNext接收到了事件：1， Observer执行的线程是：pool-1-thread-1
*/
// 调用2次subscribeOn()
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，Observable执行的线程是：" + Thread.currentThread().getName());
subscriber.onNext(1);
}
})
.subscribeOn(Schedulers.io())
.subscribeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value + "， Observer执行的线程是：" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
/**
* 调用create创建ObservableCreate对象
* 调用subscribeOn创建ObservableSubscribeOn对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：main
* 回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：pool-1-thread-1
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：pool-1-thread-1
* 开始采用subscribe连接
* 回调create操作符的subscribe()，Observable执行的线程是：pool-1-thread-1
* onNext接收到了事件：1， Observer执行的线程是：pool-1-thread-1
*/
（5）为什么多次调用subscribeOn()，只有第一个subscribeOn()起作用？
因为subscribeOn()作用的是Observable，(Observable)source.subscribe(observer)执行在新线程中，让前一个操作符返回的Observerable对象的subscribe()在新线程中执行。而多次调用subscribeOn()，从订阅（subscribe()）逆序回调，将source.subscribe(observer)执行在每个线程中，最后一个就是最终执行线程，也就是第一个subscribeOn()执行的线程起作用。
3.4 添加线程切换功能2-observeOn()操作符
（1）订阅源（被观察者）Observable
public abstract class Observable<T> {
/**
* observeOn()作用的是Subscriber
* @param scheduler
* @return
*/
public Observable<T> observeOn(final Scheduler scheduler) {
// 创建一个桥接前一个操作符和当前操作符的Observable子类-ObservableObserveOn
Log.d(Observable.TAG, "调用observeOn创建ObservableObserveOn对象");
return new ObservableObserveOn<>(this, scheduler);
}
}
（2）订阅源-subscribeOn操作符：切换Observerable对象执行线程
public class ObservableSubscribeOn<T> extends Observable<T> {
private final Observable<T> source;
private final Scheduler scheduler;
// 传入的source对象 = 前一个操作符返回的Observerable对象（Observable implements ObservableSource）
// 传入的scheduler对象 = SubscribeOn变换操作符中的scheduler对象
public ObservableSubscribeOn(Observable<T> source, Scheduler scheduler) {
this.source = source;
this.scheduler = scheduler;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用前一个操作符返回的Observerable对象的subscribe(observer)
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super T> observer) {
Log.e(Observable.TAG, "回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)");
// 创建一个桥接 下层观察者 和 前一个操作符返回的Observerable对象 的 线程切换任务Runnable对象
scheduler.scheduleDirect(new SubscribeTask(observer));
}
/**
* 线程切换任务
*/
final class SubscribeTask implements Runnable {
private final Observer<? super T> observer;
SubscribeTask(Observer<? super T> observer) {
this.observer = observer;
}
@Override
public void run() {
// 让前一个操作符返回的Observerable对象的subscribe()在新线程中执行
Log.d(Observable.TAG, "调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：" + Thread.currentThread().getName());
source.subscribe(observer);
}
}
}
（3）实践
// 只调用1次observeOn()
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，Observable执行的线程是：" + Thread.currentThread().getName());
subscriber.onNext(1);
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value + "， Observer执行的线程是：" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
/**
* 调用create创建ObservableCreate对象
* 调用observeOn创建ObservableObserveOn对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@b6c1a61
* 回调ObservableObserveOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableObserveOn$ObserveOnObserver@516f986
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：main
* 回调create操作符的subscribe()，Observable执行的线程是：main
* 回调ObserveOnObserver的onNext()，作用:进行线程切换，准备调用下层观察者的onNext()，当前线程是：main
* onNext接收到了事件：1， Observer执行的线程是：main
*/
// 只调用2次observeOn()
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，Observable执行的线程是：" + Thread.currentThread().getName());
subscriber.onNext(1);
}
})
// .subscribeOn(Schedulers.io())
// .subscribeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.io())
.map(new Function<Integer, Integer>() {
@Override
public Integer apply(Integer integer) throws Exception {
String str = "事件" + integer + "的参数从：" + integer + "，变换成字符串类型：" + (integer + 100);
Log.d(Observable.TAG, "回调map操作符的apply()，将" + str + "，当前线程是：" + Thread.currentThread().getName());
return integer + 100;
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value + "， Observer执行的线程是：" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
});
/**
* // 调用2次observeOn()
* // observeOn(Schedulers.io())
* // map
* // observeOn(AndroidSchedulers.mainThread())
*
* 调用create创建ObservableCreate对象
* 调用observeOn创建ObservableObserveOn对象
* 调用map创建ObservableMap对象
* 调用observeOn创建ObservableObserveOn对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$9@997bbe3
* 回调ObservableObserveOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableObserveOn$ObserveOnObserver@56c59e0
* 回调ObservableMap的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableMap$MapObserver@5c4b499
* 回调ObservableObserveOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableObserveOn$ObserveOnObserver@b1db35e
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：main
* 回调create操作符的subscribe()，Observable执行的线程是：main
* 回调ObserveOnObserver的onNext()，作用:进行线程切换，准备调用下层观察者的onNext()，当前线程是：pool-1-thread-1
* 回调MapObserver的onNext()，作用:进行转换和处理后，准备调用map操作符的apply()
* 回调map操作符的apply()，将事件1的参数从：1，变换成字符串类型：101，当前线程是：pool-1-thread-1
* 回调ObserveOnObserver的onNext()，作用:进行线程切换，准备调用下层观察者的onNext()，当前线程是：main
* onNext接收到了事件：101， Observer执行的线程是：main
*/
// 正常调用subscribeOn()和observeOn()
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> subscriber) {
Log.d(Observable.TAG, "回调create操作符的subscribe()，Observable执行的线程是：" + Thread.currentThread().getName());
subscriber.onNext(1);
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value + "， Observer执行的线程是：" + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
});
/**
* // 正常调用subscribeOn()和observeOn()
*
* 调用create创建ObservableCreate对象
* 调用subscribeOn创建ObservableSubscribeOn对象
* 调用observeOn创建ObservableObserveOn对象
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$6@997bbe3
* 回调ObservableObserveOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableObserveOn$ObserveOnObserver@56c59e0
* 回调ObservableSubscribeOn的subscribeActual()，作用:准备调用前一个操作符返回的Observerable对象的subscribe(observer)
* 调用前一个操作符返回的Observerable对象的subscribe(observer)，让它的subscribe()在新线程中执行，当前线程是：pool-1-thread-1
* 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableObserveOn$ObserveOnObserver@56c59e0
* 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：pool-1-thread-1
* 回调create操作符的subscribe()，Observable执行的线程是：pool-1-thread-1
* 回调ObserveOnObserver的onNext()，作用:进行线程切换，准备调用下层观察者的onNext()，当前线程是：main
* onNext接收到了事件：1， Observer执行的线程是：main
*/
（5）为什么多次调用observeOn()多次指定Observer的线程，则每次指定均有效，即每指定一次，就会进行一次线程的切换？最终的Observer的执行线程与最后一次observeOn() 的调用有关？
因为observeOn()作用的是下层Observer，ObservableObserveOn内部的ObserveOnObserver的onNext()中将observer.onNext(var1)执行在新线程中，让下层Observer在新线程中执行。
public void onNext(final T var1) {
// 进行线程切换，再把结果返回给下层观察者
worker.schedule(new Runnable() {
@Override
public void run() {
// 让下层观察者的Observer对象在新线程中执行
observer.onNext(var1);
}
});
}
3.5 zip()操作符
（1）订阅源（被观察者）Observable
/**
* zip 操作符
*
* @param source1
* @param source2
* @param source1
* @param
* @return
*/
public static <T1, T2, R> Observable<R> zip(
Observable<? extends T1> source1,
Observable<? extends T2> source2,
Function2<? super T1, ? super T2, ? extends R> function2) {
// 创建一个桥接前一个操作符和当前操作符的Observable子类-ObservableZip对象
Log.d(Observable.TAG, "调用zip创建ObservableZip对象");
return zipArray(Functions.toFunction(function2),source1, source2);
}
private static <T, R> Observable<R> zipArray(Function<? super Object[], ? extends R> function,
Observable<? extends T>... sources) {
return new ObservableZip<T, R>(sources, function);
}
（2）订阅源-zip操作符
/**
* 订阅源-zip操作符（原理在于就是依靠队列+数组）
* Created by Administrator on 2020/4/5.
*/
public final class ObservableZip<T, R> extends Observable<R> {
private final Observable<? extends T>[] sources;
private final Function<? super Object[], ? extends R> function;
// 传入的sources数组 = 前一个操作符返回的Observable对象数组（Observable implements ObservableSource）
// 传入的zipper对象 = Zip变换操作符中的Function函数对象
public ObservableZip(Observable<? extends T>[] sources, Function<? super Object[], ? extends R> function) {
this.sources = sources;
this.function = function;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用前一个操作符返回的Observable对象的subscribe(observer)
*
* @param observer
*/
@Override
public void subscribeActual(Observer<? super R> observer) {
Log.e(Observable.TAG, "回调ObservableZip的subscribeActual()，作用:准备调用前一个操作符返回的Observable对象的subscribe(observer)");
Observable<? extends T>[] sources = this.sources;
int count = sources.length;
// 创建一个协调器ZipCoordinator
// observer：下游层观察者，function：Zip-Function函数，count：Observable对象数组的数量
ZipCoordinator<T, R> zc = new ZipCoordinator<T, R>(observer, function, count);
zc.subscribe(sources);
}
static final class ZipCoordinator<T, R> extends AtomicInteger {
final Observer<? super R> observer;
final Function<? super Object[], ? extends R> function;
final ZipObserver<T, R>[] zipObservers;
final T[] row; // 被观察者数量的数组
ZipCoordinator(Observer<? super R> observer, Function<? super Object[], ? extends R> function, int count) {
// 初始化了一个和上游Observable一样数量大小的ZipObserver数组和T类型的数组
this.observer = observer;
this.function = function;
this.zipObservers = new ZipObserver[count];
this.row = (T[]) new Object[count];
}
public void subscribe(Observable<? extends T>[] sources) {
// 分别初始化了ZipObserver数组的元素
// 桥接 上游Observable 和 ZipCoordinator对象-drain() 的 Observer子类-ZipObserver对象
int len = zipObservers.length;
for (int i = 0; i < len; i++) {
zipObservers[i] = new ZipObserver<T, R>(this);
}
this.lazySet(0);
observer.onSubscribe();
// 让上游Observable分别订阅了对应的ZipObserver
for (int i = 0; i < len; i++) {
sources[i].subscribe(zipObservers[i]);
}
}
private void drain() {
if (getAndIncrement() != 0) {
return;
}
int missing = 1;
final T[] os = row;
for (; ; ) {
for (; ; ) {
int i = 0;
int emptyCount = 0;
for (ZipObserver<T, R> zipObserver : zipObservers) {
if (os[i] == null) {
// 3.1、如果数组i的元素为空，就去指定队列中poll
T v = zipObserver.queue.poll();
boolean empty = v == null;
if (!empty) {
// 4.1、如果不为null，则填充到数组的指定位置
os[i] = v;
} else {
// 4.2、如果poll出来null，说明该队列中还没有事件被发射过来，emptyCount++
emptyCount++;
}
} else {
// 3.2、如果数组i的元素不为空，判断是否结束，没结束无操作
if (zipObserver.done) {
clear();
observer.onError(new Throwable());
return;
}
}
// i++，遍历数组
i++;
}
// 5.1、emptyCount不为0则意味着数组没有被填满，某上游被观察者未发射事件，对应队列中还没有值，
// 所以只能结束此次操作，等待下一次上游发射事件了
if (emptyCount != 0) {
break;
}
// 5.2、如果emptyCount为0，那么说明数组中的值被填满了，这意味着符合触发下游Observer#onNext(T)的要求了
R r;
try {
// 6、调用zip的apply()进行转换和处理
Log.e(Observable.TAG, "调用zip的apply()进行转换和处理");
r = function.apply(os.clone());
} catch (Throwable ex) {
clear();
observer.onError(ex);
return;
}
// 7、再把结果返回给下游观察者触发下游 Observer#onNext(T)
observer.onNext(r);
// 8、将数组内部元素置null，为下次数据填充做准备。
Arrays.fill(os, null);
}
missing = addAndGet(-missing);
if (missing == 0) {
return;
}
}
}
void clear() {
for (ZipObserver<?, ?> zipObserver : zipObservers) {
zipObserver.queue.clear();
}
}
}
static final class ZipObserver<T, R> implements Observer<T> {
final ZipCoordinator<T, R> parent;
final LinkedList<T> queue;
volatile boolean done;
ZipObserver(ZipCoordinator<T, R> parent) {
this.parent = parent;
this.queue = new LinkedList<T>();
}
@Override
public void onSubscribe() {
}
@Override
public void onNext(T t) {
// 1、当一个上游事件被发射过来的时候，首先进入队列
queue.offer(t);
// 2、再去查看数组的每个元素是否为空
parent.drain();
}
@Override
public void onError(Throwable t) {
done = true;
parent.drain();
}
@Override
public void onComplete() {
done = true;
parent.drain();
}
}
}
（3）实践
public void zip(View view) {
Observable observable1 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(Observer<? super String> emitter) {
Log.d(Observable.TAG, "回调observable1的subscribe()");
emitter.onNext("11");
emitter.onNext("12");
emitter.onNext("13");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Observable observable2 = Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(Observer<? super String> emitter) {
Log.d(Observable.TAG, "回调observable2的subscribe()");
emitter.onNext("21");
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
emitter.onNext("22");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
emitter.onNext("23");
}
});
Observable.zip(observable1, observable2, new Function2<String, String, String>() {
@Override
public String apply(@NonNull String str1, @NonNull String str2) throws Exception {
Log.d(Observable.TAG, "回调zip操作符的apply()，将str1：" + str1 + " " + "str2：" + str2);
return str1 + str2;
}
}).subscribe(new Observer<String>() {
@Override
public void onSubscribe() {
Log.d(Observable.TAG, "开始采用subscribe连接");
}
@Override
public void onNext(String value) {
Log.d(Observable.TAG, "onNext接收到了事件：" + value);
}
@Override
public void onError(Throwable e) {
Log.e(Observable.TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(Observable.TAG, "对Complete事件作出响应");
}
});
/**
* 2020-05-17 17:41:58 调用create创建ObservableCreate对象
* 2020-05-17 17:41:58 调用create创建ObservableCreate对象
* 2020-05-17 17:41:58 调用zip创建ObservableZip对象
* 2020-05-17 17:41:58 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava_example.MainActivity$13@eb234b2
* 2020-05-17 17:41:58 回调ObservableZip的subscribeActual()，作用:准备调用前一个操作符返回的Observable对象的subscribe(observer)
* 2020-05-17 17:41:58 开始采用subscribe连接
* 2020-05-17 17:41:58 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableZip$ZipObserver@19adc03
* 2020-05-17 17:41:58 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 2020-05-17 17:41:58 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：main
* 2020-05-17 17:41:58 回调observable1的subscribe()
* 2020-05-17 17:42:00 调用订阅subscribe(observer)连接观察者和被观察者，observer：com.example.rxjava.observable.ObservableZip$ZipObserver@b4ac780
* 2020-05-17 17:42:00 回调ObservableCreate的subscribeActual()，作用:准备调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
* 2020-05-17 17:42:00 调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)，当前线程是：main
* 2020-05-17 17:42:00 回调observable2的subscribe()
* 2020-05-17 17:42:00 调用zip的apply()进行转换和处理
* 2020-05-17 17:42:00 回调zip操作符的apply()，将str1：11 str2：21
* 2020-05-17 17:42:00 onNext接收到了事件：1121
* 2020-05-17 17:42:02 调用zip的apply()进行转换和处理
* 2020-05-17 17:42:02 回调zip操作符的apply()，将str1：12 str2：22
* 2020-05-17 17:42:02 onNext接收到了事件：1222
* 2020-05-17 17:42:05 调用zip的apply()进行转换和处理
* 2020-05-17 17:42:05 回调zip操作符的apply()，将str1：13 str2：23
* 2020-05-17 17:42:05 onNext接收到了事件：1323
*/
}
（4）核心原理
实际上zip 操作符的原理在于就是依靠队列+数组，当一个事件被发射过来的时候，首先进入队列，再去查看数组的每个元素是否为空 ——
如果为空，就去指定队列中poll：
①如果poll出来为null，说明该队列中还没有事件被发射过来，emptyCount++；
②如果不为null，则填充到数组的指定位置。
如果不为空，则跳过此次循环。
直到最后，判定emptyCount是否不为0，不为0则意味着数组没有被填满，某些队列中还没有值，所以只能结束此次操作，等待下一次上游发射事件了。而如果emptyCount为0，那么说明数组中的值被填满了，这意味着符合触发下游Observer#onNext(T) 的要求了，当然，不要忘了将数组内部元素置 null，为下次数据填充做准备。
（5）原理分析
①第一个事件应该是上游first()返回的ObservableSource中发射的【11】，最终在 ZipObserver#onNext(T)方法中，该事件首先被塞入队列，再触发上述的 ZipCoordinator#drain()，在drain()方法中会进入ZipObserver的遍历：
第一次：【11】作为第一个事件，此时os中所有元素应该都是null，所以会走入上面的分支，接着从第一个ZipObserver的队列中poll一个值，这时队列中有且只有刚刚塞入的【11】事件，它将被填入os[0] 的位置中。
第二次：os[1] 为 null，同样会走入上分支，此时试图从第二ZipObserver中poll一个值，但是此时第二个ZipObserver中队列中肯定是没有值的，因为【21】这个事件1000毫秒后才会被发射出来，所以emptyCount++。for循环跳出后，由于emptyCount不为0，死循环结束。
②第二个事件也是由first()发射过来的【12】， 当第二个事件发射过来的时候——
第一次：os[0]不为null，走下分支，然而下分支在大部分情况下并不会执行什么逻辑，所以笔者在此处省略了；
第二次：os[1]为 null，接着emptyCount++，结束死循环。
③第三个事件也是由first()发射过来的【13】， 当第二个事件发射过来的时候——
第一次：os[0]不为null，走下分支，然而下分支在大部分情况下并不会执行什么逻辑，所以笔者在此处省略了；
第二次：os[1]为null，接着emptyCount++，结束死循环。
④1000毫秒后，第四个事件由second()发射（也就是【21】）的时候，事情就不一样了：
第一次：os[0] 不为null，走下分支，忽略。
第二次：os[1] 为null，走上分支，此时试图从第二个ZipObserver中poll一个值，此时有值吗？有——【21】此时出队并被塞入os[1] 中。
for循环跳出后，经过zipper操作合并后两个事件被传输给下游Observer的onNext(T)中，此时打印台就输出了【11，21】了。当然，最后还会将os数组中元素全部填充为null，为下一次数据填充做准备。
（6）学习链接
友好 RxJava2.x 源码解析（三）zip 源码分析
4 Rxjava源码分析
4.1 create操作符源码分析
4.1.1 基本使用
public void create(View view) {
// 步骤1：创建被观察者（Observable）& 定义需发送的事件
Observable.create(new ObservableOnSubscribe<Integer>() {
// 在复写的subscribe()里定义需要发送的事件
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
// 至此，一个被观察者对象（Observable）就创建完毕
}).subscribe(new Observer<Integer>() {
// 步骤2：创建观察者（Observer）& 定义响应事件的行为
// 步骤3：通过订阅（subscribe）连接观察者和被观察者
// 默认最先调用复写的 onSubscribe（）
@Override
public void onSubscribe(Disposable d) {
LogUtils.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
LogUtils.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
LogUtils.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
LogUtils.d(TAG, "对Complete事件作出响应");
}
});
/**
* RxCreateActivity: 开始采用subscribe连接
* RxCreateActivity: 接收到了事件1
* RxCreateActivity: 接收到了事件2
* RxCreateActivity: 接收到了事件3
* RxCreateActivity: 对Complete事件作出响应
*/
}
4.1.2 创建被观察者（Observable）& 定义需发送的事件
（1）使用方法步骤1
// 步骤1：创建被观察者（Observable）& 定义需发送的事件
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();
}
})
（2）源码分析
// 源码分析：Observable.create(new ObservableOnSubscribe(){...}）
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
... // 仅贴出关键源码
// 创建ObservableCreate对象 ->> 分析1
return new ObservableCreate<T>(source);
}
// 分析1：ObservableCreate类 = Observable的子类
public final class ObservableCreate<T> extends Observable<T> {
...
final ObservableOnSubscribe<T> source;
// 传入的source对象 = 手动创建的ObservableOnSubscribe对象
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用source对象（即ObservableOnSubscribe对象）的subscribe(observer)
*
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super T> observer) {
// 1.创建1个CreateEmitter对象（封装成1个Disposable对象）
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
// 2.调用观察者的onSubscribe()，表示“开始采用subscribe连接”
observer.onSubscribe(parent);
try {
// 核心：3.调用source对象，即ObservableOnSubscribe对象的subscribe(observer)
// subscribe()的实现 = 使用步骤1 创建被观察者（Observable））中复写的subscribe() ->>分析2
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
/**
* 分析2：emitter.onNext("1")
*/
static final class CreateEmitter<T> extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
...
@Override
public void onNext(T t) {
// 注：发送的事件不可为空
if (t == null) {
onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
return;
}
// 若无断开连接，则调用观察者的同名方法 = onNext()
// 观察者的onNext()的内容 = 使用步骤2中复写内容
if (!isDisposed()) {
observer.onNext(t);
}
}
// onError()、onComplete()类似
// 特别说明：调用该2方法，最终都会自动调用dispose()，即断开观察者 & 被观察者的连接
@Override
public void onError(Throwable t) {
if (t == null) {
t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
}
if (!isDisposed()) {
try {
observer.onError(t);
} finally {
dispose();
}
} else {
RxJavaPlugins.onError(t);
}
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
}
4.1.3 创建观察者（Observer）& 定义响应事件的行为
（1）使用方法步骤2
// 步骤2：创建观察者 & 定义响应事件的行为（方法内的创建对象代码）
subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
LogUtils.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
LogUtils.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
LogUtils.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
LogUtils.d(TAG, "对Complete事件作出响应");
}
});
（2）源码分析
public interface Observer<T> {
// 注：Observer本质 = 1个接口
// 接口内含4个方法，分别用于 响应 对应于被观察者发送的不同事件
void onSubscribe(@NonNull Disposable d); // 内部参数：Disposable 对象，可结束事件
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
4.1.4 通过订阅（subscribe）连接观察者和被观察者
（1）使用方法步骤3
// 步骤3：通过订阅（subscribe）连接观察者和被观察者 = subscribe()
subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
LogUtils.d(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer value) {
LogUtils.d(TAG, "接收到了事件" + value);
}
@Override
public void onError(Throwable e) {
LogUtils.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
LogUtils.d(TAG, "对Complete事件作出响应");
}
});
（2）源码分析
// 源码分析：Observable.subscribe(observer)
public abstract class Observable<T> implements ObservableSource<T> {
@Override
public final void subscribe(Observer<? super T> observer) {
// 当Observable.subscribe被调用时，回调subscribeActual(observer)
subscribeActual(observer);
}
/**
* 子类实现 = 步骤1创建被观察者（Observable）时创建的ObservableCreate类
*/
protected abstract void subscribeActual(Observer<? super T> observer);
}
4.1.5 源码总结
4.2 map操作符源码分析
4.2.1 基本使用
/**
* 对被观察者发送的每1个事件都通过 指定的函数 处理，从而变换成另外一种事件
* 场景：数据类型转换
* @param view
*/
public void map(View view) {
Observable.create(new ObservableOnSubscribe<Integer>() {
// 1. 被观察者发送事件 = 参数为整型 = 1、2、3
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
// 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：整型变换成字符串类型
}).map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) throws Exception {
return "使用 Map变换操作符 将事件" + integer + "的参数从 整型：" + integer + " 变换成 字符串类型：" + (integer + "s");
}
}).subscribe(new Consumer<String>() {
// 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型
@Override
public void accept(String s) throws Exception {
LogUtils.d(TAG, "接收到了事件：" + s);
}
});
/**
* RxMapActivity: 接收到了事件：使用 Map变换操作符 将事件1的参数从 整型：1 变换成 字符串类型：1s
* RxMapActivity: 接收到了事件：使用 Map变换操作符 将事件2的参数从 整型：2 变换成 字符串类型：2s
* RxMapActivity: 接收到了事件：使用 Map变换操作符 将事件3的参数从 整型：3 变换成 字符串类型：3s
*/
}
4.2.2 源码分析（简化）
// 源码分析：Observable.map(Function mapper){...}）
public static <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
... // 仅贴出关键源码
// 创建一个桥接前一个操作符和当前操作符的Observable子类-ObservableMap对象 ->> 分析1
return new ObservableMap<T, R>(this, mapper);
}
// 分析1：new ObservableMap(this, mapper)。ObservableMap类 = Observable的子类
public final class ObservableMap<T, R> extends Observable<T, R> {
final Function<? super T, ? extends U> function;
// 传入的source对象 = 前一个操作符返回的Observerable对象（Observable implements ObservableSource）
// 传入的function对象 = Map变换操作符中的Function函数对象
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
this.source = source;
this.function = function;
}
/**
* 关注：当Observable.subscribe被调用时，subscribeActual(observer)被立刻回调
* 作用：调用前一个操作符返回的Observerable对象的subscribe(observer)
*
* @param observer
*/
@Override
protected void subscribeActual(Observer<? super T> observer) {
// 创建一个桥接下层观察者和Map的Function函数对象的Observer子类-MapObserver对象
source.subscribe(new MapObserver<T, U>(observer, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {// // class BasicFuseableObserver implements Observer, QueueDisposable
Observer<? super R> observer;
final Function<? super T, ? extends U> function;
// 传入的observer对象 = 下层观察者
// 传入的function对象 = Map变换操作符中的Function函数对象
MapObserver(Observer<? super U> observer, Function<? super T, ? extends U> function) {
this.observer = observer;
this.function= function;
}
@Override
public void onNext(T t) {
// 进行转换和处理，再把结果返回给下层观察者
U v;
try {
// 回调map的apply()
v = function.apply(t);
} catch (Throwable ex) {
fail(ex);
return;
}
// 调用下层观察者的onNext()
observer.onNext(v);
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@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;
}
}
}
### 4.3 线程操作符源码分析
#### 4.3.1 基本使用
#### 4.3.2 源码分析
### 4.4 背压策源码分析
#### 4.4.1 基本使用
#### 4.4.2 源码分析
## 5 优秀的思想和设计
### 5.1
### 5.2
## 6 RxJava面试题解答
### 6.1 为什么RxJava好用？
### 6.2
7 学习链接
（1）全面详细的RxJava操作符使用攻略
Android RxJava：这是一份全面 & 详细 的RxJava操作符 使用攻略（总）
Android Rxjava：这是一篇 清晰 & 易懂的Rxjava 入门教程
Android RxJava：最基础的操作符详解 - 创建操作符
Android RxJava：图文详解 变换操作符
Android RxJava：组合 / 合并操作符 详细教程
Android RxJava：功能性操作符 全面讲解
（2）原理
一起来造一个RxJava，揭秘RxJava的实现原理
Android RxJava 2.0：手把手带你 源码分析RxJava
从微观角度解读RxJava源码
友好 RxJava2.x 源码解析（三）zip 源码分析
（3）官网
ReactiveX/RxJava文档英文版
ReactiveX/RxJava文档中文版
ReactiveX/RxJava-wiki
（4）其他
Android RxJava ：图文详解 背压策略
Android 勤用RXJava compose操作符消除重复代码
8 UML图分析
8.1 基本的RxJava例子
由于篇幅较大，请需要的小伙伴下载文件：RxJava框架时序图-基本的RxJava例子
8.2 map操作符：将T类型的Event转化成R类型
由于篇幅较大，请需要的小伙伴下载文件：RxJava框架时序图-map操作符
8.3 线程切换
由于篇幅较大，请需要的小伙伴下载文件：RxJava框架时序图-线程切换