← 返回首页 ❓ 面试题库
📑 本篇章节导航 (共11章,点击直达)
一、响应式编程基础二、Flux/Mono高级操作三、Sinks四、Context上下文五、Scheduler线程模型六、背压(Backpressure)七、WebFlux实战八、R2DBC响应式数据库九、WebClient十、调试与可观测性面试速记口诀

Q112 Reactor与WebFlux响应式高级实战

20K Java+AI 岗位高频考点 — 响应式编程是高并发系统的核心技术。覆盖Reactor核心概念、Flux/Mono高级操作、Sinks、Context、Scheduler线程模型、背压、WebFlux实战、R2DBC、WebClient、调试与可观测性。

一、响应式编程基础

1. 什么是响应式编程?

2. Reactor的核心类型?

类型说明类比
Mono<T>0或1个元素的异步序列Optional<T>的异步版
Flux<T>0到N个元素的异步序列Stream<T>的异步版

// Mono: 单值结果
Mono<User> user = userRepository.findById(1L);

// Flux: 多值流
Flux<Order> orders = orderRepository.findByUserId(1L);

// 空值/完成信号
Mono<Void> done = userRepository.deleteById(1L);

要点:Mono和Flux都是惰性的,只有subscribe时才触发数据流。

3. 冷信号(Cold) vs 热信号(Hot)?


// 冷信号:每个订阅者独立触发数据生成
Flux<String> cold = Flux.just("A", "B", "C");
cold.subscribe(s -> log.info("订阅者1: {}", s)); // A, B, C
cold.subscribe(s -> log.info("订阅者2: {}", s)); // A, B, C(重新发射)

// 热信号:数据生成与订阅无关,后订阅的只能收到订阅后的数据
Flux<Long> hot = Flux.interval(Duration.ofSeconds(1)).publish().autoConnect();
Thread.sleep(2500);
hot.subscribe(i -> log.info("订阅者1: {}", i)); // 从2开始收

4. Cold转Hot的方式?

方式行为适用场景
publish().autoConnect()至少1个订阅者后开始,永不停止持续数据源(传感器)
publish().refCount()最后一个取消时停止,重新订阅时重新开始共享昂贵资源
share()等价于publish().refCount()简写形式
cache()缓存所有数据,新订阅者拿到完整历史重放历史数据
replay(N)缓存最近N个数据,新订阅者拿到最近N个滑动窗口广播

// share():最常用的Cold→Hot转换
Flux<StockPrice> shared = stockService.getPriceStream().share();
shared.subscribe(A::update);  // 订阅者A
shared.subscribe(B::update);  // 订阅者B,共享同一数据源

5. Reactor的声明式操作符链?


Mono<String> result = userRepository.findById(userId)      // 1. 查用户
    .switchIfEmpty(Mono.error(new UserNotFoundException())) // 2. 不存在则报错
    .flatMap(user -> orderService.findOrders(user.getId()))  // 3. 查订单
    .map(orders -> formatOrders(orders))                     // 4. 格式化
    .onErrorResume(e -> Mono.just("暂无订单"));               // 5. 兜底

二、Flux/Mono高级操作

6. flatMap vs concatMap vs flatMapSequential?

操作符并发性顺序性适用场景
flatMap并发无序不保证性能优先、顺序不重要
concatMap串行有序保证顺序敏感、需要串行
flatMapSequential并发执行保持原始顺序性能+顺序兼顾

// flatMap并发无序——性能最好
Flux.just(1, 2, 3)
    .flatMap(i -> httpClient.get("/api/" + i)) // 3个请求并发发出
    .subscribe();                               // 返回顺序不确定

// flatMap控制并发度
Flux.just(1, 2, 3, 4, 5)
    .flatMap(i -> httpClient.get("/api/" + i), 2) // 最多2个并发
    .subscribe();

// concatMap串行有序——顺序保证
Flux.just(1, 2, 3)
    .concatMap(i -> httpClient.get("/api/" + i)) // 逐个执行
    .subscribe();

7. switchIfEmpty vs defaultIfEmpty?


// defaultIfEmpty:替换为固定值
Mono<String> result = userRepository.findName(999L)
    .defaultIfEmpty("未知用户");

// switchIfEmpty:替换为备选Mono(延迟创建!)
Mono<String> result = cacheService.get(key)
    .switchIfEmpty(Mono.defer(() ->   // ⚠️ 必须用defer延迟
        dbService.findName(999L)
    ));

8. then/thenMany/thenReturn的区别?


