RxJava源码分析之Observable

在学习本篇之前，我们先来看几个概念：

Observable，其英文翻译是可观察者的意思；

Observer，其英文翻译是观察者的意思；

通过这两个概念我们就可以很清楚的明白它们是做什么用的了吧，下面我们来看下它们的使用：

val observable:Observable<Int> = Observable.create(ObservableOnSubscribe<Int> {
            it.onNext(1)
            it.onNext(2)
            it.onNext(3)
            it.onNext(4)
            it.onError(Throwable())
            it.onComplete()
        })

上述例子通过Observable的create方法创建了Observable对象。其中create中传入了一个ObservableOnSubscribe接口对象，并实现了其subscribe方法用于通知观察者；

可以看到在subscribe方法内部我们使用了onNext等方法，下面会讲，接下来我们先来看下Observer的用法：

 

val observer: Observer<Int> = object : Observer<Int> {
            override fun onComplete() {
                println("========onComplete   ")
            }

            override fun onSubscribe(d: Disposable) {
                println("========onSubscribe   ")
            }

            override fun onNext(t: Int) {
                println("========onNext   $t")
            }

            override fun onError(e: Throwable) {
                println("========onError   ")
            }
        }

public interface Observer<T> {

    /**
     * Provides the Observer with the means of cancelling (disposing) the
     * connection (channel) with the Observable in both
     * synchronous (from within {@link #onNext(Object)}) and asynchronous manner.
     * @param d the Disposable instance whose {@link Disposable#dispose()} can
     * be called anytime to cancel the connection
     * @since 2.0
     */
    void onSubscribe(@NonNull Disposable d);

    /**
     * Provides the Observer with a new item to observe.
     * <p>
     * The {@link Observable} may call this method 0 or more times.
     * <p>
     * The {@code Observable} will not call this method again after it calls either {@link #onComplete} or
     * {@link #onError}.
     *
     * @param t
     *          the item emitted by the Observable
     */
    void onNext(@NonNull T t);

    /**
     * Notifies the Observer that the {@link Observable} has experienced an error condition.
     * <p>
     * If the {@link Observable} calls this method, it will not thereafter call {@link #onNext} or
     * {@link #onComplete}.
     *
     * @param e
     *          the exception encountered by the Observable
     */
    void onError(@NonNull Throwable e);

    /**
     * Notifies the Observer that the {@link Observable} has finished sending push-based notifications.
     * <p>
     * The {@link Observable} will not call this method if it calls {@link #onError}.
     */
    void onComplete();

}

我们从代码可以看出来Observer是一个接口类，内部有以上四个函数；

onSubscribe表示在订阅时，当观察者Observer订阅可观察对象Observable，建立订阅关系后，会触发这个方法，并且会生成一个Disposable对象，其实无论观察者Observer以何种方式订阅可观察对象Observable，都会生成一个Disposable，不管有没有onSubscribe(Disposable d)方法

onNext发用于发送消息数据，onError用于发送异常通知，onComplete方法用于发送完成通知。

通过源码我们可以看出onError方法上方有一句注释，“If the {@link Observable} calls this method, it will not thereafter call {@link #onNext} or {@link #onComplete}”，大概意思是说当onError这个方法被调用过之后就不能再次调用onNext和onComplete方法

同样的，在onComplete方法上也标明了当调用了onComplete方法后就不可以调用onError方法。

我们现在定义好了Observable和Observer，让我们来看一下它们是怎么使用的。

其实我们上面已经提到了，Observable内部实现了ObservableOnSubscribe这个接口，除此之外还定义了多个subscribe方法用于不同情况下的数据处理，如下图：

调用方式：observable.subscribe(observer)

通过日志我们可以看到，我们明明在onError的后面调用了onComplete方法，但并没有走，这也就是我们上面看到源码里讲的在调用了onError之后不能调用onComplete。

我们来看一下onComplete方法的源码

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

可以看到onComplete方法进入就有一个if判断，当这个observable被销毁return掉，而恰恰是在调用完onError之后的finally中调用了dispose的方法，这也就是为什么onNext，onComplete不能再次调用的原因。

@Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
                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;
        }

其中还有一点，我们再来看下源码，一旦调用了dispose，那么再次调用的时候就会抛出异常了，所以onError和onComplete是不可以重复调用的，这点一定要注意。