博客导航
承接上一篇Rxjava2源码分析(1)
这一篇将讲下Rxjava2的操作符。在Rxjava里面最常用的是map操作符,接下来将从map入手分析。
1.map操作符的基本用法
这里按照国际惯例,先上map的基本用法。
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> e) throws Exception {
e.onNext(1);
e.onNext(2);
e.onNext(3);
}
}).map(new Function<Integer, String>() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "This is result " + integer;
}
}).subscribe(new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : " + s +"\n");
Log.e(TAG, "accept : " + s +"\n" );
}
});
2.map源码跟踪
2.1 map
跟踪map进去,进入Observable里面,你会发现同样有RxJavaPlugins.onAssembly这东西。
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));
}
RxJavaPlugins.onAssembly上文已经说过了,这次主要关注ObservableMap。new ObservableMap<T, R>(this, mapper)
里面的this是create返回的Observable对象,mapper是你给的Function对象。
2.2 ObservableMap
public final class ObservableMap<T, U> extends AbstractObservableWithUpstream<T, U> {
final Function<? super T, ? extends U> function;
public ObservableMap(ObservableSource<T> source, Function<? super T, ? extends U> function) {
super(source);
this.function = function;
}
@Override
public void subscribeActual(Observer<? super U> t) {
source.subscribe(new MapObserver<T, U>(t, function));
}
static final class MapObserver<T, U> extends BasicFuseableObserver<T, U> {
final Function<? super T, ? extends U> mapper;
MapObserver(Observer<? super U> actual, Function<? super T, ? extends U> mapper) {
super(actual);
this.mapper = mapper;
}
@Override
public void onNext(T t) {
if (done) { //默认done为false,跳过
return;
}
if (sourceMode != NONE) { //默认sourceMode 为0,跳过
actual.onNext(null);
return;
}
U v;
try {
v = ObjectHelper.requireNonNull(mapper.apply(t), "The mapper function returned a null value.");//1
} catch (Throwable ex) {
fail(ex);
return;
}
actual.onNext(v);//2
}
@Override
public int requestFusion(int mode) {
return transitiveBoundaryFusion(mode);
}
@Nullable
@Override
public U poll() throws Exception {
T t = qs.poll();
return t != null ? ObjectHelper.<U>requireNonNull(mapper.apply(t), "The mapper function returned a null value.") : null;
}
}
}
AbstractObservableWithUpstream
AbstractObservableWithUpstream是什么?它继承了Observable类,把ObservableSource对象保存了起来。
abstract class AbstractObservableWithUpstream<T, U> extends Observable<U> implements HasUpstreamObservableSource<T> {
/** The source consumable Observable. */
protected final ObservableSource<T> source;
/**
* Constructs the ObservableSource with the given consumable.
* @param source the consumable Observable
*/
AbstractObservableWithUpstream(ObservableSource<T> source) {
this.source = source;
}
@Override
public final ObservableSource<T> source() {
return source;
}
}
//1 mapper.apply(t)
在ObservableMap里面,subscribeActual,将完成上游Observable的订阅。MapObserver里面的mapper.apply(t)将上游的t转换成下游所需的U。这里怎么变换是你一开始时候就设定好的。这里我们当初传入map里面的Function如下。
new Function<Integer, String>() {
@Override
public String apply(@NonNull Integer integer) throws Exception {
return "This is result " + integer;
}
}
//2 actual.onNext(v)
actual.onNext(v);
是交接给下游的Observer。actual对应本例就是当初create的对象,执行onNext方法就是执行当初自己定义的操作。
new Consumer<String>() {
@Override
public void accept(@NonNull String s) throws Exception {
mRxOperatorsText.append("accept : " + s +"\n");
Log.e(TAG, "accept : " + s +"\n" );
}
}
至此,当初的e.onNext(1)
将得到响应。
总结一下。订阅过程是最后一个Observable往上一个Observable订阅(本例中是MapObserver)。从最后一个Observable里面的subscribe有个subscribeActual方法调用,这个方法会一层层订阅,直至第一个Observable。然后触发第一个Observable的subscribe,这里面会触发数据流操作。在本例中,订阅至到第一个Observable的subscribe实现类,里面的e.onNext(1);
会触发数据一层层往下流,下一个是MapObserver对数据的操作,到最后的Observable。