map示意图:
RxJava代码
// ObseravbleCreate 自定义source传递进去了 == source
Observable.create(
// 自定义source
new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
}
})
// ObseravbleCreate.map
.map(new Function<String, Bitmap>() {
@Override
public Bitmap apply(String s) throws Exception {
return null;
}
})
// ObservableMap.subscribe 链式调用
.subscribe(
// 自定义观察者(终点)
new Observer<Bitmap>() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Bitmap bitmap) {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onComplete() {
}
});
源码分析
.subscribe()会调用ObservableMap里面的subscribeActual函数
@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, "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;
}
}
subscribeActual(observer); 调用的是ObservableMap里面的subscribeActual函数,传入的参数是自定义观察者(观察者)
因为这是ObservableMap点出来的订阅
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
自定义观察者(观察者) 传到 subscribeActual 后 又做了个包裹(1) new MapObserver<T, U>(t, function)
把 自定义观察者(观察者) 传入 MapObserver
source.subscribe (new MapObserver<T, U>(t, function)); 上一层是 ObseravbleCreate
ObseravbleCreate . subscribe 再进入ObseravbleCreate的subscribeActual
@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);
}
}
传入的observer是 自定义观察者(终点)包裹(1)
包裹(1)再被 CreateEmitter parent = new CreateEmitter(observer); 包裹成包裹(2)
observer.onSubscribe(parent); 调用第一个最先启动的函数(底端)
source.subscribe(parent); 上一层 也就是自定义source,就执行到.create()里面了(顶端)
// 自定义source
new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> e) throws Exception {
}
})
在.create()里面调用了包裹(2).onNext() 查看发射器中的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(t);
}
}
observer.onNext(t); 又拿到了下一层的onNext
包裹(1).onNext
进入了ObservableMap里面的onNext
@Override
public void onNext(T t) {
if (done) {
return;
}
if (sourceMode != NONE) {
actual.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");
} catch (Throwable ex) {
fail(ex);
return;
}
actual.onNext(v);
}
.apply(t) 把 类型转换接口
public interface Function<T, R> {
/**
* Apply some calculation to the input value and return some other value.
* @param t the input value
* @return the output value
* @throws Exception on error
*/
R apply(@NonNull T t) throws Exception;
}
真正的实现就在代码中: 它规定规则 我们来干活
// ObseravbleCreate.map
.map(new Function<String, Bitmap>() {
@Override
public Bitmap apply(String s) throws Exception {
return null;
}
})
逻辑图
装饰模式