序言

由于我是先學習了1.0版本接著繼續學習2.0，所以本文可能不太適合沒有接觸過RxJava的同學，所以可以先看一下，1.0的學習筆記,傳送門 http://www.lxweimin.com/p/a8cedc061ab1

首先要使用RxJava2，先要添加依賴：

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

類介紹

與RxJava1相比：

相同點：
都有Observable，Observer，subscribe()
不同點：

在RxJava2的Observable中重寫的方法變為subscribe(ObservableEmitter<String> emitter),其中的ObservableEmitter： Emitter是發射器的意思，就是用來發出事件的。
在RxJava2的observer重寫方法中新添加了一個方法onSubscribe(Disposable d),其中Disposable是一次性用品，用完就丟棄，對與這個參數可以理解為一個攔截器，將所有發送過來的數據攔截下倆，讓observer不會收到。

在RxJava2中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) {}

在實際項目中我們一般只關心onNext(),和onError(),所以我們一般只會重載兩個參數的。

然后我們用代碼來理解一下上面的相同點和不同點

Observable<Integer> observable = Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> e) throws Exception {
            Log.e(TAG, "subscribe: 1" );
            e.onNext(1);
            Log.e(TAG, "subscribe: 2" );
            e.onNext(2);
            Log.e(TAG, "subscribe: 3" );
            e.onNext(3);
            e.onComplete();
        }
    });

    Observer<Integer> observer = new Observer<Integer>() {
        private Disposable disposable;

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

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

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

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

    observable.subscribe(observer);

運行結果如下所示：

com.example.cosima.rxjava2learn E/MainActivity: onSubscribe: false
com.example.cosima.rxjava2learn E/MainActivity: subscribe: 1
com.example.cosima.rxjava2learn E/MainActivity: onNext: 1
com.example.cosima.rxjava2learn E/MainActivity: subscribe: 2
com.example.cosima.rxjava2learn E/MainActivity: onNext: 2
com.example.cosima.rxjava2learn E/MainActivity: onNext: true
com.example.cosima.rxjava2learn E/MainActivity: subscribe: 3

可以看到在disposable為true的時候，Observable可以發送數據，但是在Observer沒有接收到數據。

注：與RxJava1相同，當Observable發送onComplete之后，Observable在onComplete之后的數據可以發送，Observer在接收到onComplete之后不再繼續接收事件。onError與onComplete的原理一樣，但是onComplete和onError必須唯一并且互斥, 即不能發多個onComplete, 也不能發多個onError, 也不能先發一個onComplete, 然后再發一個onError, 反之亦然。

創建方式

想對于RxJava1來說，Observable的創建方式心添加了幾種方式：

fromIterable((Iterable<? extends T> list)方式
遍歷集合，發送每個item相當于多次調用onNext().

注Collection接口是Iterable接口的子接口，所以所有Collection接口的實現類都可以作為Iterable對象直接傳入fromIterable()方法。

fromArray(T... items)方式
遍歷集合，發送每個item相當于多次調用onNext().
interval(long period, TimeUnit unit)方式
創建一個按固定時間間隔發射整數序列的Observable，可用作定時器 period:時間間隔
interval(long initialDelay, long period, TimeUnit unit)方式
initialDelay：開始值，默認為0。
range(final int start, final int count)方式
創建一個發射特定整數序列的Observable，第一個參數為起始值，第二個為發送的個數，如果為0則不發送，負數則拋異常。
timer(long delay, TimeUnit unit)方式
一個給定的延遲后發射一個特殊的值，即表示延遲2秒后，調用onNext()方法。

用于實現觀察者模式方式有很多種：
<center>

</center>

現在我們來實現一個簡單的倒計時功能：

封裝Observable

private Observable<Integer> initEvent2(final int time) {
    return Observable.interval(0, 1, TimeUnit.SECONDS)
            .subscribeOn(AndroidSchedulers.mainThread())
            .observeOn(AndroidSchedulers.mainThread())
            .map(new Function<Long, Integer>() {
                @Override
                public Integer apply(Long aLong) throws Exception {
                    return time - aLong.intValue();
                }
            })
            .take(time + 1);//限制循環次數
}

使用如下：

initEvent2(5).doOnSubscribe(new Consumer<Disposable>() {
        @Override
        public void accept(Disposable disposable) throws Exception {
            Log.e(TAG, "accept: 開始計時");
        }
    })
            .subscribe(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    Log.e(TAG, "accept: 當前計時" + integer);
                }
            });

打印結果為

在上述代碼中我們使用到了map()操作符，接下來我們就一起來看下RxJava中的操作符

RxJava操作符

1.map()操作符：

把原來的Observable對象轉換成另一個Observable對象
2.flatMap()操作符：

flatMap和Map的相同點就是把一個對象轉化為另一個對象返回，但是不同的是flatMap()返回的是個Observable對象，并且這個對象并不是直接發送到了回調方法中，而是把這個對象激活，之后將他發送到回調方法中。
3.filter()操作符：

根據自己的需求加入判斷邏輯，他的返回值是true或者是false，用于表示是否需要被過濾。
4.take()操作符：

再上面的代碼中已經用到過，具體含義就是限制輸出次數
5.doOnNext()操作符：

在輸出前可以做一個額外的操作
6.delay()操作符：

延遲Observer的輸出

線程控制Scheduler

該部分與RxJava1相比沒有變換，在平常使用中較多的都是以下幾個：

Schedulers.newThread(): 總是啟用新線程，并在新線程執行操作。

Schedulers.io(): I/O 操作（讀寫文件、讀寫數據庫、網絡信息交互等）所使用的 Scheduler。行為模式和 newThread() 差不多，區別在于 io() 的內部實現是用一個無數量上限的線程池，可以重用空閑的線程，因此多數情況下 io() 比 newThread() 更有效率。不要把計算工作放在 io() 中，可以避免創建不必要的線程。

