Spring Boot事务管理进阶：自动回滚、手动控制与部分回滚-代码聚汇网

1. Spring Boot事务操作全景解析

在Java企业级应用开发中，事务管理是保证数据一致性的核心机制。Spring Boot通过@Transactional注解提供了声明式事务管理能力，但实际业务场景往往需要更精细的控制。本文将深入剖析三种典型事务处理模式：自动回滚的标准用法、需要人工干预的手动回滚，以及业务逻辑中常见的部分回滚场景。

从事务的ACID特性来看，Spring Boot默认在运行时异常(RuntimeException)和错误(Error)发生时自动触发回滚，这是大多数开发者最熟悉的基础用法。但在支付系统、订单处理等业务场景中，我们经常需要：

在捕获异常后仍保持事务活性
根据业务规则判断是否回滚
只回滚部分数据变更而保留其他操作

下面通过代码实例演示这些进阶用法，所有示例基于Spring Boot 3.1+和Spring Framework 6.0+版本，数据库使用MySQL 8.0（InnoDB引擎），完整代码可直接集成到现有项目中。

2. 自动回滚的标准实现

2.1 基础配置与注解用法

首先确保项目已包含必要依赖：

xml复制<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>com.mysql</groupId>
    <artifactId>mysql-connector-j</artifactId>
    <scope>runtime</scope>
</dependency>

在application.yml中配置事务管理器：

yaml复制spring:
  datasource:
    url: jdbc:mysql://localhost:3306/tx_demo
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

标准的事务方法示例：

java复制@Service
@RequiredArgsConstructor
public class OrderService {
    private final OrderRepository orderRepo;
    private final InventoryRepository inventoryRepo;

    @Transactional
    public void createOrder(OrderDTO dto) {
        // 扣减库存
        inventoryRepo.reduceStock(dto.getProductId(), dto.getQuantity());
        
        // 创建订单
        Order order = new Order();
        order.setProductId(dto.getProductId());
        order.setAmount(dto.getQuantity());
        orderRepo.save(order);
        
        // 模拟业务异常
        if (order.getAmount() > 100) {
            throw new BusinessException("单笔订单不能超过100件");
        }
    }
}

2.2 自动回滚的触发条件

Spring默认在以下情况自动回滚事务：

方法抛出未捕获的RuntimeException或Error
方法标记了@Transactional(rollbackFor=特定异常类)
方法未标记@Transactional但被其他事务方法调用（传播行为起作用）

关键细节：检查型异常（如IOException）默认不会触发回滚，需要通过rollbackFor显式指定

2.3 事务传播行为实战

七种传播行为的实际效果对比：

传播行为类型	外部存在事务	外部无事务	适用场景
REQUIRED	加入当前事务	新建事务	普通增删改
REQUIRES_NEW	挂起外部事务新建	新建事务	独立日志记录
NESTED	创建保存点	新建事务	部分回滚场景
SUPPORTS	加入当前事务	非事务执行	查询方法
NOT_SUPPORTED	挂起外部事务	非事务执行	非核心操作
NEVER	抛出异常	非事务执行	强制非事务
MANDATORY	加入当前事务	抛出异常	强制事务环境

典型嵌套事务示例：

java复制@Transactional(propagation = Propagation.REQUIRED)
public void parentMethod() {
    // 操作A
    childMethod(); // 内部方法使用REQUIRES_NEW
    // 操作B
}

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void childMethod() {
    // 独立事务操作
}

3. 手动回滚的精细控制

3.1 TransactionAspectSupport用法

当需要在捕获异常后仍决定回滚时：