// then:忽略上游数据,只等完成信号,返回Mono<Void>
Mono<Void> step = saveToDb(data).then(sendNotification(user));

// thenMany:忽略上游,替换为新的Flux
Flux<Order> orders = validateUser(userId)
    .thenMany(orderRepository.findAll());

// thenReturn:忽略上游,替换为固定值
Mono<String> ack = deleteCache(key).thenReturn("删除成功");
方法忽略上游返回类型典型用途
then()数据和错误Mono<Void>先做A再做B
thenMany()数据Flux<T>先验证再查列表
thenReturn()数据Mono<T>操作后返回确认值

9. merge vs concat vs zip?


Flux<Integer> f1 = Flux.just(1, 2, 3).delayElements(Duration.ofMillis(100));
Flux<Integer> f2 = Flux.just(10, 20, 30).delayElements(Duration.ofMillis(80));

// merge:并发合并,按时间交错——10, 1, 20, 2, 30, 3(取决于实际到达时间)
Flux.merge(f1, f2).subscribe();

// concat:串行连接,先f1后f2——1, 2, 3, 10, 20, 30
Flux.concat(f1, f2).subscribe();

// zip:一对一配对,等所有源都发射才组合——(1,10), (2,20), (3,30)
Flux.zip(f1, f2, (a, b) -> a + b).subscribe(); // 11, 22, 33

// combineLatest:用最新值组合——任一源发射就触发
Flux.combineLatest(f1, f2, (a, b) -> a + ":" + b).subscribe();

10. expand递归操作?


// 递归展开树形结构:先根节点,再逐层展开子节点
Flux<Department> allDepts = deptRepository.findRoot()
    .expandMany(dept -> deptRepository.findChildren(dept.getId()));
// 输出:根 → 子节点 → 孙节点 → ...

// 使用expandDeep进行深度优先遍历
Flux<Menu> allMenus = menuRepository.findRootMenu()
    .expandDeep(menu -> menuRepository.findSubMenus(menu.getId()));

11. buffer/window/groupBy分组操作?


// buffer:按大小分批
flux.buffer(100)                // 每100条一批
    .flatMap(batch -> db.batchInsert(batch));

// window:按时间窗口
flux.window(Duration.ofSeconds(5))  // 每5秒一个窗口
    .flatMap(window -> window.reduce((a, b) -> a + b));

// groupBy:按key分组
flux.groupBy(Order::getStatus)
    .flatMap(group -> group.collectList()
        .map(list -> group.key() + ": " + list.size()));
操作输出典型场景
buffer(N)Flux<List<T>>批量写入数据库
window(N)Flux<Flux<T>>滑动窗口聚合
window(Duration)Flux<Flux<T>>时间窗口统计
groupBy(key)Flux<GroupedFlux<K,T>>分组聚合

12. retry/retryWhen重试策略?


// 简单重试(不推荐生产使用)
flux.retry(3); // 失败后重试3次

// retryWhen + 指数退避 + jitter(推荐)
flux.retryWhen(Retry.backoff(3, Duration.ofSeconds(1))    // 最多3次,初始1s
    .maxBackoff(Duration.ofSeconds(10))                     // 最大退避10s
    .jitter(0.5)                                            // 随机抖动50%
    .filter(e -> e instanceof ServiceException)             // 只重试业务异常
    .doBeforeRetry(signal -> log.warn("第{}次重试", signal.totalRetries()))
    .onRetryExhaustedThrow((spec, signal) ->               // 重试耗尽抛异常
        new ServiceException("重试3次仍失败", signal.failure())));

13. onErrorResume vs onErrorReturn vs onErrorContinue?


// onErrorResume:替换为备选流(降级)
mono.onErrorResume(e -> fallbackService.query());

// onErrorReturn:替换为固定值(兜底)
mono.onErrorReturn("默认值");

// onErrorContinue:跳过错误元素继续处理(⚠️坑多,少用)
flux.onErrorContinue((err, obj) -> {
    log.warn("跳过错误元素: {}", obj, err);
});
操作符行为适用场景
onErrorResume替换为备选流降级/容错
onErrorReturn替换为固定值兜底默认值
onErrorContinue跳过错误元素批量处理容错

onErrorContinue踩坑:大多数操作符不支持,只在map/flatMap/filter等少数操作符后生效,行为不可预测。生产环境建议用flatMap内部try-catch替代。


三、Sinks

14. Sinks是什么?

15. Sinks的类型?


