Android高级开发之【RxJava】详解（附项目源码）-白红宇

文章大纲

一、什么是RxJava

二、为什么要用RxJava

三、RxJava使用详解

四、项目源码下载

一、什么是RxJava

Rx(Reactive Extensions)是一个库，用来处理事件和异步任务，在很多语言上都有实现，RxJava是Rx在Java上的实现。简单来说，RxJava就是处理异步的一个库，最基本是基于观察者模式来实现的。通过Obserable和Observer的机制，实现所谓响应式的编程体验。

二、为什么要用RxJava

比如说一个庞大的项目，一个事件传递的整个过程可能要经历很多方法，方法套方法，每个方法的位置七零八落，一个个方法跳进去看,跳过去跳过来很容易把脑袋弄晕，不够直观。但是Rxjava可以把所有逻辑用链式加闭包的方式呈现，做了哪些操作，谁在前谁在后非常直观，逻辑清晰，维护就会非常轻松。就算不是你写的你也可以很快的了解，你可以把它看作一条河流，整个过程就是对里面的水流做进行加工。懂了这个特性我们才知道在复杂的逻辑中运用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
    
     >() {        @Override        public Observable
     
       call(File file) {            return Observable.from(file.listFiles());        }    })    .filter(new Func1
      
       () {        @Override        public Boolean call(File file) {            return file.getName().endsWith(".png");        }    })    .map(new Func1
       
        () {        @Override        public Bitmap call(File file) {            return getBitmapFromFile(file);        }    })    .subscribeOn(Schedulers.io())    .observeOn(AndroidSchedulers.mainThread())    .subscribe(new Action1
        
         () {        @Override        public void call(Bitmap bitmap) {            imageCollectorView.addImage(bitmap);        }    });复制代码

三、RxJava使用详解

1. RxJava设计模式

RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。

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

OnClickListener 的模式大致如下图：

RxJava 的观察者模式

RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、 subscribe (订阅)、事件。Observable 和 Observer 通过 subscribe() 方法实现订阅关系，从而 Observable 可以在需要的时候发出事件来通知 Observer。

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

onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted()方法作为标志。

onError(): 事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。

在一个正确运行的事件序列中, onCompleted() 和 onError() 有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted() 和 onError() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。

RxJava 的观察者模式大致如下图：

开始接入RxJava之间，添加依赖

dependencies {　　compile 'io.reactivex:rxandroid:1.2.1'　　compile 'io.reactivex:rxjava:1.1.6'　　}复制代码

2. 创建RxJava几种方式

方式1：简单创建Rxjava

/**     * 简单创建Rxjava     *     * Observable是被观察者，创建后传入一个OnSubscribe对象，当Observable（观察者）调用subscribe进行注册观察者时，OnSubscribe的call方法会触发。     ObservableEmitter： Emitter 是发射器的意思，它可以发出三种类型的事件，与之对应的。     Observer有三个回调方法：     onNext：接受到一个事件     onCompleted：接受完事件后调用，只会调用一次     onError ：发生错误时调用，并停止接受事件，调用一次     注：onCompleted和onError不会同时调用，只会调用其中之一     */    public static void createOne() {        //创建被观察者        Observable observable = Observable.create(new Observable.OnSubscribe
    
     () {            @Override            public void call(Subscriber
      subscriber) {                subscriber.onNext("Hello");                subscriber.onNext("吴");                subscriber.onNext("晓畅");                subscriber.onCompleted();            }        });        Subscriber
     
       subscriber = new Subscriber
      
       () {            @Override            public void onNext(String s) {                System.out.println("Item: " + s);            }            事件队列完结,RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。            @Override            public void onCompleted() {                System.out.println("Completed!");            }            事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。            @Override            public void onError(Throwable e) {                System.out.println("Error!");            }        };        observable.subscribe(subscriber);    }复制代码

运行结果如下所示：

方式2：just(T...): 将传入的参数依次发送出来

public static void createTwo()    {        //相当于        // 将会依次调用：        // onNext("Hello");        // onNext("Hi");        // onNext("Aloha");        // onCompleted();        Observable observable = Observable.just("Hello", "wu", "xiaochang");        Subscriber
    
      subscriber = new Subscriber
     
      () {            @Override            public void onNext(String s) {                System.out.println("Item: " + s);            }            事件队列完结,RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。            @Override            public void onCompleted() {                System.out.println("Completed!");            }            事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。            @Override            public void onError(Throwable e) {                System.out.println("Error!");            }        };        observable.subscribe(subscriber);    }复制代码

运行结果如下所示：

方式3：将传入的数组或 Iterable 拆分成具体对象后，依次发送出来

