RxJava學習筆記-從源碼到應用（一：簡介及基本元素源碼分析）

響應式編程思想

響應式編程（Reactive Programming，RP）是一種面向 數據流 和 變化傳播 的 編程範式

相關概念

數據流

只能以事先規定好的順序被讀取一次的數據的一個序列。在計算機中是數據，在現實中可以是任意對象組成的有序的隊列。就像看電影排隊進場一樣，一個接一個的檢票，這些排隊進場的人們就像一個有順序的隊列。

變化傳播

類似於觀察者模式，變化了要通知別人。就像我們在飯館吃飯，點菜的變化 -> 下單的變化 -> 做菜的變化，即把變化傳播了出去。

編程範式

計算機編程的基本風格或典範模式，如我們常說的“面向對象編程“、“面向過程編程“。就像做飯，有蒸、煮、燉、炒、烤等等。

小例子：工廠流水線

• 數據流 -> 在履帶上運送的要加工的物品
• 變化傳播 -> 把前一個環節的加工結果傳到下一節
• 編程範式 -> 每一種物品的加工方式不同，流水線就不同

RxJava

A library for composing asynchronous and event-based programs by using observable sequences.
asynchronous：異步的，RxJava是一個異步的庫，基於回調的
event-based：基於事件的，事件分發的庫，消息傳遞的庫

RxJava1基本元素

• Observable
• Observer
• Subscription
• OnSubscribe
• Subscriber

RxJava1簡單代碼示列

// 首先通過Observable的create方法創建一個Observable對象
// create方法傳入的是一個OnSubscribe對象，該對象會執行一個call方法，call方法裏回調的是訂閱事件的Subscriber對象的方法
// 接着用創建出來的Observable對象去調用subscribe方法，改方法傳入一個Subscriber對象
// 調用subscribe方法後會產生一個Subscription對象
Subscription subscription1 = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        if (!subscriber.isUnsubscribed()) {
            subscriber.onNext("test");
            subscriber.onCompleted();
        }
    }
}).subscribe(new Observer<String>() {
    @Override
    public void onCompleted() {
        Log.d(TAG, "onCompleted");
    }
    @Override
    public void onError(Throwable e) {

    }
    @Override
    public void onNext(String s) {
        Log.d(TAG, "onNext: " + s);
    }
});

RxJava1基本元素源碼分析

Observer

Observer是一個接口，包含三個方法

public interface Observer<T> {
    void onCompleted(); // 成功執行
    void onError(Throwable e); // 執行過程出錯
    void onNext(T t); // 傳遞數據
}

Subscription

Subscription是一個接口，包含兩個方法

public interface Subscription {
    void unsubscribe(); // 解除訂閱
    boolean isUnsubscribed(); // 判斷是否已經解除訂閱
}

Subscriber

Subscriber是一個抽象類，實現了Observer接口（沒有實現相應方法）、Subscription接口（實現了相應方法）

public abstract class Subscriber<T> implements Observer<T>, Subscription {
    private static final long NOT_SET = Long.MIN_VALUE;
    private final SubscriptionList subscriptions;
    private final Subscriber<?> subscriber;
    private Producer producer;
    private long requested = NOT_SET;

    protected Subscriber() {
        this(null, false);
    }

    protected Subscriber(Subscriber<?> subscriber) {
        this(subscriber, true);
    }

    protected Subscriber(Subscriber<?> subscriber, boolean shareSubscriptions) {
        this.subscriber = subscriber;
        this.subscriptions = shareSubscriptions && subscriber != null ? subscriber.subscriptions : new SubscriptionList();
    }

    public final void add(Subscription s) {
        subscriptions.add(s);
    }

    @Override
    public final void unsubscribe() {
        subscriptions.unsubscribe();
    }

    @Override
    public final boolean isUnsubscribed() {
        return subscriptions.isUnsubscribed();
    }

    public void onStart() {
        // do nothing by default
    }

    protected final void request(long n) {
        ……
    }
    ……
}

OnSubcribe

