Spring Boot JPA批量插入遇异常如何跳过并继续保存其他记录？

Spring Data JPA的saveAll()默认会在同一个事务中执行所有插入操作，一旦单个记录触发异常（比如主键冲突、字段约束违例），整个事务会回滚，导致所有记录都保存失败。要实现跳过异常继续保存其他记录，可以用以下几种方案：

方案1：逐个遍历保存+捕获异常 #

最直接的方式是遍历要保存的集合，对每个实体单独调用save()，并捕获数据访问相关异常。单个实体保存失败时，仅跳过该实体，不影响其他记录。

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class EntityService {
    private static final Logger log = LoggerFactory.getLogger(EntityService.class);
    private final YourEntityRepository repository;

    public EntityService(YourEntityRepository repository) {
        this.repository = repository;
    }

    public List<YourEntity> saveAllWithErrorSkip(List<YourEntity> entities) {
        List<YourEntity> saved = new ArrayList<>();
        
        for (YourEntity entity : entities) {
            try {
                saved.add(repository.save(entity));
            } catch (DataAccessException e) {
                log.error("保存实体失败: ID={}, 原因={}", entity.getId(), e.getMessage());
                // 可选：记录失败实体到单独列表，后续处理
            }
        }
        return saved;
    }
}

优缺点：

• 优点：实现简单，容错性强，能精准跳过单个失败记录
• 缺点：性能较差，每个save()都会触发单独的数据库交互，数据量大时效率低

方案2：分批次批量保存+降级处理 #

将大集合拆分为小批次，每个批次用saveAll()批量插入，若某个批次失败，则降级为逐个保存该批次内的实体。这种方式兼顾了批量操作的性能和容错性。

import org.springframework.dao.DataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.annotation.Propagation;
import java.util.ArrayList;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class EntityService {
    private static final Logger log = LoggerFactory.getLogger(EntityService.class);
    private final YourEntityRepository repository;
    private static final int BATCH_SIZE = 50; // 根据数据库性能调整批次大小

    public EntityService(YourEntityRepository repository) {
        this.repository = repository;
    }

    public void saveInBatchesWithErrorSkip(List<YourEntity> entities) {
        List<List<YourEntity>> batches = splitIntoBatches(entities, BATCH_SIZE);
        
        for (List<YourEntity> batch : batches) {
            try {
                saveBatchInTransaction(batch);
            } catch (DataAccessException e) {
                log.error("批次保存失败，尝试逐个处理该批次: {}", e.getMessage());
                saveEachWithErrorSkip(batch);
            }
        }
    }

    // 手动实现批次拆分，无需依赖第三方工具
    private List<List<YourEntity>> splitIntoBatches(List<YourEntity> list, int batchSize) {
        List<List<YourEntity>> batches = new ArrayList<>();
        for (int i = 0; i < list.size(); i += batchSize) {
            int end = Math.min(i + batchSize, list.size());
            batches.add(list.subList(i, end));
        }
        return batches;
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    private void saveBatchInTransaction(List<YourEntity> batch) {
        repository.saveAll(batch);
    }

    private void saveEachWithErrorSkip(List<YourEntity> batch) {
        for (YourEntity entity : batch) {
            try {
                repository.save(entity);
            } catch (DataAccessException e) {
                log.error("单个实体保存失败: ID={}", entity.getId(), e);
            }
        }
    }
}

核心点：

• 使用@Transactional(Propagation.REQUIRES_NEW)让每个批次的事务独立，避免一个批次失败回滚其他批次
• 批次大小可根据数据库的批量插入能力调整（比如MySQL默认允许的批量行数）

优缺点：

• 优点：平衡了性能和容错，大批次提升效率，失败批次降级处理避免全部丢失
• 缺点：需要手动实现批次拆分逻辑（也可使用Guava等工具类简化）

方案3：用JdbcTemplate手动实现批量插入 #

如果追求极致性能且能接受手写SQL，可以用JdbcTemplate直接执行批量插入，通过捕获BatchUpdateException来定位失败的行。

import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.BatchUpdateException;

@Service
public class EntityService {
    private static final Logger log = LoggerFactory.getLogger(EntityService.class);
    private final JdbcTemplate jdbcTemplate;

    public EntityService(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    public void batchInsertWithErrorSkip(List<YourEntity> entities) {
        String sql = "INSERT INTO your_entity (column1, column2, column3) VALUES (?, ?, ?)";
        
        try {
            int[] updateCounts = jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
                @Override
                public void setValues(PreparedStatement ps, int index) throws SQLException {
                    YourEntity entity = entities.get(index);
                    ps.setString(1, entity.getColumn1());
                    ps.setInt(2, entity.getColumn2());
                    ps.setTimestamp(3, entity.getColumn3());
                }

                @Override
                public int getBatchSize() {
                    return entities.size();
                }
            });
        } catch (BatchUpdateException e) {
            int[] updateCounts = e.getUpdateCounts();
            for (int i = 0; i < updateCounts.length; i++) {
                if (updateCounts[i] == Statement.EXECUTE_FAILED) {
                    log.error("第{}个实体插入失败: {}", i+1, entities.get(i));
                }
            }
        }
    }
}

核心点：

• BatchUpdateException.getUpdateCounts()会返回每行的执行结果，Statement.EXECUTE_FAILED标识该行插入失败
• 直接用JDBC批量操作，性能远高于JPA的逐个保存

优缺点：

• 优点：性能最优，适合超大数据量的批量插入场景
• 缺点：需要手写SQL，无法利用JPA的实体映射优势，维护成本较高

注意事项 #

1. 日志记录：务必记录失败实体的信息和异常原因，方便后续排查和补录
2. 事务隔离：避免在全局事务中执行批量操作，否则单个失败会导致全局回滚
3. 性能测试：根据数据量大小选择合适的方案，小数据量用方案1，大数据量优先方案2或3

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