springboot+quartz定时任务（解决无法注入bean及持久化的问题）

该文章解决的两个痛点：

1.无法注入bean

2.任务持久化问题

效果：

1.生成任务时自动生成任务到数据库

2.结束时任务自动删除

3.宕机后重启，会自动重启任务

一、依赖

<!--quartz定时调度依赖-->
     <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.2</version>
	 </dependency>

二、properties配置

#=======================================================
#调度器配置
#=======================================================
org.quartz.scheduler.instanceId=AUTO
org.quartz.scheduler.instanceName=project1QuartzScheduler
org.quartz.scheduler.rmi.export=false
org.quartz.scheduler.rmi.proxy=false
#=======================================================
#线程池配置
#=======================================================
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=5
org.quartz.threadPool.threadPriority=5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
#=======================================================
#JobStore配置
#=======================================================
org.quartz.jobStore.misfireThreshold = 1000
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.isClustered=false
org.quartz.jobStore.tablePrefix=QRTZ_
org.quartz.jobStore.dataSource=myDS
#=======================================================
#数据库配置
#=======================================================
org.quartz.dataSource.myDS.driver=com.mysql.cj.jdbc.Driver
org.quartz.dataSource.myDS.URL=jdbc:mysql://127.0.0.1:3306/phoenix?characterEncoding=utf8&characterSetResults=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false&serverTimezone=UTC
org.quartz.dataSource.myDS.user=root
org.quartz.dataSource.myDS.password=root
org.quartz.dataSource.myDS.maxConnections=10

三、任务调度器 Scheduler

package com.nz.phoenix.irrigate.dao.impl;

import org.quartz.Scheduler;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;


@Configuration
public class QuartzConfig {
    @Autowired
    private JobFactory jobFactory;
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    
    /**
     * 当触发器触发时，与之关联的任务被Scheduler中配置的JobFactory实例化，也就是每触发一次，就会创建一个任务的实例化对象
     * (如果缺省)则调用Job类的newInstance方法生成一个实例
     * (这里选择自定义)并将创建的Job实例化交给IoC管理
     * @return
     */
    @Bean
    public JobFactory jobFactory() {
        return new AdaptableJobFactory() {
            @Override
            protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
                Object jobInstance = super.createJobInstance(bundle);
                capableBeanFactory.autowireBean(jobInstance);
                return jobInstance;
            }
        };
    }

    /**
     * 配置SchedulerFactoryBean
     *
     * 将一个方法产生为Bean并交给Spring容器管理
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws Exception {
        // Spring提供SchedulerFactoryBean为Scheduler提供配置信息,并被Spring容器管理其生命周期
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobFactory(jobFactory);
        //这句一定要加！！！！不然properties配置不生效！！！！
        factory.setConfigLocation(new ClassPathResource("/quartz.properties"));
        factory.setStartupDelay(1);
        factory.afterPropertiesSet();
        // 设置自定义Job Factory，用于Spring管理Job bean
        return factory;
    }

    @Bean(name = "scheduler")
    public Scheduler scheduler() throws Exception {
        return schedulerFactoryBean().getScheduler();
    }
}

四、QuartzManager 工具类

package com.nz.phoenix.irrigate.dao.impl;

import com.nz.phoenix.irrigate.service.impl.IrrPatrolPlanServiceImpl;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.support.TaskUtils;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * @Title:QuartzManager 工具类
 * @Description:com.nz.phoenix.irrigate.dao.impl
 * @Auther:wengshiquan
 * @Version:1.0
 * @create2020/6/3 9:22
 */

@Service
public class QuartzManager {
    private static final Logger logger = LoggerFactory.getLogger(TaskUtils.class);
    public static Scheduler scheduler;
    // 创建 schedulerFactory 工厂
    private static SchedulerFactory scheduleFactory = new StdSchedulerFactory();

