RxJava源码分析

又好长一段时间没写博客了。今天来个较简短的博客来强势回归哈哈。上篇博客写了RN的源码分析，出乎意料的就有两个出版社联系我要不要出书，可见RN的火热。本来也想写RN的，但因为最近接触了挺多Android的东东，还是想先总结总结先。RN就放后面啦。

什么是RxJava

接触RxJava也一段时间了，一直想写下关于它的文章，RxJava是用来实现异步框架的，类似于AsyncTask。这里推荐看下给Android开发者的RxJava详解这篇文章，写得很好。
RxJava能够很简洁的完成异步操作，在逻辑很复杂的情况下，RxJava的优势就很明显。

RxJava的使用

先看下RxJava完成网络请求的代码：

  Observable.create(new Observable.OnSubscribe<Integer>(){

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                Log.e("rxjava","observable call");
                subscriber.onNext(1);
            }
        }).map(new Func1<Integer, String>() {
            @Override
            public String call(Integer integer) {
                return "===>" + integer;
            }
        }).subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<String>() {
                         @Override
                         public void call(String s) {

                         }
                     }
        );

链式编程风格。简单讲下上面代码。
* Observable:被观察者，有变化时通知观察者。
* Observer:观察者，监测被观察者，有变化就做相应的触发。
* OnSubscribe：Observable中的成员变量。
首先OnSubscribe的call方法中实现业务逻辑，如网络请求等，可以在子线程中执行。subscribeOn(Schedulers.io())就会在内部实现是是用一个无数量上限的线程池，在线程中实现相应操作。observeOn(AndroidSchedulers.mainThread())用于指定观察者的执行环境，这里指定的是主纯程。执行非常简单吧。
在这里给出我自己写的Demo地址，使用RxJava和Retrofit一起进行网络请求。Demo中也对RxJava与Retrofit做了封装。可以看下。
代码下载

源码分析

进入本篇博客的重点。讲下RxJava的源码。主要是了解下它的思想，很值得学习。以下面那段代码进行分析。

Observable.create(new Observable.OnSubscribe<Integer>(){

            @Override
            public void call(Subscriber<? super Integer> subscriber) {
                Log.e("rxjava","observable call");
                subscriber.onNext(1);
            }
        }).map(new Func1<Integer, String>() {
            @Override
            public String call(Integer integer) {
                return "===>" + integer;
            }
        }).subscribe(new Action1<String>() {
                         @Override
                         public void call(String s) {

                         }
                     }
        );

首先看create:

public static <T> Observable<T> create(OnSubscribe<T> f) {
    return new Observable<T>(hook.onCreate(f));
}

这里的f就是我们定义的OnSubscribe。这里简称On1。hook.onCreate(f)的代码很简单如下：

public <T> OnSubscribe<T> onCreate(OnSubscribe<T> f) {
    return f;
}

这里只是直接把f返回，而f在这里是On1。然后就新建一了个被观察者，这里简称Ob1。看下Observable的构造方法：

protected Observable(OnSubscribe<T> f) {
    this.onSubscribe = f;
}

直接把On1赋给 Ob1里的onSubscribe变量。即Ob1.onSubscribe就是On1。记住啦。接下来，看下Map的代码，从上面分析可知，它是调用的Ob1.map（）。

public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
    return lift(new OperatorMap<T, R>(func));
}

这里实例化了OperatorMap，并将Func1作为参数传入。

public final class OperatorMap<T, R> implements Operator<R, T> {

    final Func1<? super T, ? extends R> transformer;

    public OperatorMap(Func1<? super T, ? extends R> transformer) {
        this.transformer = transformer;
    }

    @Override
    public Subscriber<? super T> call(final Subscriber<? super R> o) {
        MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
        o.add(parent);
        return parent;
    }

    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;

            try {
                result = mapper.call(t);
            } catch (Throwable ex) {
                Exceptions.throwIfFatal(ex);
                unsubscribe();
                onError(OnErrorThrowable.addValueAsLastCause(ex, t));
                return;
            }

            actual.onNext(result);
        }
}

其中transformer就是存的Func1。看下看下lift的代码：

public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
    return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}

回顾下这里的operator就是上面的OperatorMap，其中transformer就是我们定义的Func1。主要是调用OnSubscribeLift。

public final class OnSubscribeLift<T, R> implements OnSubscribe<R> {

    static final RxJavaObservableExecutionHook hook = RxJavaPlugins.getInstance().getObservableExecutionHook();

    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) {
        try {
            Subscriber<? super T> st = hook.onLift(operator).call(o);
            try {
                // new Subscriber created and being subscribed with so 'onStart' it
                st.onStart();
                parent.call(st);
            } catch (Throwable e) {
                // localized capture of errors rather than it skipping all operators
                // and ending up in the try/catch of the subscribe method which then
                // prevents onErrorResumeNext and other similar approaches to error handling
                Exceptions.throwIfFatal(e);
                st.onError(e);
            }
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // if the lift function failed all we can do is pass the error to the final Subscriber
            // as we don't have the operator available to us
            o.onError(e);
        }
    }
}

