Spring Batch中JdbcBatchItemWriter多更新查询实现方案问询

Great question! I totally get the frustration of duplicating reader/processor/listener config across two steps just to write to two tables from the same input file. Let’s break down the cleanest Spring Batch patterns to fix this without redundancy:

方案1：用官方CompositeItemWriter（最推荐，零自定义代码） #

Spring Batch原生提供了CompositeItemWriter，可以直接组合多个单表JdbcBatchItemWriter，让单个Step完成多表写入，完全复用你的现有Reader、Processor和Listener。

XML配置示例 #

<!-- 先定义两张表的单表写入器 -->
<bean id="table1Writer" class="org.springframework.batch.item.database.JdbcBatchItemWriter">
    <property name="dataSource" ref="dataSource"/>
    <property name="sql" value="INSERT INTO table1 (col1, col2) VALUES (:field1, :field2)"/>
    <property name="itemSqlParameterSourceProvider">
        <bean class="org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider"/>
    </property>
</bean>

<bean id="table2Writer" class="org.springframework.batch.item.database.JdbcBatchItemWriter">
    <property name="dataSource" ref="dataSource"/>
    <property name="sql" value="INSERT INTO table2 (col3, col4) VALUES (:field3, :field4)"/>
    <property name="itemSqlParameterSourceProvider">
        <bean class="org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider"/>
    </property>
</bean>

<!-- 组合两个写入器为一个CompositeWriter -->
<bean id="multiTableWriter" class="org.springframework.batch.item.support.CompositeItemWriter">
    <property name="delegates">
        <list>
            <ref bean="table1Writer"/>
            <ref bean="table2Writer"/>
        </list>
    </property>
</bean>

<!-- 简化为单个Step的Job配置 -->
<batch:job id="batchJob">
    <batch:step id="singleProcessingStep">
        <batch:tasklet>
            <batch:chunk reader="cvsFileItemReader" 
                         processor="myItemProcessor" 
                         writer="multiTableWriter"
                         commit-interval="100">
                <batch:listeners>
                    <batch:listener ref="myItemListener"/>
                </batch:listeners>
            </batch:chunk>
        </batch:tasklet>
    </batch:step>
</batch:job>

• 核心优势：官方原生组件，无需自定义代码维护，事务由Chunk统一管理（两张表的写入要么全部成功，要么全部回滚），完全避免重复配置。

方案2：自定义组合ItemWriter（更灵活的场景） #

如果需要在多表写入之间加自定义逻辑（比如数据校验、日志记录），可以自己封装一个组合写入器：

Java代码示例 #

@Component
public class MultiTableItemWriter implements ItemWriter<YourProcessedItem> {

    private final JdbcBatchItemWriter<YourProcessedItem> table1Writer;
    private final JdbcBatchItemWriter<YourProcessedItem> table2Writer;

    // 构造注入两个单表写入器
    public MultiTableItemWriter(JdbcBatchItemWriter<YourProcessedItem> table1Writer, 
                                JdbcBatchItemWriter<YourProcessedItem> table2Writer) {
        this.table1Writer = table1Writer;
        this.table2Writer = table2Writer;
    }

    @Override
    public void write(List<? extends YourProcessedItem> items) throws Exception {
        // 自定义逻辑：比如批量校验数据
        validateBatch(items);
        
        // 写入第一张表
        table1Writer.write(items);
        // 写入第二张表
        table2Writer.write(items);
    }

    private void validateBatch(List<? extends YourProcessedItem> items) {
        // 你的自定义校验逻辑
    }
}

然后在Job配置中直接使用这个自定义Writer即可，和方案1的Step结构一致。

方案3：针对多实体类型的分类写入器 #

如果两张表对应的实体对象完全不同（比如CSV数据需要拆分成两个独立的POJO），可以用ClassifierCompositeItemWriter实现数据路由：

1. 让Processor把原始CSV数据转换成一个包含两个实体的容器对象
2. 用分类器把不同实体路由到对应的单表Writer

核心思路代码 #

// 容器类：封装两张表的实体
public class MultiEntityContainer {
    private Table1Entity table1Entity;
    private Table2Entity table2Entity;
    // getter/setter
}

// Processor：转换原始CSV数据为容器对象
@Component
public class MultiEntityProcessor implements ItemProcessor<RawCsvItem, MultiEntityContainer> {
    @Override
    public MultiEntityContainer process(RawCsvItem item) throws Exception {
        MultiEntityContainer container = new MultiEntityContainer();
        container.setTable1Entity(mapToTable1(item));
        container.setTable2Entity(mapToTable2(item));
        return container;
    }
}

// 分类器写入器：路由不同实体到对应Writer
@Bean
public ClassifierCompositeItemWriter<MultiEntityContainer> classifierWriter(
        JdbcBatchItemWriter<Table1Entity> table1Writer,
        JdbcBatchItemWriter<Table2Entity> table2Writer) {
    
    ClassifierCompositeItemWriter<MultiEntityContainer> writer = new ClassifierCompositeItemWriter<>();
    writer.setClassifier(item -> {
        // 这里可以扩展为更复杂的路由逻辑
        return new ItemWriter<MultiEntityContainer>() {
            @Override
            public void write(List<? extends MultiEntityContainer> items) throws Exception {
                List<Table1Entity> table1Items = items.stream().map(MultiEntityContainer::getTable1Entity).toList();
                List<Table2Entity> table2Items = items.stream().map(MultiEntityContainer::getTable2Entity).toList();
                table1Writer.write(table1Items);
                table2Writer.write(table2Items);
            }
        };
    });
    return writer;
}

为什么要放弃两个Step的方案？ #

• 重复IO/计算：两个Step会重复读取整个CSV文件、重复执行Processor逻辑，浪费资源
• 事务不一致：两个Step的事务是独立的，可能出现第一张表写入成功、第二张表失败的情况，导致数据脏读
• 冗余配置：重复的Reader/Processor/Listener配置会增加维护成本

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