Rxjava2源码分析之基本流程分析

最新推荐文章于 2022-12-30 15:33:25 发布

转载最新推荐文章于 2022-12-30 15:33:25 发布 · 123 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://juejin.im/post/5c469166e51d45518e14d20f

文章标签：

#java

本文深入解析RxJava2的基本使用方法，从create方法源码出发，详细解读ObservableCreate类的工作流程，包括数据发射器CreateEmitter的实现细节，以及如何通过subscribeActual方法触发数据流的传递过程。

首先看下rxjava2的基本使用方法

先看create方法源码

@CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
复制代码

先是进行判空，然后调用onAssembly，这个方法会返回传递进来的参数new ObservableCreate(source)，

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
        observer.onSubscribe(parent);

        try {
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }
复制代码

ObservableOnSubscribe是一个接口，内部只有一个方法

 void subscribe(@NonNull ObservableEmitter<T> emitter) throws Exception;
复制代码

ObservableEmitter也是接口，继承自Emitter，它就是数据发射器，内部有onNext,onError,onComplete等方法。

至此总结一下create方法：
1、Observable.create创建一个ObservableCreate对象，并且把ObservableOnSubscribe传递到ObservableCreate成员变量里记为source
2、ObservableCreate继承自Observable，内部有接下来要分析的 void subscribe(@NonNull Observer<? super T> observer);以及许多操作符（map,flatMap等）。

接下来看Observable.subscribe方法

最终调用的是subscribeActual抽象方法，他的实现在类ObservableCreate中，回顾一下ObservableCreate代码

第一步创建CreateEmitter实例，CreateEmitter是ObservableCreate的静态内部类

static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {


        private static final long serialVersionUID = -3434801548987643227L;

        final Observer<? super T> observer;

        CreateEmitter(Observer<? super T> observer) {
            this.observer = observer;
        }

        @Override
        public void onNext(T t) {
            if (t == null) {
                onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources."));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                RxJavaPlugins.onError(t);
            }
        }

        @Override
        public boolean tryOnError(Throwable t) {
            if (t == null) {
                t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
            }
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
                return true;
            }
            return false;
        }

        @Override
        public void onComplete() {
            if (!isDisposed()) {
                try {
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

        @Override
        public void setDisposable(Disposable d) {
            DisposableHelper.set(this, d);
        }

        @Override
        public void setCancellable(Cancellable c) {
            setDisposable(new CancellableDisposable(c));
        }

        @Override
        public ObservableEmitter<T> serialize() {
            return new SerializedEmitter<T>(this);
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }
    }
复制代码

里面有我们常见的onNext、onError、onComplete,并且由源码可知，当你调用完onComplete后会立刻走到 dispose()切断流，因此后面再发射数据也不会被接收了。
接着回到ObservableCreate.subscribeActual，走到 observer.onSubscribe(parent);这个方法是我们重写的第一个方法，也就是开始订阅的回调方法，在这里我们可以拿到CreateEmitter，而CreateEmitter又实现了Disposable接口，这样我们就可以控制流的切断了。
然后是source.subscribe(parent);这句就是调用了我们复写的数据发送的代码：

  Observable.create(new ObservableOnSubscribe<Integer>() {
            @Override
            public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
                emitter.onNext(1);
            }
        })
复制代码

至此就走完了整个流程。
所以其实真正执行的顺序是从下往上，即调用了subscribe(observer)才会触发上一级的subscribeActual直到初始ObservableCreate。

转载于:https://juejin.im/post/5c469166e51d45518e14d20f