# 06-集成定时任务

# 简介

定时任务是后端开发中常见的需求，主要应用场景有定期数据报表、定时消息通知、异步的后台业务逻辑处理、日志分析处理、垃圾数据清理、定时更新缓存等等。

常用的实现方式

实现方式	描述
java.util.Timer	Timer 提供了一个 java.util.TimerTask 任务支持任务调度。该方式只能按指定频率执行，不能在指定时间运行。由于功能过于单一，使用较少。
Quartz	Quartz 是一个功能比较强大的调度器，支持在指定时间运行，也可以按照指定频率执行。缺点是使用起来相对麻烦。
Spring 框架自带的 Schedule 模块	可以看做是轻量级的 Quartz

Spring Boot 集成了一整套的定时任务工具，让我们专注于完成逻辑，剩下的基础调度工作将自动完成。接下来我们就来看一下如何在Spring Boot项目中集成定时任务功能。

# 静态定时任务(基于注解)

基于注解来创建定时任务非常简单，只需几行代码便可完成。

@Scheduled 除了支持灵活的参数表达式Cron之外，还支持简单的延时操作，例如 fixedDelay ，fixedRate 填写相应的毫秒数即可。

@Configuration //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling // 2.开启定时任务
public class SimpleScheduleConfig {
	
	/**
	 * 上次开始执行时间点后5秒再次执行
	 */
	@Scheduled(fixedRate = 5000)
	public void job3() {
		System.out.println("执行任务job3："+DateUtil.formatDateTime(new Date()));
	}
	
	/**
	 * 上次执行完毕时间点后3秒再次执行
	 */
	@Scheduled(fixedDelay = 3000)
	public void job2() {
		System.out.println("执行任务job2："+DateUtil.formatDateTime(new Date()));
	}
	
	/**
	 * 每隔10秒执行一次（按照 corn 表达式规则执行）
	 */
	@Scheduled(cron = "0/10 * * * * ?")
	public void job1() {
		System.out.println("执行任务job1："+DateUtil.formatDateTime(new Date()));
	}

	
}

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

@EnableScheduling 注解启用定时调度功能 @Scheduled 参数说明：

@Scheduled(fixedRate = 5000)：上次开始执行时间点后5秒再次执行

@Scheduled(fixedDelay = 3000)：上次执行完毕时间点后3秒再次执行

@Scheduled(cron = "0/10 * * * * ?")：每隔10秒执行一次（按照 corn 表达式规则执行）

从上面的示例可以看出，使用Scheduled 确实很方便。但缺点是当我们调整了执行周期的时候，需要重启应用才能生效，这多少有些不方便。为了达到实时生效的效果，可以使用接口来完成定时任务。

# 动态定时任务(基于接口)

# 1. 实现 SchedulingConfigurer 接口

我们编写定时任务，注意这里添加的是TriggerTask，目的是循环读取我们在数据库设置好的执行周期，以及执行相关定时任务的内容。

@Configuration
@EnableScheduling
public class CustomScheduleConfig implements SchedulingConfigurer {

	@Autowired
	private CronTriggerDao cronTriggerDao;

    
	@Override
	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		
        //上次开始执行时间点后5秒再执行
        taskRegistrar.addFixedRateTask(() -> System.out.println("执行任务job1=>" + DateUtil.formatDateTime(new Date()) + ",线程：" + Thread.currentThread().getName()), 5000);


        //上次执行完毕时间点后3秒再执行
        taskRegistrar.addFixedDelayTask(() -> System.out.println("执行任务job2=>" + DateUtil.formatDateTime(new Date()) + ",线程：" + Thread.currentThread().getName()), 3000);


        //添加一个配合数据库动态执行的定时任务
        TriggerTask triggerTask = new TriggerTask(
                //1.添加任务内容(Runnable)
                () -> {
                    System.out.println("执行动态任务job3=>" + DateUtil.formatDateTime(new Date()) + ",线程：" + Thread.currentThread().getName());
                },
                //2.设置执行周期(Trigger)
                triggerContext -> {
                    //2.1 从数据库获取执行周期
                    String cron = cronTriggerDao.getCronTriggerById(1L);
                    //2.2 合法性校验
                    if (StringUtils.isBlank(cron)) {
                        // Omitted Code ..
                        return null;
                    }
                    //2.3 返回执行周期(Date)
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                });
        taskRegistrar.addTriggerTask(triggerTask);

	}

}

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

