RxJava 簡單來說 , 是一個很靈活切換線程的褲子 .
- 簡單試例
- 源碼解讀試例
- 變換思想圖解
- 變換思想總結
1 、 簡單試例
Observable.just("url")//
.map(new Function<String, Long>() {
@Override
public Long apply(@NonNull String s) throws Exception {
return 1l;
}
})
.map(new Function<Long, Integer>() {
@Override
public Integer apply(@NonNull Long l) throws Exception {
return 50;
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(@NonNull Disposable d) {
}
@Override
public void onNext(@NonNull Integer integer) {
Log.i("Info","onNext:"+integer);
}
@Override
public void onError(@NonNull Throwable e) {
Log.i("Info","異常:"+e.getLocalizedMessage());
e.printStackTrace();
}
@Override
public void onComplete() {
}
});
打印:nNext:50
2 、 源碼解讀實例
創建 ObservableJust 對象
public static <T> Observable<T> just(T item) {
ObjectHelper.requireNonNull(item, "The item is null");
//這里其實是直接返回ObservableJust對象 .
return RxJavaPlugins.onAssembly(new ObservableJust<T>(item));
}
public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
//默認情況下 onObservableAssembly 為空 , 需要全局傳入
Function<? super Observable, ? extends Observable> f = onObservableAssembly;
if (f != null) {
return apply(f, source);
}
return source;
}
RxJavaPlugins.onAssembly 這里起到了 Hook 作用 , 加多了一層 , 可以用于 Fliter 例如
RxJavaPlugins.setOnObservableAssembly(new Function<Observable, Observable>() {
@Override
public Observable apply(@NonNull Observable observable) throws Exception {
Log.i("Info","Hook 創建對象 Observable ");
if(observable instanceof ObservableJust && !((((ObservableJust)(observable)).call()) instanceof String) ){
return null;
}
return observable;
}
});
//再一次運行上面的例子就是打印出:Hook 創建對象 Observable
使得所有屬于全局 ObservableJust 的 value 非 String 類型都無法正常創建 . 下面進入重點變換
變換也是一樣加了一層全局 Hook . 這里直接默認返回 new ObservableMap<T, R>(this, mapper)即可
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
ObservableMap 也是 Observable 的一個子類 , 把 ObservableJust 和 變換函數 Function 傳進去創建 ObservableMap , 下一個 ObservableMap 走相同邏輯 , 這樣就形成 ObservableJust(1) ∈ ObservableMap(2)
∈ ObservableMap(3) 的關系 (∈屬于) 典型的責任鏈模式 . 上面例子邏輯走到 ···(A).subscribe(new Observer<Integer>()··· (A)處的對象為ObservableMap(3) , 發生訂閱 . 繼續查看源碼
public final void subscribe(Observer<? super T> observer) {
···· 省略N多邏輯
subscribeActual(observer);
subscribeActual是一個抽象方法 , 查看子類 ObservableMap 實現該方法
public void subscribeActual(Observer<? super U> t) {
//這里的source為ObservableMap(2)對象
source.subscribe(new MapObserver<T, U>(t, function));
}
source 調用 subscribe 跟 ObservableMap(3) 執行相同邏輯 , 這里的 source 指的是 ObservableMap(2) 對象 , 這樣就形成了(有序序列). MainActivity 里的 內部類 Observer 被包裝了一層 MapObserver 當成參數往上傳形成了鏈表 MapObserver(3) --> MapObserver(2) --> Observer(1) .
最終回到 ObservableJust 發生訂閱把數據源于流的形式一層一層發射 , 見
//ObservableJust 的subscribeActual 方法
protected void subscribeActual(Observer<? super T> s) {
Log.i("Info","subscribeActual 發射 ");
//這里的s 是MapObserver(3)對象
ScalarDisposable<T> sd = new ScalarDisposable<T>(s, value);
//observer 的 onSubscribe 方法被回調
s.onSubscribe(sd);
sd.run();
}
public void run() {
if (get() == START && compareAndSet(START, ON_NEXT)) {
//正式發射數據源
observer.onNext(value);
if (get() == ON_NEXT) {
lazySet(ON_COMPLETE);
observer.onComplete();
}
}
}
數據源發射 MapObserver(3).onNext() --(Function變換)--> MapObserver(2).onNext() --(Function 變換)-->Observer(1).onNext() .
3 、 變換思想圖解
說明 : subscribe 是發生在 Observable 里面調用subscribeActual , 內部創建 MapObserver 包裝對象 Observer , 傳給父級Observable . source.subscribe(new MapObserver<T, U>(t, function));
4、 變換思想總結.
變換是 RxJava 最核心思想 , RxJava 源碼比較繞 , 但是萬變不離其中 , 包括線程調度 subscribeOn() 和 observeOn() 也是利用變換 .
