首页 > 其他分享 >Flux.merge 使用说明书

Flux.merge 使用说明书

时间：2024-10-21 20:49:26浏览次数：3  
标签：Publisher sources 合并 Flux 说明书 prefetch merge

merge

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
                                int concurrency)
Merge data from  Publisher sequences emitted by the passed  Publisher into an interleaved merged sequence. Unlike  concat, inner sources are subscribed to eagerly (but at most concurrency sources are subscribed to at the same time).

将来自传入的 Publisher 发出的序列中的数据合并为一个交错的合并序列。与 concat 不同，内部源是被迫早期订阅的（但同时最多只能订阅指定数量的源）。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理无限源且该源并未在专用的 Scheduler 上发布时，必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将会试图在订阅其他源之前耗尽该源的所有数据。

Type Parameters:

T - the merged type

Parameters:

source - a  Publisher of  Publisher sources to merge
concurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged Flux

类型参数：

T - 合并后的类型。

参数说明：

source - 一个 Publisher，其发出多个要合并的 Publisher 源。
concurrency - 发给主源的请求量，用于限制并发合并的积压。

返回值：

返回一个合并后的 Flux。 

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source, int concurrency)

是 Reactor 提供的用于将多个 Publisher 合并成一个 Flux 的方法。

它可以从一个上游 Publisher 发射的 Publisher 序列中获取元素，并合并这些 Publisher 所发射的数据到一个 Flux 流中。

通过 concurrency 参数，可以限制并发的合并数量。

1. 方法介绍

  • merge(Publisher<? extends Publisher<? extends T>> source, int concurrency): 该方法接受一个发射 Publisher 的 Publisher 作为数据源，然后将这些 Publisher 合并成一个 Flux，最终发射这些内部 Publisher 中的数据流。并发参数控制了最多有多少个内部 Publisher 同时进行数据发射。

2. 参数

  • source: 这是一个 Publisher，它发射多个 Publisher（这些 Publisher 又各自发射元素）。
  • concurrency: 表示同时并发处理的 Publisher 的最大数量。它限制了最多有多少个 Publisher 可以并发发射数据。

3. 返回值

  • Flux<T>: 返回一个包含所有合并数据的 Flux。这个 Flux 发射的元素来自 source 提供的多个 Publisher 中的数据，并以并发方式处理这些 Publisher。

4. 示例代码

合并多个 Publisher，限制并发数
java

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

public class FluxMergeConcurrencyExample {
    public static void main(String[] args) {
        // 创建多个 Mono
        Mono<String> publisher1 = Mono.just("A");
        Mono<String> publisher2 = Mono.just("B");
        Mono<String> publisher3 = Mono.just("C");

        // 将这些 Mono 放入一个 Flux 中
        Flux<Mono<String>> publishers = Flux.just(publisher1, publisher2, publisher3);

        // 使用 merge 方法，将 Flux<Mono<String>> 合并成 Flux<String>，并限制并发为 2
        Flux<String> mergedFlux = Flux.merge(publishers, 2);

        // 订阅并打印合并后的结果
        mergedFlux.subscribe(System.out::println);
    }
}

输出结果：

A
B
C

在这个例子中，我们有三个 Mono（publisher1、publisher2 和 publisher3），这些 Mono 各自发射一个字符串。我们将这些 Mono 包装在一个 Flux 中，并使用 merge() 方法合并它们。concurrency 参数设为 2，限制了最多两个 Publisher 同时处理。

5. 并发控制的重要性

  • concurrency 参数: 控制并发的 Publisher 数量非常重要，尤其是在处理 IO 密集型任务（例如网络请求、数据库查询）时。通过限制并发数量，可以避免同时过多的任务消耗系统资源。如果你设置 concurrency 为一个较高的值，可能会导致资源耗尽或性能下降；设置为较低的值，则会限制系统吞吐量。

示例：设置较低的并发数

将并发数设置为 1，表示按顺序处理每个 Publisher：

java

Flux<String> mergedFlux = Flux.merge(publishers, 1);

在这种情况下，publisher1 完成后，才会处理 publisher2，依次类推。这种方式避免了并发执行，所有 Publisher 将按顺序执行。

6. 异步处理

Flux.merge() 是异步处理的，它会并发处理多个 Publisher，并将所有发射的数据合并成一个流。如果 Publisher 是异步的（例如网络请求或异步任务），合并后的 Flux 将会保持异步行为，尽快发射数据。

7. 其他相关方法

  • Flux.merge(Publisher<T>... sources): 用于合并多个直接提供的 Publisher。
  • Flux.mergeSequential(): 和 merge() 不同的是，mergeSequential() 会按照 Publisher 的发射顺序来合并，而不是并发处理。
  • Flux.concat(): concat() 和 merge() 类似，但是它会按顺序串行处理所有 Publisher，而不是并发处理。

8. 使用场景

  • API 请求的批量处理: 在处理多个外部 API 请求时，可以使用 merge() 来同时发起多个请求，并发处理返回结果。
  • 异步任务的调度: 在调度多个异步任务时，可以通过限制并发的 Publisher 数量，来控制系统的负载。

9. 注意事项

  • 资源管理: 当使用高并发数处理大量 Publisher 时，可能会占用大量的系统资源，特别是在处理 IO 密集型任务时，需要适当调整 concurrency 参数以平衡性能和资源消耗。
  • 错误处理: 合并过程中，如果其中一个 Publisher 发射了错误，整个合并的 Flux 可能会立即终止。可以通过 one rrorResume() 或 one rrorContinue() 等操作符来处理这种情况。

10. 总结

  • Flux.merge(Publisher<? extends Publisher<? extends T>> source, int concurrency) 是一个强大的方法，它允许我们并发地合并来自多个 Publisher 的数据流。通过 concurrency 参数，我们可以精细控制并发的数量，以提高系统性能或限制资源使用。
  • 适用于异步任务、大量数据流合并等场景，同时也需要注意资源消耗和错误处理。

merge

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source,
                                int concurrency,
                                int prefetch)
Merge data from  Publisher sequences emitted by the passed  Publisher into an interleaved merged sequence. Unlike  concat, inner sources are subscribed to eagerly (but at most concurrency sources are subscribed to at the same time).

将来自传入的 Publisher 发出的多个序列中的数据合并为一个交错的合并序列。与 concat 不同，内部源会被立即订阅（但最多同时订阅指定数量的源）。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理一个无限源时，如果该源并未在专用的 Scheduler 上发布，则必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将尝试在订阅其他源之前先耗尽该源的所有数据。

Type Parameters:

T - the merged type

Parameters:

source - a  Publisher of  Publisher sources to merge
concurrency - the request produced to the main source thus limiting concurrent merge backlog
prefetch - the inner source request size

Returns:

a merged  Flux

类型参数：

T - 合并后的类型。

参数说明：

source - 一个 Publisher，其发出多个要合并的 Publisher 源。
concurrency - 发给主源的请求量，用于限制并发合并的积压。
prefetch - 内部源的请求大小。

返回值：

返回一个合并后的 Flux。 

public static <T> Flux<T> merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch)

是 Reactor 提供的用于将多个 Publisher 合并为一个 Flux 的方法。

它与 merge(Publisher<? extends Publisher<? extends T>> source, int concurrency) 类似，但多了一个 prefetch 参数，控制在每个 Publisher 中预取（预读取）的数据量。

这种设计可以在流量控制和并发性能之间进行更细致的调节。

1. 方法介绍

  • merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch): 该方法从一个发射 Publisher 的 Publisher 中合并内部发射的多个 Publisher 的数据流，并使用 concurrency 控制最大并发数量，使用 prefetch 控制每个内部 Publisher 在合并过程中预取的数据量。

2. 参数

  • source: 这是一个 Publisher，它会发射多个 Publisher。这些 Publisher 各自会发射一系列元素。
  • concurrency: 并发的最大数量，表示同时可以处理的 Publisher 的最大数量。这个参数控制合并操作中最多有多少个 Publisher 可以同时并行发射数据。
  • prefetch: 每个内部 Publisher 的预取量，表示在订阅时从每个 Publisher 中最多预取多少个数据项。这可以帮助平衡响应时间和内存占用量。

3. 返回值

  • Flux<T>: 返回一个包含所有合并数据的 Flux，这个 Flux 发射的数据来自 source 中的多个 Publisher 的合并。

4. 示例代码

合并多个 Publisher，并设置并发数和预取量
java

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

public class FluxMergePrefetchExample {
    public static void main(String[] args) {
        // 创建多个 Mono
        Mono<String> publisher1 = Mono.just("A");
        Mono<String> publisher2 = Mono.just("B");
        Mono<String> publisher3 = Mono.just("C");

        // 将这些 Mono 放入一个 Flux 中
        Flux<Mono<String>> publishers = Flux.just(publisher1, publisher2, publisher3);

        // 使用 merge 方法，设置并发为 2，预取量为 1
        Flux<String> mergedFlux = Flux.merge(publishers, 2, 1);

        // 订阅并打印合并后的结果
        mergedFlux.subscribe(System.out::println);
    }
}

输出结果：

A
B
C

在这个例子中，我们创建了三个 Mono，将它们封装在一个 Flux 中，使用 merge() 方法合并它们，并且设定了最大并发数为 2，预取量为 1。concurrency 控制并发数，而 prefetch 控制每次从 Publisher 中预读取多少数据。

5. 参数作用

  • concurrency: 决定了最多可以同时处理多少个 Publisher。在高并发场景中，这个参数可以防止一次性发起太多任务，进而过度占用系统资源。
  • prefetch: 控制了从每个 Publisher 中最多可以预取的数据量。预取的数据会保存在内存中，等到被处理时再发射给下游。prefetch 可以用来优化性能：
  • 较大的 prefetch 适合高吞吐量的场景，减少请求数据的频率。
  • 较小的 prefetch 适合低延迟的场景，确保每次只获取少量数据，从而保持响应快速。

预取的重要性

prefetch 影响的是上游 Publisher 如何从下游请求数据。较大的预取量意味着下游可以一次性获取更多的数据，这样可以减少流控（Flow Control）请求的频率。但是，如果 prefetch 设置过大，可能会导致内存占用过高。反之，预取量较小则可以降低内存占用，但可能会导致频繁的数据请求。

6. 使用场景

  • API 请求: 当从多个 API 请求数据时，concurrency 可以控制同时发起的请求数量，prefetch 可以控制每次请求获取的批次大小。
  • 批量处理任务: 当处理需要分批次获取数据的任务时，prefetch 可以控制批次的大小，从而平衡性能和资源消耗。

7. 相关方法

  • Flux.merge(Publisher<T>... sources): 合并多个 Publisher，不带并发和预取设置。
  • Flux.merge(Publisher<? extends Publisher<? extends T>> source, int concurrency): 带并发控制的合并，适合并发处理数据流，但不控制每个 Publisher 的预取量。
  • Flux.concat(): 按顺序串行处理所有 Publisher，不进行并发合并。

8. 示例：动态控制并发和预取

在处理需要动态数据的场景下，concurrency 和 prefetch 的控制可以为系统提供更灵活的解决方案。比如你希望每次只处理两个数据流，但每个数据流只预取3个元素：

java

Flux<String> mergedFlux = Flux.merge(publishers, 2, 3);

这样，在并发处理的情况下，你能保证最多有两个数据流并行发射，每个数据流最多预取3个元素。

9. 总结

  • Flux.merge(Publisher<? extends Publisher<? extends T>> source, int concurrency, int prefetch) 提供了一种灵活的方式来控制多个数据流的合并，同时通过 concurrency 和 prefetch 参数调整并发度和内存消耗。
  • 它适用于需要处理大量异步数据源的场景，通过限制并发数量和预取量来确保系统资源的合理利用，并优化性能。

merge

public static <I> Flux<I> merge(Iterable<? extends Publisher<? extends I>> sources)
Merge data from  Publisher sequences contained in an  Iterable into an interleaved merged sequence. Unlike  concat, inner sources are subscribed to eagerly. A new  Iterator will be created for each subscriber.

将来自 Iterable 中的多个 Publisher 序列的数据合并为一个交错的合并序列。与 concat 不同，内部源会被立即订阅。每个订阅者将为每个源创建一个新的 Iterator。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理一个无限源时，如果该源并未在专用的 Scheduler 上发布，则必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将尝试在订阅其他源之前先耗尽该源的所有数据。

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the  Iterable of sources to merge (will be lazily iterated on subscribe)

Returns:

a merged  Flux

类型参数：

I - 数据序列的源类型。

参数说明：

sources - 要合并的源的 Iterable（将在订阅时进行懒惰迭代）。

返回值：

返回一个合并后的 Flux。 

public static <I> Flux<I> merge(Iterable<? extends Publisher<? extends I>> sources)

是 Reactor 中用于合并多个 Publisher 的静态方法。

与其他 merge 方法类似，这个方法也将多个 Publisher 合并为一个 Flux，不过它接受的是一个 Iterable 类型的 Publisher 集合，允许从一个 Iterable 集合中动态合并多个异步流。

1. 方法介绍

  • merge(Iterable<? extends Publisher<? extends I>> sources): 这个方法将多个异步数据流 Publisher 合并成一个 Flux，并行处理每个 Publisher 中发射的数据项，不保证它们发射的顺序，合并后的 Flux 按照最早可用的数据项顺序发射。

2. 参数

  • sources: 这是一个 Iterable，其中的元素是 Publisher，即每个 Publisher 是一个异步的数据流。它可能是 Flux、Mono 等类型，这些 Publisher 的数据将被并行合并。

3. 返回值

  • Flux<I>: 返回一个 Flux，其中包含来自 sources 中所有 Publisher 的数据流。这些 Publisher 的数据被并行处理并合并到一个 Flux 中发射。

4. 示例代码

假设我们有多个 Mono 类型的 Publisher，可以将它们放入一个 List（实现了 Iterable 接口）中，并使用 merge 方法将它们合并为一个 Flux：

java

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

import java.util.Arrays;
import java.util.List;

public class FluxMergeIterableExample {
    public static void main(String[] args) {
        // 创建多个 Mono
        Mono<String> publisher1 = Mono.just("A");
        Mono<String> publisher2 = Mono.just("B");
        Mono<String> publisher3 = Mono.just("C");

        // 将这些 Mono 放入一个 List 中
        List<Mono<String>> publishers = Arrays.asList(publisher1, publisher2, publisher3);

        // 使用 merge 方法将 List 中的 Publisher 合并成一个 Flux
        Flux<String> mergedFlux = Flux.merge(publishers);

        // 订阅并打印合并后的结果
        mergedFlux.subscribe(System.out::println);
    }
}

输出结果：

A
B
C

在这个例子中，三个 Mono 分别发射了 "A"、"B" 和 "C"，我们将它们放入一个 List 中，并通过 Flux.merge 将它们合并成一个 Flux，合并后的数据按顺序发射出来。

5. 使用场景

  • 动态数据源: 当你有一组动态数据源（Publisher），需要在运行时合并它们，可以使用 Iterable 来处理这些动态生成的 Publisher。
  • 批量异步操作: 当需要处理一批异步操作，每个操作返回一个 Publisher，可以将这些 Publisher 放入 Iterable 集合中，然后通过 merge 并行处理它们。

6. 特点

  • 并行处理: 该方法并行处理 sources 中的每个 Publisher，它们可以同时发射数据，并合并到一个流中。
  • 无序发射: merge 方法不保证发射的顺序，因此，最终合并的 Flux 中数据项的顺序可能与各 Publisher 发射的顺序不同。这与 concat 方法不同，concat 是严格按顺序串行处理每个 Publisher。

7. 相关方法

  • Flux.concat(Iterable<? extends Publisher<? extends I>> sources): 按顺序串联多个 Publisher，确保合并后的数据流中元素的顺序与各个 Publisher 中的顺序一致。适用于希望严格按顺序处理多个数据流的场景。
  • Flux.merge(Publisher<T>... sources): 这是合并多个 Publisher 的另一个变体，接受可变参数的 Publisher。
  • Flux.merge(Iterable<? extends Publisher<? extends I>> sources, int concurrency): 限制并发数量的 merge 方法，concurrency 参数控制可以并行处理的 Publisher 的最大数量。

