Java on 吾爱主机

Spring 事务传播机制：REQUIRED、REQUIRES_NEW 与嵌套事务工程实践

Fri, 17 Jul 2026 00:00:00 +0800

业务代码里最容易“看起来对、跑起来却不对”的一类问题，就是 事务边界。方法上贴了 @Transactional，并不等于“想回滚就一定回滚、想独立提交就一定独立提交”。真正决定行为的，是 传播行为（propagation）、物理事务 vs 逻辑事务、以及 Spring 默认的 代理拦截模型。

本文基于 Spring Framework 官方事务文档，把 REQUIRED / REQUIRES_NEW / NESTED 等传播语义、回滚规则与常见工程踩坑讲清楚，并给出可落地的写法与排查清单。

一、先分清：物理事务 vs 逻辑事务

Spring 管理事务时，不能只看“有没有 @Transactional”，而要区分两层：

概念	含义	工程直觉
物理事务（physical）	底层资源上真正开启的事务（如一条 JDBC Connection 上的 `begin/commit/rollback`）	能不能真正提交/回滚、锁何时释放
逻辑事务（logical）	每个被 Spring 事务拦截的方法作用域	该方法能否单独标记 `rollback-only`

传播行为决定的是：外层方法与内层方法之间，逻辑作用域如何映射到物理事务。
这正是很多“内层抛异常后外层还以为自己 commit 成功了”的根源。

二、七种传播行为速查

@Transactional(propagation = …) 对应 TransactionDefinition 中的常量。按“有没有外层事务”理解最稳：

传播行为	无外层事务时	有外层事务时	典型用途
`REQUIRED`（默认）	新建物理事务	加入外层同一物理事务	服务门面 + 多仓储同事务
`SUPPORTS`	非事务执行	加入外层事务	查询既可独立也可参与写事务
`MANDATORY`	抛异常	加入外层事务	强制调用方必须已开事务
`REQUIRES_NEW`	新建物理事务	挂起外层，新建独立物理事务	审计日志、独立提交的状态点
`NOT_SUPPORTED`	非事务执行	挂起外层，非事务执行	长耗时/远程调用不想占连接
`NEVER`	非事务执行	抛异常	明确禁止在事务中调用
`NESTED`	等同 `REQUIRED` 新建	同一物理事务内建 savepoint	内层可局部回滚，外层可继续

日常工程里真正高频的是：REQUIRED、REQUIRES_NEW、NESTED。下面展开它们的语义差异。

三、REQUIRED：默认正确，但要懂 UnexpectedRollbackException

1. 语义

PROPAGATION_REQUIRED 会 强制存在物理事务：

当前没有事务 → 为本方法新建；
已有外层事务 → 参与该外层物理事务（同一连接、同一提交点）。

这很适合：一个 Service 编排多个 Repository，要求“要么一起成功，要么一起失败”。

2. 逻辑作用域仍是独立的

即便映射到同一物理事务，Spring 仍会为每个 REQUIRED 方法创建 逻辑事务作用域。每个作用域可以独立设置 rollback-only。

关键后果（官方明确描述）：

内层逻辑事务标记了 rollback-only；
外层自己没有决定回滚，仍尝试 commit；
物理事务最终回滚，外层会收到 UnexpectedRollbackException。

这不是“Spring 抽风”，而是保护调用方 绝不能误以为已经提交成功。

3. 内层 isolation / timeout / readOnly 默认会被忽略

参与外层事务时，内层声明的隔离级别、超时、只读标志 默认静默忽略，以外层特征为准。
若希望“内层要求与外层不一致时直接失败”，可在事务管理器上打开 validateExistingTransaction=true（非宽松模式也会拒绝只读/读写不匹配）。

// 伪配置示意：开启后，内层 isolation/readOnly 与外层冲突会拒绝加入
// PlatformTransactionManager 具体实现上设置 validateExistingTransaction = true

四、REQUIRES_NEW：真正的“独立事务”

1. 语义

PROPAGATION_REQUIRES_NEW 总是开启独立物理事务：

有外层事务 → 挂起外层，内层用新资源事务；
内层 commit/rollback 不影响外层事务的提交结果；
内层结束后，其持有的锁会尽快释放；
内层可使用自己的 isolation / timeout / readOnly。

2. 适合什么

操作日志 / 审计记录：业务主事务回滚，日志仍要留下；
状态机“已到达某检查点”的独立落库；
需要更短锁持有时间、且允许与外层最终结果不一致的写路径。

3. 连接池风险（必须重视）

官方明确警告：外层事务仍绑定着资源时，内层还要再拿 新的数据库连接。若连接池偏小，可能出现：

连接池耗尽；
多线程都在外层事务中等待内层连接 → 死锁式等待。

实践建议：

连接池最大连接数要 大于并发线程数（官方表述：至少比并发线程数多 1，实际应按峰值嵌套深度留余量）；
不要在循环体里高频 REQUIRES_NEW；
先问自己：真的需要“独立提交”，还是只是想“内层失败不要拖死外层”——后者可能 NESTED 更合适。

@Service
public class OrderService {

 private final AuditService auditService;
 private final OrderRepository orderRepository;

 @Transactional // 默认 REQUIRED
 public void placeOrder(OrderCmd cmd) {
 Order order = orderRepository.save(Order.create(cmd));
 // 审计希望独立提交：业务失败也不丢“尝试下单”痕迹
 auditService.recordAttempt(order.getId(), "PLACE_ORDER");
 // ... 后续业务可能抛异常导致外层回滚
 orderRepository.markPaid(order.getId());
 }
}

@Service
public class AuditService {

 @Transactional(propagation = Propagation.REQUIRES_NEW)
 public void recordAttempt(Long orderId, String action) {
 // 独立物理事务：这里的提交不会被外层回滚“带走”
 }
}

五、NESTED：同一物理事务上的 savepoint

1. 语义

PROPAGATION_NESTED：

一个物理事务；
内层通过 savepoint（保存点） 支持局部回滚；
内层回滚到 savepoint 后，外层仍可继续并最终 commit/rollback。

它通常映射到 JDBC savepoint，因此：

依赖 JDBC 资源事务；
与 DataSourceTransactionManager 一类管理器配合最常见；
不是所有事务管理器/资源都支持嵌套语义。

2. 与 REQUIRES_NEW 的选型

维度	`REQUIRES_NEW`	`NESTED`
物理事务	独立两条	仍是一条
内层回滚	不影响外层提交决策	只回滚到 savepoint，外层可继续
内层提交可见性	内层结束即可对外可见（独立提交）	仍受外层最终 commit 约束
连接占用	可能额外占连接	一般不另开连接
资源支持	广泛	依赖 savepoint 支持

口诀：

要“内层 真正提交，外层怎么回滚都保留” → REQUIRES_NEW；
要“内层失败可局部撤销，但最终仍跟外层同生共死” → NESTED。

六、回滚规则：默认只认 RuntimeException / Error

声明式事务的默认策略（官方 @Transactional 默认值）：

传播：REQUIRED
隔离：ISOLATION_DEFAULT（交给底层数据源默认）
读写：可写
超时：底层默认 / 无
回滚触发：RuntimeException 与 Error
默认不回滚：受检异常（checked Exception）

这解释了一个经典坑：业务方法 throws BusinessException extends Exception，调用方 catch 后发现 数据居然提交了。

可显式配置：

@Transactional(rollbackFor = Exception.class)
public void transfer(Long from, Long to, long amount) throws BusinessException {
 // 受检业务异常也会触发回滚
}

@Transactional(noRollbackFor = InventoryNotEnoughException.class)
public void reserveStock(Long skuId, int n) {
 // 某些“预期内”的运行时异常不希望回滚时使用（务必非常克制）
}

也可在 catch 后程序化标记：

try {
 // ...
} catch (NoProductInStockException ex) {
 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
}

官方仍建议优先用声明式 rollbackFor / noRollbackFor，少用手写 setRollbackOnly()。

七、代理模型：自调用为什么“注解失效”

默认 proxy 模式（非 AspectJ 编织）下：

只有 通过代理进来的外部调用 才会被拦截；
同类自调用（this.otherTxMethod()）不会走代理 → 内层 @Transactional 不生效；
初始化阶段（如 @PostConstruct）也不应依赖事务代理；
Spring Framework 6.0 起，基于类的代理默认可对 protected / 包可见方法生效；但 基于接口的 JDK 代理 仍要求方法在接口中且为 public。

@Service
public class PayService {

 @Transactional
 public void pay(Long id) {
 // 错误：自调用，markPaid 上的 REQUIRES_NEW 不会生效
 this.markPaid(id);
 }

 @Transactional(propagation = Propagation.REQUIRES_NEW)
 public void markPaid(Long id) {
 // ...
 }
}

常见修法：

把需要独立传播的方法拆到 另一个 Spring Bean，通过注入调用；
注入自身代理（@Lazy 自注入 / AopContext.currentProxy()，后者需暴露代理）；
切换到 AspectJ 模式（成本更高，团队要统一约定）。

八、可复现的排查清单

当“事务行为不符合预期”时，按下面顺序收敛：

是不是自调用？ 打断点看调用栈是否经过 TransactionInterceptor。
异常类型是否触发默认回滚？ checked vs runtime；是否被上层吞掉。
传播是否是你以为的那个？ REQUIRED 加入外层 ≠ REQUIRES_NEW 独立提交。
是否出现 UnexpectedRollbackException？ 说明内层已 rollback-only，外层还在 commit。
连接池是否在 REQUIRES_NEW 下打满？ 看获取连接耗时与 active connections。
只读事务是否被误用于写？ 以及是否开启了 validateExistingTransaction。
多数据源 / 非 DataSourceTransactionManager 场景 下 NESTED 是否根本不被支持。

最小实验建议（单测或本地）：

场景 A：outer REQUIRED → inner REQUIRED 抛 RuntimeException
 期望：整体回滚；外层若吞异常仍可能 UnexpectedRollbackException

场景 B：outer REQUIRED → inner REQUIRES_NEW 成功后 outer 回滚
 期望：inner 已提交数据仍在；outer 变更回滚

场景 C：同类 this.inner() 且 inner 标 REQUIRES_NEW
 期望（proxy 默认）：inner 注解不生效，与 outer 同一逻辑路径

九、工程建议（可直接落到 Code Review）

默认用 REQUIRED，不要到处 REQUIRES_NEW。
REQUIRES_NEW 只用于“必须独立提交”的窄路径，并评估连接池。
需要局部回滚且最终仍同事务提交 → 优先评估 NESTED，并确认 JDBC savepoint 支持。
业务异常若走 checked，统一 rollbackFor = Exception.class 或统一业务异常基类为 runtime。
事务边界放在 应用服务层，Repository 保持细粒度；避免 Controller 直接开事务导致边界失控。
长耗时远程调用不要包在大事务里；必要时 NOT_SUPPORTED 或先缩短事务再调外部。
Code Review 必问：谁提交？谁回滚？失败时用户看到的状态与 DB 是否一致？

十、总结

Spring 事务传播不是注解装饰，而是 逻辑作用域如何映射到物理资源事务 的规则：

REQUIRED：共享物理事务，内层 rollback-only 会拖垮外层提交预期；
REQUIRES_NEW：独立物理事务，能独立提交，但要付连接与一致性代价；
NESTED：同一物理事务上的 savepoint，适合“局部失败、整体仍可继续”的路径；
回滚默认只盯 RuntimeException/Error；
代理模式下 自调用不走事务拦截。

把这五件事吃透，线上大部分“事务没生效 / 该回没回 / 不该提交却提交”的问题都能快速定位。

参考资料

Spring Framework Reference — Transaction Propagation（REQUIRED / REQUIRES_NEW / NESTED 语义与 UnexpectedRollbackException、连接池警告）
Spring Framework Reference — Rolling Back a Declarative Transaction（默认 RuntimeException/Error 回滚、rollbackFor/setRollbackOnly）
Spring Framework Reference — Using @Transactional（默认传播/隔离/回滚规则、proxy 自调用限制、可见性）
Spring Framework Javadoc — TransactionDefinition（七种 PROPAGATION_* 常量定义）

Spring AI 2.0 结构化输出实战：让大模型返回可验证的 Java 对象

Tue, 30 Jun 2026 01:15:52 +0000

在企业应用里，调用大模型最怕的不是“它会说错话”，而是下游系统把一段不稳定的自然语言当成了稳定数据：少一个字段、数组变成字符串、JSON 外面多一段解释，都可能让订单流转、风控判断、知识库入库或自动化工单发生不可预期的问题。

Spring AI 2.0 围绕结构化输出补上了两个很实用的工程开关：一个是在响应回来后做 schema 校验并自动重试的 validateSchema()，另一个是尽量使用模型供应商原生结构化输出能力的 useProviderStructuredOutput()。这篇文章把官方博客和参考文档整理成一份中文实战指南，重点讲清楚：什么时候用、怎么接入、哪些坑需要提前规避。

一、结构化输出解决的到底是什么问题

普通聊天接口返回的是文本。文本适合展示给人看，却不适合直接交给业务代码做分支判断。例如你希望模型返回演员和电影列表：

record ActorsFilms(String actor, List<String> movies) {}

如果模型严格返回：

{"actor":"Tom Hanks","movies":["Forrest Gump","Cast Away"]}

业务代码就能很自然地反序列化为 ActorsFilms。但真实模型输出经常会变成：

当然可以，下面是结果：
```json
{"actor":"Tom Hanks","movies":["Forrest Gump","Cast Away"]}


或者字段名、类型、嵌套结构发生漂移。Spring AI 的结构化输出能力，就是把“提示模型按格式回答”和“把回答转换成 Java 类型”封装进框架，让应用更接近普通 Java 对象编程，而不是到处写字符串解析逻辑。

## 二、最基础的用法：`.entity(...)`

在 Spring AI 的 `ChatClient` 中，最直接的结构化输出入口是 `.entity(...)`。它只适用于 `.call()` 同步调用链，因为类型转换需要拿到完整响应；流式 `.stream()` 返回的是文本片段，不能直接在流上变成对象。

```java
record ActorsFilms(String actor, List<String> movies) {}

ActorsFilms films = chatClient.prompt()
 .user("Generate the filmography for a random actor.")
 .call()
 .entity(ActorsFilms.class);

System.out.println(films.actor());
System.out.println(films.movies());

背后大致会发生三件事：

Spring AI 根据目标 Java 类型生成 JSON Schema；
框架把格式要求加入提示词，让模型尽量按 schema 返回；
返回文本再交给 converter 转换成目标 Java 对象。

官方参考文档也明确提醒：这种方式本质上是 best effort。模型并不一定总能按要求返回结构化数据，所以生产环境不能只停留在“能跑通一次 demo”。

三、Spring AI 2.0 的第一个关键开关：`validateSchema()`

validateSchema() 解决的是响应侧校验与自修复问题。模型先正常回答，Spring AI 再用 schema 校验结果。如果校验失败，框架会把具体错误追加进下一轮请求，让模型基于错误信息重新生成，默认最多尝试 3 次。

ActorsFilms films = chatClient.prompt()
 .user("Generate the filmography for a random actor.")
 .call()
 .entity(ActorsFilms.class, spec -> spec.validateSchema());

这比简单地“失败后再问一次”更可靠，因为第二次请求不是盲目重试，而是带着类似“缺少 required 字段 actor”“movies 期望 array 但收到 string”这样的校验反馈。

对业务代码来说，它的价值主要体现在三类场景：

返回对象会直接入库；
返回字段会影响自动化流程分支；
错误结构不会立刻报错，但会在后续链路中造成隐性数据污染。

如果默认 3 次不够，也可以显式注册 StructuredOutputValidationAdvisor 调整重试次数：

var validationAdvisor = StructuredOutputValidationAdvisor.builder()
 .outputType(ActorsFilms.class)
 .maxRepeatAttempts(5)
 .build();

