Android RxJava初步认识

参考：

http://gank.io/post/560e15be2dca930e00da1083
http://blog.csdn.net/chen_zhang_yu/article/details/52900725
https://mcxiaoke.gitbooks.io/rxdocs/content/Observables.html

在正文开始之前的最后，放上 GitHub 链接和引入依赖的 gradle 代码： Github：
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid
引入依赖：
//compile ‘io.reactivex.rxjava2:rxjava:2.1.1’
//compile ‘io.reactivex:rxandroid:1.2.1’

一、RxJava 到底是什么

一个词：异步。
RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，概括得非常精准。
其实， RxJava 的本质可以压缩为异步这一个词。说到根上，它就是一个实现异步操作的库，而别的定语都是基于这之上的。

二、基本概念
1. 观察者模式
程序的观察者模式和真正的『观察』略有不同，观察者不需要时刻盯着被观察者（例如 A 不需要每过 2ms 就检查一次 B 的状态），而是采用注册(Register)或者称为订阅(Subscribe)的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。 Android 开发中一个比较典型的例子是点击监听器 OnClickListener 。对设置 OnClickListener 来说， View 是被观察者， OnClickListener 是观察者，二者通过 setOnClickListener() 方法达成订阅关系。订阅之后用户点击按钮的瞬间，Android Framework 就会将点击事件发送给已经注册的 OnClickListener 。采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。当然，这也得益于我们可以随意定制自己程序中的观察者和被观察者，而警察叔叔明显无法要求小偷『你在作案的时候务必通知我』。

2.RxJava的观察者模式
RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。
与传统观察者模式不同， RxJava 的事件回调方法除了普通事件 onNext() （相当于 onClick() / onEvent()）之外，还定义了两个特殊的事件：onCompleted() 和 onError()。
（1）onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
（2）onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
（3）在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

三、使用流程

主干的使用过程就是1.创建被观察者。2.创建观察者。3.将二者建立联系。完毕。然后被观察中发出信息触发观察者的动作，执行相应的方法，就这样。

    //创建一个被观察者(发布者)    Observable observable = Observable.create(new Observable.OnSubscribe<Integer>() {        @Override        public void call(Subscriber<? super Integer> subscriber) {            subscriber.onNext(1001);            subscriber.onNext(1002);            subscriber.onNext(1003);            subscriber.onCompleted();        }    });    //创建一个观察者    Subscriber<Integer> subscriber = new Subscriber<Integer>() {        @Override        public void onCompleted() {            Log.d(TAG, "onCompleted.. ");        }        @Override        public void onError(Throwable e) {            Log.d(TAG, "subscriber onError.. "　+　e.getMessage());        }        @Override        public void onNext(Integer integer) {            Log.d(TAG, "onNext.. integer:" + integer);        }    };    //注册观察者    //注册后就会开始调用call()中的观察者执行的方法 onNext() onCompleted()等    observable.subscribe(subscriber);

1) 创建 Observer

Observer 即观察者，它决定事件触发的时候将有怎样的行为。
除了 Observer 接口之外，RxJava 还内置了一个实现了 Observer 的抽象类：Subscriber。 Subscriber 对 Observer 接口进行了一些扩展，但他们的基本使用方式是完全一样的。
不仅基本使用方式一样，实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：
（1）onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法，具体可以在后面的文中看到。
（2）unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

2) 创建 Observable

Observable 即被观察者，它决定什么时候触发事件以及触发怎样的事件。RxJava 使用 create() 方法来创建一个 Observable ，并为它定义事件触发规则，从上面的例子可以看到，这里传入了一个 OnSubscribe 对象作为参数。OnSubscribe 会被存储在返回的 Observable 对象中，它的作用相当于一个计划表，当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发（对于上面的代码，就是观察者Subscriber 将会被调用三次 onNext() 和一次 onCompleted()）。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，例如：
just(T…): 将传入的参数依次发送出来。

