动态定时任务
基于SpringBoot + MySQL数据库实现动态定时任务
项目代码https://gitee.com/git870845084/scheduled.git
一、MySQL中新建task表
DROP TABLE IF EXISTS `task`;
CREATE TABLE `task` (
`task_id` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
`task_cron` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT 'cron表达式',
`task_class_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '类路径',
`task_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '名称',
`task_description` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '描述',
`task_enable` int(2) NOT NULL COMMENT '1/0 启动/关闭',
PRIMARY KEY (`task_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;
插入数据
INSERT INTO `task` VALUES ('1', '0/5 * * * * ?', 'com.scheduled.task.LogTask', '日志打印', NULL, 1);
INSERT INTO `task` VALUES ('2', '0/10 * * * * ?', 'com.scheduled.task.TestTask', '测试任务', NULL, 1);
Cron表达式参数:* * * * * *
秒(0~59)如:0/5表示每5秒
分(0~59)
时(0~59)
月的某天(0~31)需计算
月(0~11)
周几(1~7 或 SUN/MON/TUE/WED/THU/FRI/SAT)
二、新建一个SpringBoot项目
1.添加maven坐标
在pom.xml中添加maven坐标
<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>1.3.2</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
2.添加配置信息
application.properties
server.port=80
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/test?serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=666666
logging.level.com.example.demo.dao=debug
3.任务调度配置类
package com.scheduled.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
@Configuration
public class ScheduledConfig {
@Bean
public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
ThreadPoolTaskScheduler poolTaskScheduler = new ThreadPoolTaskScheduler();
poolTaskScheduler.setThreadNamePrefix("task-");
return poolTaskScheduler;
}
}
4.任务调度触发器
package com.scheduled.trigger;
import java.util.Date;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.support.CronTrigger;
public class ScheduledTrigger implements Trigger {
private String cron;
@SuppressWarnings("unused")
private ScheduledTrigger() {}
public ScheduledTrigger(String cron) {
this.cron = cron;
}
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
CronTrigger cronTrigger = new CronTrigger(cron);
Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
return nextExecutionTime;
}
}
5.任务调度组件用来开启/关闭/重启计划任务
package com.scheduled.dynamic;
import java.util.Collection;
import java.util.concurrent.ScheduledFuture;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import com.scheduled.domain.TaskEntity;
import com.scheduled.task.AbstractTask;
import com.scheduled.trigger.ScheduledTrigger;
@Component
public class DynamicScheduleTask {
@Autowired
private ThreadPoolTaskScheduler threadPoolTaskScheduler;
//关闭所有任务
public void shutDown() {
Collection<ScheduledFuture<?>> values = SingletonFuture.getInstance().getFutureMap().values();
for(ScheduledFuture<?> future:values) {
if (future != null) {
future.cancel(true);
}
}
SingletonFuture.getInstance().getFutureMap().clear();
}
public void start(AbstractTask task,TaskEntity entity) {
ScheduledTrigger trigger = new ScheduledTrigger(entity.getTask_cron());
ScheduledFuture<?> future = threadPoolTaskScheduler.schedule(task, trigger);
String className = entity.getTask_class_name();
SingletonFuture.getInstance().getFutureMap().put(className, future);
}
public void stop(String className) {
if(!StringUtils.isEmpty(className)) {
ScheduledFuture<?> future = SingletonFuture.getInstance().getFutureMap().get(className);
if (future != null) {
future.cancel(true);
SingletonFuture.getInstance().getFutureMap().remove(className);
}
}
}
public void restart(AbstractTask task,TaskEntity entity) {
stop(entity.getTask_class_name());
start(task, entity);
}
}
任务缓存类
package com.scheduled.dynamic;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
public class SingletonFuture {
private static volatile SingletonFuture ONLY;
private Map<String, ScheduledFuture<?>> futureMap = new ConcurrentHashMap<String, ScheduledFuture<?>>();
private SingletonFuture() {}
public static SingletonFuture getInstance() {
if(null == ONLY) {
synchronized(SingletonFuture.class) {
if(null == ONLY) {
ONLY = new SingletonFuture();
}
}
}
return ONLY;
}
public Map<String, ScheduledFuture<?>> getFutureMap() {
return futureMap;
}
public void setFutureMap(Map<String, ScheduledFuture<?>> futureMap) {
this.futureMap = futureMap;
}
}
6.需要执行的任务
任务父类
package com.scheduled.task;
public abstract class AbstractTask implements Runnable {
}
计划打印日志类
package com.scheduled.task;
import java.text.SimpleDateFormat;
import java.util.Date;
public class LogTask extends AbstractTask {
@Override
public void run() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = sdf.format(new Date());
System.out.println(date+" --- : i come");
}
}
计划测试类
package com.scheduled.task;
import java.text.SimpleDateFormat;
import java.util.Date;
public class TestTask extends AbstractTask {
@Override
public void run() {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date = sdf.format(new Date());
System.out.println(date+" --- : test");
}
}
7.domain实体
package com.scheduled.domain;
public class TaskEntity {
private String task_id;
private String task_cron;
private String task_class_name;
private String task_name;
private String task_description;
private Integer task_enable;
public String getTask_id() {
return task_id;
}
public void setTask_id(String task_id) {
this.task_id = task_id;
}
public String getTask_cron() {
return task_cron;
}
public void setTask_cron(String task_cron) {
this.task_cron = task_cron;
}
public String getTask_class_name() {
return task_class_name;
}
public void setTask_class_name(String task_class_name) {
this.task_class_name = task_class_name;
}
public String getTask_name() {
return task_name;
}
public void setTask_name(String task_name) {
this.task_name = task_name;
}
public String getTask_description() {
return task_description;
}
public void setTask_description(String task_description) {
this.task_description = task_description;
}
public Integer getTask_enable() {
return task_enable;
}
public void setTask_enable(Integer task_enable) {
this.task_enable = task_enable;
}
@Override
public String toString() {
return "TaskEntity [task_id=" + task_id + ", task_cron=" + task_cron + ", task_class_name=" + task_class_name
+ ", task_name=" + task_name + ", task_description=" + task_description + ", task_enable=" + task_enable
+ "]";
}
}
8.DAO层
package com.scheduled.dao.mapper;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import com.scheduled.domain.TaskEntity;
@Mapper
public interface TaskMapper {
@Select("SELECT task_id,task_cron,task_class_name,task_name,task_description,task_enable FROM task WHERE task_enable = 1")
List<TaskEntity> findAll();
@Select("SELECT task_id,task_cron,task_class_name,task_name,task_description,task_enable FROM task WHERE task_class_name=#{task_class_name}")
TaskEntity getTaskEntity(String task_class_name);
@Select("SELECT task_cron FROM task WHERE task_id=#{task_id}")
String getTaskCronById(String task_id);
}
9.SERVICE层
package com.scheduled.service;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import com.scheduled.dao.mapper.TaskMapper;
import com.scheduled.domain.TaskEntity;
@Service
public class TaskService {
@Autowired
private TaskMapper taskMapper;
public List<TaskEntity> findAll() {
List<TaskEntity> tasks = taskMapper.findAll();
if(tasks.isEmpty()) {
throw new RuntimeException("查询异常");
}
return tasks;
}
public TaskEntity getTaskEntity(String className) {
TaskEntity task = taskMapper.getTaskEntity(className);
if(null == task) {
throw new RuntimeException("查询异常");
}
return task;
}
public String getTaskCronById(String task_id) {
String cron = taskMapper.getTaskCronById(task_id);
if(StringUtils.isEmpty(task_id)) {
throw new RuntimeException("查询异常");
}
return cron;
}
}
10.WEB层
package com.scheduled.controll;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import com.scheduled.domain.TaskEntity;
import com.scheduled.dynamic.DynamicScheduleTask;
import com.scheduled.service.TaskService;
import com.scheduled.task.AbstractTask;
@RestController
public class CronContrll {
@Autowired
private DynamicScheduleTask scheduleTask;
@Autowired
private TaskService taskService;
@GetMapping("startAll")
public void startAll() throws InstantiationException, IllegalAccessException, ClassNotFoundException {
List<TaskEntity> taskEntitys = taskService.findAll();
for(TaskEntity entity:taskEntitys) {
Object newInstance = Class.forName(entity.getTask_class_name()).newInstance();
AbstractTask task = (AbstractTask) newInstance;
scheduleTask.start(task, entity);
}
}
@GetMapping("shutDown")
public void shutDown() {
scheduleTask.shutDown();
}
@GetMapping("start/{className}")
public void start(@PathVariable("className") String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
TaskEntity entity = taskService.getTaskEntity(className);
Object newInstance = Class.forName(className).newInstance();
AbstractTask task = (AbstractTask) newInstance;
scheduleTask.start(task, entity);
}
@GetMapping("stop/{className}")
public void stop(@PathVariable("className") String className) {
scheduleTask.stop(className);
}
@GetMapping("restart/{className}")
public void restart(@PathVariable("className") String className) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
TaskEntity entity = taskService.getTaskEntity(className);
Object newInstance = Class.forName(className).newInstance();
AbstractTask task = (AbstractTask) newInstance;
scheduleTask.restart(task, entity);
}
}
运行结果