Q112 Reactor与WebFlux响应式高级实战
20K Java+AI 岗位高频考点 — 响应式编程是高并发系统的核心技术。覆盖Reactor核心概念、Flux/Mono高级操作、Sinks、Context、Scheduler线程模型、背压、WebFlux实战、R2DBC、WebClient、调试与可观测性。
一、响应式编程基础
1. 什么是响应式编程?
- 声明式+异步非阻塞+数据流+背压,区别于传统的命令式编程
- 命令式是"拉"数据(主动遍历),响应式是"推"数据(生产者推送给消费者)
- 消费者通过背压控制流速,防止被生产者淹没
- 底层遵循Reactive Streams规范(Publisher/Subscriber/Subscription/Processor四个接口)
- 典型应用场景:网关代理、流式处理、实时推送、高并发IO密集型服务
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开始收
- Cold:每个订阅者拿到完整数据副本(如HTTP请求、数据库查询)
- Hot:数据不因订阅者有无而改变(如传感器数据、用户事件、WebSocket消息)
- 冷信号可以被
publish()转为热信号
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. 兜底
- 惰性执行:以上代码只是声明了数据处理流程,不会立即执行
- subscribe触发:只有调用
result.subscribe()时才会真正开始执行
- 操作符分类:创建(just/from)/转换(map/flatMap)/过滤(filter)/组合(zip/merge)/错误处理(onErrorResume)/辅助(doOnNext/log)
二、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)
));
defaultIfEmpty只能替换为固定值,switchIfEmpty可以替换为备选源
- 关键踩坑:
switchIfEmpty的备选源会被提前创建,必须用Mono.defer()延迟初始化
- 错误写法:
.switchIfEmpty(dbService.query())——无论是否需要都会执行query
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()));
expandMany:广度优先(BFS),逐层展开
expandDeep:深度优先(DFS),一条路走到底
- 实际应用:菜单树、组织架构树、文件目录遍历、评论回复树
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())));
- retry:简单固定次数重试,无法控制间隔
- retryWhen:支持指数退避、jitter、过滤条件、回调通知
- jitter防止多个实例同时重试造成惊群效应
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是什么?
- Reactor 3.4+引入的新API,替代已废弃的Processor系列
- 核心能力:线程安全地手动向Flux/Mono推送数据
- 支持多线程并发emit,内部处理了竞争条件
- 替代关系:
Sinks.one() ≈ MonoProcessor,Sinks.many() ≈ 各种FluxProcessor
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; // 非序列化失败时重试
});
tryEmitNext:非阻塞,返回结果码,适合高频场景
emitNext:阻塞式,可配合失败处理器,适合需要确保送达的场景
- FAIL_FAST:快速失败策略,多线程竞争时直接报错,不做重试
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!线程已切换
- 响应式链中一次请求可能跨多个线程执行
- ThreadLocal绑定线程,线程切换后数据丢失
- Reactor用Context替代,跟随订阅链传递,不依赖线程
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必须在链末端声明,但对整个链生效
- 使用
deferContextual(推荐)而非已废弃的subscriberContext
contextWrite写在链末端,但Context对整个链可见(自底向上传播)
- Context是不可变的,每次
contextWrite返回新Context
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 │
└───────────────────┘ └──────────────────┘
- 默认在subscribe调用者线程执行(通常是main或Netty EventLoop)
publishOn影响它之后的操作符
subscribeOn影响数据源的执行线程
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线程?
- 默认CPU核心数×2个EventLoop线程(如8核=16个线程)
- 绝对禁止在EventLoop线程做阻塞操作,否则整个服务卡死
- 常见阻塞操作:JDBC、
Thread.sleep()、同步HTTP调用、文件IO
// ❌ 错误:在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. 什么是背压?
- 消费者通知生产者减慢速度的机制,是Reactive Streams规范的核心
- 当生产者速度 > 消费者处理速度时,消费者通过
request(n)控制上游发射数量
- Flux支持背压(基于Reactive Streams),Mono天然不需要(0或1个元素)
- 底层实现:
Subscription.request(n)告诉上游只需要n个元素
// 自定义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场景下的局限?
- HTTP请求-响应是一次性的,无法真正"减速"(已经发完了)
- 背压在以下场景才真正有效:
- Kafka Consumer:通过pause/resume控制消费速率
- 数据库流式查询:R2DBC的cursor-based查询
- 文件读取:按需读取下一块
- WebSocket:双向通信,可以通知对方减速
- WebFlux中HTTP接口返回Flux时,背压主要体现在Netty的写缓冲区水位控制
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.create | Flux.generate |
| 背压 | 需手动处理 | 天然支持 |
| 并发 | 可多线程emit | 单线程同步 |
| 复杂度 | 灵活但复杂 | 简单但受限 |
| 适用 | 封装回调/API | 简单序列生成 |
七、WebFlux实战
31. WebFlux vs Spring MVC选型?
| 维度 | Spring MVC | WebFlux |
| 模型 | 同步阻塞 | 异步非阻塞 |
| 容器 | Servlet(Tomcat) | Netty |
| 数据库 | JDBC/JPA | R2DBC |
| HTTP客户端 | RestTemplate | WebClient |
| 适用场景 | 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?
| 维度 | JDBC | R2DBC |
| 模型 | 同步阻塞 | 异步非阻塞 |
| 连接占用 | 一个查询占一个线程 | 少量连接高并发 |
| 协议 | 基于SQL标准 | 基于Reactive Streams |
| Spring支持 | JPA/MyBatis | Spring Data R2DBC |
| 连接池 | HikariCP | R2DBC Pool |
| 适用 | 传统MVC | WebFlux全异步链 |
// 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清理资源
doFinally:无论正常/异常/取消都会执行,用于资源清理
doOnDiscard:流取消时丢弃缓存中的元素,触发清理
- R2DBC Pool(
r2dbc-pool)提供连接池管理,配合maxIdleTime/maxLifeTime防止泄漏
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 # 连接校验深度
- 连接池调优:maxSize根据并发量设置,idleTime回收空闲连接
- 批量操作:
batch()执行批量INSERT/UPDATE,减少网络往返
- 索引优化:R2DBC不走JPA的自动索引策略,需手动建索引
- 避免N+1:用
@QueryJOIN查询替代flatMap逐条关联查询
- 投影查询:只查需要的字段,用接口投影
Projections.bean()
九、WebClient
41. WebClient vs RestTemplate?
| 维度 | RestTemplate | WebClient |
| 模型 | 同步阻塞 | 异步非阻塞 |
| 状态 | 已废弃(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();
}
}
- 检测在Reactor线程(parallel/boundedElastic外的EventLoop)中的阻塞调用
- 生产环境可以集成为JVM Agent,持续监控
- 可以通过
BlockHoundIntegration自定义允许的阻塞操作白名单
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"));
- Micrometer Tracing自动将traceId/parentId注入Reactor Context
- 所有操作符共享同一个traceId,实现跨线程链路追踪
- 配合Zipkin/Jaeger/SkyWalking实现全链路可观测
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