Observable observable = Observable.just("Hello", "Hi", "Aloha");// 将会依次调用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

from(T[]) / from(Iterable

String[] words = {"Hello", "Hi", "Aloha"};Observable observable = Observable.from(words);// 将会依次调用：// onNext("Hello");// onNext("Hi");// onNext("Aloha");// onCompleted();

通过timer创建Observable：

//timer()创建一个Observable，它在一个给定的延迟后发射一个特殊的值 设定执行方法在UI线程执行//延时两秒后发射值//实测 延时2s后发送了一个0Observable timerObservable = Observable.timer(2, TimeUnit.SECONDS, AndroidSchedulers.mainThread());timerObservable.subscribe(        new Subscriber() {            @Override            public void onCompleted() {                Log.i(TAG, "timer(...)  onCompleted");                refreshStr("timer(...)  onCompleted\n");            }            @Override            public void onError(Throwable e) {                Log.e(TAG, "timer(...)  onError:" + e.getMessage());                refreshStr("timer(...)  onError:" + e.getMessage());            }            @Override            public void onNext(Object o) {                Log.d(TAG, "timer(...)  onNext:" + o.toString());                refreshStr("timerObservable 延时两秒触发 发送值：" + o.toString());            }        });

通过range创建Observable(这里叠加使用一个repeat方法)

//range 发射从n到m的整数序列 可以指定Scheduler设置执行方法运行的线程//repeat方法可以指定重复触发的次数Observable rangeObservable = Observable.range(3, 7).repeat(2);rangeObservable.subscribe(//在不写观察者的情况下，可以使用Action1和Action0这两个接口来实现不完整定义的回调； 参见：ActionSubscriber//Action有参无返回值//Action1<T>可以代替实现onNext(); Action1<Throwable>可以代替实现onError(); Action0可以代替实现onConplete()        new Action1() {            @Override            public void call(Object o) {                Log.e(TAG, "range(3, 7).repeat(2)  onNext:"+o.toString());            }        },        new Action1<Throwable>() {            @Override            public void call(Throwable throwable) {                Log.e(TAG, "range(3, 7).repeat(2)  "+throwable.getMessage());            }        },        new Action0() {            @Override            public void call() {                Log.i(TAG, "range(3, 7).repeat(2)  onCompleted");            }        });

3) Subscribe (订阅)

创建了 Observable 和 Observer 之后，再用 subscribe() 方法将它们联结起来，整条链子就可以工作了。

除了 subscribe(Observer) 和 subscribe(Subscriber) ，subscribe() 还支持不完整定义的回调，RxJava 会自动根据定义创建出 Subscriber 。形式如下：

