android RxJava（二）--实现原理分析_andriod rxjava2 原理详解-优快云博客

本文链接：https://blog.youkuaiyun.com/StudyOfAndroid/article/details/108773692

最近在学习RxJava，对RxJava的原理也学习了一下，这里做一下记录。自己理解，有误欢迎指出。

就以最简单的为例：

Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> emitter) throws Throwable {
                emitter.onNext("send1");
                emitter.onComplete();
            }
        }).observeOn(AndroidSchedulers.mainThread()) //前台线程展示
                .subscribeOn(Schedulers.io()) //后台线程处理数据
                .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(@NonNull Disposable d) {
                        Log.e(TAG, "Observable1  onSubscribe = " + d.isDisposed());
                    }

                    @Override
                    public void onNext(@NonNull String s) {
                        Log.e(TAG, "Observable1  onNext = " + s);
                    }

                    @Override
                    public void onError(@NonNull Throwable e) {
                        Log.e(TAG, "Observable1  onError = " + e.getMessage());
                    }

                    @Override
                    public void onComplete() {
                        Log.e(TAG, "Observable1  onComplete");
                    }
                });

具体的流程如下所示：
在这里插入图片描述
几个类之间的关系：

1、create方法就是要创建`ObservableCreate`对象，ObservableCreate对象内部持有被观察者的引用，并且还有发射器的CreateEmitter内部类

public static <T> Observable<T> create(@NonNull ObservableOnSubscribe<T> source) {
        Objects.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<>(source));
    }

调用RxJavaPlugins将被订阅者存放到onObservableAssembly中

public static <T> Observable<T> onAssembly(@NonNull Observable<T> source) {
        Function<? super Observable, ? extends Observable> f = onObservableAssembly;
        if (f != null) {
            return apply(f, source);
        }
        return source;
    }

调用下面的方法，确定是否需要转换map中的Function内部实现方法apply，

public interface Function<@NonNull T, @NonNull R> {
    /**
     * Apply some calculation to the input value and return some other value.
     * @param t the input value
     * @return the output value
     * @throws Throwable if the implementation wishes to throw any type of exception
     */
    R apply(T t) throws Throwable;
}

转换完之后，将ObservableOnSubscribe对象返回，继续下一步，

2、`observeOn(AndroidSchedulers.mainThread())`

调用Observable中的方法

public final Observable<T> observeOn(@NonNull Scheduler scheduler) {
        return observeOn(scheduler, false, bufferSize());
    }
    
public final Observable<T> observeOn(@NonNull Scheduler scheduler, boolean delayError, int bufferSize) {
        Objects.requireNonNull(scheduler, "scheduler is null");
        ObjectHelper.verifyPositive(bufferSize, "bufferSize");
        return RxJavaPlugins.onAssembly(new ObservableObserveOn<>(this, scheduler, delayError, bufferSize));
    }

这里也是看创建ObservableObserveOn对象，RxJavaPlugins.onAssembly()方法的功能就是检测，对象有没有进行转换操作，没有就直接返回

3、`subscribeOn(Schedulers.io())`也是同样的创建`ObservableSubscribeOn`对象

4、接下来就是订阅了，`subscribe(new Observer)`方法了，

public final void subscribe(@NonNull Observer<? super T> observer) {
        Objects.requireNonNull(observer, "observer is null");
        try {
            observer = RxJavaPlugins.onSubscribe(this, observer);

            Objects.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");

            subscribeActual(observer);
        } catch (NullPointerException e) { // NOPMD
            throw e;
        } catch (Throwable e) {
            Exceptions.throwIfFatal(e);
            // can't call onError because no way to know if a Disposable has been set or not
            // can't call onSubscribe because the call might have set a Subscription already
            RxJavaPlugins.onError(e);

            NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
            npe.initCause(e);
            throw npe;
        }
    }

就是两部操作，

4.1 一个是`observer = RxJavaPlugins.onSubscribe(this, observer);`这个方法内部就是进行订阅，将两者进行关联

public static <T> Observer<? super T> onSubscribe(@NonNull Observable<T> source, @NonNull Observer<? super T> observer) {
        BiFunction<? super Observable, ? super Observer, ? extends Observer> f = onObservableSubscribe;
        if (f != null) {
            return apply(f, source, observer);
        }
        return observer;
    }

4.2 第二个就是`subscribeActual(observer);`就是看各个实现类具体的实现方法了，这里使用的是create方法，就看`ObservableCreate`被订阅者中的实现方法

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

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

这里就是三个步骤了

4.2.1 创建发射器，发射器内部有观察者的引用，方法onNext就是调用observer观察中的方法onNext进行处理，其他方法都是同样的

@Override
        public void onNext(T t) {
            if (t == null) {
                onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
                return;
            }
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }