Android Rxjava：這是一篇清晰 & 易懂的Rxjava 入門教程

阿新 • • 發佈：2019-01-06

前言

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

Github截圖

本文主要：
1. 面向剛接觸Rxjava的初學者
2. 提供了一份 清晰、簡潔、易懂的Rxjava入門教程
涵蓋基本介紹、原理 & 具體使用等
1. 解決的是初學者不理解Rxjava原理 & 不懂得如何使用的問題

希望你們會喜歡。

本文主要基於Rxjava 2.0

如果讀者還沒學習過Rxjava 1.0也沒關係，因為Rxjava 2.0只是在Rxjava 1.0上增加了一些新特性，本質原理 & 使用基本相同

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

示意圖

1. 定義

RxJava 在 GitHub 的介紹：

RxJava：a library for composing asynchronous and event-based programs using observable sequences for the Java VM
// 翻譯：RxJava 是一個在 Java VM 上使用可觀測的序列來組成非同步的、基於事件的程式的庫

總結：RxJava 是一個 基於事件流、實現非同步操作的庫

2. 作用

實現非同步操作

類似於 Android中的 AsyncTask 、Handler作用

3. 特點

由於 RxJava的使用方式是：基於事件流的鏈式呼叫，所以使得 RxJava：

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

更重要的是，隨著程式邏輯的複雜性提高，它依然能夠保持簡潔 & 優雅

4. 原理

4.1 生活例子引入

我用一個生活例子引入 & 講解 Rxjava原理： 顧客到飯店吃飯

示意圖流程圖

4.2 Rxjava原理介紹

Rxjava原理基於 一種擴充套件的觀察者模式
Rxjava的擴充套件觀察者模式中有4個角色：

角色	作用	類比
被觀察者（Observable）	產生事件	顧客
觀察者（Observer）	接收事件，並給出響應動作	廚房
訂閱（Subscribe）	連線被觀察者 & 觀察者	服務員
事件（Event）	被觀察者 & 觀察者溝通的載體	菜式

具體原理

請結合上述 顧客到飯店吃飯 的生活例子理解：

示意圖流程圖

即RxJava原理可總結為：被觀察者 （Observable） 通過訂閱（Subscribe） 按順序傳送事件 給觀察者 （Observer），觀察者（Observer） 按順序接收事件 & 作出對應的響應動作。具體如下圖：

示意圖

至此，RxJava原理講解完畢。

5. 基本使用

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

5.1 方式1：分步驟實現

5.1.1 使用步驟

示意圖

5.1.2 步驟詳解

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

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

        // 1. 建立被觀察者 Observable 物件
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
          // create() 是 RxJava 最基本的創造事件序列的方法
          // 此處傳入了一個 OnSubscribe 物件引數
          // 當 Observable 被訂閱時，OnSubscribe 的 call() 方法會自動被呼叫，即事件序列就會依照設定依次被觸發
          // 即觀察者會依次呼叫對應事件的複寫方法從而響應事件
          // 從而實現被觀察者呼叫了觀察者的回撥方法 & 由被觀察者向觀察者的事件傳遞，即觀察者模式
    <span class="hljs-comment">// 2. 在複寫的subscribe（）裡定義需要傳送的事件</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">subscribe</span><span class="hljs-params">(ObservableEmitter&lt;Integer&gt; emitter)</span> <span class="hljs-keyword">throws</span> Exception </span>{
            <span class="hljs-comment">// 通過 ObservableEmitter類物件產生事件並通知觀察者</span>
            <span class="hljs-comment">// ObservableEmitter類介紹</span>
                <span class="hljs-comment">// a. 定義：事件發射器</span>
                <span class="hljs-comment">// b. 作用：定義需要傳送的事件 &amp; 向觀察者傳送事件</span>
            emitter.onNext(<span class="hljs-number">1</span>);
            emitter.onNext(<span class="hljs-number">2</span>);
            emitter.onNext(<span class="hljs-number">3</span>);
            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. 建立物件時通過對應複寫對應事件方法 從而 響應對應事件
        <span class="hljs-comment">// 觀察者接收事件前，預設最先呼叫複寫 onSubscribe（）</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onSubscribe</span><span class="hljs-params">(Disposable d)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"開始採用subscribe連線"</span>);
        }
        
        <span class="hljs-comment">// 當被觀察者生產Next事件 &amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(Integer value)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Next事件作出響應"</span> + value);
        }

        <span class="hljs-comment">// 當被觀察者生產Error事件&amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }
      
        <span class="hljs-comment">// 當被觀察者生產Complete事件&amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }
    };

