SpringBoot+Quartz实现动态可配定时任务（动态定时任务）

本文主要详细介绍了SpringBoot架构下搭配Quartz动态定时任务的使用，定时任务表达式配置在数据库中。
支持查看任务状态，动态修改任务时间，停止任务等。启动类启动后任务自启动，一个字，方便！下面我们来看看如何实现：

按我的步骤一步一步来即可，先在springboot项目建一个quartz模块，配置好配置文件（服务名等，可参照你其他模块的配置文件），然后执行以下步骤

1.前置准备
1.1数据库创建任务表
CREATE TABLE `scheduled_task` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`task_key` varchar(128) NOT NULL COMMENT '任务key值（使用bean名称）',
`task_desc` varchar(128) DEFAULT NULL COMMENT '任务描述',
`task_cron` varchar(128) NOT NULL COMMENT '任务表达式',
`init_start_flag` int(2) NOT NULL DEFAULT '1' COMMENT '程序初始化是否启动 1 是 0 否',
`create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
`update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
PRIMARY KEY (`id`),
UNIQUE KEY `uniqu_task_key` (`task_key`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

1.2添加初始化测试数据
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (1, 'scheduledTask01', '定时任务01', '0/1 * * * * ?', 1, NOW(), NOW());
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (2, 'scheduledTask02', '定时任务02', '0/1 * * * * ?', 0, NOW(), NOW());
INSERT INTO `cron`.`scheduled_task`(`id`, `task_key`, `task_desc`, `task_cron`, `init_start_flag`, `create_time`, `update_time`) VALUES (3, 'scheduledTask03', '定时任务03', '0/1 * * * * ?', 1, NOW(), NOW());

我这里corn配置的是每分钟执行一次，目的：方便自测

1.3创建Maven项目并添加Maven依赖
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.12.RELEASE</version>
</parent>

<properties>
<fastjson.version>1.2.47</fastjson.version>
<mybatis-spring-boot.version>1.3.1</mybatis-spring-boot.version>
<mybatis-spring-boot-starter.version>1.3.0</mybatis-spring-boot-starter.version>
<mybatis-plus.version>2.1-gamma</mybatis-plus.version>
<druid.version>1.1.2</druid.version>
</properties>
<dependencies>

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>${mybatis-spring-boot.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>${fastjson.version}</version>
</dependency>
</dependencies>

1.4添加配置文件application.properties
server.port=8081
spring.datasource.url:jdbc:mysql://localhost:3306/cron?useSSL=false
spring.datasource.username:root
spring.datasource.password:root

1.5添加SpringBoot启动类
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

2.任务调度
2.1创建定时任务线程池,初始化任务Map
注：任务map，存的是你的任务信息，项目启动即把这些任务初始化

import com.scheduled.dynamic.enums.ScheduledTaskEnum;
import com.scheduled.dynamic.service.ScheduledTaskJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.Map;
@Configuration
public class ScheduledTaskConfig {

/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskConfig.class);

@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
LOGGER.info("创建定时任务调度线程池 start");
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(20);
threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
LOGGER.info("创建定时任务调度线程池 end");
return threadPoolTaskScheduler;
}

/**
* 初始化定时任务Map
* key :任务key
* value : 执行接口实现
*/
@Bean(name = "scheduledTaskJobMap")
public Map<String, ScheduledTaskJob> scheduledTaskJobMap() {
return ScheduledTaskEnum.initScheduledTask();
}

}

2.2创建任务实体Bean
public class ScheduledTaskBean {

/**
* 任务key值唯一
*/
private String taskKey;
/**
* 任务描述
*/
private String taskDesc;
/**
* 任务表达式
*/
private String taskCron;

/**
* 程序初始化是否启动 1 是 0 否
*/
private Integer initStartFlag;

/**
* 当前是否已启动
*/
private boolean startFlag;
//省略 get/set get/set你可以加@Data就行了

2.3Mapper接口
/**
* 定时任务表 mapper
* 这里我就用注解写了，偷偷懒
*/
@Mapper
public interface ScheduledTaskMapper {

/**
* 根据key 获取任务信息
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task where task_key = '${taskKey}' ")
ScheduledTaskBean getByKey(@Param("taskKey") String taskKey);

/**
* 获取程序初始化需要自启的任务信息
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task where init_start_flag=1 ")
List<ScheduledTaskBean> getAllNeedStartTask();

/**
* 获取所有任务
*/
@Select("select task_key as taskKey,task_desc as taskDesc,task_cron as taskCron,init_start_flag as initStartFlag from scheduled_task ")
List<ScheduledTaskBean> getAllTask();
}

2.4创建调度任务公共父接口
/**
* 调度任务公共父接口
*/
public interface ScheduledTaskJob extends Runnable {
}

2.5实现父接口，重写run方法
注：ScheduledTask02和ScheduledTask03，我没写了，你复制01复制一下，把名字改了就行

import com.scheduled.dynamic.service.ScheduledTaskJob;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* 任务 01
*/
public class ScheduledTask01 implements ScheduledTaskJob {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTask01.class);

@Override
public void run() {
LOGGER.info("ScheduledTask => 01 run 当前线程名称 {} ", Thread.currentThread().getName());
}
}

