RXAndroid源码分析(三) map过程

标签（空格分隔）： rxandroid rxjava map

---

上一篇文章分析了一层结构最简单的事件触发的过程，接下来分析map过程，对于map过程宏观上的认识，借用官网上的一个图

从这个图中，我们可以看到，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方法。
图文结构：

代码分析：
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和其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操作其实就是新建了一层结构，在原始结果继续向下执行的中间做了一次转换，然后将转换后的结果，继续给下层结构去执行。