当前位置：首页 > news >正文

Spring 事务管理详解：保障数据一致性的实践指南

news 2025/9/21 5:58:26

一、事务概述：什么是事务及其 ACID 特性

在数据库操作中，事务（Transaction）是一组不可分割的操作单元，这些操作要么全部成功执行，要么全部失败回滚，从而保证数据的一致性。

事务的核心特性可以用 ACID 来概括：

原子性（Atomicity）：事务中的所有操作要么全部完成，要么全部不完成，不会处于中间状态
一致性（Consistency）：事务执行前后，数据库从一个一致状态转变为另一个一致状态
隔离性（Isolation）：多个事务并发执行时，彼此之间不会相互干扰
持久性（Durability）：事务一旦提交，其修改会永久保存到数据库中

在企业级应用中，事务管理至关重要。例如：

转账操作：扣除转出账户金额和增加转入账户金额必须同时成功或同时失败
订单创建：创建订单和扣减库存必须作为一个整体操作
数据同步：多个表的更新必须保持一致

Spring 提供了强大的事务管理支持，简化了传统 JDBC 或 EJB 事务管理的复杂性，本文将深入探讨 Spring 事务管理的实现方式和最佳实践。

二、Spring 事务管理的两种方式：编程式与声明式

Spring 支持两种事务管理方式：编程式事务管理和声明式事务管理。

2.1 编程式事务管理

编程式事务管理通过编写代码手动控制事务的开始、提交和回滚，灵活性高但侵入性强。

2.1.1 使用 TransactionTemplate

java

运行