<–方式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連線”);
}

        <span class="hljs-comment">// 當被觀察者生產Next事件 &amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(Integer value)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Next事件作出響應"</span> + value);
        }

        <span class="hljs-comment">// 當被觀察者生產Error事件&amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }

        <span class="hljs-comment">// 當被觀察者生產Complete事件&amp; 觀察者接收到時，會呼叫該複寫方法 進行響應</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }
    };

<–特別注意：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() 方法執行時
}

5.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（）
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(Integer value)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Next事件"</span>+ value +<span class="hljs-string">"作出響應"</span>  );
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }

    });
}

}

注：整體方法呼叫順序：觀察者.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);
            }
        });

6. 例項說明

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

6.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 {
<span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> String TAG = <span class="hljs-string">"Rxjava"</span>;

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onCreate</span><span class="hljs-params">(Bundle savedInstanceState)</span> </span>{
    <span class="hljs-keyword">super</span>.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

// 步驟1：建立被觀察者 Observable & 生產事件
// 即顧客入飯店 - 坐下餐桌 - 點菜

    <span class="hljs-comment">//  1. 建立被觀察者 Observable 物件</span>
    Observable&lt;Integer&gt; observable = Observable.create(<span class="hljs-keyword">new</span> ObservableOnSubscribe&lt;Integer&gt;() {
        <span class="hljs-comment">// 2. 在複寫的subscribe（）裡定義需要傳送的事件</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">subscribe</span><span class="hljs-params">(ObservableEmitter&lt;Integer&gt; emitter)</span> <span class="hljs-keyword">throws</span> Exception </span>{
            <span class="hljs-comment">// 通過 ObservableEmitter類物件產生事件並通知觀察者</span>
            <span class="hljs-comment">// ObservableEmitter類介紹</span>
                <span class="hljs-comment">// a. 定義：事件發射器</span>
                <span class="hljs-comment">// b. 作用：定義需要傳送的事件 &amp; 向觀察者傳送事件</span>
            emitter.onNext(<span class="hljs-number">1</span>);
            emitter.onNext(<span class="hljs-number">2</span>);
            emitter.onNext(<span class="hljs-number">3</span>);
            emitter.onComplete();
        }
    });

// 步驟2：建立觀察者 Observer 並定義響應事件行為
// 即開廚房 - 確定對應菜式

    Observer&lt;Integer&gt; observer = <span class="hljs-keyword">new</span> Observer&lt;Integer&gt;() {
        <span class="hljs-comment">// 通過複寫對應方法來 響應 被觀察者</span>
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onSubscribe</span><span class="hljs-params">(Disposable d)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"開始採用subscribe連線"</span>);
        }
        <span class="hljs-comment">// 預設最先呼叫複寫的 onSubscribe（）</span>

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(Integer value)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Next事件"</span>+ value +<span class="hljs-string">"作出響應"</span>  );
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }
    };

    
    <span class="hljs-comment">// 步驟3：通過訂閱（subscribe）連線觀察者和被觀察者</span>
    <span class="hljs-comment">// 即 顧客找到服務員 - 點菜 - 服務員下單到廚房 - 廚房烹調</span>
    observable.subscribe(observer);

測試結果

示意圖

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

