入门程序：
Observable<Object> observable = Observable.create(observer -> {
observer.onNext(Math.random());
observer.onComplete();
});
observable.subscribe(consumer -> {
System.out.println("消费的元素是:" + consumer);
});
observable.subscribe(consumer->{
System.out.println("消费的元素是:"+consumer);
});
打印结果：
消费的元素是:0.48266893835351843
消费的元素是:0.6360686910302946
对于订阅者来讲，Observable代表一连串流动的数据。来看API实现：
@CheckReturnValue
@SchedulerSupport("none")
@NonNull
//create()方法接收参数ObservableOnSubscribe<T>
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate(source));
}
//参考Reactor api设计，这里不要将它看成subscribe()订阅动作，它其实就是一个Consumer，接收一个ObservableEmitter<T>
public interface ObservableOnSubscribe<T> {
void subscribe(@NonNull ObservableEmitter<T> var1) throws Throwable;
}
来看ObservableEmitter接口设计，可以看到Observable.create()接收一个ObservableEmitter用于下发元素产生事件以及其他onError()、onComplete()事件
public interface ObservableEmitter<T> extends Emitter<T> {
void setDisposable(@Nullable Disposable var1);
void setCancellable(@Nullable Cancellable var1);
boolean isDisposed();
@NonNull
ObservableEmitter<T> serialize();
boolean tryOnError(@NonNull Throwable var1);
}
public interface Emitter<T> {
//封装下发元素动作
void onNext(@NonNull T var1);
void onError(@NonNull Throwable var1);
void onComplete();
}
于是，在入门程序的Observable.create()中传入一个ObservableEmitter的lambda表达式，实现主要其onNext()方法，用于在订阅事件产生之后下发元素。
public void onNext(T t) {
if (t == null) {
this.onError(ExceptionHelper.createNullPointerException("onNext called with a null value."));
} else {
if (!this.isDisposed()) {
//回调Observable.onNext()方法
//this.observer代表subscribeActual()方法中创建CreateEmitter传入的lambdaObserver调用
this.observer.onNext(t);
}
}
}
接着来看subscribe()订阅方法：
@CheckReturnValue
@SchedulerSupport("none")
public final Disposable subscribe(Consumer<? super T> onNext) {
//传入onNext消费元素过程，以及默认值ON_ERROR、ON_COMPLETE
return this.subscribe(onNext, Functions.ON_ERROR_MISSING, Functions.EMPTY_ACTION);
}
@CheckReturnValue
@SchedulerSupport("none")
public final Disposable subscribe(Consumer<? super T> onNext, Consumer<? super Throwable> onError, Action onComplete) {
ObjectHelper.requireNonNull(onNext, "onNext is null");
ObjectHelper.requireNonNull(onError, "onError is null");
ObjectHelper.requireNonNull(onComplete, "onComplete is null");
//在内部将onNext、onError、onComplete、Functions.emptyConsumer()包装为一个LambdaObserver
LambdaObserver<T> ls = new LambdaObserver(onNext, onError, onComplete, Functions.emptyConsumer());
this.subscribe((Observer)ls);
return ls;
}
@SchedulerSupport("none")
public final void subscribe(Observer<? super T> observer) {
ObjectHelper.requireNonNull(observer, "observer is null");
try {
observer = RxJavaPlugins.onSubscribe(this, observer);
ObjectHelper.requireNonNull(observer, "The RxJavaPlugins.onSubscribe hook returned a null Observer. Please change the handler provided to RxJavaPlugins.setOnObservableSubscribe for invalid null returns. Further reading: https://github.com/ReactiveX/RxJava/wiki/Plugins");
//订阅，传入LambdaObserver
this.subscribeActual(observer);
} catch (NullPointerException var4) {
throw var4;
} catch (Throwable var5) {
Exceptions.throwIfFatal(var5);
RxJavaPlugins.onError(var5);
NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS");
npe.initCause(var5);
throw npe;
}
}
protected void subscribeActual(Observer<? super T> observer) {
//通过lambdaObserver创建CreateEmitter
ObservableCreate.CreateEmitter<T> parent = new ObservableCreate.CreateEmitter(observer);
//调用LambdaObserver.onSubscribe()，传入通过lambdaObserver创建的CreateEmitter
observer.onSubscribe(parent);
try {
//回调ObservableEmitter.onNext()下发元素，说明Observer实例在没有订阅之前不会发射任何数据。
this.source.subscribe(parent);
} catch (Throwable var4) {
Exceptions.throwIfFatal(var4);
parent.onError(var4);
}
}
接着来看LambdaObserver#onSubscribe(parent)
public void onSubscribe(Disposable d) {
if (DisposableHelper.setOnce(this, d)) {
try {
//this代表上面subscribe()方法中创建的lambdaObserver
//this.onSubscribe就是上面给定的 Functions.emptyConsumer()，如果我们在Observable.subscribe()中传入了非默认的Consumer onSubscribe，它便会在订阅时执行。
this.onSubscribe.accept(this);
} catch (Throwable var3) {
Exceptions.throwIfFatal(var3);
d.dispose();
this.onError(var3);
}
}
}
//实际消费元素
//由ObservableEmitter.onNext回调，而这个onNext就是入门程序传入的消费元素的Consumer
public void onNext(T t) {
if (!this.isDisposed()) {
try {
this.onNext.accept(t);
} catch (Throwable var3) {
Exceptions.throwIfFatal(var3);
((Disposable)this.get()).dispose();
this.onError(var3);
}
}
}
总结：Observable.create()方法通过传入一个ObservableOnSubscribe实现其subscribe()方法从而创建一个发布者ObservableCreate。实现ubscribe()需要接收一个ObservableEmitter，而ObservableEmitter是一系列动作事件的封装体，例如onNext、onError、onComplete分别代表下发元素事件、下发error事件、下发onComplete事件。由于Lambda表达式只是定义一个动作并不会实际执行。当订阅事件subscribe()产生时，在消费过程中创建一个LambdaObserver订阅者(它实现非背压标准接口Observer，类似于Subscriber)并通过ObservableCreate.subscribeActual(LambdaObserver)将发布者订阅者建立关系。在subscribeActual()方法中创建ObservableEmitter并回调ObservableOnSubscribe.subscribe()，通过ObservableEmitter下发各种事件。当调用ObservableEmitter.onNext()下发元素事件时，回调LambdaObserver订阅者Consumer消费元素。另外，每次订阅都会Observable都会执行一次下发元素，因此两次打印结果消费了不同的元素。
