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对象：

扫描二维码关注公众号，回复： 2465008 查看本文章

// 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对象的对应方法。