序言
由于我是先學習了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>
現在我們來實現一個簡單的倒計時功能：
封裝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