# 2. 数据库中初始化数据

这边为了测试简单初始化两行数据：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for sys_cron_trigger
-- ----------------------------
DROP TABLE IF EXISTS `sys_cron_trigger`;
CREATE TABLE `sys_cron_trigger` (
  `id` int(8) NOT NULL AUTO_INCREMENT COMMENT '任务id',
  `cron` varchar(20) COLLATE utf8_bin DEFAULT NULL COMMENT 'cron表达式',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  `is_deleted` int(1) DEFAULT '0' COMMENT '作废状态 0-否 1-是',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT = 'Cron表达式定义表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of sys_cron_trigger
-- ----------------------------
BEGIN;
INSERT INTO `sys_cron_trigger` VALUES (1, '0/10 * * * * ?', '2019-10-30 13:40:14', NULL, 0);
INSERT INTO `sys_cron_trigger` VALUES (2, '0/7 * * * * ?', '2019-10-30 13:40:34', NULL, 0);
COMMIT;

SET FOREIGN_KEY_CHECKS = 1;

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

# 3. 从数据库中读取 cron 表达式值

CronTrigger 实体类

public class CronTrigger implements Serializable {

	private static final long serialVersionUID = 880141459783509786L;
	
    /** 任务id */
	private Long id;
    /** cron表达式 */
	private String cron;
    /** 创建时间 */
	private String createTime;
    /** 更新时间 */
	private String updateTime;
    /** 删除状态 */
	private boolean isDeleted=false;
	
	public Long getId() {
		return id;
	}
	public void setId(Long id) {
		this.id = id;
	}
	public String getCron() {
		return cron;
	}
	public void setCron(String cron) {
		this.cron = cron;
	}
	public String getCreateTime() {
		return createTime;
	}
	public void setCreateTime(String createTime) {
		this.createTime = createTime;
	}
	public String getUpdateTime() {
		return updateTime;
	}
	public void setUpdateTime(String updateTime) {
		this.updateTime = updateTime;
	}
	public boolean isDeleted() {
		return isDeleted;
	}
	public void setDeleted(boolean isDeleted) {
		this.isDeleted = isDeleted;
	}
}

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
45
46

CronTriggerDao

public interface CronTriggerDao {
    
	/**
	 * 根据id获取cron表达式
	 * @param id
	 * @return
	 */
	String getCronTriggerById(Long id);

}

1
2
3
4
5
6
7
8
9
10

CronTriggerMapper.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.4//EN" 
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.zwqh.springboot.dao.CronTriggerDao">
	<resultMap type="cn.zwqh.springboot.model.CronTrigger" id="cronTrigger">
		<id property="id" column="id"/>
		<result property="cron" column="cron"/>
		<result property="createTime" column="create_time"/>
		<result property="updateTime" column="update_time"/>
		<result property="isDeleted" column="is_deleted"/>
	</resultMap>
    
	<!-- 根据id获取cron表达式 -->
	<select id="getCronTriggerById" resultType="String">
		select cron from sys_cron_trigger where is_deleted=0 and id=#{id}
	</select>
    
</mapper>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 4. 测试

打印日志如下：

# 多线程定时任务

通过上面的日志我们可以看到任务执行都是单线程的。如果要实现多线程执行任务，我们可以通过在 SchedulingConfigurer 接口的 configureTasks方法中添加线程池即可。

# 1. CustomScheduleConfig

@Configuration
public class CustomScheduleConfig implements SchedulingConfigurer {

	@Autowired
	private CronTriggerDao cronTriggerDao;

	@Override
	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		
		//设定一个长度为10的定时任务线程池
		taskRegistrar.setScheduler(Executors.newScheduledThreadPool(10));
		
		// 上次开始执行时间点后5秒再执行
		taskRegistrar.addFixedRateTask(() -> System.out.println("CustomScheduleConfig执行任务job1=>"
				+ DateUtil.formatDateTime(new Date()) + ",线程：" + Thread.currentThread().getName()), 5000);
		// 上次执行完毕时间点后3秒再执行
		taskRegistrar.addFixedDelayTask(() -> System.out.println("CustomScheduleConfig执行任务job2=>"
				+ DateUtil.formatDateTime(new Date()) + ",线程：" + Thread.currentThread().getName()), 3000);
		// 添加第一个配合数据库动态执行的定时任务
		TriggerTask triggerTask = new TriggerTask(
				// 任务内容.拉姆达表达式
				() -> {
					// 1）添加任务 Runnable
					System.out.println("CustomScheduleConfig执行动态任务job3=>" + DateUtil.formatDateTime(new Date()) + ",线程："
							+ Thread.currentThread().getName());
					// 2）设置执行周期
				}, triggerContext -> {
					// 3）从数据库获取执行周期
					String cron = cronTriggerDao.getCronTriggerById(1L);
					if (cron != null) {
						// 4）返回执行周期（Date）
						return new CronTrigger(cron).nextExecutionTime(triggerContext);
					} else {
						return null;
					}

				});
		taskRegistrar.addTriggerTask(triggerTask);
		// 添加第二个配合数据库动态执行的定时任务
		TriggerTask triggerTask2 = new TriggerTask(
				// 任务内容.拉姆达表达式
				() -> {
					// 1）添加任务 Runnable
					System.out.println("CustomScheduleConfig执行动态任务job4=>" + DateUtil.formatDateTime(new Date()) + ",线程："
							+ Thread.currentThread().getName());
					// 2）设置执行周期
				}, triggerContext -> {
					// 3）从数据库获取执行周期
					String cron = cronTriggerDao.getCronTriggerById(2L);
					if (cron != null) {
						// 4）返回执行周期（Date）
						return new CronTrigger(cron).nextExecutionTime(triggerContext);
					} else {
						return null;
					}

				});
		taskRegistrar.addTriggerTask(triggerTask2);

	}

}

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

