一、本文主要内容

Quartz是一款开源的定时任务调度框架，本文主要记录一下在工作中使用springboot整合quartz实现定时任务调度管理的用例。内容主要有：springboot整合quartz相关配置、实现基于simpleTrigger的定时任务、实现基于cronTrigger的定时任务。

二、代码案例

0、环境准备

  1. @SpringBootApplication
  2. public class QuartzApplication {
  3.     public static void main(String[] args){
  4.         SpringApplication.run(QuartzApplication.class,args);
  5.     }
  7.     /**
  8.      * 初始注入scheduler
  9.      * @return
  10.      * @throws SchedulerException
  11.      */
  12.     @Bean
  13.     public Scheduler scheduler() throws SchedulerException {
  14.         SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
  15.         return schedulerFactoryBean.getScheduler();
  16.     }
  17. }

  1. /**
  2.  * @Author HanGuangKai
  3.  * @Date 2021/7/25 18:55
  4.  * @description 定时任务
  5.  */
  6. public class MyJob implements Job {
  7.     @Override
  8.     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  9.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  10.         String nowTime = format.format(new Date());
  11.         System.out.println("定时任务被触发了"+nowTime);
  12.     }
  13. }

1、开启一个任务

  1. /**
  2.  * @Author HanGuangKai
  3.  * @Date 2021/7/25 18:58
  4.  * @description quartz配置类
  5.  */
  6. @Configuration
  7. public class QuartzConfig {
  9.     @Resource
  10.     private Scheduler scheduler;
  12.     /**
  13.      * 01-开启任务
  14.      */
  15.     public void startJob() {
  16.         openJob(scheduler);
  17.         // 启动任务
  18.         try {
  19.             scheduler.start();
  20.         } catch (SchedulerException e) {
  21.             e.printStackTrace();
  22.         }
  23.     }
  25.     /**
  26.      * 开启一个任务
  27.      * @param scheduler
  28.      */
  29.     private void openJob(Scheduler scheduler) {
  30.         // 1.创建一个JobDetail
  31.         JobDetail build = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
  32.         // 2.触发器表达式对象
  33.         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/4 * * * * ?");
  34.         // 3.准备一个出触发器对象
  35.         CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggergroup1")
  36.                                                              .withSchedule(cronScheduleBuilder).build();
  37.         // 4.开始调度
  38.         try {
  39.             scheduler.scheduleJob(build, cronTrigger);
  40.         } catch (SchedulerException e) {
  41.             e.printStackTrace();
  42.         }
  43.     }
  45. }
  1. @RestController
  2. @RequestMapping(value = "/quartz")
  3. public class QuartzController {
  5.     // 任务调度器
  6.     @Autowired
  7.     private QuartzConfig quartzConfig;
  9.     /**
  10.      * 开启一个定时任务
  11.      */
  12.     @RequestMapping(value = "open-job")
  13.     public String openJob() {
  14.         quartzConfig.startJob();
  15.         return "定时任务开启成功！";
  16.     }
  17. }

2、暂停一个任务

  1. @Configuration
  2. public class QuartzConfig {
  4.     @Resource
  5.     private Scheduler scheduler;
  7.     /**
  8.      * 暂停一个任务
  9.      * @param name 任务名
  10.      * @param group 任务组名
  11.      */
  12.     public void pauseJob(String name,String group) throws SchedulerException {
  13.         // 任务的标识类
  14.         JobKey jobKey = new JobKey(name, group);
  15.         // 获取此任务
  16.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  17.         if (jobDetail != null) {
  18.             // 暂停此任务
  19.             scheduler.pauseJob(jobKey);
  20.         } else {
  21.             System.out.println("无此定时任务！");
  22.         }
  23.     }
  24. }
  1. public class QuartzController {
  3.     // 任务调度器
  4.     @Autowired
  5.     private QuartzConfig quartzConfig;
  7.     @RequestMapping(value = "pause-job")
  8.     public String pauseJob(@RequestParam("name") String name, @RequestParam("group") String group) {
  9.         try {
  10.             quartzConfig.pauseJob(name, group);
  11.         } catch (SchedulerException e) {
  12.             e.printStackTrace();
  13.             return "任务暂停异常！";
  14.         }
  15.         return "任务暂停成功！";
  16.     }
  17. }

