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默认在以下情况自动回滚事务：

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

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

2.3 事务传播行为实战

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

典型嵌套事务示例：

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 事务失效的八大场景

1. 方法自调用：

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

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

解决方案：

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

2. 异常类型不匹配：

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

3. 非public方法：

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

4. 数据库引擎不支持：

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

5. 传播行为配置错误：

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

6. 多线程调用：

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

7. 未启用事务管理：
   忘记添加@EnableTransactionManagement

8. 异常被捕获未抛出：

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

5.2 性能优化技巧

1. 事务隔离级别选择：

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

2. 只读事务优化：

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

3. 超时设置：

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

4. 批量操作处理：

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 监控与排查方案

1. 开启事务日志：

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

2. 使用Actuator端点：

code复制/actuator/transactions

3. 诊断长时间运行事务：

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

4. 死锁分析：

sql复制SHOW ENGINE INNODB STATUS;

6. 分布式事务整合方案

6.1 Seata集成配置

1. 添加依赖：

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

2. 配置文件：

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

3. 全局事务使用：

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事务拦截流程：

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

关键源码片段：

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事务管理器类图：

1. 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工作原理：

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

典型应用场景：

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

9. 生产环境问题实录

9.1 大事务问题排查

现象：

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

解决方案：

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

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 跨库事务一致性问题

场景：

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

最终一致性方案：

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

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成为瓶颈
• 监控数据不准确

优化措施：

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

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环境下的方案：

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

10.3 无服务器架构适配

Serverless函数中的事务策略：

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

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 事务边界设计原则

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

11.2 分布式事务选型矩阵

11.3 事务监控指标体系

关键监控项：

1. 事务成功率
2. 平均持续时间
3. 回滚率
4. 死锁次数
5. 连接等待时间

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 事务可视化工具

1. Arthas监控事务状态：

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

2. SkyWalking追踪分布式事务：

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 混沌工程验证

模拟事务故障场景：

1. 数据库连接中断
2. 网络分区
3. 慢SQL注入
4. 死锁触发

ChaosBlade示例：

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

13. 团队协作规范

13.1 事务代码审查清单

1. [ ] 是否设置了合理的事务超时
2. [ ] 传播行为是否符合业务语义
3. [ ] 异常处理是否考虑回滚
4. [ ] 是否存在循环依赖导致代理失效
5. [ ] 是否在事务中进行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事务处理要求：

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

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 电商下单场景

事务流程：

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

异常处理：

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

16.2 银行转账场景

严格事务要求：

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

实现方案：

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 机票预订场景

长事务挑战：

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

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
}

解决方案：

1. 重构为扁平结构
2. 使用消息队列解耦
3. 拆分事务边界

17.2 事务中远程调用

错误示范：

java复制@Transactional
public void placeOrder(OrderDTO dto) {
    // 本地数据库操作
    orderRepo.save(dto);
    
    // 同步调用支付系统（危险！）
    paymentClient.process(dto); 
}

改进方案：

1. 改为异步消息
2. 使用TCC模式
3. 添加熔断机制

17.3 过度使用声明式事务

问题现象：

• 所有方法都加@Transactional
• 查询方法也开启事务
• 传播行为随意设置

优化建议：

1. 明确事务使用场景
2. 查询方法使用SUPPORTS或只读事务
3. 建立团队事务使用规范

18. 版本升级指南

18.1 Spring Boot 2.x → 3.x

事务相关变更：

1. Jakarta EE 9+命名空间
2. 移除Hibernate 5支持
3. 默认事务隔离级别调整

迁移示例：

java复制// 旧版
import javax.transaction.Transactional;

// 新版
import jakarta.transaction.Transactional;

18.2 MySQL 5.7 → 8.0

事务增强特性：

1. 原子DDL支持
2. 性能模式事务表
3. 锁等待超时优化

配置调整：

yaml复制spring:
  datasource:
    url: jdbc:mysql://localhost:3306/db?useSSL=false&allowPublicKeyRetrieval=true
    hikari:
      isolation-level: TRANSACTION_REPEATABLE_READ

18.3 Java 11 → 17

模块化事务管理：

module-info.java复制requires spring.transaction;
requires spring.context;
requires java.sql;

19. 跨语言事务方案

19.1 与Node.js集成

使用TypeORM实现：

typescript复制@Transaction()
async createOrder(dto: OrderDTO) {
    await this.inventoryRepo.reduceStock(dto);
    const order = this.orderRepo.create(dto);
    return this.orderRepo.save(order);
}

19.2 Python服务协调

Django事务示例：

python复制from django.db import transaction

@transaction.atomic
def transfer_funds(from_acc, to_acc, amount):
    from_acc.balance -= amount
    from_acc.save()
    
    to_acc.balance += amount
    to_acc.save()

19.3 Go微服务事务

使用dtm实现SAGA：

go复制func sagaAdjustBalance() {
    saga := dtmcli.NewSaga(dtmServer, dtmcli.MustGenGid(dtmServer)).
        Add(busi+"/TransOut", busi+"/TransOutCompensate", req).
        Add(busi+"/TransIn", busi+"/TransInCompensate", req)
    saga.Submit()
}

20. 扩展阅读与资源

20.1 推荐书籍

1. 《Java事务设计策略》- Mark Richards
2. 《Spring实战（第6版）》- Craig Walls
3. 《分布式服务架构：原理、设计与实战》- 李艳鹏

20.2 开源项目参考

1. Seata: https://github.com/seata/seata
2. DTM: https://github.com/dtm-labs/dtm
3. Eventuate Tram: https://github.com/eventuate-tram/eventuate-tram-core

20.3 在线实验环境

1. Katacoda Spring Boot教程: https://www.katacoda.com/spring
2. GitHub Codespaces模板: https://github.com/spring-guides/gs-managing-transactions
3. JDoodle在线IDE: https://www.jdoodle.com/online-java-compiler/

21. 个人