OnSubscribe是Observable內部的一個接口，繼承了Action1接口

public interface OnSubscribe<T> extends Action1<Subscriber<? super T>> {
    // cover for generics insanity
}

//-------------分割線-------------
// Action1接口，包含一個call方法
public interface Action1<T> extends Action {
    void call(T t);
}

//-------------分割線-------------
// Action接口
public interface Action extends Function {

}

//-------------分割線-------------
// Function接口
public interface Function {

}

Observable

Observable是一個普通類，其構造方法用protected修飾，我們使用時不能直接通過new方法來創建Observable對象。

public class Observable<T> {
    final OnSubscribe<T> onSubscribe; // 只有這一個成員變量
    protected Observable(OnSubscribe<T> f) {
        this.onSubscribe = f;
    }
    ……
}

通過create方法創建Observable對象：

// create方法會將傳入的OnSubscribe對象賦值給所創建的Observable對象的成員變量
@Deprecated
public static <T> Observable<T> create(OnSubscribe<T> f) {
    return new Observable<T>(RxJavaHooks.onCreate(f));
}

public static <T> Observable<T> create(Action1<Emitter<T>> emitter, Emitter.BackpressureMode backpressure) {
    return unsafeCreate(new OnSubscribeCreate<T>(emitter, backpressure));
}

public static <S, T> Observable<T> create(SyncOnSubscribe<S, T> syncOnSubscribe) {
    return unsafeCreate(syncOnSubscribe);
}

@Beta
public static <S, T> Observable<T> create(AsyncOnSubscribe<S, T> asyncOnSubscribe) {
    return unsafeCreate(asyncOnSubscribe);
}

// unsafeCreate方法
public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {
    return new Observable<T>(RxJavaHooks.onCreate(f));
}

//-------------分割線-------------
// RxJavaHooks中的onCreate() 方法：
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> Observable.OnSubscribe<T> onCreate(Observable.OnSubscribe<T> onSubscribe) {
    Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
    if (f != null) {
        return f.call(onSubscribe);
    }
    return onSubscribe;
}

//-------------分割線-------------
// 其中Func1是一個接口，繼承了Function接口
public interface Func1<T, R> extends Function {
    R call(T t);
}

下面來看看subscribe方法：

// 傳入一個Observer對象，返回一個Subscription對象
public final Subscription subscribe(final Observer<? super T> observer) {
    if (observer instanceof Subscriber) {
        // 如果observer是Subscriber對象，將其強轉成Subscriber對象
        return subscribe((Subscriber<? super T>)observer);
    }
    if (observer == null) {
        throw new NullPointerException("observer is null");
    }
    // 否則將其包裝成ObserverSubscriber對象
    return subscribe(new ObserverSubscriber<T>(observer));
}

//-------------分割線-------------
// ObserverSubscriber是Subscriber的子類，內部持有一個Observer類型的成員變量
public final class ObserverSubscriber<T> extends Subscriber<T> {
    final Observer<? super T> observer;

    public ObserverSubscriber(Observer<? super T> observer) {
        this.observer = observer;
    }

    @Override
    public void onNext(T t) {
        observer.onNext(t);
    }

    @Override
    public void onError(Throwable e) {
        observer.onError(e);
    }

    @Override
    public void onCompleted() {
        observer.onCompleted();
    }
}

// 調用下面的方法
public final Subscription subscribe(Subscriber<? super T> subscriber) {
    return Observable.subscribe(subscriber, this);
}

