五种观察者模式

被观察者，观察者，subscribe()方法三者缺一不可。只有使用了subscribe()，被观察者才会开始发送数据。

graph LR
    A[RxJava 2.x 的五种观察者模式] --> B[Observable 和 Observer]
    A --> C[Flowable 和 Subscriber]
    A --> E[Single 和 SingleObserver]
    A --> F[Completable 和 CompletableObserver]
    A --> G[Maybe 和 MaybeObserver]

类型	描述
Observable	能够发射0或n个数据，并以成功或者错误时间终止
Flowable	能够发射0或n个数据，并以成功或者错误时间终止。支持背压，可以控制数据源发射的速度
Single	只发射单个数据或错误事件
Completable	从来不发射数据，只处理onComplete和onError事件。可以看成Rx的Runnable
Maybe	能够发射0或n个数据，要么成功，要么失败。有点类似Optional

do 操作符

do 操作符可以给Observable的生命周期的各个阶段加上一系列的回调监听，当Observable执行到这个阶段时，这些回调就会被触发。

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

Hot Observable 和 Cold Observable

Hot Observable：无论有没有观察者进行订阅，事件始终都会发生。可以与多个订阅者共享信息。

Cold Observable：只有观察者订阅了，才开始执行发射数据流的代码。Observable 和 Observer 只能是一对一的关系。

Cold Observable

Observable 的 just、create、range、fromXXX 等操作符都能生成Cold Observable

Hot Observable

(1) 使用publish，生成ConnectableObservable，再调用 connect() 才能真正执行。

(2) 使用 Subject/Processor

Flowable

Obserable不再支持背压（Back Pressure）,而改由Flowable来支持非阻塞式的背压。

使用Obserable较好的场景：

一般处理最大不超过1000条数据，并且几乎不会内存益处；
GUI 鼠标事件，基本不会背压（可以结合sampling/debouncing操作）；
处理同步流。

使用Flowable较好的场景：

处理以某种方式产生超过10KB的元素；
文件读取与分析；
读取数据库操作，也是一个阻塞的和基于拉取模式；
网络IO；
创建一个响应式非阻塞接口。

Single、Completable 和 Maybe

Single

Single只有onSuccess 和 onError事件。

其中，onSuccess()用于发射数据（在 Obserable/Flowable 中使用 onNext()来发射数据），而且只能发射一个数据，后面即使再发射数据也不会做任何处理。

Single.create(new SingleOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull SingleEmitter<String> e) throws Exception {
        e.onSuccess("test");
    }
}).subscribe(new BiConsumer<String, Throwable>() {
   @Override
   public void accept(String s, Throwable throwable) throw Exception {
       System.out.println(s);
   }
});

Completable

Completable在创建后，不会发射任何数据。

Completable 只有onComplete 和 onError 事件，同时 Completable 并没有 map、faltmap等操作符

Completable.fromAction(new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("Hello World");
    }
}).subscribe();

Completable.create(new CompletableOnSubscribe() {
    @Override
    public void subscribe(@NonNull CompletableEmitter emitter) throws Exception {
        try {
            TimeUnit.SECONDS.sleep(1);
            emitter.onComplete();
        } catch (InterruptedException e) {
            emitter.onError(e);
        }
    }
}).andThen(Observable.range(1,10))
.subscribe(new Consumer<Integer>) {
    @Override
    public void accept(@NonNull Integer integer) throws Exception {
        System.out.println(integer);
    }
});

>>>>>
1
2
3
4
5
6
7
8
9
10

Maybe

Maybe 可以看成是Single 和 Completable 的结合。

Maybe 创建之后，MaybeEmitter 和 SingleEmitter 一样，并没有onNext()方法，同样需要通过onSuccess()方法来发射数据。

Maybe 只能发射0或者1个数据，即使发射多个数据，后面发射等数据也不会处理。

Maybe.create(new MaybeOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull MaybeEmitter<String> e) throws Exception {
        e.onSuccess("testA");
        e.onSuccess("testB");
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(@Nonnull String s) throws Exception {
        System.out.println("s=" + s);
    }
});

>>>>>
s=testA

如果先调用了onComplete()，即使后面再调用onSuccess()，也不会发射任何数据。

Maybe.create(new MaybeOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull MaybeEmitter<String> e) throws Exception {
        e.onComplete();
        e.onSuccess("testA");
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(@Nonnull String s) throws Exception {
        System.out.println("s=" + s);
    }
});

>>>>>
不打印任何数据

会执行MaybeObserver 的 onComplete()

Maybe.create(new MaybeOnSubscribe<String>() {
    @Override
    public void subscribe(@NonNull MaybeEmitter<String> e) throws Exception {
        e.onComplete();
        e.onSuccess("testA");
    }
}).subscribe(new Consumer<String>() {
    @Override
    public void accept(@Nonnull String s) throws Exception {
        System.out.println("s=" + s);
    }
}, new Consumer<Throwable>() {
    @Override
    public void accept(@Nonnull Throwable throwable) throws Exception {
        
    }, new Action() {
        @Override
        public void run() throws Exception {
            System.out.println("Maybe onComplete");
        }
    } 
});

>>>>>
Maybe onComplete

Subject 和 Processor

Subject 是一种特殊等存在

Subject 既是 Observable，又是Observer。

public abstract class Subject<T> extends Observable<T> implements Observer<T> {
    省略...
}

AsyncSubject

Observer 会接收 AsyncSubject 的 onComplete()之前的最后一个参数。

subject.onComplete()必须要调用才会开始发送数据，否则观察者将不接收任何数据。

BehaviorSubject

Observer 会先接收到 BehaviorSubject 被订阅之前的最后一条数据，再接收订阅者之后发射过来的数据。如果 BehaviorSubject 被订阅前没有发送任何数据，则会发送一个默认数据。

ReplaySubject

ReplaySubject 会发射所有来自原始 Observable 的数据给观察者，无论它们是何时订阅的。

PublishSubject

Observer 只接收 PublishSubject 被订阅之后发送的数据。

Subject	发射行为
AsyncSubject	不论订阅发生在什么时候，只发射最后一个数据
BehaviorSubject	发送订阅之前的一个数据和订阅之后的全部数据
ReplaySubject	不论订阅发生在什么时候，都发射全部数据
PublishSubject	发送订阅之后全部数据

2、Rxjava-基础分类