ItemWriter中创建新块及多表INSERT/UPDATE的最佳实践问询

我需要在ItemWriter中针对块内的每个item，有条件地对多张表执行多次INSERT/UPDATE操作。我编写了如下CustomItemWriter代码，处理器输出为复杂对象。write方法包含业务逻辑，可根据输入item的内容准备对应每张表的INSERT/UPDATE行列表，再将这些列表封装为新块并传入对应writer。

目前代码运行正常，但我想咨询：创建如此多列表/新块是否为正确方案？有没有更规范的方式在ItemWriter中处理多表的INSERT/UPDATE操作？

public class CustomItemWriter implements ItemWriter<CustEnriched> {
 
   //writers
    private final JdbcBatchItemWriter<CustRequest> custRequestWriter;
    private final JdbcBatchItemWriter<CustEarn> custEarnWriter;
    private final JdbcBatchItemWriter<CustEligible> custEligWriter;
    private final JdbcBatchItemWriter<CustEligible> custTargetWriter;

    public void write(Chunk<? extends CustEnriched> chunk) throws Exception {
        //lists to accumulate rows/writer
        List<CustRequest> custRequestChunkList = new ArrayList<>();
        List<CustEarn> custEarnChunkList = new ArrayList<>();
        List<CustEligible> custEligChunkList = new ArrayList<>();
        List<CustEligible> custTargetChunkList = new ArrayList<>(); 
       
        for (CustEnriched item : chunk.getItems()) {
           
            //build methods contain logic to convert the item into one or more rows to be INSERTED/UPDATED per item
            
            custRequestChunkList.addAll(buildCustRequestList(item));
            custEarnChunkList.addAll(buildCustEarnList(item));
            custEligChunkList.add(buildCustEligible(item));

            if (!item.getEligibleForTarge().isEmpty()) {
                custTargetChunkList.add(buildCustTarget(item));
            }
        }
        
        //creating new chunks populated with respective lists from above & feeding to writers
        custRequestWriter.write(new Chunk<>(dedupList(custRequestChunkList)));
        custEarnWriter.write(new Chunk<>(custEarnChunkList));
        custEligWriter.write(new Chunk<>(custEligChunkList));
        custTargetWriter.write(new Chunk<>(custTargetChunkList));
    }
}

当前方案的合理性 #

你现在的实现完全可行，核心逻辑清晰——将复杂对象拆分后分发给对应表的Writer批量处理，符合Spring Batch的批量处理原则。唯一需要留意的是：如果块规模很大，内存中同时维护多个列表可能会占用较多内存，但只要块大小设置合理，这个问题通常可以忽略。

更规范的优化方案 #

1. 用ClassifierCompositeItemWriter拆分职责

Spring Batch提供的ClassifierCompositeItemWriter可以根据对象类型自动分发给对应的子Writer，配合前置的对象拆分Processor，能让代码更符合单一职责原则：

• 第一步：编写拆分Processor，把单个CustEnriched转换成包含所有子对象的集合
• 第二步：配置分类器，根据子对象类型匹配对应的JdbcBatchItemWriter

示例思路：

// 拆分处理器：负责将复杂对象拆分为各表对应的实体
public class CustEnrichedSplitterProcessor implements ItemProcessor<CustEnriched, List<Object>> {
    @Override
    public List<Object> process(CustEnriched item) throws Exception {
        List<Object> result = new ArrayList<>();
        result.addAll(buildCustRequestList(item));
        result.addAll(buildCustEarnList(item));
        result.add(buildCustEligible(item));
        if (!item.getEligibleForTarge().isEmpty()) {
            result.add(buildCustTarget(item));
        }
        return result;
    }
}

// 分类器配置：根据对象类型路由到对应Writer
ClassifierCompositeItemWriter<Object> compositeWriter = new ClassifierCompositeItemWriter<>();
compositeWriter.setClassifier(new Classifier<Object, ItemWriter<? super Object>>() {
    @Override
    public ItemWriter<? super Object> classify(Object object) {
        if (object instanceof CustRequest) {
            return custRequestWriter;
        } else if (object instanceof CustEarn) {
            return custEarnWriter;
        } else if (object instanceof CustEligible) {
            // 可给CustEligible加标记字段，区分是普通 eligibility 还是 target 数据
            return ((CustEligible) object).isTarget() ? custTargetWriter : custEligWriter;
        }
        throw new IllegalArgumentException("未知对象类型: " + object.getClass());
    }
});

2. 优化现有列表的内存使用

如果不想调整整体结构，可以对当前代码做小幅度优化：

• 初始化列表时提前预估容量（比如按块大小的倍数设置），减少ArrayList扩容的性能损耗
• 处理完每个Writer后手动清空列表，方便后续复用
• 优化dedupList逻辑，避免大数据量下成为性能瓶颈

3. 单Writer执行多表操作（适合简单场景）

如果业务逻辑不复杂，也可以在单个JdbcBatchItemWriter中执行多表操作：通过ItemPreparedStatementSetter配置多条SQL语句（需数据库支持批量多语句），或者用NamedParameterJdbcTemplate执行批量多表操作。不过这种方式灵活性不如拆分到多个Writer，仅适合逻辑简单的场景。

总结 #

你的当前实现是正确的，优化方向可以从职责拆分和内存优化两个角度入手。如果追求更规范的Spring Batch最佳实践，推荐使用ClassifierCompositeItemWriter配合拆分Processor的方案，让代码结构更清晰、可维护性更强。

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