Quartz 實現動態增長、刪除、修改、暫停、恢復定時任務（不使用quartz配置文件）

QuartzModel.java

package com.model.quartz;

/**
 * @description: Quartz實體類
 * @author 
 * @date: 
 */
public class QuartzModel {
   
   private Integer id;

   //執行任務名稱(惟一)
   private String jobName;

   //執行任務組
   @SuppressWarnings("unused")
   private String jobGroup;

   //觸發器名稱
   @SuppressWarnings("unused")
   private String triggerName;

   //觸發器組
   @SuppressWarnings("unused")
   private String triggerGroup;

   //任務描述
   private String jobDescribe;
   //執行任務的類(需繼承job類，執行方法爲execute)
   private String jobClass;
   //任務狀態，是否須要啓動 1:否，2是
   private Integer jobStatus;
   //定時器時間(cron表達式)
   private String jobCron;
   //運行狀態
   private String runStatus;
   
   private String desc;
   
   public Integer getId() {
      return id;
   }
   public void setId(Integer id) {
      this.id = id;
   }
   public String getJobName() {
      return jobName;
   }
   public void setJobName(String jobName) {
      this.jobName = jobName;
   }
   public String getJobGroup() {
      return jobName + "_GROUP";
   }
   public void setJobGroup(String jobGroup) {
      this.jobGroup = jobGroup;
   }
   public String getTriggerName() {
      return jobName + "_TRIGGER";
   }
   public void setTriggerName(String triggerName) {
      this.triggerName = triggerName;
   }
   public String getTriggerGroup() {
      return jobName + "_TRIGGER_GROUP";
   }
   public void setTriggerGroup(String triggerGroup) {
      this.triggerGroup = triggerGroup;
   }
   public String getJobDescribe() {
      return jobDescribe;
   }
   public void setJobDescribe(String jobDescribe) {
      this.jobDescribe = jobDescribe;
   }
   public String getJobClass() {
      return jobClass;
   }
   public void setJobClass(String jobClass) {
      this.jobClass = jobClass;
   }
   public Integer getJobStatus() {
      return jobStatus;
   }
   public void setJobStatus(Integer jobStatus) {
      this.jobStatus = jobStatus;
   }
   public String getJobCron() {
      return jobCron;
   }
   public void setJobCron(String jobCron) {
      this.jobCron = jobCron;
   }
   public String getRunStatus() {
      return runStatus;
   }
   public void setRunStatus(String runStatus) {
      this.runStatus = runStatus;
   }
   public String getDesc() {
      return desc;
   }
   public void setDesc(String desc) {
      this.desc = desc;
   }
   
   public String getJobStatusStr(){
      String string = "";
      if(this.jobStatus == 1){
         string = "未運行";
      }else{
         string = "已運行";
      }
      return string;
   }
   
}

 QuartzJobType.java

package com.common.schedulerManage;

import com.golden.ihome.utils.StringUtil;

/**
 * 發送消息類型
 * @author 
 * @date 
 */
public enum QuartzJobType {

   NONE("找不到觸發器"),

   NORMAL("正常"),

   PAUSED("暫停"),

   COMPLETE("已運行,任務可能還在執行中"),

   BLOCKED("線程阻塞"),

   ERROR("錯誤");

   private String value;

   public String getValue() {
      return value;
   }

   private QuartzJobType(String value) {
      this.value = value;
   }

   public static String getValue(String name) {

      if (null != name && !"".equals(name)) {
         for (QuartzJobType quartzJobType : QuartzJobType.values()) {
            if (name.equals(quartzJobType.name())) {
               return quartzJobType.getValue();
            }
         }
      }
      return "";
   }
}

QuartzManager.java

package com.common.schedulerManage;

import java.util.List;
import java.util.Map;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import com.golden.ihome.crm.dao.quartz.QuartzDao;
import com.golden.ihome.crm.model.quartz.QuartzModel;

/**
 * @description: 定時任務動態控制類
 * @author 
 * @date: 
 */ 
public class QuartzManager {

