Rxjava2源码分析

最新推荐文章于 2022-02-19 17:24:39 发布

置顶无名啊啊小辈

最新推荐文章于 2022-02-19 17:24:39 发布

阅读量180

点赞数 1

分类专栏： android rxjava 文章标签： android

本文链接：https://blog.csdn.net/qq_43676395/article/details/104864276

版权

android 同时被 2 个专栏收录

4 篇文章 0 订阅

订阅专栏

rxjava

2 篇文章 0 订阅

订阅专栏

Rxjava2源码分析（一）

看源码的前期工作
- 想了解源码解决了什么问题，就着重去想这些问题。
  - rxjava如何顺序执行的，即时是新开了线程，也是顺序执行了。
  - rxjava怎么切换线程的。
  - rxjava取消之后为什么后续不会执行了。
- 看源码要由整体到局部，由局部到细节，由简单到复杂。
- 看的过程有所记录，免得遗忘，也可以画结构图。

程序入口

Observable.create(new ObservableOnSubscribe<ArrayList<String>>() {
    @Override
    public void subscribe(ObservableEmitter<ArrayList<String>> emitter) throws Exception {
        ArrayList<String>stringArrayList=new ArrayList<>();
        stringArrayList.add("hello");
        emitter.onNext(stringArrayList);
        Log.i("msg1","上游事件线程"+Thread.currentThread());
    }
}).doOnNext(new Consumer<ArrayList<String>>() {
    @Override
    public void accept(ArrayList<String> s) throws Exception {
        Log.i("msg1","第1个线程开始执行"+Thread.currentThread());
             s.add("第一个");

    }
}).doOnNext(new Consumer<ArrayList<String>>() {
    @Override
    public void accept(ArrayList<String> s) throws Exception {
        Log.i("msg1","第2个线程开始执行"+Thread.currentThread());
       s.add("第二个");
    }
}).doOnNext(new Consumer<ArrayList<String>>() {
    @Override
    public void accept(ArrayList<String> s) throws Exception {
        Log.i("msg1","第3个线程开始执行"+Thread.currentThread());
       s.add("第三个");
    }
}).subsc.subscribe(new Observer<ArrayList<String>>() {
    @Override
    public void onSubscribe(Disposable d) {
        d.dispose();
    }
    @Override
    public void onNext(ArrayList<String> s) {
        Log.i("msg1","下游事件线程"+Thread.currentThread());
        Log.i("msg1","第四个线程"+s.toString());
    }
    @Override
    public void onError(Throwable e) {
    }
    @Override
    public void onComplete() {
    }
});

我们先看Observable.create（）方法

public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
//最终返回一个ObservableCreate类，并且将ObservableOnSubscribe参数传入构造函数中
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

我们来看ObservableCreate类

 public final class ObservableCreate<T> extends Observable<T> {
      final ObservableOnSubscribe<T> source;
	 public ObservableCreate(ObservableOnSubscribe<T> source) {
                this.source = source;
            }
……
        }

可以看到Observable.create（）方法其实就是生成ObservableCreate类，保存一个ObservableOnSubscribe引用，并且将ObservableCreate作为返回值。
再继续往下看doOnNext(new Consumer（））方法

private Observable<T> doOnEach(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete, Action onAfterTerminate) {
……
 return RxJavaPlugins.onAssembly(new ObservableDoOnEach<T>(this, onNext, onError, onComplete, onAfterTerminate));
        }

    }

doOnNext方法最终返回一个ObservableDoOnEach，并且将ObservableCreate，Consumer类传入它的构造函数中

 public final class ObservableDoOnEach<T> extends AbstractObservableWithUpstream<T, T> {
            final Consumer<? super T> onNext;
            final Consumer<? super Throwable> onError;
            final Action onComplete;
            final Action onAfterTerminate;

            public ObservableDoOnEach(ObservableSource<T> source, Consumer<? super T> onNext,
                                      Consumer<? super Throwable> onError,
                                      Action onComplete,
                                      Action onAfterTerminate) {
                super(source);
                this.onNext = onNext;
                this.onError = onError;
                this.onComplete = onComplete;
                this.onAfterTerminate = onAfterTerminate;
            }
……
        }
        abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {

            protected final ObservableSource<T> source;
            AbstractObservableWithUpstream(ObservableSource<T> source) {
                this.source = source;
            }
        }

