springquartz：禁用Quartz调度程序

我们有一个石英调度器服务

此服务可以根据某些需要进行相应的扩展

我们的Quartz调度程序未处于群集模式。

因此，我们需要根据环境变量启用或禁用调度器

不能将服务拆分为两个独立的服务。

这是我们的相关石英配置类：

@Configuration
public class QuartzSchedulerConfiguration {

    private static final String HOURLY_CRON_EXPRESSION = "0 0 * * * ?";
    private static final String MIDNIGHT_CRON_EXPRESSION = "0 0 0 * * ?";

    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, Trigger[] fitxersJobTrigger)
            throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setOverwriteExistingJobs(true);
        factory.setAutoStartup(true);
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        factory.setTriggers(fitxersJobTrigger);

        return factory;
    }

    @Bean
    public JobDetailFactoryBean loadPendingDocumentsJobDetail() {
        return createJobDetailFactoryBean(LoadPendingDocumentsJob.class);
    }

    @Bean
    public SimpleTriggerFactoryBean loadPendingDocumentsJobTrigger(
            @Qualifier("loadPendingDocumentsJobDetail") JobDetail jobDetail) {

        long interval = jobsConfiguration.get().getParameters().stream()
            .filter(param -> "loadPendingDocumentsJobInterval".equals(param.getName()))
            .findAny()
            .map(param -> (Integer)param.getValue())
            .orElse(600000); // every 10 minutes

        LOG.debug("loadPendingDocumentsJobInterval = " + interval);
        return createIntervalTriggerFactoryBean(jobDetail, interval);
    }

    private  CronTriggerFactoryBean createCronTriggerFactoryBean(JobDetail jobDetail, String expression) {
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetail);
        factoryBean.setCronExpression(expression);
        factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
        return factoryBean;
    }

    private JobDetailFactoryBean createJobDetailFactoryBean(Class<? extends Job> jobClass) {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        factoryBean.setJobClass(jobClass);
        factoryBean.setDurability(true);
        return factoryBean;
    }

    private SimpleTriggerFactoryBean createIntervalTriggerFactoryBean(JobDetail jobDetail, long interval) {
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
        factoryBean.setJobDetail(jobDetail);
        factoryBean.setStartDelay(0L);
        factoryBean.setRepeatInterval(interval);
        factoryBean.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
        factoryBean.setMisfireInstruction(SimpleTrigger.MISFIRE_INSTRUCTION_FIRE_NOW);
        return factoryBean;
    }

}

@配置
公共类QuartzSchedulerConfiguration{
私有静态最终字符串HOURLY_CRON_EXPRESSION=“0***？”；
私有静态最终字符串MIDNIGHT\u CRON\u EXPRESSION=“0**？”；
@豆子
公共作业工厂作业工厂（应用程序上下文应用程序上下文）{
AutowiringSpringBeanJobFactory=新的AutowiringSpringBeanJobFactory（）；
jobFactory.setApplicationContext（applicationContext）；
返厂；
}
@豆子
公共SchedulerFactoryBean SchedulerFactoryBean（JobFactory JobFactory，触发器[]fitxersJobTrigger）
抛出IOException{
SchedulerFactoryBean工厂=新SchedulerFactoryBean（）；
factory.setOverwriteExistingJobs（true）；
工厂设置自动启动（真）；
工厂。设置jobFactory（jobFactory）；
setQuartzProperties（quartzProperties（））；
工厂设置触发器（fitxersJobTrigger）；
返回工厂；
}
@豆子
public JobDetailFactoryBean loadPendingDocumentsJobDetail（）{
返回createJobDetailFactoryBean（LoadPendingDocumentsJob.class）；
}
@豆子
公共SimpleTriggerFactoryBean loadPendingDocumentsJobTrigger(
@限定符（“loadPendingDocumentsJobDetail”）作业详细信息（作业详细信息）{
long interval=jobsConfiguration.get（）.getParameters（）.stream（）
.filter（param->“LoadPendingDocumentsJobiInterval”.equals（param.getName（）））
.findAny（）
.map（param->（整数）param.getValue（））
.orElse（600000）；//每10分钟
LOG.debug（“LoadPendingDocumentsJobiInterval=“+interval”）；
返回createIntervalTriggerFactoryBean（作业详细信息，间隔）；
}
私有CronTriggerFactoryBean createCronTriggerFactoryBean（JobDetail JobDetail，字符串表达式）{
CronTriggerFactoryBean factoryBean=新的CronTriggerFactoryBean（）；
setJobDetail（jobDetail）；
setCronExpression（表达式）；
factoryBean.setMisfireInstruction（SimpleTrigger.MISFIRE\u INSTRUCTION\u FIRE\u NOW）；
返回factoryBean；
}
私有JobDetailFactoryBean createJobDetailFactoryBean（Class您可以尝试在您的配置类上使用
@ConditionalOnProperty
注释。
如果我理解正确，您需要创建一个服务类来运行作业。因此，我会在spring中使用@Scheduled注释，它实际上将cron作为参数，例如@Scheduled（cron=“0**？”）您可以将其置于要计划的任何方法之上。请参阅此处的进一步信息：