   @Autowired
   private  SchedulerFactoryBean schedulerFactoryBean;

   @Autowired
   private QuartzDao quartzDao;
   
   private static final Logger logger = LoggerFactory.getLogger(QuartzManager.class);

   /**
    * 初始化定時任務
    * @description: 
    * @author shehaohao 
    * @date: 2018年9月19日
    */
   public void loadJobs(){
        
       //數據庫查詢 定時任務 配置
      List<QuartzModel> list = quartzDao.getQuartzList();
      addJob(list);
   }
   
   /** 
     * @Description: 添加一個定時任務 
     *  
     * @param jobName 任務名 
     * @param jobGroupName  任務組名 
     * @param triggerName 觸發器名 
     * @param triggerGroupName 觸發器組名 
     * @param jobClass  任務 
     * @param cron   時間設置，參考quartz說明文檔  
     */  
   @SuppressWarnings({"unchecked" })
   public  void addJob(List<QuartzModel> list) {  
        try {  
             if(null == list || list.size() <=0){
               return;
              }
              
            Scheduler sched = schedulerFactoryBean.getScheduler(); 
           
            for(QuartzModel job : list){

               //去掉不運行的任務（數據庫配置是不啓動）
               if(null == job.getJobStatus() || job.getJobStatus() == 1){
                  continue;
               }

               TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

               //獲取trigger，即在spring配置文件中定義的 bean id="myTrigger"
               CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);

               if (null == trigger) {

                     JobDetail jobDetail = JobBuilder.newJob((Class<? extends Job>) Class.forName(job.getJobClass()))
                                              .withIdentity(job.getJobName(), job.getJobGroup()).build();

                     //工做詳細放入jobDataMap中
                     jobDetail.getJobDataMap().put("scheduleJob", job);

                     //表達式調度構建器
                     CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getJobCron());

                     //按新的cronExpression表達式構建一個新的trigger
                     trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())
                                    .withSchedule(scheduleBuilder).build();

                     sched.scheduleJob(jobDetail, trigger);

               }else{

                  CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
                        .getJobCron());

                     //按新的cronExpression表達式從新構建trigger
                     trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

