RxJava2.0-Observable原理分析之Create操作符

简介

RxJava一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库；扩展了观察者模式以支持数据/事件的序列，并添加操作符，允许您以声明的方式组合序列，同时抽象出对诸如低层次线程、同步、线程安全和conc等问题的关注。

相关的入门的介绍有很多，可参考https://www.jianshu.com/p/15b2f3d7141a系列的文章介绍的非常全面；这篇文章的主要介绍相关的Observable发送流程，Observer接收流程，并且结合创建操作符ObservableCreate类（位于io.reactivex.internal.operators.observable包），发送事件和接收事件逻辑，给出源码分析；

用法

先了解下最基本的用法：

1）创建一个Observable，调用Observable.create();ObservableEmitter是事件的发送器，可以发送多个onNext()方法；一旦发送onComplete（），onError（）事件之后，后续的事件将不会再发送；

2）创建一个Observer；里面有四个方法：onSubscribe()，onNext()，onError()，onComplete()；

3）stringObservable.subscribe(observer);

Observable stringObservable = Observable.create(new ObservableOnSubscribe() {
  @Override
  public void subscribe(@NonNull ObservableEmitter emitter) throws Exception { 
    Log.e(tag, "发送线程：" + Thread.currentThread().getName());
    Log.e(tag, "发送：：" + "hello");
    emitter.onNext("hello");
    Log.e(tag, "发送：：" + "world");
    emitter.onNext("world");
    Log.e(tag, "发送：：" + "Hello World");
    emitter.onNext("Hello World");
    Log.e(tag, "发送：：" + "onComplete");
    emitter.onComplete();
  }
});

Observer observer = new Observer() {
  @Override
  public void onSubscribe(@NonNull Disposable d) {
    Log.e(tag, "onSubscribe");
    //销毁资源，后续的方法不在执行；
    //d.dispose();
  }

  @Override
  public void onNext(@NonNull String s) {
    Log.e(tag, "接收线程：" + Thread.currentThread().getName());
    Log.e(tag, "接收：" + s);
  }

  @Override
  public void onError(@NonNull Throwable e) {
    Log.e(tag, "onError");
  }

  @Override
  public void onComplete() {
    Log.e(tag, "onComplete");
  }
};

stringObservable.subscribe(observer);

运行结果

从运行结果发现：stringObservable.subscribe(observer)之后，

1）observer（观察者）最先调用onSubscribe()，参数Disposable相当于阀门，可以调用d.dispose()销毁资源，后续的方法不在执行；

2）然后emitter发送事件，每发送一个事件之后，observer就接收到一个事件，在没有速差存在的情况下，发送和接收是一一对应的；且都运行在主线程；

3）一旦调用onComplete()或者onError()之后，后续的方法将不再执行，onComplete()和onError()相互互斥，只有一个方法会执行；

执行流程

详细解析下以上的执行流程：以rxjava-2.1.8源码来分析的；

Observable：Observable是ObservableSource的实现类，Observable调用create（），ObservableOnSubscribe是一个接口，

Observable stringObservable = Observable.create(new ObservableOnSubscribe(){
  @Override
  public void subscribe(@NonNull ObservableEmitter emitter) throws Exception {
    emitter.onNext("hello");
    emitter.onNext("world");
    emitter.onNext("Hello World");
    emitter.onComplete();
  }
});

create()方法

@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public static  Observable create(ObservableOnSubscribe source) {
  ObjectHelper.requireNonNull(source, "source is null");
  return RxJavaPlugins.onAssembly(new ObservableCreate(source));//调用hook关联方法；
}

先进行非空判断，否则抛出NullPointerException异常，

ObservableOnSubscribe是一个接口，定义了subscribe()方法，用来接收ObservableEmitter的实例，以安全，可取消的方式发送事件；

public interface ObservableOnSubscribe {
  void subscribe(@NonNull ObservableEmitter emitter) throws Exception;
}

