一圖理解Rxjava2底層機制

Rxjava是一種響應式編程實現,響應式編程就是定義業務邏輯關係

   比如正常的編程b = a + 1;這個是一個指令。執行到這裏的時候,b的值已經被計算出來了

   如果b <= a + 1;這是定義b和a的關係,具體的值還沒有,直到 a.onNext(1);

Rxjava 訂閱和事件分發機制

    Rxjava其實就是一個通過Observable的subcribe向上通知和onNext向下彙報事件的過程,最後交給observer處理。

具體調用流程如下:

1.public final Disposable subscribe(Consumer<? super T> onNext)

2.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError)

3.public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError,

        Action onComplete, Consumer<? super Disposable> onSubscribe)

4.public final void subscribe(Observer<? super T> observer);


上面1~3的接口會被封裝爲Observer的LambdaObserver,然後調用4.subscribe(Observer<? super T> observer),

 

 

Rxjava鏈式調用

 

    由於RXjava支持鏈式調用,從而讓observable形成一個observable雙向鏈表,Observable的source引用上一個Observable,並創建一個observer給上一個Observable引用,從而使得上一個obserable能夠回調回來,形成向上的鏈條,進而形成一個雙向鏈表。

具體到一個案例:

Observable.create(new ObservableOnSubscribe<Integer>() {
	@Override
	public void subscribe(ObservableEmitter<Integer> e) throws Exception {
		e.onNext(1);
		e.onNext(2);
		e.onNext(3);
	}
}).map(new Function<Integer, Student>() {
	@Override
	public Student apply(Integer id) throws Exception {
		return new Student(id);
	}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
	@Override
	public ObservableSource<Course> apply(Student student) throws Exception {
		return Observable.just(new Course("math", student), new Course("eng", student));
	}
}).lift(new ObservableOperator<String, Course>(){
	@Override
	public Observer<? super Course> apply(final Observer<? super String> actual) {
		return new Observer<Course>() {

			@Override
			public void onSubscribe(Disposable d) {
				actual.onSubscribe(d);
			}

			@Override
			public void onComplete() {
				actual.onComplete();
			}

			@Override
			public void onError(Throwable e) {
				actual.onError(e);
			}

			@Override
			public void onNext(Course course) {
				actual.onNext(course.getScore());
			}
		};
	}
}).subscribe(new Consumer<String>() {
	@Override
	public void accept(String score) throws Exception {
	}
});

 

我們來分段分析:

Observable.create(new ObservableOnSubscribe<Integer>() {
	@Override
	public void subscribe(ObservableEmitter<Integer> e) throws Exception {
		e.onNext(1);
		e.onNext(2);
		e.onNext(3);
	}
}).map(new Function<Integer, Student>() {
	@Override
	public Student apply(Integer id) throws Exception {
		return new Student(id);
	}
}).flatMap(new Function<Student, ObservableSource<Course>>() {
	@Override
	public ObservableSource<Course> apply(Student student) throws Exception {
		return Observable.just(new Course("math", student), new Course("eng", student));
	}
}).lift(new ObservableOperator<String, Course>(){
	@Override
	public Observer<? super Course> apply(final Observer<? super String> actual) {
		return new Observer<Course>() {

			@Override
			public void onSubscribe(Disposable d) {
				actual.onSubscribe(d);
			}

			@Override
			public void onComplete() {
				actual.onComplete();
			}

			@Override
			public void onError(Throwable e) {
				actual.onError(e);
			}

			@Override
			public void onNext(Course course) {
				actual.onNext(course.getScore());
			}
		};
	}
})

在調用subscrible之前,只構造了source這個單向鏈表

 

 

當執行最後面的subscribe

.subscribe(new Consumer<String>() {

    @Override

    public void accept(String score) throws Exception {

    }

});

會從下到上一直調用subscrible直到最頂層的ObservableOnSubscribe的subscrible

new ObservableOnSubscribe<Integer>() {

    @Override

    public void subscribe(ObservableEmitter<Integer> e) throws Exception {

        //這個函數是最後一個subscribe

        e.onNext(1);

        e.onNext(2);

        e.onNext(3);

    }

}

subscrible這個向上調用的過程就是構造Observer的過程,會構造每一層的ObserverWrap,比如最先構造OperatorObserver,最後構造CreateEmitter。

 

然後下面的代碼會從上往下一路調用前面構造的Observer.

   public void subscribe(ObservableEmitter<Integer> e) throws Exception {

        //如果我們將這個e保存爲全局變量,就可以在任意地點任意時間激發事件了

        e.onNext(1);

        e.onNext(2);

        e.onNext(3);

   }

調用圖如下:

 

 

concatMap如何保證事件的時序

    我們知道flatmap和concatMap都支持新增observable發射新的事件, 但是flatmap沒法保證時序,而concatMap保證時序

concatmap保證時序的原因是它每次調用Obserable.subscribe後會等到onSubscribe調用onComplete,然後纔會調用下一個Obserable.subscribe,從而保證了時序。

    具體源碼如下:

class SourceObserver {
         @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            if (fusionMode == QueueDisposable.NONE) {
                //先都放在隊列
                queue.offer(t);
            }
            //只能一個一個處理
            drain();
        }

        void drain() {
            if (getAndIncrement() != 0) {
                return;
            }

            for (;;) {
                if (disposed) {
                    queue.clear();
                    return;
                }
                //保證了只能一個一個處理
                if (!active) {

                    boolean d = done;

                    T t;

                    try {
                        t = queue.poll();
                    } catch (Throwable ex) {
                        Exceptions.throwIfFatal(ex);
                        dispose();
                        queue.clear();
                        downstream.onError(ex);
                        return;
                    }

                    boolean empty = t == null;

                    if (d && empty) {
                        disposed = true;
                        downstream.onComplete();
                        return;
                    }

                    if (!empty) {
                        ObservableSource<? extends U> o;
                        active = true;
                        o.subscribe(inner);
                    }
                }

                if (decrementAndGet() == 0) {
                    break;
                }
            }
        }


    InnerObserver {
            @Override
            public void onComplete() {
                parent.innerComplete();
            }
    }

    void innerComplete() {
            active = false;
            //drain會執行下一個source.subscribe
            drain();
    }

附錄

     Rxjava是一個鏈式數據處理的框架,且通過observable和observer兩種鏈接組件,能夠將其他observable和observer像搭積木的方式組合成複雜的功能,實現模塊化和解耦合的效果。

     Rxjava的常用操作

/**************************************************
* 本文來自CSDN博主"一點碼客",喜歡請頂部點擊關注
* 轉載請標明出處:http://blog.csdn.net/itchosen
***************************************************/

如需實時查看更多更新文章,請關注公衆號"一點碼客",一起探索技術

發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章