Rxjava2源码分析一Create方法

首先从一段代码开始复制代码

Observable.create(new ObservableOnSubscribe<Integer>() {
                 @Override
                 public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                     emitter.onNext(1);
                     emitter.onComplete()
                 }
             }).subscribe(new Observer<Integer>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        
                    }

                    @Override
                    public void onNext(Integer integer) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });;复制代码

 进入看Observable.creat方法

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
                             ObjectHelper.requireNonNull(source, "source is null");
                             return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
                         }复制代码

这里生成了一个ObservableCreate<T>(source)了继续看下继续看RxJavaPlugins.onAssembly方法

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

static volatile Function<? super Observable, ? extends Observable> onObservableAssembly;
            public static void setOnObservableAssembly(@Nullable Function<? super Observable, ? extends Observable> onObservableAssembly) {
                  if (lockdown) {
                      throw new IllegalStateException("Plugins can't be changed anymore");
                  }
                  RxJavaPlugins.onObservableAssembly = onObservableAssembly;
              }复制代码

因为setOnObservableAssembly()方法只有在rxJavaPlugins的reset（）方法里面设置为null为没有其他设置，所以这个方法就是返回source参数ObservableCreate对象。

以上知道create方法就是生成了一个 ObservableCreate对象现在create方法看完了。接下来看subscribe()方法

       public final void subscribe(Observer<? super T> observer) {
             ObjectHelper.requireNonNull(observer, "observer is null");
             try {
                 observer = RxJavaPlugins.onSubscribe(this, observer);   1

                 ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

                 subscribeActual(observer);                              2
             } catch (NullPointerException e) { // NOPMD
                 throw e;
             } catch (Throwable e) {
                 Exceptions.throwIfFatal(e);
                 // can't call onError because no way to know if a Disposable has been set or not
                 // can't call onSubscribe because the call might have set a Subscription already
                 RxJavaPlugins.onError(e);
                 NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
                 npe.initCause(e);
                 throw npe;
             }
             }复制代码

  1处是把observer返回 接下来看2处

protected abstract void subscribeActual(Observer<? super T> observer);复制代码

这是抽象方法,子类是刚刚的create()方法的创建的ObservableCreate类 接下来看下这类的subscribeActual方法

protected void subscribeActual(Observer<? super T> observer) {
               CreateEmitter<T> parent = new CreateEmitter<T>(observer);1
                  observer.onSubscribe(parent);2
              
                      try {
                          source.subscribe(parent);3
                      } catch (Throwable ex) {
                          Exceptions.throwIfFatal(ex);
                          parent.onError(ex);
                      }
                                  }复制代码

首先1处创建了一个CreateEmitter 在rxjava中每个方法几乎都会创建自己的Emitter对象接下来看看这类的声明

static final class CreateEmitter<T>
                extends AtomicReference<Disposable>
                implements ObservableEmitter<T>, Disposable {}复制代码

这个类是ObservableEmitter的子类 接下来执行2 即observer的onSubscribe()方法                接下来3 在下面可知source是ObservableOnSubscribe对象

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
        }
}
复制代码

 在最上面一段代码中可以看到，我们在Create（）方法参数的subscribe()回调中调用了emitter.onNext(1)  emitter.onComplete()方法

接下来看下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方法。

这样一套Create() 和 Subscribe()方法的流程就走完了