RxJava : do操作符

参考：

Rx系列<第三篇>：RxJava之do操作符

（1）doOnSubscribe：在被观察者和观察者产生关联的时候被调用，disposable可以立即取消订阅；
（2）doOnLifecycle：可以在订阅之后设置是否取消订阅；
（3）doNext和doAfterNext：可以接收到被观察者发射过来的数据；
（4）doOnEach：当onNext、onError、onComplete被触发是被调用；
（5）doOnComplete：当触发onComplete时被调用；
（6）doOnError：当触发onError时被调用；
（7）doFinally：当触发onError或onComplete时被调用；
（8）doOnDispose：当取消订阅时被调用；
（9）doAfterTerminate：订阅终止时被调用；

@Test
public void test1() {
    Observable.create(new ObservableOnSubscribe<Integer>() {
        @Override
        public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
            emitter.onNext(1);
            
            //==========onComplete onError互斥==================
            emitter.onComplete();
//                emitter.onError(new Throwable("-error-"));
        }
    })
            .doOnNext(new Consumer<Integer>() {
                @Override
                public void accept(Integer integer) throws Exception {
                    System.out.println("doOnNext integer:" + integer);
                }
            })
            .doOnComplete(new Action() {
                @Override
                public void run() throws Exception {
                    System.out.println("doOnComplete");
                }
            })
            .doOnError(new Consumer<Throwable>() {
                @Override
                public void accept(Throwable throwable) throws Exception {
                    System.out.println("doOnError" + throwable.getMessage());
                }
            })
            .subscribe(new Observer<Integer>() {
                @Override
                public void onSubscribe(Disposable d) {

                }

                @Override
                public void onNext(Integer integer) {
                    System.out.println("onNext integer:" + integer);
                }

                @Override
                public void onError(Throwable e) {
                    System.out.println("onError" + e.getMessage());
                }

                @Override
                public void onComplete() {
                    System.out.println("onComplete");
                }
            });

}
//doOnNext integer:1
//onNext integer:1
//doOnComplete
//onComplete

综合示例：

//do系列操作符相当于给Observable执行周期的关键节点添加回调。
// 当Observable执行到这个阶段的时候，这些回调就会【先被触发】。
// 当Observable每发送一个数据时，doOnNext会被首先调用，然后再onNext。
// 若发射中途出现异常doOnError会被调用，然后onError。
// 若数据正常发送完毕doOnCompleted会被触发，然后执行onCompleted。
// 当订阅或者解除订阅doOnSubscribe，doOnUnsubscribe会被执行。
Observable.just(1, 2, 3)
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        .doOnSubscribe(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                System.out.println("doOnSubscribe==========");
            }
        })
        .doOnDispose(new Action() {//当取消订阅时被调用；
            @Override
            public void run() throws Exception {
                System.out.println("doOnDispose==========");
            }
        })
        .doOnTerminate(new Action() {//订阅终止时被调用；
            @Override
            public void run() throws Exception {
                System.out.println("doOnTerminate==========");
            }
        })
        .doAfterTerminate(new Action() {
            @Override
            public void run() throws Exception {
                System.out.println("doAfterTerminate==========");
            }
        })
        .doOnLifecycle(new Consumer<Disposable>() {
            @Override
            public void accept(Disposable disposable) throws Exception {
                System.out.println("doOnLifecycle accept==========");
            }
        }, new Action() {
            @Override
            public void run() throws Exception {
                System.out.println("doOnLifecycle run==========");
            }
        })
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //##############################################################
        .doOnNext(new Consumer<Integer>() {//可以接收到被观察者发射过来的数据之前；
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println("doOnNext==========" + integer);
            }
        })
        .doAfterNext(new Consumer<Integer>() {//可以接收到被观察者发射过来的数据之后；
            @Override
            public void accept(Integer integer) throws Exception {
                System.out.println("doAfterNext==========" + integer);
            }
        })
        //##############################################################
        //**************************************************************
        .doOnComplete(new Action() {
            //当触发onComplete时被调用；
            @Override
            public void run() throws Exception {
                System.out.println("doOnComplete==========");
            }
        })
        .doOnError(new Consumer<Throwable>() {
            //当触发onError时被调用；
            @Override
            public void accept(Throwable throwable) throws Exception {
                System.out.println("doOnError==========");
            }
        })
        .doFinally(new Action() {
            //当触发onError或onComplete时被调用；
            @Override
            public void run() throws Exception {
                System.out.println("doFinally==========");
            }
        })
        .doOnEach(new Consumer<Notification<Integer>>() {
            //当onNext、onError、onComplete被触发时被调用；
            @Override
            public void accept(Notification<Integer> integerNotification) throws Exception {
                System.out.println("doOnEach==========" + integerNotification.getValue());
            }
        })
        //**************************************************************
        .subscribe(new Observer<Integer>() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println(">>>>>>>>>>>>onSubscribe==========");
            }

            @Override
            public void onNext(Integer integer) {
                System.out.println(">>>>>>>>>>>>onNext==========" + integer);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println(">>>>>>>>>>>>onError==========");
            }

            @Override
            public void onComplete() {
                System.out.println(">>>>>>>>>>>>onComplete==========");
            }
        });
        