ChatClient chatClient = ChatClient.builder(chatModel)
 .defaultAdvisors(validationAdvisor)
 .build();

需要注意：重试会增加延迟和 token 消耗，所以它适合关键链路，而不一定适合所有只用于展示的回答。

四、第二个关键开关：`useProviderStructuredOutput()`

validateSchema() 是“回来以后再检查”，而 useProviderStructuredOutput() 是“请求时就告诉供应商按结构化输出约束执行”。官方博客说明，Spring AI 2.0 支持把结构化输出 schema 通过模型供应商的 API 级能力发送出去，而不是只把格式要求塞进 prompt。

ActorsFilms films = chatClient.prompt()
 .user("Generate the filmography for a random actor.")
 .call()
 .entity(ActorsFilms.class, spec -> spec.useProviderStructuredOutput());

这样做通常有三个好处：

system prompt 不再需要携带冗长 JSON 格式说明；
schema 通过供应商 API 字段传递，约束更靠近模型运行时；
对支持原生结构化输出的模型，格式稳定性通常更好。

截至 Spring AI 2.0 官方说明，支持面包括 OpenAI、Anthropic、Google GenAI、Mistral AI，以及按模型能力区分的 Ollama。Spring AI 会检查当前 chat options 是否实现 StructuredOutputChatOptions；如果不支持，这个开关会回退到基于 prompt 的默认方式，而不是强行让请求失败。

五、生产建议：两个开关一起用

如果你的下游系统不能容忍结构漂移，推荐把两个开关组合起来：

ActorsFilms films = chatClient.prompt()
 .user("Generate the filmography for a random actor.")
 .call()
 .entity(ActorsFilms.class, spec -> spec
 .useProviderStructuredOutput()
 .validateSchema());

可以把它理解成两道防线：

useProviderStructuredOutput() 尽量在模型供应商侧减少非法输出；
validateSchema() 兜住供应商边界、模型差异和偶发异常。

这在“AI 结果要进入真实业务系统”的场景尤其重要，例如：

从客服对话中抽取投诉类型、订单号、处理建议；
从运维日志中归类故障级别和可能根因；
从合同文本中抽取主体、金额、日期、责任条款；
让智能体生成下一步工具调用参数前，先产出稳定中间对象。

如果只是把回答展示给用户阅读，单独使用 .content() 也可以；但只要结果要被程序消费，就应该优先考虑结构化输出。

六、泛型类型：`ParameterizedTypeReference`

.entity(Class) 适合普通类或 record。遇到 List<ActorsFilms>、Map<String, ActorsFilms> 这类泛型结构时，需要使用 ParameterizedTypeReference：

List<ActorsFilms> films = chatClient.prompt()
 .user("Generate filmographies for three random actors.")
 .call()
 .entity(new ParameterizedTypeReference<List<ActorsFilms>>() {});

同样可以追加参数配置：

List<ActorsFilms> films = chatClient.prompt()
 .user("Generate filmographies for three random actors.")
 .call()
 .entity(
 new ParameterizedTypeReference<List<ActorsFilms>>() {},
 spec -> spec.validateSchema()
 );

这里有一个重要兼容性坑：OpenAI 的 Structured Outputs API 不接受顶层数组。如果你在 OpenAI 上把 List<...> 和 useProviderStructuredOutput() 组合使用，可能会失败。更稳妥的方式是包一层 record：

record FilmographyList(List<ActorsFilms> films) {}

FilmographyList result = chatClient.prompt()
 .user("Generate filmographies for three random actors.")
 .call()
 .entity(FilmographyList.class, spec -> spec.useProviderStructuredOutput());

这也是面向多供应商开发时的通用经验：不要只按某一个模型的宽松行为设计数据结构，最好用显式对象包住列表、分页、错误码和元信息。

七、需要原始响应时，用 `.responseEntity(...)`

.entity(...) 只返回转换后的业务对象。如果你还需要 token 用量、模型元数据或原始 ChatResponse，可以使用 .responseEntity(...)：

ResponseEntity<ChatResponse, ActorsFilms> result = chatClient.prompt()
 .user("Generate the filmography for a random actor.")
 .call()
 .responseEntity(ActorsFilms.class);

ActorsFilms films = result.entity();
ChatResponse raw = result.response();
long totalTokens = raw.getMetadata().getUsage().getTotalTokens();

这对可观测性很有帮助。建议在生产系统中至少记录：模型名称、token 用量、重试次数、结构化校验是否失败过，以及最终转换耗时。这样当成本或延迟异常时，才能定位到底是模型调用慢、schema 过复杂，还是自修复重试过多。

八、内置 converter 与自定义 converter

Spring AI 参考文档列出了多个 converter，包括：

BeanOutputConverter<T>：把模型输出转换成指定 Java 类或 ParameterizedTypeReference，并使用符合 JSON Schema DRAFT_2020_12 的 schema；
MapOutputConverter：把 RFC8259 JSON 响应转换成 Map<String, Object>；
ListOutputConverter：面向逗号分隔列表输出转换；
AbstractConversionServiceOutputConverter 与 AbstractMessageOutputConverter：给更底层的转换扩展使用。

最常用的是 BeanOutputConverter。不过它也比较严格：如果模型在 JSON 前后加了解释文字，默认转换可能失败。对于历史模型、非原生结构化输出模型，或者你确实要兼容带代码块的 JSON，可以写一个轻量自定义 converter，先提取 JSON，再交给默认 converter：

public class LenientJsonOutputConverter<T> implements StructuredOutputConverter<T> {

 private static final Pattern FENCE = Pattern.compile("```(?:json)?\\s*([\\s\\S]*?)```");

 private final BeanOutputConverter<T> delegate;

 public LenientJsonOutputConverter(Class<T> targetType) {
 this.delegate = new BeanOutputConverter<>(targetType);
 }

 @Override
 public String getFormat() {
 return delegate.getFormat();
 }

 @Override
 public String getJsonSchema() {
 return delegate.getJsonSchema();
 }

 @Override
 public T convert(String source) {
 var matcher = FENCE.matcher(source);
 String json = matcher.find() ? matcher.group(1).trim() : source.trim();
 return delegate.convert(json);
 }
}

但要谨慎：宽松 converter 适合清理“JSON 外壳”，不应该悄悄吞掉业务字段错误。字段缺失、类型错误、枚举值非法，仍然应该交给 schema 校验或业务校验处理。

九、流式调用怎么处理结构化输出

Spring AI 文档说明，ChatClient 支持同步和流式模型。流式 .stream() 可以拿到 Flux<String> 或 Flux<ChatResponse>，但目前如果想把流式内容转成 Java 对象，需要先聚合完整文本，再显式调用结构化输出 converter。

示意代码如下：

var converter = new BeanOutputConverter<>(
 new ParameterizedTypeReference<List<ActorsFilms>>() {}
);

Flux<String> flux = chatClient.prompt()
 .user(u -> u.text("""
 Generate the filmography for a random actor.
 {format}
 """).param("format", converter.getFormat()))
 .stream()
 .content();

String content = flux.collectList()
 .block()
 .stream()
 .collect(Collectors.joining());

List<ActorsFilms> actorFilms = converter.convert(content);

如果你的业务既要“边生成边展示”，又要“最终写入结构化结果”，建议分成两个阶段：展示阶段走流式文本，落库阶段再触发一次非流式结构化调用，或者在流式完成后对完整文本做显式转换与校验。

十、工程落地清单

把 Spring AI 2.0 结构化输出接入生产系统时，可以按下面这份清单检查：

先定义稳定 DTO/record：字段名、类型、是否可为空要明确，不要把自然语言描述塞进一个大字符串字段里。
关键链路启用 validateSchema()：尤其是结果会入库、调用工具、影响流程分支的场景。
供应商支持时启用 useProviderStructuredOutput()：但要确认当前模型和 options 是否真的支持原生结构化输出。
避免顶层数组作为跨供应商公共协议：用包装 record 承载列表、分页和元信息。
记录观测指标：包括模型、token、耗时、重试次数、转换失败原因。
保留业务校验：schema 只能保证形状，不能保证“金额必须大于 0”“日期不能早于合同签署日”这类业务语义。
对失败路径设计降级策略：可以返回人工审核、重试队列、只展示原文，或者切换到更强模型，但不要静默写入脏数据。

总结

Spring AI 2.0 的结构化输出不是一个“让 JSON 更好看”的小功能，而是把大模型结果接入真实 Java 系统的重要基础设施。

.entity(...) 让模型回答直接进入 Java 类型；
validateSchema() 提供响应侧校验与自修复；
useProviderStructuredOutput() 尽量使用供应商原生结构化约束；
ParameterizedTypeReference、.responseEntity(...) 和自定义 converter 则覆盖了泛型、观测和兼容场景。

如果你正在把 LLM 从聊天窗口接进订单、工单、知识库、运维或智能体系统，建议尽早把“结构化输出 + schema 校验 + 业务校验”作为默认架构，而不是等线上出现一次脏数据事故后再补救。

Spring Boot 3.5.16 发布后，团队现在该怎么做：升级、验证与 3.5 生命周期收尾指南

Mon, 29 Jun 2026 15:21:35 +0000

Spring 团队在 2026-06-25 发布了 Spring Boot 3.5.16。如果你还在 3.5.x 线上维护窗口内，这个版本值得关注，因为它不仅是一个常规补丁版，还带着一个更重要的信号：3.5.x 已经来到开源维护周期的最后阶段。

这篇文章不重复官方公告，而是从工程落地角度整理成一份中文操作指南：这次版本到底变了什么、哪些团队应该马上升、升完要验证什么、以及如果你准备继续停留在 3.5 分支，应该怎样安排后续计划。

一、先说结论：3.5.16 是什么性质的版本

根据 Spring 官方博客，Spring Boot 3.5.16 已于 2026-06-25 发布，本次发布包含 3 项依赖升级。同时，官方明确说明它是 3.5.x 代际的最后一个 OSS 发布版本，后续若需要更长周期支持，需要转向商业支持方案。

结合 Spring Boot GitHub Release 与生命周期数据，可以把这个版本理解成：

它是 3.5.x 的收官补丁版本；
它不是一个新特性大版本，而是维护型版本；
对仍在 3.5.x 的团队来说，它很适合作为该分支的最终稳定落点；
如果你们还没有升级到 4.0/4.1，那么现在至少应先把 3.5.x 升到 3.5.16，再规划后续迁移。

二、这次实际更新了什么

从 Spring Boot 3.5.16 的 GitHub Release 页面可以确认，本次补丁版包含 3 个依赖升级：

Spring AMQP 3.2.12
Spring Data BOM 2025.0.13
Spring Integration 6.5.10

这说明 3.5.16 的核心价值并不是引入新的框架行为，而是：

对 3.5 代际已纳入管理的依赖做最后一轮维护性更新；
尽量把生态内相关模块收敛到更稳定的补丁位；
给仍在 3.5 线上运行的项目提供一个更明确的“最终补丁基线”。

如果你的应用显式或隐式使用了以下能力，建议优先升级并回归：

RabbitMQ / Spring AMQP 消息处理；
Spring Data 相关持久层能力；
Spring Integration 驱动的集成流、适配器或消息编排。

三、为什么这个版本值得今天就处理

很多团队看到“只有 3 个依赖升级”时，容易觉得可以先放一放。但从维护节奏上看，这次比功能变化更重要的是支持窗口变化。

生命周期数据表明：

Spring Boot 3.5 首次发布时间为 2025-05-31；
3.5.x 的 OSS 支持截止日期为 2026-06-30；
商业支持可延长到 2032-06-30；
截至校验时，3.5 分支最新版本就是 3.5.16（2026-06-25）。

这意味着什么？

1）你还在 3.5.x，就应该把 3.5.16 当成收官版看待

后续即便应用继续稳定运行，也不能再默认期待有新的公开补丁不断跟进。对生产团队来说，落在最后一个 OSS 补丁版本上，比停留在更早的 3.5.x 小版本上更稳妥。

2）升级 3.5.16 和规划下一跳，是两件要并行做的事

正确做法不是“反正马上要升 4.x，就不升 3.5.16 了”，而是：

短期：先把生产基线更新到 3.5.16；
中期：评估是升到 4.0 还是直接跟进 4.1；
长期：决定是否需要商业支持兜底。

因为 3.5.16 是补丁升级，风险通常远低于跨代升级。先完成这一步，可以降低你在迁移前的运行风险。

四、哪些项目应该优先升级

下面几类项目，建议你优先安排升级窗口：

1）仍在长期维护的存量业务系统

如果系统没有立刻升级到 4.x 的资源，但还要持续运行几个月甚至更久，那么停在 3.5.16 是更合理的选择。

2）依赖 Spring Data / Spring Integration / AMQP 的集成型系统

这次补丁直接涉及这些依赖线，消息、数据访问、系统集成相关项目更应该完成回归验证。

3）准备做 3.5 → 4.x 升级演练的团队

先把 3.5 基线统一到 3.5.16，再做跨代升级，排障边界会更清晰。否则你很难分辨问题来自：

旧的 3.5.x 补丁差异；
还是 4.x 的行为变化。

五、怎么升级到 3.5.16

大多数项目只需要改版本号，然后走一次标准构建与回归。

Maven

如果你使用 spring-boot-starter-parent：

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>3.5.16</version>
 <relativePath/>
</parent>

如果你使用 Spring Boot BOM：

<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-dependencies</artifactId>
 <version>3.5.16</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
</dependencyManagement>

Gradle

如果你通过 Spring Boot Gradle Plugin 管理版本：

plugins {
 id("org.springframework.boot") version "3.5.16"
 id("io.spring.dependency-management") version "1.1.7"
 kotlin("jvm") version "2.2.0"
}

如果你的项目并不使用 Kotlin 或不需要显式声明这些插件版本，请按你们自己的构建脚本风格调整，核心是把 Spring Boot 版本对齐到 3.5.16。

六、升级后重点验证什么

虽然 3.5.16 本身是补丁版，但 3.5 这一代并不是完全没有行为约束变化。Spring Boot 3.5 Release Notes 中有几项很适合作为升级后的重点回归清单。

1）`heapdump` 端点默认访问策略变更

在 3.5 代际中，heapdump Actuator 端点默认变成了 access=NONE。如果你们过去只做了暴露配置，没有显式设置访问策略，那么升级后相关诊断链路可能与旧行为不同。

如果你确实需要启用它，应同时配置暴露与访问权限，例如：

management:
 endpoints:
 web:
 exposure:
 include: heapdump
 endpoint:
 heapdump:
 access: unrestricted

建议你在测试环境确认：

端点是否仍按预期可访问；
安全配置是否仍符合内网/零信任策略；
是否存在把高敏感诊断端点暴露到错误网络边界的风险。

2）布尔型配置值解析更严格

3.5 代际对 .enabled 这类布尔配置的可接受值收紧为更一致的 true / false。如果你的历史配置里混入了不规范值，升级后应检查是否产生行为变化。

建议排查：

application.yml / application.properties；
环境变量注入后的映射值；
Helm Chart / Kustomize / Ansible 模板里的布尔值渲染方式。

3）Profile 命名校验更严格，但 3.5.1 起已部分放宽

Spring Boot 3.5 代际增强了 Profile 命名校验；官方 Release Notes 同时说明：从 3.5.1 开始，这些限制已部分放宽，额外允许 .、+、@ 字符，也可以通过 spring.profiles.validate=false 关闭校验。

如果你们组织里有历史遗留 Profile 命名习惯，比如：

prod-cn
gray@hz
perf.test

建议在升级后跑一次完整启动验证，确认 Profile 解析与加载顺序没有偏差。

4）按名称注入 `taskExecutor` 的代码需要留意

