系列文章：
本文 csdn 地址：友好 RxJava2.x 原始碼解析（一）基本訂閱流程
本文基於 RxJava 2.1.3
前言
本文基於讀者會使用 RxJava 2.x 而講解，基本原理不涉及，示例只純粹為示例而示例。示例程式碼
示例原始碼： Observable
.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onComplete();
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
Log.e("TAG", "onSubscribe(): ");
}
@Override
public void onNext(String s) {
Log.e("TAG", "onNext(): " + s);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.e("TAG", "onComplete(): ");
}
});
複製程式碼輸出結果：
E/TAG: onSubscribe():
E/TAG: onNext(): 1
E/TAG: onNext(): 2
E/TAG: onNext(): 3
E/TAG: onComplete():
複製程式碼訂閱流程解析
我們知道 subscribe() 方法是 Observable 和 Observer 的連線點，所以首先戳進 subscribe(Observer observer) 中，可以發現該方法是 Observable 類的方法，傳入了一個 Observer 物件，那首先我們需要弄明白這裡的 Observable 和 Observer 分別是什麼，觀察上方示例程式碼我們可以知道 Observer 是 new 出來的，所以我們只需要知道 Observable 是什麼，當然，這裡也很清晰，Observable 就是我們呼叫 Observable.create(ObservableOnSubscribe) 所建立出來的 Observable，來一張圖 ——
Observable 和 Observer 我們都弄清楚了，接下來就是檢視 subscribe(Observer) 具體的實現了，如下 ——
@Override
public final void subscribe(Observer<? super T> observer) {
// 略去其他原始碼
subscribeActual(observer);
// 略去其他原始碼
}
複製程式碼略去非關鍵原始碼後我們發現它只做了一件事，就是呼叫 Observable#subscribeActual(observer)，而在 Observable 中該方法是一個抽象方法：
protected abstract void subscribeActual(Observer<? super T> observer);
複製程式碼這意味著我們需要去找它的子類，我們要看看它的 subscribeActual(Observer) 方法，那我們就得從 create(ObservableOnSubscribe) 著手，看它是如何將一個 ObservableOnSubscribe 物件轉換成一個 Observable 物件的——
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
// 略去其他原始碼
return new ObservableCreate<T>(source);
}
複製程式碼同樣的，刪除非關鍵原始碼之後，我們就剩下這麼一行程式碼，這也就是意味著我們需要從 ObservableCreate 這個類中去尋找 subscribeActual(Observer) 的實現了，這裡筆者需要提及兩點——
-
從上述方法可以看出 ObservableCreate 是 Observable 的一個子類
-
我們自定義的 ObservableOnSubscribe 作為一個名為
source欄位被傳入了。事實上在 Observable 的子類實現中，它們都有一個名為source的欄位，指代上游 Observable（實際上是 ObservableOnSubscribe，但是我們不妨理解成就是 Observable）。
ObservableCreate#subscribeActual() 實現如下：
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
// 觸發 Observer#onSubscribe(Disposable)
observer.onSubscribe(parent);
try {
// 發射事件
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
複製程式碼第5行呼叫了 Observer#onSubscribe(Disposable) ，所以我們可以知道 Observer#onSubscribe(Disposable) 是先被呼叫的，而此時 Observable 甚至還沒有開始發射事件！接下來就是呼叫了 source.subscribe(ObservableEmitter)，這個方法是交由開發者去實現的，在示例程式碼是如下所寫 ——
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
emitter.onNext("2");
emitter.onNext("3");
emitter.onComplete();
}
複製程式碼在程式碼中我們呼叫了 CreateEmitter 物件的 onNext() 方法，所以我們需要戳入 CreateEmitter 類中看一下 onNext(T) 的具體實現（當然 onComplete() 方法等同，此處就不做擴充套件了），原始碼如下：
@Override
public void onNext(T t) {
// 略去其他原始碼
if (!isDisposed()) {
observer.onNext(t);
}
}
複製程式碼一目瞭然，噹噹前物件並不處於 DISPOSED 狀態時，那麼就將會呼叫下游 Observer 的 onNext(T) 方法，而下游 Observer 的 onNext(T) 方法也就是我們上面示例程式碼中所寫的——
public void onNext(String s) {
Log.e("TAG", "onNext(): ");
}
複製程式碼至此，基本訂閱流程我們就理清楚了。我們從 Observable#subscribe(Observer) 開始，將 Observer 傳給 Observable，而 Observable 又會在 onNext(T) 方法中啟用 Observer 的 onNext(T) 方法。我們在示例只涉及了少量的 Observable/Observer，事實上，我們在 RxJava 中運用的操作符都會在內部建立一個 Observable 和 Observer，雖然在 Observable#subscribeActual(Observer) 中都有自己特定的實現，但是它們大部分都是做兩個操作，一是將「下游」傳來的 Observer 根據需求進行封裝；二就是讓「上游」的 Observable subscribe() 該 Observer。
訂閱流程
經過了如上的分析後，筆者希望讀者能夠理解 RxJava2.x 的基本訂閱流程是從 Observable#subscribe(Observer) 開始的，而該方法會觸發「上游」 Observable 的 Observable#subscribeActual(Observer) 方法，而在該「上游」 Observable 中又會觸發「上游的上游」Observable 的 Observable#subscribeActual(Observer) 方法。我們不妨用以下述原始碼舉例：
Observable
.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
}
})
.flatMap(new Function<String, ObservableSource<String>>() {
@Override
public ObservableSource<String> apply(String s) throws Exception {
return Observable.just(s);
}
})
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(String s) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
複製程式碼另附一張圖，圖中標明瞭後面講到的「第一個 Observable」、「第二個 Observable」等名詞：
接下來用圖展示整個訂閱的流程——
Observable#subscribe(Observer) 流程
在 Observable#subscribe(Observer) 之前：
準備觸發 Observable#subscribe(Observer)：
Observable#subscribe(Observer) 將會導致其上游 Observable 的 subscribe(Observer) 方法被呼叫：
上游 Observable 的 subscribe(Observer) 方法內部又會呼叫上游的上游 Observable 的 subscribe(Observer)：
Observable#subscribe(Observer)會呼叫Observable#subscribeActual(Observer)，該方法是一個抽象方法，由子類覆寫，所以展現了 Observable 的多型性，而且如何啟用上游 Observable 的subscribe(Observer)/subscribeActual(Observer)方法的關鍵點也在此。實現方式就在於Observable#subscribeActual(Observer)方法雖然是一個抽象方法，但是它的子類實現中都包含有一句source.subscribe(Observer)，其中 source 就是上游 Observable（實際上是 ObservableSource，但是我們此處不妨就理解成 Observable，畢竟我們對這個物件更熟悉一些，Observable 是 ObservableSource 介面的實現），所以就可以理解在每一個 Observable 的subscribeActual(Observer)方法中它都會呼叫上游的subscribe(Observer)/subscribeActual(Observer)方法，直至到達第一個 Observable 的subscribe(Observer)/subscribeActual(Observer)中。
Observer#onSubscribe(Disposable) 流程
訂閱的關係鏈理清了，但是還沒有發射事件的流程還沒出來啊，我們繼續往下走——
到達頂部 Observable 的時候，已經不能再往上走了，就要準備搞事情（準備發射事件了），此處我們就以示例程式碼中的 Observable 為例，它的 subscribeActual(Observer) 中——
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
try {
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
複製程式碼它首先封裝了一個 Disposable，接下來將呼叫 Observer#onSubscribe(Disposable) 將 Disposable 作為引數傳給下一層 Observer。
到了下一層的 Observer 的 onSubscribe(Disposable) 中，該方法中針對上一層 Disposable 做一些操作（判斷、封裝等），然後再封裝一個 Disposable 作為引數傳遞給 Observer#onSubscribe(Disposable)。
而此時的 Observer 就是我們所自定義的 Observer——
Observer#onNext(T) 流程
在 Observer#onSubscribe(Disposable) 流程結束後，就執行到第7行程式碼 Observeable.subscribe(Observer)，實質上也就是——
new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("1");
}
})
複製程式碼ps：為了方便起見，此處只分析
onNext()執行流程。
在 ObservableEmitter#onNext(T) 的內部實際上會觸發 Observer 的 onNext(T) 方法——
再向下觸發就是我們所自定義的最底層的 Observer 了——
以示例程式碼來說，頂遊 Observable 會觸發 ObservableEmitter#onNext(T) 方法，在該方法的內部又觸發了「下游」 Observer 的 onNext(T) 方法，而在該方法內部又會觸發「下游的下游」 Observer 的 onNext(T) 方法，直至最底層的 Observer —— 我們所自定義的 Observer ——
到此，一套訂閱流程就執行完畢了。