【RxJava2.0】基本使用（一）

本文主要參考這裏，因爲之前沒用過RxJava2.0，最近想學習學習，這位大神寫得很不錯，但是光看看難以記牢，就自己敲文字加代碼加強記憶。

RxJava2已經出來很久了，網上的博客很多，現在RxJava3都出來了，本文算是學習筆記。

1 Gradle配置

要在Android中使用RxJava2，先添加Gradle配置：

    implementation 'io.reactivex.rxjava2:rxjava:2.0.1'
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.1'

2 基本原理

借用Season_zlc的管道原理來講解。用兩根水管代替觀察者和被觀察者，將從事件流這個角度來說明RxJava的基本工作原理。

先假設有兩根水管：

上面一根水管爲事件產生的水管，叫它上游，下面一根水管爲事件接收的水管叫它下游吧。兩根水管通過一定的方式連接起來，使得上游每產生一個事件，下游就能收到該事件。

這裏的上游和下游就分別對應着RxJava中的Observable和Observer，它們之間的連接就對應着subscribe()，因此這個關係用RxJava來表示就是：

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        //創建一個上游 Observable：
        Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        });
        //創建一個下游 Observer
        Observer<Integer> observer = new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
            }
            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "" + value);
            }
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }
            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        };
        //建立連接
        observable.subscribe(observer);
    }
}

運行結果

07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: subscribe
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 1
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 2
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: 3
07-29 23:21:32.549 6129-6129/com.example.rxjava2demo D/[MainActivity]: complete

只有當上遊和下游建立連接之後, 上游纔會開始發送事件. 也就是調用了subscribe() 方法之後纔開始發送事件，該代碼還可以進行鏈式操作：

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                emitter.onComplete();
            }
        }).subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "" + value);
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        });
    }
}

3 ObservableEmitter和Disposable

ObservableEmitter：是用來發出事件的，它可以發出三種類型的事件，通過調用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分別發出next事件、complete事件和error事件。

但是，發送的事件需要滿足一定的規則：

• 上游可以發送無限個onNext, 下游也可以接收無限個onNext.
• 當上遊發送了一個onComplete後, 上游onComplete之後的事件將會繼續發送, 而下游收到onComplete事件之後將不再繼續接收事件.
• 當上遊發送了一個onError後, 上游onError之後的事件將繼續發送, 而下游收到onError事件之後將不再繼續接收事件.
• 上游可以不發送onComplete或onError.
• 最爲關鍵的是onComplete和onError必須唯一併且互斥, 即不能發多個onComplete, 也不能發多個onError, 也不能先發一個onComplete, 然後再發一個onError, 反之亦然

關於onComplete和onError唯一併且互斥這一點, 是需要自行在代碼中進行控制, 如果你的代碼邏輯中違背了這個規則, **並不一定會導致程序崩潰. ** 比如發送多個onComplete是可以正常運行的, 依然是收到第一個onComplete就不再接收了, 但若是發送多個onError, 則收到第二個onError事件會導致程序會崩潰.

Disposable： 這個單詞的字面意思是一次性用品,用完即可丟棄的，對應於上面的水管的例子, 我們可以把它理解成兩根管道之間的一個機關, 當調用它的dispose()方法時, 它就會將兩根管道切斷, 從而導致下游收不到事件。

關於Disposable，如下例子，我們讓上游依次發送1,2,3,complete,4,在下游收到第二個事件之後, 切斷水管

package com.example.rxjava2demo;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;

import io.reactivex.Observable;
import io.reactivex.ObservableEmitter;
import io.reactivex.ObservableOnSubscribe;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "[MainActivity]";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        loadData();
    }

    private void loadData(){
        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {
            private Disposable mDisposable;
            private int i;

            @Override
            public void onSubscribe(Disposable d) {
                Log.d(TAG, "subscribe");
                mDisposable = d;
            }

            @Override
            public void onNext(Integer value) {
                Log.d(TAG, "onNext: " + value);
                i++;
                if (i == 2) {
                    Log.d(TAG, "dispose");
                    mDisposable.dispose();
                    Log.d(TAG, "isDisposed : " + mDisposable.isDisposed());
                }
            }

            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "error");
            }

            @Override
            public void onComplete() {
                Log.d(TAG, "complete");
            }
        });
    }
}

結果：

07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: subscribe
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 1
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: onNext: 1
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 2
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: onNext: 2
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: dispose
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: isDisposed : true
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 3
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit complete
07-29 23:30:52.415 7408-7408/com.example.rxjava2demo D/[MainActivity]: emit 4

從運行結果我們看到, 在收到onNext 2這個事件後, 切斷了水管, 但是上游仍然發送了3, complete, 4這幾個事件, 而且上游並沒有因爲發送了onComplete而停止. 同時可以看到下游的onSubscribe()方法是最先調用的。

另外, subscribe()有多個重載的方法:

    public final Disposable subscribe() {}
    public final Disposable subscribe(Consumer<? super T> onNext) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError) {} 
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {}
    public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Consumer<? super Disposable> onSubscribe) {}
    public final void subscribe(Observer<? super T> observer) {}

帶一個參數的寫法如下所示，其它可以仿照此寫法即可：

        Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emit 1");
                emitter.onNext(1);
                Log.d(TAG, "emit 2");
                emitter.onNext(2);
                Log.d(TAG, "emit 3");
                emitter.onNext(3);
                Log.d(TAG, "emit complete");
                emitter.onComplete();
                Log.d(TAG, "emit 4");
                emitter.onNext(4);
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "onNext: " + integer);
            }
        });