// Sinks.one():单值,类似Mono
Sinks.One<String> one = Sinks.one();
one.tryEmitValue("hello");
Mono<String> mono = one.asMono();

// Sinks.many().unicast():单订阅者
Sinks.Many<String> unicast = Sinks.many().unicast().onBackpressureBuffer();

// Sinks.many().multicast():多订阅者(热信号)
Sinks.Many<String> multicast = Sinks.many().multicast().onBackpressureBuffer();

// Sinks.many().replay():重放历史数据
Sinks.Many<String> replayAll = Sinks.many().replay().all();       // 重放所有
Sinks.Many<String> replayN = Sinks.many().replay().limit(5);      // 只重放最近5个
Sinks.Many<String> replayTime = Sinks.many().replay().limit(Duration.ofMinutes(5)); // 5分钟内
类型订阅者重放典型场景
unicast()仅1个无单消费者队列
multicast()多个无事件广播
replay().all()多个全部新订阅者看历史
replay().limit(N)多个最近N个滑动窗口通知

16. Sinks的线程安全与emit方式?


Sinks.Many<String> sink = Sinks.many().multicast().onBackpressureBuffer();

// 方式1:tryEmit——返回EmitResult,需手动处理失败
EmitResult result = sink.tryEmitNext("hello");
if (result.isFailure()) {
    log.warn("发送失败: {}", result);
}

// 方式2:emit——配合EmitFailureHandler处理失败
sink.emitNext("hello", Sinks.EmitFailureHandler.FAIL_FAST);  // 失败直接抛异常

// 方式3:自定义重试策略
sink.emitNext("hello", (signalType, emitResult) -> {
    log.warn("emit失败 signal={} result={}", signalType, emitResult);
    return emitResult == EmitResult.FAIL_NON_SERIALIZED; // 非序列化失败时重试
});

17. Sinks的实际应用场景?


// 场景1:WebSocket广播
@Component
public class WebSocketBroadcaster {
    private final Sinks.Many<String> sink = Sinks.many().multicast().onBackpressureBuffer();

    public void broadcast(String message) {
        sink.tryEmitNext(message);
    }

    public Flux<String> asFlux() {
        return sink.asFlux();
    }
}

// 场景2:响应式缓存更新通知
@Service
public class ReactiveCache<K, V> {
    private final Map<K, V> cache = new ConcurrentHashMap<>();
    private final Sinks.Many<CacheEvent<K>> events = Sinks.many().replay().limit(100);

    public void put(K key, V value) {
        cache.put(key, value);
        events.tryEmitNext(new CacheEvent<>(key, "UPDATE"));
    }
}

四、Context上下文

18. 为什么Reactor不能用ThreadLocal?


// 传统MVC中用ThreadLocal
public class TraceContext {
    private static final ThreadLocal<String> TRACE_ID = new ThreadLocal<>();
    public static String get() { return TRACE_ID.get(); }
}

// WebFlux中ThreadLocal失效!
// 原因:响应式链中线程会切换
Mono.just("data")
    .publishOn(Schedulers.parallel())     // 切到parallel线程
    .map(d -> TraceContext.get())          // ❌ null!线程已切换

19. Context的正确使用?


Mono<String> result = Mono.deferContextual(ctx -> {
    String traceId = ctx.get("traceId");                       // 读取
    String tenantId = ctx.getOrDefault("tenantId", "default"); // 带默认值
    return process(traceId, tenantId);
})
.contextWrite(Context.of(
    "traceId", "abc123",
    "tenantId", "tenant1"
));
// ⚠️ contextWrite必须在链末端声明,但对整个链生效

20. Context的常见踩坑?


// 踩坑1:contextWrite位置错误
Mono.just("data")
    .contextWrite(Context.of("key", "value"))  // ✅ 放链末尾
    .map(d -> d);                               // 整个链都能读到

// 踩坑2:flatMap内部新建的Mono读不到外部Context
Mono.just("user")
    .flatMap(user -> Mono.deferContextual(ctx -> {
        String v = ctx.getOrDefault("key", "missing"); // ✅ deferContextual可以读
        return Mono.just(user + ":" + v);
    }))
    .contextWrite(Context.of("key", "value"));

// 踩坑3:多次contextWrite会合并(不覆盖)
Mono.just("data")
    .contextWrite(Context.of("a", "1"))
    .contextWrite(Context.of("b", "2"))  // 结果:a=1, b=2

21. WebFlux中如何传递认证信息?


