【转】[Java] Reactive Streams 介绍

转自：https://doubao.com/chat

Reactive Streams 是一个用于异步流处理的标准，它提供了一种规范，确保不同的响应式库（如 Reactor、RxJava 等）之间可以相互兼容和交互。以下将详细介绍如何使用 Reactive Streams 进行异步编程，以 Java 和 Reactor 库为例。

1. 引入依赖

 

首先，你需要在项目中引入 Reactor Core 库。如果你使用的是 Maven 项目，可以在 pom.xml 中添加以下依赖：

 

收起

xml

 

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.4.24</version>
</dependency>

 

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

 

收起

groovy

 

implementation 'io.projectreactor:reactor-core:3.4.24'

2. 创建响应式流

 

Reactor 提供了两种主要的响应式类型：Mono 和 Flux。

 

• Mono：表示包含 0 或 1 个元素的异步序列。

 

收起

java

 

import reactor.core.publisher.Mono;

public class MonoExample {
    public static void main(String[] args) {
        // 创建一个包含单个元素的 Mono
        Mono<String> mono = Mono.just("Hello, Reactive Streams!");

        // 订阅 Mono 并处理结果
        mono.subscribe(
                value -> System.out.println("Received value: " + value),
                error -> System.err.println("Error: " + error),
                () -> System.out.println("Mono completed")
        );
    }
}

 

• Flux：表示包含 0 到 N 个元素的异步序列。

 

收起

java

 

import reactor.core.publisher.Flux;

public class FluxExample {
    public static void main(String[] args) {
        // 创建一个包含多个元素的 Flux
        Flux<Integer> flux = Flux.range(1, 5);

        // 订阅 Flux 并处理结果
        flux.subscribe(
                value -> System.out.println("Received value: " + value),
                error -> System.err.println("Error: " + error),
                () -> System.out.println("Flux completed")
        );
    }
}

3. 异步操作

 

在 Reactive Streams 中，可以使用各种操作符来处理异步流。以下是一些常见的操作符示例：

 

• map：对每个元素进行转换。

 

收起

java

 

import reactor.core.publisher.Flux;

public class MapOperatorExample {
    public static void main(String[] args) {
        Flux<Integer> numbers = Flux.range(1, 5);

        // 使用 map 操作符将每个元素乘以 2
        Flux<Integer> squaredNumbers = numbers.map(n -> n * 2);

        squaredNumbers.subscribe(System.out::println);
    }
}

 

• flatMap：将每个元素转换为一个新的流，并将这些流合并为一个流。

 

收起

java

 

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class FlatMapOperatorExample {
    public static void main(String[] args) {
        Flux<String> words = Flux.just("Hello", "World");

        // 使用 flatMap 操作符将每个单词拆分为字符流
        Flux<Character> characters = words.flatMap(word -> {
            return Flux.fromArray(word.chars().mapToObj(c -> (char) c).toArray(Character[]::new));
        });

        characters.subscribe(System.out::println);
    }
}

4. 错误处理

 

在异步编程中，错误处理非常重要。可以使用 onErrorResume、onErrorReturn 等操作符来处理错误。

 

收起

java

 

import reactor.core.publisher.Flux;

public class ErrorHandlingExample {
    public static void main(String[] args) {
        Flux<Integer> numbers = Flux.just(1, 2, 3, 0, 4)
               .map(n -> 10 / n) // 可能会抛出除零异常
               .onErrorResume(error -> {
                    if (error instanceof ArithmeticException) {
                        System.err.println("Division by zero error occurred. Returning default value.");
                        return Flux.just(-1);
                    }
                    return Flux.error(error);
                });

        numbers.subscribe(System.out::println);
    }
}

5. 背压处理

 

背压是 Reactive Streams 中的一个重要概念，用于处理生产者和消费者之间的速度不匹配问题。Reactor 库会自动处理背压，你可以通过 subscribe 方法的 Subscription 参数来手动控制背压。

 

收起

java

 

import reactor.core.publisher.Flux;
import org.reactivestreams.Subscription;

public class BackpressureExample {
    public static void main(String[] args) {
        Flux<Integer> numbers = Flux.range(1, 100);

        numbers.subscribe(new org.reactivestreams.Subscriber<Integer>() {
            private Subscription subscription;
            private int count = 0;

            @Override
            public void onSubscribe(Subscription s) {
                this.subscription = s;
                // 请求 10 个元素
                s.request(10);
            }

            @Override
            public void onNext(Integer value) {
                System.out.println("Received value: " + value);
                count++;
                if (count % 10 == 0) {
                    // 每处理 10 个元素，再请求 10 个元素
                    subscription.request(10);
                }
            }

            @Override
            public void onError(Throwable t) {
                System.err.println("Error: " + t);
            }

            @Override
            public void onComplete() {
                System.out.println("Flux completed");
            }
        });
    }
}

 

通过以上步骤，你可以使用 Reactive Streams 进行异步编程，处理异步流、执行异步操作、处理错误和背压等。