Action1<String> onNextAction = new Action1<String>() {    // onNext()    @Override    public void call(String s) {        Log.d(tag, s);    }};Action1<Throwable> onErrorAction = new Action1<Throwable>() {    // onError()    @Override    public void call(Throwable throwable) {        // Error handling    }};Action0 onCompletedAction = new Action0() {    // onCompleted()    @Override    public void call() {        Log.d(tag, "completed");    }};// 自动创建 Subscriber ，并使用 onNextAction 来定义 onNext()observable.subscribe(onNextAction);// 自动创建 Subscriber ，并使用 onNextAction 和 onErrorAction 来定义 onNext() 和 onError()observable.subscribe(onNextAction, onErrorAction);// 自动创建 Subscriber ，并使用 onNextAction、 onErrorAction 和 onCompletedAction 来定义 onNext()、 onError() 和 onCompleted()observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

3 . 线程控制 —— Scheduler (一)

在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。也就是说，如果只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于 RxJava 是至关重要的。而要实现异步，则需要用到 RxJava 的另一个概念： Scheduler 。

RxJava有两个方法可以很方便的指定观察者和被观察者代码运行的线程，RxAndroid还有一个扩展，可以指定在UI线程运行。如下：

//设置观察者和发布者代码所要运行的线程后注册观察者observable.subscribeOn(Schedulers.immediate())//在当前线程执行subscribe()方法.observeOn(AndroidSchedulers.mainThread())//在UI线程执行观察者的方法.subscribe(subscriber);

通过Scheduler作为参数来指定代码运行的线程，非常方便，好用到不行…其他常用的参数还有：
　　Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。　
　　Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
　　Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免建不必要的线程。
　　Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
　　另外， Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。

4 . 变换

RxJava 提供了对事件序列进行变换的支持，这是它的核心功能之一，也是大多数人说『RxJava 真是太好用了』的最大原因。所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。

通过自己定义的方法，你可以将输入的值变换成另一种类型再输出(比如输入url，输出bitmap)，单一变换、批量变换、甚至实现双重变换，嵌套两重异步操作，并且代码格式一如既往的干净平整。

1）使用map()方法做转换:

//将文件路径转换为bitmap发出 观察者直接收到bitmap进行处理Observable observable = Observable.just(imgFilePath);//这里有func1，代表有参有返回值observable.map(new Func1<String, Bitmap>() {@Overridepublic Bitmap call(String imgFilePath) {return getBitmapFromAssets(imgFilePath);}}).subscribeOn(Schedulers.immediate())//当前线程(子线程)发布.observeOn(AndroidSchedulers.mainThread())//UI线程执行(更新图片).subscribe(new Subscriber<Bitmap>() {    @Override    public void onCompleted() {        Log.i(TAG, "observable.map(..)  onCompleted");    }    @Override    public void onError(Throwable e) {        Log.i(TAG, "observable.map(..)  onError" + e.getMessage());    }    @Override    public void onNext(Bitmap bitmap) {        //显示图片        iv.setImageBitmap(bitmap);    }});

2）flatMap()实现双重变换
　　flatMap()将一个发射数据的Observable变换为多个Observables，然后将它们发射的数据合并后放进一个单独的Observable。即：第一次转换时，它依次将输入的数据转换成一个Observable，然后将这些Observable发射的数据集中到一个Observable里依次发射出来。觉得莫名其妙？来看一个实际例子：
　　

//flatMap可以实现一个双重转换，在它的回调方法中会返回一个observable对象，但它并不会直接发射这个对象//而是将这个observable对象要发射的值 集中到一个新的observable对象中依次发射//如本例，第一层Observable依次发射两个数组，经过flatmap转换之后，变成变成两个依次发射数组元素的observable// 最后在subscriber中接收到的直接是整型数，等于将两个数组"铺开"了，直接发射整数，这就是大概地"flat"的含义吧// flatMap方法可以很灵活的使用，实现双重变换，满足很多不同情况下的需求,比如处理嵌套的异步代码等，非常棒!Integer[] array1 = {1, 2, 3, 4}, array2 = {5, 6, 7, 8};Observable.just(array1,array2).flatMap(new Func1<Integer[], Observable<?>>() {    @Override    public Observable<?> call(Integer[] ints) {        Observable observable = Observable.from(ints);        return observable;    }}).subscribe(subscriber);

3）scan()变换
　　scan操作符对原始Observable发射的第一项数据应用一个函数，然后将那个函数的结果作为自己的第一项数据发射。它将函数的结果同第二项数据一起填充给这个函数来产生它自己的第二项数据。它持续进行这个过程来产生剩余的数据序列。
　　

//scan 会将输入的第一个元素当作参数做一个函数运算(函数由你实现，规定需要两个参数，此时另一个默认没有)，然后发射结果// 同时，运算结果会被当作函数的与第二个参数与第二个元素再进行函数运算，完成后发射结果// 然后将这个结果与第三个元素作为函数的参数再次运算...直到最后一个元素Observable.just(1, 2, 3, 4).scan(new Func2<Integer, Integer, Integer>() {    @Override    public Integer call(Integer integer, Integer integer2) {        //integer是第一个元素或上一次计算的结果，integer2是下一轮运算中新的序列中元素        Log.d(TAG, "scan call   integer:" + integer + "   integer2:" + integer2);        return integer + integer2;    }}).subscribe(new Subscriber<Integer>() {    @Override    public void onCompleted() {        Log.i(TAG, "Observable.just(1,2,3,4).scan   onCompleted..");        initViewState();    }    @Override    public void onError(Throwable e) {        Log.e(TAG, "Observable.just(1,2,3,4).scan  onError  " + e.getMessage());    }    @Override    public void onNext(Integer integer) {        Log.d(TAG, "Observable.just(1,2,3,4).scan  onNext()..  integer = " + integer);        /**         * 第一次为1，然后是3(1+2)，6(3+3),10(6+4)         */    }});

5 . 线程控制：Scheduler (二)

除了灵活的变换，RxJava 另一个牛逼的地方，就是线程的自由控制。

1) Scheduler 的 API (二)

