使用Quartz搭建定时任务脚手架

定时任务的实现有很多种，在Spring项目中使用一个注解 @Scheduled就可以很快搞定。

但是很难去管理项目中的定时任务，比如说：系统中有多少定时任务，每个定时任务执行规则，修改执行规则，暂停任务，移除任务。

这个时候我们就可以使出杀手锏了，使用Quartz框架，整合到SpringBoot中，是个不错的选择。

最近一段时间，使用SpringBoot + Quartz，整合了一个小项目，专门用来管理定时任务，其中，从截图中可以看出来，可以对定时任务进行添加，查询，暂停，恢复，编辑，移除。

 import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;

 import org.quartz.CronScheduleBuilder;
 import org.quartz.CronTrigger;
 import org.quartz.JobBuilder;
 import org.quartz.JobDetail;
 import org.quartz.JobKey;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.Trigger;
 import org.quartz.TriggerBuilder;
 import org.quartz.TriggerKey;
 import org.quartz.impl.matchers.GroupMatcher;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Component;

 import com.bm.task.annotions.JobDeclare;
 import com.bm.task.utils.TaskUtil;
 import com.bm.task.utils.TimeUtil;
 import com.bm.task.vo.JobDetailVO;

 @Component
 public class QuartzManager {

     @Autowired
     private Scheduler scheduler;

     /**
      * 添加一个定时任务
      *
      * @param jobName 任务名
      * @param jobGroupName  任务组名
      * @param triggerName 触发器名
      * @param triggerGroupName 触发器组名
      * @param jobClass  任务
      * @param cron   时间设置，参考quartz说明文档
      */
     @SuppressWarnings({ "rawtypes", "unchecked" })
     public void addJob(String jobName, String jobGroupName, String triggerName,
             String triggerGroupName,String cron,String cronDesc) {
         try {  

             Class clazz = TaskUtil.getClass(jobName);
             JobDeclare jobDeclare = (JobDeclare)clazz.getAnnotation(JobDeclare.class);
             String jobDescription = jobDeclare.description();

             // 任务名，任务组，任务执行类
             JobDetail jobDetail= JobBuilder.newJob(clazz)
                                               .withIdentity(jobName, jobGroupName)
　　　　　　　　　　　　　　　　　　　　　　　　　　　　.withDescription(jobDescription).build();

             // 触发器
             TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
             // 触发器名,触发器组
             triggerBuilder.withIdentity(triggerName, triggerGroupName)
                              .withDescription(cronDesc);
             triggerBuilder.startNow();
             // 触发器时间设定
             triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
             // 创建Trigger对象
             CronTrigger trigger = (CronTrigger) triggerBuilder.build();

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

             // 启动
             if (!scheduler.isShutdown()) {
                 scheduler.start();
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * 修改一个任务的触发时间
      *
      * @param jobName
      * @param jobGroupName
      * @param triggerName 触发器名
      * @param triggerGroupName 触发器组名
      * @param cron   时间设置，参考quartz说明文档
      */
     public void modifyJobTime(String jobName, String jobGroupName, String triggerName,
             String triggerGroupName, String cron,String cronDesc) {
         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)) {
                 /** 方式一 ：调用 rescheduleJob 开始 */
                 // 触发器
                 TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                 // 触发器名,触发器组
                 triggerBuilder.withIdentity(triggerName, triggerGroupName)
                                  .withDescription(cronDesc);
                 triggerBuilder.startNow();
                 // 触发器时间设定
                 triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
                 // 创建Trigger对象
                 trigger = (CronTrigger) triggerBuilder.build();
                 // 方式一 ：修改一个任务的触发时间
                 scheduler.rescheduleJob(triggerKey, trigger);
                 scheduler.pauseTrigger(triggerKey);// 停止触发器
                 /** 方式一 ：调用 rescheduleJob 结束 */

                 /** 方式二：先删除，然后在创建一个新的Job  */
                 //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                 //addJob(jobName, jobGroupName, triggerName, triggerGroupName, cron,cronDesc);
                 /** 方式二 ：先删除，然后在创建一个新的Job */
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**
      * 移除一个任务
      *
      * @param jobName
      * @param jobGroupName
      * @param triggerName
      * @param triggerGroupName
      */
     public  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);
         }
     }  

     /**
      * 暂停一个任务
      *
      * @param jobName
      * @param jobGroupName
      * @param triggerName
      * @param triggerGroupName
      */
     public  void pauseJob(String triggerName, String triggerGroupName) {
         try {
             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 triggerGroupName);
             scheduler.pauseTrigger(triggerKey);// 停止触发器
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * 恢复一个任务
      *
      * @param jobName
      * @param jobGroupName
      * @param triggerName
      * @param triggerGroupName
      */
     public  void resumeJob(String triggerName, String triggerGroupName) {
         try {
             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 triggerGroupName);
             scheduler.pauseTrigger(triggerKey);// 停止触发器
             scheduler.resumeTrigger(triggerKey);
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * 获取所有的JobDetail
      */
     public List<JobDetailVO> getJobs() throws SchedulerException  {
         List<JobDetailVO> result = new ArrayList<>();
         List<String> groupNames = scheduler.getJobGroupNames();
         for (String groupName : groupNames) {
              Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName));
　　　　　　　　　　for (JobKey jobKey : jobKeys) {
                 String jobName = jobKey.getName();
                 String jobGroup = jobKey.getGroup();
                 JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                 // get job's trigger
                 @SuppressWarnings("unchecked")
                 List<Trigger> triggers = (List<Trigger>) scheduler.getTriggersOfJob(jobKey);
                 CronTrigger trigger = (CronTrigger)triggers.get(0);
                 String cronExpression = trigger.getCronExpression();
                 Date  lastFireTime = trigger.getPreviousFireTime();
                 Date nextFireTime = triggers.get(0).getNextFireTime();
                 JobDetailVO vo = new JobDetailVO();
                 vo.setCronExpression(cronExpression);
                 vo.setJobDescription(jobDetail.getDescription());
                 vo.setJobName(jobName);
                 vo.setJobGroupName(jobGroup);
                 if(lastFireTime != null) {
                     vo.setLastFireTime(
                           TimeUtil
　　　　　　　　　　　　　　　 .getStringFromTime(lastFireTime,
                          TimeUtil.TIME_FORMAT_SHOW_MILLISECOND_WITH_COLON));
                 }
                 if(nextFireTime != null) {
                     vo.setNextFireTime(TimeUtil
　　　　　　　　　　　　　　　 .getStringFromTime(nextFireTime,
　　　　　　　　　　　　　　　　TimeUtil.TIME_FORMAT_SHOW_MILLISECOND_WITH_COLON));
                 }
                 vo.setTriggerDescription(trigger.getDescription());
                 vo.setTriggerName(trigger.getKey().getName());
                 vo.setTriggerGroupName(trigger.getKey().getGroup());
                 vo.setTriggerState(scheduler.getTriggerState(trigger.getKey()).name());
                 result.add(vo);
             }
         }
         return result;
     }  

 }