RxJava初体验
参考文章
http://www.cnblogs.com/halzhang/p/4458095.html
http://www.tuicool.com/articles/MjyaUfq
http://www.tuicool.com/articles/VrQRvur
http://blog.csdn.net/lzyzsd/article/details/41833541
RxJava的Guihub地址
https://github.com/ReactiveX/RxJava
添加依赖
首先，需要在Android Studio中添加依赖
dependencies {
compile 'io.reactivex:rxjava:1.0.15'
}
响应式编程
响应式编程的主要组成部分是observable, operator和susbscriber。一般响应式编程的信息流 : Observable -> Operator 1 -> Operator 2 -> Operator 3 -> Subscriber。
因为subscriber通常在主线程中执行，因此设计上要求其代码尽可能简单，只对事件进行响应，而修改事件的工作全部由operator执行。
Observable (被观察者，事件源)
消息的发送是有固定模式的。Observable可以发送任意数量的消息（包括空消息），当消息被成功处理或者出错时，流程结束。Observable会调用它的每个Subscriber的Subscriber.onNext()函数，并最终以Subscriber.onComplete()或者Subscriber.onError()结束。
Subscriber （观察者）
Subscriber有3个需要实现的方法
onNext:当顺利执行时执行
onCompleted:当执行完毕时
- 你能够知道什么时候订阅者已经接收了全部的数据。
onError:当出现错误时执行
- 只要有异常发生onError()一定会被调用
极大的简化了错误处理。只需要在一个地方处理错误即可以。 - 操作符不需要处理异常
将异常处理交给订阅者来做，Observerable的操作符调用链中一旦有一个抛出了异常，就会直接执行onError()方法。
Operators(操作符)
Operators可以在最终的Subscriber和Observable之间进行修改数据
以下列出基本的操作符
create
作用
创建一个基础的Observable对象，可执行onNext，onCompleted操作。
调用
此时，onNext，onCompleted必须主动调用，否则不会生效。而onStart等重写的方法，是会被主动调用的，无需自己调用。
代码
创建一个Observable（被观察者，事件源）
Observable observable = Observable.create(new Observable.OnSubscribe<String>() {
@Override
public void call(Subscriber<? super String> subscriber) {
subscriber.onNext("hello world!");
subscriber.onCompleted();
}
});
然后需要创建一个Subscribers（观察者）
Subscriber<String> subscriber = new Subscriber<String>() {
@Override
public void onStart() {
super.onStart();
Log.i(TAG, "start");
}
@Override
public void onCompleted() {
Log.i(TAG, "completed");
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "error:" + e.getMessage());
}
@Override
public void onNext(String s) {
Log.i(TAG, "s:" + s);
}
};
关联Observable和Subscriber
我们可以使用subscribe方法很方便的进行关联，进行关联后就会进行执行。
observable.subscribe(subscriber);
输出结果
start
s:hello world!
completed
just
作用
创建只发出一个事件就结束的Observable对象，可传递多个参数，将按照参数的顺序遍历执行。
调用
此时，Observable将自动调用onNext和OnonCompleted
代码
修改Observable 的代码，将其改为使用just
Observable observable = Observable.just("hello world!");
输出结果
start
s:hello world!
completed
什么？没发现什么变化？那再来增加一个参数
Observable observable = Observable.just("hello world!", "good job!");
输出结果
start
s:hello world!
s:good job!
Completed
just，可以接受多个参数，并逐个输出，并且可以极大化的简化代码。
from
作用
接收一个数组或集合或可变参数数组，然后逐个遍历输出。
调用
此时，Observable将自动调用onNext和OnonCompleted
代码
改变Observable 的代码，将其改为使用from
List list = new ArrayList();
list.add("hello world!");
list.add("good job!");
Observable observable = Observable.from(list);
输出结果
start
s:hello world!
s:good job!
Completed
在输入的参数是一个集合、数组或可变参数时，就可以使用from，非常方便!
subscribe方法
作用
关联Subscriber 和Observable，进行关联后就会被执行。
observable.subscribe(subscriber);
从上面的代码中我们可以知道，subscribe方法可以关联Subscriber 和Observable，但如果有时并不想把这subscriber的三个实现方法都实现时，我们就可以使用subscribe的另一个重载了。
observable.subscribe(onNextAction, onErrorAction, onCompleteAction);
比如，我们不关心OnComplete和OnError，只想使用onNext，那么就可以使用
observable.subscribe(new Action1<String>() {
@Override
public void call(String s) {
Log.i(TAG, "s:" + s);
}
});
输出结果
s:hello world!
s:good job!
map
作用
用于改变Observable对象，返回一个新的Observable对象
代码
在Observable和Subscriber之间增加以下代码
observable = observable.map(new Func1() {
@Override
public Object call(Object o) {
return o + " 增加的数据~";
}
});
输出结果
start
s:hello world! 增加的数据~
s:good job! 增加的数据~
completed
并且，map还可以改变返回的Observable的泛型类型，比如，我们现在想要返回参数的hashcode，就可以这样干
observable = observable.map(new Func1() {
@Override
public Object call(Object o) {
return o.hashCode();
}
});
但是我们最后的Subscriber是String类型的泛型，当然也可以将Subscriber的泛型修改为 Object类型，然后在call方法中toString，但Subscriber方法做得事情越少越好，所以，我们再添加一个map
observable = observable.map(new Func1() {
@Override
public Object call(Object o) {
return o.toString();
}
});
输出结果
start
s:-217287203
s:1318599047
completed
flatMap
作用
和Map的作用相同:用于改变Observable对象，返回一个新的Observable对象，区别在于map的返回值后会自动包装一层Observable，而flatmap返回值不会自动包装Observable
比如
//都是从Observable<String>转为Observable<String>，其中的区别
observable = Observable.just("hello world!").map(new Func1() {
@Override
public Object call(Object o) { //o 是 String类型
return o+"增加的数据"; //会自动包装Observable，此处直接返回String对象
}
});
observable = Observable.just("hello world!").flatMap(new Func1() {
@Override
public Object call(Object o) { // o 是 String类型
return Observable.just(o+""增加的数据""); //不会自动包装Observable，此处需自己返回一个Observable<String>对象
}
});
意义
如果输入是一个Observable<List>、Observable<数组>等，就显得非常有用了，直接可以输出为Observable<String>
代码
//修改Observable 的代码，将其改为使用flatMap，(通过Observable.just(list)可以得到一个Observable<List>对象)
observable = Observable.just(list).flatMap(new Func1<List, Observable<?>>() {
@Override
public Observable<?> call(List list) {
return Observable.from(list);
}
});
输出结果
start
s:hello world!
s:good job!
completed
filter
作用
过滤指定的数据
代码
增加list的数据
list.add(null);
list.add("4");
我们修改Observable的代码，将其改为使用filter
observable = observable.filter(new Func1() {
@Override
public Object call(Object o) {
return o != null;
}
});
输出结果
start
s:hello world!
s:good job!
s:4
completed
take
作用
输出最多指定数量的结果
代码
增加take的代码，指定其只输出一个
observable = observable.take(1);
输出结果
start
s:hello world!
completed
这篇文章这样的写法只是为了理解起来比较方便，但真正要用起来代码还是太臃肿了，有关RxJava中多线程的使用、链式调用、lambda表达式的使用将在下篇文章中使用。
相关代码在这里