[Java/Reactor/响应式/异步] Java Reactor 框架之Mono组件示例
1 Mono组件示例
案例0:Mono.defer() → then() → doFinally() → subscribeOn() → subscribe() 实际项目
//reactor.core.publisher.Mono
//reactor.core.scheduler.Schedulers
//com.xxx.common.redis.utils.RedisSetUtils
private void asyncBuildPhysicTableAndData(ObjectEntity entity) {
Mono.defer(() -> waitAndAcquire(entity.getId()))//stage1 延迟订阅,每次订阅才重新评估: 同一对象 ID 抢占 Redis 的锁; 抢不到则每 1 秒递归重试直至拿到标记
.then(Mono.fromRunnable(() -> {//stage2 抢到锁之后才执行的主体逻辑: 构建 TypeDB Snapshot → `syncSchema` 建物理表 → 回写属性物理字段名 → 写 `schemaChangeTime` → 再次置 ACTIVE 落库
ProjectHelper.setProjectCode(entity.getProjectCode());
// 本地 Schema 构建与同步激活共用同一段逻辑,避免两条路径的口径漂移
buildLocalSchema(entity);
SyncSkipReason skip = funnelObjectTypeBuilder.diagnoseObjectType(entity);
if (skip.noticeNeeded()) {
// 缺数据源不是失败:本地 schema 已建好,只跳过工作流创建,原因由 sync-info 面板提示
log.info("Skip funnel object type sync, no data source: objectTypeId={}, reason={}",
entity.getId(), skip);
} else {
try {
syncFunnelObjectType(entity);
} catch (Exception e) {
log.warn("同步到funnel失败:{}", e);
}
}
}))
.doFinally(s->{ //stage3 收尾: 无论成败都移除 Redis 占位标记(等价于: 释放锁)
RedisSetUtils.removeCacheSetValue( asyncObjectTaskSetPrefix, entity.getId()); //asyncObjectTaskSetPrefix = "object_task_queue"
})
.subscribeOn(Schedulers.boundedElastic()) //整条链(含 1 秒轮询等待)落到 boundedElastic 线程池,不占用调用方的请求线程,方法因此能立即返回
.subscribe(); //
private Mono<Void> waitAndAcquire(Long objectId) {//同一对象 ID 抢占 Redis 的锁;抢不到则每 1 秒递归重试直至拿到标记
return Mono.defer(() -> {
boolean acquired = RedisSetUtils.addCacheSetValue( asyncObjectTaskSetPrefix, objectId );
if (acquired) {
return Mono.empty();
}
return Mono.delay(Duration.ofSeconds(1)).then( waitAndAcquire(objectId) );
});
}
整个异步链路基于 reactor.core.publisher.Mono、reactor.core.scheduler.Scheduler、reactor.core.scheduler.Schedulers 等Reactor异步框架的异步组件实现。
Mono
.defer(抢占环节...)//延迟订阅,每次订阅才重新评估;这里包住 `waitAndAcquire(id)` —— 一个用 Redis Set 抢占位的递归重试
.then(真正的发布动作+上下文修复+funnel同步...)//抢到锁之后才执行的主体逻辑
.doFinally(收尾:移除redis占位锁...)
.subscribeOn(Schedulers.boundedElastic()) //整条链(含 1 秒轮询等待)落到 boundedElastic 线程池,不占用调用方的请求线程,方法因此能立即返回
.subscribe()
这条链就是该方法用 Reactor 写出的异步流水线本身
案例1:Mono.defer() → then() → doFinally() → subscribeOn() → subscribe() 经典示例
一个可本地直接跑起来的 Reactor 示例,用「加载用户会话 → 查询订单」两段串行任务,演示这条链路上每个算子的真实职责。
- 环境:JDK 17(本地 OpenJDK 17.0.2)、Reactor Core 3.7.17
- 入口类:
demo.MonoDeferChainDemo
目录结构
mono-defer-chain-demo/
├── pom.xml
├── README.md
└── src/main/java/demo/MonoDeferChainDemo.java
MonoDeferChainDemo
package demo;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import reactor.core.Disposable;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
/**
* Mono.defer() -> then() -> doFinally() -> subscribeOn() -> subscribe() 经典编排示例。
*
* 这条链路的语义分工:
* ① defer() :装配阶段只保存 Supplier,订阅瞬间才求值;每次订阅都重新求值(冷数据源)
* ② then(Mono) :串行编排,等上游【完成】后再执行下一个 Mono,并丢弃上游的值(不需要值传递)
* ③ doFinally() :终止钩子,无论 ON_COMPLETE / ON_ERROR / ON_CANCEL 都执行且只执行一次,用于资源清理
* ④ subscribeOn() :把订阅动作及其上游整体搬到指定调度器,整条链的第一个执行点落在该线程上
* ⑤ subscribe() :触发订阅,立即返回 Disposable(非阻塞),后续在主线程之外异步推进
*
* 运行方式见 README.md。
*/
public final class MonoDeferChainDemo {
private static final DateTimeFormatter TS = DateTimeFormatter.ofPattern("HH:mm:ss.SSS");
//会话序列
private static final AtomicInteger SESSION_SEQ = new AtomicInteger();
//订单序列
private static final AtomicInteger ORDER_SEQ = new AtomicInteger(9000);
public static void main(String[] args) throws InterruptedException {
banner("场景 0:defer 的延迟性 —— 装配阶段 vs 订阅瞬间");
demoDeferLaziness();
banner("场景 1:经典链路,正常完成 -> SignalType.ON_COMPLETE");
demoHappyPath();
banner("场景 2:链路中途报错 -> onError + SignalType.ON_ERROR");
demoErrorPath();
banner("场景 3:拿到 Disposable 主动取消 -> SignalType.ON_CANCEL");
demoCancelPath();
System.out.println("\n全部演示结束");
}
/* ============================== 场景 0 ============================== */
private static void demoDeferLaziness() {
log("main", "1) 装配开始,此时没有任何人 subscribe");
// 反例:Mono.just(...) 的入参先求值,副作用(IO / 加锁 / 取 ThreadLocal)在装配阶段就发生了
Mono<String> eager = Mono.just( loadSession(0) );
log("main", "2) 反例装配完成:loadSession 已在 main 线程执行(副作用提前发生,且只发生这一次): ");
// 正例:整个求值【推迟到】订阅瞬间,且每次订阅都重新求值
Mono<String> lazy = Mono.defer(() -> {
log("① defer", "supplier 此刻才执行(订阅瞬间)");
return Mono.fromCallable(() -> loadSession(0));
});
log("main", "3) 正例装配完成:什么也没发生,defer 只保存了一个 Supplier,不持有数据源");
log("main", "4) 第一次 block 订阅 lazy -> " + lazy.block());
log("main", "5) 第二次 block 订阅 lazy -> " + lazy.block() + " <- 序号变了,说明每次订阅都重建数据源");
}
/* ============================== 场景 1 ============================== */
private static void demoHappyPath() throws InterruptedException {
CountDownLatch done = new CountDownLatch(1);
Disposable disposable = classicChain("正常链路", 80, 60, false)
.subscribe(
value -> log("⑤ onNext", "收到最终结果 -> " + value),
error -> {
log("⑤ onError", "异常: " + error.getMessage());
done.countDown();
},
() -> {
log("⑤ onComplete", "序列正常结束,此后不会再有任何 onNext");
done.countDown();
}
);
log("main", "subscribe() 立即返回 Disposable(非阻塞),主线程继续往下走");
if (!done.await(5, TimeUnit.SECONDS)) {
log("main", "等待超时(5s 内没有终止信号)");
}
Thread.sleep(50); // 稍等片刻,让 doFinally(在终止信号向下游传播之后执行)也打印出来
log("main", "done 之后 disposable.isDisposed() = " + disposable.isDisposed());
}
/* ============================== 场景 2 ============================== */
private static void demoErrorPath() throws InterruptedException {
CountDownLatch done = new CountDownLatch(1);
classicChain("错误链路", 60, 0, true)
.subscribe(
value -> log("⑤ onNext", "收到最终结果 -> " + value),
error -> {
log("⑤ onError", "捕获异常: " + error.getMessage());
done.countDown();
},
() -> {
log("⑤ onComplete", "正常结束");
done.countDown();
}
);
done.await(5, TimeUnit.SECONDS);
log("main", "报错后链路终止,但 doFinally 仍然执行了清理");
}
/* ============================== 场景 3 ============================== */
private static void demoCancelPath() throws InterruptedException {
Disposable disposable = classicChain("取消链路", 400, 0, false)
.subscribe(value -> log("⑤ onNext", "收到最终结果 -> " + value));
Thread.sleep(100); // 让第一步先跑起来,确保取消发生在链路中途
log("main", "链路运行中,调用 disposable.dispose() 触发 cancel");
disposable.dispose();
Thread.sleep(300); // 等 doFinally 打印
log("main", "disposable.isDisposed() = " + disposable.isDisposed()
+ "(取消后 onComplete / onError 都不会被调用,只有 doFinally 能收到 ON_CANCEL)");
}
/* ============================== 核心链路 ============================== */
private static Mono<String> classicChain(String label, long stage1Ms, long stage2Ms, boolean failInStage2) {
return Mono
// ① defer:容器在装配阶段创建,但 supplier 只在被订阅时执行;每次订阅都重新执行
.defer(() -> {
log("① defer", label + " | supplier 执行:准备用户会话(每次订阅都会重跑)");
return Mono.fromCallable(() -> loadSession(stage1Ms));
})
// ② then:等上游完成,丢弃上游的值,再执行下一个 Mono(顺序依赖,不需要值传递)
.then(Mono.defer(() -> {
log("② then", label + " | 上游已完成,现在才启动第二步(丢弃了 session 值,只取「完成」信号)");
return Mono.fromCallable(() -> {
if (failInStage2) {
throw new IllegalStateException("下游订单服务 503");
}
return queryOrder(stage2Ms);
});
}))
// ③ doFinally:终止钩子,ON_COMPLETE / ON_ERROR / ON_CANCEL 之一,只执行一次
.doFinally(signal -> log("③ doFinally", label + " | 清理资源(连接归池、MDC 清理),signal=" + signal))
// ④ subscribeOn:把订阅动作连同上游(defer 的 supplier 与两个 callable)整体搬到弹性线程池
.subscribeOn(Schedulers.boundedElastic());
}
/* ============================== 模拟 IO ============================== */
private static String loadSession(long delayMs) {
sleep(delayMs);
return "session#" + SESSION_SEQ.incrementAndGet();
}
private static String queryOrder(long delayMs) {
sleep(delayMs);
return "order#" + ORDER_SEQ.incrementAndGet() + " 待发货";
}
/**
* 演示用的阻塞等待。
* 注意:调用 dispose() 取消时,Reactor 会中断当前工作线程;这里把中断视为「任务提前结束」直接返回,
* 返回值随后会被取消信号丢弃,从而避免在取消路径上再抛出 InterruptedException 造成 onErrorDropped 噪音。
*/
private static void sleep(long millis) {
if (millis <= 0) {
return;
}
try {
Thread.sleep(millis);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // 保留中断标记,交回上层决定是否终止
}
}
/* ============================== 输出工具 ============================== */
private static void log(String step, String message) {
System.out.printf("%s | %-16s | %-12s | %s%n",
LocalTime.now().format(TS),
Thread.currentThread().getName(),
step,
message);
}
private static void banner(String title) {
System.out.println("\n========== " + title + " ==========");
}
}
输出
========== 场景 0:defer 的延迟性 —— 装配阶段 vs 订阅瞬间 ==========
21:00:57.753 | main | main | 1) 装配开始,此时没有任何人 subscribe
21:00:57.809 | main | main | 2) 反例装配完成:loadSession 已在 main 线程执行(副作用提前发生,且只发生这一次):
21:00:57.810 | main | main | 3) 正例装配完成:什么也没发生,defer 只保存了一个 Supplier,不持有数据源
21:00:57.817 | main | ① defer | supplier 此刻才执行(订阅瞬间)
21:00:57.823 | main | main | 4) 第一次 block 订阅 lazy -> session#2
21:00:57.824 | main | ① defer | supplier 此刻才执行(订阅瞬间)
21:00:57.824 | main | main | 5) 第二次 block 订阅 lazy -> session#3 <- 序号变了,说明每次订阅都重建数据源
========== 场景 1:经典链路,正常完成 -> SignalType.ON_COMPLETE ==========
21:00:57.844 | main | main | subscribe() 立即返回 Disposable(非阻塞),主线程继续往下走
21:00:57.896 | boundedElastic-1 | ① defer | 正常链路 | supplier 执行:准备用户会话(每次订阅都会重跑)
21:00:57.981 | boundedElastic-1 | ② then | 正常链路 | 上游已完成,现在才启动第二步(丢弃了 session 值,只取「完成」信号)
21:00:58.045 | boundedElastic-1 | ⑤ onNext | 收到最终结果 -> order#9001 待发货
21:00:58.046 | boundedElastic-1 | ⑤ onComplete | 序列正常结束,此后不会再有任何 onNext
21:00:58.051 | boundedElastic-1 | ③ doFinally | 正常链路 | 清理资源(连接归池、MDC 清理),signal=onComplete
21:00:58.110 | main | main | done 之后 disposable.isDisposed() = true
========== 场景 2:链路中途报错 -> onError + SignalType.ON_ERROR ==========
21:00:58.112 | boundedElastic-1 | ① defer | 错误链路 | supplier 执行:准备用户会话(每次订阅都会重跑)
21:00:58.186 | boundedElastic-1 | ② then | 错误链路 | 上游已完成,现在才启动第二步(丢弃了 session 值,只取「完成」信号)
21:00:58.186 | boundedElastic-1 | ⑤ onError | 捕获异常: 下游订单服务 503
21:00:58.187 | main | main | 报错后链路终止,但 doFinally 仍然执行了清理
========== 场景 3:拿到 Disposable 主动取消 -> SignalType.ON_CANCEL ==========
21:00:58.187 | boundedElastic-1 | ③ doFinally | 错误链路 | 清理资源(连接归池、MDC 清理),signal=onError
21:00:58.187 | boundedElastic-1 | ① defer | 取消链路 | supplier 执行:准备用户会话(每次订阅都会重跑)
21:00:58.293 | main | main | 链路运行中,调用 disposable.dispose() 触发 cancel
21:00:58.294 | main | ③ doFinally | 取消链路 | 清理资源(连接归池、MDC 清理),signal=cancel
21:00:58.608 | main | main | disposable.isDisposed() = true(取消后 onComplete / onError 都不会被调用,只有 doFinally 能收到 ON_CANCEL)
全部演示结束
案例解读
核心链路
Mono.defer(() -> { // ① 订阅瞬间才求值,每次订阅都重跑
log("① defer", "supplier 执行:准备用户会话");
return Mono.fromCallable(() -> loadSession(80));
})
.then(Mono.defer(() -> { // ② 上游完成后再启动第二步,丢弃上游的值
log("② then", "上游已完成,现在才启动第二步");
return Mono.fromCallable(() -> queryOrder(60));
}))
.doFinally(signal -> log("③ doFinally", "清理资源,signal=" + signal)) // ③ 终止钩子,只执行一次
.subscribeOn(Schedulers.boundedElastic()) // ④ 订阅动作连同上游整体切线程
.subscribe( // ⑤ 触发,立即返回 Disposable
value -> log("⑤ onNext", "结果 -> " + value),
error -> log("⑤ onError", "异常: " + error.getMessage()),
() -> log("⑤ onComplete", "序列结束")
);
各算子职责
| 算子 | 做什么 | 示例中验证了什么 | 常见误用 |
|---|---|---|---|
defer(Supplier<Mono>) |
装配阶段只保存 Supplier,订阅时才调用它生成真正的数据源 | 反例 Mono.just(loadSession()) 在装配时就把 IO 执行完了;defer 版本订阅两次拿到两个不同 session 序号 |
用 Mono.just(service.query()) 包装阻塞调用,导致「还没订阅就已执行」 |
then(Mono<V>) |
等上游完成,丢弃上游的值,再订阅下一个 Mono | 日志里第二步在第一步结束之后才打印,且 session# 的值没有传到下游 |
需要传递上游结果时误用 then;此时应用 flatMap / map / zipWith |
doFinally(Consumer<SignalType>) |
终止钩子,ON_COMPLETE / ON_ERROR / ON_CANCEL 三选一,只执行一次,且在终端信号向下游传播之后执行 |
三个场景分别打印 signal=onComplete、signal=onError、signal=cancel |
用 doOnSuccess 做资源释放——错误和取消路径会漏掉 |
subscribeOn(Scheduler) |
把「订阅动作」及其整个上游搬到指定调度器 | 日志线程名为 boundedElastic-1,而不是 main |
以为它只影响源头;实际上没有 publishOn 时下游回调也在同一个线程。多次 subscribeOn 只有最靠近源头的那次生效 |
subscribe(...) |
触发订阅,立即返回 Disposable,不阻塞调用线程 |
subscribe() 后主线程立刻打印日志,实际执行在弹性线程池里异步完成 |
在 WebFlux 业务代码里手工 subscribe(),绕过了框架的背压与生命周期管理 |
四种终止路径的实际表现
| 场景 | 触发方式 | subscribe 收到 |
doFinally 收到 |
|---|---|---|---|
| 正常完成 | 第二步返回结果 | onNext → onComplete |
ON_COMPLETE |
| 中途报错 | 第二步抛异常 | onError(onComplete 不再触发) |
ON_ERROR |
| 主动取消 | disposable.dispose() |
两个回调都不触发 | ON_CANCEL |
| 装配后未订阅 | —— | 什么都不发生(含 defer 的 Supplier 也不会执行) |
不触发 |
运行方式
方式一:直接用本地 JDK 运行(无需联网)
$proj = "C:\Users\vire\Doubao\chats\2026-11-05\new-chat-6\mono-defer-chain-demo"
$cp = "$env:USERPROFILE\.m2\repository\io\projectreactor\reactor-core\3.7.17\reactor-core-3.7.17.jar;" +
"$env:USERPROFILE\.m2\repository\org\reactivestreams\reactive-streams\1.0.4\reactive-streams-1.0.4.jar"
javac -encoding UTF-8 -cp $cp -d "$proj\target\classes" "$proj\src\main\java\demo\MonoDeferChainDemo.java"
java -cp "$cp;$proj\target\classes" demo.MonoDeferChainDemo
上面的
$cp用的是默认仓库~/.m2/repository。本机settings.xml把localRepository指向了D:\Program-Data\Maven-Repository,两处都能找到这两个 jar;换机器时按自己的仓库路径调整即可。
方式二:用 Maven
mvn -q -DskipTests compile
mvn -q dependency:build-classpath -Dmdep.outputFile=cp.txt
java -cp "target\classes;$(Get-Content cp.txt -Raw)" demo.MonoDeferChainDemo
Windows 控制台默认 GBK,中文日志若显示乱码,可先重定向到文件再查看,或把控制台编码设为 UTF-8。
三个容易踩的细节
defer的价值在于「每次订阅都重新求值」。它不只是延迟执行:同一条Mono被订阅两次,Supplier 会跑两次,分别拿到新数据;而Mono.just(obj)里的obj只求值一次。doFinally不能改结果。它拿到的只是SignalType,无法把错误吞掉;要兜底错误用onErrorResume,要观测错误用doOnError。subscribeOn不是万能的线程切换。它作用于订阅信号所在的位置;then之后的第二个 Mono 的flatMap内部若再切线程,需要用subscribeOn/publishOn精准控制,否则整条链会一直跑在第一次切换到的线程上(本示例里三个阶段都在boundedElastic-1)。
演示代码中的取舍
sleep() 里对 InterruptedException 只恢复中断标记、不向上抛:取消链路时 Reactor 会中断工作线程,若在这里抛 IllegalStateException,取消本身不会把错误传给下游 subscriber,最终只会变成 onErrorDropped 的日志噪音。真实业务里应在取消/超时语义下显式处理中断,而不是无脑吞掉。
案例2
Demo : 总入口
源码
package demo;
/**
* 示例入口:按主题分组运行,验证 reactor-core 3.7.17 上的真实行为。
*/
public class Demo {
public static void main(String[] args) throws Exception {
System.out.println("===== 1. 创建 (CreateDemo) =====");
CreateDemo.run();
System.out.println("\n===== 2. 变换 (TransformDemo) =====");
TransformDemo.run();
System.out.println("\n===== 3. 错误处理 (ErrorDemo) =====");
ErrorDemo.run();
System.out.println("\n===== 4. 副作用 (SideEffectDemo) =====");
SideEffectDemo.run();
System.out.println("\n===== 5. 调度与上下文 (SchedulingDemo) =====");
SchedulingDemo.run();
System.out.println("\n===== 6. 订阅与取值 (SubscribeDemo) =====");
SubscribeDemo.run();
System.out.println("\n===== ALL DONE =====");
// 示例里创建了 Reactor 调度器线程与非守护线程,显式退出避免 JVM 挂住
System.exit(0);
}
}
输出
===== 1. 创建 (CreateDemo) =====
[just] A
[justOrEmpty(null)] null
[justOrEmpty(emptyOpt)] null
[empty] block=null
[error + onErrorReturn] fallback
[never] 超时符合预期: TimeoutException
[fromCallable] 3
[fromSupplier] supplied
[fromRunnable] 完成,counter=1
[fromFuture] cf-value
[fromCompletionStage] cf-value-cs
[from(Flux)] x
>> defer 内部执行(每次订阅都会执行一次)
[defer 第1次订阅] deferred-value
>> defer 内部执行(每次订阅都会执行一次)
[defer 第2次订阅] deferred-value
[deferContextual] tenant=t-001
[create] from-sink
[zip] user-1/28
[zipWith] order-9 = 99.5
[zipWhen] u-1 -> u-1's profile
[firstWithValue] fast
[hasElement] true
[Flux.merge + hasElements] true
[when] all-completed
>> cleanup resource#1
[using] use resource#1
>> async cleanup conn#1
[usingWhen] query on conn#1
===== 2. 变换 (TransformDemo) =====
[map] ABC
[mapNotNull] null
[cast] casted
[filter 命中] 10
[filter 未命中] null
[filterWhen] u-1
[flatMap] profile-of-u-1
[flatMapMany] 3
[handle] odd-7
[then] next
[thenReturn] literal
[thenEmpty] null
[and] both-done
[defaultIfEmpty] default
[switchIfEmpty] from-cache
[materialize] type=onNext, value=sig
[materialize+dematerialize] sig
[transform] [T]
[transformDeferred] deferred-d
[transformDeferredContextual] v@cn-west
[map 返回 Mono 的错误示范] c-wrapped
[正确写法 flatMap] c-flat
[as] a-as
===== 3. 错误处理 (ErrorDemo) =====
[onErrorReturn] fallback
[onErrorReturn(Class)] io-default
[onErrorResume] backup:down
[onErrorResume(predicate)] net-fallback
[onErrorMap] IllegalStateException: 业务异常: 存储不可用 / cause=IOException
[retry] ok after 3 / 调用次数=3
[retryWhen] ok after 3 / 调用次数=3
[timeout + onErrorResume] timeout-fallback
[timeout + fallback] cached-value
>> 记录错误: observe me
[doOnError] ok
[onErrorContinue 不生效] 异常仍抛出: skip
[block 抛出] IllegalStateException: signal-error
===== 4. 副作用 (SideEffectDemo) =====
>> doOnSubscribe
>> doOnNext payload
>> doOnSuccess payload
>> doOnTerminate
>> doFinally onComplete
[doOnCancel] 下游取消,释放远端任务
[doFinally] cancel(枚举 SIGNAL CANCEL=cancel)
[doOnError] bad
>> doOnDiscard will-be-filtered
[name/tag] named
[checkpoint] recovered
[ INFO] (main) [Loggers] 生产代码请用 reactor.util.Loggers,而非 System.out
>> doOnEach signal=onNext
>> doOnEach signal=onComplete
===== 5. 调度与上下文 (SchedulingDemo) =====
[publishOn] v on boundedElastic-1
[subscribeOn] src on parallel-9
[delayElement] delayed / 耗时≈111ms
[delayUntil] do-work
[elapsed] 耗时=61ms, value=0
[context] traceId=trace-abc
[Schedulers.single] single-1
[阻塞调用正确姿势] blocking-io-done
===== 6. 订阅与取值 (SubscribeDemo) =====
[subscribe(1)] v1
[subscribe(3)] onNext v2
[subscribe(3)] onComplete
[subscribe(4)] onSubscribe, 可随时 cancel
[block] blocked
[blockOptional] Optional.empty
[toFuture] future
[toFuture 超时] TimeoutException
[cache #1] r-1 / 调用次数=1
[cache #2] r-1 / 调用次数=1
[无 cache] 调用次数=2(cold publisher 每次订阅都执行)
[share] 调用次数=1
===== ALL DONE =====
CreateDemo
package demo;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.util.context.Context;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 创建类方法:如何"造"出一个 Mono。
* <p>
* 核心语义:Mono = 0..1 个元素的异步序列;构造时不执行,订阅(block/subscribe)时才执行(cold publisher)。
*/
public class CreateDemo {
public static void run() {
// 1) just:包装一个已存在的值。注意值在装配时就已经算好,且不能为 null
System.out.println("[just] " + Mono.just("A").block());
// 2) justOrEmpty:null 或 Optional.empty 退化为 empty()
System.out.println("[justOrEmpty(null)] " + Mono.justOrEmpty((String) null).block());
System.out.println("[justOrEmpty(emptyOpt)] " + Mono.justOrEmpty(Optional.empty()).block());
// 3) empty:正常完成但无值,是 Mono<Void> 的主要来源
System.out.println("[empty] block=" + Mono.empty().block());
// 4) error:立即以错误信号终止,常用于校验失败/短路
String v4 = Mono.<String>error(new IllegalStateException("boom"))
.onErrorReturn("fallback")
.block();
System.out.println("[error + onErrorReturn] " + v4);
// 5) never:永不发出任何信号。只能做占位,必须自己加 timeout 兜底
try {
Mono.never().toFuture().get(200, TimeUnit.MILLISECONDS);
} catch (Exception e) {
System.out.println("[never] 超时符合预期: " + e.getClass().getSimpleName());
}
// 6) fromCallable:把可能抛异常的同步计算延迟到订阅时执行
System.out.println("[fromCallable] " + Mono.fromCallable(() -> Math.addExact(1, 2)).block());
// 7) fromSupplier:纯生产、不支持受检异常
System.out.println("[fromSupplier] " + Mono.fromSupplier(() -> "supplied").block());
// 8) fromRunnable:只关心"做完了",不关心返回值 -> Mono<Void>
// 坑:thenReturn("...") 的参数在"装配期"就求值,想拿运行后的值必须用 defer
AtomicInteger counter = new AtomicInteger();
System.out.println("[fromRunnable] " + Mono.fromRunnable(counter::incrementAndGet)
.then(Mono.defer(() -> Mono.just("完成,counter=" + counter.get())))
.block());
// 9) fromFuture / fromCompletionStage:桥接阻塞式异步 API
CompletableFuture<String> cf = CompletableFuture.supplyAsync(() -> "cf-value");
System.out.println("[fromFuture] " + Mono.fromFuture(cf).block());
System.out.println("[fromCompletionStage] "
+ Mono.fromCompletionStage(cf.thenApply(s -> s + "-cs")).block());
// 10) from(Publisher):按 Mono 语义只保留最后(唯一)一个元素
System.out.println("[from(Flux)] " + Mono.from(Flux.just("x", "y", "z")).block());
// 11) defer:Mono 的"装配逻辑"延迟到订阅时才执行,适合订阅时才取配置/建连接
Mono<String> deferred = Mono.defer(() -> {
System.out.println(" >> defer 内部执行(每次订阅都会执行一次)");
return Mono.just("deferred-value");
});
System.out.println("[defer 第1次订阅] " + deferred.block());
System.out.println("[defer 第2次订阅] " + deferred.block());
// 12) deferContextual:装配阶段就能读取 Reactor Context(多租户/链路透传常用)
Mono<String> ctxMono = Mono.deferContextual(ctx -> Mono.just("tenant=" + ctx.get("tenant")))
.contextWrite(Context.of("tenant", "t-001"));
System.out.println("[deferContextual] " + ctxMono.block());
// 13) create:把回调式/事件式 API 桥接成 Mono(手动控制成功/失败)
Mono<String> created = Mono.create(sink -> new Thread(() -> {
// 模拟异步回调;真实场景常见于 Netty handler、监听器、回调式 SDK
sink.success("from-sink");
}).start());
System.out.println("[create] " + created.block());
// 14) zip:并行汇聚 2~8 个 Mono,任意一个 error 则整体 error
System.out.println("[zip] " + Mono.zip(Mono.just("user-1"), Mono.just(28))
.map(t -> t.getT1() + "/" + t.getT2())
.block());
// 15) zipWith:以左 Mona 为主视角的 zip
System.out.println("[zipWith] " + Mono.just("order-9")
.zipWith(Mono.just(99.5))
.map(t -> t.getT1() + " = " + t.getT2())
.block());
// 16) zipWhen:拿第一个结果去触发第二个 Mono(有依赖的串行聚合)
System.out.println("[zipWhen] " + Mono.just("u-1")
.zipWhen(uid -> Mono.just(uid + "'s profile"))
.map(t -> t.getT1() + " -> " + t.getT2())
.block());
// 17) firstWithValue:竞速,取最先"发出值"的那个
System.out.println("[firstWithValue] " + Mono.firstWithValue(
Mono.delay(java.time.Duration.ofMillis(200)).map(i -> "slow"),
Mono.just("fast")).block());
// 18) 注意:Mono 本身没有 any()。- Mono 是 0..1,判断"是否有值"用 hasElement();
// "多个源里任意一个有值" 要先 merge 成 Flux 再 hasElements()
System.out.println("[hasElement] " + Mono.just("hit").hasElement().block());
System.out.println("[Flux.merge + hasElements] "
+ Flux.merge(Mono.<String>empty(), Mono.just("hit")).hasElements().block());
// 19) when:等全部完成、只关心完成本身 -> Mono<Void>
System.out.println("[when] " + Mono.when(Mono.just("a"), Mono.empty())
.thenReturn("all-completed").block());
// 20) using:资源绑定,无论成功/失败/取消都会执行 cleanup
System.out.println("[using] " + Mono.using(
() -> "resource#1",
res -> Mono.just("use " + res),
res -> System.out.println(" >> cleanup " + res)).block());
// 21) usingWhen:cleanup 也可以是异步 Publisher,适合关连接池/回滚事务
System.out.println("[usingWhen] " + Mono.usingWhen(
Mono.just("conn#1"),
conn -> Mono.just("query on " + conn),
conn -> Mono.fromRunnable(() -> System.out.println(" >> async cleanup " + conn)))
.block());
}
}
ErrorDemo
package demo;
import reactor.core.publisher.Mono;
import reactor.util.retry.Retry;
import java.io.IOException;
import java.time.Duration;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 错误处理类方法:error 信号只会走 onError* 这一族,不会走 map/filter。
* <p>
* empty 与 error 是两种完全不同的终态:empty 走 switchIfEmpty/defaultIfEmpty,error 走 onErrorXxx。
*/
public class ErrorDemo {
/** 模拟不稳定的远程调用:前 2 次失败,第 3 次成功。 */
private static Mono<String> flaky(AtomicInteger attempts) {
return Mono.defer(() -> {
int n = attempts.incrementAndGet();
return n < 3 ? Mono.error(new IOException("call failed #" + n)) : Mono.just("ok after " + n);
});
}
/** 一个"慢且返回 String"的 Mono:先用 map 换成 String,再配合 timeout 演示。 */
private static Mono<String> slowString(long millis) {
return Mono.delay(Duration.ofMillis(millis)).map(i -> "slow-result");
}
public static void run() {
// 1) onErrorReturn:任何错误降级为固定值
System.out.println("[onErrorReturn] " + Mono.<String>error(new RuntimeException("x"))
.onErrorReturn("fallback").block());
// 2) onErrorReturn(类型, 值):只兜住指定异常类型,其它异常继续向上抛
System.out.println("[onErrorReturn(Class)] " + Mono.<String>error(new IOException("io"))
.onErrorReturn(IOException.class, "io-default").block());
// 3) onErrorResume:按错误切换备用 Publisher(重试/降级/查缓存都靠它)
System.out.println("[onErrorResume] " + Mono.<String>error(new IllegalStateException("down"))
.onErrorResume(e -> Mono.just("backup:" + e.getMessage())).block());
// 4) onErrorResume(谓词, 函数):按异常类型精细化分流
System.out.println("[onErrorResume(predicate)] " + Mono.<String>error(new IOException("net"))
.onErrorResume(IOException.class::isInstance, e -> Mono.just("net-fallback"))
.block());
// 5) onErrorMap:错误转译/包装,保留因果链(对上层暴露业务异常)
try {
Mono.error(new IOException("disk full"))
.onErrorMap(e -> new IllegalStateException("业务异常: 存储不可用", e))
.block();
} catch (Exception e) {
System.out.println("[onErrorMap] " + e.getClass().getSimpleName() + ": " + e.getMessage()
+ " / cause=" + e.getCause().getClass().getSimpleName());
}
// 6) retry:固定次数重试(无退避,短时抖动救急可以,生产建议用 retryWhen)
AtomicInteger a1 = new AtomicInteger();
System.out.println("[retry] " + flaky(a1).retry(2).block() + " / 调用次数=" + a1.get());
// 7) retryWhen + Retry:指数退避 + 过滤可重试异常,生产标准做法
AtomicInteger a2 = new AtomicInteger();
System.out.println("[retryWhen] " + flaky(a2)
.retryWhen(Retry.backoff(3, Duration.ofMillis(20))
.maxBackoff(Duration.ofMillis(200))
.filter(e -> e instanceof IOException)
.onRetryExhaustedThrow((spec, signal) -> signal.failure()))
.block() + " / 调用次数=" + a2.get());
// 8) timeout:超时转成 TimeoutException 信号,交给下游兜底
System.out.println("[timeout + onErrorResume] " + slowString(500)
.timeout(Duration.ofMillis(100))
.onErrorResume(TimeoutException.class, e -> Mono.just("timeout-fallback"))
.block());
// 9) 注意:Mono 没有 timeout(Duration, Mono) 这种"带备用值"的 overload(Flux 才有类似重载思路),
// 要"超时直接用缓存值"必须写成 timeout + onErrorResume,或 timeout + switchIfEmpty 的组合
System.out.println("[timeout + fallback] " + slowString(500)
.timeout(Duration.ofMillis(100))
.onErrorResume(TimeoutException.class, e -> Mono.just("cached-value"))
.block());
// 10) doOnError:只观测,不改变信号(打日志/上报指标)
System.out.println("[doOnError] " + Mono.<String>error(new RuntimeException("observe me"))
.doOnError(e -> System.out.println(" >> 记录错误: " + e.getMessage()))
.onErrorReturn("ok").block());
// 11) onErrorContinue:本意是"跳过出错元素继续",但它要求错误由某个 onNext 触发;
// Mono.error 这种"没有元素、直接发错误"的场景它不生效,错误会原样抛到 block()。
// 验证结论:Mono 里不要指望 onErrorContinue,用 onErrorResume/onErrorReturn 更可靠。
try {
Mono.<String>error(new RuntimeException("skip"))
.onErrorContinue((e, v) -> System.out.println(" >> 跳过: " + e.getMessage() + ", value=" + v))
.block();
System.out.println("[onErrorContinue] 被跳过了(未抛异常)");
} catch (Exception e) {
System.out.println("[onErrorContinue 不生效] 异常仍抛出: " + e.getMessage());
}
// 12) 异步异常 vs 同步异常:error 信号不是 throw 出来的异常,必须用 try/catch 才能拿到
try {
Mono.<String>error(new IllegalStateException("signal-error")).block();
} catch (Exception e) {
System.out.println("[block 抛出] " + e.getClass().getSimpleName() + ": " + e.getMessage());
}
}
}
SchedulingDemo
package demo;
import reactor.core.publisher.Mono;
import reactor.core.scheduler.Schedulers;
import reactor.util.context.Context;
import java.time.Duration;
/**
* 线程调度 / 时间 / 上下文类方法。
* <p>
* publishOn:影响"它下游"的算子执行线程;subscribeOn:影响"它上游"的订阅与源头执行线程。
*/
public class SchedulingDemo {
public static void run() {
// 1) publishOn:之后的算子切到指定调度器执行(常用于把阻塞调用挪出 event loop)
System.out.println("[publishOn] "
+ Mono.just("v")
.publishOn(Schedulers.boundedElastic())
.map(v -> v + " on " + Thread.currentThread().getName())
.block());
// 2) subscribeOn:源头(如 fromCallable)在哪个调度器上执行,链路中位置不影响结果
System.out.println("[subscribeOn] "
+ Mono.fromCallable(() -> "src on " + Thread.currentThread().getName())
.subscribeOn(Schedulers.parallel())
.block());
// 3) delayElement:给"值"加延迟(值到达后延迟再发出)
long t0 = System.currentTimeMillis();
System.out.println("[delayElement] " + Mono.just("delayed")
.delayElement(Duration.ofMillis(100))
.block() + " / 耗时≈" + (System.currentTimeMillis() - t0) + "ms");
// 4) delayUntil:等下游动作完成后再放行(不是固定延迟,而是"完成后才继续")
System.out.println("[delayUntil] " + Mono.just("do-work")
.delayUntil(v -> Mono.delay(Duration.ofMillis(80)).then())
.block());
// 5) elapsed:记录"从订阅到发值"的耗时,返回 Tuple2<Long, T>(毫秒)
System.out.println("[elapsed] " + Mono.delay(Duration.ofMillis(60))
.elapsed()
.map(t -> "耗时=" + t.getT1() + "ms, value=" + t.getT2())
.block());
// 6) contextWrite + deferContextual:Context 是"只读向下、写入向上"的,写入点是下游
String trace = Mono.deferContextual(ctx -> Mono.just("traceId=" + ctx.get("traceId")))
.contextWrite(Context.of("traceId", "trace-abc"))
.block();
System.out.println("[context] " + trace);
// 7) 单例调度器:Schedulers.single() 只有一个线程,适合事件循环/串行任务
System.out.println("[Schedulers.single] "
+ Mono.fromCallable(() -> Thread.currentThread().getName())
.subscribeOn(Schedulers.single()).block());
// 8) 常见误用:在 map/flatMap 里做阻塞 IO(JDBC、sleep、RestTemplate)
// 正确姿势是把阻塞调用放进 boundedElastic,并且不要占用 parallel 线程
System.out.println("[阻塞调用正确姿势] " + Mono.fromCallable(() -> {
Thread.sleep(50); // 模拟阻塞 IO
return "blocking-io-done";
})
.subscribeOn(Schedulers.boundedElastic())
.block());
}
}
SideEffectDemo
package demo;
import reactor.core.publisher.Mono;
import reactor.core.publisher.SignalType;
import reactor.util.Logger;
import reactor.util.Loggers;
import reactor.util.context.Context;
import java.time.Duration;
/**
* 副作用类方法(doOnXxx):用来打日志、埋点、清理。
* <p>
* 铁律:doOnXxx 必须是"轻、非阻塞、无异常"的;不能在里面改值(改值用 map/flatMap)。
*/
public class SideEffectDemo {
private static final Logger log = Loggers.getLogger(SideEffectDemo.class);
public static void run() {
// 1) doOnSubscribe:订阅发生的那一刻(每次订阅都会触发,可用于统计订阅次数)
// 2) doOnNext:成功拿到值的时候
// 3) doOnSuccess:成功终态(有值、无值都会触发,参数可能为 null)
// 4) doFinally:无论成功/失败/取消都会执行(资源清理的兜底)
Mono.just("payload")
.doOnSubscribe(s -> System.out.println(" >> doOnSubscribe"))
.doOnNext(v -> System.out.println(" >> doOnNext " + v))
.doOnSuccess(v -> System.out.println(" >> doOnSuccess " + v))
.doOnTerminate(() -> System.out.println(" >> doOnTerminate"))
.doFinally(st -> System.out.println(" >> doFinally " + st))
.block();
// 5) doOnCancel:下游取消订阅时触发(WebFlux 客户端断开常见)
// doFinally 里也能看到 SignalType.CANCEL,这里用单独订阅演示
reactor.core.Disposable d = Mono.delay(Duration.ofSeconds(5))
.doOnCancel(() -> System.out.println("[doOnCancel] 下游取消,释放远端任务"))
.doFinally(st -> System.out.println("[doFinally] " + st + "(枚举 SIGNAL CANCEL="
+ SignalType.CANCEL + ")"))
.subscribe();
d.dispose();
// 6) doOnError:错误信号观测(不改变错误本身)
Mono.<String>error(new RuntimeException("bad"))
.doOnError(e -> System.out.println("[doOnError] " + e.getMessage()))
.onErrorReturn("ok")
.block();
// 7) doOnDiscard:被丢弃的元素回调(filter/switchIfEmpty 等算子会丢弃元素)
// 主要用于释放被丢弃对象持有的资源(如 Netty ByteBuf)
Mono.just("will-be-filtered")
.filter(s -> false)
.doOnDiscard(String.class, s -> System.out.println(" >> doOnDiscard " + s))
.defaultIfEmpty("empty").block();
// 8) log:Reactor 内置链路日志,能看到 subscribe/onNext/onComplete 等信号
Mono.just("logged")
.log("mono-demo", java.util.logging.Level.FINE)
.block();
// 9) name / tag:给链路打名字与标签,便于 metrics() 与日志定位
Mono.just("named")
.name("biz.user.query")
.tag("tenant", "t-001")
.doOnNext(v -> System.out.println("[name/tag] " + v))
.block();
// 10) checkpoint:失败时给错误附加"链路位置"描述,排查长链路非常有用
Mono.<String>error(new IllegalStateException("boom"))
.checkpoint("after-step-2")
.onErrorMap(e -> new IllegalStateException("定位: " + e.getMessage(), e))
.onErrorReturn("recovered")
.doOnNext(v -> System.out.println("[checkpoint] " + v))
.block();
// 11) 日志器建议用 Loggers(自动适配 SLF4J),不要在链里直接 System.out
log.info("[Loggers] 生产代码请用 reactor.util.Loggers,而非 System.out");
// 12) contextWrite 属于"上下文"而非副作用,但常与日志一起用于链路透传
Mono.just("trace")
.doOnEach(sig -> System.out.println(" >> doOnEach signal=" + sig.getType()))
.contextWrite(Context.of("traceId", "trace-123"))
.block();
}
}
SubscribeDemo (必读)
package demo;
import reactor.core.publisher.Mono;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 订阅与取值类方法:subscribe / block / toFuture / cache。
* <p>
* 原则:WebFlux 里由框架订阅(Controller 直接返回 Mono);只有在最外层适配同步代码时才 block。
*/
public class SubscribeDemo {
public static void run() throws Exception {
// 1) subscribe(consumer):最简订阅,错误信号会走 onErrorDropped(默认打日志,容易被吞)
Mono.just("v1").subscribe(v -> System.out.println("[subscribe(1)] " + v));
// 2) subscribe(onNext, onError, onComplete):三回调齐全,生产必备
CountDownLatch latch = new CountDownLatch(1);
Mono.just("v2").subscribe(
v -> System.out.println("[subscribe(3)] onNext " + v),
e -> System.out.println("[subscribe(3)] onError " + e.getMessage()),
() -> {
System.out.println("[subscribe(3)] onComplete");
latch.countDown();
});
latch.await(2, TimeUnit.SECONDS); // 订阅是非阻塞的,这里等回调跑完
// 3) subscribe 的 4 参版本:最后一个参数是 Consumer<Subscription>(拿到订阅句柄,用于取消)
reactor.core.Disposable d3 = Mono.just("v3")
.contextWrite(ctx -> ctx.put("uid", "u-1"))
.subscribe(v -> System.out.println("[subscribe(4)] " + v),
e -> System.out.println("[subscribe(4)] onError " + e.getMessage()),
() -> { },
sub -> System.out.println("[subscribe(4)] onSubscribe, 可随时 cancel"));
d3.dispose(); // 取消订阅
// 4) block:同步阻塞取值(拿不到值返回 null)。只能在非响应式线程的最外层用
System.out.println("[block] " + Mono.just("blocked").block());
// 5) blockOptional:值可能为空时更安全,返回 Optional
System.out.println("[blockOptional] " + Mono.<String>empty().blockOptional());
// 6) toFuture:转 CompletableFuture,方便与既有异步 API 衔接
CompletableFuture<String> f = Mono.just("future").toFuture();
System.out.println("[toFuture] " + f.get());
// 7) toFuture(超时):超时自动异常完成,避免上游永久挂住
CompletableFuture<String> f2 = Mono.delay(Duration.ofMillis(300)).map(i -> "late").toFuture();
try {
f2.get(100, TimeUnit.MILLISECONDS);
} catch (Exception e) {
System.out.println("[toFuture 超时] " + e.getClass().getSimpleName());
}
// 8) cache:把结果缓存下来,后续订阅复用同一个结果(把 cold 变 hot)
AtomicInteger calls = new AtomicInteger();
Mono<String> cached = Mono.fromCallable(() -> "r-" + calls.incrementAndGet()).cache();
System.out.println("[cache #1] " + cached.block() + " / 调用次数=" + calls.get());
System.out.println("[cache #2] " + cached.block() + " / 调用次数=" + calls.get());
// 9) 对照:不加 cache 时,每次订阅都会重新执行
AtomicInteger calls2 = new AtomicInteger();
Mono<String> cold = Mono.fromCallable(() -> "r-" + calls2.incrementAndGet());
cold.block();
cold.block();
System.out.println("[无 cache] 调用次数=" + calls2.get() + "(cold publisher 每次订阅都执行)");
// 10) share:cache + 引用计数,最后一个订阅者取消后自动失效(3.6+)
AtomicInteger calls3 = new AtomicInteger();
Mono<String> shared = Mono.fromCallable(() -> "s-" + calls3.incrementAndGet()).share();
shared.block();
shared.block();
System.out.println("[share] 调用次数=" + calls3.get());
}
}
TransformDemo(必读)
package demo;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.util.context.Context;
import reactor.util.context.ContextView;
/**
* 变换类方法:把一个 Mono 变成另一个 Mono/Flux。
* <p>
* 记住两条主线:同步变换用 map/handle/filter;异步变换(返回 Publisher)用 flatMap/flatMapMany。
*/
public class TransformDemo {
public static void run() {
// 1) map:1:1 同步转换(不能做 IO、不能阻塞、不能返回 Publisher)
System.out.println("[map] " + Mono.just("abc").map(String::toUpperCase).block());
// 2) mapNotNull:转换结果可能是 null 时用它,null 自动变 empty,避免 NPE / 空指针信号
System.out.println("[mapNotNull] " + Mono.just("x")
.mapNotNull(s -> s.length() > 5 ? s : null).block());
// 3) cast:类型擦除后的安全强转(比 (Mono<T>) 强转可读)
Mono<Object> obj = Mono.just((Object) "casted");
System.out.println("[cast] " + obj.cast(String.class).block());
// 4) filter:不满足条件 -> 变成 empty(不是 error,这点很关键)
System.out.println("[filter 命中] " + Mono.just(10).filter(i -> i > 5).block());
System.out.println("[filter 未命中] " + Mono.just(3).filter(i -> i > 5).block());
// 5) filterWhen:判断条件本身要查库/查缓存(异步判定)
System.out.println("[filterWhen] " + Mono.just("u-1")
.filterWhen(u -> Mono.just(u.endsWith("1"))).block());
// 6) flatMap:1:1 异步转换,闭包里通常是一次远程调用
System.out.println("[flatMap] " + Mono.just("u-1")
.flatMap(u -> Mono.just("profile-of-" + u)).block());
// 7) flatMapMany:1:N,Mono 之后展开成 Flux(一对多查询)
long count = Mono.just("u-1").flatMapMany(u -> Flux.just("a", "b", "c")).count().block();
System.out.println("[flatMapMany] " + count);
// 8) handle:map + filter 的合体,可显式发出 0..1 个值
System.out.println("[handle] " + Mono.just(7)
.handle((v, sink) -> {
if (v % 2 == 1) {
sink.next("odd-" + v); // 发出值
} // 不调用 next 就是 empty
}).block());
// 9) then / thenReturn / thenEmpty:忽略上游的值,只保留"完成"这一事实
System.out.println("[then] " + Mono.just("ignored")
.then(Mono.just("next")).block());
System.out.println("[thenReturn] " + Mono.empty().thenReturn("literal").block());
System.out.println("[thenEmpty] " + Mono.just("ignored")
.thenEmpty(Mono.empty()).block());
// 10) and:等两个都完成再发出完成信号(不关心值)
System.out.println("[and] " + Mono.just("a").and(Mono.just("b"))
.thenReturn("both-done").block());
// 11) defaultIfEmpty:给 empty 一个默认值
System.out.println("[defaultIfEmpty] " + Mono.<String>empty().defaultIfEmpty("default").block());
// 12) switchIfEmpty:empty 时切换到另一个 Publisher("查库未命中查缓存"的经典写法)
System.out.println("[switchIfEmpty] " + Mono.<String>empty()
.switchIfEmpty(Mono.defer(() -> Mono.just("from-cache"))).block());
// 13) materialize:把信号本身当成"值"发出来,便于统一观测/桥接响应式协议
System.out.println("[materialize] " + Mono.just("sig")
.materialize()
.map(sig -> "type=" + sig.getType() + ", value=" + sig.get())
.block());
// 13b) dematerialize:把 Signal 还原成真实信号;必须是 Signal 流,中间不能转成 String
// 反例(会先 ClassCastException,再被 onErrorDropped 吞掉,block() 永久阻塞)
System.out.println("[materialize+dematerialize] " + Mono.just("sig")
.materialize()
.dematerialize()
.block());
// 14) transform:对"整个 Mono"做组合式改造(复用算子、统一埋点),装配期执行一次
Mono<String> transformed = Mono.just("t")
.transform(m -> m.map(String::toUpperCase).map(s -> "[" + s + "]"));
System.out.println("[transform] " + transformed.block());
// 15) transformDeferred:transform 的延迟版本,每次订阅才应用算子
Mono<String> deferredTransform = Mono.just("d")
.transformDeferred(m -> m.map(s -> "deferred-" + s));
System.out.println("[transformDeferred] " + deferredTransform.block());
// 16) transformDeferredContextual:装配时还能读到 Context
Mono<String> ctxTransform = Mono.just("v")
.transformDeferredContextual((m, ctx) -> m.map(s -> s + "@" + ctx.getOrDefault("zone", "none")))
.contextWrite(Context.of("zone", "cn-west"));
System.out.println("[transformDeferredContextual] " + ctxTransform.block());
// 17) 典型误用:map 里返回 Mono 会得到嵌套的 Mono<Mono<String>>(Mono 上没有 concatMap)
// 正确做法是 flatMap。下面这行能编译,但值是"装着一个 Mono 的 Mono"
Mono<Mono<String>> nested = Mono.just("c").map(s -> Mono.just(s + "-wrapped"));
System.out.println("[map 返回 Mono 的错误示范] " + nested.block().block());
System.out.println("[正确写法 flatMap] " + Mono.just("c")
.flatMap(s -> Mono.just(s + "-flat")).block());
// 18) as:以"整个 Mono"为参数做一次整体适配(与 transform 同族,语义偏类型转换)
System.out.println("[as] " + Mono.just("a")
.as(m -> m.map(s -> s + "-as")).block());
}
}
X 参考文献
Y 推荐文献
本文作者:
千千寰宇
本文链接: https://www.cnblogs.com/johnnyzen
关于博文:评论和私信会在第一时间回复,或直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
日常交流:大数据与软件开发-QQ交流群: 774386015 【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力!
本文链接: https://www.cnblogs.com/johnnyzen
关于博文:评论和私信会在第一时间回复,或直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
日常交流:大数据与软件开发-QQ交流群: 774386015 【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力!

浙公网安备 33010602011771号