Spring Boot 3下Spring Batch多数据源作业配置问题求助

核心思路 #

Spring Batch 5.x移除了BatchConfigurer接口，改为通过显式配置每个作业的基础组件（数据源、事务管理器、作业仓库等）实现多数据源隔离，彻底摆脱对默认datasource Bean的依赖。

具体实现步骤 #

1. 定义多数据源Bean #

为两个模块分别配置独立数据源，无需刻意命名为datasource，避免被Spring Batch默认拾取：

@Configuration
public class DataSourceConfig {

    // 模块A专属数据源
    @Bean
    @ConfigurationProperties("spring.datasource.module-a")
    public DataSource moduleADatasource() {
        return DataSourceBuilder.create().build();
    }

    // 模块B专属数据源
    @Bean
    @ConfigurationProperties("spring.datasource.module-b")
    public DataSource moduleBDatasource() {
        return DataSourceBuilder.create().build();
    }
}

2. 为每个模块配置独立Batch组件 #

为每个模块创建专属的作业仓库、事务管理器、作业启动器，确保两个作业的元数据完全隔离在各自数据库中。

模块A的Batch配置

@Configuration
@EnableBatchProcessing
public class ModuleABatchConfig {

    // 模块A事务管理器
    @Bean
    public PlatformTransactionManager moduleATransactionManager(@Qualifier("moduleADatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    // 模块A作业仓库
    @Bean
    public JobRepository moduleAJobRepository(@Qualifier("moduleADatasource") DataSource dataSource,
                                              @Qualifier("moduleATransactionManager") PlatformTransactionManager transactionManager) throws Exception {
        JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
        factory.setDataSource(dataSource);
        factory.setTransactionManager(transactionManager);
        factory.setIsolationLevelForCreate("ISOLATION_REPEATABLE_READ");
        factory.setTablePrefix("BATCH_"); // 可自定义表前缀区分模块
        return factory.getObject();
    }

    // 模块A作业启动器
    @Bean
    public JobLauncher moduleAJobLauncher(@Qualifier("moduleAJobRepository") JobRepository jobRepository) throws Exception {
        SimpleJobLauncher launcher = new SimpleJobLauncher();
        launcher.setJobRepository(jobRepository);
        launcher.setTaskExecutor(new SimpleAsyncTaskExecutor()); // 按需配置任务执行器
        return launcher;
    }

    // 模块A作业示例
    @Bean
    public Job moduleAJob(@Qualifier("moduleAJobRepository") JobRepository jobRepository,
                          @Qualifier("moduleAStep") Step moduleAStep) {
        return new JobBuilder("moduleAJob", jobRepository)
                .start(moduleAStep)
                .build();
    }

    // 模块A步骤示例
    @Bean
    public Step moduleAStep(@Qualifier("moduleADatasource") DataSource dataSource,
                           @Qualifier("moduleATransactionManager") PlatformTransactionManager transactionManager,
                           @Qualifier("moduleAJobRepository") JobRepository jobRepository) {
        return new StepBuilder("moduleAStep", jobRepository)
                .<YourEntity, YourEntity>chunk(100, transactionManager)
                .reader(new JdbcCursorItemReaderBuilder<YourEntity>()
                        .dataSource(dataSource)
                        .sql("SELECT * FROM module_a_table")
                        .rowMapper(new BeanPropertyRowMapper<>(YourEntity.class))
                        .build())
                .writer(items -> {
                    // 自定义写入模块A数据库的逻辑
                })
                .build();
    }
}

模块B的Batch配置

复制模块A的配置结构，替换对应的数据源和组件即可，保证两套Batch组件完全独立：

@Configuration
@EnableBatchProcessing
public class ModuleBBatchConfig {

    @Bean
    public PlatformTransactionManager moduleBTransactionManager(@Qualifier("moduleBDatasource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Bean
    public JobRepository moduleBJobRepository(@Qualifier("moduleBDatasource") DataSource dataSource,
                                              @Qualifier("moduleBTransactionManager") PlatformTransactionManager transactionManager) throws Exception {
        JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
        factory.setDataSource(dataSource);
        factory.setTransactionManager(transactionManager);
        factory.setIsolationLevelForCreate("ISOLATION_REPEATABLE_READ");
        factory.setTablePrefix("BATCH_");
        return factory.getObject();
    }

    @Bean
    public JobLauncher moduleBJobLauncher(@Qualifier("moduleBJobRepository") JobRepository jobRepository) throws Exception {
        SimpleJobLauncher launcher = new SimpleJobLauncher();
        launcher.setJobRepository(jobRepository);
        return launcher;
    }

    // 模块B的作业和Step配置，参考模块A实现
}

3. 关键注意事项 #

• 每个标注@EnableBatchProcessing的配置类会生成独立的Batch上下文，确保作业组件完全隔离。
• 确保每个数据库都初始化了Spring Batch元数据表，可通过spring.batch.jdbc.initialize-schema=always自动生成，或手动执行官方脚本。
• 若需共享通用组件（如TaskExecutor），可提取到单独配置类，通过@Qualifier注入。

轻量替代方案：BatchConfigurationCustomizer #

如果仅需替换默认数据源，无需完全隔离组件，可通过BatchConfigurationCustomizer自定义默认Batch配置（仅适用于单作业场景）：

@Configuration
public class CustomBatchConfig implements BatchConfigurationCustomizer {

    private final DataSource customDataSource;

    public CustomBatchConfig(@Qualifier("moduleADatasource") DataSource customDataSource) {
        this.customDataSource = customDataSource;
    }

    @Override
    public void customize(BatchConfiguration configuration) {
        configuration.setDataSource(customDataSource);
        // 可额外自定义事务管理器、表前缀等
    }
}

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