Spring Batch动态步骤序列作业构建：避免DuplicateJobException及最佳实践

需求说明 #

• 执行作业时从数据库读取动态步骤序列
• 无需重启应用即可生效步骤序列的变更
• 安全处理作业的并发执行

现有实现尝试 #

当前实现（工厂方法方式） #

@Configuration
@RequiredArgsConstructor
@Slf4j
public class DynamicBatchStepsConfig {
    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final AppPreferencesRepository appPreferencesRepository;  // JPA Repository

    // Factory method approach - no @Bean annotation
    public Job createDynamicJob(String stepSequence,
                              @Qualifier("dynamicStep0") Step dynamicStep0,
                              @Qualifier("dynamicStep1") Step dynamicStep1,
                              // ... other steps
                              ) throws JsonProcessingException {
        
        String uniqueJobName = "dynamicStepsJob-" + UUID.randomUUID();
        DynamicStepsDTO dynamicStepsDTO = getStepSequence(stepSequence);
        Step[] stepsArray = {dynamicStep1, dynamicStep2, /*...*/};
        
        if (dynamicStepsDTO != null && dynamicStepsDTO.getSteps() != null) {
            Step[] stepSequence = getStepsInSequence(dynamicStepsDTO, stepsArray);
            return new JobBuilder(uniqueJobName, jobRepository)
                    .incrementer(new RunIdIncrementer())
                    .start(dynamicStep0)
                    .next(/*...sequence of steps...*/)
                    .build();
        }
        throw new RuntimeException("Dynamic Steps Sequence not Defined");
    }

    @Bean("dynamicStep0")
    public Step dynamicStep0(@Qualifier("step0Tasklet") Tasklet step0Tasklet) {
        return new StepBuilder("step0Tasklet", jobRepository)
                .tasklet(step0Tasklet, transactionManager)
                .build();
    }
    // Other step @Bean definitions...
}

尝试1：原型作用域@Bean #

@Bean
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public Job dynamicStepsJob(/*parameters*/) {
    // Job building logic
}

结果：启动时报错DuplicateJobException：已注册同名作业配置[dynamicStepsJob]

尝试2：添加@Lazy的原型Bean #

@Bean
@Lazy
@Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
public Job dynamicStepsJob(/*parameters*/) {
    // Job building logic
}

结果：启动时仍出现相同的重复作业错误

尝试3：工厂方法（当前在用） #

// No @Bean annotation, just a factory method
public Job createDynamicJob(/*parameters*/) {
    // Job building logic with unique name
}

结果：可运行，但不确定是否为最佳实践

尝试4：子ApplicationContext方案 #

public Job getRefreshedJob() throws Exception {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
    
    // Register required infrastructure beans
    ctx.registerBean("jobRepository", JobRepository.class, () -> jobRepository);
    ctx.registerBean("transactionManager", PlatformTransactionManager.class, () -> transactionManager);
    
    // Need to handle JPA repository which is complex
    // AppPreferencesRepository is a JPA interface
    ctx.registerBean("appPreferencesRepository", AppPreferencesRepository.class, () -> appPreferencesRepository);
    
    // Register all tasklets
    ctx.registerBean("step0Tasklet", Tasklet.class, () -> step0Tasklet);
    ctx.registerBean("step1Tasklet", Tasklet.class, () -> step1Tasklet);
    // ... other tasklets
    
    // Register configuration
    ctx.register(DynamicBatchStepsConfig.class);
    ctx.refresh();
    
    Job job = ctx.getBean("dynamicStepsJob", Job.class);
    ctx.close();
    
    return job;
}

结果：可运行，但配置复杂，处理JPA仓库繁琐，且存在内存占用、资源清理风险，已放弃

核心疑问 #

1. 移除@Bean注解使用工厂方法是否为正确方案？
2. 每次执行创建新作业实例是否存在内存/线程安全问题？
3. 处理Spring Batch动态作业配置是否有更优方式？

环境：Spring Boot 3.x、Spring Batch 5.x、Java 17

要求：确保并发线程安全、内存高效、符合Spring Bean生命周期规范、始终使用最新配置。

解答与推荐方案 #

1. 工厂方法方案的正确性 #

工厂方法是完全可行且符合Spring Batch设计意图的方案。Spring Batch允许通过JobBuilder手动构建Job实例，无需将其注册为Spring Bean——只有那些需要被Spring Batch自动配置或调度器管理的静态作业才需要@Bean注解。你的场景中作业是动态生成的，每次执行都基于最新配置，不需要纳入Spring Bean容器管理，因此去掉@Bean是合理选择。

