简单了解RxJava的源码

现在Rxjava越来越流行，身为一名android开发者，不会使用这个显然是不行的，网上关于Rxjava的文章很多，但是你去找的话，发现很多就是一上来介绍很多操作符，让你记住了后面忘记了前面，这里推荐简书Rxjava，大家可以去看看。

事例

        Observable<String> sender = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("data1");
            }
        });


        Observer<String> receiver = new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {
                Log.d("dfy","接收到数据："+s);
            }
        };
        sender.subscribe(receiver);

上面是一个简单的rxjava的工作流程，创建了一个被观察者 sender和一个观察者 receiver，然后调用sender.subscribe(receiver);观察者就订阅了被观察者，
当sender 发送数据的时候，receiver就能接收到这个数据了
控制台打印

04-15 13:00:52.956 20438-20438/com.example.rxjava D/dfy: 接收到数据：data1

看到没，就是这么简单，但是为什么呢？看看源码就知道了!首先看

 sender.subscribe(receiver);

发送数据源码（被观察者）和 接收数据源（观察者）关联起来

public final Subscription subscribe(final Observer<? super T> observer) {
        if (observer instanceof Subscriber) {
            return subscribe((Subscriber<? super T>)observer);
        }
        return subscribe(new Subscriber<T>() {

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

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

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

        });
    }

可以看到里面先判断这个observer是不是Subscriber类型，如果是就进入
subscribe((Subscriber<? super T>)observer)，参数就是我们穿进去的observer，如果不是，就进入

return subscribe(new Subscriber<T>() {

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

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

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

        });

里面传入的就是一个new出来的Subscriber对象，然后重写他的三个方法。
好了，继续往下走，进入这个方法里，

    public final Subscription subscribe(Subscriber<? super T> subscriber) {
        return Observable.subscribe(subscriber, this);
    }

    private 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);
            // 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 RuntimeException("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();
        }
    }

这里我们可以看到最终调用的是Observable.subscribe(subscriber, this)这个方法，往下走，进入这个方法，可以看到他先判断subscriber和onSubscribe 是否为null，为null抛出异常，不为null，继续往下走，注意这行代码hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);onSubscribeStart()方法返回的仍然是observable.onSubscribe这个对象，然后调用onSubscribe的call(subscriber)方法，并把subscriber对象作为参数传过去，，哦，这下明白了当
执行sender.subscribe(receiver);的时候，我们会去回调onSubscribe里面的call方法，在这个例子里面就是会进入

   public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("data1");
            }

这个方法里，然后调用subscriber.onNext("data1"); 就会执行

subscribe(new Subscriber<T>() {

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

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

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

        })

里面的onNext(T t)方法，里面再去调用observer.onNext(t);，就会进入到我们这个例子的@Override
public void onNext(String s) {
Log.d("dfy","接收到数据："+s);
}
然后打印出接收到的数据.
OK,简单的流程就走完了，我们知道了具体的工作原理才能更好的掌握使用他，要知其然更知其所以然。如果有讲解的不对的地方，请指出，谢谢！