Rxjava从使用到原码的解析十一: Rxjava创建操作符原码解析

被观察者Observable 实现了ObservableSource接口,泛型为T,

从Observable.create方法可以看出,create这个方法一定是一个静态的,代码好下

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

  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;
    }

从上面代码可以看出,当.create的时候其实就是new 了一个ObservableCreate,ObservableCreate是继承Observable,也就是直接创建了一个被观察者.

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

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

从ObservableCreate的构造方法中传入了ObservableOnSubscribe,这是一个接口里面有个方法

void subscribe(ObservableEmitter<T> e) throws Exception;

所以每当我们用create创建一个Observable的时候就会实现这个方法,完整代码如下

        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Log.e(TAG, "上游开始发射事件 1");
                e.onNext("1");
                Log.e(TAG, "上游发射事件 完成 ");
            }
        });

这样就构建出了一个被观察者,上游就创建完了.

接下来就是下游Observer

Observer是一个接口里面有4个方法

void onSubscribe(Disposable d);  void onNext(T t);  void onError(Throwable e);   void onComplete();

当我们执行subscribe这个方法的时候,就把观察者和被观察者关联起来,删除无用代码,看起来就简单多了

    public final void subscribe(Observer<? super T> observer) {
      
        try {
            ...
            subscribeActual(observer);
            ...
        } catch (NullPointerException e) { 
          
        } catch (Throwable e) {    
            throw npe;
        }
    }

而 subscribeActual(observer);在Observable里是一个抽象方法,所以是由子类来实现的,而这个时候子类是ObservableCreate

    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(发射器),也就是用来发送onNext,onError,onComplete事件的

第二步: 执行了 observer.onSubscribe(parent),也就是当我们上下游关联的时候,执行下游的第一个方法代表着关联成功.

第三步: source.subscribe(parent); 这个source是什么,source就是在我们create方法里传入的一个接口,下面这个

public interface ObservableOnSubscribe<T> {
    void subscribe(ObservableEmitter<T> e) throws Exception;
}

也就是执行了这接口里面的方法,关把发射器当做参数给传过来,也就是执行了下面代码里面的onNext()

        Observable<String> observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> e) throws Exception {
                Log.e(TAG, "上游开始发射事件 1");
                e.onNext("1");
                Log.e(TAG, "上游发射事件 完成 ");
            }
        });

那么上游发射的事件怎么到下游接收呢,下游的第一个事件onSubscribe我们知道就是关联成功就会调用,那么onNext,onError几个事件在哪里调用的,这就得返回到我们创建发射器的这行代码  CreateEmitter<T> parent = new CreateEmitter<T>(observer);

 

CreateEmitter是 ObservableCreate的一个静态内部类,当们们创建它的时候就把我们的observer观察都给当当参数给传入,再来看看CreateEmitter里面的方法

     public void onNext(T t) {

            if (!isDisposed()) {
                observer.onNext(t);
            }

        @Override
        public void onError(Throwable t) {
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
            } else {
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

很明显当我们执行发射器的时候直接就调用的观察者的方法,这样每当上游发射事件的时候,下流就能收到相应事件

而just操作符就是内部执行了create方法创建Observable,当数量为一个的时候就是创建ObservableJust被观察者,多个的话就是

通过fromArray来执行,他里面创建的是ObservableFromArray,原理跟上面的差不多就不多解释.