最簡單易懂的RxJava2.0學習教程之RxJava2的基本使用（一）

去年RxJava2就發佈了，在這之後一直做項目都在使用Rxjava2，覺得特別好用，目前網上的的資料很多，對於以前使用過RxJava1的朋友來說只需要看看更新文檔就知道怎麼使用了，但還有一些以前沒用過RxJava的朋友可能就不知道怎麼辦了，不知道該看RxJava1還是直接學習RxJava2。如果你以前學過RxJava1，那麼對於RxJava2只需要看看更新了哪些東西就行了，RxJava2相對於RxJava1最核心的思想並沒有變化，如果你沒學過RxJava1，沒有關係，直接學習RxJava2。所以在這裏和朋友們分享一下RxJava2的知識，希望對大家有所幫助。

一、配置

要在Android中使用RxJava2, 在app的build.gradle中添加依賴：

compile 'io.reactivex.rxjava2:rxjava:2.x.y'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

一個是Rxjava的庫，一個是RxJava基於Android的庫。

二、原理

下邊就來說下RxJava的原理。網上有很多介紹RxJava原理的博客，一般文章都從觀察者模式開始，先講觀察者，被觀察者，訂閱關係等。當我第一次看到這些文章的時候完全是一臉懵逼的，需要先去看一遍觀察者模式，然後還要在觀察者模式基礎上去理解RxJava。總之，需要花很長的時間去理清楚它們之間的關係。

我覺得這樣更容易理解：用一條河的上游和下游代替被觀察者和觀察者, 上游和下游之間有個水閘，建立連接的情況下水閘是打開的，上游每發送一個事件，下游就能收到該事件。RxJava的使用都是分三步

第一步：創建被觀察者

//創建上游 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, "onSubscribe");
            }

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

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

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

第三步：建立訂閱關係

        //建立連接
        observable.subscribe(observer);

運行結果:

這裏的事件發送的順序是1,2,3, 事件接收的順序也是1,2,3的順序。
上游和下游就分別對應着RxJava中的Observable和Observer，它們之間的連接就對應着subscribe()。
只有當(上游)Observable和(下游)Observer建立連接之後, 上游纔會開始發送事件. 也就是調用了subscribe() 方法之後纔開始發送事件.
把這段代碼連起來寫就成了被大家所熟知的RxJava的鏈式操作，運行結果也是一樣的：

    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, "onSubscribe");
            }

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

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

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

解釋一下兩個關鍵詞：ObservableEmitter和Disposable

ObservableEmitter：

Emitter就是發射器的，這個就是用來發出事件的，它可以發出三種類型的事件，通過調用emitter的onNext(T value)、onComplete()和onError(Throwable error)就可以分別發出next事件、complete事件和error事件。
這裏需要注意的是：
1、上游可以發送無限個onNext, 下游也可以接收無限個onNext。當上遊發送了一個onComplete後, 上游onComplete之後的事件將會繼續發送, 而下游收到onComplete事件之後將不再繼續接收事件。
2、當上遊發送了一個onError後, 上游onError之後的事件將繼續發送, 而下游收到onError事件之後將不再繼續接收事件。上游可以不發送onComplete或onError。
3、發送多個onComplete是可以正常運行的, 但是收到第一個onComplete就不再接收了, 但若是發送多個onError, 則收到第二個onError事件會導致程序會崩潰。

我們就來一一試驗一下：

1、發送多個onComplete

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

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

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

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

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

運行結果：

可以看到，發送多個onComplete是可以的，只是接收到一個onComplete之後就不在接收事件，但是上游依舊在發送事件。

2、發送多個onError事件

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                Log.d(TAG, "emitter=1");
                emitter.onNext(1);
                Log.d(TAG, "emitter=2");
                emitter.onNext(2);
                Log.d(TAG, "emitter=3");
                emitter.onNext(3);
//                Log.d(TAG, "emitter=complete=1");
//                emitter.onComplete();
//                Log.d(TAG, "emitter=complete=2");
//                emitter.onComplete();
//                Log.d(TAG, "emitter=complete=3");
//                emitter.onComplete();
                Log.d(TAG, "emitter=error=1");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=error=2");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=error=3");
                emitter.onError(new Throwable("no message"));
                Log.d(TAG, "emitter=4");
                emitter.onNext(4);
            }
        }).subscribe(new Observer<Integer>() {

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

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

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

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

運行結果：

從這個結果中可以看到，當收到第一個onError()後,打印了error信息但是程序並沒有崩潰，然後第二個onError()程序就崩潰了。

Disposable：

這個單詞的意思：是一次性的,用後就拋棄的. 那麼在RxJava中怎麼去理解它呢, 對應於上面的例子, 我們可以把它理解成水閘, 當調用它的dispose()方法時, 水閘關閉, 下游就收不到事件。
但是調用dispose()並不會讓上游停止繼續發送事件, 相反上游會繼續發送剩餘的事件.

上游依次發送1,2,3,complete,4,在下游收到第二個事件之後, 關閉水閘, 看看運行結果:

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

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

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

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

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

運行結果爲:

從運行結果我們看到, 在收到onNext(2)這個事件後, 關閉水閘, 但是上游仍然發送了onNext(3), complete, onNext(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) {}

第一個不帶任何參數的subscribe() 表示下游不關心上游發送的是什麼。
第二個帶有一個Consumer參數的方法表示下游只關心onNext事件, 其他的事件不關心, 因此我們如果只需要onNext事件可以這麼寫，代碼如下:

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

運行結果如下：

接下來的幾個方法的使用和第二個是一樣的，就不多說了，最後一個方法的話，在文章前面就使用了，也不介紹了。

點擊下載Demo

最簡單易懂的RxJava2.0學習教程之RxJava2的基本使用（一）

一、配置

二、原理

第一步：創建被觀察者

第二步：創建觀察者

第三步：建立訂閱關係

ObservableEmitter：

1、發送多個onComplete

2、發送多個onError事件

Disposable：

如何使用 JS 判斷用戶是否處於活躍狀態

通過HPA+CronHPA組合應對業務複雜彈性伸縮場景

最完整的Windows下React Native開發環境搭建與第一個程序HelloWorld

最簡單易懂的RxJava2.0學習教程之RxJava2的基本使用（一）

Android各種學習資料（Rxjava、動畫、UI效果、開源庫、算法、面試）資源鏈接

簡單易懂的Java設計模式之單例模式

Android集合SparseArray的使用及源碼解析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結