Android使用RxJava浅析
首先说一下自己为什么使用到了RxJava，因为在处理网络异步数据的时候，我一般是使用Thread+Handler或者AsyncTask来实现，直到接触了RxJava后，竟然可以如此便利的进行网络请求以及数据处理..然后就一发不可收拾，写篇博文记录一下
一，简介
RxJava是一种响应式编程（个人理解），他有两个重要元素Observable（被观察者，事件源）和Subscriber（观察者）。Observable发出一个事件，Subscriber处理这个事件。
例：用RxJava打印出”hello rxjava!”
1.我们可以通过Observable的create方法来创建一个Observable对象。
Observable mObservable = Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscribersuper String> subscriber) {
subscriber.onNext("hello rxjava!");
}
}); 注意create的参数，是一个OnSubscribe的实现类对象，OnSubscribe是Observable类中的内部接口。call方法中发出了一个“hello rxjava!”字符串。
2.创建一个Subscriber的实现类对象
Subscriber mSubscriber = new Subscriber() {
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
}
@Override
public void onNext(String s) {
System.out.println(s);
}
}; 实现onCompleted、onError、onNext三个方法，分别代表流程结束，出错，和数据处理。
3.通过subscribe方法完成事件源与观察者之间的订阅
mObservable.subscribe(mSubscriber);完成订阅后，即会调用mSubscriber的onNext方法，打印出hello rxjava!
代码可进一步简化为：
Observable
.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext("hello rxjava!");
}
})
.subscribe(new Action1() {
@Override
public void call(String string) {
System.out.println(string);
}
}); subscribe参数除了Subscriber之外，还可以如下：
mObserable.subscribe(Action1, Action1, Action1);参数中的三个Action1分别代表subscriber的onComplete，onError，onNext，此处我们只用到了onNext，因此代码可以简化为：
Observable
.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber subscriber) {
subscriber.onNext("hello rxjava!");
}
})
.subscribe(new Action1() {
@Override
public void call(String string) {
System.out.println(string);
}
}); 二.操作符
丰富的操作符是RxJava很正的强大之处，其可以对整个流程进行很好的控制。下面列出一些常用的操作符
1. just
其实上面的代码还可以继续简化：我们不仅可以通过create来创建一个Observable对象，还能通过just来创建。
如：
Observable
.just("hello rxjava!")
.subscribe(new Action1() {
@Override
public void call(String string) {
System.out.println(string);
}
}); just方法通过传入的value来返回一个相应的Observable对象
2.from
from接收一个集合参数，并将集合中的元素依次发出
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
list.add("g");
Observable
.from(list)
.subscribe(new Action1<String>() {
@Override
public void call(String string) {
System.out.println(string);
}
});程序会将list中的元素一个一个的发送给subscriber，subscriber负责将他们打印出来。
from与just的区别：同样传入一个集合list，对于just，subscriber收到的也会是一个list；而对于from，subscriber收到的是list中的item
3. map
上面的例子，提供的原始数据是hello rxjava!，那么如何在subscriber中打印出hello rxjava!_eric。最先想到的方法：
Observable
.just("hello rxjava!")
.subscribe(new Action1() {
@Override
public void call(String string) {
System.out.println(string + "_eric");
}
}); 当然这样是可行的，但是subscriber作为观察者，他的作用是对接收到的数据做最直接的处理，不希望对数据进行转换。此时map出现了，map的作用是对observable发出的数据进行转换，将转换后的数据重新发出，转换后的数据可以与原始数据一致，当然也可以不一致！
Observable
.just("hello rxjava!")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s + "_eric";
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String string) {
System.out.println(string);
}
});这里map中对原始数据进行了处理。我们也可以增加多个map对数据进行一连串的变换。
Observable
.just("hello rxjava!")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return s + "_eric";
}
})
.map(new Func1<String, Integer>() {
@Override
public Integer call(String s) {
return s.hashCode();
}
})
.subscribe(new Action1<Integer>() {
@Override
public void call(Integer hashCode) {
System.out.println(hashCode);
}
});此代码将hello rxjava! >hello rxjava!_eric>hashCode值，Subscriber中接收到hashCode并打印出来。
4. flatMap
接收一个observable的数据输出作为输入，转换为一个observable向下传递。
与map的区别：
1.map将接收到的数据处理后，转换为另一个数据传递下去
flatMap将接收到的消息转换为一个observable传递下去
2.如果map将消息处理为observable类型，那么subscriber中的call方法的输入也将是observable类型
而flatMap传递下去后，subscriber中输入的是observable所包含的类型T，而不是observable类型
也就是说，flatMap是将事件转化后返回一个Observable对象，但是这个对象并不是直接发送到Subscriber的回调方法中。他的原理是这样的：1.将数据转化为Observable对象。2.并不发送这个Obserable，而是将他激活，于是他开始发送事件。3.所有转为为的Observable发送的事件，全部交给同一个Observable，这个Observable负责将这些事件统一交给subscriber的回调方法。
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add(null);
list.add("c");
list.add("d");
list.add("e");
list.add("f");
list.add("g");
Observable
.just(list)
.flatMap(new Func1<ArrayList<String>, Observable<String>>() {
@Override
public Observable<String> call(ArrayList<String> strings) {
return Observable.from(strings);
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
System.out.println(s);
}
});5.filter
过滤掉不符合条件的消息
6.take
指定消息数量
7.doOnNext
允许在处理观察者接收到消息前做一些事情， 比如将数据保存数据库等
Observable
.just(list)
.flatMap(new Func1<ArrayList<String>, Observable<String>>() {
@Override
public Observable<String> call(ArrayList<String> list) {
return Observable.from(list);
}
})
.filter(new Func1<String, Boolean>() {
@Override
public Boolean call(String s) {
return s != null;
}
})
.take(3) // 最多返回3个结果,应注意此处与filter的先后关系：如果filter放在take前面，则是成功filter过后的3个；
// 如果filter放在take后面，则是先取出3个再判断满不满足条件，如果不满足条件也不再增加
.doOnNext(new Action1<String>() {
@Override
public void call(String s) {
System.out.println("you can do something else about " + s);
}
})
.subscribe(new Action1<String>() {
@Override
public void call(String o) {
System.out.println(o);
}
});要注意filter和take的位置不同造成的不同结果。如上面代码：
如果filter放在take前面，则是成功filter过后的3个；
如果filter放在take后面，则是先取出3个再判断满不满足条件，如果不满足条件也不再增加
6. throttleFirst
允许在一个事件触发后的一段时间内丢弃新的事件。常用作去抖动过滤。例如
throttleFirst(500, TimeUnit.MILLISECONDS)表示丢弃掉事件处理后500ms内的事件
三、onComplete onError
一般情况下我们在回调中处理异常，这不仅要求每个回调都必须知道异常如何处理，导致重复代码，而且增加了代码之间的耦合性。
RxJava在整个消息传递的过程中，任意一个环节出现错误，就会跳过当前和后续的操作符，直接调用观察者的onError方法，操作符中不需要对错误进行处理；流程处理结束后会调用onComplete方法。因此，onComplete和onError是一定会被调用其一的。这大大简化了异常处理的方式。
四、调度器
现在的Android程序基本都离不开网络访问，另外开线程又是一件比较麻烦的事。
RxJava可以通过调度器来指定当前observable运行在哪个线程。
Observable
.just("www.baidu.com")
.map(new Func1<String, String>() {
@Override
public String call(String s) {
return getHttpResponse(s);
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<String>() {
@Override
public void call(String s) {
textview.setText(s);
}
});使用observeOn()和subscribeOn()来指定线程。
subscribeOn：事件产生的线程
observeOn：事件消费的线程
上面代码可以看到，网络请求时是放在Schedulers.io()线程中，更新UI是放在main线程。RxJava定义了几种线程分类：
- Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
- Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
- Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
- Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
- 另外， Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。
这种在 subscribe() 之前写上两句 subscribeOn(Scheduler.io()) 和 observeOn(AndroidSchedulers.mainThread()) 的使用方式非常常见，它适用于多数的 『后台线程取数据，主线程显示』的程序策略。
浅析：（摘自http://gank.io/post/560e15be2dca930e00da1083）
subscribeOn和observeOn都进行了线程切换，不同的是，subscribeOn切换是在onSubscribe中，即在通知上一级OnSuscribe时，这时事件还没有发出，因此subscribeOn可以从事件发出的开端就造成影响。observeOn发生在他内建的subscriber中，即发生在给下一级subscriber发送事件时，因此observeOn控制的是他后面的线程。
subscribeOn和observeOn的混合调度：（详细解读可查看http://gank.io/post/560e15be2dca930e00da1083）
- subscribeOn从事件创建时开始影响包括后面的线程。
- observeOn影响的是他后面的线程。
- 当流程中存在多个subscribeOn切换线程，只有第一个生效。