3、打印任务的基本信息

  1. /**
  2.  * @Author HanGuangKai
  3.  * @Date 2021/7/25 19:49
  4.  * @description 任务对象
  5.  */
  6. @Data
  7. @AllArgsConstructor
  8. @NoArgsConstructor
  9. public class TaskInfo {
  10.     private String jobName;
  11.     private String jobGroup;
  12.     private String jobDescription;
  13.     private String status;
  14.     private String cronExpression;
  15.     private String cronDescription;
  16. }
  1.  /**
  2.      * 查看所有的任务信息
  3.      * @return
  4.      */
  5.     public List<TaskInfo> getAllJobsInfo() throws SchedulerException {
  6.         ArrayList<TaskInfo> taskInfos = new ArrayList<>();
  7.         // 所有任务组
  8.         List<String> jobGroupNames = scheduler.getJobGroupNames();
  10.         for (String jobGroupName : jobGroupNames) {
  11.             Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(jobGroupName));
  12.             for (JobKey jobKey : jobKeys) {
  13.                 List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
  14.                 for (Trigger trigger : triggers) {
  15.                     Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
  16.                     JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  17.                     String cronException = "";      // cron表达式
  18.                     String cronDescription = "";    // 描述信息
  19.                     if (trigger instanceof CronTrigger) {
  20.                         CronTrigger cronTrigger = (CronTrigger)trigger;
  21.                         // cron表达式
  22.                         cronException = cronTrigger.getCronExpression();
  23.                         cronDescription = cronTrigger.getDescription();
  24.                     }
  25.                     TaskInfo taskInfo = new TaskInfo();
  26.                     taskInfo.setJobName(jobKey.getName());
  27.                     taskInfo.setJobGroup(jobKey.getGroup());
  28.                     taskInfo.setJobDescription(jobDetail.getDescription());
  29.                     taskInfo.setStatus(triggerState.name());
  30.                     taskInfo.setCronExpression(cronException);
  31.                     taskInfo.setJobDescription(cronDescription);
  32.                     taskInfos.add(taskInfo);
  33.                 }
  34.             }
  35.         }
  1.     @RequestMapping(value = "get-all-job")
  2.     public List<TaskInfo> getAllTasks() {
  3.         List<TaskInfo> allJobsInfo = null;
  4.         try {
  5.             allJobsInfo = quartzConfig.getAllJobsInfo();
  6.         } catch (SchedulerException e) {
  7.             e.printStackTrace();
  8.             return null;
  9.         }
  10.         return allJobsInfo;
  11.     }

4、关于暂停和恢复任务

  1.     /**
  2.      * 恢复某个定时任务的执行
  3.      * @param name
  4.      * @param group
  5.      */
  6.     public void resumeJob(String name,String group) throws SchedulerException {
  7.         JobKey jobKey = new JobKey(name, group);
  8.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  9.         if (jobDetail != null) {
  10.             scheduler.resumeJob(jobKey);
  11.         } else {
  12.             System.out.println("要恢复的任务不存在");
  13.         }
  14.     }
  1.    @RequestMapping(value = "resume-job")
  2.     public String resumeJob(@RequestParam("name") String name, @RequestParam("group") String group) {
  3.         try {
  4.             quartzConfig.resumeJob(name, group);
  5.         } catch (SchedulerException e) {
  6.             e.printStackTrace();
  7.             return "任务恢复异常！";
  8.         }
  9.         return "任务恢复成功！";
  10.     }

当暂停一个定时任务后，再将其恢复，会发现控制台输出很多遍相同内容：（即把之前暂停应该打印的内容，在恢复后重新打印了一遍）

  1. 定时任务被触发了2021-07-25 08:23:28
  2. 定时任务被触发了2021-07-25 08:23:42
  3. 定时任务被触发了2021-07-25 08:23:42
  4. 定时任务被触发了2021-07-25 08:23:42
  5. 定时任务被触发了2021-07-25 08:23:44

5、删除任务

  1.     /**
  2.      * 删除某个定时任务
  3.      * @param name
  4.      * @param group
  5.      */
  6.     public void deleteJob(String name,String group) throws SchedulerException {
  7.         JobKey jobKey = new JobKey(name, group);
  8.         JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  9.         if (jobDetail != null) {
  10.             scheduler.deleteJob(jobKey);
  11.         } else {
  12.             System.out.println("要删除的任务不存在");
  13.         }
  14.     }
  1.     @RequestMapping(value = "delete-job")
  2.     public String deleteJob(@RequestParam("name") String name, @RequestParam("group") String group) {
  3.         try {
  4.             quartzConfig.deleteJob(name, group);
  5.         } catch (SchedulerException e) {
  6.             e.printStackTrace();
  7.             return "任务删除异常！";
  8.         }
  9.         return "任务删除成功！";
  10.     }

