关于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过程从源码的角度看了一遍，当然里面有很多东西现在不是很懂，以后有时间慢慢研究吧。改睡觉了，明天又要上班了。