Spring Boot 3.5 Release Notes 明确指出：自动配置的 TaskExecutor 不再同时提供 taskExecutor 和 applicationTaskExecutor 两个 Bean 名称，现在只提供 applicationTaskExecutor。

如果你们代码里存在按名称获取执行器的写法，例如：

@Qualifier("taskExecutor")
手动 getBean("taskExecutor")
XML 或脚本化配置里写死旧名称

那就要重点回归这部分逻辑。更稳妥的做法是改成依赖 applicationTaskExecutor，避免在未来版本继续背兼容包袱。

七、升级前后的实操检查单

为了让这次补丁升级更可控，可以按下面的顺序执行。

升级前

锁定当前生产版本与构建产物；
导出一份依赖树，确认是否显式覆盖了 Spring AMQP、Spring Data、Spring Integration 相关版本；
识别所有依赖 Actuator、TaskExecutor、Profile、布尔配置开关的模块；
准备至少一轮完整的自动化测试与一轮烟雾验证。

升级中

把 Spring Boot 版本提升到 3.5.16；
执行依赖刷新；
运行单元测试、集成测试、启动测试；
对消息链路、数据库访问、接口调用、定时任务做重点验证。

升级后

检查 /actuator/health、/actuator/info 以及你们自定义观测端点；
检查日志里是否出现 Bean 注入名称变化、配置绑定失败、Profile 校验失败；
观察消息积压、线程池使用率、慢 SQL、启动耗时；
将 3.5.16 标记为 3.5 分支最终基线，并启动 4.x 升级计划。

八、现在是继续留在 3.5，还是直接上 4.x？

截至核实时，Spring 官方项目页显示 Spring Boot 当前最新主线版本为 4.1.0。因此从路线选择看，团队通常有三种策略：

策略 A：先稳定到 3.5.16，再规划 4.1

适合：生产系统多、变更窗口谨慎、近期不适合跨代升级的团队。

优点：

风险最低；
便于先完成一次补丁级基线收敛；
给 4.x 迁移预留独立测试周期。

策略 B：在测试环境同时启动 3.5.16 与 4.1 双线验证

适合：平台团队、公共框架团队、拥有较强自动化测试体系的组织。

优点：

能同步评估短期稳定性与中期迁移成本；
更早暴露跨代兼容性问题；
有利于制定统一升级路线。

策略 C：如果必须长期停留 3.5，评估商业支持

适合：合规要求高、升级窗口长、系统耦合深的企业场景。

因为官方已经明确 3.5.x 的 OSS 周期结束在即，所以“长期停留但不做支持兜底”会越来越被动。

九、给团队负责人的建议

如果你是技术负责人、架构师或中台维护者，我更建议把这次发布当成一个版本治理节点，而不是一次普通补丁升级。

你可以在本周内完成三件事：

把所有 3.5.x 服务统一到 3.5.16；
拉出仍按名称依赖 taskExecutor、依赖宽松布尔配置、依赖旧 profile 命名习惯的模块清单；
明确 4.0 / 4.1 的迁移时间表与负责人。

这样做的好处是，你不会在 3.5 OSS 窗口结束后，仍把版本决策停留在“以后再说”。

十、总结

Spring Boot 3.5.16 表面上只是一次小型维护发布，但它的意义并不小：

它是 Spring Boot 3.5.x 的最后一个 OSS 发布版本；
它把 Spring AMQP 3.2.12、Spring Data BOM 2025.0.13、Spring Integration 6.5.10 纳入最终补丁基线；
它适合作为仍在 3.5 分支上的团队的最终稳定落点；
它也在提醒你：该开始准备 4.x 了。

如果你今天只能做一件事，那就先把测试环境升到 3.5.16，跑完关键回归，再安排生产发布窗口。对仍处在 3.5 生命周期尾段的系统来说，这是成本最低、收益最高的一步。

24张图带你彻底弄懂Java线程池

Fri, 26 Jun 2026 10:00:00 +0000

什么是线程池

线程池其实是一种池化的技术实现，池化技术的核心思想就是实现资源的复用，避免资源的重复创建和销毁带来的性能开销。线程池可以管理一堆线程，让线程执行完任务之后不进行销毁，而是继续去处理其它线程已经提交的任务。

使用线程池的好处：

降低资源消耗：通过重复利用已创建的线程降低线程创建和销毁造成的消耗
提高响应速度：当任务到达时，任务可以不需要等到线程创建就能立即执行
提高线程的可管理性：线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性

线程池的构造

Java 主要是通过构建 ThreadPoolExecutor 来创建线程池的。构造方法参数如下：

public ThreadPoolExecutor(
 int corePoolSize, // 核心线程数
 int maximumPoolSize, // 最大线程数
 long keepAliveTime, // 空闲线程存活时间
 TimeUnit unit, // 时间单位
 BlockingQueue<Runnable> workQueue, // 任务队列
 ThreadFactory threadFactory, // 线程工厂
 RejectedExecutionHandler handler // 拒绝策略
)

corePoolSize：线程池中用来工作的核心线程数量
maximumPoolSize：最大线程数，线程池允许创建的最大线程数
keepAliveTime：超出 corePoolSize 后创建的线程存活时间
workQueue：任务队列，是一个阻塞队列
threadFactory：线程池内部创建线程所用的工厂
handler：拒绝策略

线程池的运行原理

1. 提交任务时的判断流程

提交任务
 ↓
线程数 < corePoolSize？
 ├── 是 → 创建核心线程执行任务
 └── 否 → 尝试放入workQueue
 ├── 成功 → 等待线程空闲获取任务
 └── 失败 → 线程数 < maximumPoolSize？
 ├── 是 → 创建非核心线程执行
 └── 否 → 执行拒绝策略

2. 四种拒绝策略

JDK 自带的 RejectedExecutionHandler 实现有 4 种：

策略	行为
`AbortPolicy`	丢弃任务，抛出运行时异常（默认）
`CallerRunsPolicy`	由提交任务的线程来执行任务
`DiscardPolicy`	丢弃这个任务，但是不抛异常
`DiscardOldestPolicy`	从队列中剔除最先进入队列的任务，然后再次提交任务

3. execute 方法核心逻辑

public void execute(Runnable command) {
 if (command == null) throw new NullPointerException();
 
 int c = ctl.get();
 
 // 1. 判断是否小于核心线程数
 if (workerCountOf(c) < corePoolSize) {
 if (addWorker(command, true))
 return;
 c = ctl.get();
 }
 
 // 2. 尝试将任务添加到任务队列中
 if (isRunning(c) && workQueue.offer(command)) {
 int recheck = ctl.get();
 if (!isRunning(recheck) && remove(command))
 reject(command);
 else if (workerCountOf(recheck) == 0)
 addWorker(null, false);
 }
 // 3. 尝试添加非核心线程来执行任务
 else if (!addWorker(command, false))
 reject(command);
}

线程池中线程复用的原理

线程在线程池内部被封装成了一个 Worker 对象，Worker 继承了 AQS，具有锁的特性。

创建线程来执行任务是通过 addWorker 方法。在创建 Worker 对象的时候，会把线程和任务一起封装到 Worker 内部，然后调用 runWorker 方法来让线程执行任务。

final void runWorker(Worker w) {
 Thread wt = Thread.currentThread();
 Runnable task = w.firstTask;
 w.firstTask = null;
 w.unlock();
 
 try {
 // 当有任务或能从队列获取任务时，持续运行
 while (task != null || (task = getTask()) != null) {
 w.lock();
 try {
 beforeExecute(wt, task);
 task.run();
 afterExecute(task, null);
 } finally {
 task = null;
 w.completedTasks++;
 w.unlock();
 }
 }
 } finally {
 processWorkerExit(w, completedAbruptly);
 }
}

关键点：while (task != null || (task = getTask()) != null) 这个循环让线程不会退出，而是不断从队列获取新任务，实现了线程复用。

自定义线程池的最佳实践

在实际项目中，不建议使用 Executors 工具类创建线程池，而是应该手动创建 ThreadPoolExecutor：

