Android RxJava：這是一份RxJava使用入門學習指南

Carson_Ho發表於2018-06-09

前言

Rxjava由於其基於事件流的鏈式呼叫、邏輯簡潔 & 使用簡單的特點，深受各大 Android開發者的歡迎。

如果還不瞭解RxJava，請看文章：Android：這是一篇清晰 & 易懂的Rxjava 入門教程

今天，我將為初學者帶來 RxJava的基本使用，希望大家會喜歡。

本系列文章主要基於 Rxjava 2.0

接下來的時間，我將持續推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、應用場景、背壓等等 ，有興趣可以繼續關注Carson_Ho的安卓開發筆記！！

1. RxJava簡介

此處簡單介紹RxJava

若還不瞭解RxJava，請看文章：Android：這是一篇清晰 & 易懂的Rxjava 入門教程

2. 基本使用

本文只關注 RxJava的基本使用，更深入的RxJava使用請繼續關注Carson_Ho的RxJava系列
Rxjava的使用方式有兩種：
1. 分步驟實現：該方法主要為了深入說明Rxjava的原理 & 使用，主要用於演示說明
2. 基於事件流的鏈式呼叫：主要用於實際使用

2.1 方式1：分步驟實現

2.1.1 使用步驟

2.1.2 步驟詳解

步驟1：建立被觀察者（`Observable` ）& 生產事件

即顧客入飯店 - 坐下餐桌 - 點菜
具體實現

        // 1. 建立被觀察者 Observable 物件
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
          // create() 是 RxJava 最基本的創造事件序列的方法
          // 此處傳入了一個 OnSubscribe 物件引數
          // 當 Observable 被訂閱時，OnSubscribe 的 call() 方法會自動被呼叫，即事件序列就會依照設定依次被觸發
          // 即觀察者會依次呼叫對應事件的複寫方法從而響應事件
          // 從而實現被觀察者呼叫了觀察者的回撥方法 & 由被觀察者向觀察者的事件傳遞，即觀察者模式

        // 2. 在複寫的subscribe（）裡定義需要傳送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 通過 ObservableEmitter類物件產生事件並通知觀察者
                // ObservableEmitter類介紹
                    // a. 定義：事件發射器
                    // b. 作用：定義需要傳送的事件 & 向觀察者傳送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

<--擴充套件：RxJava 提供了其他方法用於 建立被觀察者物件Observable -->
// 方法1：just(T...)：直接將傳入的引數依次傳送出來
  Observable observable = Observable.just("A", "B", "C");
  // 將會依次呼叫：
  // onNext("A");
  // onNext("B");
  // onNext("C");
  // onCompleted();

// 方法2：from(T[]) / from(Iterable<? extends T>) : 將傳入的陣列 / Iterable 拆分成具體物件後，依次傳送出來
  String[] words = {"A", "B", "C"};
  Observable observable = Observable.from(words);
  // 將會依次呼叫：
  // onNext("A");
  // onNext("B");
  // onNext("C");
  // onCompleted();

複製程式碼

步驟2：建立觀察者（`Observer` ）並定義響應事件的行為

即開廚房 - 確定對應菜式
發生的事件型別包括：Next事件、Complete事件 & Error事件。具體如下：

具體實現


<--方式1：採用Observer 介面 -->
        // 1. 建立觀察者 （Observer ）物件
        Observer<Integer> observer = new Observer<Integer>() {
        // 2. 建立物件時通過對應複寫對應事件方法 從而 響應對應事件

            // 觀察者接收事件前，預設最先呼叫複寫 onSubscribe（）
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始採用subscribe連線");
            }
            
            // 當被觀察者生產Next事件 & 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件作出響應" + value);
            }

            // 當被觀察者生產Error事件& 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }
          
            // 當被觀察者生產Complete事件& 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        };

<--方式2：採用Subscriber 抽象類 -->
// 說明：Subscriber類 = RxJava 內建的一個實現了 Observer 的抽象類，對 Observer 介面進行了擴充套件

// 1. 建立觀察者 （Observer ）物件
Subscriber<String> subscriber = new Subscriber<Integer>() {

// 2. 建立物件時通過對應複寫對應事件方法 從而 響應對應事件
            // 觀察者接收事件前，預設最先呼叫複寫 onSubscribe（）
            @Override
            public void onSubscribe(Subscription s) {
                Log.d(TAG, "開始採用subscribe連線");
            }

            // 當被觀察者生產Next事件 & 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件作出響應" + value);
            }

            // 當被觀察者生產Error事件& 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            // 當被觀察者生產Complete事件& 觀察者接收到時，會呼叫該複寫方法 進行響應
            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        };


