谈谈RxJava

概述

如果上网去了解Android App架构设计，你会发现，都会有RxJava的身影，现在越来越多人开始接受并使用RxJava。对于Android开发而言，一旦你理解它，你一定会爱不释手。接下来来从几个方面来介绍RxJava。

RxJava是什么

官方给RxJava的定义如下：

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

翻译：RxJava是 ReactiveX 在JVM上的一个实现，ReactiveX使用Observable序列组合异步和基于事件的程序。

关于ReactiveX，可以参考官方文档：
https://mcxiaoke.gitbooks.io/rxdocs/content/Intro.html

ReactiveX.io给的定义是，Rx是一个使用可观察数据流进行异步编程的编程接口，ReactiveX结合了观察者模式、迭代器模式和函数式编程的精华。

RxJava有什么好处

说到RxJava的好处，大家肯定会异口同声地说是：简洁！它可以让我们的代码更简洁，逻辑更清晰。

函数式风格：对可观察数据流使用无副作用的输入输出函数，避免了程序里错综复杂的状态
简化代码：Rx的操作符通常可以将复杂的难题简化为很少的几行代码
异步错误处理：传统的try/catch没办法处理异步计算，Rx提供了合适的错误处理机制
轻松使用并发：Rx的Observables和Schedulers让开发者可以摆脱底层的线程同步和各种并发问题

为了让大家更清晰的看到RxJava带来的好处，套用网上的一个例子来说明：

假设有这样一个需求：界面上有一个自定义的视图 imageCollectorView ，它的作用是显示多张图片，并能使用 addImage(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在 imageCollectorView 中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在 UI 线程执行。常用的实现方式有多种，我这里贴出其中一种：

new Thread() {
    @Override
    public void run() {
        super.run();
        for (File folder : folders) {
            File[] files = folder.listFiles();
            for (File file : files) {
                if (file.getName().endsWith(".png")) {
                    final Bitmap bitmap = getBitmapFromFile(file);
                    getActivity().runOnUiThread(new Runnable() {
                        @Override
                        public void run() {
                            imageCollectorView.addImage(bitmap);
                        }
                    });
                }
            }
        }
    }
}.start();

如果用RxJava可以这样实现：

Observable.from(folders)
    //找到目录下的所有文件并发送出去
    .flatMap(new Func1<File, Observable<File>>() {
        @Override
        public Observable<File> call(File file) {
            return Observable.from(file.listFiles());
        }
    })
    //过滤掉非png结尾的文件，只发送png文件
    .filter(new Func1<File, Boolean>() {
        @Override
        public Boolean call(File file) {
            return file.getName().endsWith(".png");
        }
    })
    //把收到的png文件转为Bitmap发送出去
    .map(new Func1<File, Bitmap>() {
        @Override
        public Bitmap call(File file) {
            return getBitmapFromFile(file);
        }
    })
    //以上操作都在IO线程执行
    .subscribeOn(Schedulers.io())
    //订阅者的操作在UI线程执行
    .observeOn(AndroidSchedulers.mainThread())
    //订阅者
    .subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) {
            //收到Bitmap后添加到控件中显示出来
            imageCollectorView.addImage(bitmap);
        }
    });

对比上述代码，你会发现：

代码嵌套的层级少了，更加扁平，少了很多迷之缩进
代码逻辑也变得更清晰了，步骤明显
线程切换更简单，一行代码完成线程切换

上面的例子仅体现了一部分的优势，RxJava提供很丰富的操作符可用，可以应用到很多复杂的业务场景中。

这里仅列举一些Android中常用的操作符：

过滤操作（这些操作符用于从Observable发射的数据中进行选择）

Debounce — 只有在空闲了一段时间后才发射数据，通俗的说，就是如果一段时间没有操作，就执行一次操作，应用于搜索输入框
Throttle - 节流，一段时间内的事件只允许发送一个事件，应用于防止按钮多次点击
Distinct — 去重，过滤掉重复数据项
Filter — 过滤，过滤掉没有通过谓词测试的数据项，只发射通过测试的
First — 首项，只发射满足条件的第一条数据