2. 新作业实例的内存与线程安全问题 #

• 内存层面：Job实例本身是轻量级对象，仅持有步骤引用和配置信息，而步骤（Step）是预先定义的单例Bean，不会重复创建。只要Job实例在执行完成后能被GC正常回收，就不会有内存泄漏风险，内存占用完全可控。
• 线程安全层面：Job实例本身无状态，作业的执行上下文（ExecutionContext）由Spring Batch单独管理并存储在JobRepository中，每个作业执行实例（JobExecution）都有独立上下文，因此并发执行时不会出现线程安全问题。需要注意：所有Tasklet实现必须是线程安全的（作为单例Bean），不要在Tasklet中存储执行相关状态，如需状态应使用StepExecution的ExecutionContext。

3. 更优的Spring原生实现方式 #

针对你的需求，推荐基于JobLauncher+动态Job构建的模式，结合以下优化点：

优化后的工厂方法实现

@Configuration
@RequiredArgsConstructor
@Slf4j
public class DynamicJobFactory {
    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final AppPreferencesRepository appPreferencesRepository;
    // 利用Spring自动注入所有注册的Step Bean到Map，key为Bean名称
    private final Map<String, Step> stepMap;

    public Job createDynamicJob(String stepSequenceKey) throws JsonProcessingException {
        // 1. 实时读取数据库最新步骤配置
        DynamicStepsDTO dynamicStepsDTO = fetchLatestStepConfig(stepSequenceKey);
        if (dynamicStepsDTO == null || dynamicStepsDTO.getSteps().isEmpty()) {
            throw new RuntimeException("Dynamic Steps Sequence not Defined for key: " + stepSequenceKey);
        }

        // 2. 生成唯一作业名称，避免冲突
        String uniqueJobName = "dynamicJob-" + stepSequenceKey + "-" + UUID.randomUUID();

        // 3. 构建步骤执行链
        JobBuilder jobBuilder = new JobBuilder(uniqueJobName, jobRepository)
                .incrementer(new RunIdIncrementer());

        Step firstStep = stepMap.get(dynamicStepsDTO.getSteps().get(0));
        SimpleJobBuilder simpleJobBuilder = jobBuilder.start(firstStep);

        for (int i = 1; i < dynamicStepsDTO.getSteps().size(); i++) {
            Step nextStep = stepMap.get(dynamicStepsDTO.getSteps().get(i));
            simpleJobBuilder = simpleJobBuilder.next(nextStep);
        }

        return simpleJobBuilder.build();
    }

    private DynamicStepsDTO fetchLatestStepConfig(String stepSequenceKey) {
        // 实现从数据库读取并反序列化为DTO的逻辑
        return appPreferencesRepository.findByKey(stepSequenceKey)
                .map(pref -> /* 反序列化为DynamicStepsDTO */)
                .orElse(null);
    }
}

作业触发方式

在业务服务中注入DynamicJobFactory和JobLauncher，每次执行时创建最新Job实例并启动：

@Service
@RequiredArgsConstructor
public class JobTriggerService {
    private final DynamicJobFactory dynamicJobFactory;
    private final JobLauncher jobLauncher;

    public void triggerDynamicJob(String stepSequenceKey) throws Exception {
        Job job = dynamicJobFactory.createDynamicJob(stepSequenceKey);
        JobParameters jobParameters = new JobParametersBuilder()
                .addString("executionId", UUID.randomUUID().toString())
                .toJobParameters();
        jobLauncher.run(job, jobParameters);
    }
}

关键优化点

• 自动注入所有Step：通过Map<String, Step>自动获取所有注册的Step Bean，无需手动逐个注入，简化配置维护。
• 实时读取最新配置：每次创建Job时从数据库拉取最新步骤序列，确保配置变更即时生效。
• 唯一作业名称：组合配置Key和UUID生成唯一名称，彻底避免Job名称冲突问题。
• 轻量级实例管理：Job实例仅在执行时创建，执行完成后可被GC回收，内存使用高效。

额外注意事项 #

• Tasklet线程安全：所有预定义的Step和Tasklet必须是线程安全的单例Bean，不要在Tasklet中存储执行相关状态。
• JobRepository配置：确保JobRepository使用合适的事务管理器，多作业/多租户场景下可配置表前缀避免冲突。
• 并发控制：如需限制相同配置的作业并发执行，可通过JobParameters添加唯一标识，或使用JobExecutionDecider实现自定义并发控制逻辑。

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