Spring Boot大查询场景下@Transactional注解的正确使用咨询

问题核心原因分析 #

• 原代码的核心问题不是事务传播属性，而是将全量10万条数据的处理逻辑放在了同一个大事务中：Spring声明式事务默认会在方法执行完成后才提交事务，在整个方法执行过程中，所有的save操作都只会暂存在JPA的一级缓存中，不会同步到数据库，也不会提交事务。同时大量缓存的实体对象会持续占用JVM内存，最终导致程序阻塞。
• 你提供的Repository层save方法存在逻辑错误：方法上标注的是@Query("SELECT * FROM object WHERE id is null")查询语句，根本不会执行写操作，这也是数据库没有变更的直接原因之一。
• 你对Propagation.REQUIRES_NEW的理解存在偏差：这个传播属性的作用是每次调用该方法时，开启一个独立于外层事务的新事务，方法执行结束就提交当前新事务，但前提是你需要循环调用这个带该注解的方法，每次只处理一批数据。你原来的修改只是把单事务的传播属性改了，还是把全量处理逻辑放在同一个方法里，依然是单个大事务，不会实现分批提交的效果。

正确的实现方案 #

这类批量数据处理场景的标准最佳实践是「事务拆分+分批处理」，不需要额外用bash调用接口，具体实现逻辑如下：

1. 先修正Repository代码 #

直接继承JpaRepository使用内置的批量保存方法，不要自定义错误的save逻辑：

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import java.util.List;

public interface ObjectRepository extends JpaRepository<Object, Integer> {
    // 自定义查询待处理数据的方法，支持limit限制批次大小
    @Query(value = "SELECT * FROM object WHERE id is null LIMIT ?1", nativeQuery = true)
    List<Object> findBatch待处理(int batchSize);
}

2. 拆分事务逻辑 #

将外层分批调度逻辑和内层单批事务逻辑拆分，注意Spring事务基于AOP代理实现，同类内直接调用方法不会触发事务，需要注入自身代理对象或者将单批逻辑抽到单独的Service类中：

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;

@Service
public class ObjectService {
    @Autowired
    private ObjectRepository objectRepository;
    // 注入自身代理对象，用于触发事务切面
    @Autowired
    private ObjectService self;

    // 外层调度方法，不加事务，负责循环拉取批次
    public void processAll() {
        int batchSize = 1000;
        List<Object> batch;
        do {
            batch = objectRepository.findBatch待处理(batchSize);
            if (!batch.isEmpty()) {
                // 调用代理对象的单批处理方法，事务生效
                self.processSingleBatch(batch);
            }
        } while (!batch.isEmpty());
    }

    // 单批处理方法，每次开启独立新事务，执行完成自动提交
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void processSingleBatch(List<Object> batchData) {
        for (Object obj : batchData) {
            childMethod1(obj);
            childMethod2(obj);
            childMethod3(obj);
        }
        // 批量保存，性能远高于循环单条保存
        objectRepository.saveAll(batchData);
    }

    private void childMethod1(Object obj) { 
        // 业务逻辑
    } 

    private void childMethod2(Object obj) { 
        // 业务逻辑
    } 

    private void childMethod3(Object obj) { 
        // 业务逻辑
    } 
}

性能优化建议 #

如果数据量特别大，可以额外配置JPA的批量更新参数，在application.yml中添加以下配置，进一步提升写入性能：

spring:
  jpa:
    properties:
      hibernate:
        jdbc:
          batch_size: 1000
        order_inserts: true
        order_updates: true

常见注意点 #

• 不要在大事务中处理过多业务逻辑，尽量缩短事务执行时间，避免数据库锁等待。
• 同类内调用事务方法必须通过代理对象，否则@Transactional注解会失效。
• 批量处理优先用saveAll代替循环调用save，减少和数据库的交互次数。

内容的提问来源于stack exchange，提问作者Greg