Rxjava原理分析之手写map操作符(二)

续着上篇内容 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

整个调用流程梳理完毕，分析得不太理想，得自行按照代码去捋一下流程理解起来更加清晰点；

下篇继续手写线程切换操作符（看看有没有写的必要）