spring boot 集成 spring-boot-starter-quartz 集群版配置

1、引入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

2、添加quartz配置文件

org.quartz.scheduler.instanceName = schedulerFactoryBean
org.quartz.scheduler.instanceId = AUTO
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.useProperties = false
org.quartz.jobStore.isClustered=true
org.quartz.jobStore.clusterCheckinInterval=30000
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5

3、quartz 使用

1.  开启配置

package cn.xs.qishi.cas.quartz;

import cn.xs.ambi.jds.dd.RoutingDatasource;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

/**
 * @author liuxn
 * @date 2022/6/28
 */
@Configuration
public class SchedulerConfig {

    @Autowired
    private RoutingDatasource datasource;

    public static class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
            ApplicationContextAware {

        private transient AutowireCapableBeanFactory beanFactory;

        @Override
        public void setApplicationContext(final ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }

        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    }


    @Bean
    public JobFactory jobFactory() {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        return jobFactory;
    }


    @Bean(destroyMethod = "destroy", autowire = Autowire.NO)
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws Exception {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //将spring管理job自定义工厂交由调度器维护
        schedulerFactoryBean.setJobFactory(jobFactory);
        //设置覆盖已存在的任务
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        //设置数据源，使用与项目统一数据源
        schedulerFactoryBean.setDataSource(datasource);
        //设置配置文件位置
        schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
        return schedulerFactoryBean;
    }
}

备注：以上是业务和quartz使用同一个数据源若使用独立数据源则使用注解 @QuartzDataSource 

　　2. 业务使用

package cn.xs.qishi.cas.quartz;

import cn.xs.ambi.bas.util.DateUtils;
import cn.xs.qishi.cas.constant.Constant;
import lombok.CustomLog;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 定时任务调度器
 *
 * @author liuxn
 * @date 2022/6/28
 */
@Component
@CustomLog
public class MonitorWoJobService {

    @Autowired
    private Scheduler scheduler;

    //删除任务
    public void deleteJob(JobDto job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobNo(), job.getJobGroup());
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobNo(), job.getJobGroup());
        boolean exists = scheduler.checkExists(jobKey);
        Trigger trigger = scheduler.getTrigger(triggerKey);
        if (exists && trigger != null) {
            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(jobKey);
        }
        log.info(">> 删除任务taskId:" + job.getJobId() + "taskNo:[" + job.getJobNo() + "]");
    }

    //更新任务
    public void updateJob(JobDto job) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobNo(), job.getJobGroup());
        Date startAt = DateBuilder.evenHourDateBefore(job.getStart());
        SimpleTrigger trigger = (SimpleTrigger) scheduler.getTrigger(triggerKey);
        TriggerBuilder<SimpleTrigger> triggerBuilder = trigger.getTriggerBuilder();
        SimpleScheduleBuilder newBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInMinutes(job.getInterval()).repeatForever();
        triggerBuilder.withIdentity(triggerKey).withSchedule(newBuilder);
        triggerBuilder.startAt(startAt);
        if (job.getEnd() != null) {
            triggerBuilder.endAt(job.getEnd());
        }
        trigger = triggerBuilder.build();
        scheduler.rescheduleJob(triggerKey, trigger);
        log.info(">> 更新任务taskId:" + job.getJobId() + "taskNo:[" + job.getJobNo() + "],开始时间:[" + DateUtils.emptyFormat(startAt) + "],时间间隔:[" + job.getInterval() + "]分钟");
    }

    //添加任务
    public void addJob(JobDto job) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(MonitorWoJob.class).withIdentity(job.getJobNo(), job.getJobGroup()).storeDurably().build();
        Date startAt = DateBuilder.evenHourDateBefore(job.getStart() == null ? new Date() : job.getStart());
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put(Constant.Task.TASK_ID, job.getJobId());
        jobDataMap.put(Constant.Task.TASK_NO, job.getJobNo());
        Trigger trigger = TriggerBuilder
                .newTrigger()
                .withSchedule(SimpleScheduleBuilder.repeatMinutelyForever(job.getInterval()))
                .usingJobData(jobDataMap).startAt(startAt)
                .forJob(jobDetail.getKey())
                .build();
        boolean exists = scheduler.checkExists(jobDetail.getKey());
        if (exists) {
            log.info(">> 移除任务");
            scheduler.pauseTrigger(trigger.getKey());
            scheduler.unscheduleJob(trigger.getKey());
            scheduler.deleteJob(jobDetail.getKey());
        }
        scheduler.scheduleJob(jobDetail, trigger);
        log.info(">> 任务调度器启动状态：" + scheduler.isStarted());
        if (!scheduler.isStarted()) {
            scheduler.start();
        }
        log.info(">> 新增任务taskId:[" + job.getJobId() + "],taskNo:[" + job.getJobNo() + "],开始时间:[" + DateUtils.emptyFormat(startAt) + "],时间间隔:[" + job.getInterval() + "]分钟");
    }
}

　　3.任务类

package cn.xs.qishi.cas.quartz;

import cn.xs.ambi.mgt.redis.RedisManager;
import cn.xs.qishi.cache.key.RedisPrefixOfCas;
import cn.xs.qishi.cas.constant.Constant;
import cn.xs.qishi.cas.service.impl.CasMonitorTaskServiceTx;
import cn.xs.qishi.entity.pojo.WoMonitorRule;
import cn.xs.qishi.entity.pojo.WoMonitorTask;
import com.alibaba.fastjson.JSON;
import lombok.CustomLog;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * 任务
 *
 * @author liuxn
 * @date 2022/6/28
 */
@CustomLog
@Component
@DisallowConcurrentExecution
public class MonitorWoJob extends QuartzJobBean {


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        try {
            JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
            log.info(">> 工单监控任务触发 " + JSON.toJSONString(jobDataMap));
          //todo 实现自己的业务
        } catch (Exception e) {
            log.error("工单监控计算job异常", e);
        }
    }
}

备注：@DisallowConcurrentExecution 注解使用保证了同一个任务只能在一台机器上触发 本demo是才是  SimpleScheduleBuilder 实现。  CronScheduleBuilder 详情见 官放文档 http://www.quartz-scheduler.org/documentation