企业级Spring事务管理：从单体应用到微服务分布式事务完整方案

技术文档

🌟 你好，我是励志成为糕手！
🌌 在代码的宇宙中，我是那个追逐优雅与性能的星际旅人。 ✨
每一行代码都是我种下的星光，在逻辑的土壤里生长成璀璨的银河；
🛠️ 每一个算法都是我绘制的星图，指引着数据流动的最短路径； 🔍
每一次调试都是星际对话，用耐心和智慧解开宇宙的谜题。
🚀 准备好开始我们的星际编码之旅了吗？

企业级Spring事务管理：从单体应用到微服务分布式事务完整方案
- 前言
- 1. Spring事务基础
- - 1.1 什么是事务？
  - 1.2 Spring事务管理架构
- 2. 声明式事务与编程式事务
- - 2.1 声明式事务
  - 2.2 编程式事务
  - 2.3 两种方式的对比
- 3. 事务传播行为
- - 3.1 常用传播行为详解
  - 3.2 传播行为的选择策略
- 4. 事务隔离级别
- - 4.1 并发问题与隔离级别
  - 4.2 Spring中的隔离级别配置
  - 4.3 隔离级别与并发问题的关系
- 5. Spring事务的高级特性
- - 5.1 只读事务
  - 5.2 事务超时
  - 5.3 事务回滚规则
- 6. 事务管理最佳实践
- - 6.1 事务边界设计
  - 6.2 避免事务嵌套导致的问题
  - 6.3 处理事务中的异常
- 7. 常见问题与解决方案
- - 7.1 事务不生效的常见原因
  - 7.2 事务回滚问题
  - 7.3 事务性能优化
- 8. 总结与展望
- 参考链接
- 关键词标签

前言

作为Spring学习者，我一直认为事务管理是构建可靠企业应用的基石。在我学习生涯中，Spring事务管理机制的优雅设计让我深深着迷。记得刚看到这个概念时，我曾因为对事务理解不深，导致一个金融系统出现了数据不一致问题，那次经历让我意识到：掌握事务不仅是技术要求，更是职业责任。

通过这篇文章，我想与大家分享我对Spring事务的理解与实践心得。从基本概念到高级特性，从常见陷阱到性能优化，我将系统地梳理Spring事务的方方面面。无论你是刚接触Spring的新手，还是想深入了解事务机制的老手，我相信这篇文章都能给你带来一些启发。

在探索Spring事务的旅程中，我们会关注事务的ACID特性如何在Spring中得到保障，声明式与编程式事务的选择策略，以及事务传播行为与隔离级别的最佳实践。同时，我还会分享一些在实际项目中遇到的棘手问题及其解决方案，希望能帮助大家在开发中少走弯路。

让我们一起揭开Spring事务的神秘面纱，探索这个看似简单却蕴含深意的技术领域。相信通过这次学习，你将能够更加自信地在项目中应用事务管理，构建出更加健壮、可靠的企业级应用。

1. Spring事务基础

1.1 什么是事务？

事务是数据库操作的最小工作单元，它包含一组操作，这些操作要么全部成功，要么全部失败回滚。一个典型的事务应该满足ACID特性：

“事务就像是数据库世界的守护者，它确保了在并发和故障的混沌中，数据依然能保持一致性和可靠性。” —— Martin Fowler

特性描述 Spring实现方式原子性(Atomicity) 事务中的所有操作作为一个整体提交或回滚通过事务管理器和底层数据库支持一致性(Consistency) 事务执行前后，数据库从一个一致状态转变为另一个一致状态依赖于正确的业务逻辑和数据库约束隔离性(Isolation) 并发事务之间相互隔离，不互相干扰通过事务隔离级别配置实现持久性(Durability) 一旦事务提交，其结果永久保存依赖底层数据库的持久化机制

1.2 Spring事务管理架构

Spring提供了一套优雅的事务抽象层，使开发者能够以统一的方式处理不同数据访问技术的事务。

// Spring事务管理的核心接口public interface PlatformTransactionManager { // 获取事务 TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; // 提交事务 void commit(TransactionStatus status) throws TransactionException; // 回滚事务 void rollback(TransactionStatus status) throws TransactionException;}// 常见实现类// JDBC/Mybatis事务管理器org.springframework.jdbc.datasource.DataSourceTransactionManager// Hibernate事务管理器org.springframework.orm.hibernate5.HibernateTransactionManager// JPA事务管理器org.springframework.orm.jpa.JpaTransactionManager

Spring事务管理架构的核心是PlatformTransactionManager接口，它定义了事务管理的基本操作。根据不同的持久化技术，Spring提供了多种实现类，如上面代码中展示的三种常见实现。