Schedulers.computation(): 計算所使用的 Scheduler。這個計算指的是 CPU 密集型計算，即不會被 I/O 等操作限制性能的操作，例如圖形的計算。這個 Scheduler 使用的固定的線程池，大小為 CPU 核數。不要把 I/O 操作放在 computation() 中，否則 I/O 操作的等待時間會浪費 CPU。

Android 還有一個專用的 AndroidSchedulers.mainThread()，它指定的操作將在 Android 主線程運行。

都是通過subscribeOn()和 observeOn() 兩個方法來對線程進行控制。
具體可見RxJava1.0學習筆記

與Retrofit結合使用

與1.0版本總體相差不多，只需要修改相應的參數就可以了，比如subcribe()方法中的參數，請求如下所示：
主要內容為紅框所示

接下來講一下RxJava2特有的了。

Flowable及Backpressure

來由

Rxjava2中，還有一個很大的變化就是Backpressure（背壓），何為背壓，就是觀察者來不及處理被觀察者發出的事件（產生事件的速度大于處理事件的速度），導致事件被無限堆積，最后產生異常。Flowable就是由此產生，專門用來處理這類問題。將原來的Observable拆分成了新的Observable和Flowable，同時其他相關部分也同時進行了拆分。

注意：處理Backpressure的策略僅僅是處理Subscriber接收事件的方式，并不影響Flowable發送事件的方法。即使采用了處理Backpressure的策略，Flowable原來以什么樣的速度產生事件，現在還是什么樣的速度不會變化，主要處理的是Subscriber接收事件的方式。

處理Backpressure的策略

產生原因：
生產者和消費者不在同一線程下，生產者的速度大于消費者的速度，就會產生Backpressure問題。如果生產者和消費者在同一線程下，不會產生Backpressure問題，所以可以說成同步不會產生問題，異步可能產生問題。

處理策略：
1. ERROR策略
產生Backpressure問題的時候直接拋出異常(MissingBackpressureException)

      Flowable<String> flowable = Flowable.create(new FlowableOnSubscribe<String>() {
      @Override
      public void subscribe(FlowableEmitter<String> e) throws Exception {
          e.onNext("我");
          e.onNext("愛");
          e.onNext("你");
          e.onComplete();
      }
      }, BackpressureStrategy.ERROR);

      Subscriber<String> subscriber = new Subscriber<String>() {
          @Override
          public void onSubscribe(Subscription s) {
              Log.e(TAG, "onSubscribe: ");
              s.request(Long.MAX_VALUE);
          }

          @Override
          public void onNext(String s) {
              Log.e(TAG, "onNext: " + s);
          }

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

          @Override
          public void onComplete() {
              Log.e(TAG, "onComplete: " );
          }
      };
      flowable.subscribeOn(Schedulers.io())
              .observeOn(AndroidSchedulers.mainThread())
              .subscribe(subscriber);

上述代碼中在Flowable(被觀察者)添加了一個參數，并且onSubscribe(Subscription s)中傳給我們的不再是Disposable了, 而是Subscription。然而Subscription也可以用于切斷觀察者與被觀察者之間的聯系，調用Subscription.cancel()方法，并在此方法中添加了s.request(long count);這個方法就是用來向生產者申請可以消費的事件數量。這樣就可以根據自身的消費能力進行消費。在異步調用時，RxJava中有個緩存池，用來緩存消費者處理不了暫時緩存下來的數據，緩存池的默認大小為128，即只能緩存128個事件。無論request()中傳入的數字比128大或小，緩存池中在剛開始都會存入128個事件。當然如果本身并沒有這么多事件需要發送，則不會存128個事件。
在ERROR策略下，如果緩存池溢出，就會立刻拋出MissingBackpressureException異常。

注：如果不調用request表示消費能力為0。如果不限制想request()中傳入任意參數，超過消費能力，也會造成資源浪費，產生OOM。

2. BUFFER策略
BUFFER就是把RxJava中默認的只能存128個事件的緩存池換成一個大的緩存池，支持存很多很多的數據。
這樣，消費者通過request()即使傳入一個很大的數字，生產者也會生產事件，并將處理不了的事件緩存。
但是這種方式任然比較消耗內存，除非是我們比較了解消費者的消費能力，能夠把握具體情況，不會產生OOM。BUFFER要慎用
3. DROP策略
當消費者處理不了事件，就丟棄。
消費者通過request()傳入其需求n，然后生產者把n個事件傳遞給消費者供其消費。其他消費不掉的事件就丟掉。
4. LATEST策略
LATEST與DROP功能基本一致。
消費者通過request()傳入其需求n，然后生產者把n個事件傳遞給消費者供其消費。其他消費不掉的事件就丟掉。
唯一的區別就是LATEST總能使消費者能夠接收到生產者產生的最后一個事件。
還是以上述例子展示，唯一的區別就是Flowable不再無限發事件，只發送1000000個。

參考：http://www.lxweimin.com/p/d149043d103a

源碼地址：https://github.com/MrMJL/RxJava2Demo
由于只是學習筆記，源碼可能會有點亂，又不對或者不明白歡迎評論多多交流。推薦一個Android實習&&經驗交流群：541144061

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

RxJava2.0學習筆記

RxJava2.0學習筆記

序言

類介紹

創建方式

RxJava操作符

1.map()操作符：

線程控制Scheduler

與Retrofit結合使用

Flowable及Backpressure

來由

處理Backpressure的策略

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

RxJava2.0學習筆記

序言

類介紹

創建方式

RxJava操作符

1.map()操作符：

線程控制Scheduler

與Retrofit結合使用

Flowable及Backpressure

來由

處理Backpressure的策略

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频