RxJava原理分析

首先声明下，本文并不会讲解RxJava的基本使用方法，建议对RxJava有一定了解的再来看本文。
RxJava已经有了2.0的版本，而本文是对1.0原理的描述。
RxJava是一个可以实现异步操作的框架，其优点包括可以方便的进行线程转换，数据转换以及整个异步实现流程比较清晰，使用链式调用。
首先引包

compile 'io.reactivex:rxjava:1.3.0'compile 'io.reactivex:rxandroid:1.0.1'

调用为

Observable.create(new Observable.OnSubscribe<String>() {        @Override        public void call(Subscriber<? super String> subscriber) {             subscriber.onNext("Hello");             subscriber.onNext("Hi");;             subscriber.onCompleted();         }     })    .map(new Func1<String, Date>() {        @Override        public Date call(String s) {             return null;        }    })   .observeOn(AndroidSchedulers.mainThread())   .subscribeOn(Schedulers.io())   .subscribe(new Action1<Date>() {        @Override        public void call(Date date) {        }   });

其中create用于规定触发规则，map用于进行数据转换，subscribeOn决定了订阅的线程，observeOn决定了事件处理的线程，subscribe则是最后的事件处理。接下来从源码上看看他到底是怎么做到的。
首先，最简单的

Observable.create(new Observable.OnSubscribe<String>() {        @Override        public void call(Subscriber<? super String> subscriber) {             subscriber.onNext("Hello");             subscriber.onNext("Hi");;             subscriber.onCompleted();         }     })   .subscribe(new Action1<Date>() {        @Override        public void call(Date date) {        }   });

不添加参数变化功能，不管线程的转换，那么他做了什么，首先看create方法

public static <T> Observable<T> create(OnSubscribe<T> f) {        return new Observable<T>(RxJavaHooks.onCreate(f));    }protected Observable(OnSubscribe<T> f) {        this.onSubscribe = f;    }

没什么特别的，就是创建一个Observable对象和一个与Observable相对应的OnSubscribe对象
接下来subscribe的实现

public final Subscription subscribe(final Action1<? super T> onNext) {        ......        return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));    }

有很多重载的方法，我选了最简单的一个，最后都会调到subscribe(Subscriber subscriber)

public final Subscription subscribe(Subscriber<? super T> subscriber) {        return Observable.subscribe(subscriber, this);    }static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {        ......        subscriber.onStart();        ......        RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);        return RxJavaHooks.onObservableReturn(subscriber);                }    }

就是先调用subscriber的onStart方法，接着调用OnSubscribe的call方法，结合上下文，其实也就是调用subscriber的onNext和onCompleted等方法。逻辑上很好理解，那么接下来我们增加了map方法，变成了

Observable.create(new Observable.OnSubscribe<String>() {        @Override        public void call(Subscriber<? super String> subscriber) {             subscriber.onNext("Hello");             subscriber.onNext("Hi");;             subscriber.onCompleted();         }     })    .map(new Func1<String, Date>() {        @Override        public Date call(String s) {             return null;        }    })   .subscribe(new Action1<Date>() {        @Override        public void call(Date date) {        }   });

看看map方法做了什么

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {        return unsafeCreate(new OnSubscribeMap<T, R>(this, func));    }public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {        return new Observable<T>(RxJavaHooks.onCreate(f));    }

他又创建了一个Observable对象，所以我们可以从这里知道，Observable的链式调用并不是用对象本身不停地链啊链，实际上，经过每一次变换，包括线程啊，参数啊，他都会新建一个Observable对象并返回新建的对象。
我们回来接着看这个Observable对象，很明显，关键在于OnSubscribeMap这个类

public final class OnSubscribeMap<T, R> implements OnSubscribe<R> {    final Observable<T> source;    final Func1<? super T, ? extends R> transformer;    public OnSubscribeMap(Observable<T> source, Func1<? super T, ? extends R> transformer) {        this.source = source;        this.transformer = transformer;    }    @Override    public void call(final Subscriber<? super R> o) {        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);        o.add(parent);        source.unsafeSubscribe(parent);    }}

可以看到这个OnSubscribeMap继承了OnSubscribe，其会持有上一层的Observable对象source以及我们实现了转换方法的对象transformer。
关键在于其默认的call方法，首先提醒下他的参数final Subscriber o是下一层调用subscribe时传进的subscriber对象。
我们看MapSubscriber对象

static final class MapSubscriber<T, R> extends Subscriber<T> {        final Subscriber<? super R> actual;        final Func1<? super T, ? extends R> mapper;        boolean done;        public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {            this.actual = actual;            this.mapper = mapper;        }        @Override        public void onNext(T t) {            R result = mapper.call(t);            actual.onNext(result);        }    }

他是个Subscriber，是个观察者。就拿我们写的map(new Func1<>String, Date>())来说，也就是上面的T都是String，而R则是Date，在调用他的onNext方法时，首先调用转换参数方法，将String转换为Date，之后将转换的Date给到下一层的Subscriber来进行处理。
再看source.unsafeSubscribe(parent)，记得吧，source是上一层的Observable对象

public final Subscription unsafeSubscribe(Subscriber<? super T> subscriber) {        ......        subscriber.onStart();        RxJavaHooks.onObservableStart(this, onSubscribe).call(subscriber);        return RxJavaHooks.onObservableReturn(subscriber);        }    }

所以如果这一层的Observable是发送消息时创建的，那么他就会调用subscriber的onNext等方法，而如果他是由map创建的，则就继续封装变换方法，创建新的subscriber对象，继续将新创建的subscriber对象扔给上一层Observable处理，以此类推

接着我们看看实现了线程转换的subscribeOn和observeOn都做了什么
先来subscribeOn

