创建父级parent类
创建返回值统一类 ResultBody
package com.example.demo.schedule.parent.controller;
import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings("all")
public class ResultBody<T> implements Serializable {
private static final long serialVersionUID = -6190689122701100762L;
/**
* 响应编码
*/
private int code = 0;
/**
* 提示消息
*/
private String msg = "操作成功";
/**
* 请求路径
*/
private String path;
/**
* 响应数据
*/
private T data;
/**
* 附加数据
*/
private Map<String, Object> extra;
/**
* 响应时间
*/
private long timestamp = System.currentTimeMillis();
public ResultBody() {
super();
}
public static ResultBody ok() {
return new ResultBody();
}
public static ResultBody fail() {
ResultBody resultBody = new ResultBody();
resultBody.code = -1;
resultBody.msg = "操作失败";
return resultBody;
}
public ResultBody put(String key, Object value) {
if (this.extra == null) {
this.extra = new HashMap<>();
}
this.extra.put(key, value);
return this;
}
public ResultBody data(T data) {
this.data = data;
return this;
}
public ResultBody msg(String msg) {
this.msg = msg;
return this;
}
public ResultBody path(String path) {
this.path = path;
return this;
}
public ResultBody extra(Map<String, Object> extra) {
this.extra = extra;
return this;
}
public ResultBody code(int code) {
this.code = code;
return this;
}
/* public ResultBody getEncrypt(String salt) {
try {
this.data = (T) AESUtils.encrypt(salt,
DateUtils.formatDate(new Date(), "yyyyMMdd"),
JSON.toJSONString(this.data));
} catch (Exception e) {
e.printStackTrace();
}
return this;
}*/
public String json() {
return JSON.toJSONString(this);
}
public static long getSerialVersionUID() {
return serialVersionUID;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public String getPath() {
return path;
}
public void setPath(String path) {
this.path = path;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
public Map<String, Object> getExtra() {
return extra;
}
public void setExtra(Map<String, Object> extra) {
this.extra = extra;
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(long timestamp) {
this.timestamp = timestamp;
}
}
创建 SmartTaskController
package com.example.demo.schedule.parent.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
@RestController
@RequestMapping(value = "/smart/task")
public class SmartTaskController {
@Autowired
private SmartTaskService smartTaskService;
@Autowired
private DynamicTaskService dynamicTaskService;
/**
* 分页查看任务列表
* @param paramMap
* @return
*/
@GetMapping(value = "/page")
public ResultBody page(@RequestParam Map<String, Objects> paramMap) {
return ResultBody.ok().data(smartTaskService.findTaskPageList( ));
}
/**
* 查看task详情
* @param taskId
* @return
*/
@GetMapping(value = "/getByTaskId/{taskId}")
public ResultBody<SmartTask> getByTaskId(@PathVariable("taskId") String taskId) {
return ResultBody.ok().data(smartTaskService.findTaskByTaskId(taskId));
}
/**
* 创建定时任务
* @param smartTask
* @return
*/
@PostMapping(value = "/addTask")
public ResultBody addTask(SmartTask smartTask) {
try {
smartTaskService.addTask(smartTask);
if (smartTask.getState()==1) {
dynamicTaskService.addTask(smartTask);
}
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
/**
* 更新定时任务
* @param smartTask
* @return
*/
@PostMapping(value = "/updatByTaskId")
public ResultBody updatByTaskId(@RequestBody SmartTask smartTask) {
try {
if ( null != smartTask.getExtra()) {
smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
}
smartTaskService.updateTaskByTaskId(smartTask);
SmartTask task = smartTaskService.findTaskByTaskId(smartTask.getTaskId());
if (task.getState()==1) {
dynamicTaskService.resetTriggerTask(task);
}
return ResultBody.ok();
} catch (Exception e) {
e.printStackTrace();
return ResultBody.fail().msg(e.getMessage());
}
}
/**
* 重启定时任务
* @param taskId
* @return
*/
@GetMapping(value = "/cancelByTaskId/{taskId}")
public ResultBody cancelByTaskId(@PathVariable("taskId") String taskId) {
try {
if (!dynamicTaskService.hasTask(taskId)) {
throw new RuntimeException("任务尚未执行,不可取消!");
}
SmartTask smartTask = new SmartTask();
smartTask.setTaskId(taskId);
smartTask.setState(0);
smartTaskService.updateTaskByTaskId(smartTask);
dynamicTaskService.cancelTriggerTask(taskId);
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
/**
* 批量取消任务
* @param taskIdList
* @return
*/
@PostMapping(value = "/cancel")
public ResultBody cancel(@RequestBody List<String> taskIdList) {
smartTaskService.updateStateBatch(0, taskIdList.stream().filter(x->!dynamicTaskService.hasTask(x)).collect(Collectors.toList()));
return ResultBody.ok();
}
/**
* 启动一个定时任务
* @param taskId
* @return
*/
@GetMapping(value = "/start/{taskId}")
public ResultBody start(@PathVariable("taskId") String taskId) {
try {
if (dynamicTaskService.hasTask(taskId)) {
throw new RuntimeException("当前任务已执行,不可重复操作!");
}
SmartTask smartTask = new SmartTask();
smartTask.setTaskId(taskId);
smartTask.setState(1);
smartTaskService.updateTaskByTaskId(smartTask);
dynamicTaskService.addTask(smartTaskService.findTaskByTaskId(taskId));
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
/**]
* 重置任务
* @param taskId
* @return
*/
@GetMapping(value = "/restart/{taskId}")
public ResultBody restart(@PathVariable("taskId") String taskId) {
try {
SmartTask smartTask = new SmartTask();
smartTask.setTaskId(taskId);
smartTask.setState(1);
smartTaskService.updateTaskByTaskId(smartTask);
dynamicTaskService.resetTriggerTask(smartTask);
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
/**
* 获取所有运行中的任务
* @return
*/
@GetMapping(value = "/getRunTaskList")
public ResultBody<List<SmartTask>> getRunTaskList() {
return ResultBody.ok().data(smartTaskService.getRunTaskList(dynamicTaskService.getRunTaskIdList()));
}
/**
* 创建每周任务
* @param smartTask
* @return
*/
@PostMapping(value = "/addWeekTask")
public ResultBody addWeekTask(@RequestBody SmartTask smartTask) {
try {
if (null != smartTask.getExtra()) {
throw new RuntimeException("任务创建失败!,未指定公式!");
}
smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
smartTaskService.addTask(smartTask);
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
private String cron(String cron, String extra) {
if (null == extra) {
return cron;
}
JSONObject jsonObject = JSON.parseObject(extra);
String newCron = "";
switch (jsonObject.getIntValue("type")) {
case 1: {
//每天
//获取每周哪一天的几天执行
int hour = jsonObject.getIntValue("hour");
//分
int minute = jsonObject.getIntValue("minute");
//秒
int second = jsonObject.getIntValue("second");
newCron = String.format("%d %d %d ? * *", second, minute, hour);
} break;
case 2: {
//每周的哪一天执行
int day = jsonObject.getIntValue("day");
//获取每周哪一天的几天执行
int hour = jsonObject.getIntValue("hour");
//分
int minute = jsonObject.getIntValue("minute");
//秒
int second = jsonObject.getIntValue("second");
newCron = String.format("%d %d %d ? * %d", second, minute, hour, day);
} break;
}
System.err.println("生成表达式:" + newCron);
return newCron;
}
/**
* 创建每天任务
* @return
*/
@PostMapping(value = "/addEveryDay")
public ResultBody addEveryDay(@RequestBody SmartTask smartTask) {
try {
if (null != smartTask.getExtra()) {
throw new RuntimeException("任务创建失败!,未指定公式!");
}
smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
smartTaskService.addTask(smartTask);
return ResultBody.ok();
} catch (Exception e) {
return ResultBody.fail().msg(e.getMessage());
}
}
}
创建 SmartTaskMapper
package com.example.demo.schedule.parent.mapper;
import com.example.demo.schedule.parent.model.SmartTask;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import java.util.List;
@Mapper
public interface SmartTaskMapper {
/**
* 批量执行状态更新
* @param state
* @param idList
*/
void updateStateBatch(@Param("state") int state, @Param("idList") List<String> idList);
@Select("select t.task_id as taskId, t.name as name, t.create_time as createTime, t.update_time as updateTime, t.cron as cron, t.state as state, t.brief as brief, t.clazz_name as clazzName, t.business_type as businessType, t.extra as extra from t_task t where t.state = 1 and t.business_type ='${businessType}' ")
List<SmartTask> getList(@Param("businessType") Integer businessType );
}
创建 实体类
package com.example.demo.schedule.parent.model;
import java.io.Serializable;
/**
* 任务模型
*/
public class SmartTask implements Serializable {
/**
* 对应任务ID
*/
private String taskId;
/**
* 定时任务表达式
*/
private String cron;
/**
* 具体执行的操作
*/
// private Runnable runnable;
/**
* 任务名称
*/
private String name;
/**
* 任务状态,1:开启,0:未开启
*/
private Integer state;
/**
* 任务描述
*/
private String brief;
/**
* 实现任务的类名 (路径 + 类名 例如:cn.xxx.TaskXXX)
*/
private String clazzName;
/**
* 业务类型 1: 每周答题
*/
private Integer businessType;
/**
* 附加数据
*/
private String extra;
public String createTime;
/**
* 修改时间
*/
public String updateTime;
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 String getTaskId() {
return taskId;
}
public void setTaskId(String taskId) {
this.taskId = taskId;
}
public String getCron() {
return cron;
}
public void setCron(String cron) {
this.cron = cron;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getState() {
return state;
}
public void setState(Integer state) {
this.state = state;
}
public String getBrief() {
return brief;
}
public void setBrief(String brief) {
this.brief = brief;
}
public String getClazzName() {
return clazzName;
}
public void setClazzName(String clazzName) {
this.clazzName = clazzName;
}
public Integer getBusinessType() {
return businessType;
}
public void setBusinessType(Integer businessType) {
this.businessType = businessType;
}
public String getExtra() {
return extra;
}
public void setExtra(String extra) {
this.extra = extra;
}
}
创建 SmartTaskService
package com.example.demo.schedule.parent.service;
import com.example.demo.schedule.parent.model.SmartTask;
import java.util.List;
/**
* 动态定时任务相关信息
*/
public interface SmartTaskService {
/**
* 创建定时任务
* @param smartTask
*/
void addTask(SmartTask smartTask);
/**
* 更新任务
* @param smartTask
*/
void updateTaskByTaskId(SmartTask smartTask);
/**
* 查询任务列表
* @param
* @return
*/
List<SmartTask> findTaskPageList( );
/**
* 查看任务详情
* @param taskId
* @return
*/
SmartTask findTaskByTaskId(String taskId);
/**
* 删除任务
* @param taskId
*/
void deleteTaskByTaskId(String taskId);
/**
* 查询所有在执行的任务
* @return
*/
List<SmartTask> findAll(SmartTask smartTask);
/**
* 获取所有执行中的任务
* @param idList
* @return
*/
List<SmartTask> getRunTaskList(List<String> idList);
/**
* 批量执行状态更新
* @param state
* @param idList
*/
void updateStateBatch(int state, List<String> idList);
/**
* 启动指定类型的任务
* @param businessType 任务类型
*/
void runTask( Integer businessType );
}
创建 SmartTaskServiceImpl 实现类
package com.example.demo.schedule.parent.service.impl;
import com.example.demo.schedule.parent.mapper.SmartTaskMapper;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service("smartTaskService")
public class SmartTaskServiceImpl implements SmartTaskService {
@Autowired
private SmartTaskMapper smartTaskMapper;
@Autowired
private DynamicTaskService dynamicTaskService;
/**
* 创建定时任务
*
* @param smartTask
*/
@Override
public void addTask(SmartTask smartTask) {
// smartTaskMapper.insert(smartTask);
}
/**
* 更新任务
*
* @param smartTask
*/
@Override
public void updateTaskByTaskId(SmartTask smartTask) {
// smartTaskMapper.updateById(smartTask);
}
/**
* 查询任务列表
*
* @param
* @return
*/
@Override
public List<SmartTask> findTaskPageList( ) {
return null;
}
/**
* 查看任务详情
*
* @param taskId
* @return
*/
@Override
public SmartTask findTaskByTaskId(String taskId) {
return null;
}
/**
* 删除任务
*
* @param taskId
*/
@Override
public void deleteTaskByTaskId(String taskId) {
}
/**
* 查询所有在执行的任务
*
* @return
*/
@Override
public List<SmartTask> findAll(SmartTask smartTask) {
return null;
}
/**
* 获取所有执行中的任务
*
* @param idList
* @return
*/
@Override
public List<SmartTask> getRunTaskList(List<String> idList) {
return null;
}
/**
* 批量执行状态更新
*
* @param state
* @param idList
*/
@Override
public void updateStateBatch(int state, List<String> idList) {
smartTaskMapper.updateStateBatch(state, idList);
}
@Override
public void runTask( Integer businessType ) {
List<SmartTask> smartTaskList = smartTaskMapper.getList(businessType );
if (smartTaskList!=null&&smartTaskList.size()>0) {
for (SmartTask smartTask : smartTaskList) {
dynamicTaskService.addTask(smartTask);
}
}
}
}
创建 DynamicTaskService
package com.example.demo.schedule.parent.service;
import com.example.demo.schedule.parent.model.SmartTask;
import java.util.List;
import java.util.Set;
public abstract class DynamicTaskService {
/**
* 添加任务
*/
public abstract void addTask(SmartTask smartTask);
/**
* 取消任务
*/
public abstract void cancelTriggerTask(String taskId);
/**
* 重置任务
*/
public abstract void resetTriggerTask(SmartTask smartTask);
/**
* 任务编号
*/
public abstract Set<String> taskIds();
/**
* 是否存在任务
*/
public abstract boolean hasTask(String taskId);
/**
* 是否初始化
* @return
*/
public abstract boolean inited();
/**
* 获取执行中的任务ID
* @return
*/
public abstract List<String> getRunTaskIdList();
}
创建 DynamicTaskService 实现类
package com.example.demo.schedule.parent.service.impl;
import com.example.demo.schedule.parent.SpringContextUtils;
import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import org.springframework.core.annotation.Order;
import org.springframework.scheduling.SchedulingException;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;
@EnableScheduling
@Service("dynamicTaskService")
@SuppressWarnings("all")
@Order(-5000)
public class DynamicTaskServiceImpl extends DynamicTaskService implements SchedulingConfigurer {
private ScheduledTaskRegistrar taskRegistrar = null;
private Map<String, ScheduledFuture<?>> taskFutures =new HashMap<>() ; // Maps.newHashMap();
@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
this.taskRegistrar = taskRegistrar;
}
/**
* 添加任务
* @param taskId 任务id
* @param cron 表达式
* @param runnable 代码块
*/
@Override
public void addTask(SmartTask smartTask) {
synchronized (this) {
if (taskFutures.containsKey(smartTask.getTaskId())) {
throw new SchedulingException(" taskId[" + smartTask.getTaskId() + "] 已存在.");
}
try {
TaskScheduler scheduler = taskRegistrar.getScheduler();
System.out.println(smartTask.getClazzName());
System.err.println("smartTask = " + smartTask);
Class clazz = Class.forName(smartTask.getClazzName());
AbstractTaskQueue runnable = (AbstractTaskQueue) SpringContextUtils.getBean(clazz);
runnable.setSmartTask(smartTask);
ScheduledFuture<?> future = scheduler.schedule(runnable, new CronTrigger(smartTask.getCron()));
taskFutures.put(smartTask.getTaskId(), future);
} catch (Exception e) {
e.printStackTrace();
}
}
}
/**
* 取消任务
*/
@Override
public void cancelTriggerTask(String taskId) {
ScheduledFuture<?> future = taskFutures.get(taskId);
if (future != null) {
future.cancel(true);
}
taskFutures.remove(taskId);
}
/**
* 重置任务
*/
@Override
public void resetTriggerTask(SmartTask smartTask) {
cancelTriggerTask(smartTask.getTaskId());
addTask(smartTask);
}
/**
* 任务编号
*/
@Override
public Set<String> taskIds() {
return taskFutures.keySet();
}
/**
* 是否存在任务
*/
@Override
public boolean hasTask(String taskId) {
return this.taskFutures.containsKey(taskId);
}
/**
* 任务调度是否已经初始化完成
*/
@Override
public boolean inited() {
return this.taskRegistrar != null && this.taskRegistrar.getScheduler() != null;
}
/**
* 获取执行中的任务ID
*
* @return
*/
@Override
public List<String> getRunTaskIdList() {
return taskFutures.keySet().stream().collect(Collectors.toList());
}
}
创建 配置文件 AbstractTaskQueue
package com.example.demo.schedule.parent.parentConfig;
import com.example.demo.schedule.parent.model.SmartTask;
public abstract class AbstractTaskQueue implements Runnable {
/**
* 将任务本身当做参数传入
*/
protected SmartTask smartTask;
public SmartTask getSmartTask() {
return smartTask;
}
public void setSmartTask(SmartTask smartTask) {
this.smartTask = smartTask;
}
}
创建 配置文件 ApplicationStartListener
package com.example.demo.schedule.parent.parentConfig;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
/**
* 放入父模块
* 监听程序启动
*/
@SuppressWarnings("all")
public class ApplicationStartListener implements ApplicationListener<ContextRefreshedEvent> {
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
System.out.println("程序已加载");
}
}
创建 配置文件 DynamicTaskConfiguration
package com.example.demo.schedule.parent.parentConfig;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.event.ContextRefreshedEvent;
//父类模块(多服务的时候,放入父模块)
public abstract class DynamicTaskConfiguration extends ApplicationStartListener implements ApplicationContextAware {
protected ApplicationContext context;
@Autowired
protected SmartTaskService smartTaskService;
@Autowired
protected DynamicTaskService dynamicTaskService;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
super.onApplicationEvent(event);
dynamicTaskService.inited();
}
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
this.context = context;
}
}
创建 配置文件 SpringContextUtils
package com.example.demo.schedule.parent;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
@Component
public class SpringContextUtils implements ApplicationContextAware{
private static ApplicationContext applicationContext;
public SpringContextUtils() {
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtils.applicationContext = applicationContext;
}
public static Object getBean(String beanName) {
return applicationContext != null ? applicationContext.getBean(beanName) : null;
}
public static <T> T getBean(Class<T> clazz) {
return applicationContext != null?applicationContext.getBean(clazz):null;
}
}
创建 children 子项目文件
创建配置文件TaskConfiguration (项目启动加载子项目1)
package com.example.demo.schedule.children.config;
import com.example.demo.schedule.parent.parentConfig.DynamicTaskConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
/**
* 写到子模块里面(每个子服务的定时任务不同,所有需要区分下)
* 服务器启动的时候加载对应的定时任务
*/
@Configuration
public class TaskConfiguration extends DynamicTaskConfiguration {
//添加每天轮训资格证有效期(通过条件查询对应的定时任务)
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
super.onApplicationEvent(event);
smartTaskService.runTask(1);
}
}
创建配置文件TaskConfigurationCount (项目启动加载子项目2)
package com.example.demo.schedule.children.config;
import com.example.demo.schedule.parent.parentConfig.DynamicTaskConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
/**
* @author: xlk
*/
@Configuration
public class TaskConfigurationCount extends DynamicTaskConfiguration {
//添加每天统计资格证的数量
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
super.onApplicationEvent(event);
smartTaskService.runTask( 2 );
}
}
创建执行任务逻辑1
package com.example.demo.schedule.children.task;
import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import org.springframework.stereotype.Component;
//定时任务执行逻辑
@Component
public class RotationQualificationCreator extends AbstractTaskQueue {
@Override
public void run() {
System.out.println(" =====定时任务开始执行逻辑====== " );
}
}
创建执行任务逻辑2
package com.example.demo.schedule.children.task;
import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import org.springframework.stereotype.Component;
@Component
public class RotationQualificationCreatorCount extends AbstractTaskQueue {
@Override
public void run() {
System.out.println(" ============== 每天定时统计资格证数量 ========== " );
}
}
创建 启动类
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@EnableScheduling
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
创建 application.properties
server.port=8081
spring.datasource.url:jdbc:mysql://192.168.1.215:3306/task_demo?useSSL=false
spring.datasource.username:root
spring.datasource.password:root
创建数据库脚本
SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;
-- ----------------------------
-- Table structure for t_task
-- ----------------------------
DROP TABLE IF EXISTS `t_task`;
CREATE TABLE `t_task` (
`task_id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '任务编号',
`name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '任务名称',
`create_time` varchar(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '创建时间',
`update_time` varchar(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '更新时间',
`cron` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '表达式',
`state` tinyint(1) NOT NULL COMMENT '任务状态,1:开启,0:未开启',
`brief` text CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL COMMENT '任务描述',
`clazz_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '文件名',
`business_type` int(4) NULL DEFAULT NULL COMMENT '业务类型 1: 每周答题',
`extra` text CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL COMMENT '附加数据',
PRIMARY KEY (`task_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin COMMENT = '任务表' ROW_FORMAT = Dynamic;
-- ----------------------------
-- Records of t_task
-- ----------------------------
INSERT INTO `t_task` VALUES ('2021061214255624300000010', '任务 -- 1', '2021-11-26 18:10:00', '2021-11-29 15:46:04', '0/2 * * * * ?', 1, '每天轮训资格证有效期1', 'com.example.demo.schedule.children.task.RotationQualificationCreator', 1, '');
INSERT INTO `t_task` VALUES ('2021061214255624300000020', '任务 -- 2', '2021-11-26 18:10:00', '2021-11-29 15:46:04', '0/2 * * * * ?', 1, '每天轮训资格证有效期2', 'com.example.demo.schedule.children.task.RotationQualificationCreatorCount', 2, '');
SET FOREIGN_KEY_CHECKS = 1;
执行打印日志
demo地址:
链接:https://pan.baidu.com/s/1W6tYi5uzz35dX9iWLR9n7Q
提取码:1234