Reactor 框架常用 API

OliverAAAAAA

已于 2023-05-19 10:53:59 修改

阅读量1.2k

点赞数 2

文章标签： java 大数据

于 2023-05-19 10:26:31 首次发布

本文链接：https://blog.csdn.net/OliverAAAAAA/article/details/130761035

版权

Reactor 框架是一个基于响应式编程的库，提供了丰富的 API 来处理异步和并发操作。以下是 Reactor 框架中常用的一些 API：

以下是对 Reactor 框架常用 API 的使用实例：

一、 Reactor 框架常用 API

Reactor 框架是一个基于响应式编程的库，提供了丰富的 API 来处理异步和并发操作。以下是 Reactor 框架中常用的一些 API：

Flux：表示包含 0 到 N 个元素的响应式流，可以用于处理多个值或集合。
Mono：表示包含 0 或 1 个元素的响应式流，可以用于处理单个值或空值。
Operators（操作符）：提供了丰富的操作符来转换、过滤、组合和处理响应式流，例如 map、filter、flatMap、zip 等。
Schedulers（调度器）：用于控制执行流在不同线程上的调度和并发性，例如 immediate、single、parallel、elastic 等。
MonoSink/FluxSink：用于手动创建响应式流并发送元素或错误信号。
连接操作符：包括 merge、concat、combineLatest 等，用于将多个流进行合并或组合。
异常处理：提供了 onErrorResume、onErrorReturn、retry 等操作符来处理异常情况。
背压支持：提供了背压策略和操作符，用于处理生产者和消费者之间的速度不匹配问题。
WebFlux：用于构建响应式的 Web 应用程序，提供了基于 Reactor 的非阻塞的 Web 框架。
StepVerifier：用于测试响应式流的工具，可以验证流中的元素、顺序和终止条件等。

1.1. Flux：创建一个包含多个元素的响应式流。

Flux<Integer> flux = Flux.just(1, 2, 3, 4, 5);

1.2. Mono：创建一个包含单个元素的响应式流。

Mono<String> mono = Mono.just("Hello, World!");

1.3. map 操作符：将流中的元素进行转换。

Flux<Integer> mappedFlux = flux.map(i -> i * 2);

1.4. filter 操作符：根据条件过滤流中的元素。

Flux<Integer> filteredFlux = flux.filter(i -> i % 2 == 0);

1.5. flatMap 操作符：将流中的元素进行扁平化处理。

Flux<Integer> flatMappedFlux = flux.flatMap(i -> Flux.just(i, i * 2));

1.6. zip 操作符：将多个流的元素进行组合。

Flux<Tuple2<Integer, String>> zippedFlux = flux.zipWith(mono);

1.7. Schedulers 调度器：指定流的执行线程。

Flux<Integer> scheduledFlux = flux.subscribeOn(Schedulers.parallel());

1.8. onErrorResume 操作符：处理流中的错误。

Flux<Integer> errorHandledFlux = flux.onErrorResume(ex -> Flux.just(-1));

1.9. 背压支持：在生产者和消费者之间进行流量控制。

Flux<Integer> backpressureSupportedFlux = flux.onBackpressureBuffer();

1.10. WebFlux：使用 WebFlux 构建响应式的 Web 应用程序。

@GetMapping("/users")
public Flux<User> getAllUsers() {
    return userService.getAllUsers();
}

1.11. StepVerifier：测试响应式流的行为和结果。

StepVerifier.create(flux)
    .expectNext(1, 2, 3)
    .expectComplete()
    .verify();

以上示例展示了 Reactor 框架中常用的一些 API 的使用实例，但实际使用时根据具体需求和业务场景进行适当调整和组合。

二、Operators（操作符）介绍

2.1. map 操作符：将流中的元素进行转换。

Flux<Integer> flux = Flux.just(1, 2, 3);
Flux<String> mappedFlux = flux.map(i -> "Number: " + i);

2.2. flatMap 操作符：将流中的元素进行扁平化处理。

Flux<Integer> flux = Flux.just(1, 2, 3);
Flux<String> flatMappedFlux = flux.flatMap(i -> Flux.just("Number: " + i, "Doubled: " + (i * 2)));

2.3. filter 操作符：根据条件过滤流中的元素。

Flux<Integer> flux = Flux.just(1, 2, 3, 4, 5);
Flux<Integer> filteredFlux = flux.filter(i -> i % 2 == 0);

2.4. take 操作符：只取流中的前 n 个元素。

Flux<Integer> flux = Flux.just(1, 2, 3, 4, 5);
Flux<Integer> takenFlux = flux.take(3);

2.5. reduce 操作符：对流中的元素进行累积操作，将它们合并成一个值。

