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 不能共存，即依赖不能同时存在
}
复制代码

类型	描述
Observable	能够发射0或n个数据,并以成功或错误事件终止
Flowable	能够发射0或n个数据,并以成功或错误事件终止.支持背压,可以控制数据源发射的速度
Single	只发射单个数据或错误事件
Completable	从来不发射数据,只处理onComplete和onError事件.
Maybe	能够发射0或1个数据,要么成功,要么失败.

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执行到这个阶段时,这些回调就会触发.

操作符	用途
doOnSubscribe	一旦观察者订阅了Observable,它就会调用
doOnLifecycle	可以在观察者订阅之后, 设置是否取消订阅
doOnNext	它产生的Observable每发射一条数据就会调用它一次,它的Consumer接受发射的数据项,一般用于在subscribe之前对数据进行处理
doOnEach	它产生的Observable每发射一条数据就会调用它一次,不仅包括onNext,还包括onComplete和onError
doAfterNext	在onNext之后执行,而doOnNext()是在onNext之前执行
doOnComplete	当它产生的Observable在正常终止调用onComplete时会被调用87
doFinally	在当它产生的Observable终止之后会被调用,无论是正常终止还是异常终止,doFinally优先于doAfterTerminate的调用
doAfterTerminate	注册一个Action当Observable调用onComplete或onError时会触发

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其他知识的学习笔记.