请求流程:
  1. Gateway解析JWT → 提取userId/roles
  2. 放入ServerWebExchange.Attributes
  3. 通过Reactor Context传递到下游服务
  4. 业务代码用deferContextual读取

// Gateway Filter
@Component
public class AuthFilter implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String token = exchange.getRequest().getHeaders().getFirst("Authorization");
        UserContext user = jwtUtil.parse(token);
        exchange.getAttributes().put("user", user);

        return chain.filter(exchange)
            .contextWrite(Context.of("user", user));  // 写入Reactor Context
    }
}

// 业务代码读取
Mono<String> result = Mono.deferContextual(ctx -> {
    UserContext user = ctx.get("user");
    return orderService.findOrders(user.getUserId());
});

五、Scheduler线程模型

22. Reactor的线程模型?


默认规则:在subscribe所在的线程执行所有操作
   ┌─────────────────────────────────────────────┐
   │  main线程:  source → map → filter → subscribe │
   └─────────────────────────────────────────────┘

publishOn:切换下游操作符的执行线程
   ┌──────────────────┐    ┌───────────────────┐
   │ main: source→map │ →  │ elastic: filter→sub│
   └──────────────────┘    └───────────────────┘

subscribeOn:切换数据源的执行线程
   ┌───────────────────┐    ┌──────────────────┐
   │ elastic: source   │ →  │ main: map→sub     │
   └───────────────────┘    └──────────────────┘

23. publishOn vs subscribeOn?


// publishOn:影响它之后的操作符在哪个线程执行
source.map(fn1)                                 // 线程A(原始线程)
    .publishOn(Schedulers.boundedElastic())
    .map(fn2)                                   // boundedElastic线程
    .publishOn(Schedulers.parallel())
    .map(fn3);                                  // parallel线程

// subscribeOn:影响数据源的执行线程
Mono.fromCallable(() -> blockingDbQuery())      // boundedElastic执行
    .subscribeOn(Schedulers.boundedElastic())   // 指定数据源线程
    .map(result -> transform(result));          // 也在boundedElastic

// 典型组合:阻塞IO放boundedElastic,后续切回EventLoop
blockingService.getData()
    .subscribeOn(Schedulers.boundedElastic())   // 阻塞操作放弹性线程池
    .publishOn(Schedulers.immediate())          // 切回EventLoop

24. Schedulers的类型?

Scheduler线程数适用场景
immediate()当前线程不切换(默认)
single()1个单线程串行任务
boundedElastic()10×CPU(默认)阻塞IO操作(JDBC/文件)
parallel()CPU核心数CPU密集计算
fromExecutor()自定义线程池隔离

// boundedElastic:包装阻塞调用
Mono<User> user = Mono.fromCallable(() -> jdbcRepository.findById(id))
    .subscribeOn(Schedulers.boundedElastic());

// parallel:CPU密集计算
Flux<Integer> result = Flux.range(1, 1000)
    .parallel(4)                              // 分4个轨道
    .runOn(Schedulers.parallel())             // 并行线程池
    .map(this::heavyComputation)
    .sequential();                            // 合并结果

25. WebFlux的Netty EventLoop线程?


// ❌ 错误:在WebFlux Handler中直接阻塞
@GetMapping("/user/{id}")
public Mono<User> getUser(@PathVariable Long id) {
    User user = jdbcRepo.findById(id);  // ❌ 阻塞了EventLoop!
    return Mono.just(user);
}

// ✅ 正确:用boundedElastic包装阻塞调用
@GetMapping("/user/{id}")
public Mono<User> getUser(@PathVariable Long id) {
    return Mono.fromCallable(() -> jdbcRepo.findById(id))
        .subscribeOn(Schedulers.boundedElastic());
}

26. 经典死锁场景?


// 死锁场景:在boundedElastic中调用block()
public Mono<String> getData() {
    return Mono.fromCallable(() -> {
        // 当前已在boundedElastic线程
        return anotherReactiveService.query().block(); // ❌ 死锁!
    }).subscribeOn(Schedulers.boundedElastic());
}

// boundedElastic线程池默认10×CPU个线程
// 如果所有线程都在block()等待其他Reactive操作 → 无可用线程 → 死锁

// ✅ 解决方案1:保持响应式链,不调用block()
public Mono<String> getData() {
    return anotherReactiveService.query();  // 直接返回Mono
}

// ✅ 解决方案2:增大boundedElastic线程池(治标不治本)
Schedulers.newBoundedElastic(
    Schedulers.DEFAULT_BOUNDED_ELASTIC_SIZE * 4,
    60, "custom-bounded", 60, true);