// 繼續調用下面的方法
// 傳入兩個參數：一個Subscriber對象，另一個是當前的Observable對象
static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
    // 判斷一些null值造成的異常情況
    if (subscriber == null) {
        throw new IllegalArgumentException("subscriber can not be null");
    }
    if (observable.onSubscribe == null) {
        throw new IllegalStateException("onSubscribe function can not be null.");
    }

    subscriber.onStart();
    if (!(subscriber instanceof SafeSubscriber)) {
        // 將subscriber包裝成SafeSubscriber對象，SafeSubscriber是Subscriber的子類，其內部持有實際的subscriber
        subscriber = new SafeSubscriber<T>(subscriber);
    }

    try {
        // 下面的兩句代碼是關鍵
        // RxJavaHooks.onObservableStart方法返回observable.onSubscribe對象，然後調用其相應的call方法，並將subscriber對象傳入
        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
        // 直接將之前傳入的subscriber對象返回，因爲其實現了Subscription
        return RxJavaHooks.onObservableReturn(subscriber);
    } catch (Throwable e) {
        ……
        return Subscriptions.unsubscribed();
    }
}

//-------------分割線-------------
// RxJavaHooks.onObservableStart方法
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <T> Observable.OnSubscribe<T> onObservableStart(Observable<T> instance, Observable.OnSubscribe<T> onSubscribe) {
    Func2<Observable, Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableStart;
    if (f != null) {
        return f.call(instance, onSubscribe);
    }
    return onSubscribe;
}

// RxJavaHooks.onObservableReturn方法
public static Subscription onObservableReturn(Subscription subscription) {
    Func1<Subscription, Subscription> f = onObservableReturn;
    if (f != null) {
        return f.call(subscription);
    }
    return subscription;
}

小結

• Observable
  觀察到的——被觀察者，通過Observable創建一個可觀察的序列（可以使用create方法），通過subscribe去註冊一個觀察者。
• Observer
  用於接收數據——觀察者，作爲Observable的subscribe方法參數。
• Subscription
  訂閱，用於描述被觀察者和觀察者之間的關係，有兩個方法，分別用於取消訂閱和獲取當前訂閱狀態。
• OnSubscribe
  當訂閱時會觸發此接口回調，其在Observable內部，實際的作用是向訂閱者發送數據。
• Subscriber
  實現了Observer和Subscription，最後返回的Subscription實際上就是Subscriber對象，這裏正好驗證了一句話——只有自己才能阻止自己。
• UML圖
  
  Observable類包含一個OnSubscribe類型的成員變量，通過Observable.create(OnSubscribe f)創建一個Observable對象時會將參數賦值給OnSubscribe類型的成員變量，當調用Observable.subscribe(Observer observer)方法時會將傳入的Observer類型的參數先包裝成一個Subscriber或ObserverSubscriber對象，然後執行RxJavaHooks.onObservableStart方法，該方法傳入兩個參數，一個是Observable類型的，一個是OnSubscribe類型的，然後返回一個OnSubscribe類型的對象（就是創建Observable對象傳入的OnSubscribe參數），最後執行該對象的call方法，在call方法裏會將剛纔包裝好的Observer傳入，然後回調其相應的方法。

RxJava2基本元素

• Observable、Flowable
• Observer、Subscriber
• Disposable、Subscription
• ObservableOnSubscribe、FlowableOnSubscribe
• Emitter

RxJava2簡單代碼示列

// 通過Observable.create()創建，沒有考慮背壓問題
Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        if (!emitter.isDisposed()) {
            emitter.onNext("test");
            emitter.onComplete();
        }
    }
}).subscribe(new Observer<String>() {
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "onSubscribe");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "onNext: " + s);
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onComplete() {
        Log.d(TAG, "onCompleted");
    }
});

// 通過Flowable.create()創建，加入了背壓策略
Flowable.create(new FlowableOnSubscribe<String>() {
    @Override
    public void subscribe(FlowableEmitter<String> emitter) throws Exception {
        if (!emitter.isCancelled()) {
            emitter.onNext("test");
            emitter.onComplete();
        }
    }
}, BackpressureStrategy.DROP).subscribe(new Subscriber<String>() {
    @Override
    public void onSubscribe(Subscription s) {
        s.request(Long.MAX_VALUE); // 如果不調用該方法，則不會執行onNext()方法
        Log.d(TAG, "onSubscribe");
    }

    @Override
    public void onNext(String s) {
        Log.d(TAG, "onNext: " + s);
    }

    @Override
    public void onError(Throwable t) {

    }

    @Override
    public void onComplete() {
        Log.d(TAG, "onCompleted");
    }
});

