Android 函数式编程(RxJava）

想开发app

已于 2023-09-20 16:42:44 修改

阅读量151

点赞数

文章标签： android echarts

于 2023-09-19 16:22:47 首次发布

本文链接：https://blog.csdn.net/weixin_45568421/article/details/133032395

版权

概述

RxJava（Reactive Extensions for Java）是一个用于处理异步和基于事件的编程的 Java 库。它提供了一种声明式的方法来处理异步数据流，将事件驱动的编程范式引入了 Java 编程中。RxJava的主要特点包括：

异步编程： RxJava旨在简化异步编程，使开发者能够更容易地处理异步操作，如网络请求、UI 事件、传感器数据等。
响应式编程： RxJava基于响应式编程模型，强调数据流和数据的变化。它引入了可观察对象（Observable）和观察者（Observer）的概念，允许开发者以一种更自然和高效的方式处理事件和数据流。
函数式编程： RxJava基于函数式编程原则，提供了丰富的操作符，用于对数据流进行转换、过滤、组合和处理。这使得代码更加简洁、清晰和容易测试。
并发管理： RxJava管理并发操作，允许在多线程环境中处理数据流，而无需手动管理线程。开发者可以轻松地执行操作并在需要时切换线程。
错误处理： RxJava提供了强大的错误处理机制，使开发者能够优雅地处理异常情况，从而提高应用程序的可靠性和稳定性。
可组合性： RxJava中的操作符具有高度的可组合性，可以构建复杂的数据流处理管道，同时保持代码的简洁性和可维护性。

总之，RxJava是一个强大的工具，可以帮助开发者处理异步操作、事件处理和数据流，使代码更加响应式、可读性更高，并提高应用程序的性能和可维护性。无论是在移动应用程序开发、服务器端编程还是其他需要处理异步任务的领域，RxJava都是一个有价值的工具。

基本概念

RxJava 中的观察者（Observer）、被观察者（Observable）以及背压（Backpressure）是 RxJava 中的关键概念，它们一起构成了响应式编程模型的基础。让我分别解释它们：

1. 被观察者（Observable）： 被观察者是事件源，它会发出一系列的事件或数据项。这些事件可以是任何类型的数据，比如网络请求的结果、传感器数据、UI 事件等。被观察者负责生成这些事件并将它们发送给观察者。

2. 观察者（Observer）： 观察者是订阅被观察者的实体，它们接收被观察者发出的事件。观察者通常定义了用于处理不同类型事件的回调方法，如 onNext 用于处理数据项、onError 用于处理错误、onComplete 用于处理完成通知。观察者通过订阅（subscribe）被观察者来建立连接，一旦建立连接，观察者就可以接收被观察者发送的事件。

3. 背压（Backpressure）： 背压是指在处理大量数据流时，被观察者产生的事件速度超过观察者处理事件的速度，导致观察者无法有效处理事件，从而可能引发内存溢出或性能问题。为了解决背压问题，RxJava 2 引入了背压策略，包括：

BUFFER： 缓冲所有事件，直到观察者可以处理它们。
DROP： 丢弃掉一些事件，以使事件流的速度适应观察者。
LATEST： 只保留最新的事件，丢弃其它事件。
ERROR： 如果观察者无法跟上事件流，就引发背压错误。

背压策略可以根据应用程序的需求来选择，以确保性能和内存的有效管理。

总结起来，RxJava 中的观察者和被观察者构成了响应式编程的核心，它们允许你处理异步事件和数据流。背压则是为了解决在高速数据流中的事件处理速度不匹配的问题，确保系统的稳定性和性能。通过合理使用观察者、被观察者以及背压策略，你可以构建响应式的、高效的应用程序。

RxJava的基本实现

Gradle 依赖：

如果你使用 Gradle，可以在你的 build.gradle 文件中添加以下依赖：

dependencies {
    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0' // 使用最新版本
    implementation 'io.reactivex.rxjava3:rxjava:3.0.0' // 使用最新版本
}

RxJava 的基本实现涉及到创建被观察者（Observable）和观察者（Observer），以及对数据流进行操作。以下是一个简单的 RxJava 示例，演示如何创建一个被观察者、一个观察者，并对数据流进行一些基本操作：

import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.disposables.Disposable;

public class RxJavaExample {

    public static void main(String[] args) {
        // 创建一个被观察者（Observable）
        Observable<String> observable = Observable.create(emitter -> {
            // 发送数据项
            emitter.onNext("Hello");
            emitter.onNext("RxJava");
            emitter.onNext("World");
            // 发送完成通知
            emitter.onComplete();
        });

        // 创建一个观察者（Observer）
        Observer<String> observer = new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                // 订阅时的操作
            }

            @Override
            public void onNext(String s) {
                // 处理接收到的数据项
                System.out.println("Received: " + s);
            }

            @Override
            public void onError(Throwable e) {
                // 处理发生错误的情况
            }

            @Override
            public void onComplete() {
                // 处理完成通知
                System.out.println("Done!");
            }
        };

        // 将观察者订阅到被观察者
        observable.subscribe(observer);
    }
}