<--特別注意：2種方法的區別，即Subscriber 抽象類與Observer 介面的區別 -->
// 相同點：二者基本使用方式完全一致（實質上，在RxJava的 subscribe 過程中，Observer總是會先被轉換成Subscriber再使用）
// 不同點：Subscriber抽象類對 Observer 介面進行了擴充套件，新增了兩個方法：
    // 1. onStart()：在還未響應事件前呼叫，用於做一些初始化工作
    // 2. unsubscribe()：用於取消訂閱。在該方法被呼叫後，觀察者將不再接收 & 響應事件
    // 呼叫該方法前，先使用 isUnsubscribed() 判斷狀態，確定被觀察者Observable是否還持有觀察者Subscriber的引用，如果引用不能及時釋放，就會出現記憶體洩露
複製程式碼

步驟3：通過訂閱（`Subscribe`）連線觀察者和被觀察者

即顧客找到服務員 - 點菜 - 服務員下單到廚房 - 廚房烹調
具體實現

observable.subscribe(observer);
 // 或者 observable.subscribe(subscriber)；
複製程式碼

擴充套件說明

<-- Observable.subscribe(Subscriber) 的內部實現 -->

public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart();
    // 步驟1中 觀察者  subscriber抽象類複寫的方法，用於初始化工作
    onSubscribe.call(subscriber);
    // 通過該呼叫，從而回撥觀察者中的對應方法從而響應被觀察者生產的事件
    // 從而實現被觀察者呼叫了觀察者的回撥方法 & 由被觀察者向觀察者的事件傳遞，即觀察者模式
    // 同時也看出：Observable只是生產事件，真正的傳送事件是在它被訂閱的時候，即當 subscribe() 方法執行時
}
複製程式碼

2.2 方式2：優雅的實現方法 - 基於事件流的鏈式呼叫

上述的實現方式是為了說明Rxjava的原理 & 使用
在實際應用中，會將上述步驟&程式碼連在一起，從而更加簡潔、更加優雅，即所謂的 RxJava基於事件流的鏈式呼叫

// RxJava的鏈式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
        // 1. 建立被觀察者 & 生產事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            // 2. 通過通過訂閱（subscribe）連線觀察者和被觀察者
            // 3. 建立觀察者 & 定義響應事件的行為
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始採用subscribe連線");
            }
            // 預設最先呼叫複寫的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件"+ value +"作出響應"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }

        });
    }
}

注：整體方法呼叫順序：觀察者.onSubscribe（）> 被觀察者.subscribe（）> 觀察者.onNext（）>觀察者.onComplete() 
複製程式碼

這種 基於事件流的鏈式呼叫，使得RxJava：

邏輯簡潔
實現優雅
使用簡單

更重要的是，隨著程式邏輯的複雜性提高，它依然能夠保持簡潔 & 優雅。所以，一般建議使用這種基於事件流的鏈式呼叫方式實現RxJava。

特別注意

RxJava 2.x 提供了多個函式式介面，用於實現簡便式的觀察者模式。具體如下：

以 Consumer為例：實現簡便式的觀察者模式

Observable.just("hello").subscribe(new Consumer<String>() {
            // 每次接收到Observable的事件都會呼叫Consumer.accept（）
            @Override
            public void accept(String s) throws Exception {
                System.out.println(s);
            }
        });
複製程式碼

3. 例項講解

我將用一個實際工程例項來演示 Rxjava的使用

3.1 方式1：分步驟實現

步驟1：加入依賴

    compile 'io.reactivex.rxjava2:rxjava:2.0.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
複製程式碼

步驟2：直接在MainActivity.java中實現下述步驟

建立被觀察者 （Observable ）& 生產事件
建立觀察者 （Observer ）並定義響應事件的行為
通過訂閱（Subscribe）連線觀察者和被觀察者

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);



// 步驟1：建立被觀察者 Observable & 生產事件
// 即 顧客入飯店 - 坐下餐桌 - 點菜
        
        //  1. 建立被觀察者 Observable 物件
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            // 2. 在複寫的subscribe（）裡定義需要傳送的事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                // 通過 ObservableEmitter類物件產生事件並通知觀察者
                // ObservableEmitter類介紹
                    // a. 定義：事件發射器
                    // b. 作用：定義需要傳送的事件 & 向觀察者傳送事件
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });

