Rxjava 流程分析

Observable的創建流程分析

首先看一張Rxjava的時序圖：

step1.Observable.create
在我們的使用案例中，第一步創建一個Observable對象，我們是通過Observable的Create方法來創建一個Observable實例, 我們就從這個方法開始深入源碼分析Observeble的創建過程；
實質上這就包括了上面時序圖中的兩步，先創建一個ObservableOnSubscribe(這是一個接口)實例，它是具有subscribe方法的函數接口，該方法接收ObservableEmitter實例，該實例允許以取消安全的方式推送事件
所以會通過new ObservableOnSubscribe()創建一個匿名內部類，裏面就一個方法,也是我們實現的那個方法：

         new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                if (!emitter.isDisposed()){
                    emitter.onNext("發射一條消息：");
                    emitter.onNext("你好！Rxjava");
                }
                emitter.onComplete();

            }
        }

ObservableEmitter也是一個接口。裏面方法很多，它也繼承了 Emitter 接口。


public interface ObservableEmitter<T> extends Emitter<T> {
    //設置事件流的控制器，用於控制事件流取消
	void setDisposable(@Nullable Disposable d);
	//類似Disposable的功能  取消事件
	void setCancellable(@Nullable Cancellable c);
	//判斷是否中斷了
	boolean isDisposed();
	//序列化
	ObservableEmitter<T> serialize();
	//嘗試去發送一個錯誤的事件流
	boolean tryOnError(@NonNull Throwable t);
}

public interface Emitter<T> {
	void onNext(T value);
	void onError(Throwable error);
	void onComplete();
}

Emitter定義了我們在Observer裏最常用的三個方法

其次纔將該匿名內部類實例作爲參數傳遞調用create方法

public abstract class Observable<T> implements ObservableSource<T> {
	......
 @CheckReturnValue
    @NonNull
    @SchedulerSupport(SchedulerSupport.NONE)
    //通過Observable的create方法創建一個冷的Observable 需要傳一個ObservableOnSubscribe的參數
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
    	//非空斷言 source不能爲null，爲null拋出異常
        ObjectHelper.requireNonNull(source, "source is null");
        //Observable是abstract的抽象類  ObservableCreate是其一個實現類
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
	......
}

step2.new ObservableCreate(source)
創建一個Observable的實現類，這個類纔是真正處理訂閱以及分發事件的類；
具體是怎麼實現訂閱等後續分析

step3.RxJavaPlugins.onAssembly(ObservableCreate)

 /**
     * Calls the associated hook function.
     * 調用關聯的鉤子函數
     * @param <T> the value type
     * @param source the hook's input value
     * @return the value returned by the hook
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    @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 的值不爲空，那麼就調用這個鉤子函數，onObservableAssembly 是一個靜態變量，需要我們主動的去設置纔會賦值，這裏當做空來考慮，如果 onObservableAssembly 爲空的話，也就是說這個方法啥都沒做，直接返回 source 參數，也就是上面的 ObservableCreate 對象，在大多數情況下，這個函數返回的還是函數傳入的參數source；

step4 返回Observeble
在經過前面三步，我們可以發現Observeble的create方法，在沒有異常及Hook處理的情況下，返回的就是在step2中創建的ObservableCreate對象，也正是在這個類中我們可以觀察到訂閱以及對其他事件的處理

Rxjava的訂閱流程以及事件處理分析

訂閱流程時序圖：

然後根據時序圖我們從源碼分析訂閱流程：
step1:Observable.subscribe(Observer)
在對Rxjava的使用中就是通過調用該方法實現觀察者訂閱被觀察者，那麼具體是如何實現？
看該方法的源碼實現：

public abstract class Observable<T> implements ObservableSource<T> {
	......
	@SchedulerSupport(SchedulerSupport.NONE)
	@Override
	public final void subscribe(Observer<? super T> observer) {
	     //非空斷言 observer不能爲NULL
	     ObjectHelper.requireNonNull(observer, "observer is null");
	     try {
	     	// 鉤子函數，方便Hook實現
            observer = RxJavaPlugins.onSubscribe(this, observer);
            //因爲如果存在Hook的話 可能會對observer修改，所以修改再進行一次非空斷言
            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);
        } 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;
        }
	}
	......
}

step2：subscribeActual
直接上源碼：

public abstract class Observable<T> implements ObservableSource<T> {
	......
	 /**
     * Operator implementations (both source and intermediate) should implement this method that
     * performs the necessary business logic and handles the incoming {@link Observer}s.
     * <p>There is no need to call any of the plugin hooks on the current {@code Observable} instance or
     * the {@code Observer}; all hooks and basic safeguards have been
     * applied by {@link #subscribe(Observer)} before this method gets called.
     * @param observer the incoming Observer, never null
     */
    protected abstract void subscribeActual(Observer<? super T> observer);
	......
}