Flux<Integer> flux = Flux.just(1, 2, 3, 4, 5);
Mono<Integer> reducedMono = flux.reduce(0, (acc, value) -> acc + value);

2.6. zip 操作符：将多个流的对应元素进行组合，并生成一个新的流。

Flux<Integer> flux1 = Flux.just(1, 2, 3);
Flux<String> flux2 = Flux.just("A", "B", "C");
Flux<Tuple2<Integer, String>> zippedFlux = flux1.zipWith(flux2);

2.7. merge 操作符：将多个流合并成一个流，按照元素的顺序进行交叉组合。

Flux<Integer> flux1 = Flux.just(1, 3, 5);
Flux<Integer> flux2 = Flux.just(2, 4, 6);
Flux<Integer> mergedFlux = Flux.merge(flux1, flux2);

2.8. concat 操作符：将多个流按照顺序进行连接，保持元素的顺序。

Flux<Integer> flux1 = Flux.just(1, 2, 3);
Flux<Integer> flux2 = Flux.just(4, 5, 6);
Flux<Integer> concatenatedFlux = Flux.concat(flux1, flux2);

2.9. onErrorResume 操作符：在流遇到错误时，使用备用的流继续进行操作。

Flux<Integer> flux = Flux.just(1, 2, 3);
Flux<Integer> onErrorResumeFlux = flux.concatWith(Mono.error(new RuntimeException("Error")))
        .onErrorResume(ex -> Flux.just(-1));

2.10. retry 操作符：在流遇到错误时，重新订阅源流进行重试操作。

Flux<Integer> flux = Flux.just(1, 2, 3)
        .concatWith(Mono.error(new RuntimeException

("Error")))
        .retry(3);

2.11. distinct 操作符：去除流中的重复元素。

Flux<Integer> flux = Flux.just(1, 2, 3, 1, 2, 3);
Flux<Integer> distinctFlux = flux.distinct();

2.12. takeWhile 操作符：从流中取元素，直到遇到不满足条件的元素为止。

Flux<Integer> flux = Flux.just(1, 2, 3, 4, 5);
Flux<Integer> takeWhileFlux = flux.takeWhile(i -> i < 4);

2.13. timeout 操作符：设置流的超时时间，如果超过指定时间仍未产生元素，则触发超时处理。

Flux<Integer> flux = Flux.just(1, 2, 3).delayElements(Duration.ofSeconds(1));
Flux<Integer> timeoutFlux = flux.timeout(Duration.ofSeconds(2), Flux.just(-1));

2.14. delayElements 操作符：对流中的元素进行延迟处理，按照指定的时间间隔进行发射。

Flux<Integer> flux = Flux.just(1, 2, 3).delayElements(Duration.ofSeconds(1));

三、Schedulers调度器介绍

以下是对 Reactor 框架中常见调度器的介绍和使用示例：

3.1. Schedulers.immediate(): 立即在当前线程执行操作，没有线程切换。

Flux.range(1, 5)
    .publishOn(Schedulers.immediate())
    .doOnNext(System.out::println)
    .blockLast();

3.2. Schedulers.single(): 使用单个工作线程执行操作，保证操作的顺序性。

Flux.range(1, 5)
    .publishOn(Schedulers.single())
    .doOnNext(System.out::println)
    .blockLast();

3.3. Schedulers.parallel(): 使用固定大小的线程池执行操作，适用于并行处理。

Flux.range(1, 5)
    .publishOn(Schedulers.parallel())
    .doOnNext(System.out::println)
    .blockLast();

3.4. Schedulers.elastic(): 使用弹性线程池执行操作，根据需要创建和回收线程，适用于计算密集型任务。

Flux.range(1, 5)
    .publishOn(Schedulers.elastic())
    .doOnNext(System.out::println)
    .blockLast();

3.5. Schedulers.boundedElastic(): 使用有界弹性线程池执行操作，适用于 I/O 密集型任务。

Flux.range(1, 5)
    .publishOn(Schedulers.boundedElastic())
    .doOnNext(System.out::println)
    .blockLast();

3.6. Schedulers.fromExecutorService(ExecutorService): 使用自定义的 ExecutorService 执行操作。

ExecutorService executorService = Executors.newFixedThreadPool(3);
Scheduler scheduler = Schedulers.fromExecutorService(executorService);

Flux.range(1, 5)
    .publishOn(scheduler)
    .doOnNext(System.out::println)
    .blockLast();

executorService.shutdown();

3.7. Schedulers.fromExecutor(Executor): 使用自定义的 Executor 执行操作。

Executor executor = Executors.newSingleThreadExecutor();
Scheduler scheduler = Schedulers.fromExecutor(executor);

Flux.range(1, 5)
    .publishOn(scheduler)
    .doOnNext(System.out::println)
    .blockLast();

((ExecutorService) executor).shutdown();