重新认识RxJava系列之订阅流程源码分析

前言

学习RxJava，我们不光要知道它如何使用，还要理解它的原理。只有这样，我们才能不断的成长，早日成为大佬。

基本订阅流程

常用代码

  Observable
                .create(new ObservableOnSubscribe<String>() {
                    @Override
                    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
                        emitter.onNext("1");
                        emitter.onNext("2");
                        emitter.onNext("3");
                        emitter.onComplete();
                    }
                })
                .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() {
                       
                    }
                });
复制代码

上面的代码就是我们一般实现订阅的基本代码了，然后我们一步步的来分析源码实现。

创建被观察者

    public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        ObjectHelper.requireNonNull(source, "source is null");
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }
复制代码

可以看到最后调用了RxJavaPlugins.onAssembly方法，并且传入了一个ObservableCreate对象。

onAssembly()

  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;
    }
复制代码

从上面的方法中可以看到最后返回的是传入的source对象，也就是ObservableCreate对象，那么ObservableCreate是什么呢?

public final class ObservableCreate<T> extends Observable<T> {
//省略...
  @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);
        }
    }
 }
复制代码

可以看出ObservableCreate继承了Observable，然后subscribeActual内部实现大概分为以下三步。

• 创建CreateEmitter
• 调用onSubscribe()
• 调用subscribe()发送事件

CreateEmitter

从源码中可以看出将observer传递给了CreateEmitter对象，然后又将CreateEmitter对象传递给了onSubscribe方法。首先来看一下CreateEmitter源码

   static final class CreateEmitter<T>
    extends AtomicReference<Disposable>
    implements ObservableEmitter<T>, Disposable {

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

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

    }
复制代码

可以看出在onNext方法和onComplete方法中分别对是否处于Disposed状态进行了判断处理。然后通过查看源码知道了CreateEmitter实现了ObservableEmitter接口，看一下CreateEmitter的onNext方法。

   @Override
        public void onNext(T t) {
          //......
            if (!isDisposed()) {
                observer.onNext(t);
            }
        }
复制代码

可以看出当不处于Disposed状态时，将会调用observer的onNext方法，也就是我们常见的onNext方法。

@Override
 public void onNext(String s) {
                //作出响应动作      
            }
复制代码

observer.onSubscribe()

调用观察者的onSubscribe()，也就是我们在创建观察者时复写的onSubscribe()。该方法是发生下被观察者发送事件之前的，部分代码如下：

 .subscribe(new Observer<String>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        
                    }
                    //.....
复制代码

source.subscribe()

这里的source对象，也就是我们最开始传入的参数ObservableOnSubscribe。也就是复写被观察者的subscribe方法，部分代码如下

  @Override
  public void subscribe(ObservableEmitter<String> emitter) throws Exception {
     emitter.onNext("1");
     emitter.onNext("2");
     emitter.onNext("3");
     emitter.onComplete();
           }
             })
复制代码

订阅

 public final void subscribe(Observer<? super T> observer) {
     //......
     subscribeActual(observer);
     //......
        }
复制代码

上面代码是订阅过程比较重要的代码，我们继续向下看。

protected abstract void subscribeActual(Observer<? super T> observer);
复制代码

可以看出Observable的subscribeActual方法是一个抽象方法，那么我们来看一下是谁实现了它。还记得上面我们分析过ObservableCreate继承了Observable，也就是说ObservableCreate是Observable的子类。那么只要看ObservableCreate的subscribeActual方法就可以了，在上面我们已经分析过了，可以回去再看一下。

总结

转载于:https://juejin.im/post/5c2883a4e51d452aaa7c75f9