java复制@Transactional
public void manualRollbackDemo(OrderDTO dto) {
    try {
        inventoryRepo.reduceStock(dto.getProductId(), dto.getQuantity());
        createOrder(dto);
    } catch (BusinessException e) {
        // 记录异常日志
        log.error("业务异常发生，执行回滚", e);
        // 手动触发回滚
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

3.2 编程式事务管理

对于复杂事务边界控制，可使用TransactionTemplate：

java复制@Service
@RequiredArgsConstructor
public class ComplexTransactionService {
    private final TransactionTemplate transactionTemplate;
    private final OrderRepository orderRepo;

    public void executeWithTemplate(OrderDTO dto) {
        transactionTemplate.execute(status -> {
            try {
                // 业务操作1
                orderRepo.save(convertToEntity(dto));
                
                // 业务操作2
                if (checkSomeCondition()) {
                    status.setRollbackOnly();
                    return "Condition failed";
                }
                
                return "Success";
            } catch (Exception e) {
                status.setRollbackOnly();
                throw e;
            }
        });
    }
}

3.3 事务同步管理器实战

获取当前事务状态进行精细控制：

java复制@Transactional
public void syncManagerDemo() {
    TransactionStatus status = TransactionSynchronizationManager.getCurrentTransactionStatus();
    
    if (status.isNewTransaction()) {
        // 新建事务的特殊处理
    }
    
    status.setRollbackOnly(); // 等价于@Transactional注解方式
}

4. 部分回滚的高级技巧

4.1 保存点(Savepoint)实现

利用JDBC保存点实现区块回滚：

java复制@Transactional
public void partialRollback(OrderDTO dto) {
    // 获取JDBC连接
    Connection conn = DataSourceUtils.getConnection(
            entityManager.unwrap(SessionImpl.class).connectionProvider().getConnection());
    
    Savepoint savepoint = null;
    try {
        // 操作1（必须成功）
        inventoryRepo.reduceStock(dto.getProductId(), dto.getQuantity());
        
        // 设置保存点
        savepoint = conn.setSavepoint();
        
        // 操作2（可能失败）
        applyDiscount(dto); 
        
    } catch (DiscountException e) {
        if (savepoint != null) {
            conn.rollback(savepoint); // 仅回滚到保存点
        }
        // 继续执行其他操作
        createOrderWithoutDiscount(dto);
    }
}

4.2 多数据源部分回滚

跨库事务处理方案：

java复制public void multiDataSourceTx(OrderDTO dto) {
    // 主库事务
    transactionTemplateForPrimary.execute(status1 -> {
        // 操作主库
        primaryRepo.save(convertToEntity(dto));
        
        try {
            // 从库事务（独立事务）
            transactionTemplateForSecondary.execute(status2 -> {
                secondaryRepo.saveLog(genLog(dto));
                return null;
            });
        } catch (Exception e) {
            // 从库异常不影响主库
            log.error("从库操作失败", e);
        }
        
        return null;
    });
}

4.3 补偿事务模式

最终一致性实现示例：

java复制public void compensateTransaction(OrderDTO dto) {
    try {
        // 第一阶段：尝试执行业务
        orderService.tryCreateOrder(dto);
        
        // 第二阶段：确认操作
        inventoryService.confirmReduce(dto.getProductId());
    } catch (Exception e) {
        // 执行补偿操作
        inventoryService.cancelReduce(dto.getProductId());
        throw e;
    }
}

5. 生产环境实战经验

5.1 事务失效的八大场景

方法自调用：

java复制public void selfInvoke() {
    createOrder(); // 内部调用不会触发事务
}

@Transactional
public void createOrder() {...}

解决方案：

使用AopContext.currentProxy()
将方法拆分到不同类

异常类型不匹配：

java复制@Transactional(rollbackFor = WrongException.class)
public void willNotRollback() {
    throw new OtherException(); // 不会触发回滚
}

非public方法：

java复制@Transactional
private void privateMethod() {...} // 事务无效

数据库引擎不支持：

MyISAM表不支持事务
需确认使用InnoDB

传播行为配置错误：

java复制@Transactional(propagation = Propagation.NOT_SUPPORTED)
public void notTransactional() {...}

多线程调用：

事务上下文绑定到线程
新线程中无事务环境

未启用事务管理：
忘记添加@EnableTransactionManagement
异常被捕获未抛出：

java复制@Transactional
public void noRollback() {
    try {
        failOperation();
    } catch (Exception e) {
        // 未重新抛出
    }
}

5.2 性能优化技巧

事务隔离级别选择：

java复制@Transactional(isolation = Isolation.READ_COMMITTED)
public void readCommittedTx() {...}

只读事务优化：

java复制@Transactional(readOnly = true)
public List<Order> queryOrders() {...}

超时设置：

java复制@Transactional(timeout = 30) // 单位：秒
public void longRunningTx() {...}

批量操作处理：

java复制@Transactional
public void batchInsert(List<Order> orders) {
    for (Order order : orders) {
        entityManager.persist(order);
        if (i % 50 == 0) {
            entityManager.flush();
            entityManager.clear();
        }
    }
}

5.3 监控与排查方案

开启事务日志：

yaml复制logging:
  level:
    org.springframework.transaction: DEBUG
    org.springframework.orm.jpa: DEBUG

使用Actuator端点：

code复制/actuator/transactions

诊断长时间运行事务：

sql复制-- MySQL查询未提交事务
SELECT * FROM information_schema.innodb_trx 
WHERE TIME_TO_SEC(TIMEDIFF(NOW(), trx_started)) > 60;

死锁分析：

sql复制SHOW ENGINE INNODB STATUS;

6. 分布式事务整合方案

6.1 Seata集成配置

添加依赖：

xml复制<dependency>
    <groupId>io.seata</groupId>
    <artifactId>seata-spring-boot-starter</artifactId>
    <version>1.7.1</version>
</dependency>

配置文件：

yaml复制seata:
  enabled: true
  application-id: order-service
  tx-service-group: my_tx_group
  service:
    vgroup-mapping:
      my_tx_group: default
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848

全局事务使用：

java复制@GlobalTransactional
public void crossServiceTx() {
    orderService.create();
    inventoryService.reduce();
    accountService.debit();
}

6.2 消息队列最终一致

基于RocketMQ的实现：

java复制public void mqTransaction(OrderDTO dto) {
    // 1. 发送预备消息
    TransactionSendResult sendResult = rocketMQTemplate.sendMessageInTransaction(
        "order-topic",
        MessageBuilder.withPayload(dto).build(),
        null
    );
    
    // 2. 执行本地事务
    if (executeLocalTransaction(dto, sendResult.getMsgId())) {
        // 3. 提交消息
        rocketMQTemplate.sendOneWay("commit-topic", buildCommitMsg(dto));
    } else {
        // 回滚处理
        rocketMQTemplate.sendOneWay("rollback-topic", buildRollbackMsg(dto));
    }
}

6.3 SAGA模式实践

使用Axon Framework实现：

java复制@Saga
public class OrderProcessingSaga {
    
    @StartSaga
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(OrderCreatedEvent event) {
        // 1. 扣减库存
        commandGateway.send(new ReduceStockCommand(
            event.getProductId(), 
            event.getQuantity()
        ));
    }
    
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(StockReducedEvent event) {
        // 2. 扣款
        commandGateway.send(new DebitAccountCommand(
            event.getUserId(),
            event.getAmount()
        ));
    }
    
    @EndSaga
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(PaymentCompletedEvent event) {
        // 完成处理
    }
    
    @SagaEventHandler(associationProperty = "orderId")
    public void handle(StockReduceFailedEvent event) {
        // 补偿逻辑
        commandGateway.send(new CancelOrderCommand(event.getOrderId()));
    }
}

7. 测试策略与验证方法

7.1 单元测试方案

使用Spring Boot Test进行事务测试：

java复制@SpringBootTest
@Transactional // 测试完成后自动回滚
class OrderServiceTest {
    
    @Autowired
    private OrderService orderService;
    
    @Test
    void shouldRollbackWhenOverLimit() {
        OrderDTO dto = new OrderDTO(101);
        assertThrows(BusinessException.class, 
            () -> orderService.createOrder(dto));
        
        // 验证数据是否回滚
        assertEquals(0, orderRepository.count());
    }
}

7.2 集成测试技巧

测试事务传播行为：

java复制@Test
void testNestedTransaction() {
    TransactionTemplate outerTx = new TransactionTemplate(txManager);
    outerTx.setPropagationBehavior(PROPAGATION_REQUIRED);
    
    outerTx.execute(status -> {
        // 外层事务
        repository.save(entity1);
        
        TransactionTemplate innerTx = new TransactionTemplate(txManager);
        innerTx.setPropagationBehavior(PROPAGATION_REQUIRES_NEW);
        
        innerTx.execute(innerStatus -> {
            // 内层独立事务
            repository.save(entity2);
            return null;
        });
        
        return null;
    });
    
    // 验证事务隔离
    assertTrue(repository.existsById(entity1.getId()));
    assertTrue(repository.existsById(entity2.getId()));
}

7.3 并发测试场景

模拟并发事务冲突：

java复制@Test
void testConcurrentUpdate() throws InterruptedException {
    int threadCount = 10;
    ExecutorService executor = Executors.newFixedThreadPool(threadCount);
    CountDownLatch latch = new CountDownLatch(threadCount);
    
    for (int i = 0; i < threadCount; i++) {
        executor.execute(() -> {
            try {
                latch.await();
                service.concurrentUpdate();
            } catch (Exception e) {
                // 预期中的乐观锁异常
                assertInstanceOf(ObjectOptimisticLockingFailureException.class, e);
            }
        });
        latch.countDown();
    }
    
    executor.shutdown();
    assertTrue(executor.awaitTermination(10, TimeUnit.SECONDS));
}

8. 源码级深度解析

8.1 事务拦截器链

Spring事务拦截流程：

TransactionInterceptor.invoke()
获取TransactionAttribute（注解解析）
创建TransactionInfo（绑定到当前线程）
调用目标方法
异常处理与回滚判断
提交/回滚事务

关键源码片段：

java复制public class TransactionInterceptor extends TransactionAspectSupport 
    implements MethodInterceptor {
    
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取事务属性
        TransactionAttribute txAttr = getTransactionAttributeSource()
            .getTransactionAttribute(invocation.getMethod(), 
                invocation.getThis().getClass());
        
        // 创建事务
        TransactionInfo txInfo = createTransactionIfNecessary(txAttr, 
            invocation.getMethodQualifier());
        
        try {
            // 执行目标方法
            Object retVal = invocation.proceed();
            
            // 提交事务
            commitTransactionAfterReturning(txInfo);
            return retVal;
        } catch (Throwable ex) {
            // 异常回滚处理
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        } finally {
            cleanupTransactionInfo(txInfo);
        }
    }
}

8.2 事务管理器体系

Spring事务管理器类图：

PlatformTransactionManager（顶层接口）
- AbstractPlatformTransactionManager（抽象实现）
  - DataSourceTransactionManager（JDBC事务）
  - JpaTransactionManager（JPA事务）
  - JtaTransactionManager（分布式事务）
- ReactiveTransactionManager（响应式事务）

关键配置点：

java复制@Configuration
@EnableTransactionManagement
public class TransactionConfig {
    
    @Bean
    public PlatformTransactionManager transactionManager(
            EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
    
    @Bean
    public TransactionTemplate transactionTemplate(
            PlatformTransactionManager txManager) {
        return new TransactionTemplate(txManager);
    }
}

8.3 事务同步机制

TransactionSynchronizationManager工作原理：

使用ThreadLocal存储事务状态
关键资源绑定（如JDBC Connection）
事务同步回调注册
事务事件传播

典型应用场景：

java复制@Transactional
public void withSyncOperation() {
    // 注册同步回调
    TransactionSynchronizationManager.registerSynchronization(
        new TransactionSynchronization() {
            @Override
            public void afterCommit() {
                // 事务提交后发送消息
                kafkaTemplate.send("topic", "message");
            }
        });
    
    // 业务操作
    repository.save(entity);
}

9. 生产环境问题实录

9.1 大事务问题排查

现象：

数据库连接池被占满
事务执行时间超过30秒
出现死锁错误日志

解决方案：

拆分大事务为小批次
添加事务超时配置
优化SQL减少锁定范围
使用异步处理非核心逻辑

java复制// 改造前
@Transactional
public void bigTransaction() {
    // 处理1000条记录
}

// 改造后
public void batchProcess() {
    List<Data> chunks = partitionBigList();
    for (Data chunk : chunks) {
        smallTransaction(chunk);
    }
}

@Transactional(timeout = 5)
public void smallTransaction(Data chunk) {
    // 处理100条记录
}

9.2 跨库事务一致性问题

场景：

订单库成功
库存库失败
无补偿机制导致数据不一致

最终一致性方案：

引入事务消息表
定时任务补偿
状态机控制流程

sql复制CREATE TABLE transaction_log (
    id BIGINT PRIMARY KEY,
    biz_type VARCHAR(32),
    biz_id VARCHAR(64),
    status VARCHAR(16),
    retry_count INT,
    next_retry_time DATETIME,
    created_time DATETIME
);

9.3 事务日志优化案例

问题：

事务日志量过大
磁盘IO成为瓶颈
监控数据不准确

优化措施：

调整日志级别
添加日志过滤器
关键事务采样记录

java复制@Aspect
@Component
@Slf4j
public class TransactionLogAspect {
    
    @Pointcut("@annotation(org.springframework.transaction.annotation.Transactional)")
    public void transactionalMethod() {}
    
    @Around("transactionalMethod()")
    public Object logTransaction(ProceedingJoinPoint pjp) throws Throwable {
        long start = System.currentTimeMillis();
        String method = pjp.getSignature().toShortString();
        
        try {
            Object result = pjp.proceed();
            long cost = System.currentTimeMillis() - start;
            
            if (cost > 1000) { // 只记录慢事务
                log.warn("Slow transaction: {} cost {}ms", method, cost);
            }
            return result;
        } catch (Exception e) {
            log.error("Transaction failed: " + method, e);
            throw e;
        }
    }
}

10. 前沿技术与未来演进

10.1 响应式事务管理

Spring WebFlux中的事务处理：

java复制@Transactional
public Mono<Order> reactiveCreateOrder(OrderDTO dto) {
    return inventoryRepo.findByProductId(dto.getProductId())
        .flatMap(inventory -> {
            if (inventory.getStock() < dto.getQuantity()) {
                return Mono.error(new InsufficientStockException());
            }
            return inventoryRepo.reduceStock(dto.getProductId(), dto.getQuantity());
        })
        .then(orderRepo.save(convertToEntity(dto)));
}

10.2 云原生事务方案

Kubernetes环境下的方案：

Service Mesh实现分布式事务
使用Dapr构建事务工作流
基于Saga模式的微服务编排

10.3 无服务器架构适配

Serverless函数中的事务策略：

短生命周期函数
事件驱动补偿机制
外部状态存储方案

java复制// AWS Lambda示例
public class OrderLambda implements RequestHandler<OrderDTO, String> {
    
    @Override
    public String handleRequest(OrderDTO input, Context context) {
        // 使用独立事务连接
        try (Connection conn = getConnection()) {
            conn.setAutoCommit(false);
            
            // 业务操作
            executeBusiness(conn, input);
            
            conn.commit();
            return "Success";
        } catch (Exception e) {
            // 记录到死信队列
            sendToDLQ(input, e);
            throw e;
        }
    }
}

11. 架构设计建议

11.1 事务边界设计原则

一个事务只做一件事（单一职责）
事务执行时间控制在100ms以内
避免在事务中进行远程调用
读写分离：写事务要短，读事务可长

11.2 分布式事务选型矩阵

方案类型	一致性强度	性能影响	复杂度	适用场景
2PC/XA	强一致	高	高	银行核心系统
TCC	最终一致	中	高	电商订单
SAGA	最终一致	低	中	长业务流程
消息队列	最终一致	低	低	异步通知场景
本地消息表	最终一致	中	中	中小型分布式系统

11.3 事务监控指标体系

关键监控项：

事务成功率
平均持续时间
回滚率
死锁次数
连接等待时间

Prometheus配置示例：

yaml复制- pattern: 'spring.transaction.percentage.success'
  name: 'tx_success_rate'
  help: 'Transaction success rate'
  type: GAUGE
- pattern: 'spring.transaction.time.max'
  name: 'tx_max_duration'
  help: 'Max transaction duration'
  type: GAUGE

12. 工具链与生态整合

12.1 事务可视化工具

Arthas监控事务状态：

bash复制watch org.springframework.transaction.interceptor.TransactionInterceptor invoke '{params, returnObj, throwExp}' -x 3

SkyWalking追踪分布式事务：

skywalking-transaction-trace

12.2 压测工具集成

使用JMeter测试事务性能：

xml复制<TransactionController guiclass="TransactionControllerGui" 
    testclass="TransactionController" testname="事务测试组">
  <boolProp name="TransactionController.includeTimers">false</boolProp>
  <boolProp name="TransactionController.parent">true</boolProp>
</TransactionController>

12.3 混沌工程验证

模拟事务故障场景：

数据库连接中断
网络分区
慢SQL注入
死锁触发

ChaosBlade示例：

bash复制blade create jvm delay --time 3000 --classname=com.mysql.cj.jdbc.ConnectionImpl --methodname=commit

13. 团队协作规范

13.1 事务代码审查清单

[ ] 是否设置了合理的事务超时
[ ] 传播行为是否符合业务语义
[ ] 异常处理是否考虑回滚
[ ] 是否存在循环依赖导致代理失效
[ ] 是否在事务中进行IO操作

13.2 事务注解使用公约

java复制// 推荐写法
@Transactional(
    timeout = 30,
    isolation = Isolation.READ_COMMITTED,
    propagation = Propagation.REQUIRED,
    rollbackFor = {BusinessException.class, RuntimeException.class}
)
public void recommendedMethod() {...}

// 避免写法
@Transactional // 缺少关键配置
public void notRecommended() {...}

13.3 事务文档模板

markdown复制## 事务说明 - [功能名称]

### 事务属性
- 传播行为：REQUIRED
- 隔离级别：READ_COMMITTED  
- 超时时间：30秒
- 回滚异常：BusinessException及子类

### 参与资源
1. 主库：order表写入
2. 从库：inventory表更新

### 补偿机制
1. 库存预留30分钟自动释放
2. 订单状态标记为"已取消"
3. 消息队列通知支付系统

14. 性能调优实战

14.1 连接池优化配置

HikariCP推荐配置：

yaml复制spring:
  datasource:
    hikari:
      maximum-pool-size: 20
      minimum-idle: 5
      idle-timeout: 30000
      max-lifetime: 1800000
      connection-timeout: 30000
      transaction-isolation: TRANSACTION_READ_COMMITTED

14.2 批量操作优化

JPA批量插入优化：

java复制@Transactional
public void batchInsert(List<Order> orders) {
    EntityManager em = entityManagerFactory.createEntityManager();
    em.joinTransaction();
    
    for (int i = 0; i < orders.size(); i++) {
        em.persist(orders.get(i));
        if (i % 50 == 0) {
            em.flush();
            em.clear();
        }
    }
}

14.3 二级缓存策略

Ehcache配置示例：

java复制@Bean
public JpaCacheManager jpaCacheManager() {
    JpaCacheManager cacheManager = new JpaCacheManager();
    cacheManager.setCacheManager(ehCacheManager());
    return cacheManager;
}

@Transactional
@Cacheable(value = "orders", key = "#id")
public Order getOrderById(Long id) {
    return orderRepo.findById(id).orElse(null);
}

15. 安全合规要点

15.1 审计日志记录

事务审计实现：

java复制@Aspect
@Component
public class TransactionAuditAspect {
    
    @AfterReturning("@annotation(transactional)")
    public void auditSuccess(Transactional transactional) {
        auditLog("SUCCESS", transactional.timeout());
    }
    
    @AfterThrowing(pointcut = "@annotation(transactional)", 
                  throwing = "ex")
    public void auditFailure(Transactional transactional, Exception ex) {
        auditLog("FAILURE: " + ex.getClass().getSimpleName(), 
                transactional.timeout());
    }
    
    private void auditLog(String status, int timeout) {...}
}

15.2 敏感数据保护

事务中的加密处理：

java复制@Transactional
public void saveSensitiveData(SensitiveDTO dto) {
    // 加密处理
    dto.setIdCard(encrypt(dto.getIdCard()));
    sensitiveRepo.save(convertToEntity(dto));
    
    // 审计日志需要解密
    TransactionSynchronizationManager.registerSynchronization(
        new TransactionSynchronization() {
            public void afterCommit() {
                logAudit(decrypt(dto.getIdCard()));
            }
        });
}

15.3 合规性检查

GDPR事务处理要求：

数据修改事务记录变更前值
删除操作需要标记删除而非物理删除
事务日志脱敏处理

java复制@Transactional
public void gdprDelete(Long userId) {
    User user = userRepo.findById(userId).orElseThrow();
    user.setDeleted(true);
    user.setDeleteTime(LocalDateTime.now());
    userRepo.save(user);
    
    // 记录删除审计
    auditService.logDeletion(user);
}

16. 经典案例复盘

16.1 电商下单场景

事务流程：

库存锁定（NESTED事务）
优惠券抵扣（REQUIRES_NEW）
订单创建（主事务）
支付记录（异步处理）

异常处理：

库存不足：立即回滚
优惠券失效：继续主事务
支付超时：异步补偿

16.2 银行转账场景

严格事务要求：

借方账户扣款
贷方账户入账
交易记录生成
全部成功或全部回滚

实现方案：

java复制@GlobalTransactional(timeoutMills = 60000)
public void transfer(String from, String to, BigDecimal amount) {
    accountService.debit(from, amount);
    accountService.credit(to, amount);
    transactionService.record(from, to, amount);
}

16.3 机票预订场景

长事务挑战：

座位预留（30分钟有效期）
支付等待（15分钟超时）
最终确认

SAGA模式实现：

java复制@Saga
public class BookingSaga {
    
    @StartSaga
    @SagaEventHandler(associationProperty = "bookingId")
    public void handle(BookingCreatedEvent event) {
        // 预留座位
        seatService.reserve(event.getFlightId(), event.getSeatNo());
        
        // 设置超时
        commandGateway.schedule(
            Duration.ofMinutes(15),
            new ExpireReservationCommand(event.getBookingId())
        );
    }
    
    @SagaEventHandler(associationProperty = "bookingId")
    public void handle(PaymentReceivedEvent event) {
        // 确认预订
        seatService.confirm(event.getFlightId(), event.getSeatNo());
        // 取消超时任务
        cancelTimeout(event.getBookingId());
    }
}

17. 反模式与纠正方案

17.1 事务嵌套过深

问题代码：

java复制@Transactional
public void methodA() {
    // 操作1
    methodB(); // 又调用了5层嵌套
    // 操作2
}