首先看一段Map函数的使用代码：

        Observable.create(new Observable.OnSubscribe<Integer>() {@Overridepublic void call(Subscriber<? super Integer> subscriber) {subscriber.onNext(123);}}).map(new Func1<Integer, String>() {@Overridepublic String call(Integer integer) {return integer.toString();}}).subscribe(new Subscriber<String>() {public static final String TAG ="Test" ;@Overridepublic void onCompleted() {}@Overridepublic void onError(Throwable e) {}@Overridepublic void onNext(String s) {Log.d(TAG, "onNext: "+s);}});

Observable<Integer>Observable1=Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override

public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(123); }

})；

create函数构建了一个新的Observable 在Observable的构造函数中将Observable.onSubscribe属性赋值为 Observable.OnSubscribe<Integer>;
Observable<String> Observable2= Observable1.map(new Func1<Integer, String>() {
     @Override
     public String call(Integer integer) {
     return null;
   }});
通过 map函数构建了一个新的Observable
map函数源码：
public final <R> Observable<R> map(Func1<? super T, ? extends R> func) {
     return lift(new OperatorMap<T, R>(func));
}
在map源码中首先通过func(这里的func指的就是Func1<Integer, String>())参数构建一个OperatorMap类；
public OperatorMap(Func1<? super T, ? extends R> transformer) {
   this.transformer = transformer;
}
OperatorMap.transformer 也指向了Func1<Integer, String>()；

lift函数里面创建了一个新的Observable，而上边的Observable<String> Observable2也就是lift函数创建的；
public final <R> Observable<R> lift(final Operator<? extends R, ? super T> operator) {
return new Observable<R>(new OnSubscribeLift<T, R>(onSubscribe, operator));
}
public final class OnSubscribeLift<T, R> implements OnSubscribe<R>

在构造函数中传了一个OnSubscribeLift对象，因此Observable2.onSubscribe 也就指向了OnSubscribeLift；

public OnSubscribeLift(OnSubscribe<T> parent, Operator<? extends R, ? super T> operator) {
this.parent = parent;
this.operator = operator;
}
在OnSubscribeLift的构造函数中parent 被指向为Observable1中的OnSubscribe（Observable.OnSubscribe<Integer>()）
operator指向OperatorMap；
通过Map函数就创建了一个新的Observable，所有开头的例子的代码就变成了
Observable2 .subscribe(new Subscriber<String>() {
public static final String TAG ="125" ;

@Override
public void onCompleted() {

}

@Override
public void onError(Throwable e) {

}

@Override
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}
});
然后在分析下subscribe函数：
public final Subscription subscribe(Subscriber<? super T> subscriber) {
return Observable.subscribe(subscriber, this);
}
在Observable.subscribe(subscriber, this); 中的this 指向的是Observable2；

static <T> Subscription subscribe(Subscriber<? super T> subscriber, Observable<T> observable) {
.................
subscriber.onStart();
hook.onSubscribeStart(observable, observable.onSubscribe).call(subscriber);
return hook.onSubscribeReturn(subscriber);
.................
}
从subscribe函数代码可以看出，最终调用的是onSubscribe的call函数；
此时的onSubscribe指向的是Observable2.onSubscribe 也就是早lift函数中创建的OnSubscribeLift；
在OnSubscribeLift.java 代码中:
public void call(Subscriber<? super R> o) {
.............
Subscriber<? super T> st = hook.onLift(operator).call(o);

st.onStart();
parent.call(st);
............
}
在call函数中参数 Subscriber<? super R> o指向的是subscribe函数中的Subscriber<String>()；
call函数的内部首先创建了一个新的 Subscriber<? super T> st;
此时的operator指向的是OperatorMap类
新的Subcriber（MapSubscriber对象）放入订阅列表中，以便最后一起把订阅对象释放。同时返回新的Subcriber。
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;
}
static final class MapSubscriber<T, R> extends Subscriber<T> {
  public MapSubscriber(Subscriber<? super R> actual, Func1<? super T, ? extends R> mapper) {
   this.actual = actual;
   this.mapper = mapper;
  }
}
在OperatorMap类的call方法中创建了一个新的MapSubscriber对象；
在创建的MapSubscriber对象的构造函数中对字段进行赋值
actual 指向 o 也就是subscribe函数中的Subscriber<String>()；
mapper 指向OperatorMap.transformer (指向了map函数的中参数Func1<Integer, String>())

回到在OnSubscribeLift.call 代码中，当创建好新的Subscriber对象后，将执行
parent.call(st)；
此时的parent 指向的是Observable1中的OnSubscribe，因此调用的call方法相当于是
public void call(Subscriber<? super Integer> subscriber) {
  subscriber.onNext(123);
}
此时的subscriber 就是新建的st(MapSubscriber) 跳转到onNext函数中；
static final class MapSubscriber<T, R> extends Subscriber<T> {
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);
}
}
此时的参数t为123；执行mapper.call(t);
mapper此时执行的是
public String call(Integer integer) {
return integer.toString();
}
result 就变为了"123";
然后在执行actual.onNext("123");
actual此时就是：
public void onNext(String s) {
Log.d(TAG, "onNext: "+s);
}

到现在为止，整个流程代码就分析完成了