SpringBoot中实现定时任务(Quartz)

以你之姓@ 2022-12-24 01:58 159阅读 0赞

### 一、使用Spring Task ###

Spring 3.0以后自带了 task 调度工具，使用比 Quartz简单方便，使用 @Scheduled 注解。

**1、创建一个 SpringBoot项目，引入spring-boot-starter-web依赖。**

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-quartz</artifactId>
            </dependency>

1. 在启动类上添加 @EnableScheduling 注解，表示开启定时任务。

@SpringBootApplication
    @EnableScheduling
    public class QuartzApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(QuartzApplication.class, args);
        }
    
    }

2. 了解 @Scheduled 注解

在方法上使用 @Scheduled 注解表示开启一个定时任务：下面参数单位都是**毫秒**

*  fixedRate：表示按一定频率来执行定时任务，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。
 *  fixedDelay：表示按一定时间间隔来执行定时任务，具体是指本次任务结束到下次任务开始之间的时间间隔。该属性还可以配合initialDelay使用， 定义该任务延迟执行时间。
 *  initialDelay：表示首次任务启动的延迟时间。与fixedDelay配合使用。
 *  cron：通过 cron 表达式来配置任务执行时间，cron 表达式格式为：\[秒\] \[分\] \[小时\] \[日\] \[月\] \[周\] \[年\]

**2、单线程执行任务**

使用同一个线程中串行执行，如果只有一个定时任务，这样做肯定没问题，当定时任务增多，如果一个任务卡死，会导致其他任务也无法执行。

1. 创建一个类，配置定时任务

