Spring 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 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 容器化

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 版本的新特性至关重要。