标签（空格分隔）： rxandroid rxjava map
上一篇文章分析了一层结构最简单的事件触发的过程，接下来分析map过程，对于map过程宏观上的认识，借用官网上的一个图
<img src="http://o767chiwj.bkt.clouddn.com/rxandroid_map_doc.png"/>
从这个图中，我们可以看到，map的过程是一个一对一的过程，且针对的对象都是被观察者Observable.由于rxjava是一种链式编程结构，因此一次map过程，就会增加一次层次机构。下面来看一个简单的例子加以理解。
map(): 事件对象的直接变换
Observable<String> observable = Observable.create( new Observable.OnSubscribe<String>() {
@Override
public void call( Subscriber<? super String> subscriber ) {
Log.d( TAG, "OnSubscribe call: " );
subscriber.onNext( "123" );
subscriber.onCompleted();
}
} );
observable
.map( new Func1<String, Integer>() {
@Override
public Integer call( String s ) {
return 99;
}
} )
.subscribe( new Subscriber<Integer>() {
@Override
public void onCompleted() {
Log.d( TAG, "Subscriber onCompleted: " );
}
@Override
public void onError( Throwable e ) {
Log.d( TAG, "Subscriber onError: " );
}
@Override
public void onNext( Integer s ) {
Log.d( TAG, "Subscriber onNext: " + s );
}
} );
从这段code中来看，涉及的层次结构由前文的一层变成了两层。
1.Observable.create创建了一个被观察者Observable和它对应的OnSubscribe
2.Observable.map在上一个Observable的基础上，再fork出一层，代码之后，这里会有一个新的Observable和相应的OnSubscribe对象
3.Observable.subscribe 发出命令，执行所有计划表call方法，建立订阅者链形结构，从最顶端的subscriber开始，按照指定的逻辑，一次回调所有subscriber的onNext方法。
图文结构：
<img src="http://o767chiwj.bkt.clouddn.com/rxjava_map.png"/>
代码分析：
1.Observable.create创建第一层Observable和ObSubsribe对象，如前文分析，这里不再说明
2.Observable.map
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
return lift(new OperatorMap<T, R>(func));
}
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}
这里调用map方法的是第一层结构中的Observable对象，此时它的模板类型为T,从map中可以看到，map方法的返回值也是一个Observable，同时注意到模板类型由T变成了R，整个R是由入参func决定的，这也是为什么map操作之后，会影响此后所有的模板类型值。接下来调用lift方法，这个方法里面就是新建了一个被观察者Observable<R>和其OnSubscribeLift< T, R >对象。因此完成了第二层Observable和其对应的ObSubscribe(这里即是一个OnSubscribeLift)的对象的创建。
下面分析OperatorMap和OnSubscribeLift对象和Observable之间的关系。
a.OnSubscribeLift构造方法
public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
this.parent = parent;
this.operator = operator;
}
OnSubscribeLift的实现比较简单，parent变量记录了上一层Observable对象的计划表OnSubscribe对象，operator变量记录了具体的操作，对于map操作，这里对应的是OperatorMap对象。
b.OperatorMap构造方法
public OperatorMap(Func1<? super T, ? extends R> transformer) {
this.transformer = transformer;
}
这个方法就是将map中Func1的操作保存至成员变量transformer中，接下来来分析这些结构的用处。
3.Observable.subscribe
首先，最初的Subscribe会被包装成一个SafeSubsciber对象，然后这个订阅者对象(SafeSubsciber)和map创建出来的被观察者Observable对象之间，执行订阅关系。如前文分析，此时这个被观察者的计划表ObSubscibe的call方法会被执行，这里也就是执行OnSubscribeLift的call方法。
3.1 OnSubscribeLift.call
public void call(Subscriber<? super R> o) {
try {
Subscriber<? super T> st = hook.onLift(operator).call(o);
try {
// new Subscriber created and being subscribed with so 'onStart' it
st.onStart();
parent.call(st);
} catch (Throwable e) {
// localized capture of errors rather than it skipping all operators
// and ending up in the try/catch of the subscribe method which then
// prevents onErrorResumeNext and other similar approaches to error handling
Exceptions.throwIfFatal(e);
st.onError(e);
}
} catch (Throwable e) {
Exceptions.throwIfFatal(e);
// if the lift function failed all we can do is pass the error to the final Subscriber
// as we don't have the operator available to us
o.onError(e);
}
}
这个call方法的实现逻辑也很简单，即将它的下一级订阅者委托给相应的operator对象的call方法去处理。前面分析到，operator这个操作符就是一个OperatorMap。
3.2 OperatorMap.call
@Override
public Subscriber<? super T> call(final Subscriber<? super R> o) {
MapSubscriber<T, R> parent = new MapSubscriber<T, R>(o, transformer);
o.add(parent);
return parent;
}
public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
this.actual = actual;
this.mapper = mapper;
}
这里的transformer保存的是map方法中的Func1对象，在这个call方法中，创建了一个MapSubscriber对象，这里它也是一个Subscriber的子类,，成员变量actual保存了下层传过来的subsciber,mapper中保存了Func1的操作。也即用了一个包装者的模式，将前面的SafeSubsciber和transformer对象传入，接下来返回到OnSubscribeLift.call方法中。接下来继续分析OnSubscribeLift.call方法。
try {
// new Subscriber created and being subscribed with so 'onStart' it
st.onStart();
parent.call(st);
} catch (Throwable e) {
// localized capture of errors rather than it skipping all operators
// and ending up in the try/catch of the subscribe method which then
// prevents onErrorResumeNext and other similar approaches to error handling
Exceptions.throwIfFatal(e);
st.onError(e);
}
parent对象是上一层Observable对象的计划表OnSubscribe对象，这几行代码，其实就模拟了一层订阅的关系。这里的订阅者对象变成了MapSubscriber(包装过一层结构SafeSubsciber对象),在我们这个例子中，如下call方法就会被执行，这里入参subscriber即是MapSubscriber对象。
public void call( Subscriber<? super String> subscriber ) {
Log.d( TAG, "OnSubscribe call: " );
subscriber.onNext( "123" );
subscriber.onCompleted();
}
至此，在这个call方法中，真正的逻辑开始处理，MapSubscriber对象的onNext方法会被执行，如果没有异常接下来onCompleted方法会被执行，否则onError方法会被执行。下面继续分析
3.3 MapSubscriber.onNext
@Override
public void onNext(T t) {
R result;
try {
result = mapper.call(t);
} catch (Throwable ex) {
Exceptions.throwIfFatal(ex);
unsubscribe();
onError(OnErrorThrowable.addValueAsLastCause(ex, t));
return;
}
actual.onNext(result);
}
在这里mapper对象保存的是map方法中Func1的操作，这个方法的实现很简单，就是做了一层拦截，将上一层执行下来的结果t (T),做了一次
mapper转换，最终变成result(R),再将这个新的结果，给下层subsciber去继续执行。
从图文和代码分析，可以知道，map操作其实就是新建了一层结构，在原始结果继续向下执行的中间做了一次转换，然后将转换后的结果，继续给下层结构去执行。
