RxJava2.0系列之Create源码分析

例子：

val source = object : ObservableOnSubscribe<Int> {
        override fun subscribe(emitter: ObservableEmitter<Int>) {
            emitter.onNext(1)
            emitter.onNext(2)
            emitter.onComplete()
        }
    }
    val observer = object : Observer<Int> {
        override fun onComplete() {}

        override fun onSubscribe(d: Disposable) {}

        override fun onNext(t: Int) {}

        override fun onError(e: Throwable) {}
    }    
    Observable.create(source).subscribe(observer) 

分析

入口Observable.create(source)

    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

传递一个ObservableOnSubscribe接口对象，接口里面只有一个方法

void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;

接着看RxJavaPlugins中的onAssembly方法

@NonNull
    public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

##onObservableAssembly是一个静态变量，除非主动设置，否则都为空，所以这里直接返回了source 意味着create直接返回了new ObservableCreate(source)，这一步生成了一个ObservableCreate对象，并把ObservableOnSubscribe接口对象传入进去，接着调用了(ObservableCreate对象).subscribe(observer)

    @SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
            ...
            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            ...
        }
    }

这一步触发了ObservableCreate对象内的subscribeActual方法执行。接着进入ObservableCreate类：

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
        内部有一个静态内部类，CreateEmitter（实现Disposable接口），里面有个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);
            }
        }
        
    static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
    ...
    }

subscribeActual中会生成CreateEmitter，并把observer对象传进去，接着调用observer.onSubscribe(parent);传递的是一个Disposable接口对象; source.subscribe(parent) 回调ObservableOnSubscribe接口对象中的subscribe方法，并把perant（CreateEmitter 发射器）传进去，然后emitter.onNext(1)开始发射数据，接着进入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.onNext(t);也就是观察者的onNext方法，这样整个订阅过程就串联起来了。

流程回顾

Observable.create(source).subscribe(observer) 分为两步走

第一步：Observable.create(source)，生成一个ObservableCreate对象，并将ObservableCreate对象与ObservableOnSubscribe接口对象关联起来

第二步：（ObservableCreate对象）.subscribe(observer) 是订阅真正触发的时机，会触发ObservableCreate对象中的subscribeActual方法，生成CreateEmitter对象，接着执行ObservableOnSubscribe接口对象中的subscribe方法，把CreateEmitter对象传入，然后开始发射数据emitter.onNext(1)， CreateEmitter对象onNext方法最终会回调observer的onNext方法，此刻整个订阅过程已经形成。