响应式编程思想
响应式编程(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
对象的对应方法。