前面讲到了，可以利用 subscribeOn() 结合
来实现线程控制，让事件的产生和消费发生在不同的线程。可是在了解了 map() flatMap() 等变换方法后，有些好事的（其实就是当初刚接触 RxJava 时的我）就问了：能不能多切换几次线程？

答案是：能。因为 observeOn() 指定的是 Subscriber 的线程，而这个 Subscriber 并不是（严格说应该为『不一定是』，但这里不妨理解为『不是』）subscribe() 参数中的 Subscriber ，而是 observeOn() 执行时的当前 Observable 所对应的 Subscriber ，即它的直接下级 Subscriber 。换句话说，observeOn() 指定的是它之后的操作所在的线程。因此如果有多次切换线程的需求，只要在每个想要切换线程的位置调用一次 observeOn() 即可。上代码：

Observable.just(1, 2, 3, 4) // IO 线程，由 subscribeOn() 指定    .subscribeOn(Schedulers.io())    .observeOn(Schedulers.newThread())    .map(mapOperator) // 新线程，由 observeOn() 指定    .observeOn(Schedulers.io())    .map(mapOperator2) // IO 线程，由 observeOn() 指定    .observeOn(AndroidSchedulers.mainThread)     .subscribe(subscriber);  // Android 主线程，由 observeOn() 指定

如上，通过 observeOn() 的多次调用，程序实现了线程的多次切换。
不过，不同于 observeOn() ， subscribeOn() 的位置放在哪里都可以，但它是只能调用一次的。

2) 延伸：doOnSubscribe()

然而，虽然超过一个的 subscribeOn() 对事件处理的流程没有影响，但在流程之前却是可以利用的。

在前面讲 Subscriber 的时候，提到过 Subscriber 的 onStart() 可以用作流程开始前的初始化。然而 onStart() 由于在 subscribe() 发生时就被调用了，因此不能指定线程，而是只能执行在 subscribe() 被调用时的线程。这就导致如果 onStart() 中含有对线程有要求的代码（例如在界面上显示一个 ProgressBar，这必须在主线程执行），将会有线程非法的风险，因为有时你无法预测 subscribe() 将会在什么线程执行。

而与 Subscriber.onStart() 相对应的，有一个方法 Observable.doOnSubscribe() 。它和 Subscriber.onStart() 同样是在 subscribe() 调用后而且在事件发送前执行，但区别在于它可以指定线程。默认情况下， doOnSubscribe() 执行在 subscribe() 发生的线程；而如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。

Observable.create(onSubscribe)    .subscribeOn(Schedulers.io())    .doOnSubscribe(new Action0() {        @Override        public void call() {            progressBar.setVisibility(View.VISIBLE); // 需要在主线程执行        }    })    .subscribeOn(AndroidSchedulers.mainThread()) // 指定主线程    .observeOn(AndroidSchedulers.mainThread())    .subscribe(subscriber);