上面的示例首先创建了一个被观察者 observable，该被观察者发出了三个数据项，并最后发出了完成通知。然后，创建了一个观察者 observer，它定义了如何处理接收到的数据、错误和完成通知。最后，通过 observable.subscribe(observer) 将观察者订阅到被观察者，观察者将开始接收和处理被观察者发出的事件。

也可以调用just方法添加事件到任务队列里
Obervable observable = Observable.just(“Hello”，“RxJava”，“World”)；上诉代码会自动调用onNext(),onComplete()方法

RxJava3.x的Subject和Processor

RxJava 3.x 引入了 Subject 和 Processor 这两个重要的接口，它们在 RxJava 中用于实现多播和事件总线的功能。让我解释一下它们的作用和用法：

1. Subject（主题）： Subject 是 RxJava 中的一个接口，Subject即可以是一个Observer,也可以充当一个Observerable，所以代表了一个可观察对象和观察者之间的桥梁，Subject 可以用来多播（multicast）数据流，即可以被多个观察者订阅，它会将发送给它的事件广播给所有已订阅的观察者。而不是每个观察者都创建一个独立的数据流。Subject RxJava 3.x 提供了不同类型的 Subject，包括：

PublishSubject：将事件广播给所有已订阅的观察者，但只发送自订阅之后的事件。
BehaviorSubject：在订阅时，会发送最近的一个事件，然后继续发送后续事件。
ReplaySubject：会将所有事件都缓存，并在订阅时将所有事件重新发送给观察者。
AsyncSubject：只在事件序列完成时（调用 onComplete）发送最后一个事件，无论是否有其他事件。

以下是一个示例，演示如何使用 PublishSubject：

import io.reactivex.rxjava3.subjects.PublishSubject;

public class SubjectExample {

    public static void main(String[] args) {
        PublishSubject<String> subject = PublishSubject.create();
			//创建一个订阅者（Observer 1），并将其订阅到名为subject的 PublishSubject 对象上。
        subject.subscribe(s -> System.out.println("Observer 1: " + s));
        subject.onNext("Hello");

        subject.subscribe(s -> System.out.println("Observer 2: " + s));
        subject.onNext("RxJava");
        subject.onNext("World");
    }
}

在这个特定的例子中，你创建了两个观察者（Observer 1 和 Observer 2），并将它们都订阅到了同一个PublishSubject 对象上。因此，当你调用subject.onNext(“Hello”)、subject.onNext(“RxJava”) 和 subject.onNext(“World”) 时，这三个字符串都会被传递给这两个观察者，并且它们会输出相应的消息，例如 “Observer 1: Hello” 和 “Observer 2: Hello”。这是一种常见的用法，其中多个观察者可以订阅同一个可观察对象，并且它们都会观察到相同的数据流。

2. Processor（处理器）： Processor 也是 RxJava 中的接口，它是 Subject 的子接口，具有被观察者和观察者的特性，同时支持背压。Processor 可以被订阅和订阅其他 Observer，同时也可以将事件广播给已订阅的 Observer。它是一种更加通用的多播机制。

以下是一个示例，演示如何使用 PublishProcessor：

import io.reactivex.rxjava3.processors.PublishProcessor;

public class ProcessorExample {

    public static void main(String[] args) {
        PublishProcessor<String> processor = PublishProcessor.create();

        processor.subscribe(s -> System.out.println("Observer 1: " + s));
        processor.onNext("Hello");

        processor.subscribe(s -> System.out.println("Observer 2: " + s));
        processor.onNext("RxJava");
        processor.onNext("World");
    }
}

