续着上篇内容 Rxjava原理分析之使用与手写(一) ，这篇内容继续手写加入map操作符，map 操作符在Rxjava中的作用是起到事件类型的转换，比如事件类型从String类型转成Bitmap类型，在Android 中常用的例子如传入一个图片地址，然后转成一个Bitmap，最后拿到这个Bitmap 填充到ImageView 中，如下：
Obserable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(Observer<String> o) {
o.onNext("图片地址");
}
}).map(new Function<String, Bitmap>() {
@Override
public Bitmap apply(String s) {
return Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
}
}).subscrible(new Observer<Bitmap>() {
@Override
public void onNext(Bitmap bitmap) {
// 拿到 Bitmap 填充到ImageView
}
});
map操作符号
接着上篇的例子，按照Rxjava中调用map 操作符之后返回一个Obserable ，返回一个新的老板；原来的老板刚招了个项目经理进来，员工都还没招呢，突然不想干了，把项目转交给了一个新的老板，现在这个新的老板不想做Android项目 了，他想做IOS项目
/**
* 老板
*/
public class Obserable<T> {
ObservableOnSubscribe onSubscribe;
private Obserable(ObservableOnSubscribe onSubscribe) {
this.onSubscribe = onSubscribe;
}
/**
* 老板需要招一个项目经理，所以需要传入一个ObservableOnSubscribe，参照Rxjava调度链
*/
public static <T> Obserable<T> create(ObservableOnSubscribe<T> onSubscribe) {
return new Obserable<T>(onSubscribe);
}
/**
* 创建一个新的老板，这个老板他要造做IOS项目
* 这里的T 代表Android资料，R代表IOS资料
*/
public <R> Obserable<R> map(Function<T, R> function) {
return new Obserable<R>(new OnSubscribleOnMap(onSubscribe, function));
}
/**
* 经过调用map方法之后，Obserable的泛型就是R类型了，所以下面的这个T 实际上是个R类型
*/
public void subscrible(Observer<T> observer) {
onSubscribe.subscribe(observer);
}
}
? 和上篇一样，多了个map() 方法，在方法内创建了一个做IOS的老板，这个老板也需要一个项目经理，这个项目经理能是上一个老板的项目经理吗？当然不能，IOS老板嫌弃Android的项目经理不懂通知IOS员工只懂通知Android员工，所以他也招了一个新的项目经理，这个项目经理就是OnSubscribleOnMap。IOS项目经理得和Android项目经理交接工作不是，所以OnSubscribleOnMap 就需要持有Android项目经理的引用。
? Function很简单，就是数据转换的流程，如下:
/**
* 这里的T 代表 "Android资料"，R代表“IOS资料”
*/
public interface Function<T, R> {
/**
* 由 类型T 转成 类型R,这个转换过程由使用者自己实现，只需要给到我一个R 类型就行
*/
R apply(T t);
}
下面看OnSubscribleOnMap:
public class OnSubscribleOnMap<T, R> implements ObservableOnSubscribe<R> {
private ObservableOnSubscribe<T> preOnSubscribe;
private Function<T, R> function;
public OnSubscribleOnMap(ObservableOnSubscribe<T> preOnSubscribe, Function<T, R> function) {
this.preOnSubscribe = preOnSubscribe;
this.function = function;
}
/**
* IOS项目经理通知员工的方法
*/
@Override
public void subscribe(Observer<R> rObserver) {
preOnSubscribe.subscribe(new Observer<T>() {
@Override
public void onNext(T t) {
R r = function.apply(t);
rObserver.onNext(r);
}
});
}
}
IOS项目经理也只有一个通知员工的方法，所以直接实现了ObservableOnSubscribe。通知员工开发IOS项目，但是传进来的员工只会开发IOS，不会Android，得给这个员工IOS资料他才能开发IOS，现在得拿到Android资料转成IOS的资料。Android 资料哪来的，当如是Android项目经理给到Android员工的，但是现在Android老板还没招Android员工呢，突然不干了，Android经理只能请个Android临时工来，并让这个临时工干活，临时工拿到Android资料之后经过Function转换成IOS资料。现在IOS资料拿到了，IOS经理就通知IOS员工干活了，并把IOS资料给到IOS员工。
手写map已经完成了，下面结合例子来看:
//1 创建一个Android老板
Obserable<Android> androidBoss = Obserable.create(new ObservableOnSubscribe<Android>() {
@Override
public void subscribe(Observer<Android> t) {
//Android经理通知Android员工干活，并给到Android资料
t.onNext(new Android());
}
});
//2 Android老板不想干了，交给IOS老板干
Obserable<IOS> iosBoss = androidBoss.map(new Function<Android, IOS>() {
@Override
public IOS apply(Android android) {
// 数据转换
return new IOS();
}
});
//3 IOS老板招一个IOS员工来开发IOS项目
iosBoss.subscrible(new Observer<IOS>() {
@Override
public void onNext(IOS ios) {
//IOS 员工收到ios资料接着干活了
}
});
1、通过Obserable.create 创建一个Android老板，这个老板做什么项目由项目经理决定，所以ObservableOnSubscribe的泛型是Android
2、Android老板不干了，交给IOS老板干，通过map方法造了一个IOS老板出来，IOS老板自己私招了一个IOS项目经理，在IOS项目经理内部完成了数据转换
3、IOS通知手下干活，IOS员工收到资料开始干活了
现在抛开例子说明，来分析方法调用流程：
Obserable<Android> androidBoss = Obserable.create(new ObservableOnSubscribe<Android>() {
@Override
public void subscribe(Observer<Android> t) {
//tip 1
t.onNext(new Android());
}
});
Obserable<IOS> iosBoss = androidBoss.map(new Function<Android, IOS>() {
@Override
public IOS apply(Android android) {
return new IOS();
}
});
iosBoss.subscrible(new Observer<IOS>() {
@Override
public void onNext(IOS ios) {
// tip 2
}
});
1、首先通过Obserable.create() 得到一个Obserable实例对象androidBoss，androidBoss对象里 onSubscribe 变量保存匿名ObservableOnSubscribe对象
2、androidBoss.map() 也创建了一个Obserable 实例对象iosBoss，iosBoss对象里的 onSubscribe 变量保存的是OnSubscribleOnMap对象，OnSubscribleOnMap中的变量preOnSubscribe 保存的是1中ObservableOnSubscribe匿名对象，function变量保存的是map() 方法传递进来的Function匿名对象
3、iosBoss.subscrible(new Observer()), iosBoss调用subscrible()方法，传入了Observer观察者，iosBoss的subscrible()方法内部调用的OnSubscribleOnMap类的subscribe() 方法，并传入Observer 类型的观察者
4、OnSubscribleOnMap的subscribe() 方法如下:
@Override
public void subscribe(Observer<R> rObserver) {
preOnSubscribe.subscribe(new Observer<T>() {
@Override
public void onNext(T t) {
// tip 3
R r = function.apply(t);
rObserver.onNext(r);
}
});
}
方法内通过调用preOnSubscribe.subscribe(new Observer()) 方法并传入一个临时匿名对象new Observer()，这个泛型T 在调用map方法的时候已经确定类型了，是个Android类型；所以回调到上面代码的 tip 1 ，接着调起 t.onNext(new Android()) 又回到 tip 3 ，得到一个Android对象，经function.apply() 转换后得到一个IOS类型对象，接着发起rObserver.onNext?; 这个rObserver就是步骤3传进来的Observer 类型的观察者，就回调到onNext() 方法中的tip 2
整个调用流程梳理完毕，分析得不太理想，得自行按照代码去捋一下流程理解起来更加清晰点；
下篇继续手写线程切换操作符（看看有没有写的必要）
