Spring Boot 事务管理：实战案例解析，让你快速上手

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private InventoryService inventoryService;

    /**
     * 创建订单（事务方法）
     * @param orderDTO 订单传输对象
     * @throws BusinessException 业务异常时回滚事务
     */
    @Transactional(rollbackFor = BusinessException.class)
    public void createOrder(OrderDTO orderDTO) throws BusinessException {
        try {
            // 1. 扣减库存（内部事务传播）
            inventoryService.deductStock(orderDTO.getProductId(), orderDTO.getQuantity());

            // 2. 生成订单
            Order order = convertToOrder(orderDTO);
            orderRepository.save(order);

            // 3. 模拟支付（失败则抛出异常）
            processPayment(order);
        } catch (InventoryException e) {
            throw new BusinessException("库存不足", e); // 触发回滚
        }
    }

    private void processPayment(Order order) throws PaymentException {
        if (order.getAmount().compareTo(BigDecimal.valueOf(5000)) > 0) {
            throw new PaymentException("单笔支付金额超限"); // 触发回滚
        }
        // 实际支付逻辑...
    }
}

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private AuditService auditService;

    @Transactional
    public void registerUser(User user) {
        try {
            // 1. 保存用户（主事务）
            userRepository.save(user);

            // 2. 记录审计日志（独立事务）
            auditService.logRegistration(user.getId());
        } catch (DataIntegrityViolationException e) {
            throw new RegistrationException("用户已存在", e); // 主事务回滚
        }
    }
}

@Service
public class AuditService {

    /**
     * 记录审计日志（独立事务）
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logRegistration(Long userId) {
        AuditLog log = new AuditLog("USER_REGISTER", userId);
        auditLogRepository.save(log); // 即使主事务回滚，此操作仍提交
    }
}

@Service
public class BatchTransferService {

    @Autowired
    private AccountRepository accountRepository;

    /**
     * 批量转账（带版本控制的乐观锁）
     */
    @Transactional(isolation = Isolation.READ_COMMITTED, timeout = 30)
    public void batchTransfer(List<TransferRequest> requests) {
        requests.forEach(request -> {
            // 1. 查询账户（带版本号）
            Account from = accountRepository.findByIdWithLock(request.getFromId())
                    .orElseThrow(() -> new AccountNotFoundException("转出账户不存在"));
            Account to = accountRepository.findByIdWithLock(request.getToId())
                    .orElseThrow(() -> new AccountNotFoundException("转入账户不存在"));

            // 2. 校验并转账
            if (from.getBalance().compareTo(request.getAmount()) < 0) {
                throw new InsufficientBalanceException("余额不足");
            }
            from.debit(request.getAmount());
            to.credit(request.getAmount());

            // 3. 批量更新（带版本检查）
            accountRepository.updateBalance(from.getId(), from.getBalance(), from.getVersion());
            accountRepository.updateBalance(to.getId(), to.getBalance(), to.getVersion());
        });
    }
}

// JPA 实体类优化
@Entity
public class Account {
    @Id
    private Long id;
    private BigDecimal balance;

    @Version // 乐观锁版本字段
    private Integer version;

    // 省略 getter/setter
}

seata:
  enabled: true
  application-id: order-service
  tx-service-group: my_tx_group
  service:
    vgroup-mapping:
      my_tx_group: default

@Service
public class DistributedOrderService {

    @Autowired
    private OrderService orderService;

    @Autowired
    private PaymentService paymentService;

    @Autowired
    private InventoryService inventoryService;

    /**
     * 全局分布式事务
     */
    @GlobalTransactional(name = "createOrderTx", timeoutMills = 30000)
    public void createOrderWithPayment(OrderRequest request) {
        // 1. 创建订单（本地事务）
        Order order = orderService.create(request);

        // 2. 调用支付服务（远程事务）
        paymentService.process(order.getId(), order.getAmount());

        // 3. 扣减库存（跨服务调用）
        inventoryService.deduct(order.getProductId(), order.getQuantity());
    }
}

management:
  endpoints:
    web:
      exposure:
        include: transactions,metrics
  metrics:
    tags:
      application: ${spring.application.name}