你所不知道的Rxjava原理

最新推荐文章于 2023-01-18 11:08:53 发布

qq_35561554

最新推荐文章于 2023-01-18 11:08:53 发布

阅读量751

点赞数 1

分类专栏： RxJava源码分析文章标签： Rxjava源码分析

本文链接：https://blog.csdn.net/qq_35561554/article/details/100958565

版权

本文详细介绍了RxJava的核心设计思想、基本使用方法以及源码分析，包括创建被观察者、观察者，线程切换的原理，并通过源码解读展示了RxJava如何实现线程控制和变换操作。通过对RxJava的深入理解，揭示了其面对复杂应用场景的灵活性和链式调用的便利性。

摘要由CSDN通过智能技术生成

RxJava是什么？

根据官方文档：RxJava是ReactiveX（Reactive Extensions）的Java VM实现：一个库，用于通过使用可观察序列来编写异步和基于事件的程序。

rxjava核心设计思想

要使用RxJava，您需要创建Observables（发出数据项），以各种方式转换这些Observable以获取您感兴趣的精确数据项（通过使用Observable运算符），然后观察并响应这些有趣项目序列（通过实现观察者）或者订阅者，然后将它们订阅到最终的变换后的Observables）。

RxJava使用&原理分析

基本使用

创建被观察者
创建观察者
链接观察者和被观察者

//创建被观察者
        Observable<String> observable =  Observable.create( new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                Log.d( TAG, "Observable subscribe ");
                emitter.onNext( "我叫王大麻子" );
                emitter.onComplete();
            }
        } );
        //创建观察者
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                Log.d( TAG, "Observer onSubscribe ");
            }

            @Override
            public void onNext(String s) {
                Log.d( TAG, "Observer onNext "+s);
            }

            @Override
            public void onError(Throwable e) {
                Log.d( TAG, "Observer onError ");
            }

            @Override
            public void onComplete() {
                Log.d( TAG, "Observer onComplete ");
            }
        };
        //通过subscribe链接观察者和被观察者
        observable.subscribe( observer);

输出日志：

通过日志我们知道RxJava的执行顺序是:

观察者的onSubscribe方法
被观察者的subscribe方法
观察者的onNext、onComplete或者onError

基本使用源码分析

Observable<T>实现了ObservableSource<T>接口，泛型T指定了观察者将会接收到的数据类型。

在上面的例子中我们将T限定为String,在observer中的onNext会就收到一个String 类型的对象。

Observable的crate方法

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
 @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;
    }

从上面的代码我们知道create最终创建的是一个持有ObservableOnSubscribe<T>的ObservableCreate<T>对象。我们来看看它的实现：

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);
        //1.通知观察者订阅成功
        observer.onSubscribe(parent);

        try {
            //2.被观察者开始进行工作 调用Emitter的onNext、onError、onComplete方法。
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

    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()) {
                //3.观察者接收到onNext
                observer.onNext(t);
            }
        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                //3.观察者接收到onError
                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 {
                     //3.观察者接收到onComplete
                    observer.onComplete();
                } finally {
                    dispose();