Quartz 实现动态增加、删除、修改、暂停、恢复定时任务（不使用quartz配置文件）...

最新推荐文章于 2020-07-17 19:57:52 发布

weixin_34124577

最新推荐文章于 2020-07-17 19:57:52 发布

阅读量669

点赞数

文章标签：开发工具 java 数据库

原文链接：https://my.oschina.net/u/3445245/blog/2249242

版权

2019独角兽企业重金招聘Python工程师标准>>>

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

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

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

   }
}

转载于:https://my.oschina.net/u/3445245/blog/2249242