    public QuartzManager(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

//    public static void main(String[] args) throws SchedulerException {
//        resumeJob();
//    }

    /**
     * 添加一个定时任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass         任务类名
     * @param cron             时间
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName
            , Class<? extends Job> jobClass, String cron, Map<String, Object> params) throws Exception {

        Date beginDate = (Date) params.get("beginDate");
        Date endDate = (Date) params.get("endDate");
        cron = "0/10 * * * * ?";
        if (!isValidExpression(cron)) {
            throw new Exception("时间有误，请联系管理员！");
        }
        try {
            // 任务名，任务组，任务执行类
            JobDetail job = JobBuilder.newJob(jobClass)

                    .withIdentity(jobName, jobGroupName).build();

            // 任务参数
            job.getJobDataMap().putAll(params);

//            if (null == beginDate) {
//                beginDate = new Date();
//                beginDate.setTime(beginDate.getTime() + 5000);
//            } else {
//                beginDate.setTime(beginDate.getTime() - 5000);
//            }
//            endDate.setTime(endDate.getTime() + 200000);
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();

            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
            // 创建Trigger对象
            CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroupName)
                    .usingJobData("trigger1", "这是jobDetail1的trigger")
                    .startNow()//立即生效
                    .startAt(beginDate)
                    .endAt(endDate)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .withSchedule(
                            CronScheduleBuilder.cronSchedule(cron)
                                    .withMisfireHandlingInstructionDoNothing())
                    .build();

            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(job, cronTrigger);

            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
                System.out.println("---定时任务开启  jobName:+"+ jobName +" ---");
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 修改一个任务的触发时间
     *
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param cron             时间设置，参考quartz说明文档
     */
    public void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间
                scheduler.rescheduleJob(triggerKey, trigger);

            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 移除一个任务
     *
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     */
    public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {

            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            // 停止触发器
            scheduler.pauseTrigger(triggerKey);
            // 移除触发器
            scheduler.unscheduleJob(triggerKey);
            // 删除任务
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取任务是否存在
     * <p>
     * STATE_BLOCKED 4 阻塞
     * STATE_COMPLETE 2 完成
     * STATE_ERROR 3 错误
     * STATE_NONE -1 不存在
     * STATE_NORMAL 0 正常
     * STATE_PAUSED 1 暂停
     */
    public Boolean notExists(String triggerName, String triggerGroupName) {
        try {
            return scheduler.getTriggerState(TriggerKey.triggerKey(triggerName, triggerGroupName)) == Trigger.TriggerState.NONE;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 启动所有定时任务
     */
    public static void startJobs() {
        try {
            Scheduler scheduler = scheduleFactory.getScheduler();
            scheduler.start();
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    /**
     * 关闭所有定时任务
     */
    public static void stopJobs() {
        try {
            Scheduler scheduler = scheduleFactory.getScheduler();
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (SchedulerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }


    //从数据库中找到已经存在的job，并重新开户调度
    public static void resumeJob() {
        try {
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            //获取调度器中所有的触发器组
            List<String> triggerGroups = scheduler.getTriggerGroupNames();
            //遍历获取每个触发器组
            for (int i = 0; i < triggerGroups.size(); i++) {
                List<String> triggers = scheduler.getTriggerGroupNames();
                //遍历每个触发器组
                for (int j = 0; j < triggers.size(); j++) {
                    //获取每个触发器
                    Trigger tg = scheduler.getTrigger(new TriggerKey(triggers
                            .get(j), triggerGroups.get(i)));
                    // 重新恢复在tgroup1组中，名为trigger1_1触发器的运行
//                    if (tg instanceof SimpleTrigger
//                            && tg.getDescription().equals("group1.trigger1")) {
                    //恢复运行
                    scheduler.resumeJob(new JobKey(triggers.get(j),
                            triggerGroups.get(i)));
//                    }
                }

            }
            scheduler.start();
        } catch (Exception e) {
            e.printStackTrace();

        }
    }


    /**
     * 判断cron时间表达式正确性
     *
     * @param cronExpression
     * @return
     */
    public static boolean isValidExpression(final String cronExpression) {
        CronTriggerImpl trigger = new CronTriggerImpl();
        try {
            trigger.setCronExpression(cronExpression);
            Date date = trigger.computeFirstFireTime(null);
            return date != null && date.after(new Date());
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
        }
        return false;
    }
}

五、自定义任务 Job

package com.nz.phoenix.irrigate.dao.impl;

import com.nz.phoenix.common.utils.Identifier;
import com.nz.phoenix.entity.irrigate.IrrPatrolPlan;
import com.nz.phoenix.entity.irrigate.IrrPatrolTask;
import com.nz.phoenix.entity.sm.User;
import com.nz.phoenix.enums.StateEnums;
import com.nz.phoenix.irrigate.dao.IIrrPatrolPersonDao;
import com.nz.phoenix.irrigate.dao.IIrrPatrolPlanDao;
import com.nz.phoenix.irrigate.dao.IIrrPatrolTaskDao;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Random;


@Service
public class SftpJob extends QuartzJobBean {

	//此处可自行注入
    @Autowired


    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        // 传入的参数
        JobKey key = context.getJobDetail().getKey();
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.err.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));

        System.out.println("Instance " + key + " of DumbJob says: "  + ", and val is: " + cron);

    }
}