六、背压(Backpressure)

27. 什么是背压?


// 自定义Subscriber控制消费速率
flux.subscribe(new BaseSubscriber<String>() {
    @Override
    protected void hookOnSubscribe(Subscription s) {
        request(10);  // 初始请求10个
    }
    @Override
    protected void hookOnNext(String value) {
        process(value);
        request(5);   // 每处理完一个,再请求5个
    }
});

28. 背压策略?


// onBackpressureBuffer:缓冲多余数据,超过容量报错
flux.onBackpressureBuffer(1000,
    dropped -> log.warn("丢弃: {}", dropped),  // 缓冲区满时的回调
    BufferOverflowStrategy.DROP_OLDEST)         // 满时丢弃最旧的
    .subscribe();

// onBackpressureDrop:直接丢弃无法处理的数据
flux.onBackpressureDrop(dropped -> log.warn("丢弃: {}", dropped))
    .subscribe();

// onBackpressureLatest:只保留最新数据,丢弃旧的
flux.onBackpressureLatest()
    .subscribe();
策略行为适用场景
buffer(N)缓冲N个,超则报错/丢弃允许短暂堆积
drop()直接丢弃允许丢失(日志/监控)
latest()保留最新,丢旧的只关心最新状态

29. 背压在HTTP场景下的局限?

30. Flux.create vs Flux.generate?


// Flux.create:无背压感知,需要用户自己处理request
Flux.create(sink -> {
    for (int i = 0; i < 10000; i++) {
        sink.next(i);  // 不管下游要不要,全推出去
    }
    sink.complete();
}, FluxSink.OverflowStrategy.BUFFER);  // 可以指定溢出策略

// Flux.generate:同步逐个生成,天然支持背压
Flux.generate(() -> 0, (state, sink) -> {
    sink.next(state);   // 每次只生成一个
    if (state == 10) sink.complete();
    return state + 1;   // 下一个状态
});
特性Flux.createFlux.generate
背压需手动处理天然支持
并发可多线程emit单线程同步
复杂度灵活但复杂简单但受限
适用封装回调/API简单序列生成

七、WebFlux实战

31. WebFlux vs Spring MVC选型?

维度Spring MVCWebFlux
模型同步阻塞异步非阻塞
容器Servlet(Tomcat)Netty
数据库JDBC/JPAR2DBC
HTTP客户端RestTemplateWebClient
适用场景IO密集+业务复杂IO密集+高并发
学习曲线低高
代码可读性高(直觉)低(声明式链)
调试难度低高
推荐大多数场景网关/流式/推送

关键原则:如果整个调用链不是全异步的(比如用了JDBC),用WebFlux没有意义,反而更复杂。

32. WebFlux的Router Function?


// 函数式路由(替代@Controller注解)
@Configuration
public class RouterConfig {
    @Bean
    public RouterFunction<ServerResponse> route(OrderHandler handler) {
        return RouterFunctions.route()
            .GET("/api/orders/{id}", request -> {
                Long id = Long.parseLong(request.pathVariable("id"));
                return handler.getOrder(id);
            })
            .POST("/api/orders", request ->
                request.bodyToMono(CreateOrderReq.class)
                    .flatMap(handler::createOrder))
            .GET("/api/orders", request -> {
                String status = request.queryParam("status").orElse("ALL");
                return handler.listOrders(status);
            })
            .build();
    }
}

// Handler组件
@Component
public class OrderHandler {
    public Mono<ServerResponse> getOrder(Long id) {
        return orderService.findById(id)
            .flatMap(order -> ServerResponse.ok().bodyValue(order))
            .switchIfEmpty(ServerResponse.notFound().build());
    }
}

33. WebFlux的Filter?


// WebFilter:全局过滤(类似Servlet Filter)
@Component
public class LogFilter implements WebFilter {
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        long start = System.currentTimeMillis();
        String path = exchange.getRequest().getPath().value();
        return chain.filter(exchange)
            .doFinally(signal -> {
                long cost = System.currentTimeMillis() - start;
                log.info("{} {} {} {}ms", exchange.getRequest().getMethod(),
                    path, exchange.getResponse().getStatusCode(), cost);
            });
    }
}

// HandlerFilterFunction:路由级过滤(配合RouterFunction使用)
RouterFunctions.route()
    .GET("/api/admin/**", handler::admin)
    .filter((request, next) -> {
        String token = request.headers().firstHeader("Authorization");
        if (token == null) {
            return ServerResponse.status(401).build();
        }
        return next.handle(request);
    });

