Question

我的Spring启动批处理应用程序有一个调度程序，它安排我在FirstBatchConfiguration类中编写的批处理作业每小时运行一次。

我有另一个批处理作业，我已在同一个应用程序中的SecondBatchConfiguration类中配置，我将安排在一周内运行一次，但我无法弄清楚如何在同一个JobScheduler中安排它，以便两者工作应该按照自己的预定时间进行。

如果有人能帮助我实现这一目标。

我目前的日程安排是：

@Component
public class JobScheduler {

    @Autowired
    private JobLauncher jobLauncher;

    @Autowired
    private FirstBatchConfiguration firstBatchConfiguration;

    @Scheduled(cron = "0 0 0/1 * * ?")
    public void runJob() {

        Map<String, JobParameter> confMap = new HashMap<>();
        confMap.put("time", new JobParameter(System.currentTimeMillis()));
        JobParameters jobParameters = new JobParameters(confMap);
        final Logger logger = LoggerFactory.getLogger("applicationlogger");

        try {

            jobLauncher.run(firstBatchConfiguration.firstJob(), jobParameters);

        } catch (JobExecutionAlreadyRunningException | JobInstanceAlreadyCompleteException
                | JobParametersInvalidException | org.springframework.batch.core.repository.JobRestartException e) {

            logger.error(e.getMessage());
        }
    }

}

Answer 1

如果程序必须运行第二个计划，则添加一个带有计划注释的新方法，例如@Scheduled(cron = "5 8 * * 6 ?")。如果你需要使用SecondBatchConfiguration类，那么只需要Autowired它。

Step1（自动配置您的配置）@Autowired您的SecondBatchConfiguration

示例：

@Autowired
private SecondBatchConfiguration secondBatchConfiguration;

创建一个新方法并使用@Scheduled注释安排它，并在方法体中启动第二个作业。

示例：

@Scheduled(cron = "5 8 * * 6 ?")
public void runSecondJob() { ... }

您可以根据需要拥有多个计划，每个计划都有自己的计划。

@Scheduled(cron = "5 8 * * 6 ?")
public void runSecondJob() { .... }

@Scheduled(cron = "0 0 0/1 * * ?")
public void runJob() { .... }

编辑：异步作业执行

异步作业执行是弹簧批的一个非常强大的功能，有一个很好的文档和示例。

请参阅以下说明以激活异步作业例外：

步骤1：添加作业配置（此替代方案使用内存中的JobRepository）。要阅读有关存储库类型的更多信息，请转至Spring Documentation

创建ResourcelessTransactionManager Bean

   @Bean
    public ResourcelessTransactionManager transactionManager() {
        return new ResourcelessTransactionManager();
    }

创建MapJobRepositoryFactory Bean

@Bean
public MapJobRepositoryFactoryBean mapJobRepositoryFactory(
        ResourcelessTransactionManager txManager) throws Exception {
    MapJobRepositoryFactoryBean factory = new
            MapJobRepositoryFactoryBean(txManager);
    factory.afterPropertiesSet();
    return factory;
}

创建JobRepository Bean

@Bean
public JobRepository jobRepository(
        MapJobRepositoryFactoryBean factory) throws Exception {
    return factory.getObject();
}

创建一个ThreadPoolExecutor（ThreadPoolExecutor负责异步执行，有更多类型的执行程序，你可以在Spring Documentation中阅读更多关于它们的内容）

@Bean
public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setCorePoolSize(5);
    taskExecutor.setMaxPoolSize(10);
    taskExecutor.setQueueCapacity(30);
    return taskExecutor;
}

创建JobLauncher bean

   @Bean
    public JobLauncher jobLauncher(ThreadPoolTaskExecutor taskExecutor, JobRepository jobRepository){
        SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
        jobLauncher.setTaskExecutor(taskExecutor);
        jobLauncher.setJobRepository(jobRepository);
        return jobLauncher;
    }

第2步：启用异步作业执行

转到Spring Boot Application Class和以下注释

@EnableBatchProcessing
@EnableAsync
@EnableScheduling
@SpringBootApplication
public class MyBatchApp {

Answer 2

默认情况下，Spring Boot将仅使用一个线程来运行所有计划的任务。这些任务将被阻止。相反，我将配置计划程序以在单独的线程中运行每个计划的任务：

pam_end

在Spring启动应用程序中调度多个批处理作业

2 个答案: