关于RxJava运行原理(一)

最近可能是比较忙吧，很多事很麻烦，搞得蛮烦躁的。周末才有点时间看看书，写写东西，中午骑车时还把脚给摔伤了，哎，命苦啊。前端时间写了关于RxJava的一些操作符，那么今天就来看看源码，试着去看RxJava的内部实现过程吧。这次我觉得不会写很多，就一个方法：

Observable.create(new OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> observer) {
                try {
                    if(!observer.isUnsubscribed()) {
                        observer.onNext("onNext");
                        observer.onCompleted();
                    }
                }catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }).subscribe(new Observer<String>() {

            @Override
            public void onCompleted() {
                print("onCompleted");
            }

            @Override
            public void onError(Throwable arg0) {
                print("onError:" + arg0 );
            }

            @Override
            public void onNext(String arg0) {
                print("onNext:" + arg0);
            }
        }) ;

那么简化起来，就是下面这个了：

A.create(B).subscribe(C) ;

其中A为Observable,即可观察类；
B为OnSubscribe,即观察者对象作为参数；
C为Observer，即为我们的观察者。

那么来看A.create(new B)源代码：

可以看出，create是静态方法，返回是一个新的Observable对象，那么现在还看看RxJavaHooks.onCreate(f)返回的是什么吧：

这里面有一个onObservableCreate对象，是静态的，在static静态代码块里面初始化，我们找到它：

那现在来看看

return RxJavaPlugins.getInstance().getObservableExecutionHook().onCreate(f);

返回的是什么吧：

看样子是返回了自己啊，那再回到onCreate方法中：

 Func1<Observable.OnSubscribe, Observable.OnSubscribe> f = onObservableCreate;
        if (f != null) {
            return f.call(onSubscribe);
        }
        return onSubscribe;

此时return f.call(onSubcribe) -> 以为着 return onSubcribe()它自己本身。

那么此时我们Observable.oncreate方法可以简写为：

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

好了，create方法搞定了，现在来看Observable.create().subscribe()中的subscribe方法：

我们先考虑最简单的，现在返回的是重载的subscribe方法。在这之前，我们先看一下ObserverSubscriber这个类：

public final class ObserverSubscriber<T> extends Subscriber<T> {
    final Observer<? super T> observer;

    public ObserverSubscriber(Observer<? super T> observer) {
        this.observer = observer;
    }

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

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

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

可以看出，这个ObserverSubscriber内部做事的还是一个Observer，相当于Observer的包装类。
再来看subcribe方法：

此时返回的是一个静态方法，注意传入的参数，第一个ObserverSubscriber，也就相当于我们的Observer；第二个就是我们Observable本身。好了，那么就进入这里面去看看吧：【代码经过精简】

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {

        subscriber.onStart();

        try {

            RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);

            return RxJavaHooks.onObservableReturn(subscriber);
        } catch (Throwable e) {

            if (subscriber.isUnsubscribed()) {
                RxJavaHooks.onError(RxJavaHooks.onObservableError(e));
            } else {

                try {
                    subscriber.onError(RxJavaHooks.onObservableError(e));
                } catch (Throwable e2) {
                    Exceptions.throwIfFatal(e2);

                    RuntimeException r = new OnErrorFailedException("Error occurred attempting to subscribe"); 
                    RxJavaHooks.onObservableError(r);

                    throw r; // NOPMD
                }
            }
            return Subscriptions.unsubscribed();
        }
    }

还是按照最简单的方案进行下去，看这个最重要的一句话：

 RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);

首先我们需要分清楚三个参数的含义：
第一个是就是我们设置的A，也就是上文传入的this，也就是create方法中new的那个Observable；
第二个Observable.onSubcribe就是我们设置的B，也就是我们传入的OnSubscribe；
第三个subscriber就是我们设置的C，其实就是一个Observer,它来自我们subscribe绑定的元素

来看方法的实现：

此时我们像上次那样，查看onObservableStart的实现方式：

然后直接看onSubscribeStart(t1,t2),前面的getObservableExecutionHook()相当于单例模式获取RxJavaPlugins的，所以就没什么好说的啊，来看onSubscribeStart：

看到没有，返回的是第二个参数，什么都没有改变，返回就是onSubscribe，那么就是说：

 RxJavaHooks.onObservableStart(observable, observable.onSubscribe).call(subscriber);
 --->
observable.onSubscribe.call(subscriber);

--->
C.call(subscriber)

--->

public void call(Subscriber<? super String> observer) {
                try {
                    if(!observer.isUnsubscribed()) {
                        observer.onNext("onNext");
                        observer.onCompleted();
                    }
                }catch(Exception e) {
                    e.printStackTrace();
                }
            }

好了，终于走通了，我们的程序终于大白天下了，也终于知道为啥我们这么写，可以执行onNext,onCompleted方法了。
执行完成之后，会返回一个订阅对象，即Subscription对象

 return RxJavaHooks.onObservableReturn(subscriber);

当然了，在程序执行的过程中，如果遇到错误，会调用：

 subscriber.onError(RxJavaHooks.onObservableError(e));

进行接收。当然，并不是所有的error都能接接收，这里的原因很简单，有可能是使用者在使用过程中用了非法的函数方式操作造成的，所以有些错误使我们不能接收的。

当然了，写到这里基本上把一个简单的RxJava过程从源码的角度看了一遍，当然里面有很多东西现在不是很懂，以后有时间慢慢研究吧。改睡觉了，明天又要上班了。