RXJava原理

ObservableCreate(source = 参数）

移除判空逻辑后代码如下

   public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
        return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
    }

ObservableSubscribeOn（source = this)

移除判空逻辑后代码如下

   public final Observable<T> subscribeOn(Scheduler scheduler) {
        return RxJavaPlugins.
        	onAssembly(new ObservableSubscribeOn<T>(this, scheduler));
    }

ObservableObserveOn（source = this)

移除判空逻辑后代码如下

 public final Observable<T> observeOn(Scheduler scheduler, boolean delayError
 	, int bufferSize) {
        return RxJavaPlugins.onAssembly(
        	new ObservableObserveOn<T>(this, scheduler, delayError, bufferSize));
    }

subscribe

移除判空逻辑后代码如下

public final Disposable subscribe() {
    return subscribe(Functions.emptyConsumer(), 
        	Functions.ON_ERROR_MISSING, 
        	Functions.EMPTY_ACTION, 
        	Functions.emptyConsumer());
}
public final Disposable subscribe(Consumer<? super T> onNext, 
		Consumer<? super Throwable> onError,
		Action onComplete, Consumer<? super Disposable> onSubscribe) {       
   LambdaObserver<T> ls = new LambdaObserver<T>(onNext, onError
   		, onComplete, onSubscribe);
   subscribe(ls);
   return ls;
}
public final void subscribe(Observer<? super T> observer) {
   observer = RxJavaPlugins.onSubscribe(this, observer);
   subscribeActual(observer);
}

ObservableObserveOn.subscribeActual

调用上层方法

source.subscribe(observer);

ObservableSubscribeOn.subscribeActual

public void subscribeActual(final Observer<? super T> observer) {
   final SubscribeOnObserver<T> parent = new SubscribeOnObserver<T>(observer);
   observer.onSubscribe(parent);
   parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));
}
final class SubscribeTask implements Runnable {
   private final SubscribeOnObserver<T> parent;
   SubscribeTask(SubscribeOnObserver<T> parent) {
        this.parent = parent;
   } 
   public void run() {
       source.subscribe(parent);
   }
}

scheduler.scheduleDirect切换线程到设定的线程，调用上层方法

ObservableCreate.subscribeActual

source.subscribe(parent);

注意此时的source不是上层构造传递的this了，而是构造时传递的参数对象

eg：ObservableFromArray

除了使用create创建起点外，rxjava提供了一些起点逻辑，例如ObservableFromArray，其原理类似；

//ObservableFromArray
public ObservableFromArray(T[] array) {
    this.array = array;
}
@Override
public void subscribeActual(Observer<? super T> observer) {
   FromArrayDisposable<T> d = new FromArrayDisposable<T>(observer, array);
   observer.onSubscribe(d);
   if (d.fusionMode) {
       return;
   }
   d.run();
}
//FromArrayDisposable
void run() {
    T[] a = array;
    int n = a.length;
    for (int i = 0; i < n && !isDisposed(); i++) {
        T value = a[i];
        if (value == null) {
            downstream.onError(new NullPointerException(
            	"The element at index " + i + " is null"));
           return;
        }
        downstream.onNext(value);
    }
    if (!isDisposed()) {
         downstream.onComplete();
    }
}

本质上就是，遍历数据源，将每个数据传递给onNext，出错传递给onError，完成时调用onComplete

ObservableSubscribeOn.onNext

downstream.onNext(t);
交给下游处理onNext

ObservableObserveOn.onNext

@Override
public void onNext(T t) {
    if (done) {
        return;
    }
    if (sourceMode != QueueDisposable.ASYNC) {
         queue.offer(t);
    }
    schedule();
}
void schedule() {
    if (getAndIncrement() == 0) {
        worker.schedule(this);
    }
}

ObserveOn 在onNext中进行线程切换，会影响从ObserveOn开始到下一处ObserveOn中的所有onNext逻辑均执行在ObserveOn的线程内，

上文ObservableSubscribeOn的线程切换发生在subscribeActual中，仅是改变了上层的线程，当在次遇到ObservableSubscribeOn切换时会再次切换，但是注意此时还没有执行onNext逻辑故线程切换对onNex逻辑无效，onNext仅能感知到最后一次的结果，由于subscribeActual是倒叙调用的，故仅能感知到第一次线程切换的结果。

subscribe.onNext

@Override
public void onNext(T t) {
  if (!isDisposed()) {
    try {
        onNext.accept(t);
    } catch (Throwable e) {
        Exceptions.throwIfFatal(e);
        get().dispose();
        onError(e);
    }
  }
}

执行传入的回调接口，如果没有传入，什么也不做。