34. SSE(Server-Sent Events)实现?


// 服务端:返回Flux<ServerSentEvent>
@GetMapping(value = "/stream/prices", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
public Flux<ServerSentEvent<StockPrice>> streamPrices() {
    return Flux.interval(Duration.ofSeconds(1))
        .map(i -> stockService.getLatestPrice())
        .map(price -> ServerSentEvent.<StockPrice>builder()
            .id(String.valueOf(price.getId()))
            .event("price-update")
            .data(price)
            .comment("heartbeat")
            .build());
}

// 客户端消费SSE
WebClient.create().get()
    .uri("/stream/prices")
    .accept(MediaType.TEXT_EVENT_STREAM)
    .retrieve()
    .bodyToFlux(StockPrice.class)
    .subscribe(price -> log.info("收到: {}", price));

35. WebSocket实现?


// 配置WebSocket映射
@Configuration
public class WebSocketConfig {
    @Bean
    public HandlerMapping webSocketMapping(WebSocketHandler handler) {
        Map<String, WebSocketHandler> map = Map.of("/ws/chat", handler);
        SimpleUrlHandlerMapping mapping = new SimpleUrlHandlerMapping(map, -1);
        return mapping;
    }

    @Bean
    public WebSocketHandlerAdapter handlerAdapter() {
        return new WebSocketHandlerAdapter();
    }
}

// WebSocketHandler实现
@Component
public class ChatHandler implements WebSocketHandler {
    private final Sinks.Many<String> sink = Sinks.many().multicast().onBackpressureBuffer();

    @Override
    public Mono<Void> handle(WebSocketSession session) {
        // 接收消息 → 广播
        Flux<String> receive = session.receive()
            .map(WebSocketMessage::getPayloadAsText)
            .doOnNext(sink::tryEmitNext);

        // 广播消息 → 发送
        Flux<WebSocketMessage> send = sink.asFlux()
            .map(session::textMessage);

        return session.send(send).and(receive);
    }
}

八、R2DBC响应式数据库

36. R2DBC vs JDBC?

维度JDBCR2DBC
模型同步阻塞异步非阻塞
连接占用一个查询占一个线程少量连接高并发
协议基于SQL标准基于Reactive Streams
Spring支持JPA/MyBatisSpring Data R2DBC
连接池HikariCPR2DBC Pool
适用传统MVCWebFlux全异步链

// Spring Data R2DBC
public interface UserRepository extends ReactiveCrudRepository<User, Long> {
    Mono<User> findByUsername(String username);
    Flux<User> findByAgeGreaterThan(int age);
}

关键:R2DBC只在全异步链中有意义。如果Controller是WebFlux但Service用了JDBC,整体仍是阻塞的。

37. R2DBC事务管理?


// 响应式事务:必须用ReactiveTransactionManager
@Service
public class OrderService {
    private final ReactiveTransactionManager txManager;

    // 编程式事务
    public Mono<Order> createOrder(Order order) {
        return TransactionalOperator.create(txManager)
            .transactional(
                orderRepository.save(order)
                    .flatMap(saved -> orderItemRepository.saveAll(items).collectList()
                        .thenReturn(saved))
            );
    }

    // 注解式事务(推荐)
    @Transactional(rollbackFor = Exception.class)
    public Mono<Order> createOrder(Order order) {
        return orderRepository.save(order);
    }
}

注意:必须用ReactiveTransactionManager,不能用JPA的PlatformTransactionManager,否则事务不生效。

38. 响应式流中的连接池泄漏?


// 危险:流被取消时连接未归还
public Flux<User> queryUsers() {
    return connectionFactory.create()
        .flatMapMany(conn -> conn.createStatement("SELECT * FROM users").execute()
            .flatMap(result -> result.map(row -> new User(row.get(0, Long.class))))
            .doFinally(signal -> conn.close()));  // ✅ doFinally确保关闭
}

// Spring Data R2DBC自动管理连接池
// 自定义操作必须用doFinally/doOnDiscard清理资源

39. Spring Data R2DBC实战?


// Repository
public interface OrderRepository extends ReactiveCrudRepository<Order, Long> {
    @Query("SELECT * FROM orders WHERE user_id = :userId AND status = :status")
    Flux<Order> findByUserAndStatus(@Param("userId") Long userId,
                                     @Param("status") String status);

    @Query("UPDATE orders SET status = :status WHERE id = :id")
    Mono<Integer> updateStatus(@Param("id") Long id, @Param("status") String status);
}

// Service
@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepo;

    public Flux<OrderVO> getUserOrders(Long userId) {
        return orderRepo.findByUserAndStatus(userId, "PAID")
            .flatMap(this::enrichOrder)    // 关联查询
            .sort(Comparator.comparing(OrderVO::getCreatedAt).reversed())
            .take(50);                      // 限制返回数量
    }
}

