Rxjava订阅流程分析

 

RxJava框架内部采用观察者模式，基于事件流的链式调用、逻辑简洁、使用简单，在Android开发中被广泛的使用。

使用示例 

       //创建观察者
        Observable observable = Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(ObservableEmitter<String> s) throws Exception {
                s.onNext("a");
                s.onNext("b");
                s.onNext("c");
                s.onNext("d");
            }
        });
        //创建被观察者
        Observer observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String info) {
             LogUtil.d("Rxjava--Test-----------",info);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {

            }
        };
        //绑定观察者和被观察者
        observable.subscribe(observer);

一、创建被观察者

 

通过调用Observable的create()方法创建Observable对象

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

Observable的create方法需要传递参数ObservableOnSubscribe。ObservableOnSubscribe是一个接口。

public interface ObservableOnSubscribe<T> {
    void subscribe(@NonNull ObservableEmitter<T> e) throws Exception;
}

 而 ObservableOnSubscribe 接口中的subscribe方法参数是ObservableEmitter

public interface ObservableEmitter<T> extends Emitter<T> {

  
    void setDisposable(@Nullable Disposable d);

  
    void setCancellable(@Nullable Cancellable c);

  
    boolean isDisposed();

 
    @NonNull
    ObservableEmitter<T> serialize();


    @Experimental
    boolean tryOnError(@NonNull Throwable t);
}

ObservableEmitter 继承 Emitter

public interface Emitter<T> {

    void onNext(@NonNull T value);

    void onError(@NonNull Throwable error);

    void onComplete();
}

Emitter发射器调用Emitter#onNext()方法发送事件给观察者。Emitter的onNext()、onError()、onComplete()与观察者Observer的onNext()、onError()、onComplete()方法一一对应。

 

再回到Observable.create()方法

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

​
public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;

    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }

​

  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;
    }

 

新建ObservableCreate对象  然后调用RxJavaPlugins.onAssembly()方法 返回Observable 类型的参数，RxJavaPlugins中的onObservableAssembly变量默认为空，所以onAssembly()方法是直接把参数source返回出去。

 

二、创建观察者

public interface Observer<T> {


    void onSubscribe(@NonNull Disposable d);


    void onNext(@NonNull T t);


    void onComplete();

}

Observer只是一个接口，创建观察者就是创建Observer的实例。

三、让观察者订阅被观察者，连接双方。

1. 调用Observable的subscribe()方法

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

            ObjectHelper.requireNonNull(observer, "Plugin returned null Observer");
            
             // 子类调用
            subscribeActual(observer);
           
        } catch (NullPointerException e) { 
            throw e;
        } catch (Throwable e) {

        }
    }

Observable.subscribe()最后都会调用Observable的派生类的subscribeActual()方法

我们查看ObservableCreate对象的subscribeActual()方法。

 protected void subscribeActual(Observer<? super T> observer) {
             
        CreateEmitter<T> parent = new CreateEmitter<T>(observer);
          //回调observer的onSubscribe()方法
        observer.onSubscribe(parent);

        try {
         //回调ObservableOnSubscribe的subscribe()方法
            source.subscribe(parent);
        } catch (Throwable ex) {
            Exceptions.throwIfFatal(ex);
            parent.onError(ex);
        }
    }

observer传给CreateEmitter之后，赋值给全局变量observer。CreateEmitter继承了ObservableEmitter接口，是ObservableEmitter的实现，CreateEmitter中onNext()、onError()、onComplete()方法被调用时会调用观察者observer的同名方法。

调用observer的onSubscribe方法，说明observable.subscribe(observer)方法执行时，观察者observer的onSubscribe()方法就会马上被回调。

执行source.subscribe(parent)方法，source为ObservableOnSubscribe的实例，parent为CreateEmitter的实例，那么ObservableOnSubscribe的subscribe()方法会被回调。

 

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) {
      
                return;
            }
            if (!isDisposed()) {
             //回调observer的onNext()方法

                observer.onNext(t);
            }

        }

        @Override
        public void onError(Throwable t) {
            if (!tryOnError(t)) {
            //调用tryOnError回调observer的onError()方法
                RxJavaPlugins.onError(t);
            }
        }

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

        @Override
        public void onComplete() {
            if (!isDisposed()) {

                try {
              //回调observer的onComplete()方法
                    observer.onComplete();
                } finally {
                    dispose();
                }
            }
        }

        @Override
        public void setDisposable(Disposable d) {
            DisposableHelper.set(this, d);
        }

        @Override
        public void setCancellable(Cancellable c) {
            setDisposable(new CancellableDisposable(c));
        }

        @Override
        public ObservableEmitter<T> serialize() {
            return new SerializedEmitter<T>(this);
        }

        @Override
        public void dispose() {
            DisposableHelper.dispose(this);
        }

        @Override
        public boolean isDisposed() {
            return DisposableHelper.isDisposed(get());
        }

        @Override
        public String toString() {
            return String.format("%s{%s}", getClass().getSimpleName(), super.toString());
        }
    }

总结 

1  ObservableOnSubscribe 对象  ，把ObservableOnSubscribe对象传递给ObservableCreate的构造方法 ，创建ObservableCreate对象（即Obserable对象），
把ObservableOnSubscribe对象作为全局变量source保存起来。
2 创建Observer对象。 
3 执行observable.subscribe(observer)连接观察者和被观察者，会调用ObservableCreate的subscribeActual方法。
4 把 Observer的对象传递给CreteEmitter ,创建CreateEmiter的对象
5 回调observer的onSubscribe()方法。
6 回调ObservableOnSubscribe subscribe（ObservableEmitter<T> e）方法 参数为CreateEmitter对象；那么e.onNext 方法就会调用CreateEmitter
中的onNext（）方法，然后回调 observer的onNext()方法