ObservableEmitter是Emitter（发射器）的子类；ObservableEmitter有序的发送onNext()，onError()，onComplete()方法；通过serialize()方法确保按照你想要的顺序发送；

Emitter的源码

public interface Emitter {
  void onNext(@NonNull T value);
  void onError(@NonNull Throwable error);
  void onComplete();
}

Observer是一个接口，为接收基于推的通知提供了一种机制，在observable.subscribe(observer)之后，最先调用onSubscribe()，

然后是数量不等的onNext()，最后仅调用一次onComplete() 或者onError()，这两个相互冲突，只有一个执行；在onSubscribe可以销毁资源，调用d.dispose();调用之后，后面的方法不再执行；

public interface Observer {
  void onSubscribe(@NonNull Disposable d);
  void onNext(@NonNull T t);
  void onError(@NonNull Throwable e);
  void onComplete();
}

subscribe（）中的subscribeActual(observer)在Observable是抽象方法，实际的订阅方法；操作符应该实现执行必要业务逻辑的方法，我们看下ObservableCreate类

@SchedulerSupport(SchedulerSupport.NONE)
@Override
public final void subscribe(Observer 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) {
    Exceptions.throwIfFatal(e);
    // can't call onError because no way to know if a Disposable has been set or not
    // can't call onSubscribe because the call might have set a Subscription already
    RxJavaPlugins.onError(e);
    NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
    npe.initCause(e);
    throw npe;
  }
}

ObservableCreate是Observable的子类，重写了subscribeActual()方法，

final ObservableOnSubscribe source;
public ObservableCreate(ObservableOnSubscribe source) {
  this.source = source;
}

@Override
protected void subscribeActual(Observer observer) {
  //CreateEmitter是静态匿名内部类，实现了ObservableEmitter和Disposable接口；
  CreateEmitter parent = new CreateEmitter(observer);
  //observer调用onSubscribe（），可以销毁资源
  observer.onSubscribe(parent);
  try {
    //执行subscribe（）方法
    source.subscribe(parent);
  } catch (Throwable ex) {
    Exceptions.throwIfFatal(ex);
    parent.onError(ex);
  }
}

CreateEmitter内有一个serialize()方法，确保按照你想要的顺序发送事件，返回了一个SerializedEmitter实例；

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

SerializedEmitter类连续的调用onNext, onError and onComplete，发送事件；在发送事件之前都会判断emitter是否销毁资源或者是否已经调用了onError或者onComplete；如果已经调用，就不在发送事件；

以下是SerializedEmitter发送事件的逻辑判断：

onError根据tryOnError的返回值

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

@Override
public boolean tryOnError(Throwable t) {
  if (emitter.isDisposed() || done) {//如果已经销毁子资源或者done= true;
    return false;
  }

  if (t == null) {
    t = new NullPointerException("onError called with null. Null values are generally not allowed in 2.x operators and sources.");
  }

  if (error.addThrowable(t)) {//抛出异常
    done = true;
    drain();//drain()内部调用drainLoop（）方法
    return true;
  }
  return false;
}

onComplete

@Override
public void onComplete() {
  if (emitter.isDisposed() || done) {//资源销毁或者done= true
    return;
  }
  done = true;
  drain();
}

SerializedEmitter内的逻辑比较复杂，可自行研究；以上只是个人的粗浅解析；

回到CreateEmitter中，对应的onNext, onError and onComplete，事件发送之后的回调，在调用observer的onNext, onError and onComplete之后，都会先判断isDisposed()，资源是否已经销毁，在没有销毁的前提下，再执行；

onNext：

@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（）方法；
    observer.onNext(t);
  }
}

onError：一旦执行之后，就会调用dispose()，销毁资源；

@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);//observer调用 onError（）方法
    } finally {
      dispose();//在onError（）方法调用之后，销毁资源，后续的事件将不会再发送；
    }
    return true;
  }
  return false;
}

onComplete：一旦执行之后，就会调用dispose()，销毁资源；

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

以上就是Observable发送流程，Observer接收流程的全部过程和部分细节的分析；如有问题，请多指教！