40. R2DBC的性能优化?


# 连接池配置
spring:
  r2dbc:
    url: r2dbc:mysql://localhost:3306/mydb
    pool:
      max-size: 50          # 最大连接数
      initial-size: 10      # 初始连接数
      max-idle-time: 30m    # 空闲超时
      validation-depth: LOCAL  # 连接校验深度

九、WebClient

41. WebClient vs RestTemplate?

维度RestTemplateWebClient
模型同步阻塞异步非阻塞
状态已废弃(Spring 6)推荐异步客户端
流式不支持支持Flux流式接收
连接池无内置管理底层Netty连接池
替代RestClient(同步)WebClient(异步)

// Spring 6推荐:
// - 同步场景用 RestClient
// - 异步场景用 WebClient

RestClient syncClient = RestClient.create();
User user = syncClient.get().uri("/users/1").retrieve().body(User.class);

WebClient asyncClient = WebClient.create();
Mono<User> userMono = asyncClient.get().uri("/users/1")
    .retrieve().bodyToMono(User.class);

42. WebClient的使用?


// 创建WebClient
WebClient client = WebClient.builder()
    .baseUrl("https://api.example.com")
    .defaultHeader("Authorization", "Bearer " + token)
    .codecs(configurer -> configurer
        .defaultCodecs()
        .maxInMemorySize(16 * 1024 * 1024))  // 16MB(默认256KB太小)
    .build();

// GET请求
Mono<Order> order = client.get()
    .uri("/orders/{id}", orderId)
    .retrieve()
    .bodyToMono(Order.class)
    .retryWhen(Retry.backoff(3, Duration.ofSeconds(1)));

// POST请求
Mono<Order> created = client.post()
    .uri("/orders")
    .bodyValue(createReq)
    .retrieve()
    .bodyToMono(Order.class);

// 流式接收
Flux<Event> events = client.get()
    .uri("/events")
    .accept(MediaType.TEXT_EVENT_STREAM)
    .retrieve()
    .bodyToFlux(Event.class);

43. ExchangeFilterFunction拦截器?


WebClient client = WebClient.builder()
    // 统一添加请求头
    .filter((request, next) -> {
        ClientRequest authenticated = ClientRequest.from(request)
            .header("X-Trace-Id", TraceContext.getTraceId())
            .build();
        return next.exchange(authenticated);
    })
    // 日志过滤器
    .filter((request, next) -> {
        log.info(">>> {} {}", request.method(), request.url());
        return next.exchange(request)
            .doOnNext(response -> log.info("<<< {}", response.statusCode()));
    })
    // 错误处理过滤器
    .filter((request, next) -> next.exchange(request)
        .onErrorResume(WebClientResponseException.class, e -> {
            log.error("HTTP {} 调用失败: {}", e.getStatusCode(), e.getResponseBodyAsString());
            return Mono.error(new ServiceException("外部服务调用失败"));
        }))
    .build();

44. WebClient连接池调优?


// 底层Netty HttpClient连接池配置
HttpClient httpClient = HttpClient.create(
    ConnectionProvider.builder("custom-pool")
        .maxConnections(500)                    // 最大连接数
        .pendingAcquireTimeout(Duration.ofSeconds(45))  // 获取连接超时
        .maxIdleTime(Duration.ofSeconds(20))    // 空闲连接超时
        .maxLifeTime(Duration.ofMinutes(5))     // 连接最大存活时间
        .build()
)
.responseTimeout(Duration.ofSeconds(10))        // 响应超时
.compress(true);

WebClient client = WebClient.builder()
    .clientConnector(new ReactorClientHttpConnector(httpClient))
    .build();

监控指标:通过Micrometer监控连接池使用率、pending acquire count,防止连接泄漏。

45. WebClient的错误处理?


