Spring Boot 入门（九）：集成Quartz定时任务

本片文章续《Spring Boot 入门（八）：集成RabbitMQ消息队列》，关于Quartz定时任务请参考《Quartz的基本使用之入门（2.3.0版本）》

spring boot实现定时任务，除了集成Quartz外，还可以直接使用scheduler注解。使用1个简单的注解就可以完成，为什么还要较为复杂的集成Quartz呢？这里我简单回答下这2中方式的区别，这也是我在项目中为什么要选择Quartz这种方式。

1.scheduler注解方式，一旦定时任务产生异常，那么此定时任务就无法再次启动，意味该定时任务就失效了，而Quartz不会。

2.scheduler注解方式，当前面的定时任务没有完成的时候，无法再次开启定时任务，这说明scheduler注解方式是单线程，而Quartz是多线程，同一定时任务可以并发处理。

3.scheduler注解方式，对于定时的格式很少，只能简单的在注解中配置，很多复杂的定时任务没法完成，而Quartz的格式很丰富，可以配置各种各样的定时任务。

基于上述原因，定时任务应该选择Quartz。

1.增加依赖

 <!--quartz-->
         <dependency>
             <groupId>org.quartz-scheduler</groupId>
             <artifactId>quartz</artifactId>
             <version>2.2.1</version>
         </dependency>
         <!-- 该依赖必加，里面有sping对schedule的支持 -->
         <dependency>
             <groupId>org.springframework</groupId>
             <artifactId>spring-context-support</artifactId>
         </dependency>

2.增加conf

 package
 import org.quartz.*;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;

 /**
  * @program:
  * @description: 定时任务创建job，通过注入Scheduler对任务进行操作
  * @author: DZ
  * @create: 2019-10-19 18:28
  **/
 @Service
 public class QuartzConf {
     private static final String JOB_GROUP = "job_group";
     private static final String TRIGGER_GROUP = "trigger_group";
     @Autowired
     private Scheduler scheduler;

     /**
      * 创建定时任务
      *定义相应的任务（JobDetial）和触发器(trigger)，并将其加到一个执行日程(Scheduler)中，并通过监听器启动日程。
      * @param jobDetailName
      * @param cronExpression
      * @param jobClass
      * @throws SchedulerException
      */
     public void createScheduleJob(String jobDetailName, String cronExpression, Class<? extends Job> jobClass) throws SchedulerException {
         JobDetail jobDetail = JobBuilder.newJob(jobClass)
                 .withIdentity("task_" + jobDetailName, JOB_GROUP).storeDurably().requestRecovery().build();
         CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
         Trigger trigger = TriggerBuilder.newTrigger().withIdentity("task_" + jobDetailName, TRIGGER_GROUP).withSchedule(scheduleBuilder).build();
         scheduler.scheduleJob(jobDetail, trigger);
     }
 }

3.增加过滤器

 import lombok.extern.slf4j.Slf4j;
 import org.quartz.SchedulerException;
 import org.slf4j.MDC;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.context.ApplicationListener;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.context.event.ContextRefreshedEvent;

 import java.util.UUID;

 /**
  * @program:
  * @description: 启动监听去初始化Quartz
  * @author: DZ
  * @create: 2019-10-19 18:32
  **/
 @Slf4j
 @Configuration
 public class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {
     @Autowired
     private QuartzConf quartzConf;

    /* 时间格式：
     *    *     *     *    *     *   *
     [秒] [分] [小时] [日] [月] [周] [年]*/

     /**
      * 初始启动quartz
      */
     @Override
     public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
         try {
             log.info("任务开始启动...");
                        quartzConf.createScheduleJob("TestTask", "*/30 * * * * ?", TestTask.class);
             log.info("任务已经启动...");
         } catch (SchedulerException e) {
             log.error("定时任务启动失败", e);
         }
     }
 }

如果整个项目就一个定时任务，其实也不需要过滤器，直接将定时任务的类名写在cong中即可。如果有多个定时任务，定义多个trigger和job也可以。这样代码的冗余度比较高

此监听器的作用在于：项目启动的时候，监听器将所有的定时任务注册到日程中，相当于开启定时任务。从而做到了只需要定义一套trigger和job就可以写多个定时任务。

4.写定时任务

  import lombok.extern.slf4j.Slf4j;
 import org.quartz.Job;
 import org.quartz.JobExecutionContext;
 import org.quartz.JobExecutionException;
 import org.quartz.JobKey;
 import org.slf4j.MDC;

 import java.util.UUID;

 /**
  * @program:
  * @description: 测试定时任务
  * @author: DZ
  * @create: 2019-10-19 18:49
  **/
 @Slf4j
 public class TestTask implements Job {
     @Override
     public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
                 JobKey key = jobExecutionContext.getJobDetail().getKey();
         // todo 业务逻辑
         log.info("----------" + key + "任务执行中,currentTime:" + DateUtil.getCurrentDate());
     }
 }

这个位置除了实现Job接口外，还可以继承QuartzJobBean类，其实QuartzJobBean也是Job的子类，只不过对部分参数进行了初始化

启动服务，查看结果

此外，如果不对定时任务做线程池的配置，那么默认是10个线程，这里也可以增加对线程池的配置，在yml中增加属性：

 Spring:
 #  quartz定时器配置
   quartz:
     properties:
       org:
         quartz:
           scheduler:
             instanceName: quartzScheduler
             instanceId: AUTO
           threadPool:
             class: org.quartz.simpl.SimpleThreadPool
             threadCount: 20
             threadPriority: 5
             threadsInheritContextClassLoaderOfInitializingThread: true

此时就是定义了20个线程