Rxjava(一)
使用了那么久的rxjava了。现在有时间记录下了。
1.特点
1.RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库
2.Rxjava由于其基于事件流的链式调用、逻辑简洁
Rxjava的扩展观察者模式有四种角色
1.被观察者（Observable） 产生某个事件
2.观察者（Observer） 接收事件，并给出响应动作
3.订阅（Subscribe） 连接 被观察者和观察者
4.事件（Event）被观察者 和 观察者 的载体
RxJava原理可总结为：被观察者 （Observable） 通过 订阅（Subscribe） 按顺序发送事件 给观察者 （Observer）， 观察者（Observer） 按顺序接收事件 & 作出对应的响应动作
2.使用步骤
1.创建被观察者 作用是为了生产事件
2.创建观察者 并定义接受到事件后所做的操作
3.通过订阅，连接被观察者和观察者
3.步骤详解
1.创建被观察者
1. 创建被观察者 Observable
Observable observable = Observable.create(new ObservableOnSubscribe() {
// 2. 在复写的subscribe（）里定义需要发送的事件
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
// 1. 定义：事件发射器
// 2. 作用：定义需要发送的事件 & 向观察者发送事件
emitter.onNext("hello");
emitter.onNext("word);
emitter.onNext("rxjava");
emitter.onComplete();
}
});
2 创建观察者 （Observer ）并 定义事件的响应
Next事件 Complete事件 和 Error事件等
Next事件是普通事件 向观察者发送需要相应事件的信号
Complete事件 事件队列完结 onComplete()标识着被观察者不再发送普通事件onNext() 当一个被观察者发送onComplete事件后 观察者将停止接受事件，但是被观察着还可以发送
Error事件。事件队列异常，当出现异常的时候，观察者不再接受事件
<--方式1：采用Observer 接口 -->
// 1. 创建观察者 （Observer ）对象
Observer observer = new Observer() {
// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件
// 观察者接收事件前，默认最先调用复写 onSubscribe（）
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onNext(Integer value) {
Log.d(TAG, "对Next事件作出响应" + value);
}
// 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
// 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
};
<--方式2：采用Subscriber 抽象类 -->
// 说明：Subscriber类 = RxJava 内置的一个实现了 Observer 的抽象类，对 Observer 接口进行了扩展
// 1. 创建观察者 （Observer ）对象
Subscriber subscriber = new Subscriber() {
// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件
// 观察者接收事件前，默认最先调用复写 onSubscribe（）
@Override
public void onSubscribe(Subscription s) {
Log.d(TAG, "开始采用subscribe连接");
}
// 当被观察者生产Next事件 & 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onNext(Integer value) {
Log.d(TAG, "对Next事件作出响应" + value);
}
// 当被观察者生产Error事件& 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
// 当被观察者生产Complete事件& 观察者接收到时，会调用该复写方法 进行响应
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
};
<--特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别 -->
// 相同点：二者基本使用方式完全一致（实质上，在RxJava的 subscribe 过程中，Observer总是会先被转换成Subscriber再使用）
// 不同点：Subscriber抽象类对 Observer 接口进行了扩展，新增了两个方法：
// 1. onStart()：在还未响应事件前调用，用于做一些初始化工作
// 2. unsubscribe()：用于取消订阅。在该方法被调用后，观察者将不再接收 & 响应事件
// 调用该方法前，先使用 isUnsubscribed() 判断状态，确定被观察者Observable是否还持有观察者Subscriber的引用，如果引用不能及时释放，就会出现内存泄露
3 通过订阅（Subscribe）连接观察者和被观察者
1.observable.subscribe(observer); 被观察者订阅观察者。怎么样，和常理不太一样吧
public Subscription subscribe(Subscriber subscriber) {
subscriber.onStart();
// 步骤1中 观察者 subscriber抽象类复写的方法，用于初始化工作
onSubscribe.call(subscriber);
// 通过该调用，从而回调观察者中的对应方法从而响应被观察者生产的事件
// 从而实现被观察者调用了观察者的回调方法 & 由被观察者向观察者的事件传递，即观察者模式
// 同时也看出：Observable只是生产事件，真正的发送事件是在它被订阅的时候，即当 subscribe() 方法执行时
}
重点说下
被观察者 Observable的subscribe()具备多个重载的方法
public final Disposable subscribe() {}
// 表示观察者不对被观察者发送的事件作出任何响应（但被观察者还是可以继续发送事件）
public final Disposable subscribe(Consumer onNext) {}
// 表示观察者只对被观察者发送的Next事件作出响应
public final Disposable subscribe(Consumer onNext, Consumer onError) {}
// 表示观察者只对被观察者发送的Next事件 & Error事件作出响应
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应
public final Disposable subscribe(Consumer onNext, Consumer onError, Action onComplete, Consumer onSubscribe) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应
public final void subscribe(Observer observer) {}
// 表示观察者对被观察者发送的任何事件都作出响应
Disposable.dispose() 切断观察者 与 被观察者 之间的连接
Observer observer = new Observer() {
// 1. 定义Disposable类变量
private Disposable mDisposable;
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
// 2. 对Disposable类变量赋值
mDisposable = d;
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "对Next事件"+ value +"作出响应" );
if (value == 2) {
// 设置在接收到第二个事件后切断观察者和被观察者的连接
mDisposable.dispose();
Log.d(TAG, "已经切断了连接：" + mDisposable.isDisposed());
}
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
};
4 操作符详解
1.create()操作符 作用:完整创建1个被观察者对象（Observable）
2.just()操作符号 作用:快速创建1个被观察者对象（Observable）
特点：直接发送 传入的事件 。并且最多只能发送10个参数
3 fromArray() 直接发送 传入的数组数据 快速创建 被观察者对象（Observable） & 发送10个以上事件（数组形式）
4.fromIterable() ：直接发送 传入的集合List数据,快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）
5.defef() 直到有观察者（Observer ）订阅时，才动态创建被观察者对象（Observable） & 发送事件
6.timer() 通过 Observable工厂方法创建被观察者对象（Observable）
7.interval() 快速创建1个被观察者对象（Observable）发送事件的特点：每隔指定时间 就发送 事件
8.intervalRange() 每隔指定时间 就发送 事件，可指定发送的数据的数量
5 变换操作符 niub
作用：对事件序列中的事件 / 整个事件序列 进行加工处理（即变换），使得其转变成不同的事件 / 整个事件序列
RxJava中常见的变换操作
1.map() 被观察者发送的每1个事件都通过 指定的函数 处理，从而变换成另外一种事件即， 将被观察者发送的事件转换为任意的类型事件
Observable.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
emitter.onNext("a);
emitter.onNext("b);
emitter.onNext("c);
}
// 2. 使用Map变换操作符中的Function函数对被观察者发送的事件进行统一变换：
}).map(new Function() {
@Override
public String apply(String string) throws Exception {
return "aaa";
}
}).subscribe(new Consumer() {
// 3. 观察者接收事件时，是接收到变换后的事件 = 字符串类型
@Override
public void accept(String s) throws Exception {
Log.d(TAG, s);
}
});
2.FlatMap() 将被观察者发送的事件序列进行 拆分 & 单独转换，再合并成一个新的事件序列，最后再进行发送
ConcatMap和FlatMap()差不多
操作原理：
1.为事件序列中每个事件都创建一个 Observable 对象；
2.将对每个 原始事件 转换后的 新事件 都放入到对应 Observable对象；
3.将新建的每个Observable 都合并到一个 新建的、总的Observable 对象；
4.新建的、总的Observable 对象 将 新合并的事件序列 发送给观察者（Observer）
3.Buffer()
定期从 被观察者（Obervable）需要发送的事件中 获取一定数量的事件 & 放到缓存区中，最终发送
5.组合 / 合并操作符
作用：组合 多个被观察者（Observable） & 合并需要发送的事件
1 concat（） / concatArray（）
多个被观察者一起发送数据，合并后 按发送顺序串行执行，组合被观察者的数量，即concat（）组合被观察者数量≤4个，而concatArray（）则可＞4个
Observable.concat(Observable.just(1, 2, 3),
Observable.just(4, 5, 6),
Observable.just(7, 8, 9),
Observable.just(10, 11, 12))
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
// concatArray（）：组合多个被观察者一起发送数据（可＞4个）
// 注：串行执行
Observable.concatArray(Observable.just(1, 2, 3),
Observable.just(4, 5, 6),
Observable.just(7, 8, 9),
Observable.just(10, 11, 12),
Observable.just(13, 14, 15))
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Integer value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
2.merge() / mergeArray()
组合多个被观察者一起发送数据，合并后 按时间线并行执行
组合被观察者的数量，即merge（）组合被观察者数量≤4个，而mergeArray（）则可＞4个
Observable.merge(
Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS), // 从0开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
Observable.intervalRange(2, 3, 1, 1, TimeUnit.SECONDS)) // 从2开始发送、共发送3个数据、第1次事件延迟发送时间 = 1s、间隔时间 = 1s
.subscribe(new Observer() {
@Override
public void onSubscribe(Disposable d) {
}
@Override
public void onNext(Long value) {
Log.d(TAG, "接收到了事件"+ value );
}
@Override
public void onError(Throwable e) {
Log.d(TAG, "对Error事件作出响应");
}
@Override
public void onComplete() {
Log.d(TAG, "对Complete事件作出响应");
}
});
concatDelayError（） / mergeDelayError（）
前面操作符当被观察者出现异常的时候 就会中断后续事件， 这俩操作符会把事件推迟到发送结束
Zip（）
作用：合并 多个被观察者（Observable）发送的事件，生成一个新的事件序列（即组合过后的事件序列），并最终发送