前言

在日常项目运行中，我们总会有需求在某一时间段周期性的执行某个动作。比如每天在某个时间段导出报表，或者每隔多久统计一次现在在线的用户量。在springboot中可以有很多方案去帮我们完成定时器的工作，有Java自带的java.util.Timer类，也有强大的调度器Quartz，还有SpringBoot自带的Scheduled，今天主要介绍Scheduled和Springboot整合quartz。

Spring Schedule 实现定时任务

Spring Schedule 实现定时任务有两种方式 1. 使用XML配置定时任务， 2. 使用 @Scheduled 注解。 因为是Spring Boot 项目 ，要尽量避免使用XML配置的形式，因此主要说注解的形式。

三种定时方式演示代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/**
	1、fixedDelay控制方法执行的间隔时间，是以上一次方法执行完开始算起，如上一次方法执行阻塞住了，那么直到上一次执行完，
		并间隔给定的时间后，执行下一次。
	2、fixedRate是按照一定的速率执行，是从上一次方法执行开始的时间算起，如果上一次方法阻塞住了，下一次也是不会执行，
		但是在阻塞这段时间内累计应该执行的次数，当不再阻塞时，一下子把这些全部执行掉，而后再按照固定速率继续执行。
	3、cron表达式可以定制化执行任务，但是执行的方式是与fixedDelay相近的，也是会按照上一次方法结束时间开始算起。
	4、initialDelay 。如： @Scheduled(initialDelay = 10000,fixedRate = 15000,这个定时器就是在上一个的基础上加了一个
		initialDelay = 10000 意思就是在容器启动后,延迟10秒后再执行一次定时器,以后每15秒再执行一次该定时器。
 */
@Component
public class SpringSchedule {
    public final static long SECOND = 1000;
    FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");

    /**
     * 固定等待时间 @Scheduled(fixedDelay = 时间间隔 )
     * @return: void
    */
    @Scheduled(fixedDelay = SECOND*2)
    public void fixedDelayJob() throws InterruptedException {
        TimeUnit.SECONDS.sleep(2);
        System.out.println("[FixedRateJob Execute]"+fdf.format(new Date()));
    }
    
    /** 
     * 固定间隔时间 @Scheduled(fixedRate = 时间间隔 )
     * @return: void 
    */ 
    @Scheduled(fixedRate = SECOND * 4)
    public void fixedRateJob() {
      	TimeUnit.SECONDS.sleep(2);
        System.out.println("[FixedRateJob Execute]"+fdf.format(new Date()));
    }

    /**
     * Corn表达式 @Scheduled(cron = Corn表达式)
     * @return: void
    */
    @Scheduled(cron = "0/4 * * * * ?")
    public void cronJob() {
      	TimeUnit.SECONDS.sleep(2);
        System.out.println("[CronJob Execute]"+fdf.format(new Date()));
    }
}

在启动类上添加注解 @EnableScheduling然后运行

1
2
3
4
5
6
7
@EnableScheduling
@SpringBootApplication
public class TaskApplication {
    public static void main(String[] args) {
        SpringApplication.run(TaskApplication.class, args);
    }
}

运行结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
[FixedRateJob Execute]2021-04-22 14:35:15
[FixedDelayJob Execute]2021-04-22 14:35:17
[CronJob Execute]2021-04-22 14:35:19
[FixedRateJob Execute]2021-04-22 14:35:21
[FixedDelayJob Execute]2021-04-22 14:35:23
[CronJob Execute]2021-04-22 14:35:25
[FixedRateJob Execute]2021-04-22 14:35:27
[FixedRateJob Execute]2021-04-22 14:35:29
[FixedDelayJob Execute]2021-04-22 14:35:31
[CronJob Execute]2021-04-22 14:35:33
[FixedRateJob Execute]2021-04-22 14:35:35
[FixedRateJob Execute]2021-04-22 14:35:37
[FixedDelayJob Execute]2021-04-22 14:35:39
[CronJob Execute]2021-04-22 14:35:41
[FixedRateJob Execute]2021-04-22 14:35:43
[FixedRateJob Execute]2021-04-22 14:35:45

Springboot 整合 quartz

quartz 简介

  1. Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了很多功能：

    • 持久性作业 - 就是保持调度定时的状态;
    • 作业管理 - 对调度作业进行有效的管理;

  2. Quartz有3个核心要素：调度器(Scheduler)、任务(Job)、触发器(Trigger)

    • Job（任务）：是一个接口，有一个方法void execute()，可以通过实现该接口来定义需要执行的任务（具体的逻辑代码）。
    • JobDetail:Quartz每次执行job时，都重新创建一个Job实例，会接收一个Job实现类，以便运行的时候通过newInstance()的反射调用机制去实例化Job.JobDetail是用来描述Job实现类以及相关静态信息，比如任务在scheduler中的组名等信息。
    • Trigger（触发器）：描述触发Job执行的时间触发规则实现类SimpleTrigger和CronTrigger可以通过crom表达式定义出各种复杂的调度方案。
    • Calendar：是一些日历特定时间的集合。一个Trigger可以和多个 calendar关联,比如每周一早上10:00执行任务，法定假日不执行，则可以通过calendar进行定点排除。
    • Scheduler（调度器）：代表一个Quartz的独立运行容器。Trigger和JobDetail可以注册到Scheduler中。Scheduler可以将Trigger绑定到某一JobDetail上，这样当Trigger被触发时，对应的Job就会执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job.

