Project ReactorのFlux(Monodict)に於ける「Map」 operationについて、名叫じてのdifferenceを讨論します。これらの operationは、elementのtransform operationに於けるcharacteristicsが大きく異なります。この記事は、これらの operationのcharacteristicsを理解し、適切な operationを選ぶためのguideを提供します。
一、Map operationのcharacteristics
-------------------------------
| operation |
异步 |
保序 |
並行 |
return type |
使用场景 |
| map |
否 |
否 |
否 |
`T → R`(普通の対象) |
简洁同步 transform |
| concatMap |
はい |
はい |
否 |
`T → Publisher` |
异步且は保序(例:DB 쓰込み) |
| flatMap |
はい |
否 |
はい |
`T → Publisher` |
高 throughput异步且は乱序 |
| flatMapSequential |
はい |
はい |
はい |
`T → Publisher` |
並列且は保序(例:プログレスをInvite) |
| switchMap |
はい |
否 |
否 |
`T → Publisher` |
最新-only operation(例:リアル検索) |
逐个operationの詳細
---------------------------
1. map —— 簡单 synchron operation
<span class="language">flux.map(Function<T, R> mapper) → Flux<R></span>
- 特性: synchron operation. 関数が立刻に結果を返す。
- 備考:`map`は`Publisher` objectを普通の値として传递する
- 适用场景:
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap —— 弾性且は保序 operation
<span class="language">flux.concatMap(Publisher<R> Function<T, R> mapper) → Flux<R></span>
- 特性:各要素が独立で异步 operationを実行。`concurex` operationは串行実行。
- 備考:`concatMap`は`Publisher` objectを保持する。
- 适用场景:
Flux.range(1, 3)
.concatMap(i ->
Mono.delay(Duration.ofMillis(100))
.thenReturn("Item-" + i)
)
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
3. flatMap —— 弾性且は乱序 operation
<span class="language">flux.flatMap(Publisher<R> Function<T, R> mapper) → Flux<R></span>
- 特性:`concatMap`と同等だが、`flatMap`は`Publisher` objectを保持しない。
- 備考:`flatMap`は`concurrency` parameterを介して並列数を制御する。
- 适用场景:
Flux.range(1, 3)
.flatMap(i ->
Mono.delay(Duration.ofMillis(new Random().nextInt(200)))
.thenReturn("Item-" + i)
)
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential —— 平列且は保序 operation
<span class="language">flux.flatMapSequential(Publisher<R> Function<T, R> mapper) → Flux<R></span>
- 特性:`flatMap`と同等だが、`flatMapSequential`は`Publisher` objectの出力が保序。
- 備考:`flatMapSequential`は`concurrency` parameterを介して並列数を制御する。
- 适用场景:
Flux.range(1, 3)
.flatMapSequential(i ->
Mono.delay(Duration.ofMillis(100))
.thenReturn("Item-" + i)
)
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
5. switchMap —— 最新-only operation
<span class="language">flux.switchMap(Publisher<R> Function<T, R> mapper) → Flux<R></span>
- 特性:`switchMap`は`Mono`-like operationが保持された`Publisher` objectを取消し、最新の publisherを保持する。
- 備考:`switchMap`は`Publication` objectを保持しない。
- 适用场景:
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
--------------------
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
--------------------
1. `map` operationに`Publisher` objectを传递するは避け
2. WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
3. `flatMap` operationの`concurrency`を制御
4. `switchMap`は`Publication` objectを保持しない
5. `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
--------------------
| operation |
特徴 |
| handle |
`T`を直接 transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
---------------
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionを直接applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
3. flatMap operation
並列where functionが独立で、resultが保持되지 않습니다。
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`を直接 transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
3. flatMap operation
並列where functionが独立で、resultが保持되지 않습니다。
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
3. flatMap operation
並列where functionが独立で、resultが保持izzardisch
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (順番)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
3. flatMap operation
並列where functionが独立で、resultが保持izzardisch
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
3. flatMap operation
並列where functionが独立で、resultが保持izzardisch
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
3. flatMap operation
並列where functionが独立で、resultが保持izzardisch
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |
Project Reactor, Flux, Map, Monodict, Parallel Processing
Project ReactorのMap operationの概要
Project ReactorのFlux(Monodict)は、並列化を容易に実現するための強力な工具です。特に`Map` operationは、elementのtransform operationに於けるcharacteristicsを管理します。
1. map operation
simple synchron operationで、functionをdirectly applyし、resultを返します。
Flux.just("a", "b")
.map(String::toUpperCase) // "A", "B"
.map(s -> new User(s)); // DTO
2. concatMap operation
串行where functionが独立で、resultが保持されます。
Flux.range(1, 3)
.concatMap(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
3. flatMap operation
並列where functionが独立で、resultが保持izzardisch
Flux.range(1, 3)
.flatMap(i -> Mono.delay(Duration.ofMillis(new Random().nextInt(200))) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:乱序(例:200msのdelay)
4. flatMapSequential operation
並列where functionが独立で、resultが保持され、out풋が保持される顺序です。
Flux.range(1, 3)
.flatMapSequential(i -> Mono.delay(Duration.ofMillis(100)) .thenReturn("Item-" + i))
.subscribe(System.out::println);
// 出力:Item-1, Item-2, Item-3 (顺序)
5. switchMap operation
最新-only operationで、`Mono`-like operationが保持された`Publisher` objectを取消します。
searchInputFlux
.switchMap(query -> searchService.search(query)) // 快捷入力
.subscribe(results -> updateUI(results));
// 出力:searchService.search(query)の結果
選択guide
- 异步 operation(`Publisher` objectを生成する)?
- 否 → `map`
- はい → 次に保序 operation?
- 否 → `concatMap`(低 throughput)
- はい → `flatMapSequential`(高 throughput)
- 特殊な场景:最新-only operation?
注意事項 & 最佳实践
- `map` operationに`Publisher` objectを传递するは避け
- WebFlux controllerに`block()`を呼ぶは避け(非阻塞連携)
- `flatMap` operationの`concurrency`を制御
- `switchMap`は`Publication` objectを保持しない
- `concatMap` operationは`Mono`-like operationが保持された`Publisher` objectを保持する
他 operation
| operation |
特徴 |
| handle |
`T`をdirectly transformし、`R`を生成する |
| transform |
`Flux`全体を transformする |
| compose |
`Publisher` layerを transformする |
まとめ
| operation |
キーワード |
| map |
简洁 synchron |
| concatMap |
保序、低 throughput |
| flatMap |
乱序、高 throughput |
| flatMapSequential |
保序、高 throughput |
| switchMap |
最新-only |