8. 预期的行为

在 Reactor 中使用 merge 时，每个 Publisher 都会被并行处理，意味着下游订阅者会立即收到第一个可用的数据项，而不需要等待其他 Publisher 完成。因此，当使用多个 Publisher 时，merge 能够最大化地利用并行性。

9. 总结

  • Flux.merge(Iterable<? extends Publisher<? extends I>> sources) 为多个 Publisher 的数据流提供了并行合并的能力，适用于动态或批量处理异步操作的场景。
  • 它不保证顺序，会并行处理所有 Publisher 的数据流，因此如果对顺序有严格要求，可能需要使用其他方法如 concat。
  • 通过 Iterable 接口的实现，灵活性更强，可以从集合或其他结构中动态获取 Publisher 并合并处理。

merge

@SafeVarargs
public static <I> Flux<I> merge(Publisher<? extends I>... sources)
Merge data from  Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike  concat, sources are subscribed to eagerly.

将来自数组或可变参数中的多个 Publisher 序列的数据合并为一个交错的合并序列。与 concat 不同，源会被立即订阅。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理一个无限源时，如果该源并未在专用的 Scheduler 上发布，则必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将尝试在订阅其他源之前先耗尽该源的所有数据。

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the array of  Publisher sources to merge

Returns:

a merged  Flux

类型参数：

I - 数据序列的源类型。

参数说明：

sources - 要合并的 Publisher 源的数组。

返回值：

返回一个合并后的 Flux。 

@SafeVarargs public static <I> Flux<I> merge(Publisher<? extends I>... sources)

是 Reactor 框架中用于将多个 Publisher 合并成一个 Flux 的静态方法。通过可变参数 sources，你可以传入任意多个 Publisher，并将它们的元素合并成一个异步流，进行并行处理。

1. 方法介绍

  • merge(Publisher<? extends I>... sources): 该方法可以将多个 Publisher（例如 Flux、Mono）的流合并为一个 Flux，以并行的方式从每个 Publisher 获取数据，并按它们生成的顺序进行发射。该方法不保证顺序。

2. 参数

  • sources: 这是一个可变参数，表示多个 Publisher（如 Flux 或 Mono），可以是任意数量的 Publisher 实例。

3. 返回值

  • Flux<I>: 返回一个 Flux，这个 Flux 会从所有输入的 Publisher 中合并它们的数据，并将数据发射给下游的订阅者。

4. @SafeVarargs 注解

@SafeVarargs 注解的作用是抑制编译器对可能不安全的可变参数数组的警告，特别是当泛型类型作为可变参数时。由于可变参数可能引入类型安全问题，使用这个注解可以告诉编译器在这种情况下不需要发出警告。

5. 示例代码

合并多个 Mono
java

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

public class FluxMergeExample {
    public static void main(String[] args) {
        // 创建多个 Mono
        Mono<String> mono1 = Mono.just("A");
        Mono<String> mono2 = Mono.just("B");
        Mono<String> mono3 = Mono.just("C");

        // 使用 merge 方法合并多个 Mono
        Flux<String> mergedFlux = Flux.merge(mono1, mono2, mono3);

        // 订阅并打印合并后的结果
        mergedFlux.subscribe(System.out::println);
    }
}

输出结果：

A
B
C

在这个示例中，我们创建了三个 Mono，通过 Flux.merge(mono1, mono2, mono3) 将它们合并成一个 Flux，并订阅了合并后的 Flux。结果中会并行发射 Mono 中的数据，最终输出是 "A", "B", "C"。

6. 使用场景

  • 并行处理多个异步任务: 例如当需要从多个异步数据源（如 API 或数据库）中获取数据时，可以使用 merge 并行处理这些任务，并将结果合并成一个流。
  • 合并多个 Flux 或 Mono: 当你有多个数据流需要合并时，可以使用 merge 将它们的结果并行合并为一个 Flux。这特别适合多个操作结果需要同时处理的情况。

7. 特点

  • 并行处理: 所有传入的 Publisher（例如 Flux 或 Mono）将会被并行处理，它们的数据项会立即合并并发射给下游，不等待其他 Publisher 完成。这使得 merge 是并发处理的一个有效方法。
  • 无序发射: 由于 merge 是并行处理的，合并后的 Flux 发射的数据顺序不一定与各个 Publisher 的顺序一致。换句话说，它不会严格按顺序发射每个 Publisher 的数据。

8. 与 concat 的区别

merge 方法与 concat 方法最大的区别是顺序性：

  • merge: 并行处理所有 Publisher，并且无序发射数据。
  • concat: 串行处理多个 Publisher，即严格按顺序等待一个 Publisher 完成后再处理下一个，因此是有序的。

例如，使用 Flux.concat(mono1, mono2, mono3) 将保证 "A"、"B"、"C" 的顺序，而 Flux.merge 则不保证顺序。

9. 相关方法

  • Flux.merge(Iterable<? extends Publisher<? extends I>> sources): 接受一个 Iterable 类型的 Publisher 集合，将它们合并为一个 Flux，与可变参数形式的 merge 方法类似。
  • Flux.merge(Publisher<? extends Publisher<? extends T>> source, int concurrency): 接受一个发射 Publisher 的 Publisher，并设置并发度来限制同时处理的 Publisher 的数量。

10. 性能优化

  • 控制并发: 如果你需要对并发数量进行控制，可以使用 merge 的其他重载版本，例如 merge(Publisher<? extends Publisher<? extends T>> source, int concurrency)，其中 concurrency 参数控制同时处理的 Publisher 数量。这样你可以防止系统资源被过度占用。
  • 流量控制: 对于大规模数据流的合并，可以结合使用 prefetch 参数来控制每个 Publisher 的数据预取量，从而优化内存和性能。

11. 总结

  • Flux.merge(Publisher<? extends I>... sources) 是一个非常灵活且并发友好的方法，允许你将多个 Publisher 合并为一个 Flux。
  • 它不保证顺序，会并行处理每个 Publisher，因此适合高效的异步并行任务。
  • 通过 @SafeVarargs 注解消除了泛型可变参数的警告。
  • 如果你需要顺序处理，可以考虑使用 Flux.concat，否则 merge 提供了高性能的并行数据合并功能。

merge

@SafeVarargs
public static <I> Flux<I> merge(int prefetch,
                                             Publisher<? extends I>... sources)
Merge data from  Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike  concat, sources are subscribed to eagerly.

将来自数组或可变参数中的多个 Publisher 序列的数据合并为一个交错的合并序列。与 concat 不同，源会被立即订阅。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理一个无限源时，如果该源并未在专用的 Scheduler 上发布，则必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将尝试在订阅其他源之前先耗尽该源的所有数据。

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the array of  Publisher sources to merge
prefetch - the inner source request size

Returns:

a fresh Reactive  Flux publisher ready to be subscribed

类型参数：

I - 数据序列的源类型。

参数说明：

sources - 要合并的 Publisher 源的数组。
prefetch - 内部源的请求大小。

返回值：

返回一个新的 Reactive Flux 发布者，准备好进行订阅。 

@SafeVarargs public static <I> Flux<I> merge(int prefetch, Publisher<? extends I>... sources)

是 Reactor 中的一个方法，用于合并多个 Publisher，并允许你指定 prefetch 参数来控制每个 Publisher 中的预取数据量。

1. 方法介绍

  • merge(int prefetch, Publisher<? extends I>... sources): 该方法将多个 Publisher（如 Flux、Mono）合并为一个并行发射数据的 Flux，并且允许通过 prefetch 参数控制每个 Publisher 预取的数据量。预取指的是在请求下游订阅之前，提前从上游请求的数据数量，这样可以提高吞吐量，减少上下游交互的延迟。

2. 参数

  • prefetch: 这是一个整数，指定从每个 Publisher 预取的数据量。它定义了从源 Publisher 中提前获取并缓存的数据的数量。在并行合并的情况下，合理设置 prefetch 值有助于提升性能。
  • sources: 这是一个可变参数，表示多个 Publisher（如 Flux 或 Mono）。这些 Publisher 的数据会被并行合并为一个 Flux，并按最早可用的数据发射给下游。

3. 返回值

  • Flux<I>: 返回一个 Flux，它将从所有输入的 Publisher 中并行地获取数据，并将合并后的数据发射给下游的订阅者。

4. @SafeVarargs 注解

@SafeVarargs 注解是为了避免在编译时对使用可变参数泛型时发出的 "堆污染" 警告。由于该方法使用了可变参数的泛型，@SafeVarargs 注解告诉编译器这种使用是安全的，不需要发出警告。

5. 示例代码

假设我们有多个 Mono，并希望使用 merge 方法进行合并，同时通过 prefetch 控制预取的数据量：

java

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

public class FluxMergeWithPrefetchExample {
    public static void main(String[] args) {
        // 创建多个 Mono
        Mono<String> mono1 = Mono.just("A");
        Mono<String> mono2 = Mono.just("B");
        Mono<String> mono3 = Mono.just("C");

        // 使用 merge 方法合并多个 Mono，指定 prefetch 为 1
        Flux<String> mergedFlux = Flux.merge(1, mono1, mono2, mono3);

        // 订阅并打印合并后的结果
        mergedFlux.subscribe(System.out::println);
    }
}

输出结果：

A
B
C

在这个例子中，我们创建了三个 Mono，通过 Flux.merge(1, mono1, mono2, mono3) 将它们合并。这里的 prefetch 值为 1，表示每个 Publisher 最多一次只预取一个数据项。

6. 使用场景

  • 高效处理多个异步流: 当你需要合并多个异步流，并希望通过调整预取量来优化吞吐量时，可以使用这个方法。例如，当下游消费速度较慢时，可以设置较小的 prefetch 值，以减少内存占用；而当下游消费速度较快时，可以增加 prefetch 值以提高性能。
  • 网络请求: 在处理多个异步网络请求时，合理设置 prefetch 可以优化带宽使用和请求响应时间。

7. 特点

  • 并行处理: 该方法与其他 merge 方法一样，是并行处理的。它会从多个 Publisher 中并行获取数据，并立即发射最早可用的数据。
  • 控制预取: 通过 prefetch 参数，可以控制从每个 Publisher 中提前请求的数据量。合理的 prefetch 设置能够平衡内存使用与处理速度之间的关系。

8. 与其他 merge 方法的区别

  • merge(Publisher<? extends I>... sources): 该方法直接合并多个 Publisher，但没有提供控制预取量的能力。
  • merge(int prefetch, Publisher<? extends I>... sources): 在前者的基础上，增加了对 prefetch 的控制，允许更灵活的资源管理。

9. 性能调优

prefetch 参数是性能调优的关键点之一，特别是在处理大量数据时。

  • 小的 prefetch 值: 适合需要减少内存占用的情况，特别是在每个 Publisher 发射大量数据时，较小的 prefetch 值能控制数据的积累速度，避免过多的数据积压在内存中。
  • 大的 prefetch 值: 适合下游消费速度较快的情况，大的 prefetch 值能减少上游和下游之间的交互次数，进而提高吞吐量。

10. 相关方法

  • Flux.merge(Publisher<? extends I>... sources): 合并多个 Publisher，不设置 prefetch 参数。
  • Flux.concat(Publisher<? extends I>... sources): 按顺序合并多个 Publisher，即等待一个 Publisher 完成后，再处理下一个 Publisher，适用于需要按顺序处理的数据流。
  • Flux.merge(Iterable<? extends Publisher<? extends I>> sources, int concurrency, int prefetch): 这是一个更高级的合并方法，允许同时控制并发度和预取量，适合处理大量并发流的场景。

11. 总结

  • Flux.merge(int prefetch, Publisher<? extends I>... sources) 是 Reactor 中一个强大的方法，允许你并行合并多个 Publisher，并通过 prefetch 参数控制预取量。
  • 它非常适合在处理多个异步任务时优化内存占用和吞吐量。
  • @SafeVarargs 注解确保可变参数泛型的使用是安全的，避免了编译时的警告。
  • 通过合理设置 prefetch，可以有效提升应用的性能，特别是在需要处理大量异步数据流的场景中。

这个方法适合需要对合并后的异步流进行性能优化的场景，特别是在大量数据需要同时被处理时，可以通过控制预取量来最大化系统的吞吐量并减少资源浪费。

mergeDelayError

@SafeVarargs
public static <I> Flux<I> mergeDelayError(int prefetch,
                                                       Publisher<? extends I>... sources)
Merge data from  Publisher sequences contained in an array / vararg into an interleaved merged sequence. Unlike  concat, sources are subscribed to eagerly. This variant will delay any error until after the rest of the merge backlog has been processed.

将来自数组或可变参数中的多个 Publisher 序列的数据合并为一个交错的合并序列。与 concat 不同，源会被立即订阅。此变体将在处理完其他合并积压数据后，才会延迟任何错误的发出。

Note that merge is tailored to work with asynchronous sources or finite sources. When dealing with an infinite source that doesn't already publish on a dedicated Scheduler, you must isolate that source in its own Scheduler, as merge would otherwise attempt to drain it before subscribing to another source.

请注意，merge 是专门为异步源或有限源设计的。在处理一个无限源时，如果该源并未在专用的 Scheduler 上发布，则必须将该源隔离到其自己的 Scheduler 中，因为如果不这样做，merge 将尝试在订阅其他源之前先耗尽该源的所有数据。

Type Parameters:

I - The source type of the data sequence

Parameters:

sources - the array of  Publisher sources to merge
prefetch - the inner source request size

Returns:

a fresh Reactive  Flux publisher ready to be subscribed

类型参数：

I - 数据序列的源类型。

参数说明：

sources - 要合并的 Publisher 源的数组。
prefetch - 内部源的请求大小。

返回值：

返回一个新的 Reactive Flux 发布者，准备好进行订阅。 

@SafeVarargs public static <I> Flux<I> mergeDelayError(int prefetch, Publisher<? extends I>... sources)

是 Reactor 提供的一种特殊合并方法，用于并行合并多个 Publisher，并且允许处理多个错误而不会立即终止整个流。

它与 merge 方法的不同之处在于它会延迟抛出错误，而不是一旦遇到错误就中断整个流。

1. 方法简介

  • mergeDelayError(int prefetch, Publisher<? extends I>... sources)：此方法将多个 Publisher 合并为一个并行发射数据的 Flux，但与普通的 merge 不同的是，当合并的 Publisher 中有任何一个发生错误时，它不会立即终止流，而是继续处理其他数据源，直到所有数据源都结束后才发出错误。这对于容错性要求较高的场景非常有用。

2. 参数

  • prefetch：这是一个整数值，用来控制从每个 Publisher 中提前请求和缓存的数据量。它的设置会影响并行流的吞吐量和内存占用。
  • sources：多个 Publisher 作为输入，可以是 Flux 或 Mono，表示你想要合并的异步数据源。可变参数形式，允许你传入多个 Publisher。

3. 返回值

  • Flux<I>：返回一个 Flux，它将所有输入的 Publisher 合并，并发射来自每个 Publisher 的数据，直到所有数据源发射完毕（包括延迟处理错误）。

4. @SafeVarargs 注解

@SafeVarargs 是一个用于抑制编译器在可变参数泛型方法上的“堆污染”警告的注解。这是因为 Publisher 是泛型参数，并且使用了可变参数。

5. 错误处理的特点

与 merge 不同，mergeDelayError 不会在一个数据源出错时立即终止流。相反，它会等所有数据源都完成，才发出错误信号。这使得它适合在某些数据源可能失败，但不希望整个合并操作中断的场景中使用。例如：

  • 网络请求：多个 API 请求中的某些可能会失败，但你希望尽可能地处理成功的请求，并在所有请求完成后再统一处理错误。
  • 异步任务：并行处理多个任务时，某些任务可能会失败，但你希望先完成剩余的任务，然后再处理失败的任务。

6. 示例代码

假设我们有多个 Mono，其中有些可能抛出错误，但我们希望使用 mergeDelayError 合并它们，并且只在所有数据源处理完后才抛出错误：

java

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