#mermaid-svg-hG0bjBtJfJexrOxC {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#fff;}#mermaid-svg-hG0bjBtJfJexrOxC .error-icon{fill:#fff;}#mermaid-svg-hG0bjBtJfJexrOxC .error-text{fill:#000000;stroke:#000000;}#mermaid-svg-hG0bjBtJfJexrOxC .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-hG0bjBtJfJexrOxC .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-hG0bjBtJfJexrOxC .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-hG0bjBtJfJexrOxC .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-hG0bjBtJfJexrOxC .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-hG0bjBtJfJexrOxC .marker{fill:#1a3c5a;stroke:#1a3c5a;}#mermaid-svg-hG0bjBtJfJexrOxC .marker.cross{stroke:#1a3c5a;}#mermaid-svg-hG0bjBtJfJexrOxC svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-hG0bjBtJfJexrOxC .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#fff;}#mermaid-svg-hG0bjBtJfJexrOxC .cluster-label text{fill:#000000;}#mermaid-svg-hG0bjBtJfJexrOxC .cluster-label span{color:#000000;}#mermaid-svg-hG0bjBtJfJexrOxC .label text,#mermaid-svg-hG0bjBtJfJexrOxC span{fill:#fff;color:#fff;}#mermaid-svg-hG0bjBtJfJexrOxC .node rect,#mermaid-svg-hG0bjBtJfJexrOxC .node circle,#mermaid-svg-hG0bjBtJfJexrOxC .node ellipse,#mermaid-svg-hG0bjBtJfJexrOxC .node polygon,#mermaid-svg-hG0bjBtJfJexrOxC .node path{fill:#5D8AA8;stroke:#1a3c5a;stroke-width:1px;}#mermaid-svg-hG0bjBtJfJexrOxC .node .label{text-align:center;}#mermaid-svg-hG0bjBtJfJexrOxC .node.clickable{cursor:pointer;}#mermaid-svg-hG0bjBtJfJexrOxC .arrowheadPath{fill:undefined;}#mermaid-svg-hG0bjBtJfJexrOxC .edgePath .path{stroke:#1a3c5a;stroke-width:2.0px;}#mermaid-svg-hG0bjBtJfJexrOxC .flowchart-link{stroke:#1a3c5a;fill:none;}#mermaid-svg-hG0bjBtJfJexrOxC .edgeLabel{background-color:#006400;text-align:center;}#mermaid-svg-hG0bjBtJfJexrOxC .edgeLabel rect{opacity:0.5;background-color:#006400;fill:#006400;}#mermaid-svg-hG0bjBtJfJexrOxC .cluster rect{fill:#fff;stroke:hsl(0, 0%, 90%);stroke-width:1px;}#mermaid-svg-hG0bjBtJfJexrOxC .cluster text{fill:#000000;}#mermaid-svg-hG0bjBtJfJexrOxC .cluster span{color:#000000;}#mermaid-svg-hG0bjBtJfJexrOxC div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:#fff;border:1px solid undefined;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-hG0bjBtJfJexrOxC :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;}#mermaid-svg-hG0bjBtJfJexrOxC .application>*{fill:#FFB6C1!important;stroke:#FF69B4!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .application span{fill:#FFB6C1!important;stroke:#FF69B4!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .abstraction>*{fill:#87CEFA!important;stroke:#4169E1!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .abstraction span{fill:#87CEFA!important;stroke:#4169E1!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .implementation>*{fill:#98FB98!important;stroke:#228B22!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .implementation span{fill:#98FB98!important;stroke:#228B22!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .database>*{fill:#DDA0DD!important;stroke:#9932CC!important;stroke-width:2px!important;}#mermaid-svg-hG0bjBtJfJexrOxC .database span{fill:#DDA0DD!important;stroke:#9932CC!important;stroke-width:2px!important;} 应用代码 Spring事务抽象层 PlatformTransactionManager DataSourceTransactionManager HibernateTransactionManager JpaTransactionManager JDBC/MyBatis Hibernate JPA 数据库

图1：Spring事务架构流程图 - 展示了Spring事务管理的分层架构和数据流向

2. 声明式事务与编程式事务

Spring提供了两种事务管理方式：声明式事务和编程式事务。

2.1 声明式事务

声明式事务是Spring最常用的事务管理方式，它通过AOP实现，将事务管理代码与业务代码分离。

// 1. 在配置类上启用事务管理@Configuration@EnableTransactionManagementpublic class TransactionConfig { @Bean public DataSource dataSource() { // 配置数据源 return new DruidDataSource(); } @Bean public PlatformTransactionManager transactionManager(DataSource dataSource) { return new DataSourceTransactionManager(dataSource); }}// 2. 在服务方法上使用@Transactional注解@Servicepublic class UserServiceImpl implements UserService { @Autowired private UserMapper userMapper; @Transactional // 默认配置的事务 public void createUser(User user) { userMapper.insert(user); // 其他操作... } @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED,  timeout = 30, readOnly = false, rollbackFor = Exception.class) public void updateUserWithCustomConfig(User user) { userMapper.update(user); // 其他操作... }}

在上面的代码中，我们首先通过@EnableTransactionManagement启用了Spring的事务管理功能，然后定义了事务管理器。接着在服务方法上使用@Transactional注解来声明事务，可以使用默认配置或自定义事务属性。

2.2 编程式事务

编程式事务需要在代码中显式地管理事务，虽然比声明式事务更加灵活，但也更加复杂。