从上面代码可以看出ObservableCreate被赋值为父类的成员变量source，Consumer类被保存到onNext成员变量中，如果下面继续调用两个doOnNext（）那么会形成如下结构。
在这里插入图片描述
之后再看subscribe（Observer）方法，要看ObservableDoOnEach的subscribe方法，因为最后返回的是ObservableDoOnEach类。ObservableDoOnEach的subscribe方法在Observable中，Observable是它的父类，它没有重写该方法。

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

                ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. 
                        subscribeActual(observer);
            } catch (NullPointerException e) { // NOPMD
                throw e;
            } catch (Throwable e) {
……
            }
        }
      //  该方法执行了subscribeActual(observer)方法，那我们来看ObservableDoOnEach的subscribeActual方法。
        @Override
        public void subscribeActual(Observer<? super T> t) {
            source.subscribe(new DoOnEachObserver<T>(t, onNext, onError, onComplete, onAfterTerminate));
        }
     //   这里是执行source的subscribe方法，并且将DoOnEachObserver类作为参数传入。
        static final class DoOnEachObserver<T> implements Observer<T>, Disposable {
            final Observer<? super T> downstream;
            final Consumer<? super T> onNext;
            final Consumer<? super Throwable> onError;
            final Action onComplete;
            final Action onAfterTerminate;

            Disposable upstream;

            boolean done;

            DoOnEachObserver(
                    Observer<? super T> actual,
                    Consumer<? super T> onNext,
                    Consumer<? super Throwable> onError,
                    Action onComplete,
                    Action onAfterTerminate) {
                this.downstream = actual;
                this.onNext = onNext;
                this.onError = onError;
                this.onComplete = onComplete;
                this.onAfterTerminate = onAfterTerminate;
            }
……
        }
      //  这里是一个递归调用，一直到ObservableCreate执行subscribeActual方法
        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);
            }
        }
        这里生成一个CreateEmitter，将observer作为参数传入
        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;
            }
        }
      //  接着执行ObservableDoOnEach的subscribe方法
        public void onSubscribe(Disposable d) {
            if (DisposableHelper.validate(this.upstream, d)) {
                this.upstream = d;
                downstream.onSubscribe(this);
            }
        }

这里就是给ObservableDoOnEach的upstream 逐一赋值赋值，就变成一个双向的链表了。
接着执行source.subscribe(parent)也就是

这里的方法
下面是以上代码形成的结构图
在这里插入图片描述
调用source.subscribe之后，上面的示例代码执行了emitter.onNext（T value）方法。

  @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()) {
//如果没有取消，那么就会执行下面的onNext方法，如果取消了，就不会往下执行了，这里肯定是逐步往下执行了
                observer.onNext(t);
            }
        }
//DoOnEachObserver的onNext方法，接着调用downstream的onNext方法。
        @Override
        public void onNext(T t) {
            if (done) {
                return;
            }
            try {
                onNext.accept(t);
            } catch (Throwable e) {
                Exceptions.throwIfFatal(e);
                upstream.dispose();
                onError(e);
                return;
            }

            downstream.onNext(t);
        }

这里可以回答上面的两个问题，第一个问题是如何顺序执行的，这里是一个双向链表结构，执行完该链表的方法会继续向下执行，还有一个问题是取消之后不会向下执行，那是因为，每一步执行之前都会检查是否取消了，如果取消，那么就不会继续执行了。
下面是rxjava2源码分析（二）链接: https://blog.csdn.net/qq_43676395/article/details/104877903.