public static void createThree()    {        String[] words = {
    "Hello", "wu", "xiaochang"};        //相当于        // 将会依次调用：        // onNext("Hello");        // onNext("Hi");        // onNext("Aloha");        // onCompleted();        Observable observable = Observable.from(words);        Subscriber
    
      subscriber = new Subscriber
     
      () {            @Override            public void onNext(String s) {                System.out.println("Item: " + s);            }            事件队列完结,RxJava 规定，当不会再有新的 onNext() 发出时，需要触发 onCompleted() 方法作为标志。            @Override            public void onCompleted() {                System.out.println("Completed!");            }            事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出。            @Override            public void onError(Throwable e) {                System.out.println("Error!");            }        };        observable.subscribe(subscriber);    }复制代码

运行结果如下图所示：

方式4：发送多种类型参数

/**     *发送多种类型参数     */    public static void createFour()    {        //Just类似于From，但是From会将数组或Iterable的元素具取出然后逐个发射，而Just只是简单的原样发射，将数组或Iterable当做单个数据。        //Just接受一至九个参数，返回一个按参数列表顺序发射这些数据的Observable        Observable justObservable = Observable.just(1, "someThing", false, 3.256f, "NewYork");        justObservable.subscribe(new Subscriber() {            @Override            public void onCompleted() {                System.out.println("onCompleted!");            }            @Override            public void onError(Throwable e) {                System.out.println(e.getMessage());            }            @Override            public void onNext(Object o) {                System.out.println(o);            }        });    }复制代码

运行结果如下所示：

方式5：自定义Subscriber

/**     * 自定义Subscriber     */    public static void createFive()    {        Observable observable = Observable.just("Hello", "Hi", "Aloha");        Action1
    
      onNextAction = new Action1
     
      () {            // onNext()            @Override            public void call(String s) {                System.out.println(s);            }        };        Action1
      
        onErrorAction = new Action1
       
        () {            // onError()            @Override            public void call(Throwable throwable) {                // Error handling            }        };        Action0 onCompletedAction = new Action0() {            // onCompleted()            @Override            public void call() {                System.out.println("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. 创建观察者方法

创建方式如下：

Observer
    
      observer = new Observer
     
      () {            @Override            public void onNext(String s) {                Log.d(tag, "Item: " + s);            }            @Override            public void onCompleted() {                Log.d(tag, "Completed!");            }            @Override            public void onError(Throwable e) {                Log.d(tag, "Error!");            }        };        //创建方式2        Subscriber
      
        subscriber = new Subscriber
       
        () {            @Override            public void onNext(String s) {                Log.d("MainActivity", "Item: " + s);            }            @Override            public void onCompleted() {                Log.d("MainActivity", "Completed!");            }            @Override            public void onError(Throwable e) {                Log.d("MainActivity", "Error!");            }        };复制代码

实质上，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以如果你只想使用基本功能，选择 Observer 和 Subscriber 是完全一样的。它们的区别对于使用者来说主要有两点：

onStart(): 这是 Subscriber 增加的方法。它会在 subscribe 刚开始，而事件还未发送之前被调用，可以用于做一些准备工作，例如数据的清零或重置。这是一个可选方法，默认情况下它的实现为空。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， onStart() 就不适用了，因为它总是在 subscribe 所发生的线程被调用，而不能指定线程。要在指定的线程来做准备工作，可以使用 doOnSubscribe() 方法，具体可以在后面的文中看到。

unsubscribe(): 这是 Subscriber 所实现的另一个接口 Subscription 的方法，用于取消订阅。在这个方法被调用后，Subscriber 将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed() 先判断一下状态。 unsubscribe() 这个方法很重要，因为在 subscribe() 之后， Observable 会持有 Subscriber 的引用，这个引用如果不能及时被释放，将有内存泄露的风险。所以最好保持一个原则：要在不再使用的时候尽快在合适的地方（例如 onPause() onStop() 等方法中）调用 unsubscribe() 来解除引用关系，以避免内存泄露的发生。

3. 线程Scheduler (调度器）

在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。

在RxJava 中，Scheduler ——调度器，相当于线程控制器，RxJava 通过它来指定每一段代码应该运行在什么样的线程。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 所运行在的线程。或者叫做事件消费的线程。

public class RxJavaScheduler {    public static void showScheduler()    {        Observable.just(1, 2, 3, 4)//                .subscribeOn(Schedulers.io()) // 指定 subscribe() 发生在 IO 线程//                .observeOn(AndroidSchedulers.mainThread()) // 指定 Subscriber 的回调发生在主线程                .subscribe(new Action1
    
     () {                    @Override                    public void call(Integer number) {                        System.out.println("number:" + number);                    }                });    }    public static void main(String[] args) {        showScheduler();    }}复制代码

四、项目源码下载

链接:

密码:xvr2

Android前沿技术

关于RXJava的全部学习内容，我们这边都有系统的知识体系以及进阶视频资料，有需要的朋友可以加群免费领取安卓进阶视频教程，源码，面试资料，群内有大牛一起交流讨论技术；
（包括自定义控件、NDK、架构设计、混合式开发工程师(React native，Weex)、性能优化、完整商业项目开发等）

Android高级进阶视频教程