Spring Batch Tasklet抛自定义异常时ExitCodeGenerator不生效问题

这并非Spring Boot与Spring Batch的兼容性问题，而是两者设计逻辑差异导致的：Spring Batch会捕获步骤执行中的异常，将其封装为任务失败状态而非直接向上传播到Spring Boot应用上下文层级，因此你实现的ExitCodeGenerator无法感知到Tasklet抛出的自定义异常，最终返回的是Spring Batch默认的失败退出码5。

以下是具体解决方案：

方案一：通过JobExecution结果自定义退出码 #

自定义一个ExitCodeGenerator，从Spring Batch的JobExplorer中获取任务执行记录，根据异常类型返回对应退出码：

@Component
public class BatchExitCodeGenerator implements ExitCodeGenerator {

    @Autowired
    private JobExplorer jobExplorer;

    @Override
    public int getExitCode() {
        // 替换为你的Job名称
        List<JobInstance> jobInstances = jobExplorer.getJobInstances("yourBatchJob", 0, 1);
        if (!jobInstances.isEmpty()) {
            List<JobExecution> jobExecutions = jobExplorer.getJobExecutions(jobInstances.get(0));
            if (!jobExecutions.isEmpty()) {
                JobExecution latestExecution = jobExecutions.get(jobExecutions.size() - 1);
                // 遍历步骤执行记录，检查异常类型
                for (StepExecution stepExecution : latestExecution.getStepExecutions()) {
                    Throwable failureCause = stepExecution.getFailureCause();
                    if (failureCause instanceof MyCustomException) {
                        return ((MyCustomException) failureCause).getExitCode();
                    }
                }
                // 非自定义异常导致的失败，返回默认Batch失败码
                if (latestExecution.getStatus() == BatchStatus.FAILED) {
                    return 5;
                }
            }
        }
        // 任务成功返回0
        return 0;
    }
}

方案二：启动类中手动关联任务执行结果 #

在启动类中直接执行Job并处理结果，跳过Spring Batch的异常封装逻辑：

@SpringBootApplication
@EnableBatchProcessing
public class BatchApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(BatchApplication.class, args);
        
        JobLauncher jobLauncher = context.getBean(JobLauncher.class);
        Job targetJob = context.getBean("yourBatchJob", Job.class);
        
        int exitCode = 0;
        try {
            JobExecution execution = jobLauncher.run(targetJob, new JobParameters());
            if (execution.getStatus() == BatchStatus.FAILED) {
                for (StepExecution stepExec : execution.getStepExecutions()) {
                    Throwable cause = stepExec.getFailureCause();
                    if (cause instanceof MyCustomException) {
                        exitCode = ((MyCustomException) cause).getExitCode();
                        break;
                    }
                }
                // 未匹配到自定义异常，使用默认失败码
                exitCode = exitCode == 0 ? 5 : exitCode;
            }
        } catch (JobExecutionException e) {
            // 处理Job启动阶段的异常
            exitCode = 1;
        }
        
        SpringApplication.exit(context, () -> exitCode);
    }
}

方案三：强制抛出自定义异常（谨慎使用） #

配置Step的异常处理器，将自定义异常重新抛出，让Spring Boot的ExitCodeGenerator感知到，但这种方式会跳过Spring Batch的重试、跳过等容错机制：

@Bean
public Step customStep(Tasklet myTasklet, StepBuilderFactory stepBuilderFactory) {
    return stepBuilderFactory.get("customStep")
            .tasklet(myTasklet)
            .faultTolerant()
            .skipPolicy((throwable, skipCount) -> {
                if (throwable instanceof MyCustomException) {
                    // 直接抛出自定义异常，不进入Batch容错逻辑
                    throw (MyCustomException) throwable;
                }
                return false;
            })
            .build();
}

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