public class FluxMergeDelayErrorExample {
    public static void main(String[] args) {
        // 创建多个 Mono，其中一个会抛出错误
        Mono<String> mono1 = Mono.just("A");
        Mono<String> mono2 = Mono.error(new RuntimeException("Error occurred in Mono2"));
        Mono<String> mono3 = Mono.just("C");

        // 使用 mergeDelayError 方法，指定 prefetch 为 1
        Flux<String> mergedFlux = Flux.mergeDelayError(1, mono1, mono2, mono3);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println, // 打印成功结果
            error -> System.err.println("Error: " + error) // 处理错误
        );
    }
}

输出结果：

A
C
Error: java.lang.RuntimeException: Error occurred in Mono2

在这个例子中，mono2 会抛出一个错误，但 mergeDelayError 会延迟处理错误，先输出 mono1 和 mono3 的数据，最后才输出错误。

7. 使用场景

  • 容错性应用：当多个数据源并行发射数据时，某些数据源可能会发生错误，但你希望能继续处理其他数据，而不是立即中断。例如，多个服务调用，其中某些可能会失败。
  • 日志收集：在收集多台服务器的日志时，如果某台服务器无法访问，你可以使用 mergeDelayError 来确保其他服务器的数据仍然可以正常收集。
  • 数据处理流水线：在处理多个数据流的场景下，即使某些流出现问题，也不希望整个流水线停止。

8. 特点

  • 错误延迟处理：在遇到错误时不会立即中断流，而是等待其他 Publisher 处理完毕后再发出错误。
  • 并行合并：与普通的 merge 一样，mergeDelayError 也是并行处理多个数据源，因此可以处理异步任务的高并发场景。
  • 控制预取：通过 prefetch 参数可以控制从每个 Publisher 中提前获取和缓存的数据量，这样可以优化内存使用和吞吐量。

9. 与其他方法的区别

  • merge(Publisher<? extends I>... sources)：立即中断错误，遇到错误时立刻停止数据流并发出错误信号。
  • mergeDelayError(Publisher<? extends I>... sources)：延迟处理错误，继续处理其他 Publisher 的数据，直到所有数据源都结束后再发出错误。
  • concat(Publisher<? extends I>... sources)：按顺序合并多个 Publisher，等待前一个完成后再处理下一个。
  • mergeDelayError(Iterable<? extends Publisher<? extends I>> sources)：与可变参数形式类似，但接受的是 Iterable 集合的输入。

10. 性能调优

  • prefetch 的作用：prefetch 参数控制从每个 Publisher 中提前获取的数据量，较小的 prefetch 值会减少内存占用，但可能导致性能下降；较大的 prefetch 值会提升吞吐量，但可能会占用更多内存。通过合理设置 prefetch，可以根据具体应用场景优化内存使用和性能。

11. 总结

  • mergeDelayError 是一种延迟错误处理的合并方法，允许在多个 Publisher 并行发射数据的过程中延迟处理错误，直到所有数据源都完成后才统一抛出错误。这使得它非常适合容错性强的场景。
  • 通过 prefetch 参数，可以控制从每个 Publisher 中预取的数据量，以优化内存占用和性能。
  • 该方法可以有效提升在异步环境中处理多个数据流时的容错性，使得即使某些任务失败，仍能保证其他任务的正常进行。

mergePriority

@SafeVarargs
public static <I extends Comparable<? super I>> Flux<I> mergePriority(Publisher<? extends I>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by their natural order)  as they arrive. This is not a  sort(), as it doesn't consider the whole of each sequences. Unlike mergeComparing, this operator does  not wait for a value from each source to arrive either.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过从每个源中选择到达的最小值（按照其自然顺序定义）。这不是 sort() 操作，因为它并不考虑每个序列的全部内容。与 mergeComparing 不同，这个操作符也不等待每个源的值到达。

While this operator does retrieve at most one value from each source, it only compares values when two or more sources emit at the same time. In that case it picks the smallest of these competing values and continues doing so as long as there is demand. It is therefore best suited for asynchronous sources where you do not want to wait for a value from each source before emitting a value downstream.

虽然这个操作符最多只能从每个源检索一个值，但它只在两个或多个源同时发出时进行比较。在这种情况下，它会选择这些竞争值中最小的一个，并在存在需求时持续执行此操作。因此，它最适合用于异步源，因为在发出下游值之前，您不希望等待每个源的值。

Type Parameters:

I - a  Comparable merged type that has a  natural order

Parameters:

sources -  Publisher sources of  Comparable to merge

Returns:

a merged  Flux that compares the latest available value from each source, publishing the smallest value and replenishing the source that produced it.

类型参数：

I - 具有自然顺序的可比较合并类型。

参数说明：

sources - 要合并的可比较类型的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新可用值，发布最小值，并补充产生该值的源。 

@SafeVarargs 
public static <I extends Comparable<? super I>> Flux<I> mergePriority(Publisher<? extends I>... sources)

是一种自定义的合并方法，它的特点是按优先级顺序（通过元素的自然顺序或指定的排序规则）合并多个 Publisher，即使它们发射数据的顺序不同。

1. 方法简介

  • mergePriority(Publisher<? extends I>... sources)：将多个 Publisher 合并为一个 Flux，并且基于每个元素的优先级（实现 Comparable 接口）按顺序发射数据。这对于需要按照特定顺序输出结果的场景非常有用，例如按优先级排序的任务调度或数据流合并。

2. 参数说明

  • <I extends Comparable<? super I>：这个泛型参数说明了 I 必须实现 Comparable 接口，因此，I 类型的实例可以被排序。这意味着合并时，系统可以根据数据项的自然顺序来确定发射顺序。
  • sources：多个 Publisher，它们是数据源，发射出需要被合并的 I 类型数据。使用可变参数形式，可以接收多个 Publisher。

3. 返回值

  • Flux<I>：返回一个 Flux，它将所有输入的 Publisher 合并，并按照优先级顺序发射数据。

4. @SafeVarargs 注解

@SafeVarargs 注解用于抑制可变参数泛型数组使用时的编译器警告，避免潜在的堆污染问题。这里的 Publisher<? extends I>... sources 使用了泛型的可变参数，因此需要使用此注解。

5. 典型使用场景

  • 优先级任务处理：多个任务流按照优先级进行并行处理，你可以将每个任务流表示为一个 Publisher，合并时将按优先级顺序处理。
  • 实时数据排序：在从不同的数据源接收实时数据时，需要根据时间戳、大小或其他特定规则对数据进行合并排序。
  • 多源数据聚合：从多个服务获取数据时，需要按某个字段（例如时间、价格等）合并并按顺序输出。

6. 实现思路

要实现这个方法，背后的逻辑大致如下：

  • 每个 Publisher 发射的数据需要实现 Comparable 接口，这样我们就可以对它们的发射结果进行排序。
  • 在合并多个 Publisher 时，使用一个优先级队列（如 PriorityQueue），每当有新数据发射时，将数据放入队列中，根据优先级对队列中的数据进行排序。
  • 每次从队列中取出优先级最高的元素并发射出去，直到所有 Publisher 的数据都处理完毕。

7. 示例代码

假设我们有两个 Flux，其中发射的数据是 Integer 类型，我们希望按照升序合并这些数据流，即使它们发射的顺序不同：

java

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import java.time.Duration;

public class MergePriorityExample {
    public static void main(String[] args) {
        // Flux 1 发射 5 和 2Flux<Integer> flux1 = Flux.just(5, 2).delayElements(Duration.ofMillis(500));

        // Flux 2 发射 7 和 3Flux<Integer> flux2 = Flux.just(7, 3).delayElements(Duration.ofMillis(300));

        // 使用 mergePriority 方法合并并排序Flux<Integer> mergedFlux = mergePriority(flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println);
    }

    @SafeVarargspublic static <I extends Comparable<? super I>> Flux<I> mergePriority(Publisher<? extends I>... sources) {
        return Flux.merge(sources) // 合并所有 Publisher
                   .sort();         // 对合并后的数据流进行排序
    }
}

在这个例子中，mergePriority 使用了 Flux.merge 先将两个 Flux 合并为一个数据流，然后使用 sort() 方法对合并后的数据进行排序。输出的结果将是按升序排列的：

2
3
5
7

8. 注意事项

  • 排序开销：mergePriority 需要对合并的数据进行排序，因此可能会带来一定的性能开销，特别是在数据量较大的情况下。要确保对 Comparable 的实现是高效的。
  • 排序规则：这个方法依赖于 I 实现的 Comparable 接口，如果你希望自定义排序规则，可以在 Comparable 实现中定义。

9. 高级场景

在一些复杂场景下，你可能希望基于多个字段或自定义逻辑来定义优先级。在这种情况下，Comparable 的自然顺序可能不够用，你可以借助 Comparator 来实现更灵活的排序。

例如，假设你有一个 Task 类，并且希望按任务的优先级来合并任务流：

java

import java.util.Comparator;

public class Task implements Comparable<Task> {
    private int priority;
    private String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    @Override
    public int compareTo(Task other) {
        return Integer.compare(this.priority, other.priority);
    }

    @Override
    public String toString() {
        return "Task{name='" + name + "', priority=" + priority + '}';
    }

    public static void main(String[] args) {
        Flux<Task> taskFlux1 = Flux.just(new Task(3, "Task1"), new Task(1, "Task2"));
        Flux<Task> taskFlux2 = Flux.just(new Task(2, "Task3"), new Task(4, "Task4"));

        // 合并任务流并按优先级排序
        Flux<Task> mergedTaskFlux = mergePriority(taskFlux1, taskFlux2);

        // 订阅并打印任务
        mergedTaskFlux.subscribe(System.out::println);
    }
}

在这个例子中，Task 类实现了 Comparable 接口，基于任务的 priority 字段定义了排序规则。mergePriority 会将所有任务按照优先级合并并排序。

10. 总结

  • mergePriority 是一种按优先级合并多个数据流的方法，通过元素的自然顺序（实现 Comparable 接口）来控制数据发射的顺序。
  • 这种方法特别适用于需要按优先级或时间顺序处理任务或数据的场景，例如任务调度或实时数据流排序。
  • 实现时可以使用 Flux.merge 来合并多个 Publisher，并结合 sort() 来确保按优先级顺序发射数据。
  • 对于性能敏感的应用，应根据数据量和排序复杂度调整实现方式，可能需要优化排序算法。

mergePriority

@SafeVarargs
public static <T> Flux<T> mergePriority(Comparator<? super T> comparator,
                                                     Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator)  as they arrive. This is not a  sort(Comparator), as it doesn't consider the whole of each sequences. Unlike mergeComparing, this operator does  not wait for a value from each source to arrive either.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择到达的最小值（按照提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。与 mergeComparing 不同，这个操作符也不等待每个源的值到达。

While this operator does retrieve at most one value from each source, it only compares values when two or more sources emit at the same time. In that case it picks the smallest of these competing values and continues doing so as long as there is demand. It is therefore best suited for asynchronous sources where you do not want to wait for a value from each source before emitting a value downstream.

虽然这个操作符最多只能从每个源检索一个值，但它只在两个或多个源同时发出时进行比较。在这种情况下，它会选择这些竞争值中最小的一个，并在存在需求时持续执行此操作。因此，它最适合用于异步源，因为在发出下游值之前，您不希望等待每个源的值。

Type Parameters:

T - the merged type

Parameters:

comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares the latest available value from each source, publishing the smallest value and replenishing the source that produced it.

类型参数：

T - 合并后的类型。

参数说明：

comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新可用值，发布最小值，并补充产生该值的源。 

mergePriority(Comparator<? super T> comparator, Publisher<? extends T>... sources)

是 Flux 类中的一个静态方法。它用于合并多个 Publisher，并根据提供的比较器 (Comparator) 优先排序流中的元素。

该方法允许你将来自不同 Publisher 的数据合并到一个 Flux 中，并根据指定的规则来处理元素的顺序。

1. 方法简介

  • mergePriority：合并多个 Publisher 的数据流，并根据给定的比较器确定元素的优先级，确保合并后的 Flux 按照比较器的规则顺序发出元素。

2. 参数说明

  • comparator：Comparator<? super T>，一个用于比较流中元素的比较器。它定义了如何比较来自不同 Publisher 的元素，从而决定合并后的顺序。
  • sources：一个可变参数的 Publisher 数组，表示多个待合并的 Publisher。这些 Publisher 可能是异步产生数据的流。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，合并的元素会根据比较器的规则优先发出。

4. 使用场景

  • 优先级排序：当
  • 需要合并多个数据流，并希望在合并后按照特定顺序处理时，可以使用这个方法。比如多个数据源提供不同的优先级任务，按照任务的重要性合并处理。
  • 动态优先级：当数据的发出顺序需要动态变化时，可以使用自定义比较器来调整优先级。

5. 示例代码

下面是一个使用 mergePriority 的简单示例，通过自定义比较器合并多个 Publisher 的元素，并优先处理较小的数值。

java

import reactor.core.publisher.Flux;
import java.util.Comparator;
import java.time.Duration;

public class MergePriorityExample {
    public static void main(String[] args) {
        // 定义多个 Flux，其中包含不同的数据流
        Flux<Integer> flux1 = Flux.just(5, 3, 1).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(8, 6, 2).delayElements(Duration.ofMillis(200));

        // 定义一个比较器，用于优先排序元素
        Comparator<Integer> comparator = Comparator.naturalOrder();

        // 使用 mergePriority 合并 Flux，按自然顺序优先处理较小的数值
        Flux<Integer> mergedFlux = mergePriority(comparator, flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    @SafeVarargs
    public static <T> Flux<T> mergePriority(Comparator<? super T> comparator,
                                             Publisher<? extends T>... sources) {
        return Flux.merge(sources)
                   .sort(comparator);
    }
}

6. 代码解析

在这个例子中：

  • flux1 和 flux2：定义了两个不同的 Flux，分别包含不同的整数数据。flux1 包含 5, 3, 1，flux2 包含 8, 6, 2。这些流元素是异步发出的。
  • Comparator.naturalOrder()：使用了一个自然排序的比较器，用于按数值从小到大排序。
  • mergePriority 方法：使用该方法将 flux1 和 flux2 合并，并确保输出的顺序遵循比较器的规则。在这里，它会优先发出较小的数值。

7. 特性与优势

  • 排序合并：与其他合并方法不同，mergePriority 允许根据自定义的规则（通过比较器）来控制元素的发出顺序。
  • 灵活的优先级：通过自定义比较器，开发者可以灵活控制不同 Publisher 中元素的优先顺序，适应各种业务场景。
  • 异步流的排序处理：即使多个流的元素是异步产生的，也可以通过此方法确保合并后的数据流按指定顺序处理。

8. 注意事项

  • 性能开销：由于需要对合并的元素进行排序，因此在处理大量数据时，可能会带来一定的性能开销，尤其是在流速度较快的情况下。
  • 比较器的设计：如果比较器的逻辑过于复杂，可能会影响流处理的速度，开发者需要在设计比较器时权衡性能和功能需求。

9. 高级用法

你可以结合更复杂的比较器逻辑来实现更加复杂的排序需求。例如，如果你有多个属性需要同时排序，可以使用 Comparator.comparing 来实现。

java

Comparator<MyObject> comparator = Comparator.comparing(MyObject::getPriority)
                                            .thenComparing(MyObject::getTimestamp);

通过这种方式，你可以根据多个字段的优先级进行排序，适应更复杂的业务场景。

10. 总结

mergePriority(Comparator<? super T> comparator, Publisher<? extends T>... sources) 方法为开发者提供了一种灵活的方式来合并多个数据流，并且能够根据自定义的优先级规则处理流中的元素。在处理需要按照优先级排序的异步任务或数据流时，这个方法非常有用。同时，通过自定义比较器，开发者可以轻松适配各种不同的业务场景，从而实现更加精细化的流控制。

mergePriority

@SafeVarargs
public static <T> Flux<T> mergePriority(int prefetch,
                                                     Comparator<? super T> comparator,
                                                     Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator)  as they arrive. This is not a  sort(Comparator), as it doesn't consider the whole of each sequences. Unlike mergeComparing, this operator does  not wait for a value from each source to arrive either.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择到达的最小值（按照提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。与 mergeComparing 不同，这个操作符也不等待每个源的值到达。

While this operator does retrieve at most one value from each source, it only compares values when two or more sources emit at the same time. In that case it picks the smallest of these competing values and continues doing so as long as there is demand. It is therefore best suited for asynchronous sources where you do not want to wait for a value from each source before emitting a value downstream.

虽然这个操作符最多只能从每个源检索一个值，但它只在两个或多个源同时发出时进行比较。在这种情况下，它会选择这些竞争值中最小的一个，并在有需求时持续执行此操作。因此，它最适合用于异步源，因为在发出下游值之前，您不希望等待每个源的值。

Type Parameters:

T - the merged type

Parameters:

prefetch - the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)
comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares the latest available value from each source, publishing the smallest value and replenishing the source that produced it.

类型参数：

T - 合并后的类型。

参数说明：

prefetch - 从每个源预取的元素数量（以避免在选择时向源发送过多的小请求）。
comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新可用值，发布最小值，并补充产生该值的源。 

@SafeVarargs 
public static <T> Flux<T> mergePriority(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)

是一个结合优先级排序和数据流合并的强大工具，适用于处理多个 Publisher 数据源并希望按特定顺序发射结果的场景。

1. 方法简介