背壓概念

• 異步環境下產生的問題
• 發送和處理速度不統一
• 是一種流速控制的解決策略

RxJava2無背壓策略的基本元素源碼分析

Observer

Observer是一個接口，和RxJava1相似，只不過多了一個onSubscribe方法，該方法的參數是一個Disposable對象

public interface Observer<T> {
    void onSubscribe(@NonNull Disposable d);
    void onNext(@NonNull T t);
    void onError(@NonNull Throwable e);
    void onComplete();
}

Disposable

Disposable是一個接口，有兩個方法，類似於RxJava1中的Subscription

public interface Disposable {
    void dispose();
    boolean isDisposed();
}

ObservableOnSubscribe（相當於RxJava1中的OnSubscribe）

在RxJava2中，將ObservableOnSubscribe抽離出來成爲一個單獨的接口，裏面包含一個方subscribe法，該方法傳入一個ObservableEmitter類型的參數

public interface ObservableOnSubscribe<T> {
    void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
}

Emitter

Emitter是一個接口，包含三個方法，和Observer接口中的三個方法一樣

public interface Emitter<T> {
    void onNext(@NonNull T value);
    void onError(@NonNull Throwable error);
    void onComplete();
}

Observable

Observable在RxJava2中是一個抽象類，它實現了ObservableSource接口，該接口的定義如下：

public interface ObservableSource<T> {
    void subscribe(@NonNull Observer<? super T> observer);
}

首先來看一下Observable.create方法：

// 先將ObservableOnSubscribe類型的參數包裝成ObservableCreate類型的對象
// 包裝後的ObservableCreate對象的ObservableOnSubscribe類型的成員變量source持有原來ObservableOnSubscribe對象的引用
// 然後調用RxJavaPlugins.onAssembly(Observable<T> source)方法，將包裝後的對象返回
// ObservableCreate是Observable的子類
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    ObjectHelper.requireNonNull(source, "source is null");
    return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}

//-------------分割線-------------
// RxJavaPlugins.onAssembly(Observable<T> source)方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
    Function<? super Observable, ? extends Observable> f = onObservableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source; // 返回包裝後的ObservableCreate對象 
}

ObservableCreate是一個final類，它是Observable的子類，包含兩個內部類CreateEmitter和SerializedEmitter

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);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
    static final class CreateEmitter<T> 
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
        ……
    }
    static final class SerializedEmitter<T>
    extends AtomicInteger
    implements ObservableEmitter<T> {
        ……
    }
}

可以看到在ObservableCreate類中複寫了父類Observable的subscribeActual(Observer observer)方法，查看Observable.subscribe方法我們可以發現，在subscribe方法中實際上調用了subscribeActual方法：

@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer<? super T> observer) {
    ObjectHelper.requireNonNull(observer, "observer is null");
    try {
        observer = RxJavaPlugins.onSubscribe(this, observer); // 直接返回observer
        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
        subscribeActual(observer); // 實際調用了此方法
    } catch (NullPointerException e) {
        ……
    }
}

//-------------分割線-------------
// RxJavaPlugins.onSubscribe(@NonNull Observable<T> source, @NonNull Observer<? super T> observer)
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static <T> Observer<? super T> onSubscribe(@NonNull Observable<T> source, @NonNull Observer<? super T> observer) {
    BiFunction<? super Observable, ? super Observer, ? extends Observer> f = onObservableSubscribe;
    if (f != null) {
        return apply(f, source, observer);
    }
    return observer;
}

下面來分析一下ObservableCreate類中的subscribeActual這個方法

@Override
protected void subscribeActual(Observer<? super T> observer) {
    // 將Observer對象包裝成CreateEmitter對象
    CreateEmitter<T> parent = new CreateEmitter<T>(observer);
    observer.onSubscribe(parent);
    try {
        source.subscribe(parent); // 調用ObservableOnSubscribe的subscribe方法，並將包裝好的CreateEmitter對象傳入
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        parent.onError(ex);
    }
}

