RxJava2 中 doFinally 和 doAfterTerminate 的比较

在 RxJava 中 doFinally 和 doAfterTerminate 这两个操作符很类似，都会在 Observable 的 onComplete 或 onError 调用之后进行调用。

使用了这两个操作符在 Observable 结束后，会调用 doFinally、doAfterTerminate 所提供的 Action。

这两个操作符虽然有一定的相似度，但他们依然有差别。并且两者在使用时，会存在调用的先后顺序。

doAfterTerminate

从 doAfterTerminate 操作符的源码来看

1.    @CheckReturnValue

2.    @SchedulerSupport(SchedulerSupport.NONE)

3.    public final Observable<T> doAfterTerminate(Action onFinally) {

4.        ObjectHelper.requireNonNull(onFinally, "onFinally is null");

5.        return doOnEach(Functions.emptyConsumer(), Functions.emptyConsumer(), Functions.EMPTY_ACTION, onFinally);

6.    }

它调用的是 doOnEach() 方法。

其实，doOnNext、doOnError、doOnComplete、doOnTerminate 等这些操作符也是调用 doOnEach() 方法。

doOnEach() 实际上调用的是 ObservableDoOnEach 类。( RxJavaPlugins.onAssembly 本身是一个 hook 方法，会返回一个 Observable 对象。）

doOnEach() 需要四个参数：onNext、onError、onComplete、onAfterTerminate。doAfterTerminate 操作符的参数 onFinally 对应的是 onAfterTerminate。

1.    @CheckReturnValue

2.    @SchedulerSupport(SchedulerSupport.NONE)

3.    private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) {

4.        ObjectHelper.requireNonNull(onNext, "onNext is null");

5.        ObjectHelper.requireNonNull(onError, "onError is null");

6.        ObjectHelper.requireNonNull(onComplete, "onComplete is null");

7.        ObjectHelper.requireNonNull(onAfterTerminate, "onAfterTerminate is null");

8.        return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate));

9.    }

ObservableDoOnEach 继承了 Observable 类，并实现了它的抽象方法 subscribeActual()。该方法是 Observable 和 Observer 连接的纽带。其中，source 代表了被观察者 Observable 本身，而 DoOnEachObserver 是实际的观察者。

1.    @Override

2.    public void subscribeActual(Observer<? super T> t) {

3.        source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate));

4.    }

从 DoOnEachObserver 中的 onError()、onComplete() 方法中可以看到 onAfterTerminate 是在 downstream.onError(t) 或者 downstream.onComplete() 之后，才执行 run()。这也符合我们最初对它的认识。

1.        @Override

2.        public void onError(Throwable t) {

3.            if (done) {

4.                RxJavaPlugins.onError(t);

5.                return;

6.            }

7.            done = true;

8.            try {

9.                onError.accept(t);

10.            } catch (Throwable e) {

11.                Exceptions.throwIfFatal(e);

12.                t = new CompositeException(t, e);

13.            }

14.            downstream.onError(t);

15. 
    

16.            try {

17.                onAfterTerminate.run();

18.            } catch (Throwable e) {

19.                Exceptions.throwIfFatal(e);

20.                RxJavaPlugins.onError(e);

21.            }

22.        }

23. 
    

24.        @Override

25.        public void onComplete() {

26.            if (done) {

27.                return;

28.            }

29.            try {

30.                onComplete.run();

31.            } catch (Throwable e) {

32.                Exceptions.throwIfFatal(e);

33.                onError(e);

34.                return;

35.            }

36. 
    

37.            done = true;

38.            downstream.onComplete();

39. 
    

40.            try {

41.                onAfterTerminate.run();

42.            } catch (Throwable e) {

43.                Exceptions.throwIfFatal(e);

44.                RxJavaPlugins.onError(e);

45.            }

46.        }

doFinally

doFinally 是 RxJava 在 2.0.1 版本新增的操作符。

doFinally 除了拥有 doAfterTerminate 的特性之外，还会在下游(downstream)取消时被调用。这是 doFinally 和 doAfterTerminate 最大的区别。

同样，看一下 doFinally 的源码。它调用的是 ObservableDoFinally 类。

1.    public final Observable<T> doFinally(Action onFinally) {

2.        ObjectHelper.requireNonNull(onFinally, "onFinally is null");

3.        return RxJavaPlugins.onAssembly(new ObservableDoFinally<T>(this, onFinally));

4.    }

