前言
RxJava 是什麼
RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.
以上是RxJava在Github上的介紹，大概意思是，針對於JVM(Java虛擬機器）的響應式擴充套件實現，一個在Java VM上使用可觀察的序列來組合實現非同步的、基於事件程式設計的庫。
RxJava現在大家用的都應該已經很溜了，用法這裡就不再多說了。我們都知道RxJava是對觀察者模式的擴充套件，下面就從觀察者模式的實現機制出發，瞭解一下RxJava2的實現邏輯。只有真正瞭解了RxJava 的實現原理，我們才能在遇到問題的時候，更快速更準確的定位的到問題。
此次原始碼分析基於 RxJava Release 2.1.7
觀察者模式
這裡簡單回顧一下觀察者模式的組成及使用方式，通過之前觀察者模式一文中的分析，我們知道觀察者模式中有四個重要的角色：
- 抽象主題：定義新增和刪除觀察者的功能，也就是註冊和解除註冊的功能
- 抽象觀察者：定義觀察者收到主題通知後要做什麼事情
- 具體主題：抽象主題的實現
- 具體觀察者：抽象觀察者的實現
當我們建立好了具體主題和觀察者類，就可以使用觀察者模式了，下面是一個最簡單的測試demo。
public class TestObservePattern {
public static void main(String[] args) {
// 建立主題(被觀察者)
ConcreteSubject concreteSubject = new ConcreteSubject();
// 建立觀察者
ObserverOne observerOne=new ObserverOne();
// 為主題新增觀察者
concreteSubject.addObserver(observerOne);
//主題通知所有的觀察者
concreteSubject.notifyAllObserver("wake up,wake up");
}
}
複製程式碼以上就是觀察者模式的使用方式，很簡單是吧。現在就讓我們帶著以下幾個問題，看看RxJava是如何使用觀察者模式的。
用RxJava這麼久了，你可以思考一下如下幾個問題：
- RxJava 中上面提到的四個重要角色是如何定義的？
- RxJava 中具體的主題，具體的觀察者是如何例項化的？
- RxJava 中觀察者和主題是如何實現訂閱的？
- RxJava 中上游是怎麼傳送事件的，下游又是怎樣接收到的?
- RxJava 中對常規的觀察者模式做了怎樣調整，帶來了什麼好處？
如果對以上幾個問題，你有明確的答案，恭喜你，以下內容你就不用再看了，O(∩_∩)O哈哈~。
很多開發者對RxJava的學習可能是從上游和下游的角度開始，這裡可以認為這樣的敘述更偏重RxJava 事件序列的特徵。本文從被觀察者（主題）和觀察者的角度出發，可以說是更偏向於RxJava 觀察者模式的特徵。這裡的主題就是上游，觀察者就是下游。無論從哪個角度出發去理解，原始碼就那麼一份，無所謂對錯，只是每個人的認知角度不同而已，選擇一種自己更容易瞭解的方式即可。
好了，如果你看到了這裡，說明你對以上幾個問題，還有些許疑問，那麼我們就從這幾個問題出發，瞭解一下RxJava的原始碼實現。
RxJava2 的觀察者模式實現
我們就帶著上述幾個問題，依次來看看RxJava到底是怎麼一回事兒。為了方便敘述和記憶，我們首先看一段RxJava2 最最基礎的使用方式。
private void basicRxjava2() {
Observable mObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("1");
e.onNext("2");
e.onNext("3");
e.onNext("4");
e.onComplete();
}
});
Observer mObserver = new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "onSubscribe: d=" + d);
sb.append("\nonSubcribe: d=" + d);
}
@Override
public void onNext(Object s) {
Log.e(TAG, "onNext: " + s);
sb.append("\nonNext: " + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "onError: " + e);
sb.append("\nonError: " + e.toString());
logContent.setText(sb.toString());
}
@Override
public void onComplete() {
Log.e(TAG, "onComplete");
sb.append("\nonComplete: ");
logContent.setText(sb.toString());
}
};
mObservable.subscribe(mObserver);
}
複製程式碼上面這段程式碼，應該很容易理解了，輸出結果大家閉著眼睛也能想出來吧。我們就以這段程式碼為基礎，結合上面提到的問題依次展開對RxJava的分析。
四個重要的角色
首先看看RxJava 中四個重要的角色是如何定義的。
- 抽象主題
首先可以看看這個Observable類。
public abstract class Observable<T> implements ObservableSource<T> {
……
}
複製程式碼他實現了ObservableSource介面，接著看ObservableSource
public interface ObservableSource<T> {
/**
* Subscribes the given Observer to this ObservableSource instance.
* @param observer the Observer, not null
* @throws NullPointerException if {@code observer} is null
*/
void subscribe(@NonNull Observer<? super T> observer);
}
複製程式碼這裡很明顯了，ObservableSource 就是抽象主題（被觀察者）的角色。按照之前觀察者模式中約定的職責，subscribe 方法就是用來實現訂閱觀察者（Observer）角色的功能。從這裡我們也可以看出，抽象觀察者的角色就是Observer了。
這裡，你也許會有疑問，這麼簡單？抽象主題（上游）不是需要傳送事件嗎？onNext(),onComplete()以及onError()跑哪兒去了？彆著急，我們後面慢慢看。
- 具體主題
回過頭來繼續看Observable，他實現了ObservableSource介面，並且實現了其subscribe方法，但是它並沒有真正的去完成主題和觀察者之間的訂閱關係，而是把這個功能，轉接給了另一個抽象方法subscribeActual（具體細節後面分析）。
因此，Observable依舊是一個抽象類，我們知道抽象類是不能被例項化的，因此從理論上來說，他好像不能作為具體主題的角色。其實不然，Observable內部提供了create,defer,fromXXX,repeat,just等一系列建立型操作符， 用來建立各種Observable。
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
複製程式碼在RxJava內有很多他的子類。
誠然，你可以認為，這些子類其實才是真正的具體主題。但是，換一個角度，從代理模式的角度出發，我們可以把Observable當做是一個代理類，客戶端你只管呼叫create 方法，想要什麼樣的 Observable告訴我一聲就可以，不同Observable之間的差異你不用管，包在我身上，保證給你返回你想要的Observable例項。
同時，Observable另一個巨大的貢獻，就是定義了很多的操作符，我們平時常用的map,flatMap,distinct等，也是在這裡定義。並且這些方法都是final型別的，因此他的所有子類都會繼承同時也無法改變這些操作符的實現。
因此，Observable 就是具體主題。
- 抽象觀察者
在抽象主題裡已經提過了，Observer就是抽象觀察者的角色。
public interface Observer<T> {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
複製程式碼非常符合觀察者模式中抽象觀察者的職責描述，Observer 定義了觀察者（下游）收到主題（上游）通知後該做什麼事情。這裡需要注意的是onSubscribe 也是定義在這裡的。
- 具體的觀察者
這個具體的觀察者，o(╯□╰)oo(╯□╰)o，就不多說了吧。大家平時使用應該都是直接用new一個Observer的例項。RxJava內部有很多Observer的子類，有興趣的同學可以具體瞭解一下。這裡其實可以引申出一個有意思的問題，同樣是抽象類，為什麼介面可以直接例項化，而用abstract修飾過的類就不可以？
具體的觀察者是如何例項化的
我們看一下這段程式碼：
Observable mObservable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
}
});
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
// 是否有別的其他操作符運算，有的話，在此Observable上執行一遍
if (f != null) {
return apply(f, source);
}
return source;
}
複製程式碼RxJava的程式碼裡，很多時候會有ObjectHelper.requireNonNull這種空檢查的地方，一律都是為了最大程度的防止NPE的出現，後面出現就不再贅述了.
我們使用create操作符建立Observable的過程中，看似經歷了很多方法，在不考慮任何其他操作符的前提下，整個過程簡化一下的話就這麼一句程式碼
Observable mObservable=new ObservableCreate(new ObservableOnSubscribe())
複製程式碼從之前的分析，我們也看到了ObservableCreate 就是Observeable抽象類的一個子類。我們簡單看一下他的實現。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
……
}
}
複製程式碼可以看到，他唯一的建構函式需要一個ObservableOnSubscribe例項，同時他實現subscribeActual方法，說明他真正處理主題和觀察者之間實現訂閱的邏輯。
看了半天，你可能一直很好奇，這個ObservableOnSubscribe是個什麼東西呢？他其實很簡單。
/**
* A functional interface that has a {@code subscribe()} method that receives
* an instance of an {@link ObservableEmitter} instance that allows pushing
* events in a cancellation-safe manner.
*
* @param <T> the value type pushed
*/
public interface ObservableOnSubscribe<T> {
/**
* Called for each Observer that subscribes.
* @param e the safe emitter instance, never null
* @throws Exception on error
*/
void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;
}
複製程式碼ε=(´ο｀*)))唉，怎麼又一個subscribe，這又是啥？不要慌，看註釋。意思是說，這裡的subscribe 接收到一個ObservableEmitter例項後，就會允許他以一種可以安全取消（也就是一定能取消）的形式傳送事件。
就是說會有某個物件，給他一個ObservableEmitte的例項，沒給他之前他是不會主動傳送事件的，會一直憋著。，到這裡，你是不是想到了什麼，我們知道在RxJava 中只有觀察者（下游）訂閱(subscribe)了主題（上游），主題才會傳送事件。這就是和普通的觀察者模式有區別的地方之一。
好了，最後再來看看這個神祕的ObservableEmitter是個什麼鬼？
public interface ObservableEmitter<T> extends Emitter<T> {
void setDisposable(@Nullable Disposable d);
void setCancellable(@Nullable Cancellable c);
boolean isDisposed();
ObservableEmitter<T> serialize();
/**
* Attempts to emit the specified {@code Throwable} error if the downstream
* hasn't cancelled the sequence or is otherwise terminated, returning false
* if the emission is not allowed to happen due to lifecycle restrictions.
* <p>
* Unlike {@link #onError(Throwable)}, the {@code RxJavaPlugins.onError} is not called
* if the error could not be delivered.
* @param t the throwable error to signal if possible
* @return true if successful, false if the downstream is not able to accept further
* events
* @since 2.1.1 - experimental
*/
boolean tryOnError(@NonNull Throwable t);
}
複製程式碼這裡可以關注一下tryOnError這個方法，可以看到他會把某些型別的error傳遞到下游。
o(╥﹏╥)o，又是一個介面，而且還繼承了另一個介面，什麼情況？繼續看
public interface Emitter<T> {
void onNext(@NonNull T value);
void onError(@NonNull Throwable error);
void onComplete();
}
複製程式碼驚不驚喜，意不意外？ 哈哈，終於找到你了，熟悉的onNext，onError,onComplete.原來在這裡。
這裡有個問題可以思考一下，在抽象觀察者中，定義了四個處理事件的方法，這裡只有三個，按照對應關係來說似乎缺了一個onSubscribe，這又是怎麼回事呢？後面會有分析，可以自己先想想
這兩個介面的含義很明顯了，總結一下：
- Emitter 定義了可以傳送的事件的三種機制
- ObservableEmitter 在Emitter 做了擴充套件，新增了Disposable相關的方法，可以用來取消事件的傳送。
好了，繞了一大圈，就為了一行程式碼：
Observable mObservable=new ObservableCreate(new ObservableOnSubscribe())
複製程式碼總結一下具體主題（上游）的到底幹了啥：
- 建立了一個ObservableCreate 的例項物件
- ObservableCreate 內持有ObservableOnSubscribe 物件的引用
- ObservableOnSubscribe 是一個介面，內部有一個subscribe方法，呼叫他之後，會用其ObservableEmitter例項開始傳送事件。
- ObservableEmitter 繼承自Emitte。
如何實現訂閱、傳送事件和接收事件
為了方便敘述，把問題3和4連在一起說了。
通過上面的敘述，現在具體主題和具體的觀察者都建立好了，接下來就是實現二者的訂閱關係。
mObservable.subscribe(mObserver);
複製程式碼這裡需要明確的一點是，是觀察者（下游）訂閱了主題（上游），雖然從程式碼上看好像了前者訂閱了後者，不要搞混了。
我們看Observable的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(observer);
} catch (NullPointerException e) { // NOPMD
throw e;
} catch (Throwable e) {
……
}
}
複製程式碼這個前面已經提到過了，Observable並沒有真正的去實現subscribe,而是把他轉接給了subscribeActual()方法。
前面已經說過，Observable的例項是一個ObservableCreate物件，那麼我們就到這個類裡去看看subscribeActual()的實現。
// 為了方便，順便再看一眼建構函式
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@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);
}
}
複製程式碼CreateEmitter 實現了之前提到的ObservableEmitter介面。這裡有一句關鍵的程式碼：
observer.onSubscribe(parent);
複製程式碼之前在看到Emitter的定義時，我們說缺少了onSubscribe方法，到這裡就明白了。onSubscribe並不是由主題（上游）主動傳送的事件，而是有觀察者（下游）自己呼叫的一個事件，只是為了方便獲取Emitter的例項物件，準確的說應該是Disposable的例項物件，這樣下游就可以控制上游了。
接下來就更簡單了，source 是ObservableOnSubscribe，按照之前的邏輯，呼叫其subscribe方法，給他一個ObservableEmitter物件例項，ObservableEmitter就會開始傳送事件序列。這樣，一旦開始訂閱了，主題（上游）就開始傳送事件了。也就是我們熟悉的onNext,onComplete,onError 方法真正的開始執行了。
接著看看CreateEmitter的實現。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
observer.onSubscribe(parent);
……
}
static final class CreateEmitter<T>
extends AtomicReference<Disposable>
implements ObservableEmitter<T>, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer<? super T> observer;
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
@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;
}
if (!isDisposed()) {
observer.onNext(t);
}
}
@Override
public void onError(Throwable t) {
if (!tryOnError(t)) {
RxJavaPlugins.onError(t);
}
}
@Override
public boolean tryOnError(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();
}
return true;
}
return false;
}
@Override
public void onComplete() {
if (!isDisposed()) {
try {
observer.onComplete();
} finally {
dispose();
}
}
}
@Override
public void setDisposable(Disposable d) {
DisposableHelper.set(this, d);
}
@Override
public void setCancellable(Cancellable c) {
setDisposable(new CancellableDisposable(c));
}
@Override
public ObservableEmitter<T> serialize() {
return new SerializedEmitter<T>(this);
}
@Override
public void dispose() {
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
}
}
複製程式碼- 他的建構函式，需要一個觀察者的例項；
- 他實現了ObservableEmitter介面，並依次實現他的三個方法；
- 在每一次的onNext事件中，他不再接受引數為null的型別，在事件序列沒有中斷的情況下會把主題（上游）傳送的事件T原封不動的傳遞給觀察者(下游）。
- onComplete事件發生時，他也會通知下游，如果發生異常，則中斷事件序列
- onError 事件發生時，並沒有直接傳遞到下游，而是在其內部處理
- tryOnError 事件發生時，才會把某些特定型別的錯誤傳遞到下游。
- 他實現了Disposable介面，下游根據獲取到的Emitter的例項物件，可以方便的獲取事件序列的資訊，甚至是可以主動關閉事件序列，及斷開觀察者模式中主題和觀察者間的訂閱關係。
RxJava 中對常規的觀察者模式做了怎樣調整，帶來了什麼好處？
最後再來簡單說一下，RxJava中對常規的觀察者模式做了怎樣的調整，有什麼值得借鑑的地方。大部分優點在上面已經提及了，這裡就來總結一下。
- 觀察者訂閱主題後，主題才會開始傳送事件
- RxJava中Observer通過onSubscribe獲取了傳送事件中的Disposable物件，這樣他就可以主動的獲取訂閱關係中二者的狀態，甚至是控制或者是中斷事件序列的傳送。在常規的觀察者模式中，主題有權利新增訂閱者，但也能是由他移除特定的訂閱者，因為只有他持有所有訂閱者的集合
- 抽象主題（上游）並沒有直接控制onNext，onComplete,onError事件的傳送，而是隻關注Emitter 例項的傳送，ObservableOnSubscribe介面監聽ObservableEmitter物件的傳送，一旦接受到此物件就會通過他開始傳送具體的事件，這裡可以有點觀察者模式巢狀的意味。
好了，以上就是從觀察者模式的角度出發，對RxJava的一次解讀，有什麼疏漏或理解錯誤的地方，歡迎讀者指出，共同進步！