public final Observable<T> subscribeOn(Scheduler scheduler) {        return subscribeOn(scheduler, !(this.onSubscribe instanceof OnSubscribeCreate));    }public final Observable<T> subscribeOn(Scheduler scheduler, boolean requestOn) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return unsafeCreate(new OperatorSubscribeOn<T>(this, scheduler, requestOn));    }public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {        return new Observable<T>(RxJavaHooks.onCreate(f));    }

又是一个Observable，关键还是在于他的OnSubscribe，也就是OperatorSubscribeOn

public final class OperatorSubscribeOn<T> implements OnSubscribe<T> {    final Scheduler scheduler;    final Observable<T> source;    final boolean requestOn;    public OperatorSubscribeOn(Observable<T> source, Scheduler scheduler, boolean requestOn) {        this.scheduler = scheduler;        this.source = source;        this.requestOn = requestOn;    }    @Override    public void call(final Subscriber<? super T> subscriber) {        final Worker inner = scheduler.createWorker();        SubscribeOnSubscriber<T> parent = new SubscribeOnSubscriber<T>(subscriber, requestOn, inner, source);        subscriber.add(parent);        subscriber.add(inner);        inner.schedule(parent);    }}

可以看到整体思路还是一样的，继续往上抛，不过inner.schedule(parent)说明他并不是在原始的线程里抛，根据你传递的Scheduler以此决定在哪个线程里抛，然后之后的流程也随之切换到了新线程，现在我们可以回答两个问题了
第一个：为什么subscribeOn只有一个起作用，而且是第一个。因为我们所写的那些转换等方法其实最后都是实现在了subscriber的onNext的方法中，多个subscribeOn方法其实实现了线程切换，不过实现在往上抛的过程，并没有在我们的代码中体现出来，第一个subscribeOn是最后调用的，是我们能看的到的
第二个：Observable有一个doOnSubscribe方法，调用他时的线程由他之后的第一个subscribeOn方法决定。这是因为他的实现是在抛的那一条线执行的。

public final Observable<T> doOnSubscribe(final Action0 subscribe) {        return lift(new OperatorDoOnSubscribe<T>(subscribe));    }public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {        return unsafeCreate(new OnSubscribeLift<T, R>(onSubscribe, operator));    }public class OperatorDoOnSubscribe<T> implements Operator<T, T> {    private final Action0 subscribe;    public OperatorDoOnSubscribe(Action0 subscribe) {        this.subscribe = subscribe;    }    @Override    public Subscriber<? super T> call(final Subscriber<? super T> child) {        subscribe.call();        return Subscribers.wrap(child);    }}

subscribeOn处理的是抛的那一条线，也就是OnSubscribe的call那一线，那么很明显了observeOn处理的就是另一条线，Subscriber的onNext方法了，看看源码

public final Observable<T> observeOn(Scheduler scheduler) {        return observeOn(scheduler, RxRingBuffer.SIZE);    }public final Observable<T> observeOn(Scheduler scheduler, int bufferSize) {        return observeOn(scheduler, false, bufferSize);    }public final Observable<T> observeOn(Scheduler scheduler, boolean delayError, int bufferSize) {        if (this instanceof ScalarSynchronousObservable) {            return ((ScalarSynchronousObservable<T>)this).scalarScheduleOn(scheduler);        }        return lift(new OperatorObserveOn<T>(scheduler, delayError, bufferSize));    }public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {        return unsafeCreate(new OnSubscribeLift<T, R>(onSubscribe, operator));    }public static <T> Observable<T> unsafeCreate(OnSubscribe<T> f) {        return new Observable<T>(RxJavaHooks.onCreate(f));    }

按照经验，找OnSubscribe，也就是OnSubscribeLift

public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {    final OnSubscribe<T> parent;    final Operator<? extends R, ? super T> operator;    public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {        this.parent = parent;        this.operator = operator;    }    @Override    public void call(Subscriber<? super R> o) {        Subscriber<? super T> st = RxJavaHooks.onObservableLift(operator).call(o);                st.onStart();        parent.call(st);            }}

可以看到call方法没有什么特别，我们看看Subscriber，它是由operator的call方法生成的，operator是OperatorObserveOn类

public final class OperatorObserveOn<T> implements Operator<T, T> {    private final Scheduler scheduler;    private final boolean delayError;    private final int bufferSize;    public OperatorObserveOn(Scheduler scheduler, boolean delayError, int bufferSize) {        this.scheduler = scheduler;        this.delayError = delayError;        this.bufferSize = (bufferSize > 0) ? bufferSize : RxRingBuffer.SIZE;    }    @Override    public Subscriber<? super T> call(Subscriber<? super T> child) {         ObserveOnSubscriber<T> parent = new ObserveOnSubscriber<T>(scheduler, child, delayError, bufferSize);         parent.init();         return parent;    }}

这个Subscriber是ObserveOnSubscriber，是OperatorObserveOn的一个内部类

static final class ObserveOnSubscriber<T> extends Subscriber<T> implements Action0 {        final Subscriber<? super T> child;        final Scheduler.Worker recursiveScheduler;        final boolean delayError;        public ObserveOnSubscriber(Scheduler scheduler, Subscriber<? super T> child, boolean delayError, int bufferSize) {            this.child = child;            this.recursiveScheduler = scheduler.createWorker();            this.delayError = delayError;        @Override        public void onNext(final T t) {            ......            schedule();        }        protected void schedule() {            if (counter.getAndIncrement() == 0) {                recursiveScheduler.schedule(this);            }        }    }

可以看到在onNext最后进行了线程转换，所以observeOn可以多次改变运行线程