CreateEmitter是ObservableCreate的一個靜態內部類，對應源碼如下：

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 ObservableCreate.SerializedEmitter<T>(this); }
    // 解綁定
    @Override
    public void dispose() { DisposableHelper.dispose(this); }
    // 判斷是否已經解綁定
    @Override
    public boolean isDisposed() { return DisposableHelper.isDisposed(get()); }
    @Override
    public String toString() { return String.format("%s{%s}", getClass().getSimpleName(), super.toString()); }
}

從上述代碼我們可以看到在執行onNext()、onError()、onComplete()方法時，實際上執行的是Observer對象的這三個方法。

小結

• Observable
  觀察到的——被觀察者，不支持背壓，通過Observable創建一個可觀察的序列（可以使用create方法），通過subscribe去註冊一個觀察者。
• Observer
  用於接收數據——觀察者，作爲Observable的subscribe方法參數。
• Disposable
  和RxJava1的Subscription的作用相當，用於取消訂閱和獲取當前訂閱狀態。
• ObservableOnSubscribe
  當訂閱時會觸發此接口回調，和RxJava1不同，在RxJava2中被抽離出來成爲一個單獨的接口，實際的作用是向訂閱者發送數據。
• Emitter
  一個發射數據的接口，和Observer的方法類似，本質是對Observer和Subscriber的包裝。
• UML圖
  
  首先通過Observable.create()方法創建一個Observable對象，該方法傳入一個ObservableOnSubscribe類型的參數（這裏的ObservableOnSubscribe和RxJava1中的OnSubscribe類似，只不過是將其抽離成單獨的一個接口，該接口包含一個subscribe(ObservableEmitter emitter)方法），在create()方法裏會將傳入的ObservableOnSubscribe參數包裝成一個ObservableCreate對象，包裝後的對象的成員變量source持有原ObservableOnSubscribe對象的引用，create()方法最終返回的是一個ObservableCreate對象（ObservableCreate是Observable的子類）。在執行Observable.subscribe()的時候實際執行的是包裝後的ObservableCreate對象的subscribeActual(Observer observer)方法，該方法會將傳入的Observer對象包裝成CreateEmitter對象（ObservableEmitter的子類），然後執行ObservableOnSubscribe類型的成員變量source的subscribe()方法，將包裝後CreateEmitter對象作爲參數傳入進去，接着回調CreateEmitter對象的相應方法，而這些方法實際又調用了Observer對象的對應方法。

RxJava2有背壓策略的基本元素源碼分析

Subscriber

Subscriber是一個接口，包含四個方法，相當於無背壓版的Observer

public interface Subscriber<T> {
    public void onSubscribe(Subscription s);
    public void onNext(T t);
    public void onError(Throwable t);
    public void onComplete();
}

Subscription

Subscription是一個接口，包含兩個方法，和RxJava1中的Subscription略有不同：

public interface Subscription {
    public void request(long n); // 通過響應式拉取解決背壓問題
    public void cancel();
}

FlowableOnSubscribe

FlowableOnSubscribe是一個接口，包含一個subscribe(FlowableEmitter emitter)方法，和無背壓版的ObservableOnSubscribe很像：

public interface FlowableOnSubscribe<T> {
    void subscribe(@NonNull FlowableEmitter<T> emitter) throws Exception;
}

Emitter

和無背壓版的用的是同一個接口，包含onNext()、onError()、onComplete()三個方法，這裏就不贅述了。

Flowable

Flowable是一個抽象類，其實現了Publisher接口，Publisher接口裏包含一個subscribe(Subscriber s)函數：

public interface Publisher<T> {
    public void subscribe(Subscriber<? super T> s);
}

先來看一下Flowable.create方法，該方法接收兩個參數，一個是FlowableOnSubscribe類型的，一個是BackpressureStrategy類型的，如下：