2.6创建定时任务枚举类
注：方便管理任务

import com.scheduled.dynamic.service.ScheduledTaskJob;
import com.scheduled.dynamic.task.*;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
* 定时任务枚举值
* 注：key 需要与数据库保持一致！！！(非常重要，不然报错让你怀疑人生)
*/
public enum ScheduledTaskEnum {

/**
* 任务1
*/
TASK_01("scheduledTask01", new ScheduledTask01()),
/**
* 任务2
*/
TASK_02("scheduledTask02", new ScheduledTask02()),
/**
* 任务3
*/
TASK_03("scheduledTask03", new ScheduledTask03()),
;
/**
* 定时任务key
*/
private String taskKey;
/**
* 定时任务执行实现类
*/
private ScheduledTaskJob scheduledTaskJob;

ScheduledTaskEnum(String taskKey, ScheduledTaskJob scheduledTaskJob) {
this.taskKey = taskKey;
this.scheduledTaskJob = scheduledTaskJob;
}

/**
* 初始化所有任务
*/
public static Map<String, ScheduledTaskJob> initScheduledTask() {
if (ScheduledTaskEnum.values().length < 0) {
return new ConcurrentHashMap<>();
}
Map<String, ScheduledTaskJob> scheduledTaskJobMap = new ConcurrentHashMap<>();
for (ScheduledTaskEnum taskEnum : ScheduledTaskEnum.values()) {
scheduledTaskJobMap.put(taskEnum.taskKey, taskEnum.scheduledTaskJob);
}
return scheduledTaskJobMap;
}
}

2.7功能核心接口
/**
* 定时任务接口
*/
public interface ScheduledTaskService {

/**
* 所有任务列表
*/
List<ScheduledTaskBean> taskList();

/**
* 根据任务key 启动任务
*/
Boolean start(String taskKey);

/**
* 根据任务key 停止任务
*/
Boolean stop(String taskKey);

/**
* 根据任务key 重启任务
*/
Boolean restart(String taskKey);

/**
* 程序启动时初始化 ==> 启动所有正常状态的任务
*/
void initAllTask(List<ScheduledTaskBean> scheduledTaskBeanList);

}

/**
* 定时任务实现
*/
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskServiceImpl.class);

@Autowired
private ScheduledTaskMapper taskMapper;
/**
* 可重入锁
*/
private ReentrantLock lock = new ReentrantLock();
/**
* 定时任务线程池
*/
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;
/**
* 所有定时任务存放Map
* key :任务 key
* value:任务实现
*/
@Autowired
@Qualifier(value = "scheduledTaskJobMap")
private Map<String, ScheduledTaskJob> scheduledTaskJobMap;

/**
* 存放已经启动的任务map
*/
private Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();

/**
* 所有任务列表
*/
@Override
public List<ScheduledTaskBean> taskList() {
LOGGER.info(">>>>>> 获取任务列表开始 >>>>>> ");
//数据库查询所有任务 => 未做分页
List<ScheduledTaskBean> taskBeanList = taskMapper.getAllTask();
if (CollectionUtils.isEmpty(taskBeanList)) {
return new ArrayList<>();
}

for (ScheduledTaskBean taskBean : taskBeanList) {
String taskKey = taskBean.getTaskKey();
//是否启动标记处理
taskBean.setStartFlag(this.isStart(taskKey));
}
LOGGER.info(">>>>>> 获取任务列表结束 >>>>>> ");
return taskBeanList;
}

/**
* 根据任务key 启动任务
*/
@Override
public Boolean start(String taskKey) {
LOGGER.info(">>>>>> 启动任务 {} 开始 >>>>>>", taskKey);
//添加锁放一个线程启动，防止多人启动多次
lock.lock();
LOGGER.info(">>>>>> 添加任务启动锁完毕");
try {
//校验是否已经启动
if (this.isStart(taskKey)) {
LOGGER.info(">>>>>> 当前任务已经启动，无需重复启动！");
return false;
}
//校验任务是否存在
if (!scheduledTaskJobMap.containsKey(taskKey)) {
return false;
}
//根据key数据库获取任务配置信息
ScheduledTaskBean scheduledTask = taskMapper.getByKey(taskKey);
//启动任务
this.doStartTask(scheduledTask);
} finally {
// 释放锁
lock.unlock();
LOGGER.info(">>>>>> 释放任务启动锁完毕");
}
LOGGER.info(">>>>>> 启动任务 {} 结束 >>>>>>", taskKey);
return true;
}

/**
* 根据 key 停止任务
*/
@Override
public Boolean stop(String taskKey) {
LOGGER.info(">>>>>> 进入停止任务 {} >>>>>>", taskKey);
//当前任务实例是否存在
boolean taskStartFlag = scheduledFutureMap.containsKey(taskKey);
LOGGER.info(">>>>>> 当前任务实例是否存在 {}", taskStartFlag);
if (taskStartFlag) {
//获取任务实例
ScheduledFuture scheduledFuture = scheduledFutureMap.get(taskKey);
//关闭实例
scheduledFuture.cancel(true);
}
LOGGER.info(">>>>>> 结束停止任务 {} >>>>>>", taskKey);
return taskStartFlag;
}

