RxJava的开发学习笔记

最近在看Android 框架，看到了Retrofit这个网络请求，看Retrofit又看到了RxJava，一直都听说RxJava，这次自己决定开始学习RxJava了。看了一些博客，推荐以下两位大神的博客http://gank.io/post/560e15be2dca930e00da1083和http://blog.csdn.net/lzyzsd/article/details/41833541，本文也是在以上两篇博客的基础上，自己总结的。先放上GitHub 链接和引入依赖的 gradle 代码，https://github.com/ReactiveX/RxJava，https://github.com/ReactiveX/RxAndroid；
引入依赖：

compile 'io.reactivex:rxandroid:1.2.1'
compile 'io.reactivex:rxjava:1.1.6'

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 有四个基本概念：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() 二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
 

基本实现

1) 创建 Observer/Subscriber
2) 创建 Observable
3) Subscribe (订阅)

下面我把所有的都集成在一个Activity里，布局文件里就放了一个ImageView，就不贴代码了；

public class MainActivity extends AppCompatActivity {
    private ImageView imageView;
    int drawableRes = R.mipmap.icon_yao_my;
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView = (ImageView) findViewById(R.id.imageView);
        //   1) 创建 Observer/Subscriber
        Observer observer = new Observer() {//创建 Observer观察者
            @Override
            public void onCompleted() {//事件队列完结
 
            }
 
            @Override
            public void onError(Throwable e) {//事件队列异常
 
            }
 
            @Override
            public void onNext(String s) {//普通事件
                Log.v("MainActivity===", s);
            }
        };
 
        Subscriber subscriber = new Subscriber() {//创建订阅
            @Override
            public void onCompleted() {
 
            }
 
            @Override
            public void onError(Throwable e) {
 
            }
 
            @Override
            public void onNext(String s) {
                Log.v("MainActivity===", s);
            }
 
            @Override
            public void onStart() {
                super.onStart();
            }
        };
 
//           Observer 和Subscriber基本使用方式是完全一样的，实质上，在 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 observable = Observable.create(new Observable.OnSubscribe() {
 
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("Hi");
                subscriber.onNext("Aloha");
                subscriber.onCompleted();
            }
        });
 
        //      3) Subscribe (订阅)
        observable.subscribe(observer);
        // 或者：
        observable.subscribe(subscriber);
 
        //注：create() 方法是 RxJava 最基本的创造事件序列的方法。基于这个方法， RxJava 还提供了一些方法用来快捷创建事件队列，例如：
 
        //just(T...): 将传入的参数依次发送出来。
        Observable observable1 = Observable.just("Hello", "Hi", "Aloha");
 
        //from(T[]) / from(Iterable) : 将传入的数组或 Iterable 拆分成具体对象后，依次发送出来。
        String[] words = {"Hello", "Hi", "Aloha"};
        Observable observable2 = Observable.from(words);
 
//例子：a.打印字符串数组
 
        Observable.from(words).subscribe(new Action1() {// Action1 是一个接口，它只有一个方法 call(T param)，这个方法也无返回值，但有一个参数；
            @Override
            public void call(String s) {
                Log.v("MainActivity===", s);
            }
        });
//b. 由 id 取得图片并显示
        Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                Drawable drawable = getResources().getDrawable(drawableRes);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
 
            }
        }).subscribe(new Observer() {
            @Override
            public void onCompleted() {
 
            }
 
            @Override
            public void onError(Throwable e) {
                Toast.makeText(MainActivity.this, "Error!", Toast.LENGTH_SHORT).show();
            }
 
            @Override
            public void onNext(Drawable drawable) {
                imageView.setImageDrawable(drawable);
            }
        });
    }
 
}
以上实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，因此异步对于 RxJava 是至关重要的。而要实现异步，则需要用到 RxJava 的另一个概念： Scheduler 。下期再说；