RxJava2主流程再分析

一、概述

　　项目中再次用到了RxJava2（响应式编程/流式编程），所以决定再把主流程分析分析。之前有分析过，时间太久记不大清楚了。这次当时回顾了

二、源码分析

　　1.先看一个简单的流程，上游发送一个100的数字下游接收并打印

Observable.create(object : ObservableOnSubscribe<Int> {
            override fun subscribe(emitter: ObservableEmitter<Int>) {
                emitter.onNext(100)//发射器发送数字100
            }

        }).subscribe(object:Observer<Int>{
            override fun onSubscribe(d: Disposable) {
            }

            override fun onNext(t: Int) {//打印上面下发过来的数据
                KLog.e("RxJava2发送过来的内容为:${t}")
            }

            override fun onError(e: Throwable) {
            }

            override fun onComplete() {
            }

        })

　　下面分析一下上面这个简单流程代码是如何流转的。

　　首先Observable调用create方法创建了一个Observable对象，而create方法中需要传递一个ObservableOnSubscribe接口。其最终会创建一个ObservableCreate对象，并把source:ObservableOnSubscribe传递给它。此时被观察者对象就算是创建好了

    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));//这里创建了一个被观察者对象，并把source传递进去
    }

　　接下来看后半段，也就是.subscribe方法都干了些什么

   @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);
            subscribeActual(observer);//最终把观察者对象传递给此方法
        } catch (Throwable e) {
           ....
        }
    }

　　从上面的源码可以看到subscribe方法，把传递进来的observer交给了subscribeActual方法。其实现类是ObservableCreate，所以此时代码切换到了ObservableCreate.subscribeActual方法

 @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);//创建一个发射器
        observer.onSubscribe(parent);//把发射器传递给观察者对象

        try {
            source.subscribe(parent);//把发射器传递给ObservableOnSubscribe对象
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

　　接下俩看emmitter.next都干了啥，注意：在简单案例中的emitter:ObservableEmitter其实现类是CreateEmitter，所以最终会调用CreateEmitter的onNext方法.

@Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);//此处的Observer其实就是.subscribe(observer)传递过来的。所以此处看似是CreateEmitter执行了onNext方法，其实是observer对象自己调用自己
            }
        }

　　好了，到这里这一个简单的流程就分析完事了。大致流程再梳理一下：

　　1.创建被观察者对象ObservableCreate，并把ObservableOnSubscribe对象传递进去

　　2.执行.subscribe(observer)方法并把observer实例传递进去

　　3.oberver实例会交给CreateEmitter对象，而包装过的CreateEmiiter对象会交给Observer和ObservableOnSubscribe对象

　　4.上游执行emitter.onNext其实最终调用的是Observer.onNext，其实就是自己调用自己而已。