【RxJava 系列】RxJava 學習與理解
【1】JAVA 泛型強化
<? extends T> : 上界通配符
<? super T> : 下界通配符
<? extends C> : 上界爲 C 類型範圍粗略理解爲 [C,+∞)，不允許添加除 null 的元素，獲取的元素類型是 C;
<? super C> : 下界爲 C 類型範圍粗略理解爲 (-∞,C]，允許添加 C 以及 C 的子類類型的元素，獲取的元素類型是 Object;
繼承圖示
代碼示例
public class Test<T> {
private T t;
public void add(T t) {
this.t = t;
}
public T get() {
return t;
}
}
/**
* extends 上限 Person or Person 的所有子類都可以， 最高的類型只能是 Person，把最高的類型給限制住了
* @param test
* @param <T>
*/
public static <T> void show1(Test<? extends Person> test) {
// test.add(new Person()); // 不可寫
}
// 下面時 上限 和 下限 的測試
// show1(new Test<Object>()); // Person 的父類，會報錯
show1(new Test<Person>());
show1(new Test<Student>());
show1(new Test<Worker>());
show1(new Test<WorkerStub>());
/**
* super 下限 Student or Student 的所有父類都可以， 最低的類型只能是 Student，把最低的類型給限制住了
* @param test
* @param <T>
*/
public static <T> void show2(Test<? super Student> test) {
test.add(new Student());
}
// show2(new Test<WorkerStub>()); // 因爲最低限制的子類 Student，不能在低，不能是 Student 的子類了
// show2(new Test<StudentStub>()); // 因爲最低限制的子類 Student，不能在低，不能是 Student 的子類了
show2(new Test<Student>());
show2(new Test<Person>()); // 父類
show2(new Test<Object>()); // 父類
// 可讀模式
Test<? extends Person> test1 = null;
// test1.add(new Person()); // 不可寫
// test1.add(new Student()); // 不可寫
// test1.add(new Object()); // 不可寫
// test1.add(new Worker()); // 不可寫
Person person = test1.get(); // 可讀
// 可寫模式 不完全可讀
Test<? super Person> test = null;
test.add(new Person()); // 可寫
test.add(new Student()); // 可寫
test.add(new Worker()); // 可寫
Object object = test.get(); // 不完全可讀
【2】觀察者模式
代碼示例
被觀察者
// 被觀察者 (接口)
public interface Observable {
/**
* 在被觀察者中 註冊 觀察者
*/
void registerObserver(Observer observer);
/**
* 在被觀察者中 移除 觀察者
*/
void removeObserver(Observer observer);
/**
* 在被觀察者中 通知 所有註冊的 觀察者
*/
void notifyObservers();
}
// 被觀察者 (實現類)
public class ObservableImpl implements Observable {
// 觀察者容器
private List<Observer> observerList = new ArrayList<>();
// 註冊觀察者
@Override
public void registerObserver(Observer observer) {
observerList.add(observer);
}
// 移除觀察者
@Override
public void removeObserver(Observer observer) {
observerList.remove(observer);
}
// 被觀察者發生變化通知所有觀察者
@Override
public void notifyObservers() {
for (Observer observer : observerList) {
// 在被觀察者實現類中，通知所有註冊好的觀察者
observer.changeAction("被觀察者 發生了改變...");
}
}
}
觀察者
// 觀察者 (接口)
public interface Observer {
/**
* 收到 被觀察者 發生改變
* @param observableInfo
* @param <T>
*/
<T> void changeAction(T observableInfo);
}
// 觀察者 (實現類)
public class ObserverImpl implements Observer {
@Override
public <T> void changeAction(T observableInfo) {
System.out.println(observableInfo);
}
}
public static void main(String[] args) {
Observer observer_1 = new ObserverImpl(); // 觀察者 1
Observer observer_2 = new ObserverImpl(); // 觀察者 2
Observer observer_3 = new ObserverImpl(); // 觀察者 3
Observer observer_4 = new ObserverImpl(); // 觀察者 4
Observer observer_5 = new ObserverImpl(); // 觀察者 5
// 被觀察者
Observable observable = new ObservableImpl();
// 關聯 註冊
observable.registerObserver(observer_1);
observable.registerObserver(observer_2);
observable.registerObserver(observer_3);
observable.registerObserver(observer_4);
observable.registerObserver(observer_5);
// 被觀察者發生改變
observable.notifyObservers();
}
【3】RxJava 之使用
代碼示例
Retrofit + OKHttp + RxJava 的基本使用 :
// Android 處理對話框
private ProgressDialog progressDialog;
public void request(View view) {
progressDialog = new ProgressDialog(this);
progressDialog.setMessage("正在執行中...");
/**
* 一行代碼 實現需求
* 需求：
* * 1.請求服務器註冊操作
* * 2.註冊完成之後，更新註冊 UI
* * 3.馬上去登錄服務器操作
* * 4.登錄完成之後，更新登錄的 UI
*/
// 創建 Retrofit， 創建註冊請求
MyRetrofit.createRetrofit().create(IRequestNetwork.class)
// 1. 請求服務器註冊操作
// Observable<RegisterResponse> 上游 被觀察者 耗時操作
.registerAction(new RegisterRequest())
// 給上游分配異步線程，在異步線程上訂閱
.subscribeOn(Schedulers.io())
// 在主線程上觀察，給下游切換主線程
.observeOn(AndroidSchedulers.mainThread())
// 2.註冊完成之後，更新註冊 UI
/**
* 這樣不能訂閱，如果訂閱了，就無法執行
* 3 馬上去登錄服務器操作
* 4.登錄完成之後，更新登錄的 UI
*
* 所以我們要去學習一個 .doOnNext()，可以在不訂閱的情況下，更新 UI
*/
// 執行下一步操作
.doOnNext(new Consumer<RegisterResponse>() {
@Override
public void accept(RegisterResponse registerResponse) throws Exception {
// 接收到上游的消息進行相關處理
// 更新註冊相關的所有 UI
tv_register_ui.setText("xxx");
// .......
}
})
// 3. 馬上去登錄服務器操作 -- 耗時操作
// 給上游分配異步線程，在異步線程上訂閱
.subscribeOn(Schedulers.io())
// 數據類型轉換處理
.flatMap(new Function<RegisterResponse, ObservableSource<LoginResponse>>() {
@Override
public ObservableSource<LoginResponse> apply(RegisterResponse registerResponse)
throws Exception {
// 還可以拿到 註冊後的響應對象 RegisterResponse
// 執行耗時操作
// 馬上去登錄服務器操作 -- 耗時操作
Observable<LoginResponse> observable = MyRetrofit.createRetrofit()
.create(IRequestNetwork.class)
.loginAction(new LoginRequest());
return observable;
}
})
// 在主線程上觀察，給下游切換主線程
// 4.登錄完成之後，更新登錄的 UI
.observeOn(AndroidSchedulers.mainThread())
// 下游訂閱處理
.subscribe(new Observer<LoginResponse>() {
@Override
public void onSubscribe(Disposable d) {
//訂閱時的回調處理
progressDialog.show();
}
@Override
public void onNext(LoginResponse loginResponse) {
// 更新登錄相關的所有 UI
tv_login_ui.setText("xxxx");
// ...........
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
// 結束對話框 ，整個流程完成
progressDialog.dismiss();
}
});
}
// 網絡請求操作接口
public interface IRequestNetwork {
// 請求註冊 功能 耗時操作 ---> OkHttp
public Observable<RegisterResponse> registerAction(@Body RegisterRequest registerRequest);
// 請求登錄 功能 耗時操作 ---> OKHttp
public Observable<LoginResponse> loginAction(@Body LoginRequest loginRequest);
}
// 登錄請求
public class LoginRequest {
}
// 登錄的響應
public class LoginResponse {
}
// 註冊請求
public class RegisterRequest {
}
// 註冊響應
public class RegisterResponse {
}
// 構建 Retrofit
public class MyRetrofit {
// 把 Retrofit 給 Build 出來
public static Retrofit createRetrofit() {
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.readTimeout(10, TimeUnit.SECONDS);
builder.connectTimeout(9, TimeUnit.SECONDS);
if (BuildConfig.DEBUG) {
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
builder.addInterceptor(interceptor);
}
// 構建者模式，構建 Retrofit 對象
return new Retrofit.Builder().baseUrl("http://xxxxxxx")
.client(builder.build())
.addConverterFactory(GsonConverterFactory.create())
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.build();
}
}
【4】RxJava 之 Create 方法
// 被觀察者 (接口)，上游
public interface ObservableOnSubscribe<T> {
// ? super T，T 或 T 的所有父類， 可寫
// observableEmitter : 觀察者
public void subscribe(Observer<? super T> observableEmitter);
}
// 觀察者(接口)，下游
public interface Observer<T> {
// 訂閱時回調
public void onSubscribe();
// 下一步時回調
public void onNext(T item);
// 產生錯誤時回調
public void onError(Throwable e);
// 處理完畢時回調
public void onComplete();
}
// 被觀察者， 上游
// 類聲明的泛型 T
public class Observable<T> implements ObservableOnSubscribe<T> {
ObservableOnSubscribe source;
private Observable(ObservableOnSubscribe source) {
this.source = source;
}
// create 方法 :
// 入參 :
// ObservableOnSubscribe<? extends T> source， ObservableOnSubscribe 接口變量
// 返回值 :
// Observable<T> 類型的變量
//
// 說明 :
// ? extends T : T 或 T 的所有子類，限制了最高類型，最高類型爲 T
// 該靜態方法聲明的 <T> 泛型 == ObservableOnSubscribe<T> (實現了 ObservableOnSubscribe<T> 接口)
// 參數中 : ObservableOnSubscribe<? extends T> 和可讀可寫模式沒有任何關係，僅僅影響類型的上限和下限
public static <T> Observable<T> create(ObservableOnSubscribe<? extends T> source) {
// 根據入參 source 新建 Observable<T> 類型的變量
// 構造函數中給 Observable<T> 內部成員變量 ObservableOnSubscribe source 賦值
return new Observable<T>(source);
}
@Override
public void subscribe(Observer<? super T> observableEmitter) {
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法，提示訂閱開始
observableEmitter.onSubscribe();
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)
// 實現 source 與觀察者的關聯
source.subscribe(observableEmitter);
}
}
// create 操作符
// 上游
// 1. create 是靜態方法，可以由類直接調用
// 2. ObservableOnSubscribe<Integer> : create 方法的入參類型爲 Integer 及其子類
// 3. ObservableOnSubscribe 爲接口，新建接口變量需要重寫接口中的方法
// 4. subscribe 方法入參類型爲 Observer<? super Integer>， Integer 及其父類
// 5. create 方法的返回值爲 Observable<T> 類型的變量
Observable.create(new ObservableOnSubscribe<Integer>() {
// 注 :
// 該 subscribe 方法是由 Observable<T> 類中的成員變量 ObservableOnSubscribe source 調用執行的
@Override
public void subscribe(Observer<? super Integer> observableEmitter) {
Log.d(TAG, "subscribe: 上游開始發射...");
// 發射事件 可寫的
// <? extends Integer> 不可寫
// <? super Integer> 可寫
// 步驟 2
observableEmitter.onNext(9);
// 步驟 4
observableEmitter.onComplete();
}
})
// 下游
// create 方法的返回值爲 Observable<T> 類型的變量，
// Observable<T> 類實現了 ObservableOnSubscribe<T> 接口
// Observable<T> 類型的變量可以調用 ObservableOnSubscribe<T> 接口的 subscribe 方法
// subscribe 方法的入參爲 Observer<? super T> observableEmitter，
此處新建了該接口類型變量並實現其中的方法
//
// 注 :
// 該 subscribe 方法是由 create 返回的 Observable<T> 類型的變量調用執行的
// 此處調用的 subscribe 方法是在 Observable<T> 類中重寫的
ObservableOnSubscribe<T> 接口的 subscribe 方法
//
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法實現訂閱通知
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)，實現上下游的連接，
從而可以執行上游 subscribe 方法
.subscribe(new com.netease.custom_rxjava.Observer<Integer>() {
// 實現接口方法
// 步驟 1
@Override
public void onSubscribe() {
Log.d(TAG, "已經訂閱成功，即將開始發射 onSubscribe: ");
}
// 實現接口方法
// 步驟 3
@Override
public void onNext(Integer item) {
Log.d(TAG, "下游接收事件 onNext: " + item);
}
// 實現接口方法
@Override
public void onError(Throwable e) {
}
// 實現接口方法
@Override
public void onComplete() {
// 步驟 5
Log.d(TAG, "onComplete: 下游接收事件完成");
}
});
【5】RxJava 之 Just 方法
// 被觀察者 (接口)，上游
public interface ObservableOnSubscribe<T> {
// ? super T，T 或 T 的所有父類， 可寫
// observableEmitter : 觀察者
public void subscribe(Observer<? super T> observableEmitter);
}
// 觀察者(接口)，下游
public interface Observer<T> {
// 訂閱時回調
public void onSubscribe();
// 下一步時回調
public void onNext(T item);
// 產生錯誤時回調
public void onError(Throwable e);
// 處理完畢時回調
public void onComplete();
}
// 被觀察者， 上游
public class Observable<T> implements ObservableOnSubscribe<T> {
ObservableOnSubscribe source;
private Observable(ObservableOnSubscribe source) {
this.source = source;
}
// 可變參數
public static <T> Observable<T> just(final T... t) {
// 新建 ObservableOnSubscribe<T> 接口對象並賦值給內部成員變量 ObservableOnSubscribe source
// 這樣可以確保 source 不爲 null， 而 create 操作符是使用者傳遞進來的
return new Observable<T>(new ObservableOnSubscribe<T>() {
// ObservableOnSubscribe<T> 是接口變量，需要重寫接口的方法
@Override
public void subscribe(Observer<? super T> observableEmitter) {
for (T t1 : t) {
// 步驟 2
// 發射用戶傳遞的參數數據 數據發射事件
observableEmitter.onNext(t1);
}
// 步驟 4
// 調用完畢 發射完畢事件
observableEmitter.onComplete();
}
});
}
@Override
public void subscribe(Observer<? super T> observableEmitter) {
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法，提示訂閱開始
observableEmitter.onSubscribe();
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)
// 實現 source 與觀察者的關聯
source.subscribe(observableEmitter);
}
}
// 上游
// just 方法入參爲待發送的數據， just 方法內部新建 ObservableOnSubscribe<T> 接口對象併發射數據
// just 方法返回 Observable<T> 類型對象
Observable.just("A", "B", "C", "D", "E", "F", "G")
// 訂閱
// Observable<T> 類實現了 ObservableOnSubscribe<T> 接口
// Observable<T> 類型的變量可以調用 ObservableOnSubscribe<T> 接口的 subscribe 方法
// subscribe 方法的入參爲 Observer<? super T> observableEmitter，
此處新建了該接口類型變量並實現其中的方法
// 注 :
// 該 subscribe 方法是由 just 返回的 Observable<T> 類型的變量調用執行的
// 此處調用的 subscribe 方法是在 Observable<T> 類中重寫的
ObservableOnSubscribe<T> 接口的 subscribe 方法
//
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法實現訂閱通知
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)，實現上下游的連接，
從而可以執行上游 subscribe 方法
.subscribe(new Observer<String>() {
@Override
public void onSubscribe() {
// 步驟 1
Log.d(TAG, "已經訂閱成功，即將開始發射 onSubscribe: ");
}
@Override
public void onNext(String item) {
// 步驟 3
Log.d(TAG, "下游接收事件 onNext: " + item);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
// 步驟 5
Log.d(TAG, "onComplete: ");
}
});
【6】RxJava 之 Map 方法
// map 變換操作符 RxJava 的核心
// 上游
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override // todo 6
public void subscribe(Observer<? super Integer> observableEmitter) {
Log.d(TAG, "subscribe: 上游開始發射...");
observableEmitter.onNext(9);
observableEmitter.onComplete();
}
})
.map(new Function<Integer, String>() {
// 新建 Function 接口對象實現其中的 apply 方法
// 在 apply 方法中實現變量類型的轉換功能
@Override
public String apply(Integer integer) {
Log.d(TAG, "第1個變換 apply: " + integer);
return "【" + integer + "】";
}
})
.map(new Function<String, StringBuffer>() {
// 新建 Function 接口對象實現其中的 apply 方法
// 在 apply 方法中實現變量類型的轉換功能
@Override
public StringBuffer apply(String s) {
Log.d(TAG, "第2個變換 apply: " + s);
return new StringBuffer().append(s).append("-----------------------");
}
})
.map(new Function<StringBuffer, StringBuffer>() {
// 新建 Function 接口對象實現其中的 apply 方法
// 在 apply 方法中實現變量類型的轉換功能
@Override
public StringBuffer apply(StringBuffer stringBuffer) {
return new StringBuffer(stringBuffer).append("√√√√√√√√√√√√√√√√√√√√√√√");
}
})
// 下游
// map 方法返回 Observable<R> 類型對象， 此處調用 Observable<R> 類型對象的 subscribe 方法
// 該 subscribe 在 Observable<R> 類中重寫
// 該 subscribe 方法入參爲新建的 Observer<? super T> 觀察者對象並實現了接口的方法
.subscribe(new com.netease.custom_rxjava.Observer<StringBuffer>() {
@Override
public void onSubscribe() {
Log.d(TAG, "已經訂閱成功，即將開始發射 onSubscribe: ");
}
@Override
public void onNext(StringBuffer item) {
Log.d(TAG, "下游接收事件 onNext: " + item);
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
Log.d(TAG, "onComplete: 下游接收事件完成");
}
});
// Observable<T> 類中的 subscribe 方法
@Override
public void subscribe(Observer<? super T> observableEmitter) {
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法，提示訂閱開始
observableEmitter.onSubscribe();
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)
// 實現 source 與觀察者的關聯
// 此處的 source 爲由 create / just 方法新建的被觀察對象，
// 在 map 方法中被賦值到了 ObservableMap 類的成員變量 ObservableOnSubscribe<T> source 中
source.subscribe(observableEmitter);
}
// ObservableMap<T, R> 類中的 subscribe 方法
@Override
public void subscribe(Observer<? super R> observableEmitter) {
// 將入參賦值給 ObservableMap<T, R> 類成員變量 observableEmitter， 指定觀察者
this.observableEmitter = observableEmitter;
// MapObserver<T> 實現了 Observer<T> 接口
// 新建一個 MapObserver<T> 變量並實現接口中的方法
MapObserver<T> mapObserver = new MapObserver(observableEmitter, source, function);
// 調用 Observable<T> 類中的 subscribe 方法， 遞歸調用，
// 直到調用到 create / just 方法中的 subscribe 方法
// 實現整個鏈路上的上下游的關聯
//
// 在 create / just 方法中的 Observer<? super T> 類型對象觸發 onNext 方法發射數據
// 從而鏈路上的 Observer<? super T> 類型對象層層觸發 onNext 方法向下傳遞數據
// 在 ObservableMap 的 onNext 方法中調用了
// R nextMapResultSuccesType = function.apply(item); 實現了對數據類型的轉換操作
source.subscribe(mapObserver);
}
/**
* map變換操作符
* T == 上一層傳遞過來的類型 變換前的類型
* R == 給下一層的類型 變換後的類型
*/
// ? super T 可寫模式
public <R> Observable<R> map(Function<? super T, ? extends R> function) {
// source 上一層被觀察的對象， source 由 create / just 方法新建的被觀察對象
ObservableMap<T, R> observableMap = new ObservableMap(source, function);
// 將 ObservableMap<T, R> observableMap 對象的成員變量
// ObservableOnSubscribe<T> source 賦值給 Observable<R> 的成員變量 source
return new Observable<R>(observableMap);
}
public class ObservableMap<T, R> implements ObservableOnSubscribe<R> {
// 上一層的被觀察對象
private ObservableOnSubscribe<T> source;
// 執行函數操作的接口
private Function<? super T, ? extends R> function;
// 下一層的觀察對象
private Observer<? super R> observableEmitter;
public ObservableMap(ObservableOnSubscribe source, Function<? super T, ? extends R> function) {
// 記錄上游被觀察對象
this.source = source;
// 記錄函數操作接口
this.function = function;
}
// ObservableMap<T, R> 類中的 subscribe 方法, 實現鏈路上下游的關聯操作
@Override
public void subscribe(Observer<? super R> observableEmitter) {
// 將入參賦值給 ObservableMap<T, R> 類成員變量 observableEmitter， 指定觀察者
this.observableEmitter = observableEmitter;
// MapObserver<T> 實現了 Observer<T> 接口
// 新建一個 MapObserver<T> 變量並實現接口中的方法
MapObserver<T> mapObserver = new MapObserver(observableEmitter, source, function);
// 調用 Observable<T> 類中的 subscribe 方法， 遞歸調用，
// 直到調用到 create / just 方法中的 subscribe 方法
// 實現整個鏈路上的上下游的關聯
//
// 在 create / just 方法中的 Observer<? super T> 類型對象觸發 onNext 方法發射數據
// 從而鏈路上的 Observer<? super T> 類型對象層層觸發 onNext 方法向下傳遞數據
// 在 ObservableMap 的 onNext 方法中調用了
// R nextMapResultSuccesType = function.apply(item); 實現了對數據類型的轉換操作
source.subscribe(mapObserver);
}
// 內部類 MapObserver
class MapObserver<T> implements Observer<T> {
// 下游觀察者對象
private Observer<? super R> observableEmitter;
// 上游被觀察者對象
private ObservableOnSubscribe<T> source;
// 函數處理接口對象
private Function<? super T, ? extends R> function;
// 構造函數，記錄三種對象
public MapObserver(Observer<? super R> observableEmitter,
ObservableOnSubscribe<T> source,
Function<? super T, ? extends R> function) {
this.observableEmitter = observableEmitter;
this.source = source;
this.function = function;
}
@Override
public void onSubscribe() {
}
@Override
public void onNext(T item) {
// 調用函數處理接口對象的 apply 方法實現相關操作
R nextMapResultSuccesType = function.apply(item);
// 調用下一層 onNext 方法，傳遞數據，實現鏈式操作
observableEmitter.onNext(nextMapResultSuccesType);
}
@Override
public void onError(Throwable e) {
observableEmitter.onError(e);
}
@Override
public void onComplete() {
observableEmitter.onComplete();
}
}
}
【7】RxJava 之線程切換
// 最頂端
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(Observer<? super Integer> observableEmitter) {
Log.d(TAG, "上游 subscribe: --- " + Thread.currentThread().getName());
observableEmitter.onNext(1);
}
})
.map(new Function<Integer, String>() {
@Override
public String apply(Integer integer) {
Log.d(TAG, "map 1 --- " + Thread.currentThread().getName());
return integer + ">>>";
}
})
.map(new Function<String, String>() {
@Override
public String apply(String s) {
Log.d(TAG, "map 2 --- " + Thread.currentThread().getName());
return s + "???";
}
})
// 給上游分配異步線程
.observables_On()
// 給下游分配Android主線程
.observers_AndroidMain_On()
// main 線程 訂閱
.subscribe(new Observer<String>() {
@Override
public void onSubscribe() {
}
@Override
public void onNext(String item) {
Log.d(TAG, "下游 onNext: --- " + Thread.currentThread().getName());
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
// 給所有上游分配異步線程
public Observable<T> observables_On() {
// 實例化 處理上游的線程操作符
return create(new ObservableOnIO(source));
}
// 給下游分配 Android 主線程
public Observable<T> observers_AndroidMain_On() {
// 實例化 處理下游的線程操作符
ObserverAndroidMain_On<T> observerAndroidMain_on = new ObserverAndroidMain_On(source);
return create(observerAndroidMain_on);
}
// Observable<T> 類中的 subscribe 方法
@Override
public void subscribe(Observer<? super T> observableEmitter) {
// 調用入參 observableEmitter (觀察者) 的 onSubscribe 方法，提示訂閱開始
observableEmitter.onSubscribe();
// 調用成員變量 source 的 subscribe 訂閱 observableEmitter (觀察者)
// 實現 source 與觀察者的關聯
// 此處的 source 爲由 create / just 方法新建的被觀察對象，
// 在 map 方法中被賦值到了 ObservableMap 類的成員變量 ObservableOnSubscribe<T> source 中
source.subscribe(observableEmitter);
}
// ObservableOnIO<T> 中的 subscribe 方法
@Override
public void subscribe(final Observer<? super T> observableEmitter) {
// 是主線程
// source.subscribe(observableEmitter);
// 用線程池的目的， 是爲了讓所有上游全部都在線程池中異步運行
// 在線程池中執行 subscribe 訂閱方法， 關聯上游對象，
// 使得該處理鏈路處於線程池中，從而異步執行
EXECUTOR_SERVICE.submit(new Runnable() {
@Override
public void run() {
// 線程池裏面所執行的了
source.subscribe(observableEmitter);
}
});
}
// ObserverAndroidMain_On<T> 中的 subscribe 方法
@Override
public void subscribe(Observer<? super T> observableEmitter) { // == Observer
// 包裹是爲了，往下執行的時候，優先執行我們的 包裹
PackageObserver<T> packageObserver = new PackageObserver(observableEmitter);
// 把包裹交給 source
source.subscribe(packageObserver);
}
// 上游處理 異步線程的 Observable 的子類 給所有上游 切換異步線程
public class ObservableOnIO<T> implements ObservableOnSubscribe<T>{
// 線程池， 緩存功能的線程池
private final static ExecutorService EXECUTOR_SERVICE = Executors.newCachedThreadPool();
// 拿到上游被觀察對象
private ObservableOnSubscribe<T> source;
// 構造函數記錄上游被觀察對象
public ObservableOnIO(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
public void subscribe(final Observer<? super T> observableEmitter) {
// 是主線程
// source.subscribe(observableEmitter);
// 用線程池的目的， 是爲了讓所有上游全部都在線程池中異步運行
// 在線程池中執行 subscribe 訂閱方法， 關聯上游對象，
// 使得該處理鏈路處於線程池中，從而異步執行
EXECUTOR_SERVICE.submit(new Runnable() {
@Override
public void run() {
// 線程池裏面所執行的了
source.subscribe(observableEmitter);
}
});
}
}
// 給所有下游 切換 Android 主線程線程
public class ObserverAndroidMain_On<T> implements ObservableOnSubscribe<T>{
// 上游被觀察對象
private ObservableOnSubscribe<T> source;
// 構造函數記錄上游被觀察對象
public ObserverAndroidMain_On(ObservableOnSubscribe<T> source) {
this.source = source;
}
@Override
public void subscribe(Observer<? super T> observableEmitter) { // == Observer
// 包裹是爲了，往下執行的時候，優先執行我們的 包裹
PackageObserver<T> packageObserver = new PackageObserver(observableEmitter);
// 把包裹交給 source
source.subscribe(packageObserver);
}
// 內部類 PackageObserver
private final class PackageObserver<T> implements Observer<T> {
// 下游觀察對象
private Observer<T> observer;
public PackageObserver(Observer<T> observer) {
this.observer = observer;
}
@Override
public void onSubscribe() {}
@Override
public void onNext(final T item) {
// Handler
// 獲取主循環， 在主循環上執行 runnable， 實現線程切換到主線程
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
// 變成 Android main 線程
observer.onNext(item);
}
});
}
@Override
public void onError(final Throwable e) {
// Handler
// 獲取主循環， 在主循環上執行 runnable， 實現線程切換到主線程
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
// 變成 Android main線程
observer.onError(e);
}
});
}
@Override
public void onComplete() {
// Handler
// 獲取主循環， 在主循環上執行 runnable， 實現線程切換到主線程
new Handler(Looper.getMainLooper()).post(new Runnable() {
@Override
public void run() {
// 變成 Android main線程
observer.onComplete();
}
});
}
}
}
參考致謝
本博客爲博主的學習實踐總結，並參考了衆多博主的博文，在此表示感謝，博主若有不足之處，請批評指正。