前言#

在找工作的时候看到过有面试要求会RxJava + Retrofit，当时也没有太在意，正好新的工作中用的就是这个，也慢慢体会了一下，的确是不错，他的优点就是逻辑清晰，对象的加工和线程的切换都是傻瓜操作，不得不说他火的有道理。

正文#

概念性的东西就不说了，RxAndroid是RxJava在Android平台的一个版本，实现的功能几乎都是一样的。我在使用的都是都是2.0版本，跟低版本使用方法是有区别的，这也是为什么我决定写这个博客的原因。

他的设计思想就是用观察者的模式去解决问题，把一个被观察对象让一个或多个观察者去监听他的变化，所以先来看看他的一些基础类：

Observable：被观察者，也就是我们实际上要操作的对象。
Observer：观察者，他还有很多的子类。

你能够监听到的被观察者的行为：
Action：行为，目前只找到用到onComplete。
Function：功能，一般用它来进行对象的转换。
BiFunction：另一种功能，我目前只发现用在reduce方法中，具体之后在看。
Consume：应该可以叫做执行者，可以用来回调中间的一些操作，例如onError。
BiConsumer：也一样，用在doOnEvent中。

ok，剩下的就是到底我们能对被观察者做什么，也就是Observable的api，在这里我们需要把观察者的概念反过来：

不是 观察者 --> 观察 --> 被观察者，而是 被观察者 --> 被观察 --> 观察者。

<h2>常用的api</h2>

RxAndroid的执行是顺序的，有点类似Builder模式。

首先我们需要了解两个最重要的api：

just：填装我们要进行观察的对象，之后的操作都是以这个对象为起点的。

subscribe：消耗观察的事件，我们可以从中得到回调，也就是要传入我们的观察者Observer，这里代码我们使用MaybeObserver，也可以能直接Action或者是Consume（内部把Action和Consumer封装成MaybeObserver），其实都是一样的。

如何对被观察者进行加工：

map：单个对象的转换

看一下代码：

Observable.just(numbers).map(new Function<String[], String>() {
            @Override
            public String apply(@NonNull String[] strings) throws Exception {
                return "屌爆了哦";
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("lzp", "onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("lzp", "onNext");
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("lzp", "onError");
            }

            @Override
            public void onComplete() {
                Log.e("lzp", "onComplete");
            }
        });

numbers是一个字符串数组，这里我们把他转换成了一个String，接下来看一下打印日志：

com.lzp.rxjavastudy E/lzp: onSubscribe
com.lzp.rxjavastudy E/lzp: onNext:屌爆了哦
com.lzp.rxjavastudy E/lzp: onComplete

当开始观察的时候回调了onSubscribe，每当加工完成时回调onNext，全部完成时回调onComplete，如果出现了意外情况就回调onError，我们这里没有异常，也就没有回调onError。

如果我不想一对一加工，而是一对多，并且每一个加工后的对象都会执行之后的操作怎么办？这个时候还有flatmap，可能话有点说不明白，直接看代码。

flatmap：将预装的对象，映射成多个对象，返回的对象的是Observable类型。

private class School {
        public String[] student = {"111", "222", "222", "222", "222", "222", "222", "222", "222", "222", "222"};
    }
    
Observable.just(new School()).flatMap(new Function<School, ObservableSource<String>>() {
            @Override
            public ObservableSource<String> apply(@NonNull School school) throws Exception {
                Log.e("lzp", "flatMap");
                return Observable.fromArray(school.student);
            }
        }).map(new Function<String, String>() {
            @Override
            public String apply(@NonNull String s) throws Exception {
                return "屌爆了";
            }
        }).subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(@NonNull Disposable d) {
                Log.e("lzp", "onSubscribe");
            }

            @Override
            public void onNext(@NonNull String s) {
                Log.e("lzp", "onNext:" + s);
            }

            @Override
            public void onError(@NonNull Throwable e) {
                Log.e("lzp", "onError");
            }

            @Override
            public void onComplete() {
                Log.e("lzp", "onComplete");
            }
        });

简单的分析一下代码：首先我们把预装的School对象通过flatmap映射出多个ObservableSource<String>，之后使用了map再对每一个映射出来的String对象进行加工，所以我们猜测，我们最终会看到很多的相同的结果：屌爆了。

ok，赶紧看一下日志：

com.lzp.rxjavastudy E/lzp: flatMap
com.lzp.rxjavastudy E/lzp: onSubscribe
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onNext:屌爆了
com.lzp.rxjavastudy E/lzp: onComplete

预想的跟我们几乎是完全一样，但是没想到flatmap会在onSubscrib的前面，说明flatmap并不算是被观察者发生变化的范围之内，仅仅是改变了被观察者的对象。

总结#

最后我们来仔细的总结一下map和flatmap的区别：

flatmap：不属于加工范围，仅仅是对被观察者的对象进行一些特殊的指定操作，可能由一个变成多个，返回的都是ObservableSource，可以和just看成是一个级别的，对被观察者的范围造成影响。

map：属于加工范围，会回调onNext，返回的是加工后的具体对象，而不是ObservableSource。

虽然名字很像，但是实际他俩并没有什么卵关系。

我自己画了一张流程图，来加深我们对api划分的理解，虽然难看了点，但是自我感觉还行：

这里写图片描述

刚开始我对flatmap和map的区别很懵逼，希望我对他们的理解能够对大家有帮助。

本来想一篇博客写完，但是发现想说的确实比我想象的要多，所以下一篇再继续将下一部分内容。