使用了那么久的rxjava了。现在有时间记录下了。
1.RxJava 是一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库
2.Rxjava由于其基于事件流的链式调用、逻辑简洁
Rxjava的扩展观察者模式有四种角色
1.被观察者(Observable) 产生某个事件
2.观察者(Observer) 接收事件,并给出响应动作
3.订阅(Subscribe) 连接 被观察者和观察者
4.事件(Event)被观察者 和 观察者 的载体
RxJava原理可总结为:被观察者 (Observable) 通过 订阅(Subscribe) 按顺序发送事件 给观察者 (Observer), 观察者(Observer) 按顺序接收事件 & 作出对应的响应动作
1.创建被观察者 作用是为了生产事件
2.创建观察者 并定义接受到事件后所做的操作
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 super T> onNext) {}
// 表示观察者只对被观察者发送的Next事件作出响应
public final Disposable subscribe(Consumer super T> onNext, Consumer super Throwable> onError) {}
// 表示观察者只对被观察者发送的Next事件 & Error事件作出响应
public final Disposable subscribe(Consumer super T> onNext, Consumer super Throwable> onError, Action onComplete) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 & Complete事件作出响应
public final Disposable subscribe(Consumer super T> onNext, Consumer super Throwable> onError, Action onComplete, Consumer super Disposable> onSubscribe) {}
// 表示观察者只对被观察者发送的Next事件、Error事件 、Complete事件 & onSubscribe事件作出响应
public final void subscribe(Observer super T> 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事件作出响应");
}
};
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() 每隔指定时间 就发送 事件,可指定发送的数据的数量
作用:对事件序列中的事件 / 整个事件序列 进行加工处理(即变换),使得其转变成不同的事件 / 整个事件序列
RxJava中常见的变换操作
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);
}
});
ConcatMap和FlatMap()差不多
操作原理:
1.为事件序列中每个事件都创建一个 Observable 对象;
2.将对每个 原始事件 转换后的 新事件 都放入到对应 Observable对象;
3.将新建的每个Observable 都合并到一个 新建的、总的Observable 对象;
4.新建的、总的Observable 对象 将 新合并的事件序列 发送给观察者(Observer)
定期从 被观察者(Obervable)需要发送的事件中 获取一定数量的事件 & 放到缓存区中,最终发送
作用:组合 多个被观察者(Observable) & 合并需要发送的事件
多个被观察者一起发送数据,合并后 按发送顺序串行执行,组合被观察者的数量,即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事件作出响应");
}
});
组合多个被观察者一起发送数据,合并后 按时间线并行执行
组合被观察者的数量,即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事件作出响应");
}
});
前面操作符当被观察者出现异常的时候 就会中断后续事件, 这俩操作符会把事件推迟到发送结束
作用:合并 多个被观察者(Observable)发送的事件,生成一个新的事件序列(即组合过后的事件序列),并最终发送