RxJava2（一）完整生命周期

RxJava2 完整生命周期

简介：
1.RxJava用于通过使用被观察者Obverserable/Flowable序列来构建异步和基于事件的库。
2.RxJava支持Java5之后版本，还支持跑在JVM上的各种语言。
3.RxJava可以用在Android开发的任何地方，包括App所依赖的底层框架。
4.导入依赖：

implementation "io.reactivex.rxjava2:rxjava:2.2.3"
implementation "io.reactivex.rxjava2:rxandroid:2.1.0"

创建一个Hellow World!

 Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) {
                emitter.onNext("Hello World");
            }
        }).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception{
                Log.d(TAG, "accept: " + s);
                Toast.makeText(MainActivity.this, s, Toast.LENGTH_SHORT).show();
            }
        });

5.完整的生命周期

Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) {
                emitter.onNext(1);
                emitter.onNext(2);
                emitter.onNext(3);
                try {
                    emitter.onComplete();
                } catch (Exception e) {
                    emitter.onError(e);
                }
            }
        }).doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.d(TAG, "doOnSubscribe: 一旦观察者订阅之后就会被调用");
            }
        }).doOnLifecycle(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                Log.d(TAG, "doOnLifecycle: 当观察者订阅之后可取消订阅.当前状态是否取消：" + disposable.isDisposed());
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "doOnLifecycle: 重新订阅");
            }
        }).doOnNext(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "doOnNext: Observable每发射一次数据就调用一次，在onNext之前调用，用于在subscribe之前对数据进行处理");
            }
        }).doOnEach(new Consumer<Notification<Integer>>() {
            @Override
            public void accept(Notification<Integer> integerNotification) throws Exception {
                Log.d(TAG, "doOnEach: Observable每发射一次数据就调用一次,包括onNext,onError和onComplete");
            }
        }).doAfterNext(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "doAfterNext: 在onNext之后执行");
            }
        }).doOnComplete(new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "doOnComplete: 数据发射完，Observable正常终止时调用");
            }
        }).doFinally(new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "doFinally: 无论正常终止还是异常终止都会被调用");
            }
        }).doAfterTerminate(new Action() {
            @Override
            public void run() throws Exception {
                Log.d(TAG, "doAfterTerminate: 当调用onComplete和onError时触发");
            }
        }).subscribe(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) throws Exception {
                Log.d(TAG, "subscribe 收到数据: " + integer);
            }
        });

输出结果：
doOnSubscribe: 一旦观察者订阅之后就会被调用
doOnLifecycle: 当观察者订阅之后可取消订阅.当前状态是否取消：false
doOnNext: Observable每发射一次数据就调用一次，在onNext之前调用，用于在subscribe之前对数据进行处理
doOnEach: Observable每发射一次数据就调用一次,包括onNext,onError和onComplete
subscribe 收到数据: 1
doAfterNext: 在onNext之后执行
doOnNext: Observable每发射一次数据就调用一次，在onNext之前调用，用于在subscribe之前对数据进行处理
doOnEach: Observable每发射一次数据就调用一次,包括onNext,onError和onComplete
subscribe 收到数据: 2
doAfterNext: 在onNext之后执行
doOnNext: Observable每发射一次数据就调用一次，在onNext之前调用，用于在subscribe之前对数据进行处理
doOnEach: Observable每发射一次数据就调用一次,包括onNext,onError和onComplete
subscribe 收到数据: 3
doAfterNext: 在onNext之后执行
doOnEach: Observable每发射一次数据就调用一次,包括onNext,onError和onComplete
doOnComplete: 数据发射完，Observable正常终止时调用
doAfterTerminate: 当调用onComplete和onError时触发
doFinally: 无论正常终止还是异常终止都会被调用