@CheckReturnValue
@BackpressureSupport(BackpressureKind.SPECIAL)
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Flowable<T> create(FlowableOnSubscribe<T> source, BackpressureStrategy mode) {
    ObjectHelper.requireNonNull(source, "source is null");
    ObjectHelper.requireNonNull(mode, "mode is null");
    // 調用RxJavaPlugins.onAssembly()方法時，會將傳入的參數包裝成FlowableCreate對象
    return RxJavaPlugins.onAssembly(new FlowableCreate<T>(source, mode));
}

//-------------分割線-------------
// RxJavaPlugins.onAssembly(Flowable<T> source)方法
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static <T> Flowable<T> onAssembly(@NonNull Flowable<T> source) {
    Function<? super Flowable, ? extends Flowable> f = onFlowableAssembly;
    if (f != null) {
        return apply(f, source);
    }
    return source; // 直接將傳入的Flowable對象返回
}      

FlowableCreate是Flowable的子類，包含八個內部類SerializedEmitter、BaseEmitter、MissingEmitter、NoOverflowBaseAsyncEmitter、DropAsyncEmitter、ErrorAsyncEmitter、BufferAsyncEmitter、LatestAsyncEmitter，這八個內部類都實現了FlowableEmitter接口，FlowableEmitter接口繼承了Emitter接口，FlowableCreate還包含兩個成員變量：FlowableOnSubscribe source 和 BackpressureStrategy backpressure

public final class FlowableCreate<T> extends Flowable<T> {

    final FlowableOnSubscribe<T> source;
    final BackpressureStrategy backpressure;

    public FlowableCreate(FlowableOnSubscribe<T> source, BackpressureStrategy backpressure) {
        this.source = source;
        this.backpressure = backpressure;
    }

    @Override
    public void subscribeActual(Subscriber<? super T> t) {
        BaseEmitter<T> emitter;
        switch (backpressure) {
            case MISSING: {
                emitter = new MissingEmitter<T>(t);
                break;
            }
            case ERROR: {
                emitter = new ErrorAsyncEmitter<T>(t);
                break;
            }
            case DROP: {
                emitter = new DropAsyncEmitter<T>(t);
                break;
            }
            case LATEST: {
                emitter = new LatestAsyncEmitter<T>(t);
                break;
            }
            default: {
                emitter = new BufferAsyncEmitter<T>(t, bufferSize());
                break;
            }
        }

        t.onSubscribe(emitter); // 先於source.subscribe(emitter)執行
        try {
            source.subscribe(emitter);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            emitter.onError(ex);
        }
    }

    static final class SerializedEmitter<T> extends AtomicInteger implements FlowableEmitter<T> { …… }
    abstract static class BaseEmitter<T> extends AtomicLong implements FlowableEmitter<T>, Subscription { …… }
    static final class MissingEmitter<T> extends BaseEmitter<T> { …… }
    abstract static class NoOverflowBaseAsyncEmitter<T> extends BaseEmitter<T> { …… }
    static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> { …… }
    static final class ErrorAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> { …… }
    static final class BufferAsyncEmitter<T> extends BaseEmitter<T> { …… }
    static final class LatestAsyncEmitter<T> extends BaseEmitter<T>  { …… }

}

和無背壓版的ObservableCreate原理相似，可以看到在FlowableCreate類中同樣複寫了父類Flowable的subscribeActual(Subscriber t)方法，查看Flowable.subscribe方法我們可以發現，在subscribe方法中同樣是調用了subscribeActual方法：

@BackpressureSupport(BackpressureKind.SPECIAL)
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Subscriber<? super T> s) {
    if (s instanceof FlowableSubscriber) {
        // 如果是FlowableSubscriber類型的就調用subscribe(FlowableSubscriber<? super T> s)方法
        subscribe((FlowableSubscriber<? super T>)s);
    } else {
        ObjectHelper.requireNonNull(s, "s is null");
        // 否則將傳入的Subscriber參數包裝成StrictSubscriber對象，再subscribe(FlowableSubscriber<? super T> s)方法
        subscribe(new StrictSubscriber<T>(s));
    }
}

