RxJava 學習筆記 -- 基礎知識

RxJava 基礎知識

五種觀察者

注: 使用Rxjava之前需要新增依賴

dependencies {
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
    implementation 'io.reactivex.rxjava2:rxjava:2.2.0'
    implementation 'io.reactivex.rxjava2:rxkotlin:2.3.0'
    // 注：RxJava2 與 RxJava1 不能共存，即依賴不能同時存在
}
複製程式碼

1. Observable

能夠發射0或n個資料,並以成功或錯誤事件終止

RxJava的使用通常需要三步:

1. 建立Observable
2. 建立Observer
3. 使用subscribe()進行訂閱

subscribe 有多個過載的方法:

1. subscribe(onNext)
2. subscribe(onNext,onError)
3. subscribe(onNext,onError,onComplete)
4. subscribe(onNext,onError,onComplete,onSubscribe)

在RxJava中,被觀察者,觀察者,subscribe()方法必須同時存在,只有使用了subscribe(),被觀察者才會開始傳送資料

Observable.just("Hello World!")
                .subscribeBy(
                        onComplete = {Log.e("TAG","onComplete")},
                        onError = {Log.e("TAG",it.localizedMessage)},
                        onNext = {Log.e("TAG",it)}
                )
複製程式碼

2. Flowable

Flowable是RxJava 2.X新增的被觀察者,Flowable可以看成Observable新的實現,它支援背壓,在這五種觀察者模式中,也只有Flowable支援背壓.同時實現Reactive Streams的Publisher介面,Flowable所有的操作符強制支援被壓

Flowable和Observable很相似,在使用場景上的區別

• Observable的使用場景

1. 一般處理最大不超過1000條資料,並且幾乎不會出現記憶體溢位
2. GUI滑鼠事件,基本不會背壓
3. 處理同步流

• Flowable的使用場景

1. 處理以某種方式產生超過10KB的元素
2. 檔案讀取與分析
3. 讀取資料庫記錄,也是一個阻塞的和基於拉取模式
4. 網路I/O流
5. 建立一個響應式非阻塞介面

3. Single

Single 只有onSuccess和onError事件.其中onSuccess用於發射資料,而且只能發射一個資料,後面即使再發射資料也不會做任何處理
Single 可以通過toXXX方法轉換成Observable,Flowable,Completable,Maybe

4. Completable

Completable 在建立後,不會發射任何資料,只有onComplete和onError事件,同時Completable並沒有map,flatMap等操作符.

Completable 經常結合andThen操作符使用
在Completable中,andThen有多個過載方法,正好對應了五種被觀察者型別

1. Completable andThen(CompletableSource next)
2. <T> Observable<T> andThen(ObservableSource next)
3. <T> Flowable<T> andThen(FlowableSource next)
4. <T> Single<T> andThen(SingleSource next)
5. <T> Maybe<T> andThen(MaybeSource next)

Completable 可以通過toXXX方法轉換成Observable,Flowable,Single,Maybe

Completable.fromAction { Log.e("TAG","Hello") }
                    .andThen(Observable.just(1))
                    .subscribeBy(
                            onNext = {Log.e("TAG",it.toString())}
                    )
複製程式碼

5. Maybe

Maybe 是RxJava 2.X 之後才有的新型別,可以看成是Single和Completable的結合

do操作符

do操作符可以給Observable的生命週期的各個階段加上一系列的回撥監聽,當Observable執行到這個階段時,這些回撥就會觸發.

Observable.just("Hello")
                    .doOnNext { Log.e("TAG","doOnNext: $it") }
                    .doAfterNext { Log.e("TAG","doAfterNext: $it") }
                    .doOnComplete { Log.e("TAG","doOnComplete") }
                    .doOnSubscribe { Log.e("TAG","doOnSubscribe") }
                    .doAfterTerminate { Log.e("TAG","doAfterTerminate") }
                    .doFinally { Log.e("TAG","doFinally") }
                    .doOnEach { Log.e("TAG","doOnEach: ${if (it.isOnNext) "onNext" else (if (it.isOnComplete) "onComplete" else "onErrpr")}") }
                    .doOnLifecycle({ Log.e("TAG","doOnLifecycle: ${it.isDisposed}") }, { Log.e("TAG","doOnLifecycle run: ") })
                    .doOnError { Log.e("TAG","doOnError: ${it.localizedMessage}")  }
                    .doOnTerminate { Log.e("TAG","doOnTerminate: ")  }
                    .doOnDispose { Log.e("TAG","doOnDispose: ")  }
                    .subscribeBy(
                            onNext = {Log.e("TAG","onNext: $it")},
                            onError = {Log.e("TAG","onError: ${it.localizedMessage}")},
                            onComplete = {Log.e("TAG","onComplete")}
                    )
複製程式碼

執行結果:

    doOnSubscribe
    doOnLifecycle: false
    doOnNext: Hello
    doOnEach: onNext
    onNext: Hello
    doAfterNext: Hello
    doOnComplete
    doOnEach: onComplete
    doOnTerminate: 
    onComplete
    doFinally
    doAfterTerminate複製程式碼

以上是RxJava一些基礎概念和生命週期的知識梳理, 後續會更新RxJava其他知識的學習筆記.