我的RxJava入门（一）

参考文档http://gank.io/post/560e15be2dca930e00da1083

RxJAVA是什么?
官方的解释是RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.翻译为：RxJava是Reactive Extensions的Java VM实现：通过使用观察序列构成异步和基于事件的程序库

build.gradle中添加依赖：

compile 'io.reactivex:rxjava:1.0.14' 
compile 'io.reactivex:rxandroid:1.0.1'

开发作者的githut地址
https://github.com/ReactiveX/RxJava
https://github.com/ReactiveX/RxAndroid

RxJava的好处在哪
在以前，我们实现异步处理都是使用handler，AsynTask，还有一些自定义的异步线程等去异步处理任务。但是RxJava简化我们在异步处理过程中需要做的工作，使程序代码随着逻辑逐渐变得复杂依然能够保持简洁。

RxJava原理解析
RxJava的异步实现是通过一种拓展的观察者模式来实现的

观察者模式的理解:观察者与被观察者存在一种注册(register)与订阅(subscribe)的关系，观察者要求被观察者在其状态发生变化时，传递相应事件来通知观察者,以便对不同的状态做出相应的反应。被观察者调用了观察者的回调方法，就实现了由被观察者向观察者的事件传递，即观察者模式。

RxJava中的观察者模式
四个基本概念:
1).被观察者(observable)
2).观察者(observer)
3).订阅(subscribe)
4).事件(event)

Observable 和 Observer 通过 subscribe() 方法实现订阅关系，Observable 可以在需要的时候发出事件来通知 Observer。
RxJava 的事件回调方法除了普通事件 onNext() (相当于 onClick() / onEvent())，还定义了两个特殊的事件：onCompleted() 和 onError();
解析

方法名	用途
onCompleted()	事件队列处理完毕。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava规定，当不会再有新的onNext()发出时，需要触发onCompleted()方法作为标志
onError()	事件队列异常。在事件处理过程中出异常时，onError() 会被触发，同时队列自动终止，不允许再有事件发出

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

RxJava的基本和实现
1)创建Observer
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!");
    }
};

subscribe接口的实现方式

Subscriber<String> subscriber = new Subscriber<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!");
    }
};

notes:使用基本功能时候，选择 Observer 和 Subscriber 是完全一样的
区别:

方法名	用途
onStart()	Subscriber中的可选方法,默认情况下实现为空。它会在subscribe刚开始，而事件还未发送之前被调用,可以用于做一些准备工作,例如数据的清零或重置。需要注意的是，如果对准备工作的线程有要求（例如弹出一个显示进度的对话框，这必须在主线程执行）， 它总是在 subscribe 所发生的线程被调用，而不能指定线程。
unsubscribe()	Subscriber实现的接口 Subscription中的方法，用于取消订阅。在这个方法被调用后，Subscriber将不再接收事件。一般在这个方法调用前，可以使用 isUnsubscribed()先判断一下状态。 unsubscribe() 这个方法很重要,因为在 subscribe() 之后,Observeable 会持有 Subscriber 的引用,这个引用如果不能及时被释放,将有内存泄露的风险。

2)创建 Observable —— 决定什么时候触发事件以及触发怎样的事件

当 Observable 被订阅的时候，OnSubscribe 的 call() 方法会自动被调用，事件序列就会依照设定依次触发

创建事件序列的方法

方法名	用途
create()	RxJava 最基本的创造事件序列的方法
just(T…)	将传入的参数依次发送出来
from(T[]) / from(Iterable)	将传入的数组或 Iterable 拆分成具体对象后，依次发送出来

例子代码（以下方法等价）:

//方法一:
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
    @Override
    public void call(Subscriber<? super String> subscriber) {
        subscriber.onNext("Hello");
        subscriber.onNext("Hi");
        subscriber.onNext("Aloha");
        subscriber.onCompleted();
    }
});
//方法二:
Observable observable = Observable.just("Hello", "Hi", "Aloha");
//方法三:
String[] words = {"Hello", "Hi", "Aloha"};
Observable observable = Observable.from(words);

3) Subscribe (订阅)

//方法一
observable.subscribe(observer);
//方法二
observable.subscribe(subscriber);

代码上体现为什么是被观察者订阅观察者的原因

//内部实现的核心代码
public Subscription subscribe(Subscriber subscriber) {
    subscriber.onStart();
    onSubscribe.call(subscriber);//被观察者回调观察者中的方法
    return subscriber;
}

note:Observer 在 subscribe() 过程中最终会被转换成 Subscriber 对象.

调用顺序（被观察者回调观察者中的方法）:
（1）调用 Subscriber.onStart() 。准备操作。
（2）调用 Observable 中的 OnSubscribe.call(Subscriber) 。在 RxJava 中， Observable 并不是在创建的时候就立即开始发送事件，而是在它被订阅的时候，即当 subscribe() 方法执行的时候，事件发送的逻辑开始运行。
（3）将传入的 Subscriber 作为 Subscription 返回。这是为了方便 unsubscribe()。

不完整定义的回调

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

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

简单示例(创建出 Observable 和 Subscriber ，再用 subscribe() 将它们串联起来)

（1）打印字符串数组

//onNext()
String[] names = ...;
Observable.from(names)
    .subscribe(new Action1<String>() {
        @Override
        public void call(String name) {
            Log.d(tag, name);
        }
    });

（2）根据 id 取得图片并显示

int drawableRes = ...;
ImageView imageView = ...;
Observable.create(new 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 onNext(Drawable drawable) {
        imageView.setImageDrawable(drawable);
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable e) {
        Toast.makeText(activity, "Error!", Toast.LENGTH_SHORT).show();
    }
});

在 RxJava 的默认规则中，事件的发出和消费都是在同一个线程的。上面的方法，实现出来的只是一个同步的观察者模式。观察者模式本身的目的就是『后台处理，前台回调』的异步机制，实现异步，则需要用到 RxJava 的Scheduler 。