SpringBoot整合Quartz超详细完整教程

Quartz是什么？

Quartz是一个开源的作业调度框架，它完全由Java写成，并设计用于J2SE和J2EE应用中。
它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。
它有很多特征，如：数据库支持，集群，插件，EJB作业预构 建，JavaMail及其它，支持cron-like表达式等等

SpringBoot整合Quartz全流程

一、开发环境准备

1、JDK版本1.8
2、springboot版本：2.1.0
3、开发工具：IDEA

二、Quartz的实现

2.1、引入相关依赖

pom.xml中引入相关依赖

<!--引入quartz定时框架-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

2.2、创建一个定时任务

创建的定时任务类需要继承QuzrtzJobBean，新建一个定时任务类：TaskForEvery

public class TaskForEvery extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //TODO 定时任务的执行逻辑
        System.out.println("定时任务执行时间："+new Date().toLocaleString());
    }
}

2.3、创建Quartz配置类 QuartzConfig 将创建的定时任务添加到定时调度里面

@Configuration
public class QuartzConfig {
	//定时任务类
    @Bean
    public JobDetail uploadTaskDetail() {
        return JobBuilder.newJob(TaskForEvery.class).withIdentity("TaskForEvery").storeDurably().build();
    }

    @Bean
    public Trigger uploadTaskTrigger() {
        //设定执行方式
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("*/5 * * * * ?");
        // 返回任务触发器
        return TriggerBuilder.newTrigger().forJob(uploadTaskDetail())
                .withIdentity("TaskForEvery")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

运行项目查看结果，成功执行。该方式存在一定弊端，固定写在项目内，不便于修改。

三、Quartz实现定时调度任务的动态启动、暂停、修改等操作

3.1、创建定时任务属性类QuartzBean

@Data
@AllArgsConstructor
@NoArgsConstructo
@ToString
public class QuartzBean {

    private String  id; //任务id

    private String jobName; //任务名称

    private String jobClass; //任务执行类

    private Integer status; //任务状态 启动还是暂停

    private String cronExpression; //任务运行时间表达式
  }

3.2、创建定时任务工具类QuartzUtils

public class QuartzUtils {

  /**
   * 创建定时任务 定时任务创建之后默认启动状态
   * @param scheduler   调度器
   * @param quartzBean  定时任务信息类
   * @throws Exception
   */
  public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean){
      try {
          //获取到定时任务的执行类  必须是类的绝对路径名称
          //定时任务类需要是job类的具体实现 QuartzJobBean是job的抽象类。
          Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
          // 构建定时任务信息
          JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).build();
          // 设置定时任务执行方式
          CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
          // 构建触发器trigger
          CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
          scheduler.scheduleJob(jobDetail, trigger);
      } catch (ClassNotFoundException e) {
          System.out.println("定时任务类路径出错：请输入类的绝对路径");
      } catch (SchedulerException e) {
          System.out.println("创建定时任务出错："+e.getMessage());
      }
  }

  /**
   * 根据任务名称暂停定时任务
   * @param scheduler  调度器
   * @param jobName    定时任务名称
   * @throws SchedulerException
   */
  public static void pauseScheduleJob(Scheduler scheduler, String jobName){
      JobKey jobKey = JobKey.jobKey(jobName);
      try {
          scheduler.pauseJob(jobKey);
      } catch (SchedulerException e) {
          System.out.println("暂停定时任务出错："+e.getMessage());
      }
  }

  /**
   * 根据任务名称恢复定时任务
   * @param scheduler  调度器
   * @param jobName    定时任务名称
   * @throws SchedulerException
   */
  public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
      JobKey jobKey = JobKey.jobKey(jobName);
      try {
          scheduler.resumeJob(jobKey);
      } catch (SchedulerException e) {
          System.out.println("启动定时任务出错："+e.getMessage());
      }
  }

  /**
   * 根据任务名称立即运行一次定时任务
   * @param scheduler     调度器
   * @param jobName       定时任务名称
   * @throws SchedulerException
   */
  public static void runOnce(Scheduler scheduler, String jobName){
      JobKey jobKey = JobKey.jobKey(jobName);
      try {
          scheduler.triggerJob(jobKey);
      } catch (SchedulerException e) {
          System.out.println("运行定时任务出错："+e.getMessage());
      }
  }

  /**
   * 更新定时任务
   * @param scheduler   调度器
   * @param quartzBean  定时任务信息类
   * @throws SchedulerException
   */
  public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean)  {
      try {
          //获取到对应任务的触发器
          TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
          //设置定时任务执行方式
          CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
          //重新构建任务的触发器trigger
          CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
          trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
          //重置对应的job
          scheduler.rescheduleJob(triggerKey, trigger);
      } catch (SchedulerException e) {
          System.out.println("更新定时任务出错："+e.getMessage());
      }
  }

  /**
   * 根据定时任务名称从调度器当中删除定时任务
   * @param scheduler 调度器
   * @param jobName   定时任务名称
   * @throws SchedulerException
   */
  public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
      JobKey jobKey = JobKey.jobKey(jobName);
      try {
          scheduler.deleteJob(jobKey);
      } catch (SchedulerException e) {
          System.out.println("删除定时任务出错："+e.getMessage());
      }
  }
}

3.3、测试定时任务工具

@Controller
@RequestMapping("/quartz")
public class QuartzController {

  @Autowired
  private Scheduler scheduler;

  @RequestMapping("/createJob")
  @ResponseBody
  public String  createJob(QuartzBean quartzBean)  {
      try {
          quartzBean.setJobClass("com.hjljy.blog.Quartz.TaskForEvery");
          quartzBean.setJobName("test1");
          quartzBean.setCronExpression("*/10 * * * * ?");
          QuartzUtils.createScheduleJob(scheduler,quartzBean);
      } catch (Exception e) {
          return "创建失败";
      }
      return "创建成功";
  }

  @RequestMapping("/pauseJob")
  @ResponseBody
  public String  pauseJob()  {
      try {
          QuartzUtils.pauseScheduleJob (scheduler,"test");
      } catch (Exception e) {
          return "暂停失败";
      }
      return "暂停成功";
  }

  @RequestMapping("/runOnce")
  @ResponseBody
  public String  runOnce()  {
      try {
          QuartzUtils.runOnce (scheduler,"test");
      } catch (Exception e) {
          return "运行一次失败";
      }
      return "运行一次成功";
  }

  @RequestMapping("/resume")
  @ResponseBody
  public String  resume()  {
      try {
          QuartzUtils.resumeScheduleJob(scheduler,"test");
      } catch (Exception e) {
          return "启动失败";
      }
      return "启动成功";
  }

  @RequestMapping("/update")
  @ResponseBody
  public String  update(QuartzBean quartzBean)  {
      try {
          quartzBean.setJobClass("com.hjljy.blog.Quartz.TaskForEvery");
          quartzBean.setJobName("test");
          quartzBean.setCronExpression("10 * * * * ?");
          QuartzUtils.updateScheduleJob(scheduler,quartzBean);
      } catch (Exception e) {
          return "启动失败";
      }
      return "启动成功";
  }
}

三、总结

Springboot2.0后默认添加了quartz的依赖，只需写好任务类,通过调度器scheduler添加任务就可以了。

在quartz任务暂停之后再次启动时，会立即执行一次，在更新之后也会立即执行一次

Springboot中默认quartz线程池大小为10

在启动项目初始化时需要将项目的定时任务也进行初始化