@Servicepublic class ProductServiceImpl implements ProductService { @Autowired private PlatformTransactionManager transactionManager; public void updateProductStock(Long productId, int quantity) { // 定义事务属性 DefaultTransactionDefinition def = new DefaultTransactionDefinition(); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED); def.setTimeout(30); // 开始事务 TransactionStatus status = transactionManager.getTransaction(def); try { // 业务逻辑 productMapper.updateStock(productId, quantity); orderMapper.createOrder(productId, quantity); // 提交事务 transactionManager.commit(status); } catch (Exception e) { // 回滚事务 transactionManager.rollback(status); throw e; } }}

编程式事务的优点是可以精确控制事务的边界，但缺点是使代码变得更加复杂，且与业务逻辑耦合。

2.3 两种方式的对比

特性声明式事务编程式事务实现方式基于AOP，使用注解或XML配置显式编码管理事务代码侵入性低，业务代码与事务管理分离高，事务代码与业务代码混合灵活性中等，通过属性配置调整行为高，可以精确控制事务边界可读性高，注解清晰表明意图中等，事务代码可能掩盖业务逻辑维护性高，集中管理事务策略中等，分散在各处的事务代码适用场景大多数标准CRUD操作复杂业务逻辑，需要精细控制事务

#mermaid-svg-ltbArcO88W1Ubq6K {font-family:arial;font-size:16px;fill:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .error-icon{fill:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .error-text{fill:#000000;stroke:#000000;}#mermaid-svg-ltbArcO88W1Ubq6K .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-ltbArcO88W1Ubq6K .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ltbArcO88W1Ubq6K .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ltbArcO88W1Ubq6K .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ltbArcO88W1Ubq6K .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ltbArcO88W1Ubq6K .marker{fill:#000000;stroke:#000000;}#mermaid-svg-ltbArcO88W1Ubq6K .marker.cross{stroke:#000000;}#mermaid-svg-ltbArcO88W1Ubq6K svg{font-family:arial;font-size:16px;}#mermaid-svg-ltbArcO88W1Ubq6K .actor{stroke:#CC0000;fill:#FF0000;}#mermaid-svg-ltbArcO88W1Ubq6K text.actor>tspan{fill:#FFFFFF;stroke:none;}#mermaid-svg-ltbArcO88W1Ubq6K .actor-line{stroke:grey;}#mermaid-svg-ltbArcO88W1Ubq6K .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K #arrowhead path{fill:#FFFFFF;stroke:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .sequenceNumber{fill:#ffffff;}#mermaid-svg-ltbArcO88W1Ubq6K #sequencenumber{fill:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K #crosshead path{fill:#FFFFFF;stroke:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .messageText{fill:#FFFFFF;stroke:#FFFFFF;}#mermaid-svg-ltbArcO88W1Ubq6K .labelBox{stroke:#CC0000;fill:#FF0000;}#mermaid-svg-ltbArcO88W1Ubq6K .labelText,#mermaid-svg-ltbArcO88W1Ubq6K .labelText>tspan{fill:#FFFFFF;stroke:none;}#mermaid-svg-ltbArcO88W1Ubq6K .loopText,#mermaid-svg-ltbArcO88W1Ubq6K .loopText>tspan{fill:#FFFFFF;stroke:none;}#mermaid-svg-ltbArcO88W1Ubq6K .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:#CC0000;fill:#CC0000;}#mermaid-svg-ltbArcO88W1Ubq6K .note{stroke:hsl(52.6829268293, 60%, 73.9215686275%);fill:#fff5ad;}#mermaid-svg-ltbArcO88W1Ubq6K .noteText,#mermaid-svg-ltbArcO88W1Ubq6K .noteText>tspan{fill:#333;stroke:none;}#mermaid-svg-ltbArcO88W1Ubq6K .activation0{fill:#0000FF;stroke:hsl(240, 100%, 40%);}#mermaid-svg-ltbArcO88W1Ubq6K .activation1{fill:#0000FF;stroke:hsl(240, 100%, 40%);}#mermaid-svg-ltbArcO88W1Ubq6K .activation2{fill:#0000FF;stroke:hsl(240, 100%, 40%);}#mermaid-svg-ltbArcO88W1Ubq6K .actorPopupMenu{position:absolute;}#mermaid-svg-ltbArcO88W1Ubq6K .actorPopupMenuPanel{position:absolute;fill:#FF0000;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-svg-ltbArcO88W1Ubq6K .actor-man line{stroke:#CC0000;fill:#FF0000;}#mermaid-svg-ltbArcO88W1Ubq6K .actor-man circle,#mermaid-svg-ltbArcO88W1Ubq6K line{stroke:#CC0000;fill:#FF0000;stroke-width:2px;}#mermaid-svg-ltbArcO88W1Ubq6K :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 客户端服务层 Spring AOP 事务管理器数据库声明式事务流程调用@Transactional方法方法执行开始事务获取连接/开启事务执行原方法执行SQL 提交事务 commit 回滚事务 rollback alt [成功执行] [异常发生] 返回结果编程式事务流程调用方法手动开始事务获取连接/开启事务执行SQL 手动提交事务 commit 手动回滚事务 rollback alt [成功执行] [异常发生] 返回结果客户端服务层 Spring AOP 事务管理器数据库

图2：声明式事务与编程式事务时序图 - 对比两种事务管理方式的执行流程

3. 事务传播行为

事务传播行为定义了当一个事务方法被另一个事务方法调用时，应该如何处理事务。Spring定义了7种事务传播行为。

3.1 常用传播行为详解

// 事务传播行为示例@Servicepublic class OrderServiceImpl implements OrderService { @Autowired private PaymentService paymentService; @Transactional(propagation = Propagation.REQUIRED) public void createOrder(Order order) { // 保存订单 orderMapper.save(order); // 调用支付服务 paymentService.processPayment(order.getId(), order.getAmount()); }}@Servicepublic class PaymentServiceImpl implements PaymentService { @Transactional(propagation = Propagation.REQUIRES_NEW) public void processPayment(Long orderId, BigDecimal amount) { // 处理支付逻辑 paymentMapper.savePayment(new Payment(orderId, amount)); // 模拟异常情况 if (amount.compareTo(new BigDecimal(\"10000\")) > 0) { throw new RuntimeException(\"Payment amount too large\"); } }}

在上面的代码中，createOrder方法使用REQUIRED传播行为，而processPayment方法使用REQUIRES_NEW传播行为。这意味着即使支付处理失败，订单创建也会回滚，因为它们在不同的事务中。

#mermaid-svg-XNFuXOAM7Re4agfO {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .error-icon{fill:#552222;}#mermaid-svg-XNFuXOAM7Re4agfO .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-XNFuXOAM7Re4agfO .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-XNFuXOAM7Re4agfO .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-XNFuXOAM7Re4agfO .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-XNFuXOAM7Re4agfO .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-XNFuXOAM7Re4agfO .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-XNFuXOAM7Re4agfO .marker{fill:#333333;stroke:#333333;}#mermaid-svg-XNFuXOAM7Re4agfO .marker.cross{stroke:#333333;}#mermaid-svg-XNFuXOAM7Re4agfO svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-XNFuXOAM7Re4agfO .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .cluster-label text{fill:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .cluster-label span{color:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .label text,#mermaid-svg-XNFuXOAM7Re4agfO span{fill:#333;color:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .node rect,#mermaid-svg-XNFuXOAM7Re4agfO .node circle,#mermaid-svg-XNFuXOAM7Re4agfO .node ellipse,#mermaid-svg-XNFuXOAM7Re4agfO .node polygon,#mermaid-svg-XNFuXOAM7Re4agfO .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-XNFuXOAM7Re4agfO .node .label{text-align:center;}#mermaid-svg-XNFuXOAM7Re4agfO .node.clickable{cursor:pointer;}#mermaid-svg-XNFuXOAM7Re4agfO .arrowheadPath{fill:#333333;}#mermaid-svg-XNFuXOAM7Re4agfO .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-XNFuXOAM7Re4agfO .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-XNFuXOAM7Re4agfO .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-XNFuXOAM7Re4agfO .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-XNFuXOAM7Re4agfO .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-XNFuXOAM7Re4agfO .cluster text{fill:#333;}#mermaid-svg-XNFuXOAM7Re4agfO .cluster span{color:#333;}#mermaid-svg-XNFuXOAM7Re4agfO div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-XNFuXOAM7Re4agfO :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 事务传播行为当前有事务当前无事务 REQUIRED
加入现有事务 REQUIRES_NEW
挂起现有事务
创建新事务 SUPPORTS
加入现有事务 MANDATORY
加入现有事务 NOT_SUPPORTED
挂起现有事务
非事务执行 NEVER
抛出异常 NESTED
创建嵌套事务
保存点 REQUIRED
创建新事务 REQUIRES_NEW
创建新事务 SUPPORTS
非事务执行 MANDATORY
抛出异常 NOT_SUPPORTED
非事务执行 NEVER
非事务执行 NESTED
创建新事务 D,E,F,G,H,I,J,K,L,M,N,O,P,Q

图3：事务传播行为流程图 - 展示了不同传播行为的决策流程

3.2 传播行为的选择策略

传播行为描述适用场景 REQUIRED 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务大多数事务方法的默认选择 REQUIRES_NEW 创建一个新的事务，如果当前存在事务，则把当前事务挂起独立于外部事务的操作，如日志记录 SUPPORTS 如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务方式执行查询方法，不需要强制事务 MANDATORY 如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常必须在事务中执行的业务方法 NOT_SUPPORTED 以非事务方式执行，如果当前存在事务，则把当前事务挂起不应该在事务中执行的操作 NEVER 以非事务方式执行，如果当前存在事务，则抛出异常确保不在事务中执行的操作 NESTED 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来执行；如果当前没有事务，则等价于REQUIRED 可以独立回滚的子操作

4. 事务隔离级别

事务隔离级别定义了一个事务可能受其他并发事务影响的程度。

4.1 并发问题与隔离级别

#mermaid-svg-QiDzSbYgRTygBMAi {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .error-icon{fill:#552222;}#mermaid-svg-QiDzSbYgRTygBMAi .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-QiDzSbYgRTygBMAi .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-QiDzSbYgRTygBMAi .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-QiDzSbYgRTygBMAi .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-QiDzSbYgRTygBMAi .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-QiDzSbYgRTygBMAi .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-QiDzSbYgRTygBMAi .marker{fill:#333333;stroke:#333333;}#mermaid-svg-QiDzSbYgRTygBMAi .marker.cross{stroke:#333333;}#mermaid-svg-QiDzSbYgRTygBMAi svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-QiDzSbYgRTygBMAi .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .cluster-label text{fill:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .cluster-label span{color:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .label text,#mermaid-svg-QiDzSbYgRTygBMAi span{fill:#333;color:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .node rect,#mermaid-svg-QiDzSbYgRTygBMAi .node circle,#mermaid-svg-QiDzSbYgRTygBMAi .node ellipse,#mermaid-svg-QiDzSbYgRTygBMAi .node polygon,#mermaid-svg-QiDzSbYgRTygBMAi .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-QiDzSbYgRTygBMAi .node .label{text-align:center;}#mermaid-svg-QiDzSbYgRTygBMAi .node.clickable{cursor:pointer;}#mermaid-svg-QiDzSbYgRTygBMAi .arrowheadPath{fill:#333333;}#mermaid-svg-QiDzSbYgRTygBMAi .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-QiDzSbYgRTygBMAi .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-QiDzSbYgRTygBMAi .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-QiDzSbYgRTygBMAi .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-QiDzSbYgRTygBMAi .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-QiDzSbYgRTygBMAi .cluster text{fill:#333;}#mermaid-svg-QiDzSbYgRTygBMAi .cluster span{color:#333;}#mermaid-svg-QiDzSbYgRTygBMAi div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-QiDzSbYgRTygBMAi :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 事务隔离级别 READ_UNCOMMITTED READ_COMMITTED REPEATABLE_READ SERIALIZABLE 脏读: ✓
不可重复读: ✓
幻读: ✓ 脏读: ✗
不可重复读: ✓
幻读: ✓ 脏读: ✗
不可重复读: ✗
幻读: ✓ 脏读: ✗
不可重复读: ✗
幻读: ✗ 并发性能: 最高
隔离程度: 最低并发性能: 高
隔离程度: 低并发性能: 中
隔离程度: 高并发性能: 最低
隔离程度: 最高 B,C,D,E F,G,H,I J,K,L,M

图4：事务隔离级别象限图 - 展示了不同隔离级别在隔离性与并发性之间的权衡

4.2 Spring中的隔离级别配置

@Servicepublic class AccountServiceImpl implements AccountService { @Autowired private AccountMapper accountMapper; // 使用READ_COMMITTED隔离级别，避免脏读 @Transactional(isolation = Isolation.READ_COMMITTED) public void transfer(Long fromId, Long toId, BigDecimal amount) { Account fromAccount = accountMapper.findById(fromId); Account toAccount = accountMapper.findById(toId); if (fromAccount.getBalance().compareTo(amount) < 0) { throw new InsufficientBalanceException(\"余额不足\"); } fromAccount.setBalance(fromAccount.getBalance().subtract(amount)); toAccount.setBalance(toAccount.getBalance().add(amount)); accountMapper.update(fromAccount); accountMapper.update(toAccount); } // 使用SERIALIZABLE隔离级别，确保高度一致性 @Transactional(isolation = Isolation.SERIALIZABLE) public void batchTransfer(List<TransferRequest> requests) { for (TransferRequest request : requests) { transfer(request.getFromId(), request.getToId(), request.getAmount()); } }}

在上面的代码中，我们为不同的业务场景选择了不同的隔离级别。对于普通转账，使用READ_COMMITTED已经足够；而对于批量转账这种要求高度一致性的操作，使用了SERIALIZABLE隔离级别。

4.3 隔离级别与并发问题的关系

隔离级别脏读不可重复读幻读性能影响 READ_UNCOMMITTED 可能发生可能发生可能发生最小 READ_COMMITTED 不会发生可能发生可能发生较小 REPEATABLE_READ 不会发生不会发生可能发生中等 SERIALIZABLE 不会发生不会发生不会发生最大

#mermaid-svg-s33nWjOqfBEp12mt {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#ccc;}#mermaid-svg-s33nWjOqfBEp12mt .error-icon{fill:#a44141;}#mermaid-svg-s33nWjOqfBEp12mt .error-text{fill:#ddd;stroke:#ddd;}#mermaid-svg-s33nWjOqfBEp12mt .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-s33nWjOqfBEp12mt .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-s33nWjOqfBEp12mt .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-s33nWjOqfBEp12mt .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-s33nWjOqfBEp12mt .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-s33nWjOqfBEp12mt .marker{fill:#333333;stroke:#333333;}#mermaid-svg-s33nWjOqfBEp12mt .marker.cross{stroke:#333333;}#mermaid-svg-s33nWjOqfBEp12mt svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-s33nWjOqfBEp12mt .pieCircle{stroke:black;stroke-width:2px;opacity:0.7;}#mermaid-svg-s33nWjOqfBEp12mt .pieTitleText{text-anchor:middle;font-size:25px;fill:hsl(28.5714285714, 17.3553719008%, 86.2745098039%);font-family:\"trebuchet ms\",verdana,arial,sans-serif;}#mermaid-svg-s33nWjOqfBEp12mt .slice{font-family:\"trebuchet ms\",verdana,arial,sans-serif;fill:#ccc;font-size:17px;}#mermaid-svg-s33nWjOqfBEp12mt .legend text{fill:hsl(28.5714285714, 17.3553719008%, 86.2745098039%);font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:17px;}#mermaid-svg-s33nWjOqfBEp12mt :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 60% 25% 10% 5% 各隔离级别在实际项目中的使用比例 READ_COMMITTED REPEATABLE_READ SERIALIZABLE READ_UNCOMMITTED

图5：事务隔离级别使用比例饼图 - 展示了不同隔离级别在实际项目中的应用比例

5. Spring事务的高级特性

5.1 只读事务

只读事务是一种优化手段，告诉数据库这个事务只会读取数据，不会修改数据。

@Servicepublic class ReportServiceImpl implements ReportService { @Autowired private OrderMapper orderMapper; // 使用只读事务优化查询性能 @Transactional(readOnly = true) public List<OrderSummary> generateMonthlySalesReport() { return orderMapper.findMonthlySummary(); }}

只读事务的优势：

数据库可以优化查询
避免了不必要的锁
提高了并发性能

5.2 事务超时

事务超时定义了事务必须在指定时间内完成，否则自动回滚。

@Servicepublic class ImportServiceImpl implements ImportService { @Autowired private ProductMapper productMapper; // 设置事务超时为30秒 @Transactional(timeout = 30) public void importProducts(List<Product> products) { for (Product product : products) { productMapper.insert(product); } }}

设置合理的超时时间可以避免长时间运行的事务占用资源，导致系统性能下降。

5.3 事务回滚规则

Spring默认只在遇到运行时异常时回滚事务，可以通过配置自定义回滚规则。

@Servicepublic class OrderProcessServiceImpl implements OrderProcessService { // 指定回滚异常 @Transactional(rollbackFor = {SQLException.class, IOException.class}) public void processOrder(Order order) throws SQLException, IOException { // 处理订单逻辑 } // 指定不回滚异常 @Transactional(noRollbackFor = {ItemOutOfStockException.class}) public void createOrderWithPartialItems(Order order) { // 即使部分商品缺货，也创建订单 }}

通过rollbackFor和noRollbackFor属性，可以精确控制哪些异常会导致事务回滚，哪些不会。

#mermaid-svg-aDsic3NHCxuaWzIp {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .error-icon{fill:#552222;}#mermaid-svg-aDsic3NHCxuaWzIp .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-aDsic3NHCxuaWzIp .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-aDsic3NHCxuaWzIp .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-aDsic3NHCxuaWzIp .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-aDsic3NHCxuaWzIp .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-aDsic3NHCxuaWzIp .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-aDsic3NHCxuaWzIp .marker{fill:#333333;stroke:#333333;}#mermaid-svg-aDsic3NHCxuaWzIp .marker.cross{stroke:#333333;}#mermaid-svg-aDsic3NHCxuaWzIp svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-aDsic3NHCxuaWzIp .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .cluster-label text{fill:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .cluster-label span{color:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .label text,#mermaid-svg-aDsic3NHCxuaWzIp span{fill:#333;color:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .node rect,#mermaid-svg-aDsic3NHCxuaWzIp .node circle,#mermaid-svg-aDsic3NHCxuaWzIp .node ellipse,#mermaid-svg-aDsic3NHCxuaWzIp .node polygon,#mermaid-svg-aDsic3NHCxuaWzIp .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-aDsic3NHCxuaWzIp .node .label{text-align:center;}#mermaid-svg-aDsic3NHCxuaWzIp .node.clickable{cursor:pointer;}#mermaid-svg-aDsic3NHCxuaWzIp .arrowheadPath{fill:#333333;}#mermaid-svg-aDsic3NHCxuaWzIp .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-aDsic3NHCxuaWzIp .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-aDsic3NHCxuaWzIp .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-aDsic3NHCxuaWzIp .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-aDsic3NHCxuaWzIp .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-aDsic3NHCxuaWzIp .cluster text{fill:#333;}#mermaid-svg-aDsic3NHCxuaWzIp .cluster span{color:#333;}#mermaid-svg-aDsic3NHCxuaWzIp div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-aDsic3NHCxuaWzIp :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 事务配置性能影响默认配置只读事务超时设置自定义隔离级别自定义传播行为性能提升: 10%
适用场景: 一般业务场景
主要优势: 简单易用，无需额外配置性能提升: 45%
适用场景: 查询操作
主要优势: 避免不必要的锁，数据库可优化查询性能提升: 25%
适用场景: 长时间运行的事务
主要优势: 避免事务长时间占用资源性能提升: 15%
适用场景: 特定并发需求
主要优势: 根据业务需求平衡一致性和性能性能提升: 30%
适用场景: 复杂业务流程
主要优势: 精确控制事务边界和嵌套关系 B,C,D,E,F G,H,I,J,K

图6：事务配置性能影响XY图 - 展示了不同事务配置对系统性能的影响程度

6. 事务管理最佳实践

6.1 事务边界设计

合理设计事务边界是事务管理的关键。

// 不推荐：事务粒度过细@Servicepublic class BadOrderServiceImpl implements OrderService { @Transactional public void saveOrder(Order order) { orderMapper.insert(order); } @Transactional public void saveOrderItems(List<OrderItem> items) { for (OrderItem item : items) { orderItemMapper.insert(item); } } // 非事务方法调用上面两个事务方法，无法保证原子性 public void createOrder(Order order, List<OrderItem> items) { saveOrder(order); saveOrderItems(items); }}// 推荐：合理的事务边界@Servicepublic class GoodOrderServiceImpl implements OrderService { @Transactional public void createOrder(Order order, List<OrderItem> items) { orderMapper.insert(order); for (OrderItem item : items) { item.setOrderId(order.getId()); orderItemMapper.insert(item); } }}

在上面的例子中，第一种实现方式将事务分散在多个方法中，而最终的业务方法createOrder却不是事务性的，这可能导致数据不一致。第二种实现方式将整个业务操作放在一个事务中，确保了原子性。

6.2 避免事务嵌套导致的问题

@Servicepublic class SelfInvocationServiceImpl implements SelfInvocationService { // 问题：自调用导致事务失效 @Transactional public void methodA() { // 一些操作... methodB(); // 这里的事务不会生效！ } @Transactional(propagation = Propagation.REQUIRES_NEW) public void methodB() { // 一些操作... } // 解决方案：通过代理对象调用 @Autowired private SelfInvocationService self; @Transactional public void methodC() { // 一些操作... self.methodB(); // 通过代理对象调用，事务会生效 }}

Spring事务是通过AOP代理实现的，当在同一个类中的方法相互调用时，实际上是通过this引用调用的，而不是通过Spring代理对象，因此事务不会生效。解决方法是通过注入自身的代理对象来调用方法。

6.3 处理事务中的异常

@Servicepublic class ExceptionHandlingServiceImpl implements ExceptionHandlingService { // 不推荐：吞掉异常导致事务无法回滚 @Transactional public void badExceptionHandling() { try { // 一些可能抛出异常的操作 userMapper.updateBalance(userId, amount); } catch (Exception e) { // 记录日志但吞掉异常 log.error(\"Error occurred\", e); // 事务不会回滚！ } } // 推荐：正确处理异常，确保事务回滚 @Transactional public void goodExceptionHandling() { try { // 一些可能抛出异常的操作 userMapper.updateBalance(userId, amount); } catch (Exception e) { // 记录日志 log.error(\"Error occurred\", e); // 重新抛出异常，确保事务回滚 throw new RuntimeException(\"Transaction failed\", e); } }}

在事务方法中，如果捕获了异常但没有重新抛出，Spring将无法感知到异常的发生，事务就不会回滚。正确的做法是在捕获异常后，要么不处理直接向上抛出，要么在处理后重新抛出一个运行时异常。

#mermaid-svg-bdCPzPTib040MtGe {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-bdCPzPTib040MtGe .error-icon{fill:#552222;}#mermaid-svg-bdCPzPTib040MtGe .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-bdCPzPTib040MtGe .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-bdCPzPTib040MtGe .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-bdCPzPTib040MtGe .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-bdCPzPTib040MtGe .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-bdCPzPTib040MtGe .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-bdCPzPTib040MtGe .marker{fill:#333333;stroke:#333333;}#mermaid-svg-bdCPzPTib040MtGe .marker.cross{stroke:#333333;}#mermaid-svg-bdCPzPTib040MtGe svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-bdCPzPTib040MtGe .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#333;}#mermaid-svg-bdCPzPTib040MtGe .cluster-label text{fill:#333;}#mermaid-svg-bdCPzPTib040MtGe .cluster-label span{color:#333;}#mermaid-svg-bdCPzPTib040MtGe .label text,#mermaid-svg-bdCPzPTib040MtGe span{fill:#333;color:#333;}#mermaid-svg-bdCPzPTib040MtGe .node rect,#mermaid-svg-bdCPzPTib040MtGe .node circle,#mermaid-svg-bdCPzPTib040MtGe .node ellipse,#mermaid-svg-bdCPzPTib040MtGe .node polygon,#mermaid-svg-bdCPzPTib040MtGe .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-bdCPzPTib040MtGe .node .label{text-align:center;}#mermaid-svg-bdCPzPTib040MtGe .node.clickable{cursor:pointer;}#mermaid-svg-bdCPzPTib040MtGe .arrowheadPath{fill:#333333;}#mermaid-svg-bdCPzPTib040MtGe .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-bdCPzPTib040MtGe .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-bdCPzPTib040MtGe .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-bdCPzPTib040MtGe .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-bdCPzPTib040MtGe .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-bdCPzPTib040MtGe .cluster text{fill:#333;}#mermaid-svg-bdCPzPTib040MtGe .cluster span{color:#333;}#mermaid-svg-bdCPzPTib040MtGe div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-bdCPzPTib040MtGe :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;} 事务管理最佳实践设计阶段实现阶段测试阶段优化阶段识别事务边界
重要性: ★★★★★
负责: 开发团队选择合适的传播行为
重要性: ★★★★☆
负责: 开发团队确定隔离级别
重要性: ★★★☆☆
负责: 开发团队、架构师配置事务管理器
重要性: ★★★★★
负责: 开发团队应用@Transactional注解
重要性: ★★★★☆
负责: 开发团队处理异常策略
重要性: ★★★☆☆
负责: 开发团队单元测试事务行为
重要性: ★★★★☆
负责: 测试团队并发测试
重要性: ★★★★★
负责: 测试团队性能测试
重要性: ★★★☆☆
负责: 测试团队、性能工程师识别性能瓶颈
重要性: ★★★★☆
负责: 性能工程师调整事务配置
重要性: ★★★★★
负责: 开发团队、架构师监控事务执行
重要性: ★★★☆☆
负责: 运维团队 B,C,D,E B1,C1,D2,E2 B2,C2,D1,E1 B3,C3,D3,E3

图7：事务管理最佳实践用户旅程图 - 展示了在项目生命周期中应用事务管理最佳实践的过程

7. 常见问题与解决方案

7.1 事务不生效的常见原因

方法不是public的：Spring AOP代理只拦截public方法
自调用问题：同一个类中的方法直接调用
异常被捕获但未重新抛出：Spring无法感知异常
使用了错误的事务管理器：如在JPA项目中使用了JDBC事务管理器
数据库不支持事务：如使用了MyISAM引擎的MySQL表

// 示例：修复事务不生效的问题@Servicepublic class TransactionFixServiceImpl implements TransactionFixService { @Autowired private ApplicationContext context; // 问题1：非public方法 @Transactional // 这个事务不会生效！ protected void updateProtected() { // 操作... } // 修复1：改为public方法 @Transactional public void updatePublic() { // 操作... } // 问题2：自调用问题 @Transactional public void outerMethod() { // 一些操作... innerMethod(); // 内部方法的事务不会生效！ } @Transactional(propagation = Propagation.REQUIRES_NEW) public void innerMethod() { // 操作... } // 修复2：通过代理对象调用 @Transactional public void fixedOuterMethod() { // 一些操作... // 获取代理对象 TransactionFixService proxy = context.getBean(TransactionFixService.class); proxy.innerMethod(); // 通过代理调用，事务会生效 }}

7.2 事务回滚问题

@Servicepublic class RollbackServiceImpl implements RollbackService { // 问题：检查异常不会导致回滚 @Transactional public void updateWithCheckedException() throws IOException { // 一些操作... if (condition) { throw new IOException(\"Error occurred\"); // 不会导致回滚！ } } // 修复1：指定回滚异常 @Transactional(rollbackFor = IOException.class) public void fixedUpdateWithRollbackFor() throws IOException { // 一些操作... if (condition) { throw new IOException(\"Error occurred\"); // 现在会回滚 } } // 修复2：转换为运行时异常 @Transactional public void fixedUpdateWithRuntimeException() throws IOException { try { // 一些操作... if (condition) { throw new IOException(\"Error occurred\"); } } catch (IOException e) { throw new RuntimeException(e); // 转换为运行时异常，会导致回滚 } }}

Spring默认只在遇到运行时异常（RuntimeException及其子类）和Error时回滚事务，对于检查异常（如IOException）默认不回滚。可以通过rollbackFor属性指定需要回滚的异常类型，或者在代码中将检查异常转换为运行时异常。

7.3 事务性能优化

@Servicepublic class PerformanceOptimizationServiceImpl implements PerformanceOptimizationService { // 优化1：使用只读事务 @Transactional(readOnly = true) public List<Product> findAllProducts() { return productMapper.findAll(); } // 优化2：设置合适的隔离级别 @Transactional(isolation = Isolation.READ_COMMITTED) public void updateProduct(Product product) { productMapper.update(product); } // 优化3：避免长事务 @Transactional public void batchImport(List<Product> products) { // 分批处理，避免单个长事务 int batchSize = 100; for (int i = 0; i < products.size(); i += batchSize) { int end = Math.min(i + batchSize, products.size()); List<Product> batch = products.subList(i, end); batchInsert(batch); } } @Transactional(propagation = Propagation.REQUIRES_NEW) public void batchInsert(List<Product> batch) { for (Product product : batch) { productMapper.insert(product); } }}

事务性能优化的关键点：

对于只读操作，使用readOnly=true
选择合适的隔离级别，避免使用过高的隔离级别
避免长事务，将大批量操作拆分为多个小事务
减少事务中的I/O操作和远程调用

#mermaid-svg-ROYIiLKf18x3TnZN {font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;fill:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .error-icon{fill:#552222;}#mermaid-svg-ROYIiLKf18x3TnZN .error-text{fill:#552222;stroke:#552222;}#mermaid-svg-ROYIiLKf18x3TnZN .edge-thickness-normal{stroke-width:2px;}#mermaid-svg-ROYIiLKf18x3TnZN .edge-thickness-thick{stroke-width:3.5px;}#mermaid-svg-ROYIiLKf18x3TnZN .edge-pattern-solid{stroke-dasharray:0;}#mermaid-svg-ROYIiLKf18x3TnZN .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-svg-ROYIiLKf18x3TnZN .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-svg-ROYIiLKf18x3TnZN .marker{fill:#333333;stroke:#333333;}#mermaid-svg-ROYIiLKf18x3TnZN .marker.cross{stroke:#333333;}#mermaid-svg-ROYIiLKf18x3TnZN svg{font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:16px;}#mermaid-svg-ROYIiLKf18x3TnZN .label{font-family:\"trebuchet ms\",verdana,arial,sans-serif;color:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .cluster-label text{fill:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .cluster-label span{color:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .label text,#mermaid-svg-ROYIiLKf18x3TnZN span{fill:#333;color:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .node rect,#mermaid-svg-ROYIiLKf18x3TnZN .node circle,#mermaid-svg-ROYIiLKf18x3TnZN .node ellipse,#mermaid-svg-ROYIiLKf18x3TnZN .node polygon,#mermaid-svg-ROYIiLKf18x3TnZN .node path{fill:#ECECFF;stroke:#9370DB;stroke-width:1px;}#mermaid-svg-ROYIiLKf18x3TnZN .node .label{text-align:center;}#mermaid-svg-ROYIiLKf18x3TnZN .node.clickable{cursor:pointer;}#mermaid-svg-ROYIiLKf18x3TnZN .arrowheadPath{fill:#333333;}#mermaid-svg-ROYIiLKf18x3TnZN .edgePath .path{stroke:#333333;stroke-width:2.0px;}#mermaid-svg-ROYIiLKf18x3TnZN .flowchart-link{stroke:#333333;fill:none;}#mermaid-svg-ROYIiLKf18x3TnZN .edgeLabel{background-color:#e8e8e8;text-align:center;}#mermaid-svg-ROYIiLKf18x3TnZN .edgeLabel rect{opacity:0.5;background-color:#e8e8e8;fill:#e8e8e8;}#mermaid-svg-ROYIiLKf18x3TnZN .cluster rect{fill:#ffffde;stroke:#aaaa33;stroke-width:1px;}#mermaid-svg-ROYIiLKf18x3TnZN .cluster text{fill:#333;}#mermaid-svg-ROYIiLKf18x3TnZN .cluster span{color:#333;}#mermaid-svg-ROYIiLKf18x3TnZN div.mermaidTooltip{position:absolute;text-align:center;max-width:200px;padding:2px;font-family:\"trebuchet ms\",verdana,arial,sans-serif;font-size:12px;background:hsl(80, 100%, 96.2745098039%);border:1px solid #aaaa33;border-radius:2px;pointer-events:none;z-index:100;}#mermaid-svg-ROYIiLKf18x3TnZN :root{--mermaid-font-family:\"trebuchet ms\",verdana,arial,sans-serif;}#mermaid-svg-ROYIiLKf18x3TnZN .client>*{fill:#FF6347!important;stroke:#8B0000!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .client span{fill:#FF6347!important;stroke:#8B0000!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .service>*{fill:#FFA500!important;stroke:#FF4500!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .service span{fill:#FFA500!important;stroke:#FF4500!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .aop>*{fill:#1E90FF!important;stroke:#0000CD!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .aop span{fill:#1E90FF!important;stroke:#0000CD!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .txManager>*{fill:#32CD32!important;stroke:#006400!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .txManager span{fill:#32CD32!important;stroke:#006400!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .dao>*{fill:#FFA500!important;stroke:#FF4500!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .dao span{fill:#FFA500!important;stroke:#FF4500!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .datasource>*{fill:#9932CC!important;stroke:#4B0082!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .datasource span{fill:#9932CC!important;stroke:#4B0082!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .database>*{fill:#FF1493!important;stroke:#8B0000!important;stroke-width:2px!important;}#mermaid-svg-ROYIiLKf18x3TnZN .database span{fill:#FF1493!important;stroke:#8B0000!important;stroke-width:2px!important;} 客户端应用服务层 Spring AOP 事务管理器数据源数据库 DAO层

图8：Spring事务架构图 - 展示了Spring事务管理的整体架构和数据流向

8. 总结与展望

在这篇文章中，我们深入探讨了Spring事务管理的方方面面，从基本概念到高级特性，从常见问题到最佳实践。作为一名后端开发者，我深知事务管理对于构建可靠、健壮的企业应用的重要性。

通过合理使用Spring提供的事务管理机制，我们可以确保数据的一致性和完整性，同时提高系统的性能和可维护性。在实际项目中，我们需要根据具体的业务场景选择合适的事务传播行为和隔离级别，设计合理的事务边界，并正确处理事务中的异常。

随着微服务架构的普及，分布式事务管理变得越来越重要。虽然Spring本身不直接提供分布式事务的解决方案，但它可以与其他框架（如Seata、Atomikos）结合使用，实现跨服务的事务管理。在未来的文章中，我将探讨如何在微服务架构中实现可靠的分布式事务。

希望这篇文章能够帮助你更好地理解和应用Spring事务管理，构建出更加可靠、高效的企业应用。如果你有任何问题或建议，欢迎在评论区留言交流。

🌟 我是励志成为糕手，感谢你与我共度这段技术时光！
✨ 如果这篇文章为你带来了启发：
✅ 【收藏】关键知识点，打造你的技术武器库
💡【评论】留下思考轨迹，与同行者碰撞智慧火花
🚀 【关注】持续获取前沿技术解析与实战干货
🌌 技术探索永无止境，让我们继续在代码的宇宙中：
• 用优雅的算法绘制星图
• 以严谨的逻辑搭建桥梁
• 让创新的思维照亮前路
📡 保持连接，我们下次太空见！

参考链接

Spring Framework官方文档 - 事务管理
MySQL事务隔离级别详解
Spring事务管理最佳实践
深入理解Spring事务传播行为
Spring Boot中的事务管理

关键词标签

#Spring事务 #事务管理 #ACID #传播行为 #隔离级别

企业级Spring事务管理：从单体应用到微服务分布式事务完整方案