如何触发预定的 Spring Batch Job？

Question

我希望能够使用 REST 控制器开始我的工作，然后当工作开始时，它应该按计划运行，直到我再次使用 REST 停止它。

所以这是我的控制器：

 @RestController
public class LauncherController {

    @Autowired
    JobLauncher jobLauncher;

    @Autowired
    Job job;

    @RequestMapping("/launch")
    public String launch() throws Exception {
             ...
            jobLauncher.run(job, jobParameters);
    }

这是 Batch conf 的一部分：

 @Configuration
@EnableBatchProcessing
@EnableScheduling
public class BatchConfiguration {

    @Autowired
    public JobBuilderFactory jobBuilderFactory;

    @Autowired
    public StepBuilderFactory stepBuilderFactory;

    @Scheduled(cron = "0/5 * * * * ?")
    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
                .incrementer(new RunIdIncrementer())
                .flow(step1())
                .end()
                .build();
    }

    @Bean
    public Step step1() {
        return stepBuilderFactory.get("step1")
                .<Person, Person> chunk(10)
                .reader(reader())
                .processor(processor())
                .writer(writer())
                .build();
    }

我还设置了属性 spring.batch.job.enabled=false，因为我不希望作业在 Spring Boot App 启动时立即运行。

现在我可以调用我的 Rest api lauch，并且作业运行，但只有一次。调度程序不工作。而且我无法弄清楚我应该在哪里定义我的@Scheduled Annotation ..

原文由 akcasoy 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

我会以某种方式处理它，计划的作业始终运行，但它仅在标志设置为 true 时才执行某些操作：

 @Component
class ScheduledJob {

    private final AtomicBoolean enabled = new AtomicBoolean(false);

    @Scheduled(fixedRate = 1000)
    void execute() {
        if (enabled.get()) {
            // run spring batch here.
        }
    }

    void toggle() {
        enabled.set(!enabled.get());
    }

}

和一个控制器：

 @RestController
class HelloController {

    private final ScheduledJob scheduledJob;

    // constructor

    @GetMapping("/launch")
    void toggle() {
        scheduledJob.toggle();
    }

}

原文由 Maciej Walkowiak 发布，翻译遵循 CC BY-SA 3.0 许可协议

Answer 2

首先你要定义工作：

 @Bean
@Qualifier("fancyScheduledJob")
public Job job() {
    return jobBuilderFactory.get("job")
            .incrementer(new RunIdIncrementer())
            .flow(step1())
            .end()
            .build();
}

其次，您将开始执行此作业：

 @Autowired
@Qualifier(value = "fancyScheduledJob")
private Job job;

@Autowired
private JobLauncher jobLauncher;

@Scheduled(cron = "0/5 * * * * ?")
public void launch() throws JobParametersInvalidException, JobExecutionAlreadyRunningException, JobRestartException, JobInstanceAlreadyCompleteException, JobInstanceAlreadyExistsException, NoSuchJobException {

    jobLauncher.run(job, JobParametersBuilder()
            .addLong("launchTime", System.currentTimeMillis())
            .toJobParameters())
}

另请注意，引入了“launchTime”参数：默认情况下，spring batch 会阻止使用相同参数值启动作业。

虽然您的日程安排非常紧凑 - 每 5 秒您应该注意并发性。或者，如果您想确保每时每刻只执行 1 个作业实例，您可以配置自定义单线程作业启动器：

 @Bean(name = "fancyJobExecutorPool")
public TaskExecutor singleThreadedJobExecutorPool() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(1);
    executor.setMaxPoolSize(1);
    executor.setQueueCapacity(100500);
    executor.setThreadNamePrefix("fancy-job-batch-");
    return executor;
}

@Bean(name = "fancyJobLauncher")
public JobLauncher singleThreadedJobLauncher(JobRepository jobRepository)
{
    SimpleJobLauncher sjl = new SimpleJobLauncher();
    sjl.setJobRepository(jobRepository);
    sjl.setTaskExecutor(singleThreadedJobExecutorPool());
    return sjl;
}

并在启动时使用这个单线程作业启动器。

 @Autowired
@Qualifier("fancyJobLauncher")
private JobLauncher jobLauncher;

有了这个，您的作业实例将一个接一个地执行（但这并不限制作业中步骤的并行执行）。

原文由 Ilya Dyoshin 发布，翻译遵循 CC BY-SA 3.0 许可协议