Spring Batch：如何删除刚持久化的实体？

针对你的Spring Batch转储流程，要实现“持久化Element2后删除原Element1实体”的需求，有几种可靠的实现方式，以下是具体方案：

方案一：自定义ItemWriter，统一处理保存与删除 #

这种方式将保存目标实体和删除源实体的逻辑放在同一个Writer中，保证操作在同一个事务内，要么全部成功要么全部回滚，数据一致性更强。

步骤1：创建实体配对类 #

定义一个配对类，同时持有源实体Element1和转换后的目标实体Element2，让Processor可以传递两者的关联关系：

public class ElementPair {
    private Element1 sourceElement;
    private Element2 targetElement;

    // Getter和Setter
    public Element1 getSourceElement() {
        return sourceElement;
    }

    public void setSourceElement(Element1 sourceElement) {
        this.sourceElement = sourceElement;
    }

    public Element2 getTargetElement() {
        return targetElement;
    }

    public void setTargetElement(Element2 targetElement) {
        this.targetElement = targetElement;
    }
}

步骤2：修改Processor返回配对对象 #

调整原Processor的泛型和返回值，把转换后的Element2和原Element1封装到ElementPair中：

@Component
public class ElementProcessor implements ItemProcessor<Element1, ElementPair> {

    @Override
    public ElementPair process(Element1 element1) throws Exception {
        // 原有的Element1转Element2逻辑
        Element2 element2 = convertToElement2(element1);
        
        ElementPair pair = new ElementPair();
        pair.setSourceElement(element1);
        pair.setTargetElement(element2);
        return pair;
    }

    private Element2 convertToElement2(Element1 element1) {
        // 你的转换实现代码
        Element2 element2 = new Element2();
        // 赋值逻辑...
        return element2;
    }
}

步骤3：自定义Writer处理保存与删除 #

实现一个自定义ItemWriter，先批量保存Element2，再批量删除对应的Element1：

@Component
public class SyncElementWriter implements ItemWriter<ElementPair> {

    private final OtherRepository otherRepository;
    private final Element1Repository sourceRepository;

    // 构造注入依赖
    public SyncElementWriter(OtherRepository otherRepository, Element1Repository sourceRepository) {
        this.otherRepository = otherRepository;
        this.sourceRepository = sourceRepository;
    }

    @Override
    public void write(List<? extends ElementPair> items) throws Exception {
        // 批量保存目标实体
        List<Element2> targetElements = items.stream()
                .map(ElementPair::getTargetElement)
                .collect(Collectors.toList());
        otherRepository.saveAll(targetElements);

        // 批量删除源实体
        List<Element1> sourceElements = items.stream()
                .map(ElementPair::getSourceElement)
                .collect(Collectors.toList());
        sourceRepository.deleteAll(sourceElements);
    }
}

步骤4：更新Step配置 #

修改Step的泛型和Writer引用，适配新的处理逻辑：

@Bean
public Step syncStep() {
    // 原Reader配置保持不变
    RepositoryItemReader<Element1> reader = new RepositoryItemReader<>();
    reader.setRepository(sourceRepository);
    reader.setMethodName("findElements");
    reader.setArguments(new ArrayList<>(Arrays.asList(ZonedDateTime.now())));
    final HashMap<String, Sort.Direction> sorts = new HashMap<>();
    sorts.put("uid", Sort.Direction.ASC);
    reader.setSort(sorts);

    return stepBuilderFactory.get("syncStep")
            .<Element1, ElementPair> chunk(10)
            .reader(reader)
            .processor(elementProcessor)
            .writer(syncElementWriter)
            .build();
}

方案二：使用ItemWriteListener，在保存后触发删除 #

如果不想修改Processor的返回类型，可以利用Spring Batch的ItemWriteListener，在目标实体保存成功后，通过Element2关联的源实体ID执行删除操作。

步骤1：在Element2中添加源实体ID字段 #

确保转换后的Element2包含Element1的唯一标识（比如uid），修改Processor的转换逻辑，把Element1的uid赋值给Element2：

// 在Element2类中添加字段
private Long originalUid;

// Getter和Setter
public Long getOriginalUid() {
    return originalUid;
}

public void setOriginalUid(Long originalUid) {
    this.originalUid = originalUid;
}

// Processor中的转换逻辑补充
private Element2 convertToElement2(Element1 element1) {
    Element2 element2 = new Element2();
    element2.setOriginalUid(element1.getUid()); // 传递源实体ID
    // 其他赋值逻辑...
    return element2;
}

步骤2：实现ItemWriteListener #

编写监听器，在afterWrite方法中提取源实体ID并执行批量删除：

@Component
public class DeleteSourceListener implements ItemWriteListener<Element2> {

    private final Element1Repository sourceRepository;

    public DeleteSourceListener(Element1Repository sourceRepository) {
        this.sourceRepository = sourceRepository;
    }

    @Override
    public void afterWrite(List<? extends Element2> items) {
        // 提取所有源实体ID
        List<Long> sourceUids = items.stream()
                .map(Element2::getOriginalUid)
                .collect(Collectors.toList());
        // 批量删除
        sourceRepository.deleteAllById(sourceUids);
    }

    // 空实现其他方法
    @Override
    public void beforeWrite(List<? extends Element2> items) {}

    @Override
    public void onWriteError(Exception exception, List<? extends Element2> items) {}
}

步骤3：为Step添加监听器 #

在原Step配置中注册这个监听器即可：

@Bean
public Step syncStep() {
    // 原Reader和Writer配置保持不变
    RepositoryItemReader<Element1> reader = new RepositoryItemReader<>();
    reader.setRepository(sourceRepository);
    reader.setMethodName("findElements");
    reader.setArguments(new ArrayList<>(Arrays.asList(ZonedDateTime.now())));
    final HashMap<String, Sort.Direction> sorts = new HashMap<>();
    sorts.put("uid", Sort.Direction.ASC);
    reader.setSort(sorts);

    RepositoryItemWriter<Element2> writer = new RepositoryItemWriter<>();
    writer.setRepository(otherRepository);
    writer.setMethodName("saveAll"); // 显式使用批量保存方法

    return stepBuilderFactory.get("syncStep")
            .<Element1, Element2> chunk(10)
            .reader(reader)
            .processor(elementProcessor)
            .writer(writer)
            .listener(deleteSourceListener) // 添加监听器
            .build();
}

注意事项 #

• 事务一致性：两种方案的操作都处于Chunk的事务范围内，若保存或删除任一环节失败，整个Chunk的操作都会回滚，避免数据不一致。
• 批量操作性能：使用saveAll和deleteAll/deleteAllById等批量方法，比单条操作更高效，适合Chunk处理场景。
• 异常处理：如果需要针对删除失败做特殊处理，可以在自定义Writer或监听器中添加异常捕获逻辑。

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