// 調用subscribe(FlowableSubscriber<? super T> s)方法
@BackpressureSupport(BackpressureKind.SPECIAL)
@SchedulerSupport(SchedulerSupport.NONE)
@Beta
public final void subscribe(FlowableSubscriber<? super T> s) {
    ObjectHelper.requireNonNull(s, "s is null");
    try {
        Subscriber<? super T> z = RxJavaPlugins.onSubscribe(this, s);
        ObjectHelper.requireNonNull(z, "Plugin returned null Subscriber");
        subscribeActual(z); // 實際調用了此方法
    } catch (NullPointerException e) { 
        ……
    }
}

//-------------分割線-------------
// FlowableSubscriber是一個接口，繼承了Subscriber接口
@Beta
public interface FlowableSubscriber<T> extends Subscriber<T> {
    @Override
    void onSubscribe(@NonNull Subscription s);
}

//-------------分割線-------------
// StrictSubscriber是一個類，實現了FlowableSubscriber接口、Subscription接口
// 其內部包含一個Subscriber類型的成員變量
public class StrictSubscriber<T> extends AtomicInteger implements FlowableSubscriber<T>, Subscription {
    ……
    final Subscriber<? super T> actual;
    ……
}

接下來看一下FlowableCreate類中的subscribeActual這個方法：

@Override
public void subscribeActual(Subscriber<? super T> t) {
    BaseEmitter<T> emitter; // 該方法會將傳入的Subscriber參數根據不同的背壓策略包裝成相應的Emitter對象
    switch (backpressure) {
        case MISSING: {
            emitter = new MissingEmitter<T>(t);
            break;
        }
        case ERROR: {
            emitter = new ErrorAsyncEmitter<T>(t);
            break;
        }
        case DROP: {
            emitter = new DropAsyncEmitter<T>(t);
            break;
        }
        case LATEST: {
            emitter = new LatestAsyncEmitter<T>(t);
            break;
        }
        default: {
            emitter = new BufferAsyncEmitter<T>(t, bufferSize());
            break;
        }
    }
    t.onSubscribe(emitter);
    try {
        // 然後調用FlowableOnSubscribe成員變量的的subscribe方法將包裝後的Emitter對象傳入進去
        // 這些Emitter對象的回調方法裏均執行了Subscriber對象的三個方法
        source.subscribe(emitter); 
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        emitter.onError(ex);
    }
}

背壓策略分析：以 BackpressureStrategy.DROP 策略爲例

case DROP: {
    emitter = new DropAsyncEmitter<T>(t);
    break;
}

// DropAsyncEmitter繼承了NoOverflowBaseAsyncEmitter
static final class DropAsyncEmitter<T> extends NoOverflowBaseAsyncEmitter<T> {
    private static final long serialVersionUID = 8360058422307496563L;
    DropAsyncEmitter(Subscriber<? super T> actual) {
        super(actual);
    }
    @Override
    void onOverflow() {
        // nothing to do
    }
}

// NoOverflowBaseAsyncEmitter繼承了BaseEmitter
abstract static class NoOverflowBaseAsyncEmitter<T> extends BaseEmitter<T> {
    private static final long serialVersionUID = 4127754106204442833L;
    NoOverflowBaseAsyncEmitter(Subscriber<? super T> actual) {
        super(actual);
    }
    @Override
    public final void onNext(T t) {
        if (isCancelled()) {
            return;
        }
        if (t == null) {
            onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
            return;
        }
        if (get() != 0) { // 只有當get()方法不爲0的時候纔會執行onNext()方法
            actual.onNext(t);
            BackpressureHelper.produced(this, 1);
        } else {
            onOverflow();
        }
    }
    abstract void onOverflow();
}

// BaseEmitter
abstract static class BaseEmitter<T> extends AtomicLong implements FlowableEmitter<T>, Subscription {
    private static final long serialVersionUID = 7326289992464377023L;
    final Subscriber<? super T> actual;
    final SequentialDisposable serial;
    BaseEmitter(Subscriber<? super T> actual) {
        this.actual = actual;
        this.serial = new SequentialDisposable();
    }

