Rxjava2 源码解析（一）

前言

　　Rxjava2 我们都知道是很牛逼的一个扩展的观察者模式的Scheduler，基本可以在代码中替代异步线程+Handler的开发模式，同时配合MVP设计模式，可以更好的实现业务分离。但是并不能盲目崇拜，不能为了使用而使用，一切以编码需求为主。最近开始研读源码，也边读边写下自己的一些理解把。

Rxjava最基础的模式分析

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                e.onNext("ssss");
                e.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String value) {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        });

这是一个不具备操作符，以及没有线程调度的一个例子。
我们点进create方法中查看源码

这里我们抛弃其他的干扰，只需要知道它将一层层封装，最后返回了Observable对象实例。
然后我们查看subscribe方法。

这里暂时只有subscribeActual(observer)这行对我们有效，我们接着点进去。发现是一个接口，随后我们找到实现他方法的地方。

这里我们发现通过ObservableCreate类中的subscribeActual方法，将观察者和被观察者关联起来了。这里我们先不急的查看CreateEmitter类，我们先看source.subscribe(parent)方法。

ObservableEmitter接口也是实现一些基本方法，我们暂时只需要关注onNext,onError,onCompete。
我们再回到ObservableCreate类中的subscribeAtal方法发现它将Observe封装成了CreateEitter。

代码看到这，我们就可以尝试理清下业务逻辑，相比传统的观察者模式的观察者以及被观察者，这里还多了个订阅者，以及事件。同时通过这个简单例子给我们的信息是只有通过订阅才会执行事件。 我们可以梳理下执行流程：
先通过Observable.create方法将ObservableOnSubscribe实例传入，封装成一个ObservableCreate，最后再封装成Observable对象进行返回。执行subscribe时，将Observer封装成CreateEmitter，并传入ObservableOnSubscribe执行onSubscribe中的事件，最后把结果通过CreateEmitter回调出来。
我们先写个观察者接口实现基本方法

仿写最基础模式加深理解

先写个观察者接口

public interface Observer<T> {
    public void onNext(T t);
    public void onError(Exception e);
    public void onComplete();
}

然后我们发现源码中，有个ObservableEmitter接口作为事件结果回调，我们同时也弄过来，我们暂时只考虑最基本的方法。

public interface ObservableEmitter<T> {
    public void onNext(T t);
    public void onError(Exception e);
    public void onComplete();
}

其次是事件接口

public interface ObservableOnSubscribe<T> {

    public void subscribe(ObservableEmitter<T> observableEmitter);
}

随后我们看ObservableOnSubscribe接口，源码中只含有subscribe(ObservableEmitter<T> e)一个方法

然后写个被观察者

public class Observable<T> {

    private ObservableOnSubscribe observableOnSubscribe;

    private Observable(ObservableOnSubscribe observableOnSubscribe){
        this.observableOnSubscribe = observableOnSubscribe;
    }

    public static Observable create(ObservableOnSubscribe observableOnSubscribe){
        return new Observable(observableOnSubscribe);
    }
}

create使用静态方法，将传入的ObservableOnSubscribe转换成Observable对象。
然后我们实现一个CreateEmitter类

public class CreateEmitter<T> implements ObservableEmitter<T> {
    private Observer<T> observer;
    public CreateEmitter(Observer<T> observer){
        this.observer = observer;
    }
    @Override
    public void onNext(T t) {
        observer.onNext(t);
    }

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

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

最后我们回到Observable类添加订阅方法

public class Observable<T> {

    ...
    public void subscribe(Observer<? super T>  observice){
        observableOnSubscribe.subscribe(new CreateEmitter(observice));
    }
}

这样就结束了，一个极其精简版以及不具备线程调度，操作符的小扩展观察者模式就实现了。调用也同rxjava一样。

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> observableEmitter) {
                observableEmitter.onNext("s");
                observableEmitter.onComplete();
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onNext(String s) {
                System.out.println("-------hhhhh-- "+s);
            }

            @Override
            public void onError(Exception e) {

            }

            @Override
            public void onComplete() {

            }
        });

这步分析仅仅是阅读rxjava的第一步，也是基础和最简单的一步。

Diposed是什么

我们在源码CreateEmitter中回调结果的时候会发现有个!isDisposed()的条件判断，这个diposed是什么，字面理解是处理，其实他处理的是订阅消息。我们都知道事件方法中ObservableEmitter的父类Emitter拥有onNext,onError,onComplete，onError与onComplete是互斥关系，执行了两者方法之一，都不会再次回调结果给观察者的onNext,onError,onComplete方法。
Disposable只是一个接口，只实现了两个方法。

再看ObservableEmitter，继承了AtomicReference<Disposable>，我们进入AtomicReference

发现V value通过传入的Disposable泛型，value就是Disposable的一个实例，实例化中并没有看到赋值，所以我们可以认为他默认为null。我们再继续看ObservableEmitter的回调结果传递发现onComplete,onError执行完一定会执行dispose()方法-DisposableHelper.dispose(this);，this是ObservableEmitter自身实例对象。进入DisposableHelper类发现是个枚举类，且大部分方法都是静态方法。

这个是ObservableEmitter是在回调结果传递时会判断的。前面我们说了，通常情况下初始化ObservableEmitter的实例对象，它的Disposable的value==null。

这里是我们执行完onComplete,onError后会掉用的静态方法，将枚举结果复制给传递进来的ObservableEmitter实例对象，中断订阅者以及被观察者的关系。这个值的设立是用在运算符中的判断上，例如两个Observable串行，当第一个如果出错执行了一次onError，后续就会中断订阅关系。
这是我第一次描述源码解析的感想，可能会有些理解错误以及表达不清楚的地方，希望多多包涵，rxjava这个框架十分复杂，我也还正在研读，希望能学会更多里面所用到的思想，有空我还会续写第二偏。