在 ObservableDoFinally 类中，从 subscribeActual() 可以看出它的实际观察者是 DoFinallyObserver 类。其中，onFinally 是 doFinally 操作符所传递的参数。

1.    @Override

2.    protected void subscribeActual(Observer<? super T> observer) {

3.        source.subscribe(new DoFinallyObserver<T>(observer, onFinally));

4.    }

在 DoFinallyObserver 类中的 onError、onComplete、dispose 方法中都会调用 runFinally() 方法。而 runFinally() 执行的正是 onFinally 的 run()。

1.        @Override

2.        public void onError(Throwable t) {

3.            downstream.onError(t);

4.            runFinally();

5.        }

6. 
   

7.        @Override

8.        public void onComplete() {

9.            downstream.onComplete();

10.            runFinally();

11.        }

12. 
    

13.        @Override

14.        public void dispose() {

15.            upstream.dispose();

16.            runFinally();

17.        }

18. 
    

19.        ......

20. 
    

21.        void runFinally() {

22.            if (compareAndSet(0, 1)) {

23.                try {

24.                    onFinally.run();

25.                } catch (Throwable ex) {

26.                    Exceptions.throwIfFatal(ex);

27.                    RxJavaPlugins.onError(ex);

28.                }

29.            }

30.        }

所以，从源码可以得出在 doFinally 是在观察者执行完 onError、onComplete 或取消时执行的操作。

二者的顺序

doFinally 和 doAfterTerminate 都会在 onComplete 之后才执行，那么它们二者的顺序是如何呢？

不妨写一段代码测试一下：

1.        Observable.just("Hello World")

2.                .doOnNext(s -> System.out.println("doOnNext："))

3.                .doFinally(() -> System.out.println("doFinally："))

4.                .doAfterTerminate(() -> System.out.println("doAfterTerminate："))

5.                .subscribe(

6.                        s -> System.out.println("onNext：" + s),

7.                        throwable -> System.out.println("onError："),

8.                        () -> System.out.println("onComplete："));

执行结果：

1. doOnNext：

2. onNext：Hello World

3. onComplete：

4. doAfterTerminate：

5. doFinally：

发现 doFinally 是在 doAfterTerminate 之后调用。

那么交换一下它们的顺序会如何呢？

1.        Observable.just("Hello World")

2.                .doOnNext(s -> System.out.println("doOnNext："))

3.                .doAfterTerminate(() -> System.out.println("doAfterTerminate："))

4.                .doFinally(() -> System.out.println("doFinally："))

5.                .subscribe(

6.                        s -> System.out.println("onNext：" + s),

7.                        throwable -> System.out.println("onError："),

8.                        () -> System.out.println("onComplete："));

执行结果：

1. doOnNext：

2. onNext：Hello World

3. onComplete：

4. doFinally：

5. doAfterTerminate：

这一次，doFinally 先执行而 doAfterTerminate 后执行。

因为，它们都需要在 downstream.onComplete() 执行之后，才会执行。而 downstream 对应的下游是观察者。下流的数据流向跟上游的数据流向是相反的，从下向上的。所以，离观察者越近，就越先执行。这就是两段代码执行顺序不同的缘故。

最后，写一个极端一点的例子，先后调用 doFinally、doAfterTerminate、doFinally、doAfterTerminate：

1.        Observable.just("Hello World")

2.                .doOnNext(s -> System.out.println("doOnNext："))

3.                .doFinally(() -> System.out.println("doFinally1："))

4.                .doAfterTerminate(() -> System.out.println("doAfterTerminate1："))

5.                .doFinally(() -> System.out.println("doFinally2："))

6.                .doAfterTerminate(() -> System.out.println("doAfterTerminate2："))

7.                .subscribe(

8.                        s -> System.out.println("onNext：" + s),

9.                        throwable -> System.out.println("onError："),

10.                        () -> System.out.println("onComplete："));

执行结果：

1. doOnNext：

2. onNext：Hello World

3. onComplete：

4. doAfterTerminate2：

5. doFinally2：

6. doAfterTerminate1：

7. doFinally1：

在 onComplete 调用之后，先打印了"doAfterTerminate2："，再打印"doFinally2："，然后打印"doAfterTerminate1："，最后打印"doFinally1："。这正好符合刚才的分析。

总结

本文是对 doFinally 和 doAfterTerminate 两个操作符的总结。也是对《RxJava 2.x 实战》一书中，第二章第一节最后一部分内容do操作符的补充。

只有了解源码，才能更踏实地去写我们的程序。

关注【Java与Android技术栈】

更多精彩内容请关注扫码：