  • mergePriority(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)：该方法将多个 Publisher 合并为一个 Flux，并根据指定的比较器（Comparator）控制数据的发射顺序。

2. 参数说明

  • prefetch：用于指定在合并过程中预先请求的元素数量。这有助于控制背压，并优化数据流的处理效率。预取的数量可以影响到流的性能，较大的值可能会提高吞吐量，但也可能导致内存使用增加。
  • comparator：一个 Comparator 对象，用于定义如何比较和排序 T 类型的元素。通过提供自定义比较器，可以实现灵活的排序规则，而不只是依赖于元素的自然顺序。
  • sources：可变参数形式，表示多个 Publisher，这些 Publisher 将被合并并排序。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并根据指定的比较器按顺序发射数据。

4. @SafeVarargs 注解

@SafeVarargs 注解用于表明该方法的可变参数是安全的，避免在使用时产生潜在的堆污染问题。因为 Publisher<? extends T>... sources 是一个泛型数组，所以使用此注解是必要的。

5. 典型使用场景

  • 多源数据排序：当你从多个数据源获取数据时，可能希望按特定字段（例如时间戳、优先级等）进行合并排序。例如，实时处理来自多个服务的任务或事件。
  • 任务调度：在调度任务时，可以将不同任务流的优先级考虑在内，确保更高优先级的任务先被执行。
  • 复杂数据聚合：在聚合来自不同服务的数据时，可能需要按某个复杂规则合并，比如结合多个字段的值进行排序。

6. 实现思路

在实现这个方法时，核心逻辑可以是：

  1. 创建优先级队列：使用优先级队列（如 PriorityQueue）来存储来自不同 Publisher 的数据流。优先级队列会根据提供的 Comparator 对元素进行排序。
  2. 合并数据流：利用 Flux.merge() 将所有 Publisher 的数据流合并，按顺序将发射的元素放入优先级队列。
  3. 按顺序发射元素：从优先级队列中按顺序取出元素并发射，直到所有数据处理完毕。

7. 示例代码

下面是一个使用 mergePriority 方法的示例，展示如何根据自定义的比较器合并多个 Publisher 数据流：

java

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

import java.util.Comparator;

public class MergePriorityExample {
    public static void main(String[] args) {
        // Flux 1 发射一些整数Flux<Integer> flux1 = Flux.just(5, 1, 4).delayElements(Duration.ofMillis(300));

        // Flux 2 发射一些整数Flux<Integer> flux2 = Flux.just(3, 2, 6).delayElements(Duration.ofMillis(200));

        // 使用 mergePriority 方法合并并按降序排序Flux<Integer> mergedFlux = mergePriority(2, Comparator.reverseOrder(), flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println);
    }

    @SafeVarargspublic static <T> Flux<T> mergePriority(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources) {
        // 这里可以实现具体的合并逻辑return Flux.merge(sources)
                   .sort(comparator)
                   .prefetch(prefetch);
    }
}

在这个例子中：

  • 我们有两个 Flux，分别发射一些整数，flux1 和 flux2。
  • 使用 mergePriority 方法将这两个 Flux 合并，并指定了一个降序的比较器。
  • 最后，合并后的结果将被打印出来。

8. 注意事项

  • 性能开销：使用自定义比较器可能会带来一定的性能开销，尤其是在数据量较大时。确保比较器的实现高效且简洁。
  • 内存使用：预取数量 (prefetch) 的设置需要根据实际应用场景来调整，以平衡性能和内存使用。
  • 错误处理：在使用合并方法时，确保对可能出现的错误进行适当的处理，尤其是涉及多个 Publisher 时，某个 Publisher 发生错误可能会影响整个合并结果。

9. 高级场景

在复杂的应用场景中，可能需要根据多个字段或更复杂的规则来定义排序。可以通过自定义比较器来实现这样的功能。例如，你可以定义一个对象类型，并基于多个属性进行排序。

java

import java.util.Comparator;

class Task {
    private final int priority;
    private final String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Task{" + "priority=" + priority + ", name='" + name + '\'' + '}';
    }
}

public static void main(String[] args) {
    Flux<Task> taskFlux1 = Flux.just(new Task(3, "Task A"), new Task(1, "Task B"));
    Flux<Task> taskFlux2 = Flux.just(new Task(2, "Task C"), new Task(4, "Task D"));

    // 按优先级合并任务流
    Flux<Task> mergedTaskFlux = mergePriority(2,
            Comparator.comparingInt(Task::getPriority),
            taskFlux1, taskFlux2);

    // 订阅并打印任务
    mergedTaskFlux.subscribe(System.out::println);
}

在这个例子中，我们定义了一个 Task 类，包含优先级和名称字段。我们使用 Comparator.comparingInt(Task::getPriority) 来按照优先级合并任务。

10. 总结

  • mergePriority 方法提供了一种灵活的方式来合并多个 Publisher，并根据自定义的比较器对发射的结果进行排序。
  • 通过 prefetch 参数可以优化数据流的处理效率。
  • 实现过程中需要考虑性能、内存使用和错误处理等问题，确保在多数据源环境下的稳定性和效率。

mergePriorityDelayError

@SafeVarargs
public static <T> Flux<T> mergePriorityDelayError(int prefetch,
                                                               Comparator<? super T> comparator,
                                                               Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator)  as they arrive. This is not a  sort(Comparator), as it doesn't consider the whole of each sequences. Unlike mergeComparing, this operator does  not wait for a value from each source to arrive either.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择到达的最小值（按照提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。与 mergeComparing 不同，这个操作符也不等待每个源的值到达。

While this operator does retrieve at most one value from each source, it only compares values when two or more sources emit at the same time. In that case it picks the smallest of these competing values and continues doing so as long as there is demand. It is therefore best suited for asynchronous sources where you do not want to wait for a value from each source before emitting a value downstream.

虽然这个操作符最多只能从每个源检索一个值，但它只在两个或多个源同时发出时进行比较。在这种情况下，它会选择这些竞争值中最小的一个，并在存在需求时持续执行此操作。因此，它最适合用于异步源，因为在发出下游值之前，您不希望等待每个源的值。

Note that it is delaying errors until all data is consumed.

请注意，它会延迟错误的发出，直到所有数据被消费完毕。

Type Parameters:

T - the merged type
Parameters:
prefetch - the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)
comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares the latest available value from each source, publishing the smallest value and replenishing the source that produced it.

类型参数：

T - 合并后的类型。

参数说明：

prefetch - 从每个源预取的元素数量（以避免在选择时向源发送过多的小请求）。
comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新可用值，发布最小值，并补充产生该值的源。 

@SafeVarargs 
public static <T> Flux<T> mergePriorityDelayError(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)

是一个结合优先级排序和错误处理的强大工具，适用于处理多个 Publisher 数据源时希望按特定顺序发射结果，同时也允许延迟错误通知的场景。

1. 方法简介

  • mergePriorityDelayError(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)：该方法将多个 Publisher 合并为一个 Flux，并根据指定的比较器控制数据的发射顺序，同时在合并过程中延迟错误的通知。

2. 参数说明

  • prefetch：指定在合并过程中预先请求的元素数量，有助于控制背压，并优化数据流的处理效率。
  • comparator：一个 Comparator 对象，用于定义如何比较和排序 T 类型的元素。提供自定义比较器可以实现灵活的排序规则。
  • sources：可变参数形式，表示多个 Publisher，这些 Publisher 将被合并并排序。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并根据指定的比较器按顺序发射数据，同时延迟错误的通知，直到所有数据都被发射完。

4. @SafeVarargs 注解

@SafeVarargs 注解用于表明该方法的可变参数是安全的，避免在使用时产生潜在的堆污染问题。

5. 典型使用场景

  • 多源数据排序：在从多个数据源获取数据时，可能希望按特定字段（例如时间戳、优先级等）进行合并排序，并且想要优雅地处理可能出现的错误。
  • 任务调度：在调度任务时，可以将不同任务流的优先级考虑在内，确保更高优先级的任务先被执行，同时不立即中断流的处理。
  • 复杂数据聚合：在聚合来自不同服务的数据时，可能需要按某个复杂规则合并，并考虑错误处理的需求。

6. 实现思路

在实现这个方法时，核心逻辑可以是：

  1. 创建优先级队列：使用优先级队列（如 PriorityQueue）来存储来自不同 Publisher 的数据流。优先级队列会根据提供的比较器对元素进行排序。
  2. 合并数据流：利用 Flux.mergeDelayError() 将所有 Publisher 的数据流合并，按顺序将发射的元素放入优先级队列。
  3. 按顺序发射元素：从优先级队列中按顺序取出元素并发射，同时处理可能出现的错误，确保错误在数据流处理完后再被通知。

7. 示例代码

下面是一个使用 mergePriorityDelayError 方法的示例，展示如何根据自定义的比较器合并多个 Publisher 数据流，并处理可能的错误：

java

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

import java.time.Duration;
import java.util.Comparator;

public class MergePriorityDelayErrorExample {
    public static void main(String[] args) {
        // Flux 1 发射一些整数，第二个元素抛出错误
        Flux<Integer> flux1 = Flux.just(5, 1, 4)
                                   .delayElements(Duration.ofMillis(300))
                                   .concatWith(Mono.error(new RuntimeException("Error in Flux 1")));

        // Flux 2 正常发射一些整数
        Flux<Integer> flux2 = Flux.just(3, 2, 6)
                                   .delayElements(Duration.ofMillis(200));

        // 使用 mergePriorityDelayError 方法合并并按降序排序
        Flux<Integer> mergedFlux = mergePriorityDelayError(2, 
            Comparator.reverseOrder(), 
            flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    @SafeVarargspublic static <T> Flux<T> mergePriorityDelayError(int prefetch, 
                                                       Comparator<? super T> comparator, 
                                                       Publisher<? extends T>... sources) {
        return Flux.mergeDelayError(sources)
                   .sort(comparator)
                   .prefetch(prefetch);
    }
}

在这个例子中：

  • 我们定义了两个 Flux，flux1 在发射第二个元素时抛出错误，flux2 正常发射一些整数。
  • 使用 mergePriorityDelayError 方法将这两个 Flux 合并，并指定了一个降序的比较器。
  • 订阅结果时，我们提供了对成功结果和错误的处理，确保可以正确捕获到合并过程中的错误。

8. 注意事项

  • 性能开销：使用自定义比较器和延迟错误处理可能会带来一定的性能开销，尤其是在数据量较大时。确保比较器的实现高效且简洁。
  • 内存使用：预取数量 (prefetch) 的设置需要根据实际应用场景来调整，以平衡性能和内存使用。
  • 错误处理：延迟错误通知可能会导致在流处理过程中出现多个错误。确保适当地处理这些错误，避免应用崩溃或不稳定。

9. 高级场景

在复杂的应用场景中，可能需要根据多个字段或更复杂的规则来定义排序。可以通过自定义比较器来实现这样的功能。例如，可以定义一个对象类型，并基于多个属性进行排序。

java

import java.util.Comparator;

class Task {
    private final int priority;
    private final String name;

    public Task(int priority, String name) {
        this.priority = priority;
        this.name = name;
    }

    public int getPriority() {
        return priority;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Task{" + "priority=" + priority + ", name='" + name + '\'' + '}';
    }
}

public static void main(String[] args) {
    Flux<Task> taskFlux1 = Flux.just(new Task(3, "Task A"), new Task(1, "Task B"));
    Flux<Task> taskFlux2 = Flux.just(new Task(2, "Task C"), new Task(4, "Task D"));

    // 按优先级合并任务流
    Flux<Task> mergedTaskFlux = mergePriorityDelayError(2,
            Comparator.comparingInt(Task::getPriority),
            taskFlux1, taskFlux2);

    // 订阅并打印任务
    mergedTaskFlux.subscribe(System.out::println);
}

在这个例子中，我们定义了一个 Task 类，包含优先级和名称字段。使用 Comparator.comparingInt(Task::getPriority) 按优先级合并任务。

10. 总结

  • mergePriorityDelayError 方法提供了一种灵活的方式来合并多个 Publisher，并根据自定义的比较器对发射的结果进行排序，同时延迟错误的通知。
  • 通过 prefetch 参数可以优化数据流的处理效率。
  • 实现过程中需要考虑性能、内存使用和错误处理等问题，确保在多数据源环境下的稳定性和效率。

mergeComparing

@SafeVarargs
public static <I extends Comparable<? super I>> Flux<I> mergeComparing(Publisher<? extends I>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by their natural order). This is not a  sort(), as it doesn't consider the whole of each sequences.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择每个源中的最小值（按其自然顺序定义）作为输出。这不是 sort() 操作，因为它并不考虑每个序列的全部内容。

Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.

相反，这个操作符只考虑每个源中的一个值，并从所有这些值中选择最小的值，然后为所选的源补充该值的槽位。

Type Parameters:

I - a  Comparable merged type that has a  natural order

Parameters:

sources -  Publisher sources of  Comparable to merge

Returns:

a merged  Flux that , subscribing early but keeping the original ordering

类型参数：

I - 具有自然顺序的可比较合并类型。

参数说明：

sources - 要合并的可比较类型的 Publisher 源。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。 

@SafeVarargs public static <I extends Comparable<? super I>> Flux<I> mergeComparing(Publisher<? extends I>... sources)

是一个用于合并多个 Publisher 的 Flux，同时根据元素的自然顺序进行排序的方法。

这个方法提供了一种方便的方式来处理多个数据流，确保合并后的结果按自然顺序发射。

1. 方法简介

  • mergeComparing(Publisher<? extends I>... sources)：该方法接受多个 Publisher，并将其合并为一个 Flux，结果将按元素的自然顺序发射。

2. 参数说明

  • sources：可变参数形式，表示多个 Publisher。这些 Publisher 中的元素必须实现 Comparable 接口，以便能够进行比较和排序。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并按自然顺序发射数据。

4. @SafeVarargs 注解

  • @SafeVarargs 注解用于表明该方法的可变参数是安全的，避免在使用时产生潜在的堆污染问题。

5. 典型使用场景

  • 多源数据合并：在从多个数据源获取数据时，可以使用该方法合并数据并确保按顺序发射。
  • 自然排序需求：在需要对多个元素进行自然排序（如数字、字母等）时，该方法非常有用。
  • 简单数据聚合：对于简单的聚合需求，使用此方法能够快速实现。

6. 实现思路

在实现这个方法时，核心逻辑可以是：

  1. 创建一个集合：用于存储来自各个 Publisher 的元素。
  2. 合并数据流：使用 Flux.merge() 将所有 Publisher 的数据流合并。
  3. 排序并发射：将合并后的元素按自然顺序进行排序并发射。

7. 示例代码

下面是一个使用 mergeComparing 方法的示例，展示如何合并多个 Publisher 并按自然顺序发射结果：

java
import reactor.core.publisher.Flux;

public class MergeComparingExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射整数Flux<Integer> flux1 = Flux.just(5, 1, 4);
        Flux<Integer> flux2 = Flux.just(3, 2, 6);

        // 使用 mergeComparing 方法合并并按自然顺序排序Flux<Integer> mergedFlux = mergeComparing(flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    @SafeVarargspublic static <I extends Comparable<? super I>> Flux<I> mergeComparing(Publisher<? extends I>... sources) {
        return Flux.merge(sources)
                   .sort();
    }
}

8. 代码解析

在这个例子中：