@Component
    public class Task1 {
    
        @Scheduled(fixedRate = 2000)
        public void fixedRateTask() {
            System.out.println("fixedRateTask定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    
        @Scheduled(fixedDelay = 2000)
        public void fixedDelayTask1() {
            System.out.println("fixedDelayTask1111定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    
        @Scheduled(initialDelay = 2000,fixedDelay = 2000)
        public void initialDelayTask2() throws InterruptedException {
            System.out.println("initialDelayTask2222定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(15);
        }
    
        @Scheduled(cron = "0/5 * * * * ?")
        public void cron() {
            System.out.println("cron定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    }

2. 启动项目，定时任务就开始工作了

*  可以看到使用的是同一个线程，并出现了任务阻塞的情况。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

**3、多线程执行任务**

Spring Task 默认是单线程的，想要改成多线程，

给Spring Task提供一个多线程的TaskScheduler，Spring已经有默认实现。

1. 方式一

创建配置类，@EnableAsync注解：表示开启异步事件的支持

@Configuration
    @EnableAsync // 开启异步事件的支持
    public class AsyncTaskConfig {
    
        private int corePoolSize = 10;
        private int maxPoolSize = 200;
        private int queueCapacity = 10;
        @Bean
        public Executor taskExecutor() {
            // 线程池
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.initialize();
            return executor;
        }
    }

在定时任务的类或者方法上添加 @Async 注解。最后重启项目，每一个任务都是在不同的线程中  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1][]

2. 方式二

创建配置类

@Configuration
    @EnableAsync // 开启异步事件的支持
    public class ScheduleConfig {
        @Bean("taskScheduler1")
        public TaskScheduler taskScheduler1(){
            ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
            scheduler.setPoolSize(10);
            scheduler.setThreadNamePrefix("spring-task1-thread");
            return scheduler;
        }
    
        @Bean
        public TaskScheduler taskScheduler2(){
            ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
            scheduler.setPoolSize(10);
            scheduler.setThreadNamePrefix("spring-task2-thread");
            return scheduler;
        }
    }

在定时任务的类或者方法上添加 @Async 注解。最后重启项目。

@Component
    public class TestTask2 {
    
        @Async("taskScheduler1")
        @Scheduled(cron = "0/1 * * * * ?")
        public void execute1() {
            System.out.println("execute1定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    
        @Async("taskScheduler2")
        @Scheduled(cron = "0/1 * * * * ?")
        public void execute2() throws InterruptedException {
            System.out.println("execute2定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
        @Async("taskScheduler2")
        @Scheduled(cron = "0/1 * * * * ?")
        public void execute3() throws InterruptedException {
            System.out.println("execute3定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    
        @Scheduled(cron = "0/2 * * * * ?")
        public void execute4() throws InterruptedException {
            System.out.println("execute4定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    
        }
    
        @Scheduled(cron = "0/3 * * * * ?")
        public void execute5() throws InterruptedException {
            System.out.println("execute5定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
            TimeUnit.SECONDS.sleep(15);
        }
    }

任务使用同上，线程池有区别。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2][]

### 二、使用第三方框架 Quartz ###

使用 @Scheduled 注解来解决简单的定时任务，大部分项目中可能都是使用 Quartz 来做定时任务。

**Quartz**是一个开源项目，专注于任务调度器，功能强大，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。

*  持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。
 *  集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端（节点）时，

采用Quartz的集群和分布式处理时，简单了解几点

*  1）一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
 *  2）Quartz调度是通过触发器的类别来识别不同的任务，在不同的节点定义相同的触发器的类别，这样在集群下能稳定的运行，一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
 *  3）分布式 体现在 当相同的任务定时在一个时间点，在那个时间点，不会被两个节点同时执行。

**1、添加 Quartz 依赖**

在 上面的 SpringBoot项目（把@Scheduled相关的注释掉）中使用 Quartz ，添加 Quartz 依赖。

<dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-quartz</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>

在启动类上添加 @EnableScheduling 注解，表示开启定时任务。

**2、Quartz的使用**

Quartz 在使用过程中，有两个关键概念，

*  一个是 JobDetail（要做的事情），要定义 JobDetail，需要先自定义Job
 *  一个是 Trigger触发器（什么时候做）

**1. 定义 Job**

@Service
    public class UserService {
    
        public String get(Long id){
            return "UserService get data:" + id;
        }
    }

**Job 的定义**有两种方式：

*  直接定义一个Bean，不支持传参。
 *  定义一个Bean继承 QuartzJobBean类，并实现默认的方法，支持传参，任务启动时，executeInternal 方法将会被执行。

@Component
    public class MyJob1 {
    
        public void myTask1() {
            System.out.println("MyJob1 myTask1任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    }

@Component
    public class MyJob2 extends QuartzJobBean {
    //    @Autowired  这里注入方式是不行的，报NPE
        private UserService userService;
    
        private Long id;
    
        @Override
        protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            // 处理相应的注入service业务
            String data = userService.get(id);
            System.out.println(data);
            System.out.println("MyJob2 任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        }
    
        public UserService getUserService() {
            return userService;
        }
    
        public void setUserService(UserService userService) {
            this.userService = userService;
        }
    
        public Long getId() {
            return id;
        }
    
        public void setId(Long id) {
            this.id = id;
        }
    }

**2. 创建配置类，配置 JobDetail， Trigger 触发器**

配置简单说明一下：

JobDetail 的配置有两种方式：

*  MethodInvokingJobDetailFactoryBean：可以配置目标 Bean 的名字和目标方法的名字，这种方式不支持传参。
 *  JobDetailFactoryBean：任务类继承自 QuartzJobBean ，这种方式支持传参，将参数封装在 JobDataMap 中进行传递。

Quartz 中定义了多个 Trigger触发器，，这里使用下 SimpleTrigger 和 CronTrigger 。

*  SimpleTrigger触发器： 有点类似于上面的 @Scheduled 的基本用法。
 *  CronTrigger触发器：支持 cron 表达式来配置任务执行时间

@Configuration
    public class QuartzConfig {
        // MyJob2 需要 userService， 这两个都可以注入
    //    @Bean
    //    UserService userService() {
    //        return new UserService();
    //    }
        @Autowired
        private UserService userService;
    
        // MyJob1任务配置
        @Bean
        MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean() {
            MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
            bean.setTargetBeanName("myJob1"); // 首字母小写
            bean.setTargetMethod("myTask1");
            return bean;
        }
    
        @Bean
        SimpleTriggerFactoryBean simpleTriggerFactoryBean() {
            SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
            bean.setStartTime(new Date());
            bean.setRepeatCount(5);
            bean.setRepeatInterval(2000);
            bean.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());
            return bean;
        }
    
        // MyJob2任务配置
        // 传参
        @Bean
        JobDetailFactoryBean jobDetailFactoryBean() {
            JobDetailFactoryBean bean = new JobDetailFactoryBean();
            bean.setJobClass(MyJob2.class);
            JobDataMap map = new JobDataMap();
            map.put("userService", userService);
            map.put("id", 101);
            bean.setJobDataMap(map);
            return bean;
        }
    
        @Bean
        CronTriggerFactoryBean cronTriggerFactoryBean() {
            CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
            bean.setCronExpression("0/5 * * * * ?");
            bean.setJobDetail(jobDetailFactoryBean().getObject());
            return bean;
        }
    
        // 添加 MyJob1和MyJob2的触发器
        @Bean
        SchedulerFactoryBean schedulerFactoryBean() {
            SchedulerFactoryBean bean = new SchedulerFactoryBean();
            bean.setTriggers(cronTriggerFactoryBean().getObject(), simpleTriggerFactoryBean().getObject());
            return bean;
        }
    
    }

3. 启动项目，每一个任务都是在不同的线程中执行了。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 3][]   ![20201126163854274.png][]

### 三、cron表达式 ###

cron 表达式格式为：\[秒\] \[分\] \[小时\] \[日\] \[月\] \[周\] \[年\]

一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。顺序和具体取值依次为：

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>说明</th> 
   <th>是否必填</th> 
   <th>允许填写的值</th> 
   <th>允许的通配符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>秒</td> 
   <td>是</td> 
   <td>0-59</td> 
   <td>- * /</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>分</td> 
   <td>是</td> 
   <td>0-59</td> 
   <td>- * /</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>时</td> 
   <td>是</td> 
   <td>0-23</td> 
   <td>- * /</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>日</td> 
   <td>是</td> 
   <td>1-31</td> 
   <td>- * ? / L W</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>月</td> 
   <td>是</td> 
   <td>1-12 or JAN-DEC</td> 
   <td>- * /</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>周</td> 
   <td>是</td> 
   <td>1-7 or SUN-SAT</td> 
   <td>- * ? / L #</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>年</td> 
   <td>否</td> 
   <td>1970-2099</td> 
   <td>- * /</td> 
  </tr> 
 </tbody> 
</table>

注意：由于”月份中的日期”和”星期中的日期”这两个元素互斥的，必须要对其中一个设置，因此在配置时这两个得有一个是 ?。

其中每个元素可以是一个值（5），一个连续区间（14-18），一个间隔时间（8-18/4）(/表示每隔4小时)，一个列表（1,3,5），通配符（\*）。

**通配符含义：**

? 表示不指定值，即不关心某个字段的取值时使用。需要注意的是，月份中的日期和星期可能会起冲突，因此在配置时这两个得有一个是 ?
    
    * 表示所有值，例如:在秒的字段上设置 *,表示每一秒都会触发
    
    , 用来分开多个值，例如在周字段上设置 “MON,WED,FRI” 表示周一，周三和周五触发
    
    - 表示区间，例如在秒上设置 “10-12”,表示 10,11,12秒都会触发
    
    / 用于递增触发，如在秒上面设置”5/15” 表示从5秒开始，每增15秒触发(5,20,35,50)
    
    # 序号(表示每月的第几个周几)，例如在周字段上设置”6#3”表示在每月的第三个周六，(用 在母亲节和父亲节再合适不过了)
    
    周字段的设置，若使用英文字母是不区分大小写的 ，即 MON 与mon相同
    
    L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会自动判断是否是润年), 在周字段上表示星期六，相当于”7”或”SAT”（注意周日算是第一天）。如果在”L”前加上数字，则表示该数据的最后一个。例如在周字段上设置”6L”这样的格式,则表示”本月最后一个星期五”
    
    W 表示离指定日期的最近工作日(周一至周五)，例如在日字段上设置”15W”，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发，如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，”W”前只能设置具体的数字,不允许区间”-“)
    
    L 和 W 可以一组合使用。如果在日字段上设置”LW”,则表示在本月的最后一个工作日触发(一般指发工资 )

**这里列举几个：**

"0/10 * * * * ?" 每10秒触发 
    
        "0 0/3 * * * ?" 每隔1分钟执行一次 
    
        "0 0 08 * * ?" 每天上午8点触发
     
        "0 15 10 ? * *" 每天上午10:15触发
     
        "0 15 10 * * ?" 每天上午10:15触发
     
        "0 15 10 * * ? *" 每天上午10:15触发
     
        "0 15 10 * * ? 2005" 2005年的每天上午10:15触发
     
        "0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
     
        "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
     
        "0 0/5 14-18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
     
        "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
     
        "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
     
        "0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
     
        "0 15 10 15 * ?" 每月15日上午10:15触发
     
        "0 15 10 L * ?" 每月最后一日的上午10:15触发
     
        "0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
     
        "0 15 10 ? * 6L 2009-2019" 2009年至2019年的每月的最后一个星期五上午10:15触发
     
        "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发

XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。

分布式任务调度平台XXL-JOB，在项目中也有使用。网址：[https://www.xuxueli.com/xxl-job/][https_www.xuxueli.com_xxl-job] ，参考：[XXL-JOB快速入门][XXL-JOB]

**具体时间设定可以参考文章：**

*  Cron定时器表达式生成工具：[http://www.jsons.cn/quartzcron/][http_www.jsons.cn_quartzcron]
 *  cron表达式：[https://blog.csdn.net/k\_scott/article/details/8508290][https_blog.csdn.net_k_scott_article_details_8508290]

—— Stay Hungry. Stay Foolish. 求知若饥，虚心若愚。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: /images/20221120/64a6d5cd56ac4db49306e83043fa6c2f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 1]: /images/20221120/c2890ba6fdb44dfeb3e996c4a051456b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210622164718971.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20201126161042891.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0,size_16,color_FFFFFF,t_70
[20201126163854274.png]: https://img-blog.csdnimg.cn/20201126163854274.png
[https_www.xuxueli.com_xxl-job]: https://www.xuxueli.com/xxl-job/
[XXL-JOB]: https://www.jianshu.com/p/fa7186bea84b
[http_www.jsons.cn_quartzcron]: http://www.jsons.cn/quartzcron/
[https_blog.csdn.net_k_scott_article_details_8508290]: https://blog.csdn.net/k_scott/article/details/8508290