首先先说明，这个类很重要。这里parent就是On1，operator就是OperatorMap。很好理解，我们先定义的On1再定义的Func1，所以叫On1为parent，好记。这里我们把生成的OnSubscribeList类简称为lift。多啰嗦下，lift的的parent是On1，operator是OperatorMap（存着Func1），记住，调用是在.subscribe方法中，这此之前，这些call方法都还不会运行。那什么时候运行呢。别急，让我们来看看subscribe方法。上面最后又生成了一个Observable。我们叫它Ob2。

protected Observable(OnSubscribe<T> f) {
    this.onSubscribe = f;
}

可知，它把lift作为参数存入了Ob2的onSubscribe中。所以Ob2.onSubscribe=lift。好终于到最后的subscribe了，来看看它的源码：

public final Subscription subscribe(final Action1<? super T> onNext) {
    if (onNext == null) {
        throw new IllegalArgumentException("onNext can not be null");
    }

    Action1<Throwable> onError = InternalObservableUtils.ERROR_NOT_IMPLEMENTED;
    Action0 onCompleted = Actions.empty();
    return subscribe(new ActionSubscriber<T>(onNext, onError, onCompleted));
}

简单，主要是生成了ActionSubscriber。这里OnNext就是我们定义的Action1，好，把Action1作为参数传到ActionSubscriber生成一个Subscriber，我们把生成的这个Subscriber称为Sub1。看下它的代码：

public final class ActionSubscriber<T> extends Subscriber<T> {

    final Action1<? super T> onNext;
    final Action1<Throwable> onError;
    final Action0 onCompleted;

    public ActionSubscriber(Action1<? super T> onNext, Action1<Throwable> onError, Action0 onCompleted) {
        this.onNext = onNext;
        this.onError = onError;
        this.onCompleted = onCompleted;
    }

    @Override
    public void onNext(T t) {
        onNext.call(t);
    }

    @Override
    public void onError(Throwable e) {
        onError.call(e);
    }

    @Override
    public void onCompleted() {
        onCompleted.call();
    }
}

没啥，但从这我们就知道，如果调用sub1的onNext，就是调用Action1的call方法。继续跟subscribe方法，它把sub1作为参数传了进去。

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
 // validate and proceed
    if (subscriber == null) {
        throw new IllegalArgumentException("observer can not be null");
    }
    if (observable.onSubscribe == null) {
        throw new IllegalStateException("onSubscribe function can not be null.");
        /*
         * the subscribe function can also be overridden but generally that's not the appropriate approach
         * so I won't mention that in the exception
         */
    }

    // new Subscriber so onStart it
    subscriber.onStart();

    /*
     * See https://github.com/ReactiveX/RxJava/issues/216 for discussion on "Guideline 6.4: Protect calls
     * to user code from within an Observer"
     */
    // if not already wrapped
    if (!(subscriber instanceof SafeSubscriber)) {
        // assign to `observer` so we return the protected version
        subscriber = new SafeSubscriber<T>(subscriber);
    }

    // The code below is exactly the same an unsafeSubscribe but not used because it would
    // add a significant depth to already huge call stacks.
    try {
        // allow the hook to intercept and/or decorate
        hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
        return hook.onSubscribeReturn(subscriber);
    } catch (Throwable e) {
        // special handling for certain Throwable/Error/Exception types
        Exceptions.throwIfFatal(e);
        // in case the subscriber can't listen to exceptions anymore
        if (subscriber.isUnsubscribed()) {
            RxJavaPluginUtils.handleException(hook.onSubscribeError(e));
        } else {
            // if an unhandled error occurs executing the onSubscribe we will propagate it
            try {
                subscriber.onError(hook.onSubscribeError(e));
            } catch (Throwable e2) {
                Exceptions.throwIfFatal(e2);
                // if this happens it means the onError itself failed (perhaps an invalid function implementation)
                // so we are unable to propagate the error correctly and will just throw
                RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe [" + e.getMessage() + "] and then again while trying to pass to onError.", e2);
                // TODO could the hook be the cause of the error in the on error handling.
                hook.onSubscribeError(r);
                // TODO why aren't we throwing the hook's return value.
                throw r;
            }
        }
        return Subscriptions.unsubscribed();
    }
}

这里的subscriber就是上面的sub1。主要调用onSubscribeStart，它的两个参数，observable其实就是Ob2,Ob2.onSubscribe当然知道是谁啦，就是lift。看看这个方法的实现：

public <T> OnSubscribe<T> onSubscribeStart(Observable<? extends T> observableInstance, final OnSubscribe<T> onSubscribe) {
    // pass through by default
    return onSubscribe;
}

