RxJava学习(一)

注意：文字和图片转载自抛物线博客

参考：http://gank.io/post/560e15be2dca930e00da1083

RxJava 究竟是什么

一个词：异步。

RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，归纳得很是精准。

然而，对于初学者来讲，这太难看懂了。由于它是一个『总结』，而初学者更须要一个『引言』。

其实， RxJava 的本质能够压缩为异步这一个词。说到根上，它就是一个实现异步操做的库，而别的定语都是基于这之上的。

RxJava 好在哪

换句话说，『一样是作异步，为何人们用它，而不用现成的 AsyncTask / Handler / XXX / ... ？』

一个词：简洁。

异步操做很关键的一点是程序的简洁性，由于在调度过程比较复杂的状况下，异步代码常常会既难写也难被读懂。 Android 创造的AsyncTask 和Handler ，其实都是为了让异步代码更加简洁。RxJava 的优点也是简洁，但它的简洁的不同凡响之处在于，随着程序逻辑变得愈来愈复杂，它依然可以保持简洁。

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 的观察者模式大体以下图：

2. 基本实现

基于以上的概念， RxJava 的基本实现主要有三点：

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...): 将传入的参数依次发送出来。
• from(T[]) / from(Iterable<? extends T>) : 将传入的数组或 Iterable 拆分红具体对象后，依次发送出来。

下面展现了建立Observable的各类方法。

• just( ) — 将一个或多个对象转换成发射这个或这些对象的一个Observable
• from( ) — 将一个Iterable, 一个Future, 或者一个数组转换成一个Observable
• repeat( ) — 建立一个重复发射指定数据或数据序列的Observable
• repeatWhen( ) — 建立一个重复发射指定数据或数据序列的Observable，它依赖于另外一个Observable发射的数据
• create( ) — 使用一个函数从头建立一个Observable
• defer( ) — 只有当订阅者订阅才建立Observable；为每一个订阅建立一个新的Observable
• range( ) — 建立一个发射指定范围的整数序列的Observable
• interval( ) — 建立一个按照给定的时间间隔发射整数序列的Observable
• timer( ) — 建立一个在给定的延时以后发射单个数据的Observable
• empty( ) — 建立一个什么都不作直接通知完成的Observable
• error( ) — 建立一个什么都不作直接通知错误的Observable
• never( ) — 建立一个不发射任何数据的Observable

3) Subscribe (订阅)

建立了 Observable 和 Observer 以后，再用 subscribe() 方法将它们联结起来，整条链子就能够工做了。

有人可能会注意到， subscribe() 这个方法有点怪：它看起来是『observalbe 订阅了 observer / subscriber』而不是『observer /subscriber 订阅了 observalbe』，这看起来就像『杂志订阅了读者』同样颠倒了对象关系。这让人读起来有点别扭，不过若是把 API 设计成 observer.subscribe(observable) / subscriber.subscribe(observable) ，虽然更加符合思惟逻辑，但对流式 API 的设计就形成影响了，比较起来明显是得不偿失的。

Observable.subscribe(Subscriber) 的内部实现是这样的（仅核心代码）：

// 注意：这不是 subscribe() 的源码，而是将源码中与性能、兼容性、扩展性有关的代码剔除后的核心代码。
// 若是须要看源码，能够去 RxJava 的 GitHub 仓库下载。
public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart();
    onSubscribe.call(subscriber);
    return subscriber;
}

能够看到， 作了3件事：subscriber()

1. 调用 Subscriber.onStart() 。这个方法在前面已经介绍过，是一个可选的准备方法。
2. 调用 Observable 中的 OnSubscribe.call(Subscriber) 。在这里，事件发送的逻辑开始运行。从这也能够看出，在 RxJava 中，Observable 并非在建立的时候就当即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候。
3. 将传入的 Subscriber 做为 Subscription 返回。这是为了方便 unsubscribe().

整个过程当中对象间的关系以下图：

或者能够看动图：

完整3步的代码：

public static void learnRxJava(){
        //生成Observer
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

            }
        };

        //生成Subscriber
        //多了onStart和unsubscribe两个很是有用的方法
        Subscriber<String> subscriber = new Subscriber<String>() {
            @Override
            public void onStart() {
                super.onStart();
            }

            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String o) {

            }
        };

        if(subscriber.isUnsubscribed()){
            subscriber.unsubscribe();
        }

        //生成Observable的三种方法

        //1.create
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("1");
                subscriber.onNext("2");
                subscriber.onNext("3");
                subscriber.onCompleted();
            }
        });

        //2.just
        // 将会依次调用：
        // onNext(1);
        // onNext(2);
        // onNext(3);
        // onNext(4);
        // onCompleted();
        Observable<Integer> observable1 = Observable.just(1, 2, 3, 4);

        //3.from 参数传入一个集合
        // 将会依次调用：
        // onNext(1);
        // onNext(2);
        // onNext(3);
        // onNext(4);
        // onCompleted();
        Integer[] numbers = new Integer[]{1,2,3,4};
        Observable<Integer> observable2 = Observable.from(numbers);

        observable.subscribe(observer);

}

除了 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);

简单解释一下这段代码中出现的 Action1 和 Action0。 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) 的，它们能够被用以包装不一样的无返回值的方法。

注：正如前面所提到的，Observer 和 Subscriber 具备相同的角色，并且 Observer 在 subscribe() 过程当中最终会被转换成 Subscriber对象，所以，从这里开始，后面的描述我将用 Subscriber 来代替 Observer ，这样更加严谨。