组合操作（组合操作符用于将多个Observable组合成一个单一的Observable）

Zip — 打包，使用一个指定的函数将多个Observable发射的数据组合在一起，然后将这个函数的结果作为单项数据发射。应用于一个界面需要从多个接口请求数据
Concat - 顺序，Concat持有多个Observable对象，并将它们按顺序串联成队列。 first()操作符只从串联队列中取出并发送第一个事件。因此，如果使用concat().first()，无论多少个数据源，只有第一个事件会被检索出并发送。应用于接口缓存

其它操作

RetryWhen - 重试，指定什么情况重新执行发射流，应用于接口重试

更多操作符参考文档：https://mcxiaoke.gitbooks.io/rxdocs/content/Operators.html

RxJava基本原理

RxJava 的基本原理就是观察者模式。它有四个基本概念：

Observable - 可观察者，即被观察者
Observer - 观察者
Subscribe - 订阅
Event - 事件

与传统观察者模式不同， RxJava 的事件回调方法除了普通事件 onNext() （相当于 onClick() / onEvent()）之外，还定义了两个特殊的事件：onCompleted() 和 onError()。

onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。
onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。
在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

如何让整个事件流跑起来？

创建被观察者，可以通过from、just、create等操作符进行创建
创建观察者，可以直接new一个Subscriber的实现
订阅，通过subscribe函数把两者关联起来

PS:这里需要执行订阅后事件流才会开始，即如果没有订阅者，被观察者是不会执行任何操作

以下就是简单的创建一个事件流的示例代码：

        Observable.create(new Observable.OnSubscribe<Object>() {
            @Override
            public void call(Subscriber<? super Object> subscriber) {
                
            }
        }).subscribe(new Subscriber<Object>() {
            @Override
            public void onCompleted() {
                
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {

            }
        });

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

RxJava 已经内置了几个 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 主线程运行。

有了这几个 Scheduler ，就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。

subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。
observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

RxJava调用器还可以随时切换线程，让处理更加灵活：

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() 指定

可以这样简单理解，事件流是自上而下发送的，所以操作运行的线程都是在上游指定的，可以随意切换。但触发订阅这个动作是在最后面，之前说过，需要有订阅者订阅了，被观察者才会去执行发送事件。也就是订阅动作发生后，会自下而上去通知被观察者，即使中间写了subscribeOn也会无效，有效的只会是最上面的一个subscribeOn。所以被观察者发送事件的动作是由下面最近一个subscribeOn指定的。

RxJava在Android中使用的注意事项

内存泄漏问题

使用RxJava发布一个订阅后，当页面被finish，此时订阅逻辑还未完成，如果没有及时取消订阅，就会导致Activity/Fragment无法被回收，从而引发内存泄漏。

解决方案1：使用RxLifecycle库，使用此库要继承它的Fragment和Activity基类，然后在事件流中调用bindToLifecycle()方法。

解决方案2：自己管理，在Fragment和Activity、Presenter基类中添加CompositeSubscription, 每次调用订阅里把得到的subscription添加进去，基类会在onDestroy里自动取消订阅。
空指针问题

使用RxJava发布一个订阅后，当页面被finish，此时订阅逻辑还未完成，如果没有及时取消订阅，订阅逻辑完成后一样会触发订阅者的onNext方法，此时如果操作了页面元素，就会Crash。

解决方案：及时取消订阅，同时把presenter持有的view置空，不执行回调。

总结

RxJava是一种编程思想的突破，它给开发者带来了很多便利，让代码逻辑更加清晰简洁。可能有些开发团队认为学习曲线较长而放弃使用RxJava，但可以很负责任的告诉你，学习它！使用它！享受它！