這是一個抽象方法，那麼必然需要尋找對應實現該方法的子類；
看上面Observable的創建流程，返回的Observeble是一個ObservableCreate對象，因此我們去這個類中找真正的實現：

public final class ObservableCreate<T> extends Observable<T> {
    //這個就是創建流程中傳遞的ObservableOnSubscribe的一個匿名實現類
    final ObservableOnSubscribe<T> source;
	......
	@Override
    protected void subscribeActual(Observer<? super T> observer) {
        //創建了一個發射器CreateEmitter，這個CreateEmitter很眼熟 就是創建流程中ObservableEmitter的實現類，也就是負責具體的事件分發以及控制處理的類
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        //通知觀察者 已經產生了訂閱
        observer.onSubscribe(parent);
        try {
            //回調通知被觀察者訂閱關係已經建立，並提供一個發射器工具發送數據
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
	......
}

step3:CreateEmitter實現

static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {
        private static final long serialVersionUID = -3434801548987643227L;
        //觀察者對象
        final Observer<? super T> observer;
        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }
        @Override
        public void onNext(T t) {
            //接收到被觀察發送的oNext事件
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            //如果沒有Disposable 也就是控制流沒有被中斷
            if (!isDisposed()) {
                //通知觀察 收到onNext事件
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                RxJavaPlugins.onError(t);
            }
        }
        @Override
        public boolean tryOnError(Throwable t) {
            if (t == null) {
                t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
            }
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
                return true;
            }
            return false;
        }
        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }
       @Override
        public void setDisposable(Disposable d) {
            DisposableHelper.set(this, d);
        }
        @Override
        public void setCancellable(Cancellable c) {
            setDisposable(new CancellableDisposable(c));
        }
        @Override
        public ObservableEmitter<T> serialize() {
            return new SerializedEmitter<T>(this);
        }
        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        @Override
        public String toString() {
            return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
        }
    }

這也就回答了上面爲什麼說ObserverCreate是真正實現事件分發處理的類，因爲提供一個Emitter去完成這些工作；
從源碼中我們可以看到主要就是兩部分：
一部分是對Emitter功能的處理：
也就是Observer中最常用的三個方法，看實現也只是做了一層包裝做了一些對控制邏輯的判斷最終調用的還是觀察者的onNext onComplete以及onError;
另外一部分就是對事件的邏輯控制：提供中斷方法提供設置Disposable 和Cancellable 實現對事件的控制，提供對事件中斷的判斷等。

step4:source.subscribe
訂閱關係已經建立，通過創建被觀察者時傳入的回調接口通知被觀察者，同時提供了一個發射器用於發射數據

Rxjava 流程分析

Observable的創建流程分析

Rxjava的訂閱流程以及事件處理分析

總結：Rxjava的調用鏈

註解第二部分原理分析和註解處理器

Rxjava入門：簡單介紹與使用(一)

Java泛型定義和基本使用筆記

View第一部分自定義View 簡單介紹及使用

Rxjava 流程分析

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結