ThreadPoolExecutor executor = new ThreadPoolExecutor(
 10, // 核心线程数
 20, // 最大线程数
 60L, // 空闲存活时间
 TimeUnit.SECONDS, // 时间单位
 new LinkedBlockingQueue<>(1000), // 有界队列
 new ThreadFactoryBuilder().setNameFormat("business-pool-%d").build(),
 new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

注意事项：

核心线程数设置：CPU密集型任务设置为 CPU核心数+1，IO密集型任务设置为 CPU核心数*2
队列选择：建议使用有界队列，避免OOM
拒绝策略：根据业务场景选择合适的拒绝策略
线程池命名：便于排查问题

总结

线程池是 Java 并发编程中非常重要的组件，理解其工作原理对于编写高性能的并发程序至关重要。核心要点：

线程池通过复用线程来降低资源消耗
ThreadPoolExecutor 的核心参数决定了线程池的行为
任务提交流程：核心线程 → 队列 → 非核心线程 → 拒绝策略
线程复用通过 Worker + runWorker 的 while 循环实现
生产环境建议手动创建线程池，避免使用 Executors

Spring Cloud 微服务架构全解：注册发现、网关、熔断与实战

Thu, 25 Jun 2026 18:00:00 +0000

前言

Spring Cloud 是基于 Spring Boot 的微服务架构解决方案，提供了一系列工具和框架来解决分布式系统中的常见问题：服务注册与发现、配置中心、负载均衡、熔断降级、网关路由、链路追踪等。本文基于 Spring Cloud 2022.x + Spring Boot 3.x 体系讲解。

1. 微服务架构概览

 ┌──────────────┐
 │ 客户端 │
 └──────┬───────┘
 │
 ┌──────▼───────┐
 │ Gateway │ (路由、限流、鉴权)
 │ 网关服务 │
 └──────┬───────┘
 │
 ┌──────────────┼──────────────┐
 │ │ │
 ┌──────▼──────┐ ┌────▼──────┐ ┌─────▼─────┐
 │ 用户服务 │ │ 订单服务 │ │ 商品服务 │
 │ user-svc │ │ order-svc │ │ product-svc│
 └──────┬──────┘ └────┬──────┘ └─────┬─────┘
 │ │ │
 ┌──────▼──────────────▼──────────────▼─────┐
 │ Nacos (注册中心 + 配置中心) │
 └──────────────────────────────────────────┘
 │ │ │
 ┌──────▼──────┐ ┌────▼──────┐ ┌─────▼─────┐
 │ MySQL │ │ Redis │ │ RocketMQ │
 └─────────────┘ └───────────┘ └────────────┘

2. Spring Cloud 版本选择

Spring Cloud	Spring Boot	主要组件
2024.0.x	3.4.x / 3.5.x	Nacos 2.x, Sentinel, Gateway
2023.0.x (Leyton)	3.2.x / 3.3.x	Nacos 2.x, Sentinel, Gateway
2022.0.x (Kilburn)	3.0.x / 3.1.x	Nacos 2.x, Sentinel, Gateway

Spring Boot 4.x 适配的 Spring Cloud 版本请参考官方文档。

2.1 依赖管理（pom.xml）

<dependencyManagement>
 <dependencies>
 <!-- Spring Cloud 版本管理 -->
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>2023.0.0</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>

 <!-- Spring Cloud Alibaba 版本管理 -->
 <dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-alibaba-dependencies</artifactId>
 <version>2023.0.0.0</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
</dependencyManagement>

3. Nacos — 注册中心与配置中心

3.1 安装 Nacos

# Docker 快速启动
docker run -d \
 --name nacos \
 -p 8848:8848 \
 -p 9848:9848 \
 -e MODE=standalone \
 -e NACOS_AUTH_ENABLE=true \
 nacos/nacos-server:v2.3.0

# 访问控制台: http://localhost:8848/nacos
# 默认账号: nacos / nacos

3.2 服务注册

<!-- 引入依赖 -->
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

# application.yml
spring:
 application:
 name: user-service
 cloud:
 nacos:
 discovery:
 server-addr: localhost:8848
 namespace: dev
 group: DEFAULT_GROUP
 username: nacos
 password: nacos

// 启动类
@SpringBootApplication
@EnableDiscoveryClient
public class UserServiceApplication {
 public static void main(String[] args) {
 SpringApplication.run(UserServiceApplication.class, args);
 }
}

3.3 配置中心

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-bootstrap</artifactId>
</dependency>

# bootstrap.yml
spring:
 application:
 name: user-service
 cloud:
 nacos:
 config:
 server-addr: localhost:8848
 file-extension: yml
 namespace: dev
 group: DEFAULT_GROUP
 # 共享配置
 shared-configs:
 - data-id: common.yml
 group: DEFAULT_GROUP
 refresh: true

// 动态刷新配置
@RestController
@RefreshScope
public class ConfigController {

 @Value("${app.custom-config}")
 private String customConfig;

 @GetMapping("/config")
 public String getConfig() {
 return customConfig;
 }
}

4. OpenFeign — 声明式 HTTP 调用

4.1 基本用法

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>

// 启动类
@SpringBootApplication
@EnableFeignClients
public class OrderServiceApplication { }

// 定义 Feign 客户端
@FeignClient(name = "user-service", fallbackFactory = UserClientFallbackFactory.class)
public interface UserClient {

 @GetMapping("/api/users/{id}")
 ApiResponse<UserDTO> getUserById(@PathVariable("id") Long id);

 @PostMapping("/api/users/batch")
 ApiResponse<List<UserDTO>> getUsersByIds(@RequestBody List<Long> ids);
}

// 降级工厂
@Component
public class UserClientFallbackFactory implements FallbackFactory<UserClient> {
 @Override
 public UserClient create(Throwable cause) {
 return new UserClient() {
 @Override
 public ApiResponse<UserDTO> getUserById(Long id) {
 return ApiResponse.error(503, "用户服务不可用: " + cause.getMessage());
 }
 @Override
 public ApiResponse<List<UserDTO>> getUsersByIds(List<Long> ids) {
 return ApiResponse.error(503, "用户服务不可用");
 }
 };
 }
}

// 使用
@Service
@RequiredArgsConstructor
public class OrderService {

 private final UserClient userClient;

 public OrderDTO getOrderDetail(Long orderId) {
 Order order = orderRepository.findById(orderId).orElseThrow();
 // 调用用户服务
 ApiResponse<UserDTO> userResp = userClient.getUserById(order.getUserId());
 // 组装返回
 OrderDTO dto = new OrderDTO();
 dto.setOrder(order);
 dto.setUser(userResp.getData());
 return dto;
 }
}

4.2 Feign 配置

feign:
 client:
 config:
 default:
 connect-timeout: 5000
 read-timeout: 10000
 logger-level: FULL
 compression:
 request:
 enabled: true
 mime-types: application/json
 min-request-size: 2048
 response:
 enabled: true
 circuitbreaker:
 enabled: true

5. Gateway — API 网关

5.1 网关服务搭建

<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>
<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>

spring:
 application:
 name: gateway
 cloud:
 nacos:
 discovery:
 server-addr: localhost:8848
 gateway:
 # 路由配置
 routes:
 - id: user-service
 uri: lb://user-service  # 负载均衡
 predicates:
 - Path=/api/users/**
 filters:
 - StripPrefix=1  # 去掉前缀

 - id: order-service
 uri: lb://order-service
 predicates:
 - Path=/api/orders/**
 filters:
 - StripPrefix=1

 - id: product-service
 uri: lb://product-service
 predicates:
 - Path=/api/products/**
 filters:
 - StripPrefix=1

 # 全局 CORS
 globalcors:
 cors-configurations:
 '[/**]':
 allowedOrigins: "*"
 allowedMethods: "*"
 allowedHeaders: "*"

5.2 自定义过滤器

@Component
public class AuthFilter implements GlobalFilter, Ordered {

 @Override
 public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
 String token = exchange.getRequest().getHeaders().getFirst("Authorization");

 // 白名单
 String path = exchange.getRequest().getURI().getPath();
 if (path.contains("/auth/") || path.contains("/public/")) {
 return chain.filter(exchange);
 }

 // 验证 Token
 if (token == null || !validateToken(token)) {
 ServerHttpResponse response = exchange.getResponse();
 response.setStatusCode(HttpStatus.UNAUTHORIZED);
 response.getHeaders().setContentType(MediaType.APPLICATION_JSON);
 String body = "{\"code\":401,\"message\":\"未授权\"}";
 DataBuffer buffer = response.bufferFactory().wrap(body.getBytes());
 return response.writeWith(Mono.just(buffer));
 }

 // 将用户信息传递给下游服务
 ServerHttpRequest request = exchange.getRequest().mutate()
 .header("X-User-Id", getUserId(token))
 .build();

 return chain.filter(exchange.mutate().request(request).build());
 }

 @Override
 public int getOrder() {
 return -1; // 最高优先级
 }
}

6. Sentinel — 熔断降级与限流

6.1 引入依赖

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
</dependency>

6.2 限流规则

@Service
public class ProductService {

 @SentinelResource(
 value = "getProduct",
 blockHandler = "getProductBlock",
 fallback = "getProductFallback"
 )
 public ProductDTO getProduct(Long id) {
 return productRepository.findById(id)
 .map(this::convertToDTO)
 .orElseThrow(() -> new BusinessException(404, "商品不存在"));
 }

 // 限流降级
 public ProductDTO getProductBlock(Long id, BlockException ex) {
 throw new BusinessException(429, "请求过于频繁，请稍后再试");
 }

 // 业务降级
 public ProductDTO getProductFallback(Long id, Throwable ex) {
 return ProductDTO.builder()
 .id(id)
 .name("商品信息暂不可用")
 .build();
 }
}

6.3 熔断规则（代码配置）

@Configuration
public class SentinelConfig {

 @PostConstruct
 public void initRules() {
 // 限流规则
 FlowRule flowRule = new FlowRule();
 flowRule.setResource("getProduct");
 flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
 flowRule.setCount(100); // QPS 限制为 100
 flowRule.setControlBehavior(RuleConstant.CONTROL_BEHAVIOR_WARM_UP);
 flowRule.setWarmUpPeriodSec(10); // 预热 10 秒
 FlowRuleManager.loadRules(Collections.singletonList(flowRule));

 // 熔断规则
 DegradeRule degradeRule = new DegradeRule();
 degradeRule.setResource("getProduct");
 degradeRule.setGrade(CircuitBreakerStrategy.ERROR_RATIO.getType());
 degradeRule.setCount(0.5); // 错误率 50%
 degradeRule.setTimeWindow(30); // 熔断持续 30 秒
 degradeRule.setMinRequestAmount(10); // 最少 10 次请求
 degradeRule.setStatIntervalMs(10000); // 统计窗口 10 秒
 DegradeManager.loadRules(Collections.singletonList(degradeRule));
 }
}

6.4 网关限流

spring:
 cloud:
 gateway:
 routes:
 - id: user-service
 uri: lb://user-service
 predicates:
 - Path=/api/users/**
 filters:
 - name: RequestRateLimiter
 args:
 redis-rate-limiter.replenishRate: 10 # 每秒 10 个请求
 redis-rate-limiter.burstCapacity: 20 # 突发容量 20
 key-resolver: "#{@userKeyResolver}"

@Component
public class UserKeyResolver implements KeyResolver {
 @Override
 public Mono<String> resolve(ServerWebExchange exchange) {
 // 按用户 ID 限流
 String userId = exchange.getRequest().getHeaders().getFirst("X-User-Id");
 return Mono.just(userId != null ? userId : exchange.getRequest().getRemoteAddress().getHostString());
 }
}

7. Seata — 分布式事务

7.1 引入依赖

<dependency>
 <groupId>com.alibaba.cloud</groupId>
 <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
</dependency>

7.2 使用 @GlobalTransactional

@Service
@RequiredArgsConstructor
public class OrderService {

 private final OrderMapper orderMapper;
 private final AccountClient accountClient;
 private final StorageClient storageClient;

 @GlobalTransactional(name = "create-order", rollbackFor = Exception.class)
 public void createOrder(OrderRequest request) {
 // 1. 创建订单
 Order order = new Order();
 order.setUserId(request.getUserId());
 order.setProductId(request.getProductId());
 order.setCount(request.getCount());
 order.setStatus(0);
 orderMapper.insert(order);

 // 2. 扣减库存（远程调用）
 storageClient.deduct(request.getProductId(), request.getCount());

 // 3. 扣减余额（远程调用）
 accountClient.debit(request.getUserId(), request.getTotalAmount());

 // 4. 更新订单状态
 order.setStatus(1);
 orderMapper.updateById(order);

 // 如果任何一步失败，所有操作都会回滚
 }
}

8. Sleuth + Zipkin — 链路追踪

<!-- 依赖 -->
<dependency>
 <groupId>io.micrometer</groupId>
 <artifactId>micrometer-tracing-bridge-brave</artifactId>
</dependency>
<dependency>
 <groupId>io.zipkin.reporter2</groupId>
 <artifactId>zipkin-reporter-brave</artifactId>
</dependency>

management:
 tracing:
 sampling:
 probability: 1.0 # 采样率（1.0 = 100%）
 zipkin:
 tracing:
 endpoint: http://localhost:9411/api/v2/spans

9. 完整项目结构

my-cloud/
├── pom.xml # 父 POM
├── gateway/ # 网关服务
│ ├── pom.xml
│ └── src/
├── user-service/ # 用户服务
│ ├── pom.xml
│ └── src/
├── order-service/ # 订单服务
│ ├── pom.xml
│ └── src/
├── product-service/ # 商品服务
│ ├── pom.xml
│ └── src/
└── common/ # 公共模块
 ├── pom.xml
 └── src/
 └── main/java/com/example/common/
 ├── model/ # 公共 DTO
 ├── exception/ # 异常定义
 ├── util/ # 工具类
 └── config/ # 公共配置

10. 核心组件对比

功能	Spring Cloud Netflix (旧)	Spring Cloud Alibaba (推荐)
注册中心	Eureka	Nacos
配置中心	Spring Cloud Config	Nacos
负载均衡	Ribbon	Spring Cloud LoadBalancer
远程调用	Feign	OpenFeign
网关	Zuul	Spring Cloud Gateway
熔断降级	Hystrix	Sentinel
分布式事务	—	Seata
消息队列	—	RocketMQ

11. 常见面试题

Q: Nacos 和 Eureka 的区别？ A: Nacos 同时支持 CP（配置中心）和 AP（注册中心）模式，支持配置中心，支持主动推送；Eureka 只支持 AP 模式，仅做注册中心。

Q: Sentinel 和 Hystrix 的区别？ A: Sentinel 支持实时监控 Dashboard、多种限流策略（QPS/线程数/热点参数）、网关限流；Hystrix 已停止维护，功能相对简单。

Q: Gateway 和 Zuul 的区别？ A: Gateway 基于 Spring WebFlux（响应式），性能更好；Zuul 1.x 基于 Servlet（阻塞式），性能较差。Zuul 2.x 未与 Spring Cloud 深度集成。

Q: 如何保证分布式事务一致性？ A: 常用方案：Seata（AT/TCC/SAGA 模式）、本地消息表 + MQ、最大努力通知等。

总结

Spring Cloud 核心组件：

Nacos — 注册中心 + 配置中心，服务发现与动态配置
OpenFeign — 声明式 HTTP 调用，简化微服务间通信
Gateway — API 网关，路由、限流、鉴权
Sentinel — 熔断降级 + 限流，保护服务稳定性
Seata — 分布式事务，保证数据一致性
Sleuth + Zipkin — 链路追踪，排查分布式调用问题
LoadBalancer — 客户端负载均衡

Spring Boot 4 从入门到实战：自动配置、Web 开发与生产部署

Thu, 25 Jun 2026 17:30:00 +0000

前言

Spring Boot 是 Spring 生态中最受欢迎的框架，它通过"约定优于配置"的理念，让开发者能快速创建独立运行的、生产级的 Spring 应用。目前最新版本为 Spring Boot 4.1.0（2026 年 6 月发布），要求 Java 17+，基于 Spring Framework 7，全面拥抱 Jakarta EE。

1. 核心特性

特性	说明
自动配置	根据引入的依赖自动配置 Bean
起步依赖	Starter 依赖简化 Maven/Gradle 配置
内嵌服务器	内嵌 Tomcat/Jetty/Undertow，无需外部部署
Actuator	生产级监控和管理端点
外部化配置	支持 YAML/Properties/环境变量/命令行参数
无代码生成	不生成代码，不修改字节码

2. 快速开始

2.1 创建项目

# 使用 Spring Initializr（推荐）
# https://start.spring.io

# 或使用命令行
curl https://start.spring.io/starter.tgz \
 -d type=maven-project \
 -d language=java \
 -d bootVersion=4.1.0 \
 -d baseDir=myapp \
 -d groupId=com.example \
 -d artifactId=myapp \
 -d name=myapp \
 -d packageName=com.example.myapp \
 -d javaVersion=17 \
 -d dependencies=web,data-jpa,mysql,lombok,actuator \
| tar -xzvf -

2.2 pom.xml 核心依赖

<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>4.1.0</version>
</parent>

<dependencies>
 <!-- Web -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-web</artifactId>
 </dependency>

 <!-- 数据库 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-jpa</artifactId>
 </dependency>
 <dependency>
 <groupId>com.mysql</groupId>
 <artifactId>mysql-connector-j</artifactId>
 </dependency>

 <!-- Redis -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-data-redis</artifactId>
 </dependency>

 <!-- 参数校验 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-validation</artifactId>
 </dependency>

 <!-- Lombok -->
 <dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <optional>true</optional>
 </dependency>

 <!-- 监控 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-actuator</artifactId>
 </dependency>

 <!-- 测试 -->
 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-test</artifactId>
 <scope>test</scope>
 </dependency>
</dependencies>

2.3 启动类

@SpringBootApplication
public class MyApplication {
 public static void main(String[] args) {
 SpringApplication.run(MyApplication.class, args);
 }
}

3. 自动配置原理

3.1 启动流程

@SpringBootApplication
 ├── @SpringBootConfiguration → 标记为配置类
 ├── @EnableAutoConfiguration → 开启自动配置
 │ └── @Import(AutoConfigurationImportSelector)
 │ └── 读取 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
 └── @ComponentScan → 扫描当前包及子包

3.2 自动配置条件注解

@ConditionalOnClass // 类路径下存在指定类
@ConditionalOnMissingClass // 类路径下不存在指定类
@ConditionalOnBean // 容器中存在指定 Bean
@ConditionalOnMissingBean // 容器中不存在指定 Bean
@ConditionalOnProperty // 配置属性满足条件
@ConditionalOnResource // 类路径下存在指定资源
@ConditionalOnWebApplication // 是 Web 应用

3.3 查看自动配置报告

# 启动时添加 --debug 参数
java -jar myapp.jar --debug

# 或在配置中添加
debug=true

日志中会显示：

Positive matches — 匹配成功的自动配置
Negative matches — 未匹配的自动配置
Unconditional classes — 无条件配置的类

4. 配置文件

4.1 application.yml

server:
 port: 8080
 servlet:
 context-path: /api

spring:
 # 数据源
 datasource:
 url: jdbc:mysql://localhost:3306/mydb?useSSL=false&serverTimezone=Asia/Shanghai
 username: root
 password: ${DB_PASSWORD:default}
 hikari:
 maximum-pool-size: 20
 minimum-idle: 5

 # JPA
 jpa:
 hibernate:
 ddl-auto: update
 show-sql: true
 properties:
 hibernate:
 format_sql: true

 # Redis
 data:
 redis:
 host: localhost
 port: 6379
 password: ${REDIS_PASSWORD:}
 database: 0

 # Jackson
 jackson:
 date-format: yyyy-MM-dd HH:mm:ss
 time-zone: Asia/Shanghai
 default-property-inclusion: non_null

# 自定义配置
app:
 name: My Application
 version: 1.0.0

# 日志
logging:
 level:
 root: INFO
 com.example.myapp: DEBUG
 org.hibernate.SQL: DEBUG
 file:
 name: logs/app.log
 max-size: 100MB
 max-history: 30

# Actuator
management:
 endpoints:
 web:
 exposure:
 include: health,info,metrics,prometheus
 endpoint:
 health:
 show-details: always

4.2 多环境配置

# application-dev.yml → 开发环境
# application-test.yml → 测试环境
# application-prod.yml → 生产环境

# 激活方式
java -jar myapp.jar --spring.profiles.active=prod

# 或环境变量
export SPRING_PROFILES_ACTIVE=prod

4.3 读取配置

// 方式一：@Value
@Value("${app.name}")
private String appName;

// 方式二：@ConfigurationProperties
@Data
@ConfigurationProperties(prefix = "app")
public class AppProperties {
 private String name;
 private String version;
 private List<String> servers;
}

// 在启动类上启用
@SpringBootApplication
@EnableConfigurationProperties(AppProperties.class)
public class MyApplication { }

5. Web 开发

5.1 RESTful Controller

@RestController
@RequestMapping("/api/users")
@RequiredArgsConstructor
public class UserController {

 private final UserService userService;

 @GetMapping
 public ApiResponse<List<UserDTO>> list(@RequestParam(defaultValue = "1") int page,
 @RequestParam(defaultValue = "10") int size) {
 return ApiResponse.success(userService.list(page, size));
 }

 @GetMapping("/{id}")
 public ApiResponse<UserDTO> getById(@PathVariable Long id) {
 return ApiResponse.success(userService.getById(id));
 }

 @PostMapping
 public ApiResponse<UserDTO> create(@Valid @RequestBody UserCreateRequest request) {
 return ApiResponse.success(userService.create(request));
 }

 @PutMapping("/{id}")
 public ApiResponse<UserDTO> update(@PathVariable Long id,
 @Valid @RequestBody UserUpdateRequest request) {
 return ApiResponse.success(userService.update(id, request));
 }

 @DeleteMapping("/{id}")
 public ApiResponse<Void> delete(@PathVariable Long id) {
 userService.delete(id);
 return ApiResponse.success(null);
 }
}

5.2 统一响应封装

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse<T> {
 private int code;
 private String message;
 private T data;

 public static <T> ApiResponse<T> success(T data) {
 return new ApiResponse<>(200, "OK", data);
 }

 public static <T> ApiResponse<T> error(int code, String message) {
 return new ApiResponse<>(code, message, null);
 }
}

5.3 全局异常处理

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {

 // 参数校验异常
 @ExceptionHandler(MethodArgumentNotValidException.class)
 public ApiResponse<Void> handleValidation(MethodArgumentNotValidException e) {
 String message = e.getBindingResult().getFieldErrors().stream()
 .map(fe -> fe.getField() + ": " + fe.getDefaultMessage())
 .collect(Collectors.joining(", "));
 return ApiResponse.error(400, message);
 }

 // 业务异常
 @ExceptionHandler(BusinessException.class)
 public ApiResponse<Void> handleBusiness(BusinessException e) {
 return ApiResponse.error(e.getCode(), e.getMessage());
 }

 // 未捕获异常
 @ExceptionHandler(Exception.class)
 public ApiResponse<Void> handleException(Exception e) {
 log.error("Unexpected error", e);
 return ApiResponse.error(500, "服务器内部错误");
 }
}

5.4 请求参数校验

@Data
public class UserCreateRequest {

 @NotBlank(message = "用户名不能为空")
 @Size(min = 2, max = 20, message = "用户名长度 2-20")
 private String username;

 @NotBlank(message = "邮箱不能为空")
 @Email(message = "邮箱格式不正确")
 private String email;

 @NotNull(message = "年龄不能为空")
 @Min(value = 1, message = "年龄最小 1")
 @Max(value = 150, message = "年龄最大 150")
 private Integer age;
}

5.5 拦截器

@Component
public class AuthInterceptor implements HandlerInterceptor {

 @Override
 public boolean preHandle(HttpServletRequest request,
 HttpServletResponse response,
 Object handler) throws Exception {
 String token = request.getHeader("Authorization");
 if (token == null || !validateToken(token)) {
 response.setStatus(401);
 response.getWriter().write("{\"code\":401,\"message\":\"未授权\"}");
 return false;
 }
 return true;
 }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

 @Autowired
 private AuthInterceptor authInterceptor;

 @Override
 public void addInterceptors(InterceptorRegistry registry) {
 registry.addInterceptor(authInterceptor)
 .addPathPatterns("/api/**")
 .excludePathPatterns("/api/auth/**");
 }
}

5.6 跨域配置

@Configuration
public class CorsConfig implements WebMvcConfigurer {

 @Override
 public void addCorsMappings(CorsRegistry registry) {
 registry.addMapping("/api/**")
 .allowedOrigins("http://localhost:3000")
 .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS")
 .allowedHeaders("*")
 .allowCredentials(true)
 .maxAge(3600);
 }
}

6. 数据访问

6.1 JPA 实体

@Entity
@Table(name = "users")
@Data
public class User {
 @Id
 @GeneratedValue(strategy = GenerationType.IDENTITY)
 private Long id;

 @Column(nullable = false, unique = true, length = 50)
 private String username;

 @Column(nullable = false)
 private String email;

 @Column(nullable = false)
 private Integer age;

 @CreationTimestamp
 private LocalDateTime createdAt;

 @UpdateTimestamp
 private LocalDateTime updatedAt;
}

6.2 JPA Repository

public interface UserRepository extends JpaRepository<User, Long> {

 Optional<User> findByUsername(String username);

 List<User> findByAgeBetween(Integer minAge, Integer maxAge);

 @Query("SELECT u FROM User u WHERE u.email LIKE %:keyword% OR u.username LIKE %:keyword%")
 Page<User> search(@Param("keyword") String keyword, Pageable pageable);

 @Modifying
 @Query("UPDATE User u SET u.email = :email WHERE u.id = :id")
 int updateEmail(@Param("id") Long id, @Param("email") String email);
}

6.3 Redis 缓存

@Service
@RequiredArgsConstructor
public class UserService {

 private final UserRepository userRepository;
 private final RedisTemplate<String, Object> redisTemplate;

 // 使用 RedisTemplate
 public UserDTO getById(Long id) {
 String key = "user:" + id;
 UserDTO cached = (UserDTO) redisTemplate.opsForValue().get(key);
 if (cached != null) return cached;

 User user = userRepository.findById(id)
 .orElseThrow(() -> new BusinessException(404, "用户不存在"));
 UserDTO dto = convertToDTO(user);
 redisTemplate.opsForValue().set(key, dto, 30, TimeUnit.MINUTES);
 return dto;
 }

 // 使用 Spring Cache 注解
 @Cacheable(value = "users", key = "#id")
 public UserDTO getByIdCached(Long id) { ... }

 @CachePut(value = "users", key = "#id")
 public UserDTO update(Long id, UserUpdateRequest request) { ... }

 @CacheEvict(value = "users", key = "#id")
 public void delete(Long id) { ... }
}

7. AOP 切面

@Aspect
@Component
@Slf4j
public class LogAspect {

 @Around("@annotation(logOperation)")
 public Object around(ProceedingJoinPoint point, LogOperation logOperation) throws Throwable {
 long start = System.currentTimeMillis();
 String methodName = point.getSignature().toShortString();

 log.info("开始执行: {} - {}", logOperation.value(), methodName);

 try {
 Object result = point.proceed();
 long cost = System.currentTimeMillis() - start;
 log.info("执行完成: {} - {} ({}ms)", logOperation.value(), methodName, cost);
 return result;
 } catch (Exception e) {
 log.error("执行异常: {} - {}", logOperation.value(), methodName, e);
 throw e;
 }
 }
}

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogOperation {
 String value() default "";
}

8. 定时任务

@SpringBootApplication
@EnableScheduling
public class MyApplication { }

@Component
@Slf4j
public class ScheduledTasks {

 @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨 2 点
 public void dailyBackup() {
 log.info("执行每日备份...");
 }

 @Scheduled(fixedRate = 60000) // 每 60 秒
 public void syncData() {
 log.info("同步数据...");
 }

 @Scheduled(fixedDelay = 30000) // 上次完成后 30 秒
 public void cleanup() {
 log.info("清理任务...");
 }
}

9. 异步处理

@SpringBootApplication
@EnableAsync
public class MyApplication { }

@Configuration
public class AsyncConfig {

 @Bean("taskExecutor")
 public Executor taskExecutor() {
 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 executor.setCorePoolSize(5);
 executor.setMaxPoolSize(20);
 executor.setQueueCapacity(100);
 executor.setThreadNamePrefix("async-");
 executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
 return executor;
 }
}

@Service
public class NotificationService {

 @Async("taskExecutor")
 public CompletableFuture<String> sendEmail(String to, String content) {
 // 耗时操作
 return CompletableFuture.completedFuture("sent");
 }
}

10. 生产部署

10.1 打包

# Maven 打包
mvn clean package -DskipTests

# Gradle 打包
gradle bootJar

# 运行
java -jar target/myapp-1.0.0.jar

# 指定 profile
java -jar myapp.jar --spring.profiles.active=prod

# JVM 参数
java -Xms512m -Xmx1024m -XX:+UseG1GC -jar myapp.jar

10.2 Docker 部署

FROM eclipse-temurin:17-jre-alpine
WORKDIR /app
COPY target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

10.3 Actuator 监控端点

端点	说明
`/actuator/health`	健康检查
`/actuator/info`	应用信息
`/actuator/metrics`	指标数据
`/actuator/prometheus`	Prometheus 格式指标
`/actuator/env`	环境变量
`/actuator/configprops`	配置属性
`/actuator/beans`	所有 Bean
`/actuator/mappings`	URL 映射
`/actuator/loggers`	日志级别管理
`/actuator/threaddump`	线程 dump
`/actuator/heapdump`	堆 dump

11. 常用 Starter 一览

Starter	用途
spring-boot-starter-web	Web/RESTful
spring-boot-starter-data-jpa	JPA 数据访问
spring-boot-starter-data-redis	Redis
spring-boot-starter-data-mongodb	MongoDB
spring-boot-starter-security	安全认证
spring-boot-starter-validation	参数校验
spring-boot-starter-mail	邮件发送
spring-boot-starter-quartz	定时任务
spring-boot-starter-websocket	WebSocket
spring-boot-starter-actuator	监控管理
spring-boot-starter-test	单元测试
mybatis-plus-spring-boot3-starter	MyBatis-Plus

12. Spring Boot 版本选择

版本	状态	Java 要求	Spring Framework
4.1.x (推荐)	最新，OSS 支持到 2027.7	Java 17-26	7.0.x
4.0.x	稳定	Java 17-26	7.0.x
3.5.x	OSS 支持到 2026.6	Java 17-24	6.2.x
3.2.x	已停止 OSS 支持	Java 17-21	6.1.x
2.7.x	已停止支持	Java 8/11/17	5.3.x

💡 建议：新项目直接使用 Spring Boot 4.1.x + Java 21/25。

总结

Spring Boot 核心知识点：

自动配置 — 根据依赖自动配置，减少样板代码
起步依赖 — Starter 一站式引入所需依赖
Web 开发 — RESTful API、参数校验、异常处理、拦截器
数据访问 — JPA、Redis、MyBatis
AOP — 日志、权限、缓存等横切关注点
生产特性 — Actuator 监控、多环境配置、优雅停机
部署方式 — JAR 直接运行、Docker 容器化

Java 21 新特性详解：虚拟线程、Pattern Matching Switch 与现代并发

Thu, 25 Jun 2026 15:00:00 +0000

前言

Java 21 于 2023 年 9 月发布，是继 Java 17 之后的下一个长期支持版本（LTS）。它带来了 Java 并发编程的革命性变化——虚拟线程（Virtual Threads），以及一系列语法增强。对于需要处理高并发的后端开发者来说，Java 21 是一个里程碑式的版本。

1. 虚拟线程（Virtual Threads）

虚拟线程是 Project Loom 的核心成果，用极低的资源开销实现百万级并发。

1.1 传统线程 vs 虚拟线程

// 传统平台线程：每个线程占用约 1MB 内存
// 1 万个线程 ≈ 10GB 内存
Thread platformThread = new Thread(() -> System.out.println("Platform Thread"));

// 虚拟线程：每个虚拟线程仅占几 KB
// 100 万个虚拟线程也只需几 GB 内存
Thread virtualThread = Thread.ofVirtual().start(() -> System.out.println("Virtual Thread"));

// 创建虚拟线程（方式一：Builder）
Thread vt1 = Thread.ofVirtual()
 .name("my-vt", 0)
 .start(() -> doWork());

// 创建虚拟线程（方式二：工厂）
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
executor.submit(() -> doWork());

// 创建虚拟线程（方式三：直接创建）
Thread.startVirtualThread(() -> doWork());

1.2 与传统线程池对比

// 传统方式：固定线程池，线程数受限
ExecutorService pool = Executors.newFixedThreadPool(200);
for (int i = 0; i < 100_000; i++) {
 pool.submit(() -> {
 Thread.sleep(Duration.ofSeconds(1)); // 阻塞
 return fetchData();
 });
}
// 问题：200 个线程只能同时处理 200 个请求，其余排队

// 虚拟线程：每个任务一个线程，百万级并发
ExecutorService vExecutor = Executors.newVirtualThreadPerTaskExecutor();
for (int i = 0; i < 1_000_000; i++) {
 vExecutor.submit(() -> {
 Thread.sleep(Duration.ofSeconds(1)); // 阻塞不浪费资源
 return fetchData();
 });
}
// 100 万个任务几乎同时执行

1.3 实战：HTTP 服务

// 使用虚拟线程的 HTTP 服务器
public class VirtualThreadServer {
 public static void main(String[] args) throws IOException {
 // 传统方式需要线程池，虚拟线程直接创建
 var server = HttpServer.create(new InetSocketAddress(8080), 0);
 server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
 server.createContext("/api/users", exchange -> {
 // 每个请求一个虚拟线程，可以安全地阻塞
 String userId = extractUserId(exchange);
 User user = db.query(userId); // 阻塞 IO，虚拟线程自动让出
 Order order = fetchOrder(userId); // 阻塞 HTTP 调用
 String response = formatResponse(user, order);
 exchange.sendResponseHeaders(200, response.length());
 exchange.getResponseBody().write(response.getBytes());
 });
 server.start();
 }
}

1.4 虚拟线程注意事项

// ❌ 不要在虚拟线程中使用 synchronized（会导致载体线程被固定）
synchronized (lock) {
 // 这会阻止虚拟线程从载体线程上卸载
 doBlockingIO();
}

// ✅ 使用 ReentrantLock 替代
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
 doBlockingIO();
} finally {
 lock.unlock();
}

// ❌ 不要池化虚拟线程
// 虚拟线程的设计就是"用完即弃"，不需要池化
ExecutorService pool = Executors.newFixedThreadPool(100); // 不要这样做

// ✅ 正确用法
ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();

2. Pattern Matching for Switch

Java 21 正式特性。让 switch 支持类型模式匹配和解构。

2.1 类型模式匹配

// 传统写法
static String format(Object obj) {
 if (obj instanceof Integer i) {
 return String.format("int %d", i);
 } else if (obj instanceof Long l) {
 return String.format("long %d", l);
 } else if (obj instanceof Double d) {
 return String.format("double %f", d);
 } else if (obj instanceof String s) {
 return String.format("String %s", s);
 } else {
 return obj.toString();
 }
}

// Pattern Matching for Switch
static String format(Object obj) {
 return switch (obj) {
 case Integer i -> String.format("int %d", i);
 case Long l -> String.format("long %d", l);
 case Double d -> String.format("double %f", d);
 case String s -> String.format("String %s", s);
 case null -> "null";
 default -> obj.toString();
 };
}

2.2 Guarded Patterns（守卫模式）

static String classify(Object obj) {
 return switch (obj) {
 case String s && s.length() > 10 -> "长字符串: " + s.substring(0, 10) + "...";
 case String s && s.isEmpty() -> "空字符串";
 case String s -> "字符串: " + s;
 case Integer i && i > 0 -> "正整数: " + i;
 case Integer i && i < 0 -> "负整数: " + i;
 case Integer i -> "零";
 case null -> "null";
 default -> "其他: " + obj;
 };
}

2.3 配合 Sealed Classes

public sealed interface Shape permits Circle, Rectangle, Triangle {}
public record Circle(double radius) implements Shape {}
public record Rectangle(double w, double h) implements Shape {}
public record Triangle(double a, double b, double c) implements Shape {}

static double area(Shape shape) {
 return switch (shape) {
 case Circle c -> Math.PI * c.radius() * c.radius();
 case Rectangle r -> r.w() * r.h();
 case Triangle t -> {
 double s = (t.a() + t.b() + t.c()) / 2;
 yield Math.sqrt(s * (s - t.a()) * (s - t.b()) * (s - t.c()));
 }
 // 不需要 default！编译器知道已经穷举
 };
}

3. Record Patterns（记录模式）

Java 21 正式特性。对 Record 进行解构匹配。

public record Point(int x, int y) {}
public record Line(Point start, Point end) {}
public record Triangle(Point a, Point b, Point c) {}

// Record 解构模式
static double length(Line line) {
 return switch (line) {
 case Line(Point(int x1, int y1), Point(int x2, int y2)) ->
 Math.sqrt(Math.pow(x2 - x1, 2) + Math.pow(y2 - y1, 2));
 };
}

// 嵌套解构
static String describe(Object obj) {
 return switch (obj) {
 case Line(Point(var x1, var y1), Point(var x2, var y2)) ->
 "线段从 (%d,%d) 到 (%d,%d)".formatted(x1, y1, x2, y2);
 case Point(var x, var y) ->
 "点 (%d, %d)".formatted(x, y);
 default -> "未知形状";
 };
}

// 在 if 中使用
if (obj instanceof Line(Point(int x1, int y1), Point(int x2, int y2))) {
 System.out.printf("从 (%d,%d) 到 (%d,%d)%n", x1, y1, x2, y2);
}

4. Sequenced Collections（有序集合）

Java 21 引入了 SequencedCollection 接口，统一了有序集合的操作。

// 新接口层次
// SequencedCollection<E> extends Collection<E>
// - SequencedSet<E> extends Set<E>, SequencedCollection<E>
// - SequencedMap<K,V> extends Map<K,V>

// SequencedCollection 新方法
List<String> list = new ArrayList<>(List.of("a", "b", "c"));

list.getFirst(); // "a" — 获取第一个元素
list.getLast(); // "c" — 获取最后一个元素
list.addFirst("z"); // [z, a, b, c]
list.addLast("d"); // [z, a, b, c, d]
list.reversed(); // [d, c, b, a, z] — 返回反转视图

// SequencedMap 新方法
LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
map.put("first", 1);
map.put("second", 2);
map.put("third", 3);

map.firstEntry(); // first=1
map.lastEntry(); // third=3
map.pollFirstEntry(); // 移除并返回 first=1
map.pollLastEntry(); // 移除并返回 third=3
map.putFirst("zero", 0); // 在最前面插入
map.putLast("four", 4); // 在最后面插入
map.reversed(); // 返回反转视图

// 适用类型
// ArrayList, LinkedList, ArrayDeque → SequencedCollection
// LinkedHashSet, TreeSet → SequencedSet
// LinkedHashMap, TreeMap → SequencedMap

5. Unnamed Patterns and Variables（未命名模式和变量）

Java 21 正式特性。用 _ 忽略不需要的变量。

// 未命名变量
if (obj instanceof Point(int x, int _)) {
 // 只关心 x，不关心 y
 System.out.println("x = " + x);
}

// 在 switch 中使用
switch (obj) {
 case Point(int x, _) -> System.out.println("x = " + x);
 case Line(_, Point(int x, _)) -> System.out.println("终点 x = " + x);
 default -> {}
}

// 在 lambda 中使用（忽略不需要的参数）
map.forEach((key, _) -> System.out.println(key)); // 不关心 value

// try-with-resources（资源需实现 AutoCloseable，这里忽略其引用）
try (var _ = acquireResource()) {
 // 不需要引用资源变量
}

// for 循环
for (var _ : range) {
 doSomething(); // 不需要迭代变量
}

6. String Templates（字符串模板）

预览特性。类似其他语言的字符串插值。

// STR 处理器（自动处理转义和格式化）
String name = "Alice";
int age = 30;
String message = STR."Hello, \{name}! You are \{age} years old.";
// "Hello, Alice! You are 30 years old."

// 嵌入表达式
String result = STR."The result is \{2 * 3 + 1}.";
// "The result is 7."

// 方法调用
String upper = STR."Name: \{name.toUpperCase()}";

// 多行
String html = STR."""
 <div class="user">
 <h1>\{name}</h1>
 <p>Age: \{age}</p>
 </div>
 """;

// RAW 处理器（不转义）
String raw = RAW."<script>alert('hello')</script>";

// FMT 处理器（支持格式化）
String formatted = FMT."%.2f\{3.14159}"; // "3.14"

7. Scoped Values（作用域值）

Java 21 预览特性。替代 ThreadLocal 的更安全方案。

// ThreadLocal 的问题：需要手动清理，容易内存泄漏
// Scoped Values：自动随作用域结束而清理

// 定义
private static final ScopedValue<User> CURRENT_USER = ScopedValue.newInstance();

// 使用
ScopedValue.where(CURRENT_USER, user).run(() -> {
 // 在这个作用域内可以访问 CURRENT_USER
 processRequest();
 handleOrder();
});

// 读取
void processRequest() {
 User user = CURRENT_USER.get(); // 获取当前用户
 // ...
}

8. Structured Concurrency（结构化并发）

Java 21 预览特性。将多线程任务组织为结构化的任务树。

// 传统方式：手动管理多个 Future
Future<User> userFuture = executor.submit(() -> fetchUser(id));
Future<Order> orderFuture = executor.submit(() -> fetchOrder(id));
User user = userFuture.get();
Order order = orderFuture.get();

// 结构化并发
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
 Subtask<User> userTask = scope.fork(() -> fetchUser(id));
 Subtask<Order> orderTask = scope.fork(() -> fetchOrder(id));

 scope.join(); // 等待所有任务完成
 scope.throwIfFailed(); // 如果有失败则抛出异常

 return new UserOrder(userTask.get(), orderTask.get());
}
// 自动关闭 scope，取消未完成的任务

// ShutdownOnSuccess：任一成功即取消其他
try (var scope = new StructuredTaskScope.ShutdownOnSuccess<String>()) {
 scope.fork(() -> queryFromDB());
 scope.fork(() -> queryFromCache());
 scope.fork(() -> queryFromAPI());

 scope.join(); // 等待所有任务完成
 return scope.result(); // 返回第一个成功的结果
}

9. Generational ZGC（分代 ZGC）

Java 21 引入分代 ZGC，性能显著提升。

# 启用分代 ZGC（Java 21 中需显式开启，默认仍为非分代；分代模式自 JDK 24 起成为默认）
java -XX:+UseZGC -XX:+ZGenerational -Xmx4g MyApp

# 特点：
# - 吞吐量提升约 25%
# - 停顿时间仍然 < 1ms
# - 内存占用更低
# - 更好的大堆支持

10. 从 Java 17 迁移到 Java 21

特性	Java 17	Java 21
Record	✅	✅
Sealed Classes	✅	✅
Pattern Matching (instanceof)	✅	✅
Pattern Matching (switch)	预览	✅ 正式
Record Patterns	❌	✅
虚拟线程	预览	✅ 正式
Sequenced Collections	❌	✅
String Templates	❌	预览
Scoped Values	❌	预览
结构化并发	❌	预览
分代 ZGC	❌	✅

总结

Java 21 的核心特性：

虚拟线程 — 革命性并发模型，百万级线程不再是梦
Pattern Matching Switch — 类型匹配 + 守卫模式 + 穷举检查
Record Patterns — Record 的解构匹配
Sequenced Collections — 统一有序集合的操作
未命名变量 — 用 _ 忽略不需要的变量
分代 ZGC — 更强的低延迟垃圾收集

如果你在用 Spring Boot 3.2+/4.x，可以直接使用 Java 21。虚拟线程是最大的卖点——对于 IO 密集型服务，性能提升非常可观。

💡 Java 25 LTS 已于 2025 年 9 月发布，新增了 Scoped Values 正式版（JEP 506）、Compact Object Headers 正式版（JEP 519）等特性；Structured Concurrency 在 Java 25 中仍为预览特性（JEP 505，第五次预览）。如果是全新项目，建议直接上 Java 25。

Java 17 新特性详解：Record、Sealed Classes、Pattern Matching 与现代 Java

Thu, 25 Jun 2026 14:30:00 +0000

前言

Java 17 于 2021 年 9 月发布，是继 Java 8 和 Java 11 之后的第三个长期支持版本（LTS）。Spring Boot 3.x 最低要求 Java 17，这使得 Java 17 成为当前企业开发的主流版本。相比 Java 8，Java 17 引入了大量语法糖和现代化改进，显著提升了开发效率。

1. Record（记录类型）

Record 是一种特殊的类，专门用于存储不可变数据，自动生成 equals()、hashCode()、toString() 和 getter。

1.1 基本用法

// 定义 Record
public record Point(int x, int y) {}

// 使用
Point p = new Point(10, 20);
System.out.println(p.x()); // 10（注意：不是 getX()）
System.out.println(p.y()); // 20
System.out.println(p); // Point[x=10, y=20]

// 自动实现
p.equals(new Point(10, 20)) // true
p.hashCode() // 基于 x, y 计算

1.2 自定义方法和构造器

public record Point(int x, int y) {
 // 紧凑构造器（验证参数）
 public Point {
 if (x < 0 || y < 0) {
 throw new IllegalArgumentException("坐标不能为负数");
 }
 }

 // 自定义方法
 public double distanceTo(Point other) {
 return Math.sqrt(Math.pow(this.x - other.x, 2) + Math.pow(this.y - other.y, 2));
 }

 // 静态方法
 public static Point origin() {
 return new Point(0, 0);
 }
}

Point p1 = new Point(3, 4);
Point p2 = new Point(6, 8);
System.out.println(p1.distanceTo(p2)); // 5.0

1.3 实战场景

// DTO / VO
public record UserDTO(String name, String email, int age) {}

// API 响应
public record ApiResponse<T>(int code, String message, T data) {
 public static <T> ApiResponse<T> success(T data) {
 return new ApiResponse<>(200, "OK", data);
 }
 public static <T> ApiResponse<T> error(String message) {
 return new ApiResponse<>(500, message, null);
 }
}

// Map 的 Entry
public record KeyValue<K, V>(K key, V value) implements Map.Entry<K, V> {
 @Override
 public V setValue(V value) {
 throw new UnsupportedOperationException();
 }
}

2. Sealed Classes（密封类）

密封类限制哪些类可以继承或实现它，提供更精确的类型控制。

2.1 基本用法

// 定义密封类
public sealed class Shape permits Circle, Rectangle, Triangle {
 // 公共方法
}

// 子类必须是 final、sealed 或 non-sealed
public final class Circle extends Shape {
 double radius;
}

public final class Rectangle extends Shape {
 double width, height;
}

public non-sealed class Triangle extends Shape {
 double a, b, c;
 // non-sealed 允许任意类继承
}

2.2 与 Record 结合

// 配合 Record 实现代数数据类型（ADT）
public sealed interface Expression
 permits Number, Add, Multiply, Negate {
}

public record Number(double value) implements Expression {}
public record Add(Expression left, Expression right) implements Expression {}
public record Multiply(Expression left, Expression right) implements Expression {}
public record Negate(Expression operand) implements Expression {}

2.3 与 Pattern Matching 结合

// 模式匹配 + sealed = 穷举检查
public static double evaluate(Expression expr) {
 return switch (expr) {
 case Number n -> n.value();
 case Add a -> evaluate(a.left()) + evaluate(a.right());
 case Multiply m -> evaluate(m.left()) * evaluate(m.right());
 case Negate n -> -evaluate(n.operand());
 // 不需要 default，编译器知道已穷举所有子类
 };
}

3. Pattern Matching for instanceof

Java 14 引入、Java 16 转正。在 instanceof 判断的同时完成类型转换。

// 传统写法
if (obj instanceof String) {
 String s = (String) obj;
 System.out.println(s.length());
}

// Java 16+ 写法
if (obj instanceof String s) {
 System.out.println(s.length()); // s 已经是 String 类型
}

// 可以在条件中直接使用变量
if (obj instanceof String s && s.length() > 5) {
 System.out.println(s.toUpperCase());
}

// 在 equals 中的典型应用
@Override
public boolean equals(Object obj) {
 return this == obj
 || (obj instanceof Point p && this.x == p.x && this.y == p.y);
}

4. Text Blocks（文本块）

Java 15 转正。多行字符串不再需要转义和拼接。

// 传统写法
String json = "{\n" +
 " \"name\": \"Alice\",\n" +
 " \"age\": 30\n" +
 "}";

// Text Block 写法
String json = """
 {
 "name": "Alice",
 "age": 30
 }
 """;

// SQL
String sql = """
 SELECT u.name, u.email, o.total
 FROM users u
 JOIN orders o ON u.id = o.user_id
 WHERE u.status = 'ACTIVE'
 ORDER BY o.created_at DESC
 """;

// HTML
String html = """
 <html>
 <body>
 <h1>Hello, World!</h1>
 </body>
 </html>
 """;

// 支持格式化占位符
String greeting = """
 Hello, %s!
 Welcome to %s.
 """.formatted("Alice", "Java 17");

// 行尾空格处理
String text = """
 Line 1 \s
 Line 2 \s
 """;

5. Switch 表达式

Java 14 转正。Switch 不仅是语句，还可以是表达式。

// 传统写法
String result;
switch (day) {
 case MONDAY:
 case FRIDAY:
 case SUNDAY:
 result = "好好工作";
 break;
 case TUESDAY:
 result = "继续努力";
 break;
 default:
 result = "未知";
 break;
}

// Switch 表达式
String result = switch (day) {
 case MONDAY, FRIDAY, SUNDAY -> "好好工作";
 case TUESDAY -> "继续努力";
 case WEDNESDAY, THURSDAY -> "快到周末了";
 case SATURDAY -> "休息日";
};

// yield 返回值（多行时使用）
int numLetters = switch (day) {
 case MONDAY, FRIDAY, SUNDAY -> {
 System.out.println("工作日");
 yield 6;
 }
 case TUESDAY -> {
 System.out.println("又是工作日");
 yield 7;
 }
 default -> {
 String s = day.toString();
 yield s.length();
 }
};

// 穷举检查（配合 enum 或 sealed class）
// 不需要 default，编译器会检查是否覆盖所有情况

6. 新的 HttpClient API

Java 11 引入、Java 15 完善。替代老旧的 HttpURLConnection。

HttpClient client = HttpClient.newBuilder()
 .connectTimeout(Duration.ofSeconds(10))
 .build();

// GET 请求
HttpRequest request = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/users"))
 .header("Accept", "application/json")
 .GET()
 .build();

// 同步
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.statusCode());
System.out.println(response.body());

// 异步
client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
 .thenApply(HttpResponse::body)
 .thenAccept(System.out::println)
 .join();

// POST JSON
HttpRequest postRequest = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/users"))
 .header("Content-Type", "application/json")
 .POST(HttpRequest.BodyPublishers.ofString("""
 {"name": "Alice", "age": 30}
 """))
 .build();

// POST 文件
HttpRequest fileRequest = HttpRequest.newBuilder()
 .uri(URI.create("https://api.example.com/upload"))
 .POST(HttpRequest.BodyPublishers.ofFile(Path.of("file.txt")))
 .build();

7. 其他重要特性

7.1 instanceof 模式的反模式

// 不推荐：多余的变量作用域
if (obj instanceof String s) {
 // s 可用
} else {
 // s 不可用
 // 如果在 else 中使用 s 会编译错误
}

// 推荐：在最窄的作用域中使用

7.2 NullPointerException 增强消息

# Java 14+ 增强了 NPE 的错误信息
# 之前: Cannot invoke method on null
# 之后: Cannot invoke "String.length()" because the return value of "User.getName()" is null

# 启用（默认开启）
-XX:+ShowCodeDetailsInExceptionMessages

7.3 强封装 JDK 内部 API

// Java 17 默认禁止反射访问 JDK 内部 API
// 如果必须使用，需要添加 JVM 参数：
// --add-opens java.base/java.lang=ALL-UNNAMED
// --add-opens java.base/sun.nio.ch=ALL-UNNAMED

7.4 新的随机数生成器 API

// Java 17 引入了 RandomGenerator 接口
RandomGenerator generator = RandomGeneratorFactory.of("L128X1024MixRandom").create();
int random = generator.nextInt(100);

// 获取所有可用算法
RandomGeneratorFactory.all()
 .map(f -> f.name() + " (" + f.group() + ")")
 .forEach(System.out::println);

7.5 ZGC（生产就绪）

# Java 15 转正的低延迟垃圾收集器
java -XX:+UseZGC -Xmx4g MyApp

# 特点：
# - 停顿时间 < 1ms（不随堆大小增长）
# - 支持 TB 级堆
# - 吞吐量下降不超过 15%

7.6 Shenandoah GC（生产就绪）

# Java 15 转正
java -XX:+UseShenandoahGC -Xmx4g MyApp

# 特点：
# - 与 ZGC 类似的低延迟
# - 更早进入生产就绪状态
# - 适合对延迟敏感的应用

8. 从 Java 8 迁移到 Java 17

8.1 主要变化清单

变化	说明
删除 `--release 8` 兼容性	确保代码不使用已删除的 API
删除 `javax.*` 包	部分迁移到 `jakarta.*`（EE 相关）
强封装内部 API	`sun.misc.*` 等不再可直接访问
Nashorn 移除	Java 15 移除了 JavaScript 引擎
安全管理器弃用	`SecurityManager` 将在未来版本移除

8.2 迁移检查清单

# 1. 编译检查
javac --release 17 YourClass.java

# 2. 检查对 JDK 内部 API 的非法访问（如有反射访问内部 API，运行时会报警告或异常）
# 注意：--illegal-access 选项自 JDK 17 起已失效（JEP 403 强封装），改用下列方式按需开放
java --add-opens java.base/java.lang=ALL-UNNAMED -jar app.jar

# 3. 依赖检查
# Spring Boot 3.x 需要 Java 17
# 检查所有第三方库是否支持 Java 17

# 4. JVM 参数调整
# 移除已废弃的 GC 参数
# 更新反射访问参数

8.3 Spring Boot 3.x 迁移

<!-- pom.xml -->
<properties>
 <java.version>17</java.version>
</properties>

<!-- jakarta 命名空间迁移 -->
<!-- javax.servlet.* → jakarta.servlet.* -->
<!-- javax.persistence.* → jakarta.persistence.* -->

9. 版本对比

特性	Java 8	Java 17
Lambda/Stream	✅	✅
Optional	✅	✅
新日期 API	✅	✅
Record	❌	✅
Sealed Classes	❌	✅
Pattern Matching	❌	✅
Text Blocks	❌	✅
Switch 表达式	❌	✅
新 HttpClient	❌	✅
ZGC/Shenandoah	❌	✅ (生产就绪)
LTS 支持截止	Extended 2030 年	Premier 2026.9，Extended 2029.9

总结

Java 17 的核心特性：

Record — 不可变数据类的简洁声明，自动生成样板代码
Sealed Classes — 限制类的继承层次，配合 switch 实现穷举检查
Pattern Matching — instanceof + 类型转换一步到位
Text Blocks — 多行字符串不再痛苦
Switch 表达式 — 更简洁、更安全的 switch
新 HttpClient — 现代化的 HTTP 客户端
ZGC/Shenandoah — 低延迟垃圾收集器正式可用

如果你的项目还在 Java 8，现在是升级到 Java 17 的好时机。Spring Boot 3.x/4.x、Spring Cloud 2022+ 都要求 Java 17 最低版本。

⚠️ 注意：Java 17 Premier Support 将于 2026 年 9 月 到期，建议新项目直接使用 Java 21 或 Java 25 LTS。

Java 8 新特性详解：Lambda、Stream、Optional 与函数式编程

Thu, 25 Jun 2026 14:00:00 +0000

前言

Java 8 是 Java 发展史上最重要的版本之一，于 2014 年 3 月发布。它引入了函数式编程思想，彻底改变了 Java 的编码风格。至今仍有大量项目运行在 Java 8 上，掌握其特性是 Java 开发者的基本功。

1. Lambda 表达式

Lambda 是 Java 8 最核心的特性，让代码更简洁、更具表达力。

1.1 基本语法

// 语法: (参数列表) -> { 方法体 }

// 无参数
Runnable r = () -> System.out.println("Hello Lambda");

// 单个参数（可省略括号）
Consumer<String> print = s -> System.out.println(s);

// 多个参数
Comparator<String> comp = (a, b) -> a.length() - b.length();

// 多行方法体
BinaryOperator<Integer> add = (a, b) -> {
 int result = a + b;
 return result;
};

1.2 Lambda 与匿名内部类对比

// 之前：匿名内部类
List<String> list = Arrays.asList("c", "a", "b");
Collections.sort(list, new Comparator<String>() {
 @Override
 public int compare(String a, String b) {
 return a.compareTo(b);
 }
});

// 之后：Lambda
Collections.sort(list, (a, b) -> a.compareTo(b));
// 更简洁
Collections.sort(list, String::compareTo);

1.3 变量捕获

int num = 10; // effectively final
Runnable r = () -> System.out.println(num); // OK
// num = 20; // 编译错误，Lambda 要求变量为 final 或 effectively final

2. 函数式接口

函数式接口是只有一个抽象方法的接口，是 Lambda 的基础。

2.1 内置函数式接口

接口	方法	用途	示例
`Predicate<T>`	`boolean test(T t)`	条件判断	`s -> s.length() > 5`
`Function<T,R>`	`R apply(T t)`	类型转换	`s -> s.length()`
`Consumer<T>`	`void accept(T t)`	消费数据	`s -> System.out.println(s)`
`Supplier<T>`	`T get()`	生产数据	`() -> new ArrayList<>()`
`BiFunction<T,U,R>`	`R apply(T t, U u)`	双参数转换	`(a, b) -> a + b`
`UnaryOperator<T>`	`T apply(T t)`	一元操作	`s -> s.toUpperCase()`
`BinaryOperator<T>`	`T apply(T a, T b)`	二元操作	`(a, b) -> a + b`

2.2 自定义函数式接口

@FunctionalInterface
interface MyFunction<T, R> {
 R apply(T t);

 // 可以有默认方法
 default MyFunction<T, R> andThen(MyFunction<R, R> after) {
 return t -> after.apply(this.apply(t));
 }
}

// 使用
MyFunction<String, Integer> toLength = String::length;
MyFunction<String, Integer> toUpper = s -> s.toUpperCase().length();
System.out.println(toLength.apply("hello")); // 5
System.out.println(toLength.andThen(toUpper).apply("hello")); // 注意：这里类型不匹配需调整

3. 方法引用

方法引用是 Lambda 的简写形式。

// 1. 静态方法引用: ClassName::staticMethod
Function<String, Integer> parseInt = Integer::parseInt;
// 等价于: s -> Integer.parseInt(s)

// 2. 实例方法引用: instance::method
String str = "Hello";
Supplier<String> upper = str::toUpperCase;
// 等价于: () -> str.toUpperCase()

// 3. 对象方法引用: ClassName::method
Function<String, Integer> length = String::length;
// 等价于: s -> s.length()

// 4. 构造方法引用: ClassName::new
Supplier<ArrayList<String>> listFactory = ArrayList::new;
Function<Integer, ArrayList<String>> listWithCap = ArrayList::new;
// 等价于: n -> new ArrayList<>(n)

4. Stream API

Stream 是 Java 8 处理集合的核心 API，支持链式操作、惰性求值和并行处理。

4.1 创建 Stream

// 从集合创建
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream = list.stream();

// 从数组创建
String[] arr = {"a", "b", "c"};
Stream<String> stream2 = Arrays.stream(arr);

// 直接创建
Stream<String> stream3 = Stream.of("a", "b", "c");

// 生成无限流
Stream<Integer> infinite = Stream.iterate(0, n -> n + 1);
Stream<Double> random = Stream.generate(Math::random);

// 范围流
IntStream range = IntStream.range(1, 10); // 1-9
IntStream rangeClosed = IntStream.rangeClosed(1, 10); // 1-10

// 文件流
Stream<String> lines = Files.lines(Paths.get("file.txt"));

4.2 中间操作（惰性）

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

// filter - 过滤
names.stream().filter(s -> s.length() > 3);

// map - 映射转换
names.stream().map(String::toUpperCase);
names.stream().map(String::length);

// flatMap - 扁平化映射
List<List<Integer>> nested = Arrays.asList(
 Arrays.asList(1, 2, 3),
 Arrays.asList(4, 5, 6)
);
nested.stream().flatMap(Collection::stream);
// 结果: 1, 2, 3, 4, 5, 6

// sorted - 排序
names.stream().sorted();
names.stream().sorted(Comparator.comparing(String::length).reversed());

// distinct - 去重
Stream.of(1, 2, 2, 3, 3).distinct(); // 1, 2, 3

// limit / skip - 截取
names.stream().limit(3); // 前3个
names.stream().skip(2); // 跳过前2个

// peek - 查看（调试用）
names.stream()
 .peek(s -> System.out.println("Before: " + s))
 .map(String::toUpperCase)
 .peek(s -> System.out.println("After: " + s))
 .collect(Collectors.toList());

4.3 终端操作

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

// collect - 收集
List<String> result = names.stream()
 .filter(s -> s.length() > 3)
 .collect(Collectors.toList());

Set<String> set = names.stream().collect(Collectors.toSet());

String joined = names.stream().collect(Collectors.joining(", "));
// "Alice, Bob, Charlie, David"

// reduce - 归约
int sum = IntStream.rangeClosed(1, 100).reduce(0, Integer::sum);
// 5050

Optional<String> longest = names.stream()
 .reduce((a, b) -> a.length() >= b.length() ? a : b);

// count / min / max
long count = names.stream().filter(s -> s.startsWith("A")).count();
Optional<String> min = names.stream().min(String::compareTo);
Optional<String> max = names.stream().max(Comparator.comparing(String::length));

// forEach
names.stream().forEach(System.out::println);

// toArray
String[] array = names.stream().toArray(String[]::new);

// 匹配操作
boolean anyStartsWithA = names.stream().anyMatch(s -> s.startsWith("A"));
boolean allLongerThan3 = names.stream().allMatch(s -> s.length() > 3);
boolean noneStartsWithZ = names.stream().noneMatch(s -> s.startsWith("Z"));

// find
Optional<String> first = names.stream().filter(s -> s.length() > 3).findFirst();
Optional<String> any = names.stream().filter(s -> s.length() > 3).findAny();

4.4 Collectors 高级用法

List<Employee> employees = getEmployees();

// 分组
Map<String, List<Employee>> byDept = employees.stream()
 .collect(Collectors.groupingBy(Employee::getDepartment));

// 分组计数
Map<String, Long> countByDept = employees.stream()
 .collect(Collectors.groupingBy(Employee::getDepartment, Collectors.counting()));

// 分组求和
Map<String, Double> salaryByDept = employees.stream()
 .collect(Collectors.groupingBy(
 Employee::getDepartment,
 Collectors.summingDouble(Employee::getSalary)
 ));

// 分区（按条件分为两组）
Map<Boolean, List<Employee>> partitioned = employees.stream()
 .collect(Collectors.partitioningBy(e -> e.getSalary() > 10000));

// 统计
DoubleSummaryStatistics stats = employees.stream()
 .collect(Collectors.summarizingDouble(Employee::getSalary));
// stats.getCount(), stats.getSum(), stats.getAverage(), stats.getMax(), stats.getMin()

// toMap
Map<String, Double> salaryMap = employees.stream()
 .collect(Collectors.toMap(Employee::getName, Employee::getSalary));

// 有重复 key 时的处理
Map<String, Double> salaryMap2 = employees.stream()
 .collect(Collectors.toMap(Employee::getDepartment, Employee::getSalary, Double::sum));

4.5 并行流

// 串行转并行
long count = list.parallelStream()
 .filter(s -> s.length() > 3)
 .count();

// 或者
long count2 = list.stream()
 .parallel()
 .filter(s -> s.length() > 3)
 .count();

// 注意：并行流使用 ForkJoinPool，不适合 IO 密集型任务
// 数据量小时串行更快，并行有线程切换开销

5. Optional

Optional 用于优雅地处理可能为 null 的值，避免 NullPointerException。

5.1 创建 Optional

Optional<String> empty = Optional.empty();
Optional<String> opt = Optional.of("hello"); // 不能传 null
Optional<String> nullable = Optional.ofNullable(null); // 可以传 null

5.2 常用方法

Optional<String> opt = Optional.ofNullable(getName());

// isPresent / isEmpty
if (opt.isPresent()) {
 System.out.println(opt.get());
}

// ifPresent - 值存在时执行
opt.ifPresent(name -> System.out.println(name));
// 注意：ifPresentOrElse 是 Java 9 新增方法，Java 8 不可用
// Java 9+ 写法：
// opt.ifPresentOrElse(
// name -> System.out.println("Name: " + name),
// () -> System.out.println("Name is null")
// );

// orElse - 提供默认值
String name = opt.orElse("Unknown");
String name2 = opt.orElseGet(() -> computeDefault()); // 惰性求值
String name3 = opt.orElseThrow(() -> new RuntimeException("Name not found"));

// map / flatMap - 链式转换
Optional<Integer> length = opt.map(String::length);
Optional<String> upper = opt.map(String::toUpperCase);

// filter - 条件过滤
Optional<String> filtered = opt.filter(s -> s.length() > 3);

5.3 实战链式调用

// 传统写法
public String getUserCity(User user) {
 if (user != null) {
 Address addr = user.getAddress();
 if (addr != null) {
 String city = addr.getCity();
 if (city != null) {
 return city.toUpperCase();
 }
 }
 }
 return "UNKNOWN";
}

// Optional 写法
public String getUserCity(User user) {
 return Optional.ofNullable(user)
 .map(User::getAddress)
 .map(Address::getCity)
 .map(String::toUpperCase)
 .orElse("UNKNOWN");
}

6. 新的日期时间 API

Java 8 引入了 java.time 包，彻底解决了旧日期 API 的线程安全和设计缺陷。

// LocalDate - 只有日期
LocalDate today = LocalDate.now();
LocalDate birthday = LocalDate.of(1990, 6, 15);
LocalDate parsed = LocalDate.parse("2025-01-01");
int year = today.getYear();
int month = today.getMonthValue();
LocalDate nextWeek = today.plusWeeks(1);
LocalDate lastMonth = today.minusMonths(1);
boolean isBefore = today.isBefore(birthday);

// LocalTime - 只有时间
LocalTime now = LocalTime.now();
LocalTime time = LocalTime.of(14, 30, 0);
LocalTime later = now.plusHours(2);

// LocalDateTime - 日期 + 时间
LocalDateTime dateTime = LocalDateTime.now();
LocalDateTime specific = LocalDateTime.of(2025, 1, 1, 12, 0);

// ZonedDateTime - 带时区
ZonedDateTime zoned = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));

// Instant - 时间戳（UTC）
Instant instant = Instant.now();
long epochSecond = instant.getEpochSecond();
long epochMilli = instant.toEpochMilli();

// Duration - 时间段（秒/纳秒）
Duration duration = Duration.between(startTime, endTime);
Duration twoHours = Duration.ofHours(2);
long seconds = duration.getSeconds();

// Period - 日期段（年/月/日）
Period period = Period.between(startDate, endDate);
Period threeMonths = Period.ofMonths(3);
int days = period.getDays();

// 格式化
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = dateTime.format(formatter);
LocalDateTime parsed2 = LocalDateTime.parse("2025-01-01 12:00:00", formatter);

7. CompletableFuture

异步编程利器，支持链式调用和组合。

// 创建异步任务
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 // 耗时操作
 return fetchDataFromDB();
});

// 链式处理
CompletableFuture<Integer> result = CompletableFuture
 .supplyAsync(() -> "Hello")
 .thenApply(s -> s + " World") // 同步转换
 .thenApply(String::length); // 同步转换

// 异步处理
CompletableFuture<Void> future2 = CompletableFuture
 .supplyAsync(() -> fetchData())
 .thenAcceptAsync(data -> saveToDB(data)); // 异步消费

// 组合多个异步任务
CompletableFuture<String> userFuture = CompletableFuture.supplyAsync(() -> getUser());
CompletableFuture<String> orderFuture = CompletableFuture.supplyAsync(() -> getOrder());

CompletableFuture<String> combined = userFuture.thenCombine(orderFuture,
 (user, order) -> user + " - " + order);

// 等待所有完成
CompletableFuture.allOf(future1, future2, future3).join();

// 任一完成
CompletableFuture.anyOf(future1, future2, future3).join();

// 异常处理
CompletableFuture<String> safe = CompletableFuture
 .supplyAsync(() -> riskyOperation())
 .exceptionally(ex -> "Default Value")
 .handle((result, ex) -> ex != null ? "Error" : result);

8. 其他新特性

8.1 接口默认方法和静态方法

public interface Vehicle {
 // 抽象方法
 void start();

 // 默认方法（有实现）
 default void honk() {
 System.out.println("Beep!");
 }

 // 静态方法
 static boolean isMotorized(Vehicle v) {
 return true;
 }
}

8.2 重复注解

@Repeatable(Schedules.class)
@interface Schedule {
 String time();
}

@interface Schedules {
 Schedule[] value();
}

@Schedule(time = "08:00")
@Schedule(time = "12:00")
@Schedule(time = "18:00")
public void doSomething() { }

8.3 Base64 编解码

// 基本编码
String encoded = Base64.getEncoder().encodeToString("Hello".getBytes());
byte[] decoded = Base64.getDecoder().decode(encoded);

// URL 安全编码
String urlSafe = Base64.getUrlEncoder().encodeToString(data);

// MIME 编码
String mime = Base64.getMimeEncoder().encodeToString(data);

9. 版本选择建议

场景	建议
老项目维护	继续使用 Java 8，Extended Support 到 2030 年（Oracle JDK 需订阅）
新项目启动	建议直接使用 Java 21 或 25（均为 LTS）
Spring Boot 4.x	最低要求 Java 17，推荐 Java 21+
学习 Lambda/Stream	Java 8 特性是最基础的，必须掌握

💡 LTS 版本线：Java 8 → 11 → 17 → 21 → 25（2025 年 9 月发布）→ 29（2027 年 9 月）

总结

Java 8 的核心特性：

Lambda 表达式 — 简化匿名内部类，函数式编程的基础
函数式接口 — Predicate/Function/Consumer/Supplier 四大金刚
方法引用 — Lambda 的简写形式
Stream API — 集合操作的声明式编程，支持并行处理
Optional — 优雅处理空值，避免 NPE
新日期时间 API — 线程安全、设计合理的 java.time 包
CompletableFuture — 异步编程的链式调用

这些特性至今仍是 Java 开发的核心基础，无论使用哪个 JDK 版本都必须熟练掌握。

2025 Java MySQL 面试高频题汇总

Thu, 25 Jun 2026 10:05:00 +0000

前言

本文整理了 2025 年 Java 后端开发面试中 MySQL 相关的高频考点，涵盖索引优化、事务隔离、锁机制、SQL 调优等核心内容，帮助候选人系统复习、高效备战。

一、MySQL 索引相关

1.1 为什么 MySQL 使用 B+ 树而不是 B 树？

B+ 树叶子节点形成有序链表，范围查询效率更高
非叶子节点只存储索引，单个页能容纳更多索引，树高更矮，IO 次数更少
所有查询都落到叶子节点，查询性能稳定

1.2 聚簇索引和非聚簇索引的区别？

特性	聚簇索引	非聚簇索引（二级索引）
数据存储	叶子节点存储完整数据行	叶子节点存储主键值
查询方式	直接获取数据	需要回表查询
数量限制	一张表只有一个	可以有多个

1.3 什么是覆盖索引？

覆盖索引是指查询的列全部在索引中，不需要回表查询主键索引就能获取数据，显著提升查询性能。

-- 假设有联合索引 idx_name_age(name, age)
SELECT name, age FROM user WHERE name = '张三';
-- 此查询走覆盖索引，无需回表

1.4 索引失效的常见场景

使用 LIKE '%xxx' 左模糊查询
对索引列使用函数或表达式
隐式类型转换
使用 OR 连接非索引列
联合索引未遵循最左前缀原则
NOT IN、NOT EXISTS、!=、<> 可能导致失效

二、事务与隔离级别

2.1 事务的 ACID 特性

A（原子性）：undo log 实现，事务要么全部成功，要么全部回滚
C（一致性）：由其他三个特性共同保证
I（隔离性）：锁机制 + MVCC 实现
D（持久性）：redo log 实现

2.2 四种隔离级别

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	✓	✓	✓
READ COMMITTED	✗	✓	✓
REPEATABLE READ（默认）	✗	✗	✗*
SERIALIZABLE	✗	✗	✗

InnoDB 在 RR 级别下通过 MVCC + Next-Key Lock 解决了大部分幻读问题。

2.3 MVCC 实现原理

MVCC（多版本并发控制）通过以下机制实现：

隐藏列：每行数据包含 DB_TRX_ID（事务ID）、DB_ROLL_PTR（回滚指针）
undo log：形成版本链
Read View：根据事务启动时机判断可见性

RC 与 RR 的区别：RC 每次查询生成新的 Read View，RR 只在事务第一次查询时生成。

三、锁机制

3.1 InnoDB 锁类型

共享锁（S Lock）：读锁，多个事务可共享
排他锁（X Lock）：写锁，互斥
意向锁（IS/IX）：表级锁，标识事务意图
间隙锁（Gap Lock）：锁定索引间隙，防止幻读
临键锁（Next-Key Lock）：记录锁 + 间隙锁，左开右闭区间

3.2 死锁如何产生和解决？

产生条件：两个或多个事务互相等待对方持有的锁。

排查方法：

SHOW ENGINE INNODB STATUS; -- 查看最近死锁信息
SELECT * FROM information_schema.INNODB_TRX; -- 查看当前事务

解决方案：

按固定顺序访问表和行
大事务拆小事务
设置合理的锁等待超时 innodb_lock_wait_timeout
使用低隔离级别（业务允许时）

四、SQL 优化

4.1 EXPLAIN 执行计划关键字段

EXPLAIN SELECT * FROM user WHERE name = '张三';

重点关注字段：

type：访问类型，性能从好到差 system > const > eq_ref > ref > range > index > ALL
key：实际使用的索引
rows：预估扫描行数
Extra：Using index（覆盖索引）、Using filesort（文件排序）、Using temporary（临时表）

4.2 慢查询优化思路

开启慢查询日志定位问题 SQL
使用 EXPLAIN 分析执行计划
合理添加索引（遵循最左前缀原则）
避免 SELECT *，只查询需要的列
分页优化：深分页使用延迟关联

-- 深分页优化：先查主键再关联
SELECT * FROM user u
INNER JOIN (
 SELECT id FROM user ORDER BY id LIMIT 1000000, 10
) t ON u.id = t.id;

4.3 JOIN 优化

小表驱动大表
被驱动表关联字段加索引
避免 LEFT JOIN 时 ON 条件使用 OR

五、MySQL 架构

5.1 InnoDB 架构核心组件

Buffer Pool：缓存数据页和索引页
Change Buffer：缓存非唯一二级索引的写操作
Log Buffer：缓存 redo log
redo log：保证事务持久性（WAL 机制）
undo log：保证事务原子性，支持 MVCC

5.2 binlog、redo log、undo log 区别

特性	binlog	redo log	undo log
层级	Server 层	InnoDB 引擎	InnoDB 引擎
内容	逻辑日志	物理日志	逻辑日志
作用	主从复制、数据恢复	崩溃恢复	事务回滚、MVCC
写入方式	追加写入	循环写入	追加写入

5.3 两阶段提交（2PC）

为了保证 binlog 和 redo log 的一致性：

prepare 阶段：redo log 写入磁盘，标记为 prepare
commit 阶段：binlog 写入磁盘后，redo log 标记为 commit

六、高频场景题

6.1 分库分表方案

垂直分库：按业务拆分（订单库、用户库）
水平分表：按行拆分（取模、范围、时间）
常用中间件：ShardingSphere、MyCat

6.2 如何设计一个高并发的秒杀数据库方案？

热点数据缓存到 Redis
库存扣减使用 Redis 原子操作预扣
订单写入异步队列
数据库层面乐观锁更新
分库分表减少单表压力

-- 乐观锁扣减库存
UPDATE goods SET stock = stock - 1 
WHERE id = 1001 AND stock > 0;

总结

2025 年 Java MySQL 面试依然围绕 索引原理、事务隔离、锁机制、SQL 优化 四大核心主题展开。理解底层原理比死记硬背更重要，建议结合源码和实际项目经验深入学习。

推荐书籍：《高性能 MySQL》《MySQL 技术内幕：InnoDB 存储引擎》

2025 年 Java Spring 面试题精选

Fri, 01 May 2026 14:00:00 +0000

概述

本文整理了 2025 年常见的 Java Spring 面试题，涵盖 Spring Core、Spring Boot、Spring MVC、Spring Cloud 等核心知识点，帮助开发者系统备战面试。

一、Spring Core

1. 什么是 IoC（控制反转）？

IoC 是一种设计思想，将对象的创建和依赖管理交给 Spring 容器，而不是由开发者手动 new 对象。Spring 通过依赖注入（DI）实现 IoC，降低了代码耦合度。

2. Spring Bean 的作用域有哪些？

作用域	说明
`singleton`	默认，整个容器中只有一个实例
`prototype`	每次请求创建一个新的实例
`request`	每次 HTTP 请求创建一个实例（Web 应用）
`session`	每个 HTTP Session 创建一个实例
`application`	每个 ServletContext 创建一个实例

3. @Autowired 和 @Resource 的区别？

@Autowired：Spring 注解，默认按类型注入，可配合 @Qualifier 按名称注入
@Resource：JSR-250 注解，默认按名称注入，找不到再按类型注入

4. Spring Bean 的生命周期？

实例化 Bean
属性注入（依赖注入）
调用 BeanNameAware、BeanFactoryAware 等接口
调用 BeanPostProcessor#postProcessBeforeInitialization
调用 @PostConstruct / InitializingBean#afterPropertiesSet / init-method
调用 BeanPostProcessor#postProcessAfterInitialization
Bean 就绪，可使用
调用 @PreDestroy / DisposableBean#destroy / destroy-method

二、Spring Boot

5. Spring Boot 的核心优势？

自动配置：根据引入的依赖自动配置 Bean
起步依赖：简化 Maven/Gradle 依赖管理
内嵌服务器：无需外部 Tomcat，直接 java -jar 运行
Actuator：提供生产级监控端点

6. @SpringBootApplication 注解的作用？

@SpringBootApplication 是组合注解，包含：

@SpringBootConfiguration：标记为配置类
@EnableAutoConfiguration：启用自动配置
@ComponentScan：扫描当前包及子包的组件

7. Spring Boot 自动配置原理？

核心是 @EnableAutoConfiguration 注解，通过 SpringFactoriesLoader 加载 META-INF/spring.factories（Spring Boot 3.x 改为 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports）中定义的自动配置类。结合 @Conditional 系列注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）按条件决定是否生效。

8. 如何自定义 Starter？

创建 xxx-spring-boot-autoconfigure 模块，编写自动配置类
创建 xxx-spring-boot-starter 模块，引入 autoconfigure 依赖
在 META-INF/spring.factories 或 AutoConfiguration.imports 中注册

三、Spring MVC

9. Spring MVC 的请求处理流程？

客户端发送请求到 DispatcherServlet
DispatcherServlet 查询 HandlerMapping 获取对应的 Handler
通过 HandlerAdapter 调用具体的 Controller 方法
Controller 处理业务，返回 ModelAndView
ViewResolver 解析视图名称
渲染视图并返回响应

10. @RestController 和 @Controller 的区别？

@Controller：返回视图名称，需要配合 @ResponseBody 返回数据
@RestController：等价于 @Controller + @ResponseBody，所有方法默认返回 JSON/XML

四、Spring Cloud

11. 常见的服务注册中心有哪些？

Nacos：阿里开源，支持配置管理和服务发现
Eureka：Netflix 开源，AP 模型（已停止维护）
Consul：HashiCorp 出品，支持健康检查
Zookeeper：CP 模型，强一致性

12. 什么是服务熔断和降级？

熔断：当下游服务异常率超过阈值时，熔断器打开，快速失败，避免雪崩
降级：熔断后的兜底策略，返回默认值或缓存数据

常用框架：Sentinel、Resilience4j、Hystrix（已停止维护）

13. Spring Cloud Gateway 核心概念？

Route（路由）：网关的基本单元
Predicate（断言）：匹配请求条件
Filter（过滤器）：对请求/响应进行处理

五、数据访问

14. Spring 事务传播行为有哪些？

传播行为	说明
`REQUIRED`	默认，有则加入，无则创建
`REQUIRES_NEW`	总是新建事务，挂起当前事务
`SUPPORTS`	有则加入，无则非事务执行
`NOT_SUPPORTED`	非事务执行，挂起当前事务
`MANDATORY`	必须在事务中，否则抛异常
`NEVER`	不能在事务中，否则抛异常
`NESTED`	嵌套事务，外部回滚则一起回滚

15. @Transactional 失效的常见场景？

方法非 public 修饰
同类方法内部调用（未经过代理）
异常被 catch 未抛出
抛出的异常类型不是 RuntimeException
数据库引擎不支持事务（如 MyISAM）

六、并发与缓存

16. Spring 中如何使用缓存？

@Cacheable(value = "users", key = "#id")
public User getUserById(Long id) {
 return userMapper.selectById(id);
}

@CacheEvict(value = "users", key = "#id")
public void deleteUser(Long id) {
 userMapper.deleteById(id);
}

支持的缓存实现：Redis、Caffeine、EhCache 等。

17. @Async 异步执行注意事项？

需在启动类添加 @EnableAsync
方法需为 public，且不能在同一个类内部调用
推荐自定义线程池，避免使用默认的 SimpleAsyncTaskExecutor

总结

以上是 2025 年高频 Java Spring 面试题的核心要点。建议结合源码理解底层原理，而不仅仅背诵答案。Spring 生态不断演进，持续关注 Spring Boot 3.x 和 Spring Cloud 2024/2025 版本的新特性至关重要。

Java on 吾爱主机

Spring 事务传播机制：REQUIRED、REQUIRES_NEW 与嵌套事务工程实践

一、先分清：物理事务 vs 逻辑事务

二、七种传播行为速查

三、REQUIRED：默认正确，但要懂 UnexpectedRollbackException

1. 语义

2. 逻辑作用域仍是独立的

3. 内层 isolation / timeout / readOnly 默认会被忽略

四、REQUIRES_NEW：真正的“独立事务”

1. 语义

2. 适合什么

3. 连接池风险（必须重视）

五、NESTED：同一物理事务上的 savepoint

1. 语义

2. 与 REQUIRES_NEW 的选型

六、回滚规则：默认只认 RuntimeException / Error

七、代理模型：自调用为什么“注解失效”

八、可复现的排查清单

九、工程建议（可直接落到 Code Review）

十、总结

参考资料

Spring AI 2.0 结构化输出实战：让大模型返回可验证的 Java 对象

一、结构化输出解决的到底是什么问题

三、Spring AI 2.0 的第一个关键开关：validateSchema()

四、第二个关键开关：useProviderStructuredOutput()

五、生产建议：两个开关一起用

六、泛型类型：ParameterizedTypeReference

七、需要原始响应时，用 .responseEntity(...)

八、内置 converter 与自定义 converter

九、流式调用怎么处理结构化输出

十、工程落地清单

总结

Spring Boot 3.5.16 发布后，团队现在该怎么做：升级、验证与 3.5 生命周期收尾指南

一、先说结论：3.5.16 是什么性质的版本

二、这次实际更新了什么

三、为什么这个版本值得今天就处理

1）你还在 3.5.x，就应该把 3.5.16 当成收官版看待

2）升级 3.5.16 和规划下一跳，是两件要并行做的事

四、哪些项目应该优先升级

1）仍在长期维护的存量业务系统

2）依赖 Spring Data / Spring Integration / AMQP 的集成型系统

3）准备做 3.5 → 4.x 升级演练的团队

五、怎么升级到 3.5.16

Maven

Gradle

六、升级后重点验证什么

1）heapdump 端点默认访问策略变更

2）布尔型配置值解析更严格

3）Profile 命名校验更严格，但 3.5.1 起已部分放宽

4）按名称注入 taskExecutor 的代码需要留意

七、升级前后的实操检查单

升级前

升级中

升级后

八、现在是继续留在 3.5，还是直接上 4.x？

策略 A：先稳定到 3.5.16，再规划 4.1

策略 B：在测试环境同时启动 3.5.16 与 4.1 双线验证

策略 C：如果必须长期停留 3.5，评估商业支持

九、给团队负责人的建议

十、总结

24张图带你彻底弄懂Java线程池

什么是线程池

线程池的构造

线程池的运行原理

1. 提交任务时的判断流程

2. 四种拒绝策略

3. execute 方法核心逻辑

线程池中线程复用的原理

自定义线程池的最佳实践

总结

Spring Cloud 微服务架构全解：注册发现、网关、熔断与实战

前言

1. 微服务架构概览

2. Spring Cloud 版本选择

2.1 依赖管理（pom.xml）

3. Nacos — 注册中心与配置中心

3.1 安装 Nacos

3.2 服务注册

3.3 配置中心

4. OpenFeign — 声明式 HTTP 调用

三、Spring AI 2.0 的第一个关键开关：`validateSchema()`

四、第二个关键开关：`useProviderStructuredOutput()`

六、泛型类型：`ParameterizedTypeReference`

七、需要原始响应时，用 `.responseEntity(...)`

1）`heapdump` 端点默认访问策略变更

4）按名称注入 `taskExecutor` 的代码需要留意