RxJava笔记

RxJava 定义

** a library for composing（组成） asynchronous and event-based programs using observable sequences for the java VM (一个在 Java VM 上使用可观测的序列来组成的异步的、基于事件的程序的库)；**

RxJava 优点

简洁：异步操作很关键的一点是程序的简洁性，因为在调度过程比较复杂的情况下，异步代码经常会既难写又难被读懂。Android 创造的AsyncTask和Handler，其实都是为了让异步代码更加简洁。RxJava 的优势也是简洁，但它的简洁与众不同之处在于，随着程序逻辑变得越来越复杂，它依然能够保持简洁。

API 介绍和原理分析

1. 概念：扩展的观察者模式

RxJava 的异步实现，是通过一种扩展的观察者模式来实现的。
观察者模式：观察者模式面向的需求是：A 对象（观察者）对 B 对象（被查观察者）的某种变化高度敏感，需要在 B 变化的一瞬间做出反应。程序的观察者模式，观察者不需要时刻盯着被观察者，而是采用注册（Register）或者称为订阅（Subscribe）的方式，告诉被观察者：我需要你的某某状态，你要在它变化的时候通知我。Android 开发中一个比较典型的日子是点击监听器OnClickListener。对设置OnClickListenr来说，View是被观察者，OnClickListenr是观察者，二者通过setOnClickListener方法达成订阅关系。订阅之后用户点击按钮的瞬间，AndroidFrameWork 就会将点击事件发送给已经注册的OnClickListenr。采取这样被动的观察方式，既省去了反复检索状态的资源消耗，也能够得到最高的反馈速度。

2. RxJava 的观察者模式

RxJava 有四个基本概念：

Observable（可观察者，即被观测者）

Observer（观察者）

Subscribe（订阅）

Event（事件）

Observable和Observer通过suscribe()方法实现订阅关系，从而Observable可以在需要的时候发出事件来通知Observer。与传统观测者模式不同，RxJava 的事件回调除了普通事件onNext（）（相当于onClick()和onEvent()）之外，还定义了俩个特殊的事件：onCompleted（）和onError（）：

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

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

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

RxJava 的观察者模式大致如下： Observable–》onNext（）/onCompleted（） or onError（）–》Observer；

3. 基本实现：

1. 创建`Observer`

Observer即观察者，它决定事件触发的时候将有怎样的行为。RxJava 的Observer接口的实现方式：

  Observer<String> observer = new Observer<String>() {
    @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!");
    }
};

除了Observer接口之外，RxJava 还内置了一个实现了Observer的抽象类：Subscriber。Subscriber对Observer接口进行了一些扩展，但他们的基本使用方式是完全一样的：

Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted() called with: " + "");
            }
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError() called with: " + "e = [" + e + "]");
            }
            @Override
            public void onNext(String s) {
                Log.d(TAG, "onNext() called with: " + "s = [" + s + "]");
            }
        };

不仅基本使用方式一样，实质上，在 RxJava 的Subscribe过程中，Observer也总是会被先转换成一个Subscriber再使用。他们之间的区别主要有俩点：

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

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

2. 创建 Observable

Observable 即被观察者，它决定什么时候触发事件以及触发怎么样的事件。RxJava 使用create（）方法来创建一个Observable，并为他定义事件触发规则：

Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber< ? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("World!");
                subscriber.onNext("RxJava");
                subscriber.onCompleted();
            }
        });

可以看到这里传入了一个OnSubscribe对象作为参数。OnSbuscribe会被存储在返回的Onservable对象中，它的作用相当于一个计划表，当Obervable被订阅的时候，OnSubscribe的call（）方法会自动被调用，事件序列就会依照设定顺序依次触发。这样，由被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

create（）方法是 RxJava 最基本的创造事件序列的方法。基于这个方法，RxJava 还提供了一些方法用来快捷创建事件队列，例如:

just（T...)将传入的参数依次发送出来：
1

//被观察者的创建方式2：just（） 将传入的参数依次发送出来
    Observable<String> observable1 = Observable.just("Hello", "World!", "RxJava");
    // 将会依次调用：
    // onNext("Hello");
    // onNext("World!");
    // onNext("RxJava");
    // onCompleted();

