RxJava ：源码学习笔记（一）

最新推荐文章于 2024-09-23 08:40:31 发布

原创最新推荐文章于 2024-09-23 08:40:31 发布 · 136 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #android

Java基础专栏收录该内容

21 篇文章

订阅专栏

本文深入研究RxJava的内部实现机制，详细解析Observable的.create()和.subscribe()方法如何工作，通过实例展示事件订阅流程及核心组件的功能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

好奇RxJava的内部实现，怎么实现订阅，以及内部的流程，本篇文章主要研究Observable的.create()和.subscribe（）

先来个简单的栗子

 Observable
                .create(
                        //  此处称为起点，source
                        new ObservableOnSubscribe<String>() {
                            @Override
                            public void subscribe(ObservableEmitter<String> e) throws Exception {

                            }
                        }
                ).subscribe(
                //  此处称为终点
                new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    @Override
                    public void onNext(String s) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

逻辑比较简单 Observable 调用 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));
    }

一个判空，一个hook，咱们看看onAssembly方法作用

@NonNull
    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;
    }

根据源码来看这就是个hook机制，没啥影响
咱们再看 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);
        }
    }
    ...
    ...
 }

这个环节只是 new ObservableOnSubscribe() 当做 source 放入其中，此处之后的方法应该是由 ObservableCreate . 出来的，咱们继续往下走

Observable.subscribe(new Observer<String>(){} );

@SchedulerSupport(SchedulerSupport.NONE)
    @Override
    public final void subscribe(Observer<? super T> observer) {
        ObjectHelper.requireNonNull(observer, "observer is null");
        try {
        	//	依旧是hook
            observer = RxJavaPlugins.onSubscribe(this, observer);
			//	判空
            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
			//	没有实现，由  ObservableCreate 实现
            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;
        }
    }

此处有用的代码只有一句
subscribeActual(observer);
点进去并没有实现，回想之前，此方法应该由ObservableCreate实现，咱们看看

@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);
        }
    }

看看这段代码的实现：
1.首先把observer装箱，放入CreateEmitter中，咱们暂且叫他为‘一级包’
2.调用observer的onSubscribe方法，订阅完成，此处可以接收一个disposable
3.调用source.subscribe(parent)，此处的source就是咱们的new ObservableOnSubscribe()，即实现咱们的

emitter.onNext("start");
emitter.onNext("end");
emitter.onComplete();

3.1 上面代码段中的emitter即 ‘一级包’ CreateEmitter
emitter.onNext(“start”)====》CreateEmitter.onNext(“start”)

@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);
            }
        }

3.2 上面是实现：先判空，在用isDisposed判断是否需要继续执行，最后调用 observer.onNext(t)；observer就是咱们的终点，也就是咱们放入’一级包’的终点，不需要再拆包，直接调用 observer.onNext(String)即可

总结：RxJava是先执行到底部完成事件的订阅，又返回起点往下走，呈’U’型结构，中间的流程有点像递归，不断装箱、拆箱

下面是整体流程的注释代码

Observable
                //  1. Observable.create
                //  return new ObservableCreate<T>(source)     source---> ObservableOnSubscribe<String> ,第一步只有把source放入，没啥别的操作
                //  2.1.4   emitter.onNext("start") 的实现   emitter 即 CreateEmitter<String>
                //      CreateEmitter.onNext("start") 内部调用  observer.onNext(t); 即调用终点的onNext
                .create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                        emitter.onNext("start");
                        emitter.onNext("end");
                        emitter.onComplete();
                    }
                })
                //  2. ObservableCreate.subscribe
                //  2.1 调用  ObservableCreate.subscribeActual(observer)
                //  2.1.1   CreateEmitter<T> parent = new CreateEmitter<T>(observer);   将observer装箱，放入CreateEmitter
                //  2.1.2   observer.onSubscribe(parent);  调用Observer的订阅方法,此时可以接受一个Disposable，用于终止
                //  2.1.3    source.subscribe(parent);      此处的source是 1 的source，即是ObservableOnSubscribe<String>().parent是source装箱后的一级包CreateEmitter<String> ，实现咱们在
                //          public void subscribe(ObservableEmitter<String> emitter) 中的方法:
                //              emitter.onNext("start");emitter.onNext("end");emitter.onComplete();
                .subscribe(new Observer<String>() {

                    //  2.1.2   实现的地方，实现订阅
                    @Override
                    public void onSubscribe(Disposable d) {

                    }

                    //  2.1.4   实现调用的地方
                    @Override
                    public void onNext(String s) {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onComplete() {

                    }
                });

Github 代码笔记