// 步驟2：建立觀察者 Observer 並 定義響應事件行為
// 即 開廚房 - 確定對應菜式
        
        Observer<Integer> observer = new Observer<Integer>() {
            // 通過複寫對應方法來 響應 被觀察者
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始採用subscribe連線");
            }
            // 預設最先呼叫複寫的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件"+ value +"作出響應"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        };

        
        // 步驟3：通過訂閱（subscribe）連線觀察者和被觀察者
        // 即 顧客找到服務員 - 點菜 - 服務員下單到廚房 - 廚房烹調
        observable.subscribe(observer);
複製程式碼

測試結果

3.2 方式2：基於事件流的鏈式呼叫方式

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "Rxjava";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

// RxJava的流式操作
        Observable.create(new ObservableOnSubscribe<Integer>() {
        // 1. 建立被觀察者 & 生產事件
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            // 2. 通過通過訂閱（subscribe）連線觀察者和被觀察者
            // 3. 建立觀察者 & 定義響應事件的行為
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始採用subscribe連線");
            }
            // 預設最先呼叫複寫的 onSubscribe（）

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件"+ value +"作出響應"  );
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }

        });
    }
}
複製程式碼

測試效果實現效果同上
Demo 下載地址 Carson_Ho的Github地址 = RxJava2系列：基礎使用

喜歡的麻煩點個star！

4. 額外說明

4.1 觀察者 Observer的subscribe()具備多個過載的方法

    public final Disposable subscribe() {}
    // 表示觀察者不對被觀察者傳送的事件作出任何響應（但被觀察者還是可以繼續傳送事件）

    public final Disposable subscribe(Consumer<? super T> onNext) {}
    // 表示觀察者只對被觀察者傳送的Next事件作出響應
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    // 表示觀察者只對被觀察者傳送的Next事件 & Error事件作出響應

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    // 表示觀察者只對被觀察者傳送的Next事件、Error事件 & Complete事件作出響應

    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    // 表示觀察者只對被觀察者傳送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出響應

    public final void subscribe(Observer<? super T> observer) {}
    // 表示觀察者對被觀察者傳送的任何事件都作出響應
複製程式碼

4.2 可採用 Disposable.dispose() 切斷觀察者與被觀察者之間的連線

即觀察者無法繼續接收被觀察者的事件，但被觀察者還是可以繼續傳送事件
具體使用


// 主要在觀察者 Observer中 實現
        Observer<Integer> observer = new Observer<Integer>() {
            // 1. 定義Disposable類變數
            private Disposable mDisposable;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "開始採用subscribe連線");
                // 2. 對Disposable類變數賦值
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "對Next事件"+ value +"作出響應"  );
                if (value == 2) {
                    // 設定在接收到第二個事件後切斷觀察者和被觀察者的連線
                    mDisposable.dispose();
                    Log.d(TAG, "已經切斷了連線：" + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "對Error事件作出響應");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "對Complete事件作出響應");
            }
        };
複製程式碼

效果圖

至此，關於RxJava的基礎使用講解完畢。

5. 總結

本文主要講解 Rxjava 的基礎使用，更多例項應用請看文章：Android RxJava實際應用教學：你該什麼時候使用RxJava？
接下來，我將持續推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、應用場景、背壓等等 ，有興趣可以繼續關注Carson_Ho的安卓開發筆記！！

請幫頂 / 評論點贊！因為你的鼓勵是我寫作的最大動力！

