RxJava 在最近两年迅速火爆起来，最近学习RxJava2，免不了需要学习它的源码，写下博客记录学习结果。
RxJava 的设计理念基于观察者模式，这里就需要先了解一下它所涉及的东西。Observable，称为被观察者，由它产生一系列的事件。Observer，称为观察者。Observer和Observable之间通过subscribe方法发生订阅关系。这样Observer就可以 ”观察“ Observable发生的事件，并根据这些事件做出相应的动作。
先看示例代码：
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext( 1);
emitter.onNext( 2);
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
System.out.println("FirstMain.onSubscribe d="+d.isDisposed());
}
@Override
public void onNext(Integer integer) {
System.out.println("FirstMain.onNext i="+integer);
}
@Override
public void onError(Throwable e) {
System.out.println("FirstMain.onError");
}
@Override
public void onComplete() {
System.out.println("FirstMain.onComplete");
}
});可以看到如上代码，首先调用Observable的create方法创建一个Observable对象，实际创建的是ObservableCreate的对象，ObservableCreate是Observable的子类。在create方法中首先进行判空。然后创建并返回ObservableCreate对象。
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");//判空
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}返回ObservableCreate对象时先调用了RxJavaPlugins.onAssembly方法，下面看一下这个方法：
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;
}
static <T, R> R apply(@NonNull Function<T, R> f, @NonNull T t) {
try {
return f.apply(t);
} catch (Throwable ex) {
throw ExceptionHelper.wrapOrThrow(ex);
}
}可以看到RxJavaPlugins.onAssembly方法是对Observable对象经行一步操作，就是使用Function对象变量onObservableAssembly给Observable对象经行操作。这里onObservableAssembly对象变量为null，所以实际上onAssembly方法返回的时原来的Observable对象。如果有需要对Observable对象进行什么操作的话，可以给onObservableAssembly对象变量赋值。
接着调用了Observable的subscribe方法，是的Observer和Observable发生订阅关系。
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) {
//...
}
}可以看到在subscribe方法中，先对传进来的参数判空，然后RxJavaPlugins.onSubscribe也是根据onObservableSubscribe是否为空对observer经行操作。源码如下：
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;
}
static <T, U, R> R apply(@NonNull BiFunction<T, U, R> f, @NonNull T t, @NonNull U u) {
try {
return f.apply(t, u);
} catch (Throwable ex) {
throw ExceptionHelper.wrapOrThrow(ex);
}
}接着调用subscribeActual方法，这里可以要知道，因为create方法返回的是ObservableCreate对象，所以调用的是ObservableCreate的subscribeActual方法。
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 {
//...
CreateEmitter(Observer<? super T> observer) {
this.observer = observer;
}
//...
}subscribeActual方法中，先创建了CreateEmitter对象，它是用来发射事件的。然后调用了Observer的onSubscribe方法。
public interface Observer<T> {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}可以看到Observer是一个接口，它是在Observable调用subscribe函数的时候创建的，并实现了Observer的四个方法，而ObservableCreate的subscribeActual方法中observer.onSubscribe()这一句调用的就是此时实现的onSubscribe方法。
紧接着调用了source.subscribe(parent);这里的source是在crete方法中创建ObservableCreate对象的时候传进去的。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
}所以source.subscribe调用的是ObservableOnSubscribe的subscribe方法，而这个方法就是在create方法的参数实现的回调函数。
总结
上面代码调整幅度太大，这里简单总结方法调用过程（有部分同名方法，所以带上了类名）：
Observable.create实现ObservableOnSubscribe.subscribe
Observable.subscribe（携带Observer）调用ObservableCreate.subscribeActual（携带Observer）
ObservableCreate.subscribeActual（携带Observer）调用ObservableOnSubscribe.subscribe
ObservableOnSubscribe.subscribe又调用CreateEmitter对象（携带Observer）的方法（onNext、onComplete、onError）发射事件
CreateEmitter的方法中最终调用到了Observer的方法（onNext、onComplete、onError）
到这，RxJava分析的整个流程就结束了，就是数据从Observable中流出，通过subscribe方法关联Observer，然后Observer接收数据，并对数据经行处理。