在这个代码示例中，使用了RxJava中的 PublishProcessor，它是一种特殊的可观察对象（Observable），也可以充当观察者（Observer）。PublishProcessor 可以像普通的 Observable 一样发送数据项，同时它还可以订阅其他的可观察对象或让其他观察者订阅它自己，从而形成一个数据流的中继器。

下面是代码的执行步骤解释：

PublishProcessor<String> processor = PublishProcessor.create(); 创建了一个 PublishProcessor 对象，这个对象可以用于发送和接收字符串类型的数据项。
processor.subscribe(s -> System.out.println("Observer 1: " + s)); 创建了第一个观察者（Observer 1），并将其订阅到 processor 上。这个观察者会打印出接收到的数据项。
processor.onNext("Hello"); 向 processor 发送了一个字符串数据项 “Hello”。由于已经有一个观察者（Observer 1）订阅了 processor，因此这个数据项会被传递给 Observer 1，并打印出 “Observer 1: Hello”。
processor.subscribe(s -> System.out.println("Observer 2: " + s)); 创建了第二个观察者（Observer 2），并将其订阅到 processor 上。
processor.onNext("RxJava"); 和 processor.onNext("World"); 分别向 processor 发送了两个字符串数据项。这两个数据项会被传递给所有已经订阅 processor 的观察者，因此 Observer 1 和 Observer 2 都会接收到这两个数据项，并分别打印出相应的消息。

总结起来，PublishProcessor 具有广播数据给所有已经订阅它的观察者的能力，这使得多个观察者可以同时观察到同一数据流。在这个例子中，Observer 1 和 Observer 2 都订阅了 processor，因此它们都能接收到 “Hello”、“RxJava” 和 “World” 这三个字符串数据项。

Subject和Processor的区别

PublishProcessor 和 PublishSubject 都是 RxJava 中用于处理可观察对象（Observables）的类，它们有一些相似之处，但也有一些关键的不同点：

相似之处：

可观察对象（Observable）的特性：两者都可以作为可观察对象，可以向它们发送数据项并让观察者订阅它们。
多个观察者：你可以将多个观察者订阅到 PublishProcessor 或 PublishSubject 上，这样它们都可以观察到相同的数据流。

不同之处：

Processor vs. Subject：PublishProcessor 是一个特殊的可观察对象，同时也可以充当观察者。它可以用来中继数据流，将数据从一个可观察对象传递到另一个。而 PublishSubject 是一个普通的可观察对象，只能作为数据源，不能用来中继数据。
Hot vs. Cold Observable：PublishProcessor 是一种热（Hot）可观察对象，它在创建后立即开始发射数据项，而不管是否有观察者订阅。相比之下，PublishSubject 是一种冷（Cold）可观察对象，它只有在有观察者订阅后才开始发射数据项。这意味着在 PublishProcessor 中，数据项可能会丢失，因为它们会在观察者订阅之前被发射，而在 PublishSubject 中不会有这个问题。

所以，在你的第一个示例中，PublishSubject 是一个冷可观察对象，而在第二个示例中，PublishProcessor 是一个热可观察对象。这是两者之间的主要区别。你可以根据需求选择使用哪种类型，取决于是否需要热或冷的行为以及是否需要中继数据流。

RxJava3.x操作符

RxJava 3.x 提供了丰富的操作符，用于对可观察对象（Observables）和数据流进行转换、过滤、组合和操作。这些操作符使得你能够以一种流畅和声明性的方式处理异步数据流。以下是一些常见的 RxJava 3.x 操作符及其用法示例：

1. Map 操作符： 用于将可观察对象发出的每个数据项通过一个函数转换成另一个数据项。

Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);
Observable<String> mappedNumbers = numbers.map(n -> "Number: " + n);

2. Filter 操作符： 用于从可观察对象中过滤出符合条件的数据项。

Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);
Observable<Integer> evenNumbers = numbers.filter(n -> n % 2 == 0);

3. FlatMap 操作符： 用于将每个数据项映射到一个可观察对象，并将这些可观察对象合并成一个新的可观察对象。

Observable<String> source = Observable.just("Hello", "RxJava", "World");
Observable<String> words = source.flatMap(s -> Observable.fromArray(s.split(" ")));