  • 我们定义了两个 Flux，flux1 和 flux2，分别发射一些整数。
  • 使用 mergeComparing 方法合并这两个 Flux，合并后的结果按自然顺序排序。
  • 订阅结果时，我们将打印出合并后的整数。

9. 注意事项

  • 元素类型要求：确保输入的 Publisher 中的元素实现了 Comparable 接口，否则将无法进行比较和排序。
  • 性能考虑：在合并大量数据时，可能会涉及性能开销。注意合理使用此方法。
  • 数据流的完整性：如果某个 Publisher 中存在错误，整个合并流将会被中断，确保适当地处理错误。

10. 高级场景

在更复杂的应用中，可能需要根据特定的规则进行排序。例如，合并字符串流并按字母顺序排序，或者合并用户对象并根据年龄排序。

java

import java.util.Comparator;

class User implements Comparable<User> {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(User other) {
        return Integer.compare(this.age, other.age); // 按年龄比较
    }

    @Override
    public String toString() {
        return name + " (age: " + age + ")";
    }
}

public static void main(String[] args) {
    Flux<User> userFlux1 = Flux.just(new User("Alice", 30), new User("Bob", 20));
    Flux<User> userFlux2 = Flux.just(new User("Charlie", 25), new User("Dave", 35));

    // 使用 mergeComparing 方法合并用户流
    Flux<User> mergedUserFlux = mergeComparing(userFlux1, userFlux2);

    // 订阅并打印用户
    mergedUserFlux.subscribe(System.out::println);
}

11. 总结

  • mergeComparing 方法提供了一种简单而高效的方式来合并多个 Publisher 并按自然顺序发射数据。
  • 通过使用 Comparable 接口，确保元素可以进行比较和排序。
  • 该方法适合于多源数据流的简单合并和排序需求，适用于需要保持元素顺序的场景。

mergeComparing

@SafeVarargs
public static <T> Flux<T> mergeComparing(Comparator<? super T> comparator,
                                                      Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator). This is not a  sort(Comparator), as it doesn't consider the whole of each sequences.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择每个源中的最小值（按提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。

Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.

相反，这个操作符只考虑每个源中的一个值，并从所有这些值中选择最小的值，然后为所选的源补充该值的槽位。

Type Parameters:

T - the merged type

Parameters:

comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares latest values from each source, using the smallest value and replenishing the source that produced it

类型参数：

T - 合并后的类型。

参数说明：

comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新值，使用最小值并补充产生该值的源。 

@SafeVarargs public static <T> Flux<T> mergeComparing(Comparator<? super T> comparator, Publisher<? extends T>... sources)

是一个用于合并多个 Publisher 的 Flux，并根据给定的比较器对合并后的结果进行排序的方法。这个方法为处理复杂的数据合并和排序需求提供了便利。

1. 方法简介

  • mergeComparing(Comparator<? super T> comparator, Publisher<? extends T>... sources)：此方法接受一个比较器和多个 Publisher，将它们合并为一个 Flux，并根据提供的比较器对合并后的结果进行排序。

2. 参数说明

  • comparator：用于比较元素的 Comparator。通过此比较器，合并后的结果将按照自定义的规则进行排序。
  • sources：可变参数形式，表示多个 Publisher，这些 Publisher 中的元素将被合并和排序。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并根据比较器的定义对元素进行排序。

4. @SafeVarargs 注解

  • @SafeVarargs 注解表明该方法的可变参数是安全的，避免了潜在的堆污染问题。

5. 典型使用场景

  • 复杂数据合并：当需要根据特定的逻辑规则合并多个数据源并排序时，此方法特别有用。
  • 自定义排序需求：如按某个属性（如年龄、名字等）进行排序，而不是默认的自然顺序。
  • 数据聚合与处理：适用于需要从多个来源聚合数据并进行处理的场景。

6. 实现思路

实现这个方法的核心思路如下：

  1. 合并数据流：使用 Flux.merge() 将多个 Publisher 的数据流合并。
  2. 使用 Comparator 进行排序：对合并后的结果应用提供的比较器进行排序。

7. 示例代码

下面是一个使用 mergeComparing 方法的示例，展示如何合并多个 Publisher 并按自定义规则进行排序：

java

import reactor.core.publisher.Flux;

import java.util.Comparator;

public class MergeComparingExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射字符串Flux<String> flux1 = Flux.just("Banana", "Apple", "Cherry");
        Flux<String> flux2 = Flux.just("Grape", "Fig", "Elderberry");

        // 使用 mergeComparing 方法合并并按字符串长度排序Flux<String> mergedFlux = mergeComparing(Comparator.comparing(String::length), flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    @SafeVarargspublic static <T> Flux<T> mergeComparing(Comparator<? super T> comparator, Publisher<? extends T>... sources) {
        return Flux.merge(sources)
                   .sort(comparator);
    }
}

8. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，分别发射一些字符串。
  • 使用 mergeComparing 方法合并这两个 Flux，并按照字符串的长度进行排序。
  • 订阅结果并打印合并后的字符串。

9. 注意事项

  • 比较器的合理性：确保传入的比较器适用于合并的元素类型，否则可能会导致 ClassCastException。
  • 性能考虑：在合并大量数据时，可能会涉及性能开销，注意合理使用此方法。
  • 数据流的完整性：如某个 Publisher 中存在错误，整个合并流将会被中断，需适当处理错误。

10. 高级场景

在更复杂的应用中，可以根据具体的业务需求来定义比较器。例如，合并用户对象并根据年龄或姓名进行排序。

java

import java.util.Comparator;

class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return name + " (age: " + age + ")";
    }
}

public static void main(String[] args) {
    Flux<User> userFlux1 = Flux.just(new User("Alice", 30), new User("Bob", 20));
    Flux<User> userFlux2 = Flux.just(new User("Charlie", 25), new User("Dave", 35));

    // 使用 mergeComparing 方法合并用户流并按年龄排序
    Flux<User> mergedUserFlux = mergeComparing(Comparator.comparing(User::getAge), userFlux1, userFlux2);

    // 订阅并打印用户
    mergedUserFlux.subscribe(System.out::println);
}

11. 总结

  • mergeComparing 方法提供了一种简单而灵活的方式来合并多个 Publisher 并根据自定义规则进行排序。
  • 通过使用 Comparator，能够实现对元素的精确控制，适应复杂场景的需求。
  • 适用于需要保持元素顺序并根据特定逻辑进行排序的数据聚合场景。

mergeComparing

@SafeVarargs
public static <T> Flux<T> mergeComparing(int prefetch,
                                                      Comparator<? super T> comparator,
                                                      Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator). This is not a  sort(Comparator), as it doesn't consider the whole of each sequences.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择每个源中的最小值（按提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。

Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.

相反，这个操作符只考虑每个源中的一个值，并从所有这些值中选择最小的一个，然后为所选的源补充该值的槽位。

Type Parameters:

T - the merged type

Parameters:

prefetch - the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)
comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares latest values from each source, using the smallest value and replenishing the source that produced it

类型参数：

T - 合并后的类型。

参数说明：

prefetch - 从每个源预取的元素数量（以避免在选择时向源发送过多的小请求）。
comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新值，使用最小值并补充产生该值的源。 

@SafeVarargs 
public static <T> Flux<T> mergeComparing(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)

是一个用于合并多个 Publisher 的 Flux，并根据给定的比较器对合并后的结果进行排序的静态方法。该方法还允许用户指定预取（prefetch）数量，以优化数据流的性能。

1. 方法简介

  • mergeComparing(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)：此方法接受一个预取数量、一个比较器和多个 Publisher，将它们合并为一个 Flux，并根据提供的比较器对合并后的结果进行排序。

2. 参数说明

  • prefetch：用于指定预取的数量。预取是指在处理流时一次性请求的元素数量，合理的预取设置可以提升性能和降低延迟。
  • comparator：用于比较元素的 Comparator。通过此比较器，合并后的结果将按照自定义的规则进行排序。
  • sources：可变参数形式，表示多个 Publisher，这些 Publisher 中的元素将被合并和排序。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并根据比较器的定义对元素进行排序。

4. @SafeVarargs 注解

  • @SafeVarargs 注解表明该方法的可变参数是安全的，避免了潜在的堆污染问题。

5. 典型使用场景

  • 复杂数据合并：当需要根据特定的逻辑规则合并多个数据源并排序时，此方法特别有用。
  • 自定义排序需求：如按某个属性（如年龄、名字等）进行排序，而不是默认的自然顺序。
  • 数据聚合与处理：适用于需要从多个来源聚合数据并进行处理的场景。

6. 实现思路

实现这个方法的核心思路如下：

  1. 合并数据流：使用 Flux.merge() 将多个 Publisher 的数据流合并，并设置预取数量。
  2. 使用 Comparator 进行排序：对合并后的结果应用提供的比较器进行排序。

7. 示例代码

下面是一个使用 mergeComparing 方法的示例，展示如何合并多个 Publisher 并按自定义规则进行排序：

java

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

import java.util.Comparator;

public class MergeComparingExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射整数Flux<Integer> flux1 = Flux.just(5, 2, 8);
        Flux<Integer> flux2 = Flux.just(3, 1, 4);

        // 使用 mergeComparing 方法合并并按整数大小排序Flux<Integer> mergedFlux = mergeComparing(2, Comparator.naturalOrder(), flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    @SafeVarargspublic static <T> Flux<T> mergeComparing(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources) {
        return Flux.mergeDelayError(prefetch, sources)
                   .sort(comparator);
    }
}

8. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，分别发射一些整数。
  • 使用 mergeComparing 方法合并这两个 Flux，并按照自然顺序进行排序。
  • 订阅结果并打印合并后的整数。

9. 注意事项

  • 预取数量的合理性：预取数量过大可能导致内存占用增加，而过小则可能降低性能，需根据实际情况进行调整。
  • 比较器的合理性：确保传入的比较器适用于合并的元素类型，否则可能会导致 ClassCastException。
  • 性能考虑：在合并大量数据时，合理使用预取可以改善性能，但同时也要监控内存使用情况。

10. 高级场景

在更复杂的应用中，可以根据具体的业务需求来定义比较器。例如，合并用户对象并根据年龄或姓名进行排序。

java

class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return name + " (age: " + age + ")";
    }
}

public static void main(String[] args) {
    Flux<User> userFlux1 = Flux.just(new User("Alice", 30), new User("Bob", 20));
    Flux<User> userFlux2 = Flux.just(new User("Charlie", 25), new User("Dave", 35));

    // 使用 mergeComparing 方法合并用户流并按年龄排序
    Flux<User> mergedUserFlux = mergeComparing(2, Comparator.comparing(User::getAge), userFlux1, userFlux2);

    // 订阅并打印用户
    mergedUserFlux.subscribe(System.out::println);
}

11. 总结

  • mergeComparing 方法提供了一种简单而灵活的方式来合并多个 Publisher 并根据自定义规则进行排序。
  • 通过使用 Comparator，能够实现对元素的精确控制，适应复杂场景的需求。
  • 适用于需要保持元素顺序并根据特定逻辑进行排序的数据聚合场景。

mergeComparingDelayError

@SafeVarargs
public static <T> Flux<T> mergeComparingDelayError(int prefetch,
                                                                Comparator<? super T> comparator,
                                                                Publisher<? extends T>... sources)
Merge data from provided  Publisher sequences into an ordered merged sequence, by picking the smallest values from each source (as defined by the provided  Comparator). This is not a  sort(Comparator), as it doesn't consider the whole of each sequences.

将来自提供的 Publisher 序列的数据合并为一个有序的合并序列，通过选择每个源中的最小值（按提供的比较器定义）作为输出。这不是 sort(Comparator) 操作，因为它并不考虑每个序列的全部内容。

Instead, this operator considers only one value from each source and picks the smallest of all these values, then replenishes the slot for that picked source.

相反，这个操作符只考虑每个源中的一个值，并从所有这些值中选择最小的值，然后为所选的源补充该值的槽位。

Note that it is delaying errors until all data is consumed.

请注意，它会延迟错误的发出，直到所有数据被消费完毕。

Type Parameters:

T - the merged type

Parameters:

prefetch - the number of elements to prefetch from each source (avoiding too many small requests to the source when picking)
comparator - the  Comparator to use to find the smallest value
sources -  Publisher sources to merge

Returns:

a merged  Flux that compares latest values from each source, using the smallest value and replenishing the source that produced it

类型参数：

T - 合并后的类型。

参数说明：

prefetch - 从每个源预取的元素数量（以避免在选择时向源发送过多的小请求）。
comparator - 用于查找最小值的比较器。
sources - 要合并的 Publisher 源。

返回值：

返回一个合并后的 Flux，它比较每个源的最新值，使用最小值并补充产生该值的源。 

@SafeVarargs 
public static <T> Flux<T> mergeComparingDelayError(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)

是一个用于合并多个 Publisher 的 Flux 方法，它可以根据给定的比较器对合并后的结果进行排序，同时在发生错误时仍然允许其他数据继续处理。

1. 方法简介

  • mergeComparingDelayError(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources)：此方法将多个 Publisher 的数据流合并为一个 Flux，并根据提供的比较器对合并后的结果进行排序。在发生错误时，其他数据仍然可以继续发送，而不会立即终止流。

2. 参数说明

  • prefetch：指定在处理流时一次性请求的元素数量（预取数量）。合理的预取设置可以优化性能。
  • comparator：用于比较合并后的元素的 Comparator，以确定元素的顺序。
  • sources：可变参数形式，表示多个 Publisher，这些 Publisher 中的元素将被合并和排序。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它将所有输入的 Publisher 合并，并根据比较器的定义对元素进行排序。如果在数据处理过程中发生错误，它将延迟处理错误。

4. @SafeVarargs 注解

  • @SafeVarargs 注解表示该方法的可变参数是安全的，以避免潜在的堆污染问题。

5. 典型使用场景

  • 错误处理：当希望在合并多个数据源时，允许其中某些源发生错误而不影响其他源的处理时，这个方法特别有用。
  • 复杂数据流：适用于需要从多个来源聚合数据并进行排序的场景。

6. 实现思路

实现这个方法的核心思路如下：

  1. 合并数据流：使用 Flux.mergeDelayError() 将多个 Publisher 的数据流合并，并设置预取数量。
  2. 使用 Comparator 进行排序：对合并后的结果应用提供的比较器进行排序。

7. 示例代码

下面是一个使用 mergeComparingDelayError 方法的示例，展示如何合并多个 Publisher 并按自定义规则进行排序，同时处理错误：

java

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

import java.util.Comparator;

public class MergeComparingDelayErrorExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射整数
        Flux<Integer> flux1 = Flux.just(5, 2, 8).concatWith(Mono.error(new RuntimeException("Error in flux1")));
        Flux<Integer> flux2 = Flux.just(3, 1, 4);

        // 使用 mergeComparingDelayError 方法合并并按整数大小排序
        Flux<Integer> mergedFlux = mergeComparingDelayError(2, Comparator.naturalOrder(), flux1, flux2);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    @SafeVarargspublic static <T> Flux<T> mergeComparingDelayError(int prefetch, Comparator<? super T> comparator, Publisher<? extends T>... sources) {
        return Flux.mergeDelayError(prefetch, sources)
                   .sort(comparator);
    }
}

8. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，分别发射一些整数，并且在 flux1 中引入了一个错误。
  • 使用 mergeComparingDelayError 方法合并这两个 Flux，并按照自然顺序进行排序。
  • 订阅结果并打印合并后的整数，错误会被处理并打印出来。

