示例代码
示例中引入的RxJava库为RxJava2.0。
public class TempInfo {
public static final Random RANDOM = new Random();
private final String town;
private final int temp;
public TempInfo(String town, int temp) {
this.town = town;
this.temp = temp;
}
public static TempInfo fetch(String town){
/*if(RANDOM.nextInt(10) == 0){
throw new RuntimeException("Error!");
}*/
return new TempInfo(town, RANDOM.nextInt(100));
}
@Override
public String toString() {
return town + " : " + temp;
}
public String getTown() {
return town;
}
public int getTemp() {
return temp;
}
}
public class TempObserver implements Observer<TempInfo> {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(TempInfo tempInfo) {
System.out.println(tempInfo);
}
@Override
public void onError(Throwable e) {
System.out.println("Got problem: " + e.getMessage());
}
@Override
public void onComplete() {
System.out.println("Done!");
}
}
public static void main(String[] args) {
getNegativeTemperature("New York").blockingSubscribe(new TempObserver());
}
public static Observable<TempInfo> getTemperature(String town){
//create传参ObservableOnSubscribe，为一函数式接口，只有一个subscribe方法，传参ObservableEmitter
return Observable.create(emitter -> Observable.interval(1, TimeUnit.SECONDS).subscribe(i -> {
if(!emitter.isDisposed()){
if(i >= 5){
emitter.onComplete();
} else {
try {
emitter.onNext(TempInfo.fetch(town));
} catch (Exception e) {
emitter.onError(e);
}
}
}
}));
}
public static Observable<TempInfo> getCelsiusTemperature(String town){
return getTemperature(town).map(tempInfo -> new TempInfo(tempInfo.getTown(), (tempInfo.getTemp() - 32) * 5 / 9));
}
public static Observable<TempInfo> getNegativeTemperature(String town){
return getCelsiusTemperature(town).filter(tempInfo -> tempInfo.getTemp() < 0);
}
示例意思为：创建一个每秒一次返回温度的Observable对象，且将温度转换为摄氏温度，并且只有在摄氏温度低于0℃时才返回。
调用流程分析
入口是Observable.create方法，参数为一个等待传入emitter的lambda表达式，针对返回的ObservableCreate，执行map和filter操作。
//1.Observable.create方法，source为lambda表达式
@CheckReturnValue
@NonNull
@SchedulerSupport(SchedulerSupport.NONE)
public static <T> Observable<T> create(ObservableOnSubscribe<T> source) {
ObjectHelper.requireNonNull(source, "source is null");
return RxJavaPlugins.onAssembly(new ObservableCreate<T>(source));
}
//2.map操作，方法存在于Observable类中
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final <R> Observable<R> map(Function<? super T, ? extends R> mapper) {
ObjectHelper.requireNonNull(mapper, "mapper is null");
return RxJavaPlugins.onAssembly(new ObservableMap<T, R>(this, mapper));
}
//3.filter操作，方法存在于Observable类中
@CheckReturnValue
@SchedulerSupport(SchedulerSupport.NONE)
public final Observable<T> filter(Predicate<? super T> predicate) {
ObjectHelper.requireNonNull(predicate, "predicate is null");
return RxJavaPlugins.onAssembly(new ObservableFilter<T>(this, predicate));
}
上面的操作执行完，返回的Observable为ObservableFilter，接着在其上执行blockingSubscribe方法，传入TempInfo。
//4.blockingSubscribe，方法存在于ObservableFilter的父类Observable中
@SchedulerSupport(SchedulerSupport.NONE)
public final void blockingSubscribe(Observer<? super T> observer) {
ObservableBlockingSubscribe.subscribe(this, observer);
}
进入方法内部分析。
//4.1 ObservableBlockingSubscribe
public static <T> void subscribe(ObservableSource<? extends T> o, Observer<? super T> observer) {
final BlockingQueue<Object> queue = new LinkedBlockingQueue<Object>();
BlockingObserver<T> bs = new BlockingObserver<T>(queue);
observer.onSubscribe(bs);
//4.1.1 构造订阅链
o.subscribe(bs);//转换为bs对o的订阅，o为ObservableFilter
//4.1.2 出队操作
for (;;) {
if (bs.isDisposed()) {
break;
}
Object v = queue.poll();
if (v == null) {
try {
v = queue.take();
} catch (InterruptedException ex) {
bs.dispose();
observer.onError(ex);
return;
}
}
//4.1.2.1 打印输出
if (bs.isDisposed()
|| v == BlockingObserver.TERMINATED
|| NotificationLite.acceptFull(v, observer)) {
break;
}
}
}
//4.1.1 方法存在于Observable
@SchedulerSupport(SchedulerSupport.NONE)
@Override
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");
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;
}
}
其中subscribeActual为一抽象方法，由具体子类实现，此处先是执行到ObservableFilter中。
//4.1.1.1 ObservableFilter
@Override
public void subscribeActual(Observer<? super T> observer) {
source.subscribe(new FilterObserver<T>(observer, predicate));
}
source为构造ObservableFilter时传入的ObservableMap，此处将传参BlockingObserver和构造ObservableFilter时传入的prediacate封装为一个FilterObserver，接着订阅ObservableMap。
接着又执行到4.1.1，不过此时的方法调用者变成了ObservableMap，再次执行到抽象方法subscribeActual中。
//4.1.1.2 ObservableMap
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
此处source为构造ObservableMap时传入的ObservableCreate，接着将FilterObserver和function封装为MapObserver，去订阅ObservableMap。
再次执行到4.1.1，此时方法调用者变成了ObservableCreate，再次执行到抽象方法subscribeActual中。
//4.1.1.3 ObservableCreate
@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);
}
}
通过MapObserver构造一个CreateEmitter，作为参数，再次执行subscribe方法。不过这个subscribe方法存在于函数接口ObservableOnSubscribe中，接收一个ObservableEmitter参数，所以此处的执行其实是执行到了Observable.create中定义的lambda表达式。
接着执行自定义的内部订阅emitter.onNext。
//5.订阅链处理
//5.1 CreateEmitter
@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);
}
}
observer为4.1.1.3时构造CreateEmitter传入的MapObserver。
//5.2 MapObserver
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
downstream.onNext(null);
return;
}
U v;
try {
//处理mapper映射
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
downstream.onNext(v);
}
downstream为4.1.1.1时构造的FilterObserver。
//5.3 FilterObserver
@Override
public void onNext(T t) {
if (sourceMode == NONE) {
boolean b;
try {
//执行filter过滤
b = filter.test(t);
} catch (Throwable e) {
fail(e);
return;
}
if (b) {
downstream.onNext(t);
}
} else {
downstream.onNext(null);
}
}
downstream为4.1中构造的BlockingObserver。
//5.4 BlockingObserver
@Override
public void onNext(T t) {
queue.offer(NotificationLite.next(t));
}
@Override
public void onComplete() {
queue.offer(NotificationLite.complete());
}
即在BlockingObserver中执行入队操作，待入队结束后，返回4.1.2执行出队操作，进而执行到
NotificationLite.acceptFull(v, observer)。
//4.1.2.1 observer为调用blockingSubscribe方法时的传参
public static <T> boolean acceptFull(Object o, Observer<? super T> observer) {
if (o == COMPLETE) {
observer.onComplete();
return true;
} else
if (o instanceof ErrorNotification) {
observer.onError(((ErrorNotification)o).e);
return true;
} else
if (o instanceof DisposableNotification) {
observer.onSubscribe(((DisposableNotification)o).upstream);
return false;
}
//执行打印输出
observer.onNext((T)o);
return false;
}
其中，ObservableCreate、ObservableMap、ObservableFilter都是抽象类Observable的子类；FilterObserver、MapObserver都是接口Observer的子类。
总结
ObservableMap持有ObservableCreate，ObservableFilter持有ObservableMap，即在这条Observable链上，下游的Observable始终持有上一个Observable。
ObservableOnSubscribe <-- ObservableCreate <-- ObservableMap <-- ObservableFilter，最后以最末尾的Observable返回，然后在每一个Observable子类的subscribeActual方法中，构造Observer对前一个Observable的订阅。
而针对Observer，始终是上一个Observer持有下一个Observer。
CreateEmitter --> MapObserver --> FilterObserver --> BlockingObserver。
可以把Emitter看成是不带onSubscribe方法的Observer。
ObservableFilter的订阅者是BlockingObserver，ObservableMap的订阅者是FilterObserver，ObservableCreate的订阅者是MapObserver，ObservableOnSubscribe中的订阅者是CreateEmitter。
本文转自 blog.csdn.net/zlk25262006…，如有侵权，请联系删除。