4. Merge 操作符： 用于将多个可观察对象合并成一个可观察对象，不保证顺序。

Observable<Integer> source1 = Observable.just(1, 2, 3);
Observable<Integer> source2 = Observable.just(4, 5, 6);
Observable<Integer> merged = Observable.merge(source1, source2);

5. Concat 操作符： 用于将多个可观察对象按顺序连接成一个可观察对象。

Observable<Integer> source1 = Observable.just(1, 2, 3);
Observable<Integer> source2 = Observable.just(4, 5, 6);
Observable<Integer> concatenated = Observable.concat(source1, source2);

6. Zip 操作符： 用于将多个可观察对象的相同位置的数据项合并成一个新的数据项。

Observable<Integer> numbers = Observable.just(1, 2, 3);
Observable<String> colors = Observable.just("Red", "Green", "Blue");
Observable<String> zipped = Observable.zip(numbers, colors, (n, c) -> n + "-" + c);

7. Reduce 操作符： 用于对可观察对象发出的所有数据项进行累积操作。

Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);
Observable<Integer> sum = numbers.reduce(0, (acc, n) -> acc + n);

8. Take 操作符： 用于仅发射可观察对象的前 N 个数据项。

Observable<Integer> numbers = Observable.just(1, 2, 3, 4, 5);
Observable<Integer> firstThree = numbers.take(3);

9. Debounce 操作符： 用于过滤掉可观察对象中连续出现的数据项，只发射最后一个。

Observable<String> input = ... // 用户输入流
Observable<String> debouncedInput = input.debounce(300, TimeUnit.MILLISECONDS);

10. Retry 操作符： 用于在发生错误时重新订阅可观察对象，重试指定次数。

Observable<Integer> source = ... // 可能会出错的可观察对象
Observable<Integer> retried = source.retry(3); // 最多重试3次

以上是一些 RxJava 3.x 中常见的操作符及其用法示例，但还有许多其他操作符可供使用，以满足不同的需求。操作符的选择取决于你希望对数据流进行的具体转换和操作。根据你的项目需求，你可以组合使用这些操作符来构建复杂的数据处理管道。

Rx线程控制

在 RxJava 3.x 中，你可以使用操作符来控制数据流在不同线程之间的切换和调度，以便在合适的时候执行操作。以下是一些常见的线程控制操作符：

1. subscribeOn 操作符： 用于指定被观察者的线程，即数据流的生产线程。通常用于执行耗时的操作，如网络请求或数据库查询。

Observable.create(emitter -> {
    // 在后台线程执行耗时操作
    // ...
}).subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(result -> {
    // 在主线程处理结果
    // ...
});

在上面的示例中，subscribeOn(Schedulers.io()) 指定了被观察者在 IO 线程中执行，而 observeOn(AndroidSchedulers.mainThread()) 则指定了观察者在主线程中接收和处理结果。

2. observeOn 操作符： 用于指定观察者的线程，即数据流的消费线程。通常用于在主线程中更新 UI 或执行其他与 UI 相关的操作。

3. doOnSubscribe 和 doOnNext 操作符： 用于在数据流中的特定位置执行副作用操作，例如在订阅时执行某些操作或在每个数据项发射时执行某些操作。可以通过指定调度器来控制在哪个线程上执行这些操作。

Observable.just(1, 2, 3)
  .doOnSubscribe(disposable -> {
    // 在订阅时执行操作，通常用于显示进度条等
  })
  .doOnNext(item -> {
    // 在每个数据项发射时执行操作
  })
  .subscribeOn(Schedulers.io())
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(result -> {
    // 在主线程处理结果
  });

4. delay 操作符： 用于延迟发射数据项的时间，可以用于模拟网络请求延迟等场景。

Observable.just(1, 2, 3)
  .delay(2, TimeUnit.SECONDS)
  .observeOn(AndroidSchedulers.mainThread())
  .subscribe(result -> {
    // 在主线程处理结果，但会延迟2秒
    // ...
});

这些操作符允许你在 RxJava 中进行线程控制，以确保数据流在不同线程上进行适当的切换和调度。通过合理使用这些操作符，你可以处理异步任务、优化性能和确保响应性。在 Android 开发中，subscribeOn 和 observeOn 操作符特别有用，可以帮助你在后台线程执行耗时操作并在主线程更新 UI。