要理解RxJava框架，就需要理清楚其链路是怎样形成的。
先看一段简单的代码：
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("hello");
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println("result:"+s);
}
});打印出来的结果：
result:hello
我们先来分析一下其中的observable链：
public abstract class Observable<T> implements ObservableSource<T> {Observable是一个抽象类，它实现了ObservableSource接口，也就说我们后面如果看到ObservableSource接口的实例，可以看作是Observable向上转型的实例。
public interface ObservableSource<T> {
/**
* Subscribes the given Observer to this ObservableSource instance.
* @param observer the Observer, not null
* @throws NullPointerException if {@code observer} is null
*/
void subscribe(@NonNull Observer<? super T> observer);
}在Observable create的过程：
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
...
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}先不看RxJavaPlugins中的内容，调用者只需要传入一个ObservableOnSubscribe的实现类，RxJava会将其以构造函数参数的形式传入，并封装构造一个ObservableCreate对象。ObservableCreate不再是一个抽象类，而且继承了Observable对象。
public final class ObservableCreate<T> extends Observable<T> {
final ObservableOnSubscribe<T> source;
public ObservableCreate(ObservableOnSubscribe<T> source) {
this.source = source;
}
...于是这个时候，我们构造出了一个具体的Observable实例。
Observable抽象类，中只有一个方法是抽象的。
protected abstract void subscribeActual(Observer<? super T> observer);
所以，每个Observable子类实例化过程中，都需要实现subscribeActual方法。
回到之前的问题，Observable在链式调用过程中是怎样形成Observable链的呢？
我们接着看源码，得到ObservableCreate实例后，构建了一个单一入参的Consumer对象，并调用了subcribe方法，跟进去看一下：
public final Disposable subscribe(Consumer<? super T> onNext) {
return subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION,
Functions.emptyConsumer());
}继续跟：
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,
Action onComplete, Consumer<? super Disposable> onSubscribe) {
...
LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError, onComplete, onSubscribe);
subscribe(ls);
return ls;
}LambdaObserver同样地，以构造函数的方式将Consumer对象封装到了Observer中，这样让调用者用很简洁的代码构造出一个Observer
public final void subscribe(Observer<? super T> observer) {
...
try {
...
subscribeActual(observer);
} catch (NullPointerException e) { // NOPMD
...
}
}最后，发现subscribe调用的是Observable的实现类中的subscribeActual()方法。我们来看看之前的Observable子类ObservableCreate是如何实现subscribeActual方法的：
@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);
}
}看到这里有个source.subscribe()，于是直接调用了我们传入的接口ObservableOnSubscribe实例中的subscribe方法。
因为我们这里只有一个Observable，所以还没有看到链，没关系，先走一遍，后面再加入几个Observable再瞧瞧。
source.subscribe()后，由于我们在subscribe方法中执行了emitter的onNext()方法，所以，consumer收到了具体的消息。
Emitter是个什么东东？什么时候传给subscribe()方法？
之前讲到Consumer被封装到了一个lambdaObserver中，现在传了进来，并且以构造函数的方式传到CreateEmitter中，这种构造类的方式好眼熟啊，在哪儿看到过？
try {
InputStream stream = new BufferedInputStream(new FileInputStream(new
File("//abc")));
...
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally{
...
}装饰者模式。ContextWrapper和ContextImpl也比较类似。
这里Emitter把Observer作为入参传进来
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) {
...
}
@Override
public boolean tryOnError(Throwable t) {
...
}
@Override
public void onComplete() {
...
}
@Override
public void setDisposable(Disposable d) {
...
}
...
}可以看到起对onNext()方法进行了增强，添加了异常处理，disposable中断，最后还是调用了observer的onNext()方法。然而CreateEmitter与Observer之间并没有相同的父类，虽然有同样名称的方法。所以此处并非装饰者模式。
在emitter中调用了observer的OnNext()，于是lambdaObserver收到了onNext()回来的数据，
@Override
public void onNext(T t) {
if (!isDisposed()) {
try {
onNext.accept(t);
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
get().dispose();
onError(e);
}
}
}lambdaObserver收到数据后，调用了Consumer的accept()方法，于是乎，我们最后成功在Consumer中打印到最后的字符串。
流程走了一遍。接下来，我们看，如果再加入几个Observable的转换后，多个Observable是如何形成链式关系了。
比如，我们把最开头的test1源码做一些修改：
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("hello");
}
}).map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return "abc-"+s;
}
}).map(new Function<String, String>() {
@Override
public String apply(String s) throws Exception {
return s+"-def";
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(String s) throws Exception {
System.out.println("result:"+s);
}
});再次插入两条map操作。
看看observable的静态方法map()都做了些什么：
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}似乎看到了一些细微的区别，我们来对比一下：
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}create()的时候只有一个入参，而现在new ObservableMap()的时候有两个入参，除了Function()用来构造一个新的Observable外，还传入了一个this，把当前这个observable实例也传了进去。
传进去干嘛？
莫非这里就与链有关了？
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
...只看到source传了进来，没看到哪儿用到了啊？
只看到被父类的构造函数拿去用来。
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
/** The source consumable Observable. */
protected final ObservableSource<T> source;
/**
* Constructs the ObservableSource with the given consumable.
* @param source the consumable Observable
*/
AbstractObservableWithUpstream(ObservableSource<T> source) {
this.source = source;
}
@Override
public final ObservableSource<T> source() {
return source;
}
}我们来分析一下父类，ObservableSource是干嘛？之间好像有讨论过，对不对？
抽象类Observable实现了ObservableSource，所以这里相当于向上转型了，也就说我在构造下一个mapObservable的时候，把上一个Observable存了起来，这不正是一个链表吗？
明白了吧。
接着分析下，加入map后，后面的subscribe()发生了一些怎样的变化，observer的链又是怎样形成的。
欲知后事如何，且看下回分解。