/**
* 根据任务key 重启任务
*/
@Override
public Boolean restart(String taskKey) {
LOGGER.info(">>>>>> 进入重启任务 {} >>>>>>", taskKey);
//先停止
this.stop(taskKey);
//再启动
return this.start(taskKey);
}

/**
* 程序启动时初始化 ==> 启动所有正常状态的任务
*/
@Override
public void initAllTask(List<ScheduledTaskBean> scheduledTaskBeanList) {
LOGGER.info("程序启动 ==> 初始化所有任务开始！size={}", scheduledTaskBeanList.size());
if (CollectionUtils.isEmpty(scheduledTaskBeanList)) {
return;
}
for (ScheduledTaskBean scheduledTask : scheduledTaskBeanList) {
//任务 key
String taskKey = scheduledTask.getTaskKey();
//校验是否已经启动
if (this.isStart(taskKey)) {
continue;
}
//启动任务
this.doStartTask(scheduledTask);
}
LOGGER.info("程序启动 ==> 初始化所有任务结束！size={}", scheduledTaskBeanList.size());
}

/**
* 执行启动任务
*/
private void doStartTask(ScheduledTaskBean scheduledTask) {
//任务key
String taskKey = scheduledTask.getTaskKey();
//定时表达式
String taskCron = scheduledTask.getTaskCron();
//获取需要定时调度的接口
ScheduledTaskJob scheduledTaskJob = scheduledTaskJobMap.get(taskKey);
LOGGER.info(">>>>>> 任务 [ {} ] ,cron={}", scheduledTask.getTaskDesc(), taskCron);
ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob,
new Trigger() {
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
CronTrigger cronTrigger = new CronTrigger(taskCron);
return cronTrigger.nextExecutionTime(triggerContext);
}
});
//将启动的任务放入 map
scheduledFutureMap.put(taskKey, scheduledFuture);
}

/**
* 任务是否已经启动
*/
private Boolean isStart(String taskKey) {
//校验是否已经启动
if (scheduledFutureMap.containsKey(taskKey)) {
if (!scheduledFutureMap.get(taskKey).isCancelled()) {
return true;
}
}
return false;
}

}

2.8 定时任务Controller

/**
* 定时任务 controller
*/
@RestController
@RequestMapping("/scheduled")
public class ScheduledController {
@Autowired
private ScheduledTaskService scheduledTaskService;
/**
* 所有任务列表
*/
@RequestMapping("/taskList")
public List<ScheduledTaskBean> taskList() {
return scheduledTaskService.taskList();
}

/**
* 根据任务key => 启动任务
*/
@RequestMapping("/start")
public String start(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.start(taskKey);
return "start success";
}

/**
* 根据任务key => 停止任务
*/
@RequestMapping("/stop")
public String stop(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.stop(taskKey);
return "stop success";
}

/**
* 根据任务key => 重启任务
*/
@RequestMapping("/restart")
public String restart(@RequestParam("taskKey") String taskKey) {
scheduledTaskService.restart(taskKey);
return "restart success";
}

}

到这里，恭喜你，CV大法又精进了，咳咳，偏了偏了，是已经可以实现，动态管理任务了，包括动态修改启动表达式，停止任务，启动任务，重启任务等。

但是，还有一个问题，项目重启后，需要人工来启动需要启动的任务。谁不想偷点懒呢，让它自启动多好，打包扔上去启动就行了，谁还一个一个去启，麻烦，于是我们再加一步：

2.9实现项目启动时自启动
注：SpringBoot给我们提供了两个接口来帮助我们实现这种需求。这两个接口分别为CommandLineRunner和ApplicationRunner。他们的执行时机为容器启动完成的时候。

/**
* @see @Order注解的执行优先级是按value值从小到大顺序。
* 项目启动完毕后开启需要自启的任务
*/
@Component
@Order(value = 1)
public class ScheduledTaskRunner implements ApplicationRunner {
/**
* 日志
*/
private static final Logger LOGGER = LoggerFactory.getLogger(ScheduledTaskRunner.class);

@Autowired
private ScheduledTaskMapper taskMapper;

@Autowired
private ScheduledTaskService scheduledTaskService;

/**
* 程序启动完毕后,需要自启的任务
*/
@Override
public void run(ApplicationArguments applicationArguments) throws Exception {
LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务开始!");
List<ScheduledTaskBean> scheduledTaskBeanList = taskMapper.getAllNeedStartTask();
scheduledTaskService.initAllTask(scheduledTaskBeanList);
LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务结束！");
}
}

到这里，算是没啥问题了，只需要把你的任务模块代码写到run方法里就行

福利：
https://github.com/mengq0815/spring-boot-example/tree/master/spring-boot-scheduled-task
---------------------
作者：君子博学而日参省乎己
来源：博客园

posted @ 2019-07-19 16:39 君子博学而日参省乎己阅读(5796) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

君子博学而日参省乎己

SpringBoot+Quartz实现动态可配定时任务（动态定时任务）

公告