注：本系列文章主要用于博主个人学习记录，本文末尾附上了一些较好的文章提供学习。
转载请附 原文链接
RxJava学习系列(一)--使用
RxJava学习系列(二)--原理
RxJava利用响应式编程思想，专注于异步任务的处理，通过操作符进行流式操作，可以极大的去除多层嵌套，达到逻辑的简洁明了。
举个栗子🌰
RxJava的观察者模式与普通观察者模式有一个区别是分为“冷”启动和“热”启动，“热”启动即不管有没有观察者，观察者会按照自己的逻辑发送数据，而“冷”启动则是只有当观察者开启订阅时才开始发送数据。
1.基本概念及用法
-
三个重要的对象
- Observable-数据发送者
- Subscriber-订阅者
- OnSubscribe-事件
一次事件订阅的流程：Observable持有一个 OnSubscribe对象，事件在OnSubscribe对象中被执行，当有Subscriber订阅了这个 Observable时，OnSubscribe中的事件开始执行，并由Observable发射数据给Subscriber
-
Subscriber对象
Subscriber是一个抽象类，需要实现三个方法
-
onCompleted(): 事件队列完结。RxJava 不仅把每个事件单独处理，还会把它们看做一个队列。RxJava 规定，当不会再有新的onNext()发出时，需要触发onCompleted()方法作为标志。 -
onError(): 事件队列异常。在事件处理过程中出异常时，onError()会被触发，同时队列自动终止，不允许再有事件发出。 - 在一个正确运行的事件序列中,
onCompleted()和onError()有且只有一个，并且是事件序列中的最后一个。需要注意的是，onCompleted()和onError()二者也是互斥的，即在队列中调用了其中一个，就不应该再调用另一个。
引用自扔物线
在代码中调用了onComplete后再调用onNext，依然可以发送数据，onComplete会在发送完所有的数据后才被调用
当onError被调用了，即使在出现错误之前调用onNext依然不会成功，只会触发onError
Subscriber<String> subscriber = new Subscriber<String>() { @Override public void onCompleted() { //数据发送完毕 } @Override public void onError(Throwable e) { //数据发送出错 } @Override public void onNext(String data) { //数据发送成功 } };通过泛型指定Subscriber所能接收的数据，在onNext 中处理相应的逻辑，此处需要注意的是： onNext方法调用的次数取决于OnSubscribe中被调用的次数
-
Action1<T>
在某些情况下我们不需要在每一个回调中都处理逻辑，可能只需要订阅onNext，就可以实现Action1<T>
new Action1<Object>() { @Override public void call(Object obj) { //有参数的回调onError和onNext } }; new Action0(){ @override public void call(){ //onComplete } }; -
-
Observable对象
- Observable.create(OnSubscribe<T> onSubscribe);
create方法传入一个OnSubscribe对象，在call方法中发送数据，这是最基础的创建方法
Observable.create(new Observable.OnSubscribe<String>() { @Override public void call(Subscriber<? super String> subscriber) { subscriber.onNext("create success"); } });- Observable.just（ T1 t1, T2 t2, T3 t3,…)
just方法允许快速创建队列，每一个参数会调用onNext方法传递一次(最多10个），且按顺序发送,just在发送完数据后，会调用onComplete
Observable.just("one","two","three");- from
from可以将数组,Iterable,Future对象转换为 Observable对象，发送数据
- Javadoc: from(array)
- Javadoc: from(Iterable)
- Javadoc: from(Future)
- Javadoc: from(Future,Scheduler)
- Javadoc: from(Future,timeout, timeUnit)
String [] array = new String[]{"one-from","two-from","three-from"}; Observable.from(array);创建一个Observable的方法有很多，不一一列举
创建Observable
-
订阅事件
- Observable.subcribe()－－return Subscription;
通过subscribe来开启订阅，此时Observable开始发送数据，并且返回一个Subscription对象
- Subscription
Subscription是一个接口，有两个方法unsubscribe()和isUnsubscribe(),在订阅事件时返回这个对象，可以在需要的时候取消掉订阅，在android开发中能简单有效的避免内存溢出。
2.线程控制
上面所提到的订阅会默认在当前线程中执行，然并卵，既然是专注于异步操作，就一定有线程控制的方法
-
Schedulers—线程调度
Sckedulers的各种线程
subscribeOn—被观察事件执行线程（事实上，在该方法调用之前，以及调用后，observeOn之前的代码都会在subscribeOn所在的线程中执行）
observeOn— 观察线程（可以多次转换，observeOn指定在它之后的代码线程）
-
实践
该方法只应该被调用一次，如果调用多次，只有第一个会生效 !
多次调用subscribeOn
如上图，首先指定了subscribeOn的线程为io线程，然后又指定了计算线程，打印日志
通过日志打印可以发现，只有第一个subscribeOn生效，并且在observeOn之前的代码也都在io线程中执行，而在observeOn之后的代码，在每一次调用该方法后都改变了线程
有好事的同学说了，那如果我先调用observeOn再调用subscribeOn呢？虽然没有人这么做，但严谨的我还是要试试
先调用observeOn指定为主线程，然后subscribeOn指定为ui线程
可以看到第一条日志在io线程中执行，而第二条日志在主线程中，似乎可以得到一个结论
observeOn指定在它之后的代码的执行线程，而其余代码均在第一个subscribeOn指定的线程中执行
3.操作符
A.转换操作
-
map()— 将发射的数据转化为subscriber所需要的数据
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(random()); subscriber.onCompleted(); } }).map(new Func1<Integer, String>() { @Override public String call(Integer integer){ if(integer == 0){ return "the number is 1"; }else{ return "the number is not 1"; } } });栗子中的代码是在原始的Observable中发射类型为Integer的数据，通过map操作后，subscriber所接收到的数据为 String 类型，map中需要传入Fun1<T,E>,参数1表示上一个操作符操作后所发送的数据，一个Observable可以进行多次转化操作，subscriber接收到的数据为最后一次转化发射的数据。
注意：map操作转换的是发射的数据，Observable本身并不会被转换
-
flatmap()— 将一个Observable转换为一个新的Observable，并且由这个新的Observable发射数据
Observable.create(new Observable.OnSubscribe<Integer>() { @Override public void call(Subscriber<? super Integer> subscriber) { subscriber.onNext(random()); subscriber.onCompleted(); } }).flatMap(new Func1<Integer, Observable<String>>() { @Override public Observable<String> call(Integer integer) { return Observable.just("new Observable"+integer); } });flatMap 同样需要传入Func1<T,E> 与map不同的是，返回的是一个Observable对象，而subscriber所订阅的应该是这个新的Observable，flatmap也可以多次调用多次转换，问题来了～subscriber只关心接收到的数据，并不关心订阅的具体是哪一个Observable，那flatMap和map的应用场景是什么呢？
-
应用场景
- map比较简单，一个Observable可能被多个subscriber订阅，而不同的订阅所需要的最终数据不同，但事件的操作逻辑是相同的，就可以利用map来满足不同的数据需求
-
flatmap的用处就比较多了，文章最开头举的栗子，一次复杂的注册逻辑，首先要请求服务器获取token，获取token后注册请求，注册请求完成后，登录请求，每一次请求利用Retrofit封装返回一个 Observable对象.我们只关心最后登录成功后告知用户，并刷新UI。这样原本用回调至少嵌套两次的逻辑，变得清晰明了（这样的注册逻辑本身是有问题的～）
模拟一次注册请求
![Uploading 48862518-1B43-457E-B734-36AE6669893C_441752.jpg . . .]
注意：只有每一个Observable都成功发射数据后，才会调用onNext方法，如果出现异常会直接调用onError
这样看来，好像很鸡肋，后面会讲到错误操作，你会发现RxJava确实是很牛逼的啊～
-
其它转换操作
转换操作符
B.合并操作
-
merge— 将多个Observable合并为一个Observable发射数据
Observable.merge(observable1,observable2,observable3,observable4);官方文档说明：merge可能会导致交错发射数据，即不是按照合并顺序来发射数据
同样，一旦有一个Observable发射异常，会立即触发onError，RxJava的实现中有一个mergeDelayError— 只有当所有的数据都发射完毕后才会调用onError
-
concat— 将多个Observable合并为一个Observable并且按顺序发射数据
Observable.concat(observable1,observable2,observable3,observable4) -
zip— 将多个Observables的发射物结合到一起，基于这个函数的结果为每个结合体发射单个数据项。
Observable.zip( Observable.just("1"), Observable.just("2"), Observable.just("3"), Observable.just("4"), new Func4<String, String, String, String, String>() { @Override public String call(String s, String s2, String s3, String s4) { return s+s2+s3+s4; } });zip传入需要合并的Observable对象，以及 Func4<T,...,Object>,与merge不同的是，zip是将所有发射的数据拿到后，进行整合，最后发射这个整合后的数据。call中的参数是严格按照合并顺序所发射的数据，return的即为最终发射的数据
zip的不仅可以合并发射源，并且可以根据需要转换最终发射的数据类型
C.过滤操作
假设这样一种场景，加载数据的时候先向服务器请求，如果成功就显示，如果失败就查找缓存数据。很容易想到可以利用合并操作符来处理，但是合并操作会依次发射数据，这不是我们所希望的。这里就需要用的过滤操作了
-
filter — 只发射通过了谓词测试的数据项
filter根据规则去检验数据，只要通过了检验的数据都会被发射，直到检验完最后一个 Observable
.filter(new Func1<Integer, Boolean>() { @Override public Boolean call(Integer i) { //只发射小于等于5的数据 return i<=5; } }) -
first — 只发射第一项（或者满足某个条件的第一项）数据
first类似于filter，不同的是，只发射第一个通过检验的数据
first()//只发射第一个数据 first(Func1)//满足某个条件的第一个发射成功的数据 .first(new Func1<String, Boolean>() { @Override public Boolean call(String s) { return false; } })所有发射的数据，会在call中按照规则进行检验，比如当第一个传过来的字符串不为空时，就认为发射数据成功，那么应该return true，当return为true的时候会调用onNext方法，而还没有发射数据的Observable将不再发射数据，如果return为false，那么会依次检验后面的Observable是否发射数据成功，直到return true或者全部不符合调onError
-
last — 只发射最后一条（或者满足某个条件的最后一项）数据
last的用法跟frist一毛一样。
-
其它过滤操作
过滤操作符
D.异常处理
onErrorReturn可以在异常发生时发射一个默认的数据，结合过滤操作，可以发射一个不符合规则的数据，避免中断数据发射
E.doOn
有一种场景，比如说请求到数据后写入缓存，但是不希望订阅者去处理，因为如果多处订阅必然会产生重复代码并且可能阻塞主线程，doOn的系列操作就派上了用场
-
doOnNext — 当数据发射成功时调用
Observable.just("data to shoot") .doOnNext(new Action1<String>() { @Override public void call(String s) { //发射成功后需要的操作 writeToCache(s); } })在使用的时候注意判断doOnNext当前在哪个线程执行
- doOnError — 当发生异常时调用
- doOnSubscribe — 当被订阅时调用
- doOnTerminate — 发射数据完毕后调用
F.封装-compose
当我们真正开始使用RxJava来替换之前的逻辑代码时，我们发现仅用现有的操作符无法做到完全的简洁，依然会出现一些不必要的重复代码和逻辑。适度的封装也是必要的，RxJava早就想到了这点，提供了一个操作符来封装一些通用代码
-
compose(@NotNull Transformer<T,R>)
compose方法需要传入一个变形金刚对象,其中泛型T为原始的Observable所发射的数据类型，R为变形后所发射的数据类型，举个栗子，比如封装一个方法在io线程中发射数据，在ui线程中观察接收数据。
public <T> Observable.Transformer<T,T> io_main(){ return new Observable.Transformer<T, T>() { @Override public Observable<T> call(Observable<T> tObservable) { return tObservable.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()); } }; }创建一个Transformer对象，需要实现call方法，return一个新的Observable，然后传入到compose（）中：
Observable.just("123") .compose(this.<String>io_main()) .subscribe();查看一下compose的源码发现，它其实就做了一件事情，调用 Transformer的call方法，并把当前的Observable对象作为参数传进去，返回call方法得到的新的Observable
public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer) { return ((Transformer<T, R>) transformer).call(this); }
4.RxBus
EventBus让模块间的耦合更低，利用 RxJava实现EventBus简直是容易，且便于管理
在实现RxBus之前介绍两个很重要的类
-
CompositeSubscription— Subscription that represents a group of Subscriptions that are unsubscribed together.
是Subscription的一个实习类，用于管理一组订阅，当取消订阅时，会将这一组订阅全部取消，在Android中可以利用该类管理一个Activity中所有的异步任务，当Activity被销毁时，取消订阅，避免内存泄漏
- add — 将一个订阅加入到一个订阅组中
- remove — 将一个订阅从该组中移除
- clear — 清空订阅组
- unsubscribe — 取消改组中正在进行的所有订阅
-
Subject — 一个神奇的类，在 RxJava中它同时充当了Observer和Observable的角色。
文章一开头提到了“冷”启动和“热”启动，而一个Subject可以将一个“冷”Observer变成一个“热”的，因为它是一个Observer，它可以订阅一个或多个Observable；又因为它是一个Observable，它可以转发它收到(Observe)的数据，也可以发射新的数据。
subject.subscribe(subscriber) — 订阅事件
subject.onNext(obj) — 发射数据
Subject 在RxJava中总共有7个子类，这里不一一介绍（因为我也没用过…）
-
PublishSubject — 一个“热”的Observable,这个对象会在onNext被调用的时候就开始发射数据，无论有没有订阅者，当一个Observer订阅了这个对象时，只会收到订阅时间点之后所发射的数据。官方给出的栗子：
两个observer分别订阅了同一个subject，observer1会收到所有的数据，而observer2只能收到最后一条数据
PublishSubject<Object> subject = PublishSubject.create(); // observer1 will receive all onNext and onCompleted events subject.subscribe(observer1); subject.onNext("one"); subject.onNext("two"); // observer2 will only receive "three" and onCompleted subject.subscribe(observer2); subject.onNext("three"); subject.onCompleted();再想想EventBus的原理，我们所需要的正是这样一个“热”Observable。这里是较为复杂的一种实现，先上原理图
RxBus原理 -
再贴代码
private ConcurrentHashMap<Object, List<Subject>> subjectMapper
= new ConcurrentHashMap<Object, List<Subject>>();
//订阅事件
public <T> Observable<T> subscribe(@NonNull Object tag) {
List<Subject> subjectList = subjectMapper.get(tag);
if (null == subjectList) {
subjectList = new ArrayList<Subject>();
subjectMapper.put(tag, subjectList);
}
Subject<T, T> subject;
subjectList.add(subject = PublishSubject.create());
return subject;
}
//发布事件－－发射数据
public void post(@NonNull Object tag, @NonNull Object content) {
List<Subject> subjectList = subjectMapper.get(tag);
if (!isEmpty(subjectList)) {
for (Subject subject : subjectList) {
subject.onNext(content);
}
}
}
RxBus的核心逻辑就完成了，当然还需要加上取消订阅，清空事件等代码，比较简单不再赘述，在我实际的项目开发中，我将 RxBus交由 RxJavaManager进行管理，所有的订阅事件全部经过 RxJavaManager来操作，在需要取消订阅的地方统一unsubscribe
5.资料
- RxDocs — ReactiveX中文文档
- 给 Android 开发者的 RxJava 详解 — 扔物线大神的文章
- 什么是函数响应式编程 — android中响应式编程介绍
- T-MVP — 一个不错的开源项目 RxJava+MVP
- ReactiveX.io — 官方网站
- 从 RxBus 这辆兰博基尼深入进去 — 我的好基友谢三弟的Subject源码分析
