###1、概述
rxjava官方给出来的定义是组成异步和事件通过观测序列的基础程序库。rxjava通过观测者模式实现观察者和被观察者之间数据改变,通过修饰者模式实现不通操作符转换。
###2、源码分析
主要通过分析rxjava2.0代码了解rxjava如何使用观察者和被观察者之间订阅关系,首先分析Observable.create方法,我们可以通过Observable.create创建自定义对象,在调用create方法时传递ObservableOnSubscrible接口
@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));
}
在调用create方法时会判断当前传递的ObservableOnSubscrible对象是否为空,为空抛出异常。
public static <T> T requireNonNull(T object, String message) {
if (object == null) {
throw new NullPointerException(message);
}
return object;
}
然后通过调用RxjavaPlugins.onAssembly方法创建一个Observable对象。先创建一个Observablecreate对象包裹ObservableOnSubscrible,ObservableOnSubscrible是继承Observable,然后传递给onAssembly方法。
@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;
}
在onAssembly方法中先判断是否需要hook,当前不hook方法直接返回source方法,source就是ObservableCreate对象,然后我们通过调用subscribe方法订阅
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe() {
return subscribe(Functions.emptyConsumer(), Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION, Functions.emptyConsumer());
}
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
ObjectHelper.requireNonNull(onNext, "onNext is null");
ObjectHelper.requireNonNull(onError, "onError is null");
ObjectHelper.requireNonNull(onComplete, "onComplete is null");
ObjectHelper.requireNonNull(onSubscribe, "onSubscribe is null");
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}
在subscrible方法中,如果用户没有传递onNex、onError、onComplete和onSubscrible rxjava帮忙创建相关方法,然后组装成LambdaObserver对象,然后调用subscribe方法
@SchedulerSupport(SchedulerSupport.NONE)
@Override
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) {
Exceptions.throwIfFatal(e);
// can't call onError because no way to know if a Disposable has been set or not
// can't call onSubscribe because the call might have set a Subscription already
RxJavaPlugins.onError(e);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(e);
throw npe;
}
}
在subscrible方法中检测Observer对象是否为空,然后调用subscribleActual方法,这个方法就是刚才创建的ObservbleCreate对象
@Override
protected void subscribeActual(Observer<? super T> observer) {
CreateEmitter<T> parent = new CreateEmitter<T>(observer);
//observable中onSubscrible方法,保证onSubscrible在onNext和onError方法之前调用
observer.onSubscribe(parent);
try {
//实际观察者调用的方法
source.subscribe(parent);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
在subscribleActual方法中创建一个发射器,然后调用Observer的onSubscrible方法,把发射器传递给onSubscrible中,然后调用onSubscrible,这个Observable.onSubscrible就是我们通过Obserable.create创建时候实现ObservableOnSubscrible实现类,通过try catch把异常捕获,如果异常后调用createEmitter中onError方法,在CreateEmitter中的Error方法实际是调用rxjava封装的LambdaObserver中的onError方法。
###3 类图分析
我们在通过Observable.create方法创建自定义被观察者时,通过创建ObservableOnSubscrible实例对象,rxjava会创建一个修饰者对象ObservableCreate继承Observable存储ObservableOnSubscrible字段,然后我们通过subscribe订阅时通过组装一个LambdaObserver对象,lambdaObserver继承Observer,通过调用subsrcibe实现订阅,订阅后会调用ObservableCreate.subsrcibeActual方法,在ObservableCreate方法中组装一个CreateEmitter发射器对象,然后调用lambdaObserver中onSubscribe方法把发射器传递到lambdaObserver.onSubscribe中,然后调用ObservableOnSubscrible中subscribe方法传入发射器,可以通过发射器调用onNext、onError方法。
###4 总结
rxjava是基于观察者模式实现事假订阅,但是有区别于现实中理解,rxjava是通过被观察者订阅观察者实现,在观察者中有被观察者实例,底层是创建lambdaObserver包裹onNext,onError方法,然后通过ObservableCreate中的subscribeActual创建一个CreateEmitter发射器,调用ObservableOnSubscrible中的subscribe方法传递CreateEmitter对象,实现对象引用。