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,原理跟上面的差不多就不多解釋.