Spring Batch：如何在调用ItemWriter前拦截注入对象或扩展Chunk列表？

嘿，这个场景我太熟悉了！之前做批量订单导入的时候，正好遇到过类似的需求——要在Chunk提交给Writer之前动态添加对象，而且不想动原有的Reader/Processor/Writer核心逻辑对吧？给你几个实用的方案，你可以根据自己的业务场景选：

方案一：用ChunkListener在Writer前拦截并修改Chunk #

这是最直接的方案，利用Spring Batch的ChunkListener，在Chunk被传递给Writer之前修改原始的items列表。这个方案适合基于整个Chunk的统计/条件来添加对象的场景（比如每10个订单加一个汇总订单）。

实现步骤： #

1. 自定义ChunkListener，实现beforeChunk方法：

@Component
public class CustomChunkListener implements ChunkListener {

    @Override
    public void beforeChunk(ChunkContext chunkContext) {
        // 获取当前Chunk的items列表（注意类型转换）
        Chunk<?> chunk = chunkContext.getStepContext().getStepExecution().getChunk();
        List<OrderObject> items = (List<OrderObject>) chunk.getItems();
        
        // 这里替换成你的业务判断逻辑
        if (shouldAddExtraOrder(items)) {
            OrderObject extraOrder = new OrderObject();
            // 设置额外订单的属性
            extraOrder.setOrderType("EXTRA");
            items.add(extraOrder);
        }
    }

    // 你的业务判断方法
    private boolean shouldAddExtraOrder(List<OrderObject> items) {
        return items.size() == 10; // 比如每满10个就加一个
    }
}

2. 在Step配置中注册这个监听器：

<batch:step id="myImportStep">
    <batch:tasklet>
        <batch:chunk reader="myFileItemReader" processor="myFileProcessor" writer="myFileWriter"
                     chunk-completion-policy="myCompletionPolicy" skip-limit="1000000" retry-limit="3">
            <batch:listeners>
                <!-- 添加自定义ChunkListener -->
                <batch:listener ref="customChunkListener"/>
            </batch:listeners>
            <!-- 原有的异常和监听器配置 -->
        </batch:chunk>
    </batch:tasklet>
</batch:step>

这个方法的优势是完全不侵入原有的Reader/Processor/Writer逻辑，符合开闭原则。

方案二：在ItemProcessor中返回多个对象 #

如果你的新增逻辑和单个输入行强相关（比如每处理一行数据，根据该行内容生成一个主订单+一个额外订单），可以修改ItemProcessor让它返回多个对象，再通过一个拆分处理器把列表展开成单个Item，这样Chunk会自动收集这些Item直到达到完成策略的数量。

实现步骤： #

1. 修改原Processor，返回List：

public class MyFileProcessor implements ItemProcessor<String, List<OrderObject>> {

    @Override
    public List<OrderObject> process(String line) throws Exception {
        // 生成主订单
        OrderObject mainOrder = parseLineToOrder(line);
        
        List<OrderObject> orders = new ArrayList<>();
        orders.add(mainOrder);
        
        // 根据当前行的内容判断是否需要添加额外订单
        if (needExtraOrder(mainOrder)) {
            OrderObject extraOrder = createExtraOrder(mainOrder);
            orders.add(extraOrder);
        }
        
        return orders;
    }

    // 业务判断和对象创建方法
    private boolean needExtraOrder(OrderObject mainOrder) {
        return "VIP".equals(mainOrder.getCustomerType());
    }
}

2. 实现一个拆分处理器，把List拆成单个Item：

public class ListUnpackingItemProcessor implements ItemProcessor<List<OrderObject>, OrderObject> {

    private Iterator<OrderObject> currentIterator;

    @Override
    public OrderObject process(List<OrderObject> orders) throws Exception {
        if (currentIterator == null || !currentIterator.hasNext()) {
            currentIterator = orders.iterator();
        }
        // 返回单个Item，直到列表为空返回null
        return currentIterator.hasNext() ? currentIterator.next() : null;
    }
}

3. 配置CompositeItemProcessor组合这两个处理器：

<bean id="compositeProcessor" class="org.springframework.batch.item.support.CompositeItemProcessor">
    <property name="delegates">
        <list>
            <ref bean="myFileProcessor"/>
            <ref bean="listUnpackingItemProcessor"/>
        </list>
    </property>
</bean>

4. 修改Step的processor为这个组合处理器：

<batch:chunk reader="myFileItemReader" processor="compositeProcessor" writer="myFileWriter"
             chunk-completion-policy="myCompletionPolicy" skip-limit="1000000" retry-limit="3">
    <!-- 其他配置 -->
</batch:chunk>

方案三：包装ItemWriter，修改传入的列表 #

如果你的新增逻辑必须在Writer处理阶段执行（比如要根据Writer的处理状态添加对象），可以包装原有的ItemWriter，在调用原Writer之前把不可修改的列表转成可修改的ArrayList并添加对象。

实现步骤： #

1. 实现包装类：

public class WrappingOrderItemWriter implements ItemWriter<OrderObject> {

    // 注入原有的Writer
    private final ItemWriter<OrderObject> delegate;

    public WrappingOrderItemWriter(ItemWriter<OrderObject> delegate) {
        this.delegate = delegate;
    }

    @Override
    public void write(List<? extends OrderObject> items) throws Exception {
        // 把不可修改的List转成可修改的ArrayList
        List<OrderObject> modifiableItems = new ArrayList<>(items);
        
        // 业务逻辑：判断是否添加额外订单
        if (shouldAddSummaryOrder(modifiableItems)) {
            OrderObject summaryOrder = createSummaryOrder(modifiableItems);
            modifiableItems.add(summaryOrder);
        }
        
        // 调用原Writer处理修改后的列表
        delegate.write(modifiableItems);
    }

    // 业务逻辑方法
    private boolean shouldAddSummaryOrder(List<OrderObject> items) {
        return items.stream().anyMatch(order -> order.isNeedSummary());
    }
}

2. 配置包装后的Writer：

<bean id="wrappingOrderItemWriter" class="com.example.WrappingOrderItemWriter">
    <constructor-arg ref="myFileWriter"/>
</bean>

3. 修改Step的writer为这个包装类：

<batch:chunk reader="myFileItemReader" processor="myFileProcessor" writer="wrappingOrderItemWriter"
             chunk-completion-policy="myCompletionPolicy" skip-limit="1000000" retry-limit="3">
    <!-- 其他配置 -->
</batch:chunk>

总结 #

• 如果是基于整个Chunk的全局逻辑，选ChunkListener方案；
• 如果是和单个输入项强相关的逻辑，选Processor返回多对象方案；
• 如果必须在Writer阶段处理，选Writer包装方案。

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