RxJava快速入門
2024-07-18
RxJava
RxJava 入門和常見使用方式
2018-06-06
RxJava
Android RxJava：這是一份全面的操作符使用匯總（含詳細例項講解）
2018-05-31
AndroidRxJava
RxJava 從入門到全解析
2021-09-09
RxJava
RxJava2 學習（一）
2018-08-30
RxJava
RxJava2 學習（二）
2018-08-30
RxJava
Android RxJava：基礎介紹與使用
2019-03-28
AndroidRxJava
Android 動畫：這是一份詳細 & 清晰的動畫學習指南
2018-05-03
Android動畫
RxJava 2.x入門新姿勢一
2019-03-02
RxJava
響應式程式設計入門(RxJava)
2018-08-28
程式設計RxJava
Android開發之從零開始學RxJava 2.x(一)認識Rxjava
2018-07-07
AndroidRxJava
RxJava學習(10):複用與join
2018-06-14
RxJava
大話RxJava：三、RxJava的中級使用方法
2018-07-02
RxJava
為了學習Rxjava，年輕小夥竟作出這種事！
2019-02-26
RxJava
如何學習RxJava3?有這個專案就夠了!
2022-01-19
RxJava
RxJava 學習筆記 -- 基礎知識
2018-09-06
RxJava筆記
小白讀原始碼 | RxJava2 入門篇(一)
2018-12-15
原始碼RxJava
RxJava 系列-3：使用 Subject
2018-08-24
RxJava
2章 RxJava基本使用
2019-05-13
RxJava
RxJava基礎使用(一)
2021-09-09
RxJava
RxJava2操作符學習筆記
2018-12-10
RxJava筆記
RxJava 學習筆記 -- 變換操作符
2018-09-08
RxJava筆記
RxJava 學習筆記 -- 過濾操作符
2018-09-12
RxJava筆記
RxJava小考題 -- Rxjava原始碼分析(一)
2018-06-13
RxJava原始碼
Android——RxJava2史上最全講解
2018-07-31
AndroidRxJava
RxJava梳理
2019-02-18
RxJava
Retrofit + RxJava
2020-12-24
RxJava
使用RxJava實現快取
2019-01-05
RxJava快取
RxJava(RxKotlin)、RxAndroid 簡單使用
2021-09-09
RxJavaKotlinAndroid
RxJava 2.x 程式設計實戰 - 01 入門之旅
2018-09-26
RxJava程式設計
Android RxJava系列三: 與Retrofit2結合使用和封
2021-09-09
AndroidRxJava
Android開發中的Kotlin Coroutine VS RxJava
2019-02-21
AndroidKotlinRxJava
計算機網路基礎：這是一份詳細 HTTP 學習指南
2018-08-28
計算機網路HTTP
RxJava2 系列-3：使用 Subject
2018-08-24
RxJava
Retrofit2+RxJava 簡單使用
2018-09-05
RxJava
使用RxJava快取Rest請求
2021-09-09
RxJava快取REST
XTask與RxJava的使用比較
2022-04-10
RxJava
RxJava2.X 學習筆記 -- 建立操作符
2018-09-04
RxJava筆記

Android RxJava：這是一份RxJava使用入門學習指南

前言

目錄

1. RxJava簡介

2. 基本使用

2.1 方式1：分步驟實現

2.1.1 使用步驟

2.1.2 步驟詳解

步驟1：建立被觀察者（`Observable` ）& 生產事件

步驟2：建立觀察者（`Observer` ）並定義響應事件的行為

步驟3：通過訂閱（`Subscribe`）連線觀察者和被觀察者

2.2 方式2：優雅的實現方法 - 基於事件流的鏈式呼叫

特別注意

3. 例項講解

3.1 方式1：分步驟實現

3.2 方式2：基於事件流的鏈式呼叫方式

4. 額外說明

4.1 觀察者 Observer的subscribe()具備多個過載的方法

4.2 可採用 Disposable.dispose() 切斷觀察者與被觀察者之間的連線

5. 總結

請幫頂 / 評論點贊！因為你的鼓勵是我寫作的最大動力！

相關文章

Android RxJava：這是一份RxJava使用入門學習指南

前言

目錄

1. RxJava簡介

2. 基本使用

2.1 方式1：分步驟實現

2.1.1 使用步驟

2.1.2 步驟詳解

步驟1：建立被觀察者 （Observable ）& 生產事件

步驟2：建立觀察者 （Observer ）並 定義響應事件的行為

步驟3：通過訂閱（Subscribe）連線觀察者和被觀察者

2.2 方式2：優雅的實現方法 - 基於事件流的鏈式呼叫

特別注意

3. 例項講解

3.1 方式1：分步驟實現

3.2 方式2：基於事件流的鏈式呼叫方式

4. 額外說明

4.1 觀察者 Observer的subscribe()具備多個過載的方法

4.2 可採用 Disposable.dispose() 切斷觀察者 與 被觀察者 之間的連線

5. 總結

請幫頂 / 評論點贊！因為你的鼓勵是我寫作的最大動力！

相關文章

步驟1：建立被觀察者（`Observable` ）& 生產事件

步驟2：建立觀察者（`Observer` ）並定義響應事件的行為

步驟3：通過訂閱（`Subscribe`）連線觀察者和被觀察者

4.2 可採用 Disposable.dispose() 切斷觀察者與被觀察者之間的連線