Rxjava2源码浅析(一)

前言

一直对Rxjava的实现很好奇,这次刚好有时间就看下它的源码,并把其中的思路记录下来,加深印象。先是看了其它人的分析后自己又去看了源码,说实话源码还是蛮绕的,可能自己还是对观察者模式理解的不够深刻吧…

这次主要了解三点:
1. 知道源头(Observable)是如何将数据发送出去的。
2. 知道终点（Observer）是如何接收到数据的。
3. 何时将源头和终点关联起来的。

---

源码分析

我们先用一个最简单的例子来看,这个例子不包含线程切换和其它操作符:

        Observable
                .create(
                        object : ObservableOnSubscribe<Int> {
                            override fun subscribe(e: ObservableEmitter<Int>) {
                                Log.i("test", "开始发送:")
                                e.onNext(1)
                                Log.i("test","准备结束:")
                                e.onComplete()
                            }
                        }
                )
                .subscribe(
                        object : Observer<Int> {
                            override fun onComplete() {
                                Log.i("test", "结束")
                            }

                            override fun onSubscribe(d: Disposable) {
                                Log.i("test", "注册成功!")
                            }

                            override fun onNext(t: Int) {
                                Log.i("test", "获得发送的数据:" + t.toString())
                            }

                            override fun onError(e: Throwable) {

                            }
                        }
                )

Log打印结果:

02-02 11:41:41.022 2602-2602/com.z2wenfa.innostic.main I/test: 注册成功!
02-02 11:41:41.022 2602-2602/com.z2wenfa.innostic.main I/test: 开始发送:
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 获得发送的数据:1
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 准备结束:
02-02 11:41:41.023 2602-2602/com.z2wenfa.innostic.main I/test: 结束

从Log日志我们已经能够看到执行的顺序了
先执行Observer的onSubscribe(d: Disposable) ->
再执行ObservableOnSubscribe的subscribe(e: ObservableEmitter<Int>)->
然后使用ObservableEmitter执行onNext()->Observer的onNext(t: Int)->
ObservableEmitter的onComplete()->Observer的onComplete()

看完执行的顺序我们开始通过源码看下内部是怎么实现的,为了更好的理解执行流程,代码我进行了部分的精简,首先我们来看Observable的create()方法。

create(ObservableOnSubscribe source)解析

 public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ......
        return new ObservableCreate<T>(source);
    }

从这里我们可以看到我们传入一个ObservableOnSubscribe对象返回一个ObservableCreate对象。来看下ObservableCreate的源码。

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);
        source.subscribe(parent);
        ......
    }
   }

这里我们可以看到ObservableCreate的构造函数就是把ObservableOnSubscribe给保存下来,这样做的目的是为了延迟将数据发送源和终点关联起来,我们看到ObservableCreate其实还是继承的Observable类,所以在获得ObservableCreate实例后调用subscribe方法。

---

subscribe(Observer observer)解析

 public final void subscribe(Observer<? super T> observer) {
           ......
           subscribeActual(observer);
           ......
 }

我们看到最终实际上调用的是subscribeActual(observer);我们再回头看下ObservableCreate的subscribeActual()方法。

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

我们一行一行的看,这里我们通过传入的Observer对象创建了一个CreateEmitter对象,来看下CreateEmitter对象的源码:

 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 (!isDisposed()) {
                observer.onNext(t);
            }
        }

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

        @Override
        public boolean tryOnError(Throwable t) {
           ......
            if (!isDisposed()) {
                try {
                    observer.onError(t);
                } finally {
                    dispose();
                }
                return true;
            }
            return false;
        }

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

通过源码能够看到首先判断时候isDisposed(),为True那么则不再执行后面的操作,如果为false再看,就是调用Observer相应的方法。这个ObservableEmitter还是一个包装类。
我们接着往下看,source.subscribe(parent);,还记得当时保存到Observable中的ObservableOnSubscribe source吗?传入创建的ObservableEmitter调用它的subscribe(@NonNull ObservableEmitter<T> e)这样我们就把Observable和Observer通过
ObservableEmitter这个适配器关联起来了,调用ObservableEmitter相应方法的同时,通知Observer执行对应的方法。

后言

经过源码分析之后,感觉自己是明白了点,但是能力有限,不知道写出来之后大家是否能够看的很明白,如果还有疑惑可以自己再多看看源码。

参考

RxJava2 源码解析（一）