@Service
public class OrderService {@Autowiredprivate JdbcTemplate jdbcTemplate;@Autowiredprivate TransactionTemplate transactionTemplate;public void createOrder(Order order) {// 使用TransactionTemplate执行事务transactionTemplate.execute(new TransactionCallbackWithoutResult() {@Overrideprotected void doInTransactionWithoutResult(TransactionStatus status) {try {// 插入订单jdbcTemplate.update("INSERT INTO orders(id, user_id, amount) VALUES(?, ?, ?)",order.getId(), order.getUserId(), order.getAmount());// 扣减库存jdbcTemplate.update("UPDATE products SET stock = stock - ? WHERE id = ?",order.getProductId(), order.getQuantity());// 如果有异常会自动回滚} catch (Exception e) {// 手动标记回滚（可选，异常会触发自动回滚）status.setRollbackOnly();throw new RuntimeException("创建订单失败", e);}}});}
}

2.1.2 直接使用 PlatformTransactionManager

java

运行

@Service
public class PaymentService {@Autowiredprivate JdbcTemplate jdbcTemplate;@Autowiredprivate PlatformTransactionManager transactionManager;public void processPayment(Payment payment) {// 定义事务属性DefaultTransactionDefinition def = new DefaultTransactionDefinition();def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);// 获取事务状态TransactionStatus status = transactionManager.getTransaction(def);try {// 执行数据库操作jdbcTemplate.update("INSERT INTO payments(id, order_id, amount) VALUES(?, ?, ?)",payment.getId(), payment.getOrderId(), payment.getAmount());jdbcTemplate.update("UPDATE orders SET status = 'PAID' WHERE id = ?",payment.getOrderId());// 提交事务transactionManager.commit(status);} catch (Exception e) {// 回滚事务transactionManager.rollback(status);throw new RuntimeException("处理支付失败", e);}}
}

2.2 声明式事务管理

声明式事务管理通过注解或 XML 配置来管理事务，无需修改业务代码，是非侵入式的，是 Spring 推荐的事务管理方式。

2.2.1 基于注解的声明式事务

启用事务注解支持：

java

运行

@Configuration
@EnableTransactionManagement // 启用注解式事务管理
public class AppConfig {// 配置数据源@Beanpublic DataSource dataSource() {DriverManagerDataSource dataSource = new DriverManagerDataSource();dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/test");dataSource.setUsername("root");dataSource.setPassword("root");return dataSource;}// 配置事务管理器@Beanpublic PlatformTransactionManager transactionManager(DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}
}

在服务方法上使用 @Transactional 注解：

java

运行

@Service
public class OrderService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate ProductDao productDao;// 声明式事务@Transactional(rollbackFor = Exception.class)public void createOrder(Order order) {// 插入订单orderDao.insert(order);// 扣减库存int rows = productDao.decreaseStock(order.getProductId(), order.getQuantity());// 检查库存是否充足if (rows == 0) {throw new InsufficientStockException("库存不足");}}
}

2.2.2 基于 XML 的声明式事务

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx.xsd"><!-- 数据源 --><bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/test"/><property name="username" value="root"/><property name="password" value="root"/></bean><!-- 事务管理器 --><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><!-- 事务通知 --><tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><!-- 匹配所有以create、update、delete开头的方法 --><tx:method name="create*" propagation="REQUIRED" rollback-for="Exception"/><tx:method name="update*" propagation="REQUIRED" rollback-for="Exception"/><tx:method name="delete*" propagation="REQUIRED" rollback-for="Exception"/><!-- 查询方法使用只读事务 --><tx:method name="get*" propagation="SUPPORTS" read-only="true"/><tx:method name="find*" propagation="SUPPORTS" read-only="true"/></tx:attributes></tx:advice><!-- AOP配置，将事务通知应用到服务层 --><aop:config><aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/></aop:config>
</beans>

2.3 两种方式的对比

事务管理方式	优点	缺点	适用场景
编程式	灵活性高，可精确控制事务	侵入性强，代码冗余	复杂的事务控制场景
声明式	非侵入式，配置简单，易维护	灵活性稍差	大多数常规业务场景

最佳实践：优先使用声明式事务管理，仅在必要时使用编程式事务管理。

三、事务属性详解：传播行为、隔离级别与超时设置

Spring 事务提供了丰富的属性配置，允许开发者根据业务需求定制事务行为。

3.1 事务传播行为

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

REQUIRED（默认）：如果当前存在事务，则加入该事务；如果不存在，则创建新事务
SUPPORTS：如果当前存在事务，则加入该事务；如果不存在，则以非事务方式执行
MANDATORY：如果当前存在事务，则加入该事务；如果不存在，则抛出异常
REQUIRES_NEW：创建新事务，如果当前存在事务，则将当前事务挂起
NOT_SUPPORTED：以非事务方式执行，如果当前存在事务，则将当前事务挂起
NEVER：以非事务方式执行，如果当前存在事务，则抛出异常
NESTED：如果当前存在事务，则在嵌套事务中执行；如果不存在，则创建新事务

传播行为示例：

java

运行

@Service
public class OrderService {@Autowiredprivate PaymentService paymentService;@Transactional(propagation = Propagation.REQUIRED)public void createOrder(Order order) {// 保存订单（在当前事务中）saveOrder(order);// 调用支付服务// REQUIRES_NEW会创建新事务，与当前事务独立paymentService.processPayment(order.getId(), order.getAmount());}
}@Service
public class PaymentService {@Transactional(propagation = Propagation.REQUIRES_NEW)public void processPayment(Long orderId, BigDecimal amount) {// 处理支付（在新事务中）}
}

3.2 事务隔离级别

事务隔离级别定义了多个并发事务之间的隔离程度，解决并发带来的脏读、不可重复读和幻读问题。

Spring 支持 5 种隔离级别：

DEFAULT（默认）：使用数据库默认的隔离级别
READ_UNCOMMITTED：最低隔离级别，允许读取未提交的数据，可能导致脏读、不可重复读和幻读
READ_COMMITTED：允许读取已提交的数据，防止脏读，但可能出现不可重复读和幻读
REPEATABLE_READ：保证多次读取同一数据结果一致，防止脏读和不可重复读，但可能出现幻读
SERIALIZABLE：最高隔离级别，完全隔离事务，防止所有并发问题，但性能最差

隔离级别示例：

java

运行

@Service
public class InventoryService {// 使用READ_COMMITTED隔离级别@Transactional(isolation = Isolation.READ_COMMITTED)public int checkStock(Long productId) {// 检查库存return jdbcTemplate.queryForObject("SELECT stock FROM products WHERE id = ?",Integer.class,productId);}
}

不同数据库的默认隔离级别：

MySQL：REPEATABLE_READ
Oracle：READ_COMMITTED
SQL Server：READ_COMMITTED

3.3 其他事务属性

只读（readOnly）：

设置为true表示事务只读，可提高查询性能
适用于只执行查询操作的方法

java

运行

@Transactional(readOnly = true)
public List<Order> getUserOrders(Long userId) {// 只查询，不修改数据return orderDao.findByUserId(userId);
}

超时时间（timeout）：
- 事务超时时间（秒），超过时间未完成则自动回滚
- 防止长事务占用资源
java
运行
```
@Transactional(timeout = 30) // 30秒超时
public void batchProcess() {// 执行批量处理
}
```

回滚规则（rollbackFor/noRollbackFor）：

指定哪些异常会触发回滚或不触发回滚
默认情况下，RuntimeException 和 Error 会触发回滚，checked 异常不会

java

运行

// 所有Exception及其子类都会触发回滚
@Transactional(rollbackFor = Exception.class)
public void processOrder() {// 业务逻辑
}// 除了BusinessException外的异常会触发回滚
@Transactional(noRollbackFor = BusinessException.class)
public void updateStatus() {// 业务逻辑
}

四、Spring 事务的实现原理：AOP 与动态代理

Spring 事务管理基于 AOP 实现，通过动态代理为目标方法添加事务控制逻辑。其核心流程如下：

代理对象创建：Spring 为带有@Transactional注解的 Bean 创建代理对象
事务拦截：当调用代理对象的方法时，AOP 拦截器介入
事务创建：根据事务属性（传播行为、隔离级别等）创建或加入事务
方法执行：调用目标方法的业务逻辑
事务处理：
- 如果方法正常执行，根据事务属性提交事务
- 如果方法抛出异常，根据回滚规则决定是否回滚事务

4.1 事务拦截器的工作流程

Spring 事务的核心拦截器是TransactionInterceptor，其工作流程如下：

plaintext

调用方法 → TransactionInterceptor.invoke() → 1. 获取事务属性 → 2. 确定事务管理器 → 3. 根据传播行为处理事务 → 4. 调用目标方法 → 5. 根据执行结果提交或回滚 → 
返回结果

4.2 自调用问题及解决方案

Spring 事务基于动态代理实现，因此存在 "自调用" 问题：当一个事务方法调用同一个类中的另一个事务方法时，事务注解不会生效。

问题示例：

java

运行

@Service
public class OrderService {@Transactionalpublic void createOrder(Order order) {// 保存订单saveOrder(order);// 自调用，updateOrderStatus的事务注解不会生效updateOrderStatus(order.getId(), "PENDING");}@Transactional(propagation = Propagation.REQUIRES_NEW)public void updateOrderStatus(Long orderId, String status) {// 更新订单状态}
}

解决方案：

注入自身 Bean：

java

运行

@Service
public class OrderService {// 注入自身代理对象@Autowiredprivate OrderService self;@Transactionalpublic void createOrder(Order order) {saveOrder(order);// 通过代理对象调用，事务生效self.updateOrderStatus(order.getId(), "PENDING");}@Transactional(propagation = Propagation.REQUIRES_NEW)public void updateOrderStatus(Long orderId, String status) {// 更新订单状态}
}

使用 AopContext 获取当前代理：

java

运行

@Service
public class OrderService {@Transactionalpublic void createOrder(Order order) {saveOrder(order);// 获取当前代理对象OrderService proxy = (OrderService) AopContext.currentProxy();proxy.updateOrderStatus(order.getId(), "PENDING");}@Transactional(propagation = Propagation.REQUIRES_NEW)public void updateOrderStatus(Long orderId, String status) {// 更新订单状态}
}// 需要在配置类中启用暴露代理
@EnableAspectJAutoProxy(exposeProxy = true)

重构代码：将方法拆分到不同的类中

五、事务实战：常见场景与解决方案

5.1 批量操作事务管理

处理大量数据时，需要控制事务粒度，避免长事务：

java

运行

@Service
public class BatchService {@Autowiredprivate UserDao userDao;@Autowiredprivate PlatformTransactionManager transactionManager;public void batchImport(List<User> users, int batchSize) {// 分批次处理for (int i = 0; i < users.size(); i += batchSize) {int end = Math.min(i + batchSize, users.size());List<User> batch = users.subList(i, end);// 每批数据使用独立事务DefaultTransactionDefinition def = new DefaultTransactionDefinition();TransactionStatus status = transactionManager.getTransaction(def);try {userDao.batchInsert(batch);transactionManager.commit(status);System.out.println("成功导入第" + (i/batchSize + 1) + "批数据");} catch (Exception e) {transactionManager.rollback(status);System.err.println("第" + (i/batchSize + 1) + "批数据导入失败：" + e.getMessage());// 可以选择继续处理下一批或终止}}}
}

5.2 分布式事务处理

在分布式系统中，跨多个数据库的事务需要特殊处理。Spring 提供了JtaTransactionManager支持分布式事务：

java

运行

@Configuration
@EnableTransactionManagement
public class JtaConfig {@Beanpublic JtaTransactionManager transactionManager() {return new JtaTransactionManager();}
}@Service
public class DistributedService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate InventoryDao inventoryDao;// 分布式事务@Transactionalpublic void processCrossDbOperation(Order order) {// 操作数据库1orderDao.insert(order);// 操作数据库2inventoryDao.decreaseStock(order.getProductId(), order.getQuantity());}
}

对于复杂的分布式事务，可考虑使用：

Seata：阿里开源的分布式事务解决方案
Hmily：基于 TCC 模式的分布式事务框架
Saga 模式：长事务解决方案

5.3 事务与缓存的协同

事务与缓存结合时，需要确保数据一致性：

java

运行

@Service
public class ProductService {@Autowiredprivate ProductDao productDao;@Autowiredprivate RedisTemplate<String, Product> redisTemplate;// 查询方法使用缓存@Transactional(readOnly = true)public Product getProduct(Long id) {String key = "product:" + id;// 先查缓存Product product = redisTemplate.opsForValue().get(key);if (product != null) {return product;}// 缓存未命中，查数据库product = productDao.findById(id);if (product != null) {// 放入缓存redisTemplate.opsForValue().set(key, product, 30, TimeUnit.MINUTES);}return product;}// 更新方法更新数据库并清除缓存@Transactionalpublic void updateProduct(Product product) {productDao.update(product);// 清除缓存redisTemplate.delete("product:" + product.getId());}
}

5.4 事务与异步方法

异步方法默认不会参与当前事务，需要特殊处理：

java

运行

@Service
public class OrderService {@Autowiredprivate OrderDao orderDao;@Autowiredprivate AsyncService asyncService;@Transactionalpublic void createOrder(Order order) {// 保存订单orderDao.insert(order);// 同步获取订单ID（已生成）Long orderId = order.getId();// 调用异步方法，传递订单IDasyncService.sendOrderNotification(orderId);}
}@Service
public class AsyncService {@Autowiredprivate NotificationDao notificationDao;@Asyncpublic void sendOrderNotification(Long orderId) {// 使用新的事务处理异步操作saveNotification(orderId);}@Transactionalpublic void saveNotification(Long orderId) {notificationDao.insert(new Notification(orderId, "订单创建成功"));}
}

六、事务常见问题与解决方案

6.1 事务不回滚的常见原因

异常被捕获但未重新抛出：

java

运行

@Transactional
public void createOrder(Order order) {try {// 业务逻辑} catch (Exception e) {// 只记录日志，未重新抛出异常，事务不会回滚log.error("错误", e);}
}// 正确做法：
@Transactional
public void createOrder(Order order) {try {// 业务逻辑} catch (Exception e) {log.error("错误", e);throw e; // 重新抛出异常}
}

抛出的异常不是 rollbackFor 指定的异常类型：

java

运行

// 默认只回滚RuntimeException， checked异常不会回滚
@Transactional
public void createOrder(Order order) throws IOException {throw new IOException("IO错误"); // 不会回滚
}// 正确做法：指定rollbackFor
@Transactional(rollbackFor = Exception.class)
public void createOrder(Order order) throws IOException {throw new IOException("IO错误"); // 会回滚
}

方法不是 public 的：

java

运行

// 非public方法的事务注解不生效
@Transactional
void createOrder(Order order) {// 业务逻辑
}// 正确做法：使用public方法
@Transactional
public void createOrder(Order order) {// 业务逻辑
}

自调用问题：如前所述，同一类中方法调用不会触发事务拦截器。
数据源未配置事务管理器：确保已配置与数据源对应的事务管理器。

6.2 事务传播行为误用

最常见的是对REQUIRED和REQUIRES_NEW的误用：

java

运行

@Service
public class PaymentService {@Autowiredprivate LogService logService;@Transactionalpublic void processPayment(Payment payment) {// 处理支付savePayment(payment);// 如果logService的方法使用REQUIRES_NEW// 即使当前事务回滚，日志也会被保存logService.logPayment(payment.getId());}
}@Service
public class LogService {// 使用REQUIRES_NEW确保日志一定会被记录@Transactional(propagation = Propagation.REQUIRES_NEW)public void logPayment(Long paymentId) {saveLog(paymentId, "支付处理中");}
}

6.3 长事务问题

长事务会导致数据库连接长时间被占用，可能引发性能问题和死锁：

解决方案：

拆分长事务为多个短事务
减少事务中的操作，只保留必要的数据库操作
非核心操作使用异步处理
合理设置事务超时时间

java

运行

// 优化前：长事务
@Transactional
public void complexOperation(Order order) {saveOrder(order);callExternalSystem(order); // 耗时的外部调用updateInventory(order);sendNotifications(order); // 耗时的通知
}// 优化后：拆分事务
@Transactional
public void createOrder(Order order) {saveOrder(order);updateInventory(order);
}// 异步处理非核心操作
@Async
public void processNonCriticalOperations(Order order) {callExternalSystem(order);sendNotifications(order);
}

七、事务最佳实践

最小化事务范围：
- 只在必要的方法上添加事务注解
- 事务中只包含必要的数据库操作
- 避免在事务中进行耗时操作（如 IO、网络请求）
合理选择传播行为：
- 大多数情况使用默认的 REQUIRED
- 需要独立事务时使用 REQUIRES_NEW
- 只读操作使用 SUPPORTS 并设置 readOnly=true
明确指定回滚规则：
- 建议显式指定 rollbackFor = Exception.class
- 避免依赖默认的回滚规则
正确处理异常：
- 事务方法中捕获异常后要重新抛出
- 区分业务异常和系统异常，合理设置回滚规则
优化事务性能：
- 对只读操作设置 readOnly=true
- 合理设置事务超时时间
- 避免长事务，拆分复杂事务
测试事务行为：
- 编写专门的测试用例验证事务回滚
- 测试并发场景下的事务行为
- 验证事务隔离级别是否符合预期
监控事务性能：
- 监控长事务和频繁回滚的事务
- 分析事务相关的锁等待问题
- 跟踪事务超时情况