# 2. 测试

打印日志如下：

# Cron 表达式

# 1. Cron表达式格式

{秒} {分} {时} {日} {月} {周} {年(可选)}

# 2. Cron 表达式字段取值范围及说明

字段	取值范围	允许的特殊字符
Seconds（秒）	0 ~ 59	, - * /
Minutes（分）	0 ~ 59	, - * /
Hours（时）	0 ~ 23	, - * /
Day-of-Month（天）	可以用数字 1 ~ 31 中的任意一个值，但要注意特殊月份	, - * ? / L W C
Month（月）	可以用 0 ~ 11 或者字符串 “JAN、FEB、MAR、APR、MAY、JUN、JUL、AUG、SEP、OCT、NOV、DEC” 表示	, - * /
Day-of-Week（每周）	可以用数字 1 ~ 7 表示（1=星期日）或者用字符串 “SUN、MON、TUE、WED、THU、FRI、SAT” 表示	, - * ? / L C #
Year（年）	取值范围(1970-2099)，允许为空值	, - * /

# 3. Cron 表达式中特殊字符的意义

特殊字符	说明
*	表示可以匹配该域的所有值
？	主要用于日和星期，可以匹配域的任意值，但实际不会。当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为？
/	表示为每隔一段时间。如 0 0/10 * * * ? 其中的 0/10表示从0分钟开始，每隔10分钟执行一次
-	表示范围。如 0 0-5 14 * * ? 表示在每天14:00到14:05期间每1分钟执行一次
,	表示枚举多个值，这些值之间是"或"的关系。如 0 10,30 14 * 3 ? 表示每个星期二14点10分或者14点30分执行一次
L	表示每月或者每周的最后一天。如 0 0 0 L * ? * 表示每月的最后一天执行
W	表示最近工作日。如 0 0 0 15W * ？* 表示每月15号最近的那个工作日执行
#	用来指定具体的周数，"#"前面代表星期，"#"后面代表本月的第几周。如"2#1"表示本月第二周的星期日

# 4. Cron 在线生成工具

www.bejson.com/othertools/cron/ (opens new window)

← 05-集成JWT实现token验证 07-集成邮件服务 →