OK，返回onSubscribe。那就是lift，则上面的代码等价于：

lift.call(sub1)

看OnSubscribeLift的call方法。

@Override
public void call(Subscriber<? super R> o) {
    try {
        Subscriber<? super T> st = hook.onLift(operator).call(o);
        try {
            // new Subscriber created and being subscribed with so 'onStart' it
            st.onStart();
            parent.call(st);
        } catch (Throwable e) {
            // localized capture of errors rather than it skipping all operators
            // and ending up in the try/catch of the subscribe method which then
            // prevents onErrorResumeNext and other similar approaches to error handling
            Exceptions.throwIfFatal(e);
            st.onError(e);
        }
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        // if the lift function failed all we can do is pass the error to the final Subscriber
        // as we don't have the operator available to us
        o.onError(e);
    }
}

o是sub1，list中的operator是operatorMap,parent是On1，这个我们上面己经分析过，忘记的可以回去看看。看下hook.OnLift方法：

public <T, R> Operator<? extends R, ? super T> onLift(final Operator<? extends R, ? super T> lift) {
    return lift;
}

lift是传进来的operatorMap，onLift返回lift。所以相当于是调用了operatorMap.call(sub1),看它OperatorMap中的call方法：

public Subscriber<? super T> call(final Subscriber<? super R> o) {
    MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
    o.add(parent);
    return parent;
}

这里的transformer就是Func1，创建了一个MapSubscriber，这里我们叫它Sub2。o是Sub1。看下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;

        try {
            result = mapper.call(t);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            unsubscribe();
            onError(OnErrorThrowable.addValueAsLastCause(ex, t));
            return;
        }

        actual.onNext(result);
    }

    @Override
    public void onError(Throwable e) {
        if (done) {
            RxJavaPluginUtils.handleException(e);
            return;
        }
        done = true;

        actual.onError(e);
    }


    @Override
    public void onCompleted() {
        if (done) {
            return;
        }
        actual.onCompleted();
    }

    @Override
    public void setProducer(Producer p) {
        actual.setProducer(p);
    }
}

Ok,那么actual就是Sub1，mapper就是transformer，其实就是Func1，记住啦。回到OnSubscribeLift中的代码，接下来调用以下代码：

parent.call(st);

好，st就是我们创建的Sub2。parent就是On1。那么调用On1.call方法就回到了我们自定义的方法中：

public void call(Subscriber<? super Integer> subscriber) {
        Log.e("rxjava","observable call");
        subscriber.onNext(1);
    }

在例子中，我们调用的就是Sub2的onNext方法。看下Sub2的onNext方法，在MapSubscriber中：

@Override
public void onNext(T t) {
    R result;

    try {
        result = mapper.call(t);
    } catch (Throwable ex) {
        Exceptions.throwIfFatal(ex);
        unsubscribe();
        onError(OnErrorThrowable.addValueAsLastCause(ex, t));
        return;
    }

    actual.onNext(result);
}

oK,那result就为“===>1”。最后调用actual的onNext方法。其实就是Sub1的onNext方法，这在上面己经说过，调用的就是Action的call，如下：

@Override
    public void onNext(T t) {
        onNext.call(t);
    }

那最后就回到我们定义的Action的call方法了，t为“===>1”。

new Action1<String>() {
                 @Override
                 public void call(String s) {

                 }
             }

这样调用就结束了。

总结

上面流程看起来有点复杂，先看下面这张图：

个人把它分为三个步骤。

• 从左边开始，从上到下每一次lift都会新建一个Observable，一个OnSubscribe和Operator从上面分析过程中，lift就是OnSubscribe。而opeatorMap就是这里的Operator。在没有调用subscribe方法之前，它们的call是不会调用的。直到调用到subscribe。
• 从下到上，创建Suscriber，每创建一个就调用OnSubscribe的call方法，接着调用Operator的Call方法，层层往上。之所以能层层往上是因为Suscriber中有parent变量。直到调用On1中的方法。
• 第三阶段，从上到下调用各个Subscriber，如这个例子就是先On1再Func1再Action1。从而完成整个过程 。
  篇幅关系，没有分析RxJava的线程切换流程。但这里说明下，线程切换跟上文分析的一样，同样是用Lift来切换。被观察者的创建的对象OperatorSubscribeOn是一个OnSubscribe，而观察者创建的OperatorObserveOn对象是一个Operator。所以它们同样是执行上面的那些流程。之前subscribeOn只有一次有效，是因为上面第二阶段一直往上但又没执行，直到第一个声明subscribeOn之后再开始调用On1，所以明显只有一个有效。而之所以observeOn每个都有它之上的代码有效，是因为第三阶段往下执行，每执行完Subscriber如遇observeOn就会线程切换。所以是每次有效。