    @Override
    public void onComplete() { complete(); }
    protected void complete() {
        if (isCancelled()) {
            return;
        }
        try {
            actual.onComplete();
        } finally {
            serial.dispose();
        }
    }

    @Override
    public final void onError(Throwable e) {
        if (!tryOnError(e)) {
            RxJavaPlugins.onError(e);
        }
    }

    @Override
    public boolean tryOnError(Throwable e) { return error(e); }

    protected boolean error(Throwable e) {
        if (e == null) {
            e = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
        }
        if (isCancelled()) {
            return false;
        }
        try {
            actual.onError(e);
        } finally {
            serial.dispose();
        }
        return true;
    }

    @Override
    public final void cancel() {
        serial.dispose();
        onUnsubscribed();
    }

    void onUnsubscribed() {
        // default is no-op
    }

    @Override
    public final boolean isCancelled() {
        return serial.isDisposed();
    }

    @Override
    public final void request(long n) {
        // 首先會調用SubscriptionHelper.validate(n)來判斷傳入的參數是否大於零，大於零纔會繼續執行
        if (SubscriptionHelper.validate(n)) {
            BackpressureHelper.add(this, n); // 執行此方法後，會讓get()方法返回值不爲0，從而能使onNext()方法得到執行
            onRequested();
        }
    }

    void onRequested() {
        // default is no-op
    }

    @Override
    public final void setDisposable(Disposable s) { serial.update(s); }
    @Override
    public final void setCancellable(Cancellable c) { setDisposable(new CancellableDisposable(c)); }
    @Override
    public final long requested() { return get(); }
    @Override
    public final FlowableEmitter<T> serialize() { return new SerializedEmitter<T>(this); }
    @Override
    public String toString() { return String.format("%s{%s}", getClass().getSimpleName(), super.toString()); }
}

小結

• Flowable
  易流動的——被觀察者，支持背壓，通過Flowable創建一個可觀察的序列（可以使用create方法），通過subscribe去註冊一個觀察者。
• Subscriber
  一個單獨的接口，不在是RxJava1中的Subscriber類，和無背壓的Observer的方法類似，作爲Flowable的subscribe方法參數。
• Subscription
  訂閱，和RxJava1的Subscription的有所不同，支持背壓，有用於背壓的request方法，用於背壓響應式拉取。
• FlowableOnSubscribe
  當訂閱時會觸發此接口回調，和無背壓的ObservableOnSubscribe含義一樣、用法一樣，實際的作用是向訂閱者發送數據。
• Emitter
  一個發射數據的接口，和Observer的方法類似，本質是對Observer和Subscriber的包裝。
• UML圖
  
  首先通過Flowable.create()方法創建一個Flowable對象，該方法傳入兩個參數，一個是FlowableOnSubscribe類型的參數（這裏的FlowableOnSubscribe和無背壓版的ObservableOnSubscribe類似，該接口包含一個subscribe(FlowableEmitter emitter)方法），另一個參數是BackpressureStrategy類型的參數，代表了具體的背壓策略，在create()方法裏會將傳入的FlowableOnSubscribe參數包裝成一個FlowableCreate對象，包裝後的對象的成員變量source持有原FlowableOnSubscribe對象的引用，create()方法最終返回的是一個FlowableCreate對象（FlowableCreate是Flowable的子類）。在執行Flowable.subscribe()的時候實際執行的是包裝後的FlowableCreate對象的subscribeActual(Subscriber subscriber)方法，該方法會將傳入的Subscriber對象根據不同的背壓策略包裝成相應的BaseEmitter對象（FlowableEmitter的子類），然後執行FlowableOnSubscribe類型的成員變量source的subscribe()方法，將包裝後BaseEmitter對象作爲參數傳入進去，接着回調BaseEmitter對象的相應方法，而這些方法實際又調用了Subscriber對象的對應方法。