瞭解 RxJava 的應該都知道是一個基於事務驅動的庫，響應式程式設計的典範。提到事務驅動和響應就不得不說說，設計模式中觀察者模式，已經瞭解的朋友，可以直接跳過觀察者模式的介紹，直接到 RxJava 原始碼中對於觀察者的應用。
觀察者模式
該部分結合自扔物線的 《給 Android 開發者的 RxJava 詳解》， 強烈推薦剛接觸 RxJava 的朋友閱讀。
傳統觀察者模式
觀察者模式面向的需求是：A 物件（觀察者）對 B 物件（被觀察者）的某種變化高度敏感，需要在 B 變化的一瞬間做出反應。舉個例子，新聞裡喜聞樂見的警察抓小偷，警察需要在小偷伸手作案的時候實施抓捕。在這個例子裡，警察是觀察者，小偷是被觀察者，警察需要時刻盯著小偷的一舉一動，才能保證不會漏過任何瞬間。程式的觀察者模式和這種真正的『觀察』略有不同，觀察者不需要時刻盯著被觀察者（例如 A 不需要每過 2ms 就檢查一次 B 的狀態），而是採用註冊( Register )或者稱為訂閱( Subscribe )的方式，告訴被觀察者：我需要你的某某狀態，你要在它變化的時候通知我。 Android 開發中一個比較典型的例子是點選監聽器 OnClickListener 。對設定 OnClickListener 來說， View 是被觀察者， OnClickListener 是觀察者，二者通過 setOnClickListener() 方法達成訂閱關係。訂閱之後使用者點選按鈕的瞬間，Android Framework 就會將點選事件傳送給已經註冊的 OnClickListener 。採取這樣被動的觀察方式，既省去了反覆檢索狀態的資源消耗，也能夠得到最高的反饋速度。當然，這也得益於我們可以隨意定製自己程式中的觀察者和被觀察者，而警察叔叔明顯無法要求小偷『你在作案的時候務必通知我』。
OnClickListener 的模式大致如下圖：
如圖所示，通過 setOnClickListener() 方法，Button 持有 OnClickListener 的引用（這一過程沒有在圖上畫出）；當使用者點選時，Button 自動呼叫 OnClickListener 的 onClick() 方法。另外，如果把這張圖中的概念抽象出來（Button -> 被觀察者、OnClickListener -> 觀察者、setOnClickListener() -> 訂閱，onClick() -> 事件），就由專用的觀察者模式（例如只用於監聽控制元件點選）轉變成了通用的觀察者模式。如下圖：
而 RxJava 作為一個工具庫，使用的就是通用形式的觀察者模式。
RxJava 中觀察者模式
RxJava 有四個基本概念：Observable (可觀察者，即被觀察者)、 Observer (觀察者)、 subscribe (訂閱)、事件。Observable 和 Observer 通過 subscribe() 方法實現訂閱關係，從而 Observable 可以在需要的時候發出事件來通知 Observer。
與傳統觀察者模式不同， RxJava 的事件回撥方法除了普通事件 onNext() （相當於 onClick() / onEvent()）之外，還定義了兩個特殊的事件：onCompleted() 和 onError()。
onCompleted(): 事件佇列完結。RxJava 不僅把每個事件單獨處理，還會把它們看做一個佇列。RxJava 規定，當不會再有新的onNext()發出時，需要觸發onCompleted()方法作為標誌。onError(): 事件佇列異常。在事件處理過程中出異常時，onError()會被觸發，同時佇列自動終止，不允許再有事件發出。- 在一個正確執行的事件序列中,
onCompleted()和onError()有且只有一個，並且是事件序列中的最後一個。需要注意的是，onCompleted()和onError()二者也是互斥的，即在佇列中呼叫了其中一個，就不應該再呼叫另一個。並且只要onCompleted()和onError()中有一個呼叫了，都會中止onNext()的呼叫。
RxJava 的觀察者模式大致如下圖：
基本實現
基於以上觀點， RxJava 的基本實現主要有三點:
建立 Observer
Observer 即觀察者，它決定事件觸發的時候將有怎樣的行為。 RxJava 中的 Observer 介面的實現方式：
Observer<String> observer = new Observer<String>() {
@Override
public void onNext(String s) {
Log.d(tag, "Item: " + s);
}
@Override
public void onCompleted() {
Log.d(tag, "Completed!");
}
@Override
public void onError(Throwable e) {
Log.d(tag, "Error!");
}
};複製程式碼除了 Observer 介面之外，RxJava 還內建了一個實現了 Observer 的抽象類：Subscriber。 Subscriber 對 Observer 介面進行了一些擴充套件，但他們的基本使用方式是完全一樣的：
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onNext(String s) {
Log.d(tag, "Item: " + s);
}
@Override
public void onCompleted() {
Log.d(tag, "Completed!");
}
@Override
public void onError(Throwable e) {
Log.d(tag, "Error!");
}
};複製程式碼不僅基本使用方式一樣，實質上，在 RxJava 的 subscribe 過程中，Observer 也總是會先被轉換成一個 Subscriber 再使用。
// Observable.java 原始碼
public final Subscription subscribe(final Observer<? super T> observer) {
if (observer instanceof Subscriber) { // 如果是 Subscriber 的子類，直接轉化為 Subscriber
return subscribe((Subscriber<? super T>)observer);
}
if (observer == null) {
throw new NullPointerException("observer is null");
}
return subscribe(new ObserverSubscriber<T>(observer));
}複製程式碼// ObserverSubscriber.java
public final class ObserverSubscriber<T> extends Subscriber<T> {
...
}複製程式碼通過原始碼可以看到，傳入的
Observer最終還是會轉化為Subscriber來使用。
所以如果你只想使用基本功能，選擇 Observer 和 Subscriber 是完全一樣的。它們的區別對於使用者來說主要有兩點：
onStart(): 這是 Subscriber 增加的方法。它會在 subscribe 剛開始，而事件還未傳送之前被呼叫，可以用於做一些準備工作，例如資料的清零或重置。這是一個可選方法，預設情況下它的實現為空。需要注意的是，如果對準備工作的執行緒有要求（例如彈出一個顯示進度的對話方塊，這必須在主執行緒執行）， onStart() 就不適用了，因為它總是在 subscribe 所發生的執行緒被呼叫，而不能指定執行緒。要在指定的執行緒來做準備工作，可以使用 doOnSubscribe() 方法。
// Subscriber.java
public void onStart() {
// do nothing by default
}複製程式碼unsubscribe(): 這是 Subscriber 所實現的另一個介面 Subscription 的方法，用於取消訂閱。在這個方法被呼叫後，Subscriber 將不再接收事件。一般在這個方法呼叫前，可以使用 isUnsubscribed() 先判斷一下狀態。unsubscribe()這個方法很重要，因為在 subscribe() 之後， Observable 會持有 Subscriber 的引用，這個引用如果不能及時被釋放，將有記憶體洩露的風險。所以最好保持一個原則：要在不再使用的時候儘快在合適的地方（例如 onPause() onStop() 等方法中）呼叫unsubscribe()來解除引用關係，以避免記憶體洩露的發生。
// Subscriber.java
@Override
public final void unsubscribe() {
subscriptions.unsubscribe();
}
@Override
public final boolean isUnsubscribed() {
return subscriptions.isUnsubscribed();
}複製程式碼建立 Observable
Observable 即被觀察者，它決定什麼時候觸發事件以及觸發怎樣的事件。例如 create() 方法
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Hi");
subscriber.onNext("Aloha");
subscriber.onCompleted();
}
});複製程式碼可以看到，這裡傳入了一個 OnSubscribe 物件作為引數。OnSubscribe 會被儲存在返回的 Observable 物件中，它的作用相當於一個計劃表，當 Observable 被訂閱的時候，OnSubscribe 的 call() 方法會自動被呼叫，事件序列就會依照設定依次觸發（對於上面的程式碼，就是觀察者Subscriber 將會被呼叫三次 onNext() 和一次 onCompleted()。這樣，由被觀察者呼叫了觀察者的回撥方法，就實現了由被觀察者向觀察者的事件傳遞，即觀察者模式。
create() 方法是 RxJava 最基本的創造事件序列的方法。基於這個方法， RxJava 還提供了一些方法用來快捷建立事件佇列，例如 just(), from()
訂閱 Subscribe
建立了 Observable 和 Observer 之後，再用 subscribe() 方法將它們聯結起來，整條鏈子就可以工作了。程式碼形式很簡單：
observable.subscribe(observer);
// 或者：
observable.subscribe(subscriber);複製程式碼有人可能會注意到，
subscribe()這個方法有點怪：它看起來是『observalbe訂閱了observer / subscriber』而不是『observer / subscriber訂閱了observalbe』，這看起來就像『雜誌訂閱了讀者』一樣顛倒了物件關係。這讓人讀起來有點彆扭，不過如果把 API 設計成observer.subscribe(observable) / subscriber.subscribe(observable)，雖然更加符合思維邏輯，但對流式 API 的設計就造成影響了，比較起來明顯是得不償失的。
整個過程中物件間的關係如下圖：
原始碼層解析
基礎原理
// 例子
Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("Hello");
subscriber.onNext("Hi");
subscriber.onNext("Aloha");
subscriber.onCompleted();
}
}).subscribe(new Subscriber<String>() {
@Override
public void onCompleted() {
System.out.println("onCompleted");
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
System.out.println("value: " + s);
}
});複製程式碼log 資訊
value: Hello
value: Hi
value: Aloha
onCompleted複製程式碼看到上面程式碼，可能會有人跟我一樣不明白， create() 中的 OnSubscribe 中 call() 的 Subscriber 是怎麼樣最終就變成了 subscribe() 中的 Subscriber。
下面來一下 Observable.subscribe(Subscriber) 的內部實現是這樣的（僅核心程式碼）：
// 注意：這不是 subscribe() 的原始碼，而是將原始碼中與效能、相容性、擴充套件性有關的程式碼剔除後的核心程式碼。
static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
...
// 可以用於做一些準備工作，例如資料的清零或重置, 預設情況下它的實現為空
subscriber.onStart();
if (!(subscriber instanceof SafeSubscriber)) {
// 強制轉化為 SafeSubscriber 是為了保證 onCompleted 或 onError 呼叫的時候會中止 onNext 的呼叫
subscriber = new SafeSubscriber<T>(subscriber);
}
...
// // onObservableStart() 預設返回的就是 observable.onSubscribe
RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
// onObservableReturn() 預設也是返回 subscriber
return RxJavaHooks.onObservableReturn(subscriber);
...
}複製程式碼通過原始碼可以看到，subscriber() 實際就做了 4 件事情
- 呼叫
Subscriber.onStart()。這個方法在前面已經介紹過，是一個可選的準備方法。 - 將傳入的
Subscriber轉化為SafeSubscriber， 為了保證 onCompleted 或 onError 呼叫的時候會中止 onNext 的呼叫。
// 注意：這不是 SafeSubscriber 的原始碼，而是將原始碼中與效能、相容性、擴充套件性有關的程式碼剔除後的核心程式碼。
public class SafeSubscriber<T> extends Subscriber<T> {
private final Subscriber<? super T> actual;
boolean done; // 通過改標誌來保證 onCompleted 或 onError 呼叫的時候會中止 onNext 的呼叫
public SafeSubscriber(Subscriber<? super T> actual) {
super(actual);
this.actual = actual;
}
@Override
public void onCompleted() {
if (!done) {
done = true;
...
actual.onCompleted();
...
unsubscribe(); // 取消訂閱，結束事務
}
}
@Override
public void onError(Throwable e) {
...
if (!done) {
done = true;
_onError(e);
}
}
@Override
public void onNext(T t) {
if (!done) { // done 為 true 時，中止傳遞
actual.onNext(t);
}
}
@SuppressWarnings("deprecation")
protected void _onError(Throwable e) {
...
actual.onError(e);
...
unsubscribe();
...
}
}複製程式碼通過程式碼可以看出來，通過 SafeSubscriber 中的布林變數 done 來做標記保證上文提到的 onCompleted() 和 onError() 二者的互斥性，即在佇列中呼叫了其中一個，就不應該再呼叫另一個。並且只要 onCompleted() 和 onError() 中有一個呼叫了，都會中止 onNext() 的呼叫。
- 呼叫 Observable 中的 OnSubscribe.call(Subscriber) 。在這裡，事件傳送的邏輯開始執行。從這也可以看出，在 RxJava 中， Observable 並不是在建立的時候就立即開始傳送事件，而是在它被訂閱的時候，即當 subscribe() 方法執行的時候。
- 將傳入的
Subscriber作為 Subscription 返回。這是為了方便unsubscribe().
以上就是 RxJava 最基本的一個通過觀察者模式，來響應事件的原理。下面來看看 RxJava 中一些基本操作符的實現原理又是怎樣的。
為了能更好的理解原始碼，需要對 RxJava 有基本的使用基礎，對 RxJava 不太熟悉的朋友請先一步到《給 Android 開發者的 RxJava 詳解》
進階
Observable.interval(1, TimeUnit.SECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
return aLong * 5;
}
})
.subscribe(new Action1<Long>() {
@Override
public void call(Long aLong) {
System.out.println("value: " + aLong);
}
});複製程式碼log 資訊
value: 0
value: 5
value: 10
...複製程式碼上面的列子會每秒生成一個從 0 依次遞增的整數，然後通過 map() 變換操作符後，變成了 5 的倍數的一個整數列。
第一次看到該例子時，就喜歡上了 RxJava，這種鏈式函式的互動模式真的很簡潔，終於可以從回撥地獄裡逃出來了。喜歡的同時不免也會想 RxJava 是如何實現的。這種鏈式的函式流可以算是建造者模式的一種變形，只不過省去了中間 Builder 而直接返回當前物件來實現。 更讓我興奮的是內部這些操作符的實現原理。
上文也已經說過了在 RxJava 中， Observable 並不是在建立的時候就立即開始傳送事件，而是在它被訂閱的時候，即當 subscribe() 方法執行的時候。 所以對於上面一段的程式碼我們要從 subscribe() 往前屢，首先看一下 map() 這個函式的內部實現。
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
// 新建了一個 Observable 並使用新的 OnSubscribeMap 來封裝傳入的資料
return unsafeCreate(new OnSubscribeMap<T, R>(this, func));
}複製程式碼不用說大家也猜到了 OnSubscribeMap 是 OnSubscribe 的子類
// 注意：這不是 OnSubscribeMap 的原始碼，而是將原始碼中與效能、相容性、擴充套件性有關的程式碼剔除後的核心程式碼。
public final class OnSubscribeMap<T, R> implements OnSubscribe<R> {
final Observable<T> source;
final Func1<? super T, ? extends R> transformer;
public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {
this.source = source; // 列子中經過 Observable.interval() 函式生成的 Observable
this.transformer = transformer;
}
// 傳入的 o 就是例子中 `subscribe()` 出入的 Subscribe
// 具體結合 Observable.subscribe() 原始碼來理解
@Override
public void call(final Subscriber<? super R> o) {
// 對傳入的 Subscriber 進行再次封裝成 MapSubscriber
// 具體 Observable.map() 的邏輯是在 MapSubscriber 中
MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
o.add(parent); // 加入到 SubscriptionList 中，為之後取消訂閱
// Observable.interval() 返回的 Observable 進行訂閱(關鍵點)
source.unsafeSubscribe(parent);
}
...
}複製程式碼可以看到 call() 方法的邏輯很簡單，只是將例子中 Observable.subscribe() 傳入的 Subscriber 進行封裝後，再將上流傳入的 Observable 進行訂閱
// 注意：這不是 MapSubscriber 的原始碼
// 而是將原始碼中與效能、相容性、擴充套件性有關的程式碼剔除後的核心程式碼。
static final class MapSubscriber<T, R> extends Subscriber<T> {
final Subscriber<? super R> actual;
final Func1<? super T, ? extends R> mapper;
public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
this.actual = actual; // Observable.subscribe() 傳入的 Subscriber
this.mapper = mapper;
}
@Override
public void onNext(T t) {
R result;
...
result = mapper.call(t); // 資料進行了變換
...
actual.onNext(result); // 往下流傳
}
...
}複製程式碼通過以上就完成了
map()對資料的變換，這裡最終的就是理解OnSubscribeMap的call()中 source.unsafeSubscribe(parent);source指的是例子中Observable.interval()生成的物件。
再來看一下 RxJava 中對 Observable.interval() 的實現
public static Observable<Long> interval(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
return unsafeCreate(new OnSubscribeTimerPeriodically(initialDelay, period, unit, scheduler));
}複製程式碼可以看出 interval() 和 map() 一樣都是通過生成新的 Observable 並向 Observable 中傳入與之對應的 OnSubscribe 的子類來完成具體操作。
// 注意：這不是 OnSubscribeTimerPeriodically 的原始碼
// 而是將原始碼中與效能、相容性、擴充套件性有關的程式碼剔除後的核心程式碼。
public final class OnSubscribeTimerPeriodically implements OnSubscribe<Long> {
final long initialDelay;
final long period;
final TimeUnit unit;
final Scheduler scheduler;
public OnSubscribeTimerPeriodically(long initialDelay, long period, TimeUnit unit, Scheduler scheduler) {
this.initialDelay = initialDelay;
this.period = period;
this.unit = unit;
this.scheduler = scheduler;
}
// 傳入的 Subscriber 為上文提到的 OnSubscribeMap.call() 方法中 source.unsafeSubscribe(parent);
@Override
public void call(final Subscriber<? super Long> child) {
final Worker worker = scheduler.createWorker();
child.add(worker);
worker.schedulePeriodically(new Action0() {
long counter;
@Override
public void call() {
...
child.onNext(counter++);
...
}
}, initialDelay, period, unit);
}
}複製程式碼以上就是 RxJava 整體的邏輯結構，可以看到 RxJava 將觀察者模式發揮的淋漓盡致。整體邏輯的處理有點像遞迴函式的原理。而 map() 則像一種代理機制，通過事件攔截和處理實現事件序列的變換。
總結: 精簡掉細節的話，也可以這麼說：在 Observable 執行了各種操作符( map, interval 等)之後 方法之後，會返回一個新的 Observable，這個新的 Observable 會像一個代理一樣，負責接收原始的 Observable 發出的事件，並在處理後傳送給 Subscriber。