创建操作符概述
| 操作符 | 描 述 | 备注 |
|---|---|---|
| create() | 使用一个函数从头创建一个 Observable | |
| just() | 将一个或多个对象转换成发射这个或这些对象的一个 Observable | 最多只能发送10个参数 |
| fromArray() | 将一个 数组 转换成一个 Observable | 可发送10个以上事件（数组形式） |
| fromIterable() | 将一个 Iterable转换成一个 Observable | 可发送10个以上事件（集合形式） |
| never() | 创建一个不发射任何数据的 Observable | |
| empty() | 创建一个什么都不做直接通知完成的 Observable | |
| error() | 创建一个什么都不做直接通知错误的 Observable | |
| defer() | 只有当订阅者订阅才创建 Observable，为每个订阅者创建一个新的Observable | Observable对象里的数据是最新的 |
| timer() | 创建一个在给定的延迟之后发射单个数据的 Observable | 延迟后发送1个数值0 |
| interval() | 创建一个按照给定的时间间隔发射整数序列的 Observable | |
| range() | 创建一个发射指定范围的整数序列的 Observable |
基本创建
场景：完整的创建被观察者对象
create(): 完整创建
- 作用
- 完整创建一个被观察者对象（Observable）
- 使用
// 1. 通过 create() 创建被观察者 Observable 对象
Observable.create(new ObservableOnSubscribe<Integer>() {
// 传入参数: ObservableOnSubscribe 接口的实例
// 当 Observable 被订阅时, ObservableOnSubscribe 的 subscribe() 方法
// 会自动被调用, 即事件序列就会依照设定依次被触发
// 即观察者会依次调用对应事件的复写方法从而响应事件
// 从而实现由被观察者向观察者的事件传递 & 被观察者调用了观察者的回调方法, 即观察者模式
//2. 再复写的 subscribe() 里定义需要发送的事件
@Override
public void subscribe(@NonNull ObservableEmitter<Integer> emitter) {
// 通过 ObservableEmitter 类对象 产生 & 发送事件
// ObservableEmitter类介绍
// a. 定义: 事件发射器
// b. 作用：定义需要发送的事件 & 向观察者发送事件
// 注: 建议发送事件前检查emitter的isDisposed状态，以便在没有观察者或
// 观察者与被观察者断开连接时，让Observable停止发射数据
if (!emitter.isDisposed()) {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
}
emitter.onComplete();
} // 至此，一个完整的被观察者对象 Observable 就创建完毕了。
}).subscribe(new Observer<Integer>() {
// 3. 通过通过订阅 subscribe 连接观察者和被观察者
// 4. 创建观察者 & 定义响应事件的行为
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe（）
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到了事件1
接收到了事件2
接收到了事件3
对Complete事件作出响应
快速创建 & 发送事件
场景：快速的创建被观察者对象
just(): 10参数以下快速创建
- 作用
- 快速创建1个被观察者对象（Observable）
- 发送事件的特点：直接发送 传入的事件
注：最多只能发送10个参数, 因为构造函数的参数最多是十个
-
应用场景
- 快速创建 被观察者对象（Observable） & 发送10个以下事件
-
使用
// 1. 创建时传入整型1、2、3
// 在创建后就会发送这些对象，相当于执行了onNext(1)、onNext(2)、onNext(3)
Observable.just(1, 2, 3)
// 至此，一个Observable对象创建完毕
// just方法是对元素判空后, 如果长度大于1, 则调用fromArray方法
// 2. 通过通过订阅 subscribe 连接观察者和被观察者
// 3. 创建观察者 & 定义响应事件的行为
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe（）
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到了事件1
接收到了事件2
接收到了事件3
对Complete事件作出响应
fromArray(): 快速创建数组
- 作用
- 快速创建1个被观察者对象 (Observable)
- 发送事件的特点: 直接发送传入的数组数据
会将数组中的数据转换为 Observable 对象
-
应用场景
- 快速创建 被观察者对象（Observable） & 发送10个以上事件（数组形式）
- 数组元素遍历
-
使用
// 1. 设置需要传入的数组
Integer[] items = { 0, 1, 2, 3, 4 };
// 2. 创建被观察者对象（Observable）时传入数组
// 在创建后就会将该数组转换成Observable & 发送该对象中的所有数据
Observable.fromArray(items)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
// 注：
// 可发送10个以上参数
>>>>>>
开始采用subscribe连接
接收到了事0
接收到了事1
接收到了事2
接收到了事3
接收到了事4
对Complete事件作出响应
fromIterable(): 快速创建集合
- 作用
- 快速创建1个被观察者对象（Observable）
- 发送事件的特点：直接发送 传入的集合List数据
会将数组中的数据转换为Observable对象
-
应用场景
- 快速创建 被观察者对象（Observable） & 发送10个以上事件（集合形式）
- 集合元素遍历
-
使用
/*
* 快速发送集合
**/
// 1. 设置一个集合
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
// 2. 通过fromIterable()将集合中的对象 / 数据发送出去
Observable.fromIterable(list)
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到了事件1
接收到了事件2
接收到了事件3
对Complete事件作出响应
empty：直接通知完成
Observable observable = Observable.empty();
该方法创建的被观察者对象发送事件的特点：
仅发送Complete事件，直接通知完成，即观察者接收后会直接调用onCompleted（）
error：直接通知异常
Observable observable = Observable.error(new RuntimeException())
该方法创建的被观察者对象发送事件的特点：仅发送Error事件，直接通知异常
可自定义异常，即观察者接收后会直接调用onError（）
never：不发送任何事件
Observable observable = Observable.never();
该方法创建的被观察者对象发送事件的特点：
不发送任何事件，即观察者接收后什么都不调用
List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
Observable.fromIterable(list) 或
Observable.just(1, 2, 3)
.flatMap(new Function<Integer, ObservableSource<Integer>>() {
@Override
public ObservableSource<Integer> apply(Integer integer) throws Exception {
if (integer == 2) {
// return Observable.never();
return Observable.empty();
// return Observable.error(new Throwable("这条信息报错啦"));
}
return Observable.just(integer);
}
})
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.i(TAG, "开始采用subscribe连接");
}
@Override
public void onNext(Integer integer) {
Log.i(TAG, "接收到了事件" + integer);
}
@Override
public void onError(Throwable e) {
Log.i(TAG, "onError = " + e.getMessage());
}
@Override
public void onComplete() {
Log.i(TAG, "对Complete事件作出响应");
}
});
>>>>>>
Observable.fromIterable 或者Observable.just 都是把多个对象转换为一个新的 Observable
通过flatMap 转换后，会生成一个新的Observable序列
Observable.empty()
开始采用subscribe连接
接收到了事件1
接收到了事件3
对Complete事件作出响应
Observable.never()
开始采用subscribe连接
接收到了事件1
接收到了事件3
Observable.error(new Throwable("这条信息报错啦"))
开始采用subscribe连接
接收到了事件1
onError = 这条信息报错啦
延迟创建
场景：
- 定时操作：在经过了 x 秒后，需要自动执行 y 操作
- 周期性操作：每隔 x 秒后，需要自动执行 y 操作
defer(): 获取最新的Observable
- 作用
- 直到有观察者（Observer) 订阅时，才动态创建被观察者对象（Observable） & 发送事件
- 通过 Observable工厂方法创建被观察者对象（Observable）
- 每次订阅后，都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的
-
应用场景
- 动态创建被观察者对象（Observable） & 获取最新的Observable对象数据
-
使用
// 1. 通过 defer 定义被观察者对象
// 注: 此时被观察者对象还没创建, Observable.just()还未调用
Observable<Integer> observable = Observable.defer(new Callable<ObservableSource<? extends Integer>>() {
@Override
public ObservableSource<? extends Integer> call() {
return Observable.just(10, 20);
}
});
// 2. 此时，才会调用 defer() 创建被观察者对象 (Observable)
observable.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@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事件作出响应");
}
});
observable.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到的整数是10
接收到的整数是20
对Complete事件作出响应
开始采用subscribe连接
接收到的整数是10
接收到的整数是20
对Complete事件作出响应
timer(): 延迟发射数据
- 作用
- 快速创建1个被观察者对象（Observable）
- 发送事件的特点：延迟指定时间后，发送1个数值0（Long类型）
本质 = 延迟指定时间后，调用一次 onNext(0)
-
应用场景
- 延迟指定事件，发送一个0，一般用于检测
-
使用
// 该例子 = 延迟2s后，发送一个long类型数值
Observable.timer(2, TimeUnit.SECONDS)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
// 注：timer操作符默认运行在一个新线程上
// 也可自定义线程调度器 (第3个参数): timer(long,TimeUnit,Scheduler)
>>>>>>
开始采用subscribe连接
(2s后)接收到了事件0
对Complete事件作出响应
interval()：轮询发射数据
- 作用
- 快速创建1个被观察者对象 (Observable)
- 发送事件的特点：每隔指定时间 就发送 事件
发送的事件序列 = 从0开始、无限递增1的的整数序列
- 使用
// 参数说明：
// 参数1 = 第1次延迟时间；
// 参数2 = 间隔时间数字；
// 参数3 = 时间单位；
Observable.interval( 3, 1, TimeUnit.SECONDS)
// 该例子发送的事件序列特点：延迟3s后发送事件，每隔1秒产生1个数字（从0开始递增1，无限个）
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
// 注：interval默认在computation调度器上执行
// 也可自定义指定线程调度器（第3个参数）：interval(long,TimeUnit,Scheduler)
>>>>>>
开始采用subscribe连接
(3s后)接收到了事件0
(1s后)接收到了事件1
(1s后)接收到了事件2
(1s后)接收到了事件3
...
intervalRange(): 延迟轮询发射指定数量的数据
- 作用
- 快速创建1个被观察者对象 (Observable)
- 发送事件的特点：每隔指定时间 就发送 事件，可指定发送的数据的数量
a. 发送的事件序列 = 从0开始、无限递增1的的整数序列 b. 作用类似于interval(), 但可指定发送的数据的数量
- 使用
// 参数说明：
// 参数1 = 事件序列起始点；
// 参数2 = 事件数量；
// 参数3 = 第1次事件延迟发送时间；
// 参数4 = 间隔时间数字；
// 参数5 = 时间单位
Observable.intervalRange(11, 5, 2, 5, TimeUnit.SECONDS)
// 该例子发送的事件序列特点:
// 1. 从11开始，一共发送5个事件;
// 2. 第1次延迟 2s发送，之后每隔 5秒产生1个数字(递增加1)
.subscribe(new Observer<Long>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
(2s后)接收到了事件11
(5s后)接收到了事件12
(5s后)接收到了事件13
(5s后)接收到了事件14
(5s后)接收到了事件15
对Complete事件作出响应
range()：无延迟轮询发射指定数量的数据
- 作用
- 快速创建1个被观察者对象（Observable）
- 发送事件的特点：连续发送 1个事件序列，可指定范围
a. 发送的事件序列 = 从0开始、无限递增1的的整数序列 b. 作用类似于intervalRange() ，但区别在于：无延迟发送事件
- 使用
// 参数说明:
// 参数1 = 事件序列起始点;
// 参数2 = 事件数量;
// 注：若设置为负数，则会抛出异常
Observable.range(3, 4)
// 该例子发送的事件序列特点: 从3开始发送，每次发送事件递增1,一共发送4个事件
.subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
Log.d(TAG, "开始采用subscribe连接");
}
// 默认最先调用复写的 onSubscribe()
@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事件作出响应");
}
});
>>>>>>
开始采用subscribe连接
接收到了事件3
接收到了事件4
接收到了事件5
接收到了事件6
对Complete事件作出响应