9. 注意事项

  • 预取数量的合理性：预取数量过大可能导致内存占用增加，而过小则可能降低性能，需要根据实际情况进行调整。
  • 比较器的合理性：确保传入的比较器适用于合并的元素类型，否则可能导致 ClassCastException。
  • 错误处理：该方法允许继续处理其他 Publisher 中的数据，即使某个 Publisher 出现错误。

10. 高级场景

在更复杂的应用中，可以根据具体的业务需求来定义比较器。例如，合并用户对象并根据年龄或姓名进行排序。

java

class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return name + " (age: " + age + ")";
    }
}

public static void main(String[] args) {
    Flux<User> userFlux1 = Flux.just(new User("Alice", 30), new User("Bob", 20));
    Flux<User> userFlux2 = Flux.just(new User("Charlie", 25), new User("Dave", 35));

    // 使用 mergeComparingDelayError 方法合并用户流并按年龄排序
    Flux<User> mergedUserFlux = mergeComparingDelayError(2, Comparator.comparing(User::getAge), userFlux1, userFlux2);

    // 订阅并打印用户
    mergedUserFlux.subscribe(System.out::println);
}

11. 总结

  • mergeComparingDelayError 方法提供了一种灵活的方式来合并多个 Publisher 并根据自定义规则进行排序，同时支持延迟错误处理。
  • 通过使用 Comparator，能够实现对元素的精确控制，适应复杂场景的需求。
  • 适用于需要保持元素顺序并根据特定逻辑进行排序的数据聚合场景，同时保证错误处理的灵活性。

mergeSequential

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources)
Merge data from  Publisher sequences emitted by the passed  Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

将通过传入的 Publisher 发出的 Publisher 序列的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

T - the merged type

Parameters:

sources - a  Publisher of  Publisher sources to merge

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

T - 合并后的类型。

参数说明：

sources - 要合并的 Publisher 源的 Publisher。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。 

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources)

是一个在反应式编程中使用的方法，用于合并多个 Publisher，并按照顺序（即顺序执行）将它们的元素组合成一个新的 Flux。

1. 方法简介

  • mergeSequential：该方法接受一个 Publisher，该 Publisher 发出其他 Publisher 的序列。它会顺序地合并这些 Publisher 的输出，确保一个 Publisher 完成后才开始下一个 Publisher 的处理。

2. 参数说明

  • sources：一个 Publisher，其发出的每个元素都是一个 Publisher，这些 Publisher 将会被顺序合并。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它会顺序地发出所有输入 Publisher 的元素。

4. 使用场景

  • 控制执行顺序：当需要确保每个 Publisher 的元素完全处理完毕后再处理下一个 Publisher 的元素时，可以使用 mergeSequential。
  • 数据依赖：适用于某些场景，其中后续的数据处理依赖于之前 Publisher 的输出结果。

5. 示例代码

以下是使用 mergeSequential 方法的示例，展示如何合并多个 Publisher 并顺序地输出结果：

java

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

public class MergeSequentialExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射元素
        Flux<Integer> flux1 = Flux.just(1, 2, 3);
        Flux<Integer> flux2 = Flux.just(4, 5, 6);
        
        // 将这两个 Flux 放入一个 Publisher 中
        Flux<Flux<Integer>> source = Flux.just(flux1, flux2);

        // 使用 mergeSequential 合并并顺序输出元素
        Flux<Integer> mergedFlux = mergeSequential(source);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources) {
        return Flux.from(sources)
                   .flatMapSequential(publisher -> publisher);
    }
}

6. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，分别发射一些整数。
  • 将这两个 Flux 封装到一个 Publisher（source）中。
  • 使用 mergeSequential 方法合并这两个 Flux，顺序输出其元素。
  • 通过 subscribe 方法打印输出结果。

7. 特性与优势

  • 顺序处理：不同于 merge 方法，mergeSequential 确保了每个 Publisher 的处理是顺序的，避免了并发执行导致的顺序问题。
  • 灵活性：适用于多种场景，如异步任务的依赖关系处理。
  • 简化错误处理：在顺序处理时，容易定位到具体的出错 Publisher。

8. 注意事项

  • 性能：由于是顺序处理，可能会导致性能下降，特别是在处理大量数据时，需要根据实际需求选择使用。
  • 阻塞：若某个 Publisher 的处理耗时较长，会影响到后续 Publisher 的执行，因此设计时要注意时间复杂性。

9. 高级使用

可以在更复杂的场景中，结合其他操作符使用，例如可以在 flatMapSequential 中引入更多的转换逻辑：

java

public static <T> Flux<T> mergeSequentialWithTransformation(Publisher<? extends Publisher<? extends T>> sources) {
    return Flux.from(sources)
               .flatMapSequential(publisher -> publisher.map(value -> transform(value))); // 进行转换
}

private static <T> T transform(T value) {
    // 在这里进行自定义转换逻辑return value; // 示例中直接返回
}

10. 总结

  • mergeSequential 方法是一个强大的工具，适用于需要顺序处理多个 Publisher 的场景。通过合并流的顺序输出，能够确保处理的逻辑清晰且易于管理。
  • 在使用时，需要注意可能带来的性能影响，并合理设计数据流的顺序和处理策略。

mergeSequential

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources,
                                          int maxConcurrency,
                                          int prefetch)
Merge data from  Publisher sequences emitted by the passed  Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order.

将通过传入的 Publisher 发出的 Publisher 序列的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的（但最多同时订阅 maxConcurrency 个源）。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

T - the merged type

Parameters:

sources - a  Publisher of  Publisher sources to merge
prefetch - the inner source request size
maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

T - 合并后的类型。

参数说明：

sources - 要合并的 Publisher 源的 Publisher。
prefetch - 内部源的请求大小。
maxConcurrency - 向主源请求的数量，从而限制并发合并的积压。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。 

public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

是一个在反应式编程中使用的方法，提供了一种合并多个 Publisher 的方式，允许对流的并发程度和预取数量进行控制。让我们详细了解一下这个方法的用法。

1. 方法简介

  • mergeSequential：此方法用于合并多个 Publisher，并确保它们的元素按顺序发出，同时还可以控制同时并发执行的 Publisher 数量和预取的元素数量。

2. 参数说明

  • sources：一个 Publisher，其发出的每个元素都是一个 Publisher，这些 Publisher 将会被顺序合并。
  • maxConcurrency：允许同时处理的最大 Publisher 数量。也就是说，最多有 maxConcurrency 个 Publisher 同时被处理。
  • prefetch：指示在等待下一个 Publisher 发出元素之前，应该从该 Publisher 中预取的元素数量。这有助于减少阻塞和提高吞吐量。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，它会顺序地发出所有输入 Publisher 的元素，按照给定的并发和预取策略。

4. 使用场景

  • 控制并发：当需要对多个流的并发执行进行控制时，此方法非常有用，尤其是在资源有限的情况下。
  • 提高性能：通过合理设置预取数量，可以提高性能，减少元素处理的延迟。

5. 示例代码

下面是一个使用 mergeSequential 方法的示例，展示如何合并多个 Publisher，并控制最大并发和预取数量：

java

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

import java.time.Duration;

public class MergeSequentialExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射元素
        Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));

        // 将这两个 Flux 放入一个 Publisher 中
        Flux<Flux<Integer>> source = Flux.just(flux1, flux2);

        // 使用 mergeSequential 合并并设置最大并发和预取数量
        Flux<Integer> mergedFlux = mergeSequential(source, 2, 1);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    public static <T> Flux<T> mergeSequential(Publisher<? extends Publisher<? extends T>> sources, 
                                              int maxConcurrency, 
                                              int prefetch) {
        return Flux.from(sources)
                   .flatMapSequential(publisher -> publisher, maxConcurrency, prefetch);
    }
}

6. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，它们会分别延迟发射元素。
  • 将这两个 Flux 封装到一个 Publisher（source）中。
  • 使用 mergeSequential 方法合并这两个 Flux，设置 maxConcurrency 为 2，表示最多可以同时处理两个 Publisher，预取数量设置为 1。
  • 通过 subscribe 方法打印输出结果。

7. 特性与优势

  • 并发控制：通过 maxConcurrency 参数，可以灵活控制并发量，避免过载。
  • 优化性能：通过合理设置 prefetch 数量，可以减少处理延迟，提高流的吞吐量。
  • 顺序处理：确保每个 Publisher 的输出顺序，避免了数据处理时的混乱。

8. 注意事项

  • 性能权衡：较高的并发和预取数量可能导致系统资源的过度消耗，因此应根据实际场景进行合理设置。
  • 流的完结：在使用 mergeSequential 时，所有的输入 Publisher 都会被顺序处理，确保每个流在开始下一个流之前完成。

9. 高级使用

可以在更复杂的场景中，结合其他操作符使用，例如进行额外的数据转换或过滤：

java

public static <T> Flux<T> mergeSequentialWithTransformation(Publisher<? extends Publisher<? extends T>> sources, 
                                                            int maxConcurrency, 
                                                            int prefetch) {
    return Flux.from(sources)
               .flatMapSequential(publisher -> publisher.map(value -> transform(value)), 
                                  maxConcurrency, prefetch);
}

private static <T> T transform(T value) {
    // 自定义转换逻辑return value; // 示例中直接返回
}

10. 总结

  • mergeSequential 方法是处理多个 Publisher 的强大工具，特别是在需要控制并发和性能的情况下。它确保流的顺序性，并提供灵活的参数来优化数据流处理。
  • 使用此方法时，合理设置 maxConcurrency 和 prefetch 参数，可以有效提高性能并降低资源消耗，从而提高应用程序的响应能力。

mergeSequentialDelayError

public static <T> Flux<T> mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources,
                                                    int maxConcurrency,
                                                    int prefetch)
Merge data from  Publisher sequences emitted by the passed  Publisher into an ordered merged sequence. Unlike concat, the inner publishers are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.

将通过传入的 Publisher 发出的 Publisher 序列的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的（但最多同时订阅 maxConcurrency 个源）。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。此变体会延迟任何错误的发出，直到处理完其余的 mergeSequential 积压。

Type Parameters:

T - the merged type

Parameters:

sources - a  Publisher of  Publisher sources to merge
prefetch - the inner source request size
maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

T - 合并后的类型。

参数说明：

sources - 要合并的 Publisher 源的 Publisher。
prefetch - 内部源的请求大小。
maxConcurrency - 向主源请求的数量，从而限制并发合并的积压。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。此变体会延迟任何错误的发出，直到处理完其余的 mergeSequential 积压。 

public static <T> Flux<T> mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources, int maxConcurrency, int prefetch)

方法是一个用于顺序合并多个 Publisher 的工具，并允许在发出元素时延迟错误的处理。

这个方法在处理多个流时特别有用，尤其是在希望在一个流出错时仍然能够继续处理其他流的场景。

1. 方法简介

  • mergeSequentialDelayError：此方法将多个 Publisher 顺序合并，并且如果某个 Publisher 产生错误，错误不会立即被传播，而是会在所有其他 Publisher 完成后再传播。

2. 参数说明

  • sources：一个 Publisher，其中的每个元素都是一个 Publisher，这些 Publisher 将被顺序合并。
  • maxConcurrency：允许同时处理的最大 Publisher 数量。也就是说，最多有 maxConcurrency 个 Publisher 同时被处理。
  • prefetch：指示在等待下一个 Publisher 发出元素之前，应该从该 Publisher 中预取的元素数量。这有助于提高性能并减少延迟。

3. 返回值

  • Flux<T>：返回一个合并后的 Flux，按顺序发出所有输入 Publisher 的元素。如果在任何 Publisher 中发生错误，这个错误将在所有 Publisher 处理完成后抛出。

4. 使用场景

  • 错误处理：当需要在处理多个流时允许单个流的错误不影响整个处理流程的场景。
  • 顺序执行：确保多个流按照顺序执行，即使其中一个流出现错误，仍然可以完成其他流的处理。

5. 示例代码

下面是一个使用 mergeSequentialDelayError 方法的示例，展示如何合并多个 Publisher，并控制最大并发和预取数量，同时处理可能出现的错误。

java

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

import java.time.Duration;

public class MergeSequentialDelayErrorExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射元素
        Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.error(new RuntimeException("Error in flux2")); // 模拟错误
        Flux<Integer> flux3 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(100));

        // 将这三个 Flux 放入一个 Publisher 中
        Flux<Flux<Integer>> source = Flux.just(flux1, flux2, flux3);

        // 使用 mergeSequentialDelayError 合并并设置最大并发和预取数量
        Flux<Integer> mergedFlux = mergeSequentialDelayError(source, 2, 1);

        // 订阅并打印结果
        mergedFlux.subscribe(
            System.out::println,
            error -> System.err.println("Error: " + error.getMessage()),
            () -> System.out.println("Complete")
        );
    }

    public static <T> Flux<T> mergeSequentialDelayError(Publisher<? extends Publisher<? extends T>> sources, 
                                                         int maxConcurrency, 
                                                         int prefetch) {
        return Flux.from(sources)
                   .flatMapSequential(publisher -> publisher, maxConcurrency, prefetch)
                   .onErrorResume(error -> {
                       // 处理错误，并延迟传播return Mono.empty(); // 返回空的 Mono，继续其他流
                   });
    }
}

6. 代码解析

在这个例子中：

  • 定义了三个 Flux，其中 flux2 会产生一个错误。
  • 将这三个 Flux 封装到一个 Publisher（source）中。
  • 使用 mergeSequentialDelayError 方法合并这三个 Flux，设置 maxConcurrency 为 2，表示最多可以同时处理两个 Publisher，预取数量设置为 1。
  • 通过 subscribe 方法打印输出结果，并处理可能出现的错误。

7. 特性与优势

  • 顺序合并：确保每个 Publisher 的输出顺序，避免了数据处理的混乱。
  • 错误延迟处理：如果某个 Publisher 发生错误，错误将在所有其他 Publisher 完成后再传播，这允许我们在处理流的过程中收集所有可能的错误。
  • 并发控制：通过 maxConcurrency 参数，可以灵活控制并发量，避免过载。

8. 注意事项

  • 性能权衡：较高的并发和预取数量可能导致系统资源的过度消耗，因此应根据实际场景进行合理设置。
  • 错误处理策略：可以根据需求自定义错误处理策略，例如返回默认值、记录错误等。

9. 高级使用

在更复杂的场景中，可以结合其他操作符使用，例如进行额外的数据转换或过滤，或是在发生错误时执行特定逻辑：

java

public static <T> Flux<T> mergeSequentialDelayErrorWithLogging(Publisher<? extends Publisher<? extends T>> sources, 
                                                               int maxConcurrency, 
                                                               int prefetch) {
    return Flux.from(sources)
               .flatMapSequential(publisher -> publisher, maxConcurrency, prefetch)
               .doOnError(error -> logError(error)) // 自定义错误记录逻辑
               .onErrorResume(error -> Mono.empty());
}

private static void logError(Throwable error) {
    System.err.println("Logged error: " + error.getMessage());
}

10. 总结

  • mergeSequentialDelayError 方法是处理多个 Publisher 的强大工具，特别是在需要顺序处理和错误延迟处理的情况下。它确保流的顺序性，并提供灵活的参数来优化数据流处理。
  • 使用此方法时，合理设置 maxConcurrency 和 prefetch 参数，可以有效提高性能并降低资源消耗，从而提高应用程序的响应能力。

mergeSequential

@SafeVarargs
public static <I> Flux<I> mergeSequential(Publisher<? extends I>... sources)
Merge data from  Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

将提供的 Publisher 序列（以数组或可变参数的形式）中的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

I - the merged type

Parameters:

sources - a number of  Publisher sequences to merge

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型。

参数说明：

sources - 要合并的多个 Publisher 序列。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。

public static <I> Flux<I> mergeSequential(Publisher<? extends I>... sources) 方法是一个用于顺序合并多个 Publisher 的静态方法，能够按照顺序处理多个流中的元素。这种方法在需要保证元素处理顺序的场景下非常有用。

1. 方法简介

  • mergeSequential：此方法合并多个 Publisher，确保从每个 Publisher 中发出的元素按照它们的顺序依次发出。

