Java特殊场景事务处理实战指南

1. 存储过程调用的事务控制

存储过程作为数据库预编译的SQL集合，在Java应用中调用时需要特别注意事务边界控制。

关键问题与解决方案

问题场景：

• 存储过程内部包含多个DML操作
• Java应用与存储过程需要共享事务
• 存储过程执行失败需要回滚Java业务逻辑

解决方案：

@Service
public class OrderService {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Transactional
    public void processOrderWithProcedure(Long orderId) {
        try {
            // 调用存储过程
            jdbcTemplate.update("CALL PROC_UPDATE_ORDER(?)", orderId);
            
            // 其他业务逻辑
            updateInventory(orderId);
        } catch (DataAccessException e) {
            // 存储过程执行异常将触发事务回滚
            throw new BusinessException("订单处理失败", e);
        }
    }
}

最佳实践：

1. 使用@Transactional注解确保存储过程调用在事务中执行
2. 存储过程内部避免使用COMMIT/ROLLBACK语句（交由Spring管理）
3. 对于Oracle等需要OUT参数的存储过程，使用SimpleJdbcCall

SimpleJdbcCall call = new SimpleJdbcCall(dataSource)
    .withProcedureName("PROC_COMPLEX_OPERATION")
    .declareParameters(
        new SqlParameter("in_param", Types.VARCHAR),
        new SqlOutParameter("out_param", Types.INTEGER));

2. 文件操作与事务一致性

文件上传+DB写入的原子性保障

典型问题：文件上传成功但数据库记录失败，导致数据不一致

解决方案一：事务性文件系统（XADisk）

<dependency>
    <groupId>com.github.javaxceph</groupId>
    <artifactId>xadisk</artifactId>
    <version>1.2.2</version>
</dependency>

@Transactional
public void uploadFileWithTransaction(File file, FileMetadata metadata) {
    // 1. 写入文件系统（事务性）
    XASession session = xaFileSystem.createSessionForFile(file);
    session.write(file, metadata.getContent());
    
    // 2. 写入数据库
    fileMetadataRepository.save(metadata);
    
    // 提交时两个操作作为一个事务
    session.commit();
}

解决方案二：补偿机制（更常用）

public void uploadFileWithCompensation(File file, FileMetadata metadata) {
    try {
        // 1. 先传文件到临时目录
        String tempPath = "/temp/" + UUID.randomUUID();
        Files.copy(file.getInputStream(), Paths.get(tempPath));
        
        // 2. 写数据库（主事务）
        fileMetadataRepository.save(metadata);
        
        // 3. 移动到正式目录
        Files.move(Paths.get(tempPath), 
                  Paths.get("/official/" + metadata.getFileName()));
    } catch (Exception e) {
        // 补偿：删除临时文件
        Files.deleteIfExists(Paths.get(tempPath));
        throw new BusinessException("文件上传失败", e);
    }
}

实践建议：

1. 大文件处理采用分片上传+事务日志
2. 使用文件MD5校验确保完整性
3. 重要业务场景实现清理Job扫描半成品文件

3. 消息队列与事务联动

3.1 事务性消息（RocketMQ示例）

@Transactional
public void createOrder(Order order) {
    // 1. 本地事务
    orderDao.insert(order);
    
    // 2. 发送事务消息
    TransactionSendResult result = rocketMQTemplate.sendMessageInTransaction(
        "order-topic",
        MessageBuilder.withPayload(order).build(),
        order.getUserId() // 业务参数
    );
    
    if (result.getLocalTransactionState() != LocalTransactionState.COMMIT_MESSAGE) {
        throw new RuntimeException("消息发送失败");
    }
}

// 实现TransactionListener
@RocketMQTransactionListener
class OrderTransactionListenerImpl implements RocketMQLocalTransactionListener {
    @Override
    public RocketMQLocalTransactionState executeLocalTransaction(Message msg, Object arg) {
        // 执行本地事务（与@Transactional一起构成分布式事务）
        return RocketMQLocalTransactionState.UNKNOWN;
    }
    
    @Override
    public RocketMQLocalTransactionState checkLocalTransaction(Message msg) {
        // 检查本地事务状态
        return orderDao.exists(orderId) ? 
            RocketMQLocalTransactionState.COMMIT_MESSAGE :
            RocketMQLocalTransactionState.ROLLBACK_MESSAGE;
    }
}

3.2 本地事务表+定时任务

实现方案：

核心代码：

@Entity
@Table(name = "t_event_publish")
public class EventPublish {
    @Id
    private String eventId;
    private String eventType;
    private String payload;
    private LocalDateTime createTime;
    private boolean published;
}

@Transactional
public void createUser(User user) {
    // 1. 业务操作
    userRepository.save(user);
    
    // 2. 记录事件（同一个事务）
    EventPublish event = new EventPublish();
    event.setEventId(UUID.randomUUID().toString());
    event.setEventType("USER_CREATED");
    event.setPayload(JSON.toJSONString(user));
    event.setCreateTime(LocalDateTime.now());
    eventPublishRepository.save(event);
}

// 定时任务
@Scheduled(fixedRate = 5000)
public void publishEvents() {
    List<EventPublish> events = eventPublishRepository
        .findByPublishedFalseAndCreateTimeBefore(
            LocalDateTime.now().minusMinutes(5));
    
    events.forEach(event -> {
        try {
            rabbitTemplate.convertAndSend(
                "user-events", 
                event.getEventType(), 
                event.getPayload());
            
            event.setPublished(true);
            eventPublishRepository.save(event);
        } catch (Exception e) {
            log.error("事件发布失败", e);
        }
    });
}

方案对比：

进阶建议

1. 分布式事务选型：

   • 严格一致性：Seata AT模式
   • 高并发场景：Saga模式
   • 长流程业务：TCC模式

2. Spring事务失效场景防范：

   • 避免同类内方法调用（需通过AOP代理）
   • 检查异常默认不回滚（需配置rollbackFor）
   • 非public方法不生效

3. 性能优化：

   • 合理设置事务超时时间
   • 只读事务优化标记
   • 批量操作使用@Transactional+REQUIRES_NEW隔离

通过以上方案，可以解决Java开发中大多数特殊场景的事务一致性问题，根据业务特点选择最适合的技术组合。