一、RxJava 简介：
1.RxJava 定义：
> RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.
> 大概意思：RxJava - JVM的响应式扩展 - 在Java VM上使用可观察序列编写异步及基于事件的程序的库。
2.RxJava 架构：
RxJava 是基于观察者设计模式设计开发的。主要概念有：
Observable ： 被观察者。也是事件源，里面包含很多操作符。如：map,flatMap,groupBy,forEach,subscribe等等。是整个框架的核心；
Observer ： 观察者。也是事件的接收者。Observable发射出去的数据，最终会在Observer接口里面的onNext(),onComplete或者onError里面回调。注：正常情况下onComplete(表示事件已经正常处理完毕) 与 onError(事件处理过程中出错，不再往下执行) 不会同时被回调；
ObservableOnSubscribe ： 该接口只有一个 subscribe 方法，此方法用于发射事件。当 observable.subscribe(mObserver) 执行时, Observer 的 subscribeActual 方法将会调用此接口的 subscribe 方法把事件发射出去；
二、RxJava 2.x 环境搭建（基于AS 3.x）：
api 'io.reactivex.rxjava2:rxandroid:2.0.1'
api 'io.reactivex.rxjava2:rxjava:2.1.0'
三、RxJava 2.x 的使用及原理分析：
1.先写一个典型的使用例子：
首先，创建 Observable:
Observable observable = Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("I love rx!");
}
});
然后，创建 Observer:
Observer mObserver = new Observer() {
@Override
public void onSubscribe(Disposable d) {
Log.e(TAG, "-- onSubscribe --" + d.toString());
}
@Override
public void onNext(Object s) {
Log.e(TAG, "-- onNext --" + s);
}
@Override
public void onError(Throwable e) {
Log.e(TAG, "-- onError --" + e.getMessage());
}
@Override
public void onComplete() {
Log.e(TAG, "-- onComplete ---");
}
};
最后，也是最关键的，就是订阅。这一步是一切事件发生的触发点（后面会分析）。
observable.subscribe(mObserver);
至此，一个最简单的RxJava工作流程代码就写完了。运行之后，会看到日志：
-- onSubscribe --null
-- onNext --I love rx!
2.根据上面的典型案例分析RxJava 2.x的实现原理：
首先分析Observable的创建流程(Observable可通过just方法创建，也可通过create方法创建。这里先分析create方法创建的流程)：
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static Observable create(ObservableOnSubscribe source) {
ObjectHelper.requireNonNull(source, "source is null"); // 1
return RxJavaPlugins.onAssembly(new ObservableCreate(source)); // 2
}
注释1很容易理解，先判断source是否为空，是则抛出异常，否则往下执行；
注释2中new ObservableCreate 实例化一个ObservableCreate对象，它继承于Observable。并把ObservableOnSubscribe注入到ObservableCreate：
public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
this.source = source;
}
......
至于RxJavaPlugins.onAssembly()做的是类型转换的工作，现在没有用到map操作符，所以f为null。所以，create()目前返回ObservableCreate的实例source：
@SuppressWarnings({ "rawtypes", "unchecked" })
@NonNull
public static Observable onAssembly(@NonNull Observable source) {
Function f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
接着分析Observer的创建流程：
public interface Observer {
void onSubscribe(@NonNull Disposable d);
void onNext(@NonNull T t);
void onError(@NonNull Throwable e);
void onComplete();
}
Observer是一个接口，这里我把所有方法的注释去掉（节省空间）。Observer的创建很简单，直接实现这4个方法即可。
然后分析最关键的代码，也可以说是事件发射的导火索：
observable.subscribe(mObserver);
@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer observer) {
ObjectHelper.requireNonNull(observer, "observer is null"); // 1
try {
observer = RxJavaPlugins.onSubscribe(this, observer); // 2
ObjectHelper.requireNonNull(observer, "Plugin returned null Observer"); // 3
subscribeActual(observer); // 4
} 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;
}
}
注释1很简单，先判断observer是否为空，是则抛出异常，否则往下执行；
注释2也很容易理解，先判断是否要进行类型转换，是则进行转换，否则直接返回observer。由于目前没有写类型转换操作，所以这里直接返回observer；
注释3和注释1类似，都是做非空判断。为空则抛异常，否则往下执行；
注释4看方法名就知道，这里才是真正的订阅观察者操作。点进去，看到：
protected abstract void subscribeActual(Observer observer);
这里subscribeActual是一个抽象方法。那么真正的实现代码在哪呢？其实就在前面创建的Observable实例中，即ObservableCreate类中：
public final class ObservableCreate extends Observable {
final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
this.source = source;
}
@Override
protected void subscribeActual(Observer observer) {
CreateEmitter parent = new CreateEmitter(observer); // 1
observer.onSubscribe(parent); // 2
try {
source.subscribe(parent); // 3
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
parent.onError(ex);
}
}
......
注释1创建一个发射器，源码如下：
static final class CreateEmitter
extends AtomicReference
implements ObservableEmitter, Disposable {
private static final long serialVersionUID = -3434801548987643227L;
final Observer observer;
CreateEmitter(Observer 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 (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();
}
} else {
RxJavaPlugins.onError(t);
}
}
@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 serialize() {
return new SerializedEmitter(this);
}
@Override
public void dispose() {
DisposableHelper.dispose(this);
}
@Override
public boolean isDisposed() {
return DisposableHelper.isDisposed(get());
}
}
注释2实际上回调的是前面Observer接口的onSubscribe()方法；
注释3实际上回调的是下面这段代码中的subscribe方法，把事件给发射出去。
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter e) throws Exception {
e.onNext("I love rx!"); //4
}
});
注释4调用的实际上是注释1中创建的发射器CreateEmitter里面的onNext方法：
@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); // 5
}
}
注释5实际上回调的是Observer接口的onNext()方法。
至此，一个简单且典型的RxJava 2.x工作流程已经跑完了。
总结
在整个流程中(我们看得到的方法调用流程，不包括源码里面的方法)，Observer的onSubscribe()方法总是先执行，然后再到ObservableOnSubscribe里面的subscribe()方法，最后回调Observer的onNext()方法。如果是通过just()创建的Observable，还会自动调用Observer的onComplete()方法