RxJava是如何实现订阅关系的？

什么是RxJava

说到RxJava，就必须说到ReactiveX，它是一个编程模型，目标是提供一致的编程接口，帮助开发者更方便的处理异步数据流，RxJava只是它的Java语言实现方式，还有诸如RxJS、Rx.NET等其他语言的版本。

用过RxJava的都知道它实现起来代码简洁干练，使用链式调用方式可以将一系列复杂的操作用仅用一段代码就能串起来。但这对于初次接触它的人来说往往感觉可读性很差，很难理解其中的奥秘，这篇文章主要介绍Rxjava最简单的操作方式，并解析其中的源码。

RxJava的观察者模式

RxJava最核心的思想就是观察者模式。软件开发过程中，经常就需要去后台请求一串数据，请求到结果后将数据展示在页面上，这时候如果用观察者模式开发，就可以定义一个被观察者，用来作数据请求，然后定义一个观察者，用来处理界面展示，然后观察者订阅被观察者。

等被观察者请求的数据完成后，就通知观察者数据已经完成可以界面更新了。RxJava就是通过这样的方式来实现的。

RxJava的实现方式

举一个很简单的例子，假设我们要在后台连续创建五个字符串hello world，然后再通过前台打印出来(为了描述更形象，后台不是仅仅是在被观察者中实现，没有开线程处理)，可以通过以下代码实现：

1. 创建观察者对象Observer，实现onSubscribe(), onNext()，onComplete()，onError()；

2. 创建被观察者对象ObservableOnSubscribe，这里使用了lumbda的写法，参数e可以理解为就是Observer的对象，这个方法体里面可以实现任何操作，然后拿到参数e将操作的结果通过onNext()通知给观察者Observer；

3. 调用订阅方法subscribe，这个方法被执行后，被观察者对象的操作就开始被执行。

Observable.create((ObservableOnSubscribe<String>) e ->
            for (int i = 0; i < 5; i++) {
                e.onNext("hello world " + i);
            }
            e.onComplete();
        ).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {

            }

            @Override
            public void onNext(String o) {
                System.out.println("onNext" + o);
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        });
复制代码

执行结果：

onNexthello world 0
onNexthello world 1
onNexthello world 2
onNexthello world 3
onNexthello world 4
onComplete
复制代码

RxJava的实现原理

1. Observable的创建过程。

我们来看下Observable.create的源码，它将上面通过匿名类实现的ObservableOnSubscribe对象作为ObservableCreate的构造函数参数又创建了ObservableCreate对象。

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

ObservableCreate类很简单，里面只包含了ObservableOnSubscribe这个成员变量，就是通过上面的create函数传进来的。

public final class ObservableCreate<T> extends Observable<T> {
    final ObservableOnSubscribe<T> source;
    public ObservableCreate(ObservableOnSubscribe<T> source) {
        this.source = source;
    }
    ...
}    
复制代码

创建完ObservableCreate对象后，再调用RxJavaPlugins的静态方法onAssembly，前者作为后者的参数传入，onAssembly方法中还有一个apply的操作，这个我们目前还没有用到，可以先忽略，所以这个方法就是将传入的ObservableCreate对象直接返回。

public final class RxJavaPlugins {
  ...
  /**
   * Calls the associated hook function.
   * @param <T> the value type
   * @param source the hook's input value
   * @return the value returned by the hook
   */
  @SuppressWarnings({ "rawtypes", "unchecked" })
  @NonNull
  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;
  }
  ...
}  
复制代码

2. Observer的创建过程:通过上个步骤返回的ObservableCreate对象再调用subscribe方法，我们直接创建了一个Observer匿名内部类作为参数传入subscribe()方法，Observer就是我们定义的观察者，内部实现了onNext，onComplete和onError方法。

3. 订阅的流程。

接着我们重点分析subscribe的内部实现，由于ObservableCreate是Observable的子类，该方法首先是调用了父类Observable的subscribe方法，然后调用子类也就是ObservableCreate的subscribeActual方法。

这里就使用了设计模式中的模板模式，在父类中定义了方法模板subscribe，再通过subscribeActual让子类各自去实现。

public abstract class Observable<T> implements ObservableSource<T> {
  ...
  @Override
  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) { // NOPMD
          throw e;
      } catch (Throwable e) {
          ...
      }
  }
  ...
}  
复制代码

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

subscribeActual方法中创建了CreateEmitter实例parent，CreateEmitter是对Observer再作一层封装，通过isDisposed方法判断订阅状态是否已销毁，只要没被销毁才会调用到我们定义的onNext等观察者方法，通过parent调用的onNext、onError等方法内部就是拿到observer再调用对应的onNext、onError。

接着就是真正开始执行被观察者的操作了，source.subscribe(parent)就是调用了我们在RxJava的实现方式中第二步创建的ObservableOnSubscribe对象了，即开始执行了for循环打印hello world的流程了。

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

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