demo

  1. 引入依赖
1
2
3
4
5
6
7
8
9
10
11
<!--spring boot集成quartz-->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
<!--为了使用FastDateFormat, jdk自带的dataformat是线程不安全的-->
<dependency>
  <groupId>commons-lang</groupId>
  <artifactId>commons-lang</artifactId>
  <version>2.6</version>
</dependency>

  1. 项目结构

    image-20210422152644251

  2. DateTimeJob.java(具体的业务逻辑代码写在这里)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    public class DateTimeJob extends QuartzJobBean {
     
        @Override
        protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException{
            //获取JobDetail中关联的数据
            String msg = (String) jobExecutionContext.getJobDetail().getJobDataMap().get("msg");
            System.out.println("current time :"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "---" + msg);
        }
    }

  3. QuartzConfig.java（配置类）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    @Configuration
    public class QuartzConfig {
        @Bean
        public JobDetail printTimeJobDetail(){
            return JobBuilder.newJob(DateTimeJob.class)//PrintTimeJob我们的业务类
                    .withIdentity("DateTimeJob")//可以给该JobDetail起一个id
                    //每个JobDetail内都有一个Map，包含了关联到这个Job的数据，在Job类中可以通过context获取
                    .usingJobData("msg", "Hello Quartz")//关联键值对
                    .storeDurably()//即使没有Trigger关联时，也不需要删除该JobDetail
                    .build();
        }
        @Bean
        public Trigger printTimeJobTrigger() {
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/1 * * * * ?");
            return TriggerBuilder.newTrigger()
                    .forJob(printTimeJobDetail())//关联上述的JobDetail
                    .withIdentity("quartzTaskService")//给Trigger起个名字
                    .withSchedule(cronScheduleBuilder)
                    .build();
        }
    }

  4. 结果

    image-20210422152447097

cron 详细说明

cron表达式，有专门的语法，而且感觉有点绕人，不过我们只要记住一些常用的用法即可

cron一共有7位，但是最后一位是年，可以留空，所以我们可以写6位：

  • 第一位，表示秒，取值0-59
  • 第二位，表示分，取值0-59
  • 第三位，表示小时，取值0-23
  • 第四位，日期天/日，取值1-31
  • 第五位，日期月份，取值1-12
  • 第六位，星期，取值1-7，星期一，星期二…，注：不是第1周，第二周的意思 另外：1表示星期天，2表示星期一。
  • 第七位，年份，可以留空，取值1970-2099

注意：此处介绍的是quartz中cron的语法。 而Spring Schedule 中的cron语法有一些不同的地方，主要有两点：

  1. Spring Schedule 中 cron 表达式必须由6位组成，也就是没有year着一位
  2. Spring Schedule 中 cron 表达式中第六位其值 1，2，3，4，5，6，7分别表示 “MON,TUE,WED,THU,FRI,SAT,SUN”；0也表示SUN

其他地方一致

cron 中还有一些特殊符号，含义如下：

1
2
3
4
5
(*)星号：可以理解为每的意思，每秒，每分，每天，每月，每年...
(?)问号：问号只能出现在日期和星期这两个位置，表示这个位置的值不确定，每天3点执行，所以第六位星期的位置，我们是不需要关注的，就是不确定的值。同时：日期和星期是两个相互排斥的元素，通过问号来表明不指定值。比如，1月10日，比如是星期1，如果在星期的位置是另指定星期二，就前后冲突矛盾了。
(-)减号：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12
(,)逗号：表达一个列表值，如在星期字段中使用“1,2,4”，则表示星期一，星期二，星期四
(/)斜杠：如：x/y，x是开始值，y是步长，比如在第一位（秒） 0/15就是，从0秒开始，每15秒，最后就是0，15，30，45，60    另：*/y，等同于0/y

一些样例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
>"0 0 12 * * ?" 每天中午12点触发 
>"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 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
>"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
>每隔5秒执行一次：*/5 * * * * ?
>每隔1分钟执行一次：0 */1 * * * ?
>每天23点执行一次：0 0 23 * * ?
>每天凌晨1点执行一次：0 0 1 * * ?
>每月1号凌晨1点执行一次：0 0 1 1 * ?
>每月最后一天23点执行一次：0 0 23 L * ?
>每周星期天凌晨1点实行一次：0 0 1 ? * L

cron表达式在线生成网站