[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。

三个容易踩的细节

  1. defer 的价值在于「每次订阅都重新求值」。它不只是延迟执行:同一条 Mono 被订阅两次,Supplier 会跑两次,分别拿到新数据;而 Mono.just(obj) 里的 obj 只求值一次。
  2. doFinally 不能改结果。它拿到的只是 SignalType,无法把错误吞掉;要兜底错误用 onErrorResume,要观测错误用 doOnError。
  3. 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 推荐文献

posted @ 2026-11-05 20:55  千千寰宇  阅读(8)  评论(0)    收藏  举报