RxJava使用和原理(一)
基本介绍
项目源码路径
- Github: RxJava
介绍
- RxJava（Reactive Extensions for Java）是JVM的一个响应式扩展（ReactiveX）实现。
- 它通过使用可观察的序列来组合异步和基于事件的程序。
定义与原理
- RxJava是一个在Java VM上使用可观测的序列来组成异步的、基于事件的程序的库。它扩展了传统的观察者模式，增加了对事件序列的丰富操作和变换能力。
- 在RxJava中，被观察者（Observable）通过订阅（Subscribe）按顺序发送事件给观察者（Observer），观察者按顺序接收事件并作出对应的响应动作。
核心特性
- 观察者模式：RxJava的核心思想是观察者模式，它允许对象（被观察者）在状态改变时通知其他对象（观察者）。
- 丰富的操作符：RxJava提供了一系列的操作符，可以使用它们来过滤、选择、变换、结合和组合多个Observable。这些操作符让执行和复合变得非常高效。
- 线程切换：RxJava内部提供了多个调度器（Schedulers），如I/O操作调度器（Schedulers.io()）、新线- 程调度器（Schedulers.newThread()）、默认线程调度器（Schedulers.immediate()）和计算所使用的调度器（Schedulers.computation()）。开发者可以使用这些调度器来控制Observable在不同线程上的执行。
- 背压机制：背压是响应式流中的一个重要概念，它允许消费者控制从生产者那里接收数据的速率。RxJava支持背压机制，使得开发者可以更好地处理数据流中的压力。
基本使用
核心概念
- Observable（被观察者）：负责发送事件（数据流）。
- Observer（观察者）：接收事件并处理。
- Subscriber（订阅者）：Observer 的子类，增加了对订阅关系的控制。
- Scheduler（调度器）：用于控制线程切换。
基本使用示例
Observable.create(new ObservableOnSubscribe<String>() {
@Override
public void subscribe(ObservableEmitter<String> emitter) throws Exception {
emitter.onNext("Hello");
emitter.onNext("RxJava");
emitter.onComplete();
}
})
.subscribeOn(Schedulers.io()) // 指定被观察者的执行线程
.observeOn(AndroidSchedulers.mainThread()) // 指定观察者的执行线程
.subscribe(new Observer<String>() {
@Override
public void onSubscribe(Disposable d) {
// 订阅时调用
}
@Override
public void onNext(String s) {
// 接收到数据时调用
Log.d("RxJava", s);
}
@Override
public void onError(Throwable e) {
// 发生错误时调用
}
@Override
public void onComplete() {
// 数据流结束时调用
}
});
常用操作符
不同类型的被观察者
Observable
特性：
- 支持异步操作，可以在后台线程上执行任务，然后将结果发送到前台线程。
- 基于事件驱动，当有新的数据产生时，会自动通知所有订阅者。
- 支持多种操作符，可以方便地对数据进行转换、过滤等操作。
- 可以处理错误，当出现异常时，可以选择继续执行或者终止操作。
- 可以自动管理资源，例如在订阅时打开资源，在取消订阅时关闭资源。
使用场景：
- 处理最大不超过1000条数据，并且几乎不会出现内存溢出的情况。
- 处理同步流。
Flowable
特性：
- 是RxJava2.x新增的被观察者，用于替代Observable以支持非阻塞式的背压。
- 可以看作是Observable的新实现，但增加了对背压的支持。
- 支持并发模式，是JDK9标准接口Reactive Streams的实现。
使用场景：
- 处理以某种方式产生超过10KB的元素。
- 文件读取与分析。
- 读取数据库记录（阻塞的和基于拉取的模式）。
- 创建一个响应式非阻塞接口。
Single
特性：
- 只有onSuccess和onError事件。
- onSuccess()用于发射数据，而且只能发射一个数据，后面即使再发射数据也不会做任何处理。
- SingleObserver中只有onSuccess和onError，并没有onComplete。
使用场景：
- 当确定只会发射一个数据项或发生错误时，可以使用Single。
Completable
特性：
- 在创建后，不会发射任何数据。
- 只有onComplete和onError事件。
- 相比Observable/Flowable，操作符要少得多。
使用场景：
- 当不需要发射数据，只需要知道操作何时完成时，可以使用Completable。
Maybe
特性：
- 可以看作是Single和Completable的结合。
- 只能通过onSuccess()方法发射数据，且只能发射0或1个数据。
- 如果MaybeEmitter先调用了onComplete()，即使后面再调用onSuccess()，也不会发射任何数据。
使用场景：
- 当不确定是否会发射数据，但希望有一个明确的完成或错误信号时，可以使用Maybe。
操作符
创建操作符
创建操作符用于从头开始创建Observable（被观察者对象）或其他类型的被观察者，并允许观察者的方法被编程调用
create
- 作用：从头开始创建一个Observable，允许开发者通过编程方式调用观察者的方法（如onNext、onError、onCompleted）。
- 特点：开发者需要提供一个函数，该函数接受一个Subscriber（或ObservableEmitter）作为参数，并在其中定义事件发送的逻辑。
- 示例：
Observable.create(new ObservableOnSubscribe<Integer>() {
@Override
public void subscribe(ObservableEmitter<Integer> emitter) throws Exception {
emitter.onNext(1);
emitter.onNext(2);
emitter.onNext(3);
emitter.onComplete();
}
}).subscribe(new Observer<Integer>() {
@Override
public void onSubscribe(Disposable d) {
// 开始订阅时的操作
}
@Override
public void onNext(Integer value) {
// 接收到事件时的操作
}
@Override
public void onError(Throwable e) {
// 发生错误时的操作
}
@Override
public void onComplete() {
// 完成时的操作
}
});
just
- 作用：快速创建一个Observable，并直接发送传入的事件。
- 特点：最多只能发送10个参数，适用于快速创建Observable并发送少量事件。
- 示例：
Observable.just(1, 2, 3, 4).subscribe(new Observer<Integer>() {
// ...省略订阅逻辑...
});
defer
- 作用：直到有观察者订阅时，才动态创建Observable并发送事件。
- 特点：每次订阅都会得到一个新的Observable对象，确保Observable对象里的数据是最新的。
- 示例：
Observable<Integer> observable = Observable.defer(new Callable<Observable<Integer>>() {
@Override
public Observable<Integer> call() throws Exception {
// 根据条件动态创建Observable
if (someCondition) {
return Observable.just(1, 2, 3);
} else {
return Observable.just(4, 5, 6);
}
}
});
observable.subscribe(new Observer<Integer>() {
// ...省略订阅逻辑...
});
from
- 作用：将其他类型的对象或数据结构转换为Observable。
- 特点：支持将数组、集合、Future等转换为Observable，方便统一处理。
- 示例：
Integer[] items = {0, 1, 2, 3, 4, 5};
Observable.fromArray(items).subscribe(new Observer<Integer>() {
// ...省略订阅逻辑...
});
interval
- 作用：创建一个在指定时间间隔内发射整数的Observable。
- 特点：通常用于需要定时发送事件的场景。
- 示例：
Observable.interval(1, TimeUnit.SECONDS).take(5).subscribe(new Observer<Long>() {
// ...省略订阅逻辑...
});
上述代码会每秒发送一个递增的整数，共发送5个。
range
- 作用：创建一个以给定范围的整数序列发射的Observable。
- 特点：适用于需要生成一定范围内整数序列的场景。
- 示例：
Observable.range(1, 5).subscribe(new Observer<Integer>() {
// ...省略订阅逻辑...
});
上述代码会发送从1到5的整数序列。
repeat
- 作用：创建一个重复发射特定数据或数据序列的Observable。
- 特点：适用于需要重复发送相同数据或数据序列的场景。
- 示例：
Observable.just("Hello").repeat(3).subscribe(new Observer<String>() {
// ...省略订阅逻辑...
});
上述代码会重复发送字符串"Hello"三次。
timer
- 作用：创建一个延迟一段时间后发射单个项的Observable。
- 特点：通常用于需要延迟发送事件的场景。
- 示例：
Observable.timer(2, TimeUnit.SECONDS).subscribe(new Observer<Long>() {
// ...省略订阅逻辑...
});
转换操作符
转换操作符用于对Observable（被观察者对象）发射的数据进行转换，以便观察者能够接收到转换后的数据。
map()
- 作用：对Observable发射的每一项数据应用一个函数，然后返回一个新的Observable，该Observable发射转换后的数据。
- 特点：适用于一对一的数据转换场景。
- 示例：将整数列表中的每个整数转换为它的平方数。
Observable.range(1, 4)
.map(i -> i * i)
.subscribe(i -> System.out.println(i)); // 输出：1, 4, 9, 16
flatMap()
- 作用：将一个发射数据的Observable变换为多个Observables，然后将它们的数据合并后放入一个单独的Observable。
- 特点：适用于一对多或多对多的数据转换场景，可以处理嵌套的数据结构。
- 示例：将学生列表中的每个学生的课程列表展平为一个课程列表。
List<Student> students = // ... 学生列表
Observable.from(students)
.flatMap(student -> Observable.fromIterable(student.getCourses()))
.subscribe(course -> System.out.println(course.getName()));
concatMap()
- 作用：与flatMap()类似，但确保转发出来的事件是有序的。
- 特点：适用于需要保持数据顺序的一对多数据转换场景。
- 示例：与flatMap()类似，但确保转换后的数据按原始顺序发射。
flatMapIterable()
- 作用：类似于flatMap()，但转换后的是一个Iterable对象。
- 特点：适用于将发射的数据项转换为Iterable对象，并将这些Iterable对象的内容合并到一个Observable中发射。
switchMap()
- 作用：当一个Observable发射一个数据时，使用这个函数将数据映射成一个新的Observable，然后开始发射这个新Observable的数据。如果原始的Observable发射了一个新的数据项，switchMap会取消订阅当前正在发射数据的Observable，并开始发射一个新的Observable的数据。
- 特点：适用于需要切换Observable的场景，如网络请求的取消和重试。
scan()
- 作用：对Observable流序列的每一项数据应用一个累积函数，然后将这个函数的累积结果发射出去。
- 特点：类似于递归操作，可以用于计算累计和、平均值等。
- 示例：计算1到5的累加和。
Observable.range(1, 5)
.scan(0, (sum, i) -> sum + i)
.subscribe(sum -> System.out.println(sum)); // 输出：0, 1, 3, 6, 10, 15（注意第一个输出是初始值0）
注意：在上面的示例中，scan的累积函数接受两个参数：一个是累积的结果（sum），另一个是当前的元素（i）。初始值设置为0。
buffer()
- 作用：从需要发送的事件当中获取一定数量的事件，并将这些事件放到缓冲区当中一并发出。
- 特点：适用于需要将多个事件组合成一个事件发射的场景。
window()
- 作用：类似于buffer()，但window()操作符返回的是Observable
类型，即它会发射一个Observable，这个Observable又发射原始Observable中的元素。
groupBy()
- 作用：根据指定的函数对Observable发射的数据进行分组，并返回一个Observable
- 特点：适用于需要对数据进行分组处理的场景。
cast()
- 作用：将源事件类型转换成指定的数据类型。
- 特点：是map的特殊版本，只能用于将父类对象转换为子类对象。如果转换失败，会抛出ClassCastException异常。
组合操作符
组合操作符用于将多个 Observable（被观察者对象）组合成一个 Observable，以便能够同时处理多个数据源。
concat() 和 concatArray()
- 作用：组合多个 Observable 一起发送数据，合并后按发送顺序串行执行。
- 区别：concat() 用于组合数量小于或等于 4 个的 Observable，而 concatArray() 可以组合数量大于 4 个的 Observable。
- 示例：
Observable.concat(
Observable.just(1, 2, 3),
Observable.just(4, 5, 6)
)
.subscribe(integer -> System.out.println("接收到的数据: " + integer));
// 输出将按顺序：1, 2, 3, 4, 5, 6
merge() 和 mergeArray()
- 作用：组合多个 Observable 一起发送数据，合并后按时间线并行执行。
- 区别：与 concat() 和 concatArray() 类似，merge() 用于组合数量小于或等于 4 个的 Observable，而 mergeArray() 可以组合数量大于 4 个的 Observable。
- 特点：合并后的 Observable 可能会让原始 Observables 发射的数据交错。
- 示例：
Observable.merge(
Observable.intervalRange(0, 3, 1, 1, TimeUnit.SECONDS),
Observable.intervalRange(10, 3, 1, 1, TimeUnit.SECONDS)
)
.subscribe(aLong -> System.out.println("接收事件: " + aLong));
// 输出将交错：0, 10, 1, 11, 2, 12…
zip()
- 作用：将多个 Observable 发射的数据按顺序结合，每个数据只能组合一次，且都是有序的。它只发射与发射数据项最少的那个 Observable 一样多的数据。
- 特点：具体的结合方式由提供的函数决定。
- 示例：
Observable.zip(
Observable.just(1, 2, 3),
Observable.just('a', 'b', 'c'),
(integer, c) -> integer + "-" + c
)
.subscribe(s -> System.out.println("zip 结果: " + s));
// 输出：1-a, 2-b, 3-c
combineLatest()
- 作用：将两个或多个 Observable 产生的结果进行合并，合并的结果组成一个新的 Observable。这两个 Observable 中任意一个 Observable 产生的结果，都和另一个 Observable 最后产生的结果，按照一定的规则进行合并。
- 特点：只要有一个 Observable 发射数据，combineLatest 就会发射一个合并后的数据项，且每次发射都会基于每个 Observable 的最新数据。
- 示例：
Observable<Long> observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
.map(aLong -> aLong * 5)
.take(5);
Observable<Long> observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
.map(aLong -> aLong * 10)
.take(5);
Observable.combineLatest(
observable1,
observable2,
(aLong, aLong2) -> aLong + aLong2
)
.subscribe(aLong -> System.out.println("combineLatest 结果: " + aLong));
// 输出将基于两个 Observable 的最新数据进行合并
startWith() 和 startWithArray()
- 作用：在发送原始 Observable 的数据之前，先发送指定的数据或数据数组。
- 示例：
Observable.just(2, 3, 4)
.startWith(1)
.subscribe(integer -> System.out.println("接收到的数据: " + integer));
// 输出：1, 2, 3, 4
concatDelayError() 和 mergeDelayError()
- 作用：类似于 concat() 和 merge()，但它们在处理错误时有所不同。这些操作符会延迟错误的传递，直到所有原始 Observable 都完成或遇到错误。
- 特点：concatDelayError() 按顺序执行，而 mergeDelayError() 并行执行。
join() 和 groupJoin()
- 作用：基于时间窗口将两个 Observable 发射的数据结合在一起。每个 Observable 在自己的时间窗口内都是有效的，都可以拿来组合。
- 特点：join() 和 groupJoin() 的参数包括源 Observable、目标 Observable、以及控制每个 Observable 产生结果生命周期和合并规则的函数。
过滤操作符
过滤操作符用于根据特定条件筛选 Observable 发射的数据项。这些操作符允许你定义逻辑来保留或丢弃流中的元素。
filter(Predicate predicate)：
- 功能：只保留满足给定谓词（Predicate）条件的元素。
- 示例：从整数列表中过滤出所有的偶数。
Observable.fromIterable(Arrays.asList(1, 2, 3, 4, 5, 6))
.filter(x -> x % 2 == 0)
.subscribe(System.out::println); // 输出: 2, 4, 6
take(long count)：
- 功能：从流中取前 count 个元素。
- 示例：获取 Observable 发射的前 3 个元素。
Observable.range(1, 10)
.take(3)
.subscribe(System.out::println); // 输出: 1, 2, 3
takeLast(long count)：
- 功能：从流中取最后 count 个元素（需要 Observable 完成才能确定）。
- 示例：获取 Observable 发射的最后 3 个元素。
Observable.range(1, 10)
.takeLast(3)
.subscribe(System.out::println); // 输出: 8, 9, 10（在 Observable 完成时）
takeWhile(Predicate predicate)：
- 功能：只要元素满足给定条件就继续发射，一旦遇到不满足条件的元素就停止发射。
- 示例：发射整数直到遇到第一个偶数。
Observable.range(1, 10)
.takeWhile(x -> x % 2 != 0)
.subscribe(System.out::println); // 输出: 1（因为 1 是奇数，但 2 不是）
skip(long count)：
- 功能：跳过前 count 个元素，然后发射剩余的元素。
- 示例：跳过 Observable 发射的前 3 个元素。
Observable.range(1, 10)
.skip(3)
.subscribe(System.out::println); // 输出: 4, 5, 6, 7, 8, 9, 10
skipWhile(Predicate predicate)：
- 功能：只要元素满足给定条件就继续跳过，一旦遇到不满足条件的元素就开始发射。
- 示例：跳过所有奇数，然后开始发射偶数。
Observable.range(1, 10)
.skipWhile(x -> x % 2 != 0)
.subscribe(System.out::println); // 输出: 2, 4, 6, 8, 10（因为从 2 开始都是偶数）
throttleFirst(long windowDuration, TimeUnit unit) 和 throttleLast(long windowDuration, TimeUnit unit) 等节流操作符：
- 功能：用于控制发射频率，throttleFirst 保留每个窗口周期内的第一个元素，throttleLast 保留每个窗口周期内的最后一个元素。
- 示例：每秒钟只保留第一个或最后一个发射的元素。
条件操作符
条件操作符允许通过设置函数来判断被观察者（Observable）发送的事件是否符合特定条件，从而决定如何处理这些事件。
all(Predicate predicate)：
- 功能：判断 Observable 发射的所有数据项是否都满足给定的条件。如果所有数据项都满足条件，则返回 true；否则返回 false。
- 示例：检查一个整数列表中的所有数字是否都小于 10。
Observable.just(1, 2, 3, 4, 5, 6)
.all(integer -> integer < 10)
.subscribe(result -> System.out.println("All numbers are less than 10: " + result)); // 输出: All numbers are less than 10: true
contains(Object o)：
- 功能：判断 Observable 发射的数据流中是否包含指定的元素。
- 示例：检查一个整数列表中是否包含数字 3。
Observable.just(1, 2, 3, 4, 5)
.contains(3)
.subscribe(result -> System.out.println("Contains 3: " + result)); // 输出: Contains 3: true
exists(Predicate predicate)（或某些版本中的 any(Predicate predicate)）：
- 功能：判断 Observable 发射的数据流中是否存在至少一个满足给定条件的元素。如果存在，则返回 true；否则返回 false。
- 示例：检查一个整数列表中是否存在偶数。
Observable.just(1, 3, 5, 7, 8)
.any(integer -> integer % 2 == 0)
.subscribe(result -> System.out.println("Exists even number: " + result)); // 输出: Exists even number: true
isEmpty()：
- 功能：判断 Observable 是否没有发射任何元素。如果 Observable 没有发射元素就完成了，则返回 true；否则返回 false。
- 示例：检查一个 Observable 是否为空。
Observable.empty()
.isEmpty()
.subscribe(result -> System.out.println("Is empty: " + result)); // 输出: Is empty: true
takeWhile(Predicate predicate)：
- 功能：只要发射的元素满足给定条件就继续发射，一旦遇到不满足条件的元素就停止发射。
- 示例：发射整数直到遇到第一个大于或等于 5 的数字。
Observable.range(1, 10)
.takeWhile(integer -> integer < 5)
.subscribe(System.out::println); // 输出: 1, 2, 3, 4
takeUntil(Predicate predicate) 或 takeUntil(Observable other)：
- 功能：第一个版本是当发射的元素满足给定条件时停止发射；第二个版本是当另一个 Observable 开始发射元素时停止当前 Observable 的发射。
- 示例：发射整数直到遇到数字 5（使用 Predicate 版本）。
Observable.range(1, 10)
.takeUntil(integer -> integer == 5)
.subscribe(System.out::println); // 输出: 1, 2, 3, 4, 5（注意：5 也会被发射，因为条件是“直到”满足时停止）
或者，使用另一个 Observable 来停止发射：
Observable.interval(1, TimeUnit.SECONDS)
.takeUntil(Observable.timer(5, TimeUnit.SECONDS))
.subscribe(System.out::println); // 输出: 每秒发射一个数字，直到 5 秒后停止
skipWhile(Predicate predicate)：
- 功能：只要发射的元素满足给定条件就继续跳过，一旦遇到不满足条件的元素就开始发射。
- 示例：跳过所有小于 5 的整数，然后开始发射。
Observable.range(1, 10)
.skipWhile(integer -> integer < 5)
.subscribe(System.out::println); // 输出: 5, 6, 7, 8, 9
skipUntil(Observable other)：
- 功能：在另一个 Observable 开始发射元素之前，跳过当前 Observable 发射的所有元素。
- 示例：跳过所有元素，直到另一个 Observable 开始发射。
Observable.interval(1, TimeUnit.SECONDS)
.skipUntil(Observable.timer(3, TimeUnit.SECONDS))
.subscribe(System.out::println); // 前 3 秒发射的元素被跳过，从第 4 秒开始发射
sequenceEqual(Observable other)：
- 功能：比较两个 Observable 发射的元素序列是否相同（包括元素、发射顺序和最终状态）。
- 示例：比较两个整数序列是否相等。
Observable.just(1, 2, 3)
.sequenceEqual(Observable.just(1, 2, 3))
.subscribe(result -> System.out.println("Sequences are equal: " + result)); // 输出: Sequences are equal: true