1 2	* `from(T[])/from(Iterable(? extend T))`将传入的数组或者Iterable拆分成具体对象后发送出来 ~~~java

//被观察者的创建方式3：from（T[])/from(Iteraable< ? extends T>) 将传入的数组或者Iterable拆分成具体对象后发送出来
    String[] words = {"Hello", "World!", "RxJava"};
    Observable observable2 = Observable.from(words);
    // 将会依次调用：
    // onNext("Hello");
    // onNext("World!");
    // onNext("RxJava");
    // onCompleted();

上面三种方式创建被观察者 Obersvable 对象，是等价的！

创建了Observable和Observer对象之后，再用subscribe（）方法将他们连接起来，整条工作链就完成了。
代码很简单：

1	observable.subscribe(subscriber);

    //or
 observable.subscribe(observer);

**`Observable.subscribe(Subscriber)`的内部实现功能核心伪代码**
~~~java
// 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 如果需要看源码，可以去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) {

subscriber.onStart();
onSubscribe.call(subscriber);
return subscriber;

}

这里`subscribe（）`做了3件事：
* 调用`Subscriber.onStart()`.
* 调用`Observable`中的OnSubscribe.call（Subscriber）`。
* 将传入的`Subscriber`作为`Subscription`返回。这是为了方便`unsubscribe（）`；
![](/images/subscribe.gif)
除了`subscribe（Observer）`和`subscribe（subscriber）`，`subscribe（）`还支持不完整定义的回调，RxJava会自动根据定义创建出Subscriber。
形式如下：
~~~java
 	   Action1<String> onNextAction = new Action1<String>() {

        @Override
        public void call(String s) {
            Log.d(TAG, "call() called with: " + "s = [" + s + "]");
        }
    };
    Action1<Throwable> onErrorAction = new Action1<Throwable>() {
        @Override
        public void call(Throwable throwable) {
            Log.d(TAG, "call() called with: " + "throwable = [" + throwable + "]");
        }
    };
    Action0 onCompletedAction = new Action0() {
        @Override
        public void call() {
            Log.d(TAG, "call() called with: " + "completed");
        }
    };

//自动创建 Subscriber,并使用 onNextAciton 来定义 onNext（）；
observable.subscribe(onNextAction);
//自动创建 Subscriber,并使用 onNextAciton 和 onErrorAciton，来定义 onNext（）和 onError（）；
observable.subscribe(onNextAction, onErrorAction);
//自动创建 Subscriber,并使用 onNextAction 来定义 onNext（），使用 onErrorAciton 来定义 onError（），使用 onCompletedAction 来定义 onCompleted（）
observable.subscribe(onNextAction,onErrorAction,onCompletedAction);

`Action0` 是 RxJava 的一个接口，它只有一个方法 `call()`，这个方法是无参无返回值的；由于 `onCompleted()` 方法也是无参无返回值的，因此 `Action0` 可以被当成一个包装对象，将 `onCompleted()` 的内容打包起来将自己作为一个参数传入 `subscribe()` 以实现不完整定义的回调。这样其实也可以看做将`onCompleted()` 方法作为参数传进了 `subscribe()`，相当于其他某些语言中的『闭包』。 `Action1` 也是一个接口，它同样只有一个方法 `call(T param)`，这个方法也无返回值，但有一个参数；与 `Action0` 同理，由于 `onNext(T obj)` 和 `onError(Throwable error)` 也是单参数无返回值的，因此 `Action1` 可以将 `onNext(obj)` 和 `onError(error)` 打包起来传入 `subscribe()` 以实现不完整定义的回调。事实上，虽然 `Action0` 和 `Action1` 在 API 中使用最广泛，但 RxJava 是提供了多个 `ActionX` 形式的接口 (例如 `Action2`, `Action3`) 的，它们可以被用以包装不同的无返回值的方法。

4. 场景展示

打印字符串数组：

/**
  * 使用RxJava模式打印字符串数组
  */
 private void printStr() {
     String[] names = {"tom", "lily", "hanmeimei"};
     Observable.from(names).subscribe(new Action1<String>() {
         @Override
         public void call(String s) {
             Log.d(TAG, "call() called with: " + "s = [" + s + "]");
         }
     });
 }

使用 RxJava 的方式设置一张图片

/**
    * 使用RxJava模式设置ImageView的背景显示
    */
   private void setImageViewWithRxJava() {
       final int drawableRes = R.drawable.cloudsea;
       Observable.create(new Observable.OnSubscribe<Drawable>() {
           @Override
           public void call(Subscriber< ? super Drawable> subscriber) {
               Drawable drawable = getTheme().getDrawable(drawableRes);
               subscriber.onNext(drawable);
               subscriber.onCompleted();
           }
       }).subscribe(new Observer<Drawable>() {
           @Override
           public void onCompleted() {
               Log.d(TAG, "onCompleted() called with: " + "");
           }
           @Override
           public void onError(Throwable e) {
               Log.d(TAG, "onError() called with: " + "e = [" + e + "]");
           }
           @Override
           public void onNext(Drawable drawable) {
               ivRxjavademo.setImageDrawable(drawable);
           }
       });
   }

如上所示：创建出Observable和Suberver，再用subscribe（）将他们串起来，一次 RxJava 的基本使用就完成了。
然而，在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程。也就是说，如果只用上面的方法，实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是：后台处理，前台回调 的异步机制，因此异步对于 RxJava 是至关重要的。而实现异步，这需要用到 RxJava 的另一个概念：Scheduler。

5. 线程控制–Scheduler

在不指定线程的情况下，RxJava 遵循的是线程不变的原则，即：在那个线程调用subscribe（），就在那个线程生产事件；在那个线程生产事件，就在那个线程消费事件。如果需要切换线程，就需要用到scheduler（）调度器。
Scheduler 的 API：在 RxJava 中，Scheduler–调度器，相当于线程控制器，RxJava 通过它来指定每一段代码运行在什么样的线程。RxJava 已经内置了几个 Scheduler。它们已经适合大多数使用场景：

Schedulers.immediate():直接在当前线程运行，相当于不指定线程。这是默认的Scheduler。

Schedulers.newThread():总是启用新线程，并在新线程执行操作。
Schedulers.io():I/0 操作（读写文件、读写数据库、网络信息交互等）所使用的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所运行的线程，或者叫做事件消费的线程。

/**
     * Scheduler: 调度器使用
     */
    private void scheduler() {
        Observable.just(1, 2, 3, 4)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Log.d(TAG, "call() called with: " + "integer = [" + integer + "]");
                    }
                });
    }

上面这段代码中，由于subscribeOn（Schedulers.io()）的指定，被创建的事件的内容 1/2/3/4 将会在 IO 线程发出；而由于observeOn（AndroidSchedulers.mainThread()）的指定，因此subscriber数字的打印将发生在主线程中。事实上，这种在subscribe（）之前加上subscribeOn（Scheduler.io)和observeOn（AndroidSchedulers.mainThread())的使用方式非常常见，它适用于多数的【后台线程获取数据，主线程显示】的程序策略。
优化前面加载图片的例子：

/**
     * 使用RxJava模式设置ImageView的背景显示
     */
    private void setImageViewWithRxJava() {
        final int drawableRes = R.drawable.cloudsea;
        Observable.create(new Observable.OnSubscribe<Drawable>() {
            @Override
            public void call(Subscriber< ? super Drawable> subscriber) {
                Drawable drawable = getTheme().getDrawable(drawableRes);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
            }
        })
                .subscribeOn(Schedulers.io()) //指定subscribe（）发生在I/O线程
                .observeOn(AndroidSchedulers.mainThread())//指定Subscriber的回调发生在主线程
                .subscribe(new Observer<Drawable>() {
            @Override
            public void onCompleted() {
                Log.d(TAG, "onCompleted() called with: " + "");
            }
            @Override
            public void onError(Throwable e) {
                Log.d(TAG, "onError() called with: " + "e = [" + e + "]");
            }
            @Override
            public void onNext(Drawable drawable) {
                ivRxjavademo.setImageDrawable(drawable);
            }
        });
    }

加载图片将会发生在 IO 线程，而设置图片则被设定在了主线程。这就意味着，即使加载图片好黑了几十甚至几百毫秒的事件，也不会造成界面的卡顿。