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);

    }
}