如何在Spring Batch中创建动态步骤？解决字符串参数自动装配报错

云原生阿岚

2026-6-19

问题：Spring Batch动态传递JobParameters到步骤时出现自动装配错误

我拥有MigrationService、BatchConfig等类，希望通过MigrationJobListener将JobParameters传递给相关步骤，但在步骤构造方法的String collectionName、String query参数处出现**"Could not autowire. No beans of 'String' type found."**错误，请问该如何解决？

相关代码实现

MigrationService

@Service
@RequiredArgsConstructor
public class MigrationService {

    private final BatchJobLauncher batchJobLauncher;

    public void runJob(UsageDataRequest request) {

        // 定义集合-查询语句的映射
        Map<String, String> pairs = new HashMap<>();
        pairs.put("employee", "{}");
        pairs.put("student", "{}");

        // 转换为JSON字符串
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonPairs = objectMapper.writeValueAsString(pairs);

        // 构造包含JSON参数的JobParameters
        JobParameters jobParameters = new JobParametersBuilder()
                .addString("collectionsAndQueries", jsonPairs)
                .toJobParameters();

        batchJobLauncher.launchJob(jobParameters);
    }
}

BatchConfig

@Configuration
public class BatchConfig {

    @Bean
    public Job migrationJob(JobRepository jobRepository,
                            @Qualifier("sourceTransactionManager") PlatformTransactionManager sourceTransactionManager,
                            @Qualifier("sourceMongoTemplate") MongoTemplate sourceMongoTemplate,
                            @Qualifier("targetMongoTemplate") MongoTemplate targetMongoTemplate,
                            @Qualifier("dataDeletionTasklet") DataDeletionTasklet dataDeletionTasklet,
                            @Qualifier("migrationJobListener") MigrationJobListener migrationJobListener) {

        // 尝试从JobListener获取参数映射
        Map<String, String> jobParametersMap = migrationJobListener.getJobParametersMap();

        JobBuilder jobBuilder = new JobBuilder("migrationJob", jobRepository).incrementer(new RunIdIncrementer());
        SimpleJobBuilder simpleJobBuilder = new SimpleJobBuilder(jobBuilder);

        // 遍历参数映射创建步骤
        for (Map.Entry<String, String> entry : jobParametersMap.entrySet()) {
            String collectionName = entry.getKey();
            String query = entry.getValue();

            // 传递参数到步骤
            Step deleteStep = deleteMatchingData(jobRepository, sourceTransactionManager, dataDeletionTasklet, collectionName, query);
            Step insertStep = insertData(jobRepository, sourceTransactionManager, sourceMongoTemplate, targetMongoTemplate, collectionName, query);

            simpleJobBuilder = simpleJobBuilder.start(deleteStep).next(insertStep);
        }

        return simpleJobBuilder
                .listener(migrationJobListener)
                .build();
    }

    @Bean
    public Step deleteData(JobRepository jobRepository,
                           PlatformTransactionManager sourceTransactionManager,
                           DeletionTasklet deletionTasklet,
                           String collectionName,
                           String query
    ) {
        // 给Tasklet设置参数
        deletionTasklet.setCollectionName(collectionName);
        deletionTasklet.setQuery(query);

        return new StepBuilder("deleteData", jobRepository)
                .tasklet(deletionTasklet, sourceTransactionManager)
                .listener(new MigrationStepListener("deleteData"))
                .build();
    }
}

DeletionTasklet

@Component
public class DeletionTasklet implements Tasklet, StepExecutionListener {

    @Getter
    @Setter
    private String query;

    @Getter
    @Setter
    private String collectionName;

    // 省略其他代码

    // 尝试使用从BatchConfig传递来的参数执行逻辑
}

MigrationJobListener

@Component
public class MigrationJobListener implements JobExecutionListener {

    private Map<String, String> jobParametersMap;

    @Override
    public void beforeJob(JobExecution jobExecution) {
        JobParameters jobParameters = jobExecution.getJobParameters();
        String jsonPairs = jobParameters.getString("collectionsAndQueries");

        try {
            ObjectMapper objectMapper = new ObjectMapper();
            jobParametersMap = objectMapper.readValue(jsonPairs, new TypeReference<Map<String, String>>() {});
        } catch (JsonProcessingException e) {
            throw new RuntimeException("解析Job参数失败", e);
        }
    }

    @Override
    public void afterJob(JobExecution jobExecution) {

    }

    public Map<String, String> getJobParametersMap() {
        return jobParametersMap;
    }
}

解决方案

问题根源

自动装配错误：Spring容器在创建deleteData这个Step Bean时，会尝试自动装配所有方法参数，但collectionName和query是普通字符串，不是Spring容器管理的Bean，因此找不到匹配的Bean注入。
时序错误：MigrationJobListener的beforeJob方法是在Job执行阶段才会被调用，但BatchConfig中的migrationJob Bean是在Spring容器初始化阶段创建的，此时调用getJobParametersMap()得到的是null，根本无法生成动态步骤。

可行方案

方案一：使用`@JobScope`动态生成Job和步骤

通过@JobScope延迟Job Bean的创建时机到Job启动时，此时可以直接获取JobParameters并动态生成步骤：

修改BatchConfig：

@Configuration
public class BatchConfig {

    private final ApplicationContext applicationContext;

