要在Android中使用RxJava2, 先添加Gradle配置:
compile 'io.reactivex.rxjava2:rxjava:2.0.1'
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
正題
在開始學習之前,先來介紹點原理性的東西。
網上也有很多介紹RxJava原理的文章,通常這些文章都從觀察者模式開始,先講觀察者,被觀察者,訂閱關係巴拉巴拉一大堆,說實話,當我第一次看到這些文章的時候已經被這些名詞給繞暈了,用了很長的時間才理清楚它們之間的關係。可能是我太蠢了,境界不夠,領會不到那麼多高大上的名詞.
今天我用兩根水管代替觀察者和被觀察者, 試圖用通俗易懂的話把它們的關係解釋清楚, 在這裏我將從事件流這個角度來說明RxJava的基本工作原理。
先假設有兩根水管:
上面一根水管爲事件產生的水管,叫它上游
吧,下面一根水管爲事件接收的水管叫它下游
吧。
兩根水管通過一定的方式連接起來,使得上游每產生一個事件,下游就能收到該事件。注意這裏和官網的事件圖是反過來的, 這裏的事件發送的順序是先1,後2,後3這樣的順序, 事件接收的順序也是先1,後2,後3的順序, 我覺得這樣更符合我們普通人的思維, 簡單明瞭.
這裏的上游
和下游
就分別對應着RxJava中的Observable
和Observer
,它們之間的連接就對應着subscribe()
,因此這個關係用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, "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);
這個運行的結果就是:
12-02 03:37:17.818 4166-4166/zlc.season.rxjava2demo D/TAG: subscribe
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 1
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 2
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: 3
12-02 03:37:17.819 4166-4166/zlc.season.rxjava2demo D/TAG: complete
注意: 只有當上遊和下游建立連接之後, 上游纔會開始發送事件. 也就是調用了
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, "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");
}
});
接下來解釋一下其中兩個陌生的玩意:ObservableEmitter
和Disposable
.
ObservableEmitter: Emitter是發射器的意思,那就很好猜了,這個就是用來發出事件的,它可以發出三種類型的事件,通過調用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事件會導致程序會崩潰.
以上幾個規則用示意圖表示如下:
示意圖 | |
---|---|
只發送onNext事件 |
|
發送onComplete事件 |
|
發送onError事件 |
|
介紹了ObservableEmitter, 接下來介紹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, "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");
}
});
運行結果爲:
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: subscribe
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 1
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: onNext: 2
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: dispose
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: isDisposed : true
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 3
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit complete
12-02 06:54:07.728 7404-7404/zlc.season.rxjava2demo D/TAG: emit 4
從運行結果我們看到, 在收到onNext 2這個事件後, 切斷了水管, 但是上游仍然發送了3, complete, 4這幾個事件, 而且上游並沒有因爲發送了onComplete而停止. 同時可以看到下游的onSubscribe()
方法是最先調用的.
Disposable的用處不止這些, 後面講解到了線程的調度之後, 我們會發現它的重要性. 隨着後續深入的講解, 我們會在更多的地方發現它的身影.
另外, 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) {}
最後一個帶有Observer
參數的我們已經使用過了,這裏對其他幾個方法進行說明.
- 不帶任何參數的
subscribe()
表示下游不關心任何事件,你上游儘管發你的數據去吧, 老子可不管你發什麼. - 帶有一個
Consumer
參數的方法表示下游只關心onNext事件, 其他的事件我假裝沒看見, 因此我們如果只需要onNext事件可以這麼寫:
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);
}
});