2. 参数说明

  • sources：一个可变参数列表，包含多个 Publisher，这些 Publisher 将被顺序合并。可以是任意数量的 Publisher，但它们的类型需要是 I 或者 I 的子类。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，将每个输入的 Publisher 中的元素按顺序发出。

4. 使用场景

  • 顺序处理：在需要按顺序处理多个流的情况下，例如合并多个 API 调用的结果，或者按照特定顺序处理事件流。
  • 流的控制：在某些情况下，可能希望在前一个流处理完成后再开始下一个流，以便更好地控制资源。

5. 示例代码

下面是一个使用 mergeSequential 方法的简单示例，演示如何合并多个 Publisher。

java
Copy code
import reactor.core.publisher.Flux;

import java.time.Duration;

public class MergeSequentialExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射元素Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));
        
        // 使用 mergeSequential 合并这两个 FluxFlux<Integer> mergedFlux = mergeSequential(flux1, flux2);
        
        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    @SafeVarargspublic static <I> Flux<I> mergeSequential(Publisher<? extends I>... sources) {
        return Flux.concat(sources);
    }
}

6. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，它们分别发射整数。
  • 使用 mergeSequential 方法将这两个 Flux 合并。由于 flux1 的元素会比 flux2 的元素先发出，因此输出的顺序将遵循 flux1 的顺序，然后是 flux2。
  • 通过 subscribe 方法来打印合并后的结果。

7. 特性与优势

  • 保证顺序：mergeSequential 确保合并后的 Flux 中的元素按照输入 Publisher 的顺序依次发出。
  • 简洁性：使用可变参数可以方便地合并多个 Publisher，无需显式创建一个 Iterable。

8. 注意事项

  • 性能考量：尽管 mergeSequential 提供了顺序保证，但这可能导致某些流的处理被阻塞，尤其是在某个流发出元素较慢的情况下。应根据具体需求权衡流的顺序性与处理性能。
  • 错误处理：如果其中一个 Publisher 发生错误，该错误会立即传播到返回的 Flux 中。可以根据需要进行错误处理。

9. 高级用法

可以与其他操作符结合使用，进行数据转换、过滤等操作，例如：

java
Copy code
public static <I> Flux<I> mergeSequentialWithLogging(Publisher<? extends I>... sources) {
    return Flux.concat(sources)
               .doOnNext(item -> System.out.println("Processing item: " + item)); // 日志记录
}

10. 总结

  • mergeSequential 是一个非常有用的方法，特别适用于需要确保顺序处理多个 Publisher 的场景。通过简单的语法，可以轻松合并任意数量的流，并保持其顺序性，帮助开发者更高效地管理数据流处理。

mergeSequential

@SafeVarargs
public static <I> Flux<I> mergeSequential(int prefetch,
                                                       Publisher<? extends I>... sources)
Merge data from  Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

将提供的 Publisher 序列（以数组或可变参数的形式）中的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

I - the merged type

Parameters:

prefetch - the inner source request size
sources - a number of  Publisher sequences to merge

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型。

参数说明：

prefetch - 内部源的请求大小。
sources - 要合并的多个 Publisher 序列。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。 

public static <I> Flux<I> mergeSequential(int prefetch, Publisher<? extends I>... sources)

方法是用于顺序合并多个 Publisher 的一个静态方法。这个版本的方法允许设置预取数量，从而在处理流时优化性能。

1. 方法简介

  • mergeSequential：此方法用于合并多个 Publisher，并确保它们的元素按照顺序发出。相比于没有预取参数的版本，这个方法允许开发者指定在处理过程中要预取多少个元素，从而可以更好地控制内存使用和性能。

2. 参数说明

  • prefetch：一个整数，指定在合并过程中要预取的元素数量。适当的预取可以减少流的延迟，改善性能，尤其是在与后端系统交互时。
  • sources：一个可变参数列表，包含多个 Publisher，这些 Publisher 将被顺序合并。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，将每个输入的 Publisher 中的元素按顺序发出。

4. 使用场景

  • 优化性能：在需要处理大量数据流时，通过适当的预取设置，可以减少背压带来的延迟，提升整体性能。
  • 顺序处理：适用于需要按照顺序处理多个流的场景，例如合并多个数据库查询的结果。

5. 示例代码

下面是一个使用 mergeSequential 方法的简单示例，演示如何合并多个 Publisher，并设置预取数量。

java

import reactor.core.publisher.Flux;
import java.time.Duration;

public class MergeSequentialWithPrefetchExample {
    public static void main(String[] args) {
        // 定义两个 Flux，分别发射元素Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));

        // 使用 mergeSequential 合并这两个 Flux，设置预取数量为 2Flux<Integer> mergedFlux = mergeSequential(2, flux1, flux2);
        
        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    @SafeVarargspublic static <I> Flux<I> mergeSequential(int prefetch, Publisher<? extends I>... sources) {
        return Flux.concat(sources)
                   .onBackpressureBuffer(prefetch); // 设置预取数量
    }
}

6. 代码解析

在这个例子中：

  • 定义了两个 Flux，flux1 和 flux2，它们分别发射整数，并在发射元素时添加了一些延迟。
  • 使用 mergeSequential 方法将这两个 Flux 合并，并设置了预取数量为 2。这意味着在处理每个 Publisher 时，将尝试提前获取 2 个元素，以提高流的处理效率。
  • 通过 subscribe 方法来打印合并后的结果。

7. 特性与优势

  • 顺序保证：mergeSequential 确保合并后的 Flux 中的元素按照输入 Publisher 的顺序依次发出。
  • 预取控制：通过设置 prefetch 参数，可以有效管理内存使用和性能，减少延迟。

8. 注意事项

  • 预取数量的选择：适当的预取数量可以提高性能，但过高的预取数量可能导致内存占用过高，因此需要根据具体场景进行调整。
  • 错误处理：如果其中一个 Publisher 发生错误，该错误会立即传播到返回的 Flux 中，开发者可以根据需要进行错误处理。

9. 高级用法

可以与其他操作符结合使用，进行数据转换、过滤等操作，例如：

java

public static <I> Flux<I> mergeSequentialWithLogging(int prefetch, Publisher<? extends I>... sources) {
    return Flux.concat(sources)
               .doOnNext(item -> System.out.println("Processing item: " + item))
               .onBackpressureBuffer(prefetch);
}

10. 总结

  • mergeSequential(int prefetch, Publisher<? extends I>... sources) 是一个灵活的方法，特别适用于需要顺序合并多个 Publisher 且希望优化性能的场景。通过简单的语法，可以轻松合并任意数量的流，并保持其顺序性，同时通过预取设置优化处理效率。这使得开发者在处理复杂的数据流时更加高效和灵活。

mergeSequentialDelayError

@SafeVarargs
public static <I> Flux<I> mergeSequentialDelayError(int prefetch,
                                                                 Publisher<? extends I>... sources)
Merge data from  Publisher sequences provided in an array/vararg into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.

将提供的 Publisher 序列（以数组或可变参数的形式）中的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。此变体会延迟任何错误的发出，直到处理完其余的 mergeSequential 积压。

Type Parameters:

I - the merged type

Parameters:

prefetch - the inner source request size
sources - a number of  Publisher sequences to merge

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型。

参数说明：

prefetch - 内部源的请求大小。
sources - 要合并的多个 Publisher 序列。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。此变体会延迟任何错误的发出，直到处理完其余的合并积压。

mergeSequentialDelayError 方法是 Flux 类中的一个静态方法，用于合并多个 Publisher，并确保它们的元素按照顺序发出，同时在遇到错误时延迟传播。

这意味着，只有在所有的源 Publisher 都完成后，错误才会被发送。这个方法在处理可能抛出异常的多个流时特别有用。

1. 方法简介

  • mergeSequentialDelayError：该方法将多个 Publisher 的元素合并为一个 Flux，确保元素按顺序发出，并在所有 Publisher 完成后，才处理可能发生的错误。

2. 参数说明

  • prefetch：一个整数，指定在合并过程中要预取的元素数量。合适的预取量可以改善性能，减少背压导致的延迟。
  • sources：一个可变参数列表，包含多个 Publisher，这些 Publisher 将被顺序合并。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，将每个输入的 Publisher 中的元素按顺序发出，并在最后处理错误。

4. 使用场景

  • 处理可能出错的流：在需要处理多个可能会抛出异常的流的情况下，通过此方法可以避免早期传播错误，从而在所有源都尝试完成后再统一处理错误。
  • 顺序合并多个流：在某些情况下，可能需要保证输出的顺序，如合并多个异步数据库查询的结果。

5. 示例代码

下面是一个使用 mergeSequentialDelayError 方法的简单示例，演示如何合并多个 Publisher 并处理错误。

java

import reactor.core.publisher.Flux;
import java.time.Duration;

public class MergeSequentialDelayErrorExample {
    public static void main(String[] args) {
        // 定义两个 Flux，第二个 Flux 会抛出异常
        Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6)
                                   .delayElements(Duration.ofMillis(200))
                                   .map(i -> {
                                       if (i == 5) throw new RuntimeException("Error at 5");
                                       return i;
                                   });

        // 使用 mergeSequentialDelayError 合并这两个 Flux，设置预取数量为 2
        Flux<Integer> mergedFlux = mergeSequentialDelayError(2, flux1, flux2);
        
        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    @SafeVarargspublic static <I> Flux<I> mergeSequentialDelayError(int prefetch, Publisher<? extends I>... sources) {
        return Flux.concat(sources)
                   .onErrorResume(e -> {
                       // Handle error
                       System.err.println("An error occurred: " + e.getMessage());
                       return Flux.empty(); // Returning empty Flux to continue processing
                   })
                   .onBackpressureBuffer(prefetch); // 设置预取数量
    }
}

6. 代码解析

在这个例子中：

  • flux1 和 flux2：定义了两个 Flux，flux1 发射 1, 2, 3，flux2 发射 4, 5, 6，但在发射 5 时会抛出异常。
  • mergeSequentialDelayError 方法：将这两个 Flux 合并，并设置了预取数量为 2。通过此方法，流中的元素按顺序发出，直到所有流都完成，最后再处理可能发生的错误。
  • 错误处理：在 one rrorResume 中处理错误，输出错误信息并返回一个空的 Flux，以继续后续的元素处理。

7. 特性与优势

  • 顺序保证：与 mergeSequential 类似，该方法保证合并后的 Flux 中的元素按照输入 Publisher 的顺序依次发出。
  • 延迟错误处理：在所有的 Publisher 完成后，才处理发生的错误，这对于需要确保每个流都尝试完成的场景非常重要。
  • 预取控制：通过设置 prefetch 参数，可以有效管理内存使用和性能，减少延迟。

8. 注意事项

  • 错误传播：所有源 Publisher 都必须完成，才会处理错误。如果多个 Publisher 中有错误，那么只有在所有 Publisher 处理完后，才会得到错误通知。
  • 适当的预取数量：选择合适的预取数量可以提高性能，但过高的预取数量可能会导致内存占用过高，因此需要根据具体场景进行调整。

9. 高级用法

可以与其他操作符结合使用，例如过滤、转换等操作，以创建更复杂的流处理逻辑。

java

public static <I> Flux<I> mergeSequentialDelayErrorWithLogging(int prefetch, Publisher<? extends I>... sources) {
    return Flux.concat(sources)
               .doOnNext(item -> System.out.println("Processing item: " + item))
               .onErrorResume(e -> {
                   System.err.println("An error occurred: " + e.getMessage());
                   return Flux.empty(); // Continue processing
               })
               .onBackpressureBuffer(prefetch);
}

10. 总结

  • mergeSequentialDelayError(int prefetch, Publisher<? extends I>... sources) 是一个强大的工具，特别适用于需要顺序合并多个 Publisher 并延迟错误处理的场景。通过简单的语法，可以灵活地合并多个流，并有效控制错误的传播与性能。这样的特性使得开发者在处理复杂的数据流时，能够更加高效和灵活。

mergeSequential

public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources)
Merge data from  Publisher sequences provided in an  Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly. Unlike merge, their emitted values are merged into the final sequence in subscription order.

将提供的 Publisher 序列（以可迭代的形式）中的数据合并为一个有序的合并序列。与 concat 不同，内部的 Publisher 是被提前订阅的。与 merge 不同，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

I - the merged type

Parameters:

sources - an  Iterable of  Publisher sequences to merge

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型。

参数说明：

sources - 要合并的 Publisher 序列的可迭代集合。

返回值：

返回一个合并后的 Flux，它会提前订阅，但保持原始的顺序。

mergeSequential 方法是 Flux 类中的一个静态方法，它用于合并多个 Publisher，确保它们的元素按照顺序发出。

与其他合并方法不同，mergeSequential 允许对每个 Publisher 的元素进行顺序处理，并在一个流完成后再处理下一个流的元素。

这使得它在处理有依赖关系的异步流时非常有用。

1. 方法简介

  • mergeSequential(Iterable<? extends Publisher<? extends I>> sources)：该方法将多个 Publisher 的元素按顺序合并成一个 Flux，确保在前一个 Publisher 完成后才会开始下一个 Publisher。

2. 参数说明

  • sources：一个 Iterable 的 Publisher，表示多个待合并的流。这些流中的元素将被按顺序发出。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，该 Flux 将输入的 Publisher 中的元素按顺序发出。

4. 使用场景

  • 顺序处理：在某些情况下，可能需要确保输出的顺序，例如合并多个异步操作的结果，或者根据前一个操作的结果来决定后一个操作的执行。
  • 简单的合并：当需要合并多个流而不关心它们之间的并发时，可以使用此方法。

5. 示例代码

下面是一个使用 mergeSequential 方法的简单示例，演示如何合并多个 Publisher 并按顺序处理它们。

java

import reactor.core.publisher.Flux;

import java.time.Duration;
import java.util.Arrays;

public class MergeSequentialExample {
    public static void main(String[] args) {
        // 定义多个 FluxFlux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));
        Flux<Integer> flux3 = Flux.just(7, 8, 9).delayElements(Duration.ofMillis(150));

        // 使用 mergeSequential 合并多个 FluxFlux<Integer> mergedFlux = mergeSequential(Arrays.asList(flux1, flux2, flux3));
        
        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources) {
        return Flux.concat(sources); // 使用 concat 方法实现顺序合并
    }
}

6. 代码解析

在这个例子中：

  • flux1、flux2 和 flux3：定义了三个 Flux，每个 Flux 中都包含了数字，并且使用 delayElements 模拟了异步操作的延迟。
  • mergeSequential 方法：将这三个 Flux 按顺序合并。由于 Flux.concat 会处理这些 Publisher，确保它们的元素按顺序发出。

7. 特性与优势

  • 顺序保证：该方法保证合并后的 Flux 中的元素按照输入 Publisher 的顺序依次发出。
  • 简单的 API：通过简单的 API，可以方便地合并多个流，避免了复杂的流控制逻辑。

8. 注意事项

  • 顺序处理：由于该方法是顺序处理，因此在一个 Publisher 完成之前，其他 Publisher 不会开始处理，这可能会影响性能。如果对并发处理有需求，可能需要考虑使用 merge 方法。
  • 错误传播：如果任何一个 Publisher 发生错误，合并后的 Flux 将立即终止，不会处理后续的 Publisher。

9. 高级用法

可以与其他操作符结合使用，例如过滤、转换等操作，以创建更复杂的流处理逻辑。

java

public static <I> Flux<I> mergeSequentialWithLogging(Iterable<? extends Publisher<? extends I>> sources) {
    return Flux.concat(sources)
               .doOnNext(item -> System.out.println("Processing item: " + item));
}

10. 总结

mergeSequential(Iterable<? extends Publisher<? extends I>> sources) 方法是一个强大的工具，特别适用于需要顺序合并多个 Publisher 的场景。通过简单的语法，可以灵活地合并多个流，确保处理顺序和结果的一致性。这种特性使得开发者在处理复杂的数据流时，能够更加高效和灵活。

mergeSequential

public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources,
                                          int maxConcurrency,
                                          int prefetch)
Merge data from  Publisher sequences provided in an  Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order.