    public BatchConfig(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    @Bean
    @JobScope
    public Job migrationJob(JobRepository jobRepository,
                            @Qualifier("sourceTransactionManager") PlatformTransactionManager sourceTransactionManager,
                            @Value("#{jobParameters['collectionsAndQueries']}") String jsonPairs) throws JsonProcessingException {

        // 解析JobParameters中的JSON参数
        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, String> pairs = objectMapper.readValue(jsonPairs, new TypeReference<Map<String, String>>() {});

        JobBuilder jobBuilder = new JobBuilder("migrationJob", jobRepository).incrementer(new RunIdIncrementer());
        SimpleJobBuilder simpleJobBuilder = new SimpleJobBuilder(jobBuilder);

        // 遍历参数生成带标识的步骤
        for (Map.Entry<String, String> entry : pairs.entrySet()) {
            String collectionName = entry.getKey();
            String query = entry.getValue();

            // 获取原型Scope的Tasklet新实例
            DeletionTasklet tasklet = applicationContext.getBean(DeletionTasklet.class);
            tasklet.setCollectionName(collectionName);
            tasklet.setQuery(query);

            Step deleteStep = deleteData(jobRepository, sourceTransactionManager, tasklet, collectionName);
            simpleJobBuilder = simpleJobBuilder.next(deleteStep);
        }

        return simpleJobBuilder.build();
    }

    @Bean
    public Step deleteData(JobRepository jobRepository,
                           PlatformTransactionManager sourceTransactionManager,
                           DeletionTasklet deletionTasklet,
                           String collectionName) {
        // 步骤名称带上集合名，方便区分
        return new StepBuilder("deleteData-" + collectionName, jobRepository)
                .tasklet(deletionTasklet, sourceTransactionManager)
                .build();
    }
}

修改DeletionTasklet为原型Scope（避免多个步骤共享同一个实例导致参数覆盖）：

@Component
@Scope("prototype")
public class DeletionTasklet implements Tasklet {

    private String query;
    private String collectionName;

    public void setQuery(String query) {
        this.query = query;
    }

    public void setCollectionName(String collectionName) {
        this.collectionName = collectionName;
    }

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // 执行删除逻辑，使用collectionName和query
        return RepeatStatus.FINISHED;
    }
}

方案二：通过StepExecutionListener直接获取JobParameters

让Tasklet自己从StepExecution中解析JobParameters，无需在BatchConfig中传递参数：

修改DeletionTasklet：

@Component
@StepScope
public class DeletionTasklet implements Tasklet, StepExecutionListener {

    private String query;
    private String collectionName;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // 从StepExecution获取JobParameters
        JobParameters jobParameters = stepExecution.getJobParameters();
        String jsonPairs = jobParameters.getString("collectionsAndQueries");

        // 从步骤名称中提取集合名（假设步骤名称格式为deleteData-xxx）
        String stepName = stepExecution.getStepName();
        collectionName = stepName.replace("deleteData-", "");

        // 解析JSON获取对应查询语句
        try {
            ObjectMapper objectMapper = new ObjectMapper();
            Map<String, String> pairs = objectMapper.readValue(jsonPairs, new TypeReference<Map<String, String>>() {});
            query = pairs.get(collectionName);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("解析Job参数失败", e);
        }
    }

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // 执行删除逻辑
        return RepeatStatus.FINISHED;
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        return ExitStatus.COMPLETED;
    }
}

修改BatchConfig：

@Configuration
public class BatchConfig {

    @Bean
    @JobScope
    public Job migrationJob(JobRepository jobRepository,
                            @Qualifier("sourceTransactionManager") PlatformTransactionManager sourceTransactionManager,
                            @Qualifier("deletionTasklet") DeletionTasklet deletionTasklet,
                            @Value("#{jobParameters['collectionsAndQueries']}") String jsonPairs) throws JsonProcessingException {

        ObjectMapper objectMapper = new ObjectMapper();
        Map<String, String> pairs = objectMapper.readValue(jsonPairs, new TypeReference<Map<String, String>>() {});

        JobBuilder jobBuilder = new JobBuilder("migrationJob", jobRepository).incrementer(new RunIdIncrementer());
        SimpleJobBuilder simpleJobBuilder = new SimpleJobBuilder(jobBuilder);

        for (String collectionName : pairs.keySet()) {
            Step deleteStep = deleteData(jobRepository, sourceTransactionManager, deletionTasklet, collectionName);
            simpleJobBuilder = simpleJobBuilder.next(deleteStep);
        }

        return simpleJobBuilder.build();
    }

    @Bean
    public Step deleteData(JobRepository jobRepository,
                           PlatformTransactionManager sourceTransactionManager,
                           DeletionTasklet deletionTasklet,
                           String collectionName) {
        return new StepBuilder("deleteData-" + collectionName, jobRepository)
                .tasklet(deletionTasklet, sourceTransactionManager)
                .build();
    }
}

核心注意事项

不要在容器初始化阶段尝试获取JobParameters，必须使用@JobScope或@StepScope延迟Bean创建到Job/Step执行阶段。
普通字符串不能作为Spring Bean方法的参数让容器自动装配，必须手动传入或从ExecutionContext/JobParameters中动态获取。
如果多个步骤使用同一个Tasklet类，一定要将Tasklet设置为prototype Scope，避免参数覆盖问题。

内容的提问来源于stack exchange，提问作者Murat Yıldız

如何在Spring Batch中创建动态步骤？解决字符串参数自动装配报错

相关代码实现 #

MigrationService #

BatchConfig #

DeletionTasklet #

MigrationJobListener #

解决方案 #

问题根源 #

可行方案 #

方案一：使用@JobScope动态生成Job和步骤