Spring Batch：如何向StepExecution的ExecutionContext传递自定义参数

嘿，我刚好处理过类似的Spring Batch需求，给你分享几个实用的实现方式，完美解决你要给StepExecution的ExecutionContext初始化超时阈值，以及在步骤定义时传递自定义参数的问题：

方法1：通过JobParameters传递动态阈值，用StepListener注入到ExecutionContext #

如果你的阈值需要动态调整（比如每次启动Job时传入不同的阈值），这个方法最适合。核心思路是把阈值作为JobParameters传入，然后通过StepExecutionListener的beforeStep方法，把参数放到当前Step的ExecutionContext里。

先写一个自定义的StepListener：

public class ThresholdInjectListener implements StepExecutionListener {

    // 可以通过配置指定当前Step对应的阈值参数名
    private String thresholdParamName;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        // 从JobExecution的参数里拿到阈值
        JobParameters jobParams = stepExecution.getJobExecution().getJobParameters();
        Long timeoutThreshold = jobParams.getLong(thresholdParamName);
        if (timeoutThreshold != null) {
            // 把阈值存入当前Step的ExecutionContext
            stepExecution.getExecutionContext().put("timeoutThreshold", timeoutThreshold);
        }
    }

    @Override
    public ExitStatus afterStep(StepExecution stepExecution) {
        return null; // 不需要处理后置逻辑就返回null
    }

    // 提供setter让Spring注入参数名
    public void setThresholdParamName(String thresholdParamName) {
        this.thresholdParamName = thresholdParamName;
    }
}

然后在Step配置里注册这个Listener，同时启动Job时传入对应的参数：

@Bean
public ThresholdInjectListener step1ThresholdListener() {
    ThresholdInjectListener listener = new ThresholdInjectListener();
    listener.setThresholdParamName("step1TimeoutThreshold"); // 指定参数名
    return listener;
}

@Bean
public Step step1(ThresholdInjectListener step1ThresholdListener) {
    return stepBuilderFactory.get("step1")
            .<Input, Output>chunk(100)
            .reader(step1ItemReader())
            .processor(step1ItemProcessor())
            .writer(step1ItemWriter())
            .listener(step1ThresholdListener)
            .build();
}

// 启动Job时传入不同Step的阈值参数
JobParameters jobParams = new JobParametersBuilder()
        .addLong("step1TimeoutThreshold", 30000L) // Step1的30秒阈值
        .addLong("step2TimeoutThreshold", 60000L) // Step2的60秒阈值
        .addDate("runDate", new Date()) // 确保每次Job实例唯一
        .toJobParameters();
jobLauncher.run(myBatchJob, jobParams);

方法2：在Step定义时直接固定注入阈值 #

如果你的阈值是固定不变的（或者可以从配置文件读取固定值），可以直接在Step的定义里通过executionContext方法设置，不用额外写Listener。

Java配置示例：

@Value("${step1.timeout.threshold:30000}") // 从配置文件读取，默认30秒
private Long step1Threshold;

@Bean
public Step step1() {
    return stepBuilderFactory.get("step1")
            .<Input, Output>chunk(100)
            .reader(step1ItemReader())
            .processor(step1ItemProcessor())
            .writer(step1ItemWriter())
            // 直接往当前Step的ExecutionContext里放阈值
            .executionContext(context -> context.put("timeoutThreshold", step1Threshold))
            .build();
}

如果用XML配置的话，更直观：

<step id="step1">
    <tasklet>
        <chunk reader="step1Reader" processor="step1Processor" writer="step1Writer" commit-interval="100"/>
        <!-- 直接定义ExecutionContext的参数 -->
        <execution-context>
            <entry key="timeoutThreshold" value="30000"/>
        </execution-context>
    </tasklet>
</step>

方法3：为每个Step定制Listener，结合配置文件注入专属阈值 #

如果每个Step的阈值都存在配置文件里，且不想用JobParameters传递，还可以给每个Step写专属的Listener，直接从配置文件注入阈值。

示例代码：

@Component
public class Step1ThresholdListener implements StepExecutionListener {

    // 直接注入Step1的专属阈值
    @Value("${step1.timeout.threshold}")
    private Long timeoutThreshold;

    @Override
    public void beforeStep(StepExecution stepExecution) {
        stepExecution.getExecutionContext().put("timeoutThreshold", timeoutThreshold);
    }

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

// 配置Step时绑定专属Listener
@Bean
public Step step1(Step1ThresholdListener step1ThresholdListener) {
    return stepBuilderFactory.get("step1")
            .chunk(100)
            .reader(step1ItemReader())
            .processor(step1ItemProcessor())
            .writer(step1ItemWriter())
            .listener(step1ThresholdListener)
            .build();
}

如何在Step逻辑中使用这个阈值？ #

不管用哪种方法注入阈值，你都可以在Step的ItemProcessor、ItemWriter或者自定义Tasklet里获取到这个值：

比如在Tasklet里：

public class CustomTasklet implements Tasklet {

    @Override
    public RepeatStatus execute(StepContribution contribution, ChunkContext chunkContext) throws Exception {
        // 从ChunkContext里拿到当前Step的ExecutionContext
        StepExecution stepExecution = chunkContext.getStepContext().getStepExecution();
        Long timeoutThreshold = stepExecution.getExecutionContext().getLong("timeoutThreshold");
        
        // 这里就可以用阈值判断是否超时了，比如记录步骤开始时间，对比当前时间
        long startTime = System.currentTimeMillis();
        // 执行你的任务逻辑
        long elapsedTime = System.currentTimeMillis() - startTime;
        if (elapsedTime > timeoutThreshold) {
            throw new JobExecutionException("Step执行超时，已超过阈值：" + timeoutThreshold + "ms");
        }
        
        return RepeatStatus.FINISHED;
    }
}

或者在ItemProcessor里（需要注入StepExecution）：

public class CustomItemProcessor implements ItemProcessor<Input, Output> {

    @Autowired
    private StepExecution stepExecution;

    @Override
    public Output process(Input item) throws Exception {
        Long threshold = stepExecution.getExecutionContext().getLong("timeoutThreshold");
        // 结合业务逻辑做超时判断
        return processedItem;
    }
}

以上几种方法都能完美实现你的需求，你可以根据阈值是否需要动态调整来选择最合适的方案~

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