将来自可迭代集合中的 Publisher 序列的数据合并成一个有序的合并序列。与 concat 不同的是，这些源会被提前订阅（但最多同时订阅 maxConcurrency 个源）。与 merge 不同的是，它们发出的值会按照订阅顺序合并到最终序列中。

Type Parameters:

I - the merged type

Parameters:

sources - an  Iterable of  Publisher sequences to merge
maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
prefetch - the inner source request size

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型

参数：

sources - 要合并的 Publisher 序列的可迭代集合
maxConcurrency - 生成的请求数量，限制并发合并的积压
prefetch - 内部源的请求大小

返回：

一个合并的 Flux，提前订阅但保持原始的顺序。 

mergeSequential(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch)

方法是 Flux 类中的一个静态方法，用于顺序合并多个 Publisher 的元素，允许一定程度的并发处理。

这个方法提供了比简单的顺序合并更灵活的配置选项，特别是在需要控制并发数时。

1. 方法简介

  • mergeSequential(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch)：将多个 Publisher 的元素按顺序合并，同时允许并发处理多个 Publisher，并通过 prefetch 参数控制预取的元素数量。

2. 参数说明

  • sources：一个 Iterable 的 Publisher，表示多个待合并的流。它们中的元素将被按顺序发出。
  • maxConcurrency：控制同时处理的 Publisher 数量。即使是顺序合并，仍然可以通过这个参数控制并发度。
  • prefetch：在下游消费者准备好处理数据之前，预取的元素数量。这有助于提高处理效率，尤其是在处理高延迟的 Publisher 时。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，该 Flux 将输入的 Publisher 中的元素按顺序发出，但允许一定程度的并发。

4. 使用场景

  • 高并发场景：在某些场景下，可能需要控制同时处理的流数量，例如 API 调用或者数据库查询时，以避免过多的并发请求导致系统过载。
  • 顺序依赖：当需要确保输出的顺序，同时又希望提高性能时，使用这个方法可以平衡并发性和顺序性。

5. 示例代码

下面是一个使用 mergeSequential 方法的简单示例，演示如何合并多个 Publisher 并按顺序处理它们，同时控制并发和预取。

java

import reactor.core.publisher.Flux;

import java.time.Duration;
import java.util.Arrays;

public class MergeSequentialWithConcurrencyExample {
    public static void main(String[] args) {
        // 定义多个 Flux
        Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));
        Flux<Integer> flux3 = Flux.just(7, 8, 9).delayElements(Duration.ofMillis(150));

        // 使用 mergeSequential 合并多个 Flux，允许最大并发为2，预取为1
        Flux<Integer> mergedFlux = mergeSequential(
                Arrays.asList(flux1, flux2, flux3), 
                2, // maxConcurrency1  // prefetch
        );

        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    public static <I> Flux<I> mergeSequential(Iterable<? extends Publisher<? extends I>> sources, 
                                              int maxConcurrency, 
                                              int prefetch) {
        return Flux.mergeSequential(sources, maxConcurrency, prefetch);
    }
}

6. 代码解析

在这个例子中：

  • flux1、flux2 和 flux3：定义了三个 Flux，每个 Flux 中都包含了数字，并且使用 delayElements 模拟了异步操作的延迟。
  • mergeSequential 方法：将这三个 Flux 按顺序合并，同时允许最多两个 Publisher 同时处理。由于设置了 prefetch 为 1，表示每次只预取一个元素，尽可能降低内存占用。

7. 特性与优势

  • 控制并发：通过 maxConcurrency 参数，可以灵活控制同时处理的流的数量，这对于资源管理非常重要。
  • 预取机制：使用 prefetch 可以提高性能，特别是在处理高延迟的流时，避免下游处理的空闲时间。
  • 顺序保证：尽管允许并发处理，合并后的 Flux 仍然保证了输出的顺序。

8. 注意事项

  • 顺序处理：如果对输出顺序没有要求，可以考虑使用其他合并方法（如 merge），以提高并发性能。
  • 错误传播：如果任何一个 Publisher 发生错误，合并后的 Flux 将立即终止，不会处理后续的 Publisher。

9. 高级用法

结合其他操作符，例如过滤、转换等操作，可以创建更复杂的流处理逻辑，同时保持良好的可读性和可维护性。

java

public static <I> Flux<I> mergeSequentialWithLogging(Iterable<? extends Publisher<? extends I>> sources, 
                                                     int maxConcurrency, 
                                                     int prefetch) {
    return Flux.mergeSequential(sources, maxConcurrency, prefetch)
               .doOnNext(item -> System.out.println("Processing item: " + item));
}

10. 总结

mergeSequential(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch) 方法为开发者提供了强大的工具来管理流的合并，尤其是在需要控制并发的场景下。通过简单的配置，可以有效地提高性能，确保输出的顺序，并优化系统资源的使用。这种灵活性使得它在复杂的异步流处理场景中非常受欢迎。

mergeSequentialDelayError

public static <I> Flux<I> mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources,
                                                    int maxConcurrency,
                                                    int prefetch)
Merge data from  Publisher sequences provided in an  Iterable into an ordered merged sequence. Unlike concat, sources are subscribed to eagerly (but at most maxConcurrency sources at a time). Unlike merge, their emitted values are merged into the final sequence in subscription order. This variant will delay any error until after the rest of the mergeSequential backlog has been processed.

合并来自可迭代集合中的 Publisher 序列的数据，以形成一个有序的合并序列。与 concat 不同，源会被提前订阅（但同时最多只订阅 maxConcurrency 个源）。与 merge 不同，它们发出的值会按订阅顺序合并到最终序列中。此变体会延迟任何错误，直到处理完合并顺序的其余积压后再报告。

Type Parameters:

I - the merged type

Parameters:

sources - an  Iterable of  Publisher sequences to merge
maxConcurrency - the request produced to the main source thus limiting concurrent merge backlog
prefetch - the inner source request size

Returns:

a merged  Flux, subscribing early but keeping the original ordering

类型参数：

I - 合并后的类型

参数：

sources - 要合并的 Publisher 序列的可迭代集合
maxConcurrency - 生成的请求数量，限制同时合并的积压
prefetch - 内部源的请求大小

返回：

一个合并的 Flux，提前订阅但保持原始的顺序。 

mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch)

方法是 Flux 类中的一个静态方法，用于顺序合并多个 Publisher 的元素，同时允许一定程度的并发处理，并且在合并过程中如果发生错误，则会延迟错误的传播，直到所有的 Publisher 都完成。

1. 方法简介

  • mergeSequentialDelayError：按顺序合并多个 Publisher 的元素，允许并发处理，并在发生错误时延迟错误的传播，直到所有 Publisher 完成或所有元素发出。

2. 参数说明

  • sources：一个 Iterable 的 Publisher，表示多个待合并的流。它们中的元素将被按顺序发出。
  • maxConcurrency：控制同时处理的 Publisher 数量，即使是顺序合并，仍然可以通过这个参数控制并发度。
  • prefetch：在下游消费者准备好处理数据之前，预取的元素数量。这有助于提高处理效率，尤其是在处理高延迟的 Publisher 时。

3. 返回值

  • Flux<I>：返回一个合并后的 Flux，该 Flux 将输入的 Publisher 中的元素按顺序发出，但允许一定程度的并发，并且如果任何 Publisher 发生错误，错误会被延迟传播。

4. 使用场景

  • 高并发场景：在某些场景下，可能需要控制同时处理的流数量，例如 API 调用或者数据库查询时，以避免过多的并发请求导致系统过载。
  • 顺序依赖：当需要确保输出的顺序，同时又希望提高性能时，使用这个方法可以平衡并发性和顺序性。
  • 错误处理：在处理多个流时，可能会有某个流发生错误，通过延迟错误传播，可以确保其他流的处理不会立即中断。

5. 示例代码

下面是一个使用 mergeSequentialDelayError 方法的简单示例，演示如何合并多个 Publisher 并按顺序处理它们，同时控制并发和预取，并处理错误延迟。

java

import reactor.core.publisher.Flux;
import java.time.Duration;
import java.util.Arrays;

public class MergeSequentialDelayErrorExample {
    public static void main(String[] args) {
        // 定义多个 Flux，其中一个 Flux 将会抛出异常
        Flux<Integer> flux1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
        Flux<Integer> flux2 = Flux.just(4, 5, 6).delayElements(Duration.ofMillis(200));
        Flux<Integer> flux3 = Flux.<Integer>error(new RuntimeException("Error in flux3")).delayElements(Duration.ofMillis(150));
        Flux<Integer> flux4 = Flux.just(7, 8, 9).delayElements(Duration.ofMillis(100));

        // 使用 mergeSequentialDelayError 合并多个 Flux，允许最大并发为2，预取为1
        Flux<Integer> mergedFlux = mergeSequentialDelayError(
                Arrays.asList(flux1, flux2, flux3, flux4), 
                2, // maxConcurrency1  // prefetch
        );

        // 订阅并打印结果
        mergedFlux.subscribe(System.out::println,
                              error -> System.err.println("Error: " + error.getMessage()),
                              () -> System.out.println("Complete"));
    }

    public static <I> Flux<I> mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources, 
                                                         int maxConcurrency, 
                                                         int prefetch) {
        return Flux.mergeSequentialDelayError(sources, maxConcurrency, prefetch);
    }
}

6. 代码解析

在这个例子中：

  • flux1、flux2、flux3 和 flux4：定义了多个 Flux，其中 flux3 通过 error 方法抛出了一个运行时异常，模拟了流中的错误。
  • mergeSequentialDelayError 方法：将这四个 Flux 按顺序合并，同时允许最多两个 Publisher 同时处理。由于设置了 prefetch 为 1，表示每次只预取一个元素，尽可能降低内存占用。

7. 特性与优势

  • 控制并发：通过 maxConcurrency 参数，可以灵活控制同时处理的流的数量，这对于资源管理非常重要。
  • 预取机制：使用 prefetch 可以提高性能，特别是在处理高延迟的流时，避免下游处理的空闲时间。
  • 顺序保证：尽管允许并发处理，合并后的 Flux 仍然保证了输出的顺序。
  • 延迟错误传播：如果任何一个 Publisher 发生错误，合并后的 Flux 将在所有 Publisher 完成后再传播错误，而不是立即终止，这可以帮助用户更好地处理错误。

8. 注意事项

  • 顺序处理：如果对输出顺序没有要求，可以考虑使用其他合并方法（如 merge），以提高并发性能。
  • 错误传播：合并后的 Flux 在所有 Publisher 完成后会传播错误，用户需要在订阅时适当处理错误。

9. 高级用法

结合其他操作符，例如过滤、转换等操作，可以创建更复杂的流处理逻辑，同时保持良好的可读性和可维护性。

java

public static <I> Flux<I> mergeSequentialDelayErrorWithLogging(Iterable<? extends Publisher<? extends I>> sources, 
                                                               int maxConcurrency, 
                                                               int prefetch) {
    return Flux.mergeSequentialDelayError(sources, maxConcurrency, prefetch)
               .doOnNext(item -> System.out.println("Processing item: " + item))
               .doOnError(error -> System.err.println("Error encountered: " + error.getMessage()));
}

10. 总结

mergeSequentialDelayError(Iterable<? extends Publisher<? extends I>> sources, int maxConcurrency, int prefetch) 方法为开发者提供了强大的工具来管理流的合并，尤其是在需要控制并发和延迟错误处理的场景下。通过简单的配置，可以有效地提高性能，确保输出的顺序，并优化系统资源的使用。这种灵活性使得它在复杂的异步流处理场景中非常受欢迎。

标签：Publisher,sources,合并,Flux,说明书,prefetch,merge
From： https://blog.csdn.net/heliangb46/article/details/143127537

相关文章

  • 基于Telegraf+Influxdb+Grafana的监控平台介绍
    我们知道这种监控平台的数据特征一般都是时间序列数据（简称时序数据），那么相应的这些数据最好是存储在时序数据库中，目前主流的时序数据库有InfluxDB、OpenTSDB、Graphite、TimescaleDB等。其中，InfluxDB是目前监控领域使用较多的时序数据库，并且基于InfluxDB有一套完善的开源解决方案......
  • 合并分支：Git merge 和 rebase 的区别
    结论：直接merge会产生合并提交记录，而rebase是会形成线性的提交记录，如果该合并是有意义的合并，则可以使用merge，记录合并提交记录，如果是日常个人的合并，则使用rebase，减少无意义的合并提交记录使用rebase要注意在自己的分支上进行，不然会导致其他人由于指向的commitid不同，导致同步问......
  • Fluid Flux2.0海浪原理拆解
    【USparkle专栏】如果你深怀绝技，爱“搞点研究”，乐于分享也博采众长，我们期待你的加入，让智慧的火花碰撞交织，让知识的传递生生不息！大概一年前，在油管上看到这个视频：FluidFlux2.0-Coastline[UnrealEngine5]  除了效果很好，更重要的是看到简介中写着：“并非实时模拟”、“......
  • PG 的 MergeJoin 就是鸡肋
    好久没写博客，平时工作非常忙，而且现在对接的应用基本都是微服务架构。微服务这种架构平时也很难遇到复杂SQL，架构层面也限制了不允许有复杂SQL，平时处理的都是简单一批的点查SQL。基本上优化的内容就是业务，架构上改改和开发扯皮，每条SQL扣毫秒这样来搞，并发情况下程序接口的整体RT降......
  • 【软件资料】数据库设计规范，数据库设计说明书，数据库设计规范，数据库文档（Word资料下载）
     1编写目的2数据库策略2.1数据库对象长度策略2.2数据完整性策略2.3规范化设计与性能之间的权衡策略2.4字段类型的定义与使用策略3命名规范3.1数据库命名规则3.2数据库对象命名的一般原则3.3表空间(Tablespace)命名规则3.4表(Table)命名规则3.5字段命......
  • 10093-基于STM32的无线串口小型直流电机调速器设计（仿真+原理图+源代码工程+详细介绍说
    10093-基于STM32的无线串口小型直流电机调速器设计（仿真+原理图+源代码工程+详细介绍说明书+proteus）功能描述：直流电机的调速器设计设计，需要设计一个调速与控制系统，是设备可以直接控制和读取信息，并且显示。①设计直流电机转速控制系统；②通过按键调节直流电机转速；③可以在......
  • 10093-基于STM32的无线串口小型直流电机调速器设计（仿真+原理图+源代码工程+详细介绍说
    10093-基于STM32的无线串口小型直流电机调速器设计（仿真+原理图+源代码工程+详细介绍说明书+proteus）功能描述：直流电机的调速器设计设计，需要设计一个调速与控制系统，是设备可以直接控制和读取信息，并且显示。①设计直流电机转速控制系统；②通过按键调节直流电机转速；③可以在......
  • 【closerAI ComfyUI】电商模特一键换装解决方案来了！细节到位无瑕疵！再加上flux模型加持
    不得了了兄弟们。这应该是电商界的福音，电商模特一键换装解决方案来了！细节到位无瑕疵！再加上flux模型加持，这个工作流不服不行！这期我们主要讨论如何使用stablediffusioncomfyUI制作完美无瑕疵的换装工作流。**这一次我们用到的节点是catVTON节点。CatVTON介绍[CatVTON是......
  • ComfyUI-Flux-PuLID-定制写真生成工作流整合包，含提示词反推，相关软件包及工作流均已打
    本期本期带来基于PuLID-for-FLUX的ComfyUI定制写真工作流，通过一张面部参考图像生成真实感十足的高保真写真图像，基于Flux底层模型，更为写实。**其中包含“输入提示词生成图像”和“参考图像反推提示词生成图像”两套工作流，**工作流操作较简单，相关ComfyUI软件包、模型、节点、......
  • Flux 文生图模型，一键整合包！解压即用，出图效果惊艳
    朋友们！今天给大家带来一款全新且超强的AI文生图神器——Flux文生图模型！（最低N卡3060以上电脑）由知名AI开发团队BlackForestLabs（黑森林实验室）打造，这款高质量的文本到图像生成模型在多个方面展现了超凡的性能。无论是细腻的手部细节、复杂的多主体场景，还是中文文本......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99