6、动态修改一个定时任务

  1. /**
  2.      * 动态修改一个定时任务的cron表达式（即触发规则）
  3.      */
  4.     public boolean modifyJob(String name,String group,String newTime) throws SchedulerException {
  5.         Date date = null;
  6.         TriggerKey triggerKey = new TriggerKey(name, group);
  7.         Trigger trigger = scheduler.getTrigger(triggerKey);
  8.         CronTrigger cronTrigger = null;
  9.         if (trigger instanceof CronTrigger) {
  10.             cronTrigger = (CronTrigger) trigger;
  11.             // 获取到表达式
  12.             String cronExpression = cronTrigger.getCronExpression();
  13.             if (cronExpression.equalsIgnoreCase(newTime)) {
  14.                 System.out.println("需要修改原来的表达式："+cronExpression+"为"+newTime);
  15.                 CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(newTime);
  16.                 // 新的cronTrigger1
  17.                 CronTrigger cronTrigger1 = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(cronScheduleBuilder).build();
  18.                 date = scheduler.rescheduleJob(triggerKey, cronTrigger1);
  19.             } else {
  20.                 System.out.println("二者一样，不用修改");
  21.             }
  22.         }
  23.         if (date != null) {
  24.             return true;
  25.         } else {
  26.             return false;
  27.         }
  1.    @RequestMapping("modify-job")
  2.     public boolean modifyJob(@RequestParam("name") String name, @RequestParam("group") String group,@RequestParam("cron") String cron) {
  3.         boolean b = false;
  4.         try {
  5.             b = quartzConfig.modifyJob(name, group, cron);
  6.         } catch (SchedulerException e) {
  7.             e.printStackTrace();
  8.             return b;
  9.         }
  10.         return b;
  11.     }

7、web项目开启时便开启定时任务

  1. package com.hgk.quartz.listener;
  3. import com.hgk.quartz.config.QuartzConfig;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.context.ApplicationListener;
  6. import org.springframework.context.annotation.Configuration;
  7. import org.springframework.context.event.ContextRefreshedEvent;
  9. /**
  10.  * @Author HanGuangKai
  11.  * @Date 2021/7/26 20:07
  12.  * @description 自定义一个监听器监听web启动
  13.  */
  14. @Configuration
  15. public class QuartzListener implements ApplicationListener<ContextRefreshedEvent> {
  17.     @Autowired
  18.     private QuartzConfig quartzConfig;
  20.     @Override
  21.     public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
  22.         quartzConfig.startJob();
  23.         System.out.println("web项目启动了！");
  24.     }
  25. }

8、如何在JOB任务中获取Spring容器中的对象-为了调用方法

  1. /**
  2.      * 开启一个任务
  3.      * @param scheduler
  4.      */
  5.     private void openJob(Scheduler scheduler) {
  7.         // 将spring上下文对象放到容器中
  8.         JobDataMap map = new JobDataMap();
  9.         map.put("applicationContext",applicationContext);
  11.         // 然后创建对象的时候传过去
  12.         // 1.创建一个JobDetail
  13.         JobDetail build = JobBuilder.newJob(MyJob.class).usingJobData(map)
  14.                 .withIdentity("job1", "group1").build();
  15.         // 2.触发器表达式对象
  16.         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/4 * * * * ?");
  17.         // 3.准备一个出触发器对象
  18.         CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggergroup1")
  19.                                                              .withSchedule(cronScheduleBuilder).build();
  20.         // 4.开始调度
  21.         try {
  22.             scheduler.scheduleJob(build, cronTrigger);
  23.         } catch (SchedulerException e) {
  24.             e.printStackTrace();
  25.         }
  26.     }
  1. public class MyJob implements Job {
  2.     @Override
  3.     public void execute(JobExecutionContext context) throws JobExecutionException {
  4.         ApplicationContext applicationContext1 = (ApplicationContext) context.getJobDetail().getJobDataMap().get("applicationContext");
  5.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
  6.         String nowTime = format.format(new Date());
  7.         System.out.println("定时任务被触发了"+nowTime);
  8.         // 现在就可以调用业务逻辑层方法了(从spring容器中获取对象)
  9.         OrderService orderService = applicationContext1.getBean(OrderService.class);
  10.         orderService.sayHi();
  11.     }
  12. }

9、关于quartz的暂停补偿问题

  1.     /**
  2.      * 开启一个任务
  3.      * @param scheduler
  4.      */
  5.     private void openJob(Scheduler scheduler) {
  7.         // 将spring上下文对象放到容器中
  8.         JobDataMap map = new JobDataMap();
  9.         map.put("applicationContext",applicationContext);
  11.         // 然后创建对象的时候传过去
  12.         // 1.创建一个JobDetail
  13.         JobDetail build = JobBuilder.newJob(MyJob.class).usingJobData(map)
  14.                 .withIdentity("job1", "group1").build();
  15.         // 2.触发器表达式对象
  16.         /**
  17.          * withMisfireHandlingInstructionDoNothing():不触发立即执行，一个任务恢复执行，以前错过的定时任务不补偿，继续执行下一个周期
  18.          * withMisfireHandlingInstructionFireAndProceed():以当前时间先触发一次，以后继续按照cron执行
  19.          * withMisfireHandlingInstructionIgnoreMisfires():举例：如果九点暂停定时任务，十点十五恢复定时任务，错误的九点十点的定时任务补偿，以后正常执行
  20.          */
  21.         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/4 * * * * ?").withMisfireHandlingInstructionDoNothing();
  22.         // 3.准备一个出触发器对象
  23.         CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggergroup1")
  24.                                                              .withSchedule(cronScheduleBuilder).build();
  25.         // 4.开始调度
  26.         try {
  27.             scheduler.scheduleJob(build, cronTrigger);
  28.         } catch (SchedulerException e) {
  29.             e.printStackTrace();
  30.         }
  31.     }

注意：还要写配置文件withMisfireHandlingInstructionDoNothing才能生效。