public class MainActivity extends AppCompatActivity {
<span class="hljs-keyword">private</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">final</span> String TAG = <span class="hljs-string">"Rxjava"</span>;

<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">protected</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onCreate</span><span class="hljs-params">(Bundle savedInstanceState)</span> </span>{
    <span class="hljs-keyword">super</span>.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（）

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onNext</span><span class="hljs-params">(Integer value)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Next事件"</span>+ value +<span class="hljs-string">"作出響應"</span>  );
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }

    });
}

}

喜歡的麻煩點個star！

7. 額外說明

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

    public final Disposable subscribe() {}
    // 表示觀察者不對被觀察者傳送的事件作出任何響應（但被觀察者還是可以繼續傳送事件）
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> Disposable <span class="hljs-title">subscribe</span><span class="hljs-params">(Consumer&lt;? <span class="hljs-keyword">super</span> T&gt; onNext)</span> </span>{}
<span class="hljs-comment">// 表示觀察者只對被觀察者傳送的Next事件作出響應</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> Disposable <span class="hljs-title">subscribe</span><span class="hljs-params">(Consumer&lt;? <span class="hljs-keyword">super</span> T&gt; onNext, Consumer&lt;? <span class="hljs-keyword">super</span> Throwable&gt; onError)</span> </span>{} 
<span class="hljs-comment">// 表示觀察者只對被觀察者傳送的Next事件 &amp; Error事件作出響應</span>

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> Disposable <span class="hljs-title">subscribe</span><span class="hljs-params">(Consumer&lt;? <span class="hljs-keyword">super</span> T&gt; onNext, Consumer&lt;? <span class="hljs-keyword">super</span> Throwable&gt; onError, Action onComplete)</span> </span>{}
<span class="hljs-comment">// 表示觀察者只對被觀察者傳送的Next事件、Error事件 &amp; Complete事件作出響應</span>

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> Disposable <span class="hljs-title">subscribe</span><span class="hljs-params">(Consumer&lt;? <span class="hljs-keyword">super</span> T&gt; onNext, Consumer&lt;? <span class="hljs-keyword">super</span> Throwable&gt; onError, Action onComplete, Consumer&lt;? <span class="hljs-keyword">super</span> Disposable&gt; onSubscribe)</span> </span>{}
<span class="hljs-comment">// 表示觀察者只對被觀察者傳送的Next事件、Error事件 、Complete事件 &amp; onSubscribe事件作出響應</span>

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">final</span> <span class="hljs-keyword">void</span> <span class="hljs-title">subscribe</span><span class="hljs-params">(Observer&lt;? <span class="hljs-keyword">super</span> T&gt; observer)</span> </span>{}
<span class="hljs-comment">// 表示觀察者對被觀察者傳送的任何事件都作出響應</span>

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

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


// 主要在觀察者 Observer中 實現
        Observer<Integer> observer = new Observer<Integer>() {
            // 1. 定義Disposable類變數
            private Disposable mDisposable;
        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onSubscribe</span><span class="hljs-params">(Disposable d)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"開始採用subscribe連線"</span>);
            <span class="hljs-comment">// 2. 對Disposable類變數賦值</span>
            mDisposable = d;
        }

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

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onError</span><span class="hljs-params">(Throwable e)</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Error事件作出響應"</span>);
        }

        <span class="hljs-meta">@Override</span>
        <span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">onComplete</span><span class="hljs-params">()</span> </span>{
            Log.d(TAG, <span class="hljs-string">"對Complete事件作出響應"</span>);
        }
    };

效果圖

示意圖

8. 總結

本文主要對 Rxjava 的入門知識進行講解，包括基本介紹、原理 & 具體使用等
接下來，我將持續推出 Android中 Rxjava 2.0 的一系列文章，包括原理、操作符、應用場景、背壓等等 ，有興趣可以繼續關注Carson_Ho的安卓開發筆記！！

示意圖

請點贊！因為你的鼓勵是我寫作的最大動力！

不定期分享關於安卓開發的乾貨，追求短、平、快，但卻不缺深度。

      </div>
    </div>

Android Rxjava：這是一篇 清晰 & 易懂的Rxjava 入門教程

前言

目錄