spring boot2.X版本集成quartz并实现@Autowired自动注入

近期工作需求实现用到了quartz框架，特地针对此框架进行了一些研究：
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。
先介绍几个概念：
1、Job 表示一个工作，要执行的具体内容。
2、JobDetail 表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。
3、Trigger 代表一个调度参数的配置，什么时候去调。
4、Scheduler 代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。
简单集成的话很简单，但是要实现@Autowired的话需要把quartz的类都交由spring管理，因为quartz是有自己的context的，好了，直接上集成代码了：
1、首先引入jar包

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>2.3.7.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
        </dependency>

2、定义Quartz管理类

import org.apache.commons.collections.CollectionUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;
import java.util.Set;

/**
 * @Author:
 * @Description:
 * @Date:Created in 20:22 2020/11/14
 * @Modify by:
 */
@Component
public class QuartzManager {

    private static Logger logger = LoggerFactory.getLogger(QuartzManager.class);


    @Autowired
    private Scheduler scheduler;


    /**
     * 新添加一个调度作业
     *
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * @param jobClazz
     * @param cron
     * @param dataMap
     * @return
     * @throws SchedulerException
     */
    public boolean addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
                          Class<? extends Job> jobClazz, String cron, JobDataMap dataMap) throws SchedulerException {

        logger.info("添加一个job,设备编号为{}", jobName);
        JobKey jobKey = new JobKey(jobName, jobGroupName);
        boolean flag = isExistJob(jobKey);
        if (flag) {
            logger.error("已存在该任务，jobName：" + jobName + " jobGroupName:" + jobGroupName);
            return false;
        }

        boolean checkResult = isValidExpression(cron);
        if (!checkResult) {
            logger.error("非法的cron表达式，cron：" + cron);
        }


        JobDetail jobDetail = JobBuilder.newJob(jobClazz).withIdentity(jobKey).usingJobData(dataMap).build();
        TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(cron)).build();
        CronTriggerImpl cronTrigger = (CronTriggerImpl) trigger;
        cronTrigger.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
        scheduler.scheduleJob(jobDetail, cronTrigger);
        scheduler.start();
        return true;
    }


    /**
     * 检查一个job是否存在
     *
     * @param jobKey jobKey
     * @return true存在，false不存在
     * @throws SchedulerException
     */
    public boolean isExistJob(JobKey jobKey) throws SchedulerException {
        return CollectionUtils.isNotEmpty(scheduler.getTriggersOfJob(jobKey));
    }

    /**
     * 是否存在job
     *
     * @param jobName      jobName
     * @param jobGroupName jobGroupName
     * @return
     * @throws SchedulerException
     */
    public boolean isExistJob(String jobName, String jobGroupName) throws SchedulerException {
        return isExistJob(new JobKey(jobName, jobGroupName));
    }

    /**
     * 判断是否是正确的cron quarz 表达式
     *
     * @param cronExpression cron表达式
     * @return boolean
     */
    public boolean isValidExpression(String cronExpression) {
        return cronExpression != null && CronExpression.isValidExpression(cronExpression);
    }


    /**
     * 更改一个job的调度时间
     *
     * @param triggerName
     * @param triggerGroupName
     * @param cron
     * @return
     * @throws SchedulerException
     */
    public boolean modifyJobTriggerTime(String triggerName, String triggerGroupName, String cron) throws SchedulerException {

        boolean flag = isValidExpression(cron);
        if (flag) {
            logger.error("不是一个正确的cron表达式");
            return false;
        }

        Set<TriggerKey> triggerKeys = scheduler.getTriggerKeys(GroupMatcher.triggerGroupStartsWith(triggerGroupName));
        if (CollectionUtils.isEmpty(triggerKeys)) {
            logger.error("找不到触发器");
            return false;
        }
        for (TriggerKey triggerKey : triggerKeys) {
            scheduler.unscheduleJob(triggerKey);
        }

        TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroupName);

        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(new TriggerKey(triggerName, triggerGroupName))
                .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                .build();
        CronTriggerImpl cronTrigger = (CronTriggerImpl) trigger;
        cronTrigger.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
        scheduler.rescheduleJob(triggerKey, cronTrigger);
        return true;
    }

    /**
     * 移除一个job
     *
     * @param jobName
     * @param jobGroupName
     * @return
     * @throws SchedulerException
     */
    public boolean removeJob(String jobName, String jobGroupName) throws SchedulerException {

        try {
            JobKey jobKey = new JobKey(jobName, jobGroupName);
            if (isExistJob(jobKey)) {
                scheduler.deleteJob(jobKey);
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

    /**
     * 移除一个job
     *
     * @param jobKey
     * @return
     * @throws SchedulerException
     */
    public boolean removeJob(JobKey jobKey) throws SchedulerException {

        try {
            if (isExistJob(jobKey)) {
                scheduler.deleteJob(jobKey);
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }


    /**
     * @param
     * @Author:
     * @Description: 移除所有的job
     * @Date:Created in 2020/11/18_11:16
     * @Modify by:
     */
    public void removeAllJobs() {
        try {
            for (String groupName : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                    if (isExistJob(jobKey)) {
                        scheduler.deleteJob(jobKey);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 暂停一个作业
     *
     * @param jobName
     * @param groupName
     * @return
     * @throws SchedulerException
     */
    public boolean pauseJob(String jobName, String groupName) throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, groupName);
        scheduler.pauseJob(jobKey);
        return true;
    }

    /**
     * 恢复一个作业
     *
     * @param jobName
     * @param groupName
     * @return
     * @throws SchedulerException
     */
    public boolean resumeJob(String jobName, String groupName) throws SchedulerException {
        JobKey jobKey = new JobKey(jobName, groupName);
        scheduler.resumeJob(jobKey);
        return true;
    }

    public boolean shutDownScheduler() throws SchedulerException {
        scheduler.shutdown(true);
        return true;
    }


    /**
     * 获取下次的执行时间列表
     *
     * @param cron     cron表达式
     * @param numTimes 多少个
     * @return Date
     */
    public static List<Date> getNextFireTimeDate(String cron, Integer numTimes) {

        List<Date> dates = null;
        try {
            CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
            cronTriggerImpl.setCronExpression(cron);
            dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, numTimes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dates;
    }

    /**
     * 获取trigger状态:
     * None：Trigger已经完成，且不会在执行，或者找不到该触发器，或者Trigger已经被删除
     * NORMAL:   正常状态
     * PAUSED：  暂停状态
     * COMPLETE：触发器完成，但是任务可能还正在执行中
     * BLOCKED： 线程阻塞状态
     * ERROR：   出现错误
     *
     * @param triggerName
     * @param triggerGroup
     * @return
     * @throws SchedulerException
     */
    public String getTriggerState(String triggerName, String triggerGroup) throws SchedulerException {
        TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
        Trigger.TriggerState triggerState = scheduler.getTriggerState(triggerKey);
        return triggerState.name();

    }

    /**
     * 安全关闭
     *
     * @throws SchedulerException
     */
    public void safeShutdown() throws SchedulerException {
        if (!scheduler.isShutdown()) {
            int executingJobSize = scheduler.getCurrentlyExecutingJobs().size();
            logger.info("安全关闭 当前还有" + executingJobSize + "个任务正在执行，等待完成后关闭");
            //等待任务执行完后安全关闭
            scheduler.shutdown(true);

            logger.info("安全关闭 成功");
        }
    }
}

3、QuartzJobFactory工厂类

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:06 2020/11/21
 * @Modify by:
 */
@Component
public class QuartzJobFactory extends SpringBeanJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

4、QuartzConfig配置类

import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:07 2020/12/21
 * @Modify by:
 */
@Configuration

public class QuartzConfig {

    @Autowired
    private QuartzJobFactory quartzJobFactory;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobFactory(quartzJobFactory);
        QuartzJobListener jobListener = new QuartzJobListener();
        //添加job监听器,或其它trigger监听器
        factory.setGlobalJobListeners(jobListener);
        return factory;
    }

    @Bean
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }

}

5、QuartzJobListener监听类，可在job执行前后随意加逻辑

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:08 2020/12/21
 * @Modify by:
 */
public class QuartzJobListener implements JobListener {
    @Override
    public String getName() {
        return "QuartzJobListener";
    }


    /**
     * @param
     * @Author:
     * @Description:任务执行之前执行
     * @Date:Created in 2020/12/21_14:26
     * @Modify by:
     */
    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {

        System.out.println("QuarztJob开始执行！！！");
    }


    /**
     * @param
     * @Author:
     * @Description: 这个方法正常情况下不执行, 但是如果当TriggerListener中的vetoJobExecution方法返回true时, 那么执行这个方法;
     * 需要注意的是如果此方法执行那么前后这俩个方法不会执行,因为任务被终止了嘛.
     * @Date:Created in 2020/12/21_14:26
     * @Modify by:
     */
    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {

        System.out.println("QuartzJob执行出现异常，任务被终止！！！");

    }

    /**
     * @param
     * @Author:
     * @Description:任务执行完成后执行
     * @Date:Created in 2020/12/21_14:27
     * @Modify by:
     */
    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {

        System.out.println("QuartzJob执行完毕！！！");

    }
}

6、job类

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:18 2020/12/21
 * @Modify by:
 */
public class QuartzJob implements Job {

    @Autowired
    private QuartzServce quartzServce;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //获取创建job时传过来的参数
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        String param1 = jobDataMap.get("param1").toString();
        String param2 = jobDataMap.get("param2").toString();
        String param3 = jobDataMap.get("param3").toString();
        //调取quartzServce服务方法
        quartzServce.doEverying(param1, param2, param3);
    }
}

7、JobProducer job任务生产类

import org.quartz.JobDataMap;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:10 2020/12/21
 * @Modify by:
 */
@Component
public class JobProducer {
    @Autowired
    private QuartzManager quartzManager;
    private void ProductJob() {
        String jobName = "jobName1";
        String jobGroupName = "jobGroupName1";
        String triggerName = "triggerName1";
        String triggerGroupName = "triggerGroupName1";
        String cron = "0 0 /1 * * ? ";
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("param1", "param1");
        jobDataMap.put("param2", "param2");
        jobDataMap.put("param3", "param3");
        jobDataMap.put("param4", "param4");
        try {
            quartzManager.addJob(jobName, jobGroupName, triggerName, triggerGroupName, QuartzJob.class, cron, jobDataMap);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

7、QuartzServce自定义业务逻辑类

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:20 2020/12/21
 * @Modify by:
 */
public interface QuartzServce {

    void doEverying(String param1, String param2, String param3);
}

7、QuartzServceImpl自定义业务逻辑实现类

import org.springframework.stereotype.Service;

/**
 * @Author:
 * @Description:
 * @Date:Created in 14:22 2020/12/21
 * @Modify by:
 */

@Service
public class QuartzServceImpl implements QuartzServce {
    @Override
    public void doEverying(String param1, String param2, String param3) {

    }
}

全套集成代码即拿即用，有问题欢迎大家留言、点赞