Mono<Order> order = client.get()
    .uri("/orders/{id}", orderId)
    .retrieve()
    // onStatus:处理HTTP错误状态码
    .onStatus(status -> status.is4xxClientError(),
        response -> response.bodyToMono(String.class)
            .flatMap(body -> Mono.error(new ClientException(body))))
    .onStatus(status -> status.is5xxServerError(),
        response -> Mono.error(new ServerException("服务端错误")))
    .bodyToMono(Order.class)
    // onErrorResume:降级处理
    .onErrorResume(ServerException.class,
        e -> fallbackService.getOrder(orderId))
    // retryWhen:重试策略
    .retryWhen(Retry.backoff(3, Duration.ofSeconds(1))
        .filter(e -> e instanceof ServerException)     // 只重试5xx
        .doBeforeRetry(s -> log.warn("重试 {}", s.totalRetries())));

十、调试与可观测性

46. Reactor调试的难点?


// 典型的无用堆栈:
// reactor.core.publisher.Mono.onErrorResume -> Mono.flatMap -> ...
// 看不出是哪一行代码出了问题

47. 调试方案?


// 方案1:Hooks.onOperatorDebug()(仅开发环境,性能差)
Hooks.onOperatorDebug();  // 全局开启操作符调试
// 会捕获每个操作符的创建堆栈,异常时输出完整链路

// 方案2:checkpoint()(推荐生产环境,轻量级)
flux.checkpoint("after-db-query")      // 在关键位置打追踪点
    .map(this::transform)
    .checkpoint("after-transform")     // 异常时显示最近的checkpoint
    .log("order-service");             // 日志操作符,记录subscribe/next/complete/error

// 方案3:log()操作符
flux.log("debug-category", Level.FINE)
    // 输出:onSubscribe → request → onNext(值) → onComplete
方案性能影响适用环境信息量
Hooks.onOperatorDebug()大开发最完整
checkpoint()小生产关键节点
log()中开发/生产事件流

48. BlockHound检测阻塞调用?


// 测试依赖
// io.projectreactor.tools:blockhound

// 在测试类中安装
@ExtendWith(ReactorTestExtension.class)
class ServiceTest {
    @BeforeAll
    static void setup() {
        BlockHound.install();  // 安装BlockHound
    }

    @Test
    void shouldNotBlock() {
        // 自动检测在Reactor线程中的阻塞操作
        // Thread.sleep, blocking IO, synchronized等待等
        // 抛出 BlockingOperationError
        StepVerifier.create(
            Mono.fromCallable(() -> {
                Thread.sleep(100);  // ❌ BlockHound会检测到
                return "data";
            }).subscribeOn(Schedulers.parallel())
        ).expectError(BlockingOperationError.class).verify();
    }
}

49. 链路追踪集成?


// Spring Boot 3 + Micrometer Tracing + Reactor自动传播
// 依赖:spring-boot-starter-tracing + reactor-netty + micrometer-tracing

// 配置:自动将traceId传入Reactor Context
@Bean
Hooks.OnOperatorDebug debugHook() {
    // Context自动传播:traceId在操作符链中自动传递
    return Hooks.onOperatorDebug();
}

// 手动在日志中输出traceId
Mono<String> result = service.process()
    .doOnEach(signal -> {
        signal.getContextView().getOrEmpty("traceId")
            .ifPresent(traceId -> MDC.put("traceId", traceId));
    })
    .doFinally(signal -> MDC.remove("traceId"));

50. 响应式编程的适用场景总结?

场景适合不适合
API网关/代理✅ 高并发转发,IO密集-
实时推送/SSE/WebSocket✅ 天然长连接流式-
流式数据处理✅ Kafka/文件流式处理-
微服务间调用✅ WebClient非阻塞-
CPU密集计算-❌ 响应式无优势
复杂CRUD业务-❌ 代码复杂度暴增
团队不熟悉响应式-❌ 维护成本高

选型决策树:

1. 是否全链路异步?(DB/JDBC/外部调用都必须异步)

2. 是否真的有高并发IO瓶颈?(Tomcat 200线程不够用?)

3. 团队是否熟悉响应式编程?(学习曲线陡峭)

4. 调试和排障能力是否跟上?(可观测性投入)

如果以上任一回答为否,建议使用Spring MVC + RestClient。


面试速记口诀

Reactor三核心:Mono(0-1)、Flux(0-N)、Sinks(手动推送)
线程二操作:publishOn(切下游)、subscribeOn(切上游)
背压三策略:Buffer(缓冲)、Drop(丢弃)、Latest(保最新)
调试三件套:checkpoint(追踪点)、log(日志)、BlockHound(检测阻塞)
选型一句话:全链路异步用WebFlux,否则老老实实Spring MVC