                     //按新的trigger從新設置job執行
                     sched.rescheduleJob(triggerKey, trigger);
               }
               
            }

            // 啓動  
            if (!sched.isShutdown()) {  
                sched.start();  
            }  
           
        } catch (Exception e) {  
            logger.info(e.getMessage());
        }  
    }
   
   /**
    * @description: 暫停任務
    * @author 
    * @date: 
    */
   public Integer pushJob(Map<String, Object> map){

      Integer result = 1;

      try {

         Scheduler scheduler = schedulerFactoryBean.getScheduler();

         JobKey jobKey = JobKey.jobKey(String.valueOf(map.get("jobName")), String.valueOf(map.get("jobName"))+"_GROUP");

         scheduler.pauseJob(jobKey);

      } catch (SchedulerException e) {
         result  = -1;
         logger.info(e.getMessage());
      }
      return result ;
   }
   
   /**
    * @description: 恢復任務
    * @author 
    * @date: 
    */
   public Integer restoreJob(Map<String, Object> map){
      Integer result = 1;

      try {

         Scheduler scheduler = schedulerFactoryBean.getScheduler();

         JobKey jobKey = JobKey.jobKey(String.valueOf(map.get("jobName")), String.valueOf(map.get("jobName"))+"_GROUP");

         scheduler.resumeJob(jobKey);
         
      } catch (SchedulerException e) {
         result = -1;
         logger.info(e.getMessage());
      }
      return result;
   }
   
   /**
    * @description: 刪除任務
    * @author 
    * @date: 
    */
   public Integer delJob(QuartzModel quartzModel){
      Integer result = 1;

      try {

         Scheduler scheduler = schedulerFactoryBean.getScheduler();

         JobKey jobKey = JobKey.jobKey(quartzModel.getJobName(), quartzModel.getJobName()+"_GROUP");

         scheduler.deleteJob(jobKey);

      } catch (SchedulerException e) {
         result = -1;
         logger.info(e.getMessage());
      }
      return result;
   }
   
   
   /**
    * @description: 馬上執行 任務
    * @author 
    * @date: 
    */
   public Integer runJob(QuartzModel quartzModel){
      Integer result= 1;

      try {

         Scheduler scheduler = schedulerFactoryBean.getScheduler();

         JobKey jobKey = JobKey.jobKey(quartzModel.getJobName(), quartzModel.getJobName()+"_GROUP");

         scheduler.triggerJob(jobKey);
        
      } catch (SchedulerException e) {
         result = -1;
         logger.info(e.getMessage());
      }
      return result;
   }
   
   
   /**
    * @description: 更新cron表達式
    * @author 
    * @date: 
    */
   public Integer updateJobCron(Map<String, Object> map){
      Integer result = 1;

      try {

         Scheduler scheduler = schedulerFactoryBean.getScheduler();

         TriggerKey triggerKey = TriggerKey.triggerKey(String.valueOf(map.get("jobName")),String.valueOf(map.get("jobName"))+"_GROUP");

         //獲取trigger，即在spring配置文件中定義的 bean id="myTrigger"
         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

         //表達式調度構建器
         CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(String.valueOf(map.get("jobCron")));

         //按新的cronExpression表達式從新構建trigger
         trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

         //按新的trigger從新設置job執行
         scheduler.rescheduleJob(triggerKey, trigger);
 
      } catch (SchedulerException e) {
         result = -1;
         e.printStackTrace();
      } catch (Exception e) {
         result = -1;
         e.printStackTrace();
      }
      return result;
   }

  /**
   * @description: 獲取正在運行的任務
   * @author 
   * @date: 
   */
   public List<QuartzModel> getAllJobs() throws SchedulerException{

       Scheduler scheduler = schedulerFactoryBean.getScheduler();
       GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
       Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);

       List<QuartzModel> jobList = new ArrayList<>();
   
      for (JobKey jobKey : jobKeys) {
         //獲取任務詳情
         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        //獲取任務中傳遞的參數
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        QuartzModel job = (QuartzModel) jobDataMap.get("scheduleJob");
        List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);

        for (Trigger trigger : triggers) {
           Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
           job.setJobRunStatus(QuartzJobType.getValue(triggerState.name()));
        }
        jobList.add(job);
      }

      return jobList;
   }
}

JobFactory.java

package com.common.schedulerManage;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

/**
 * @description: JOB類須要實例化 （不然 quartz的job沒法注入spring對象，使用autowired註解注入的對象爲空）
 * @author 
 * @date: 
 */

public class JobFactory extends AdaptableJobFactory{

    @Autowired 
    private AutowireCapableBeanFactory capableBeanFactory;  

    @Override 
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {  

        //調用父類的方法  
        Object jobInstance = super.createJobInstance(bundle);  

        //進行注入  
        capableBeanFactory.autowireBean(jobInstance);  

        return jobInstance;  
    }

}

ApplicationContext.xml (spring配置文件)

<!-- 定時器工廠注入 -->
<!-- quartz的定時任務的factorybean,配置其餘config -->  
<bean id="jobFactory" class="com.golden.ihome.common.schedulerManage.JobFactory"></bean>  
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
    <property name="jobFactory" ref="jobFactory"></property>  
</bean> 

<!-- 初始化定時任務 -->
<bean id="initQuartzMethod" class="com.golden.ihome.common.schedulerManage.QuartzManager" init-method="loadJobs"/>

QuartzJob.java

package com.common.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 定時任務具體的執行類
 */
@Component
@DisallowConcurrentExecution //該註解做用禁止相同的任務併發
public class QuartzJob implements Job {
 
   @Override
   public void execute(JobExecutionContext content) throws JobExecutionException {

      String jobName = content.getJobDetail().getKey().getName();

      JobDataMap dataMap = content.getJobDetail().getJobDataMap();

      String param = dataMap.getString("param");

      System.out.println("傳遞的參數是="+param +"任務名字是="+jobName);

   }
}