//doOnLifecycle accept==========

//doOnSubscribe==========
//>>>>>>>>>>>>onSubscribe==========

//doOnEach==========1
//doOnNext==========1
//>>>>>>>>>>>>onNext==========1
//doAfterNext==========1

//doOnEach==========2
//doOnNext==========2
//>>>>>>>>>>>>onNext==========2
//doAfterNext==========2

//doOnEach==========3
//doOnNext==========3
//>>>>>>>>>>>>onNext==========3
//doAfterNext==========3

//doOnComplete==========
//doOnEach==========null
//doOnTerminate==========
//>>>>>>>>>>>>onComplete==========
//doFinally==========
//doAfterTerminate==========

doOnNext测试一：

Disposable disposable = Observable.just("1", "2")
        .doOnNext(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("doOnNext=============" + s);
            }
        })
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println("accept=============" + s);
            }
        });
//doOnNext=============1
//accept=============1

//doOnNext=============2
//accept=============2

doOnNext测试二：

Observable.just("1", "2")
    .map(new Function<String, String>() {
        @Override
        public String apply(String s) throws Exception {
            return "map1:" + s;
        }
    })
    .doOnNext(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            System.out.println("doOnNext1==========" + s);
        }
    })
    .map(new Function<String, String>() {
        @Override
        public String apply(String s) throws Exception {
            return "map2:" + s;
        }
    })
    .doOnNext(new Consumer<String>() {
        @Override
        public void accept(String s) throws Exception {
            System.out.println("doOnNext2============" + s);
        }
    })
    .subscribe(new Observer<String>() {
        @Override
        public void onSubscribe(Disposable d) {

        }

        @Override
        public void onNext(String s) {
            System.out.println("onNext=========" + s);
        }

        @Override
        public void onError(Throwable e) {
            System.out.println("onError======="+e.getMessage());
        }

        @Override
        public void onComplete() {
            System.out.println("onComplete=======");
        }
    });
//doOnNext1==========map1:1
//doOnNext2============map2:map1:1
//onNext=========map2:map1:1

//doOnNext1==========map1:2
//doOnNext2============map2:map1:2
//onNext=========map2:map1:2

//onComplete=======

doOnTerminate / doAfterTerminate 测试：

Observable.create(new ObservableOnSubscribe<Integer>() {
    @Override
    public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
        emitter.onNext(1);
        emitter.onNext(2);
        emitter.onComplete();
    }
}).doOnTerminate(new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("==========doOnTerminate===========");
    }
}).doAfterTerminate(new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("==========doAfterTerminate===========");
    }
}).doOnDispose(new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("==========doOnDispose===========");
    }
}).doOnSubscribe(new Consumer<Disposable>() {
    @Override
    public void accept(Disposable disposable) throws Exception {
        System.out.println("==========doOnSubscribe===========");
    }
}).doOnLifecycle(new Consumer<Disposable>() {
    @Override
    public void accept(Disposable disposable) throws Exception {
        System.out.println("========== doOnLifecycle accept ===========");
    }
}, new Action() {
    @Override
    public void run() throws Exception {
        System.out.println("========== doOnLifecycle run ===========");
    }
}).subscribe(new Observer<Integer>() {
    @Override
    public void onSubscribe(Disposable disposable) {
        mDisposable = disposable;
        System.out.println("==========onSubscribe===========");
    }

    @Override
    public void onNext(Integer integer) {
        System.out.println("==========onNext===========" + integer);
    }

    @Override
    public void onError(Throwable e) {
        System.out.println("==========onError===========");
    }

    @Override
    public void onComplete() {
        System.out.println("==========onComplete===========");
    }
});

if (mDisposable != null && !mDisposable.isDisposed()) {
    mDisposable.dispose();
}


//==========doOnSubscribe===========
//========== doOnLifecycle accept ===========
//==========onSubscribe===========
//
//==========onNext===========1
//==========onNext===========2
//
//==========doOnTerminate===========
//==========onComplete===========
//==========doAfterTerminate===========