From d03b8cdd891531f7c46589e0a24e67a4aa60d7ec Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 07:04:11 +0000 Subject: [PATCH 01/14] =?UTF-8?q?=E8=BF=BD=E5=8A=A0=E5=BC=80=E5=90=AF?= =?UTF-8?q?=E6=B3=A8=E8=A7=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../container/components/redis/ApplicationConfiguration.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/redis-component/src/main/java/com/gcc/container/components/redis/ApplicationConfiguration.java b/redis-component/src/main/java/com/gcc/container/components/redis/ApplicationConfiguration.java index c181c76..98c4ba0 100644 --- a/redis-component/src/main/java/com/gcc/container/components/redis/ApplicationConfiguration.java +++ b/redis-component/src/main/java/com/gcc/container/components/redis/ApplicationConfiguration.java @@ -2,8 +2,9 @@ package com.gcc.container.components.redis; import org.springframework.context.annotation.ComponentScan; import org.springframework.context.annotation.Configuration; - +import org.springframework.cache.annotation.EnableCaching; @Configuration +@EnableCaching @ComponentScan(basePackages = "com.gcc.container.components.redis.*") public class ApplicationConfiguration { } -- Gitee From daab27ae526ab4ac58b25b70915aa97fcc227be5 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:54:07 +0000 Subject: [PATCH 02/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/README.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- task-component/README.md | 333 --------------------------------------- 1 file changed, 333 deletions(-) delete mode 100644 task-component/README.md diff --git a/task-component/README.md b/task-component/README.md deleted file mode 100644 index eb4143d..0000000 --- a/task-component/README.md +++ /dev/null @@ -1,333 +0,0 @@ -# task-component - -> 相比于SpringBoot本身自带的定时任务注解的死板（程序一旦运行，无法更改定时任务执行周期、相关配置等问题）和xxl-Job的笨重，该组件从代码级提供了轻量级的定时任务管理解决方案 -> -> 引入该组件，只需要实现定时任务基类，即可完成自动注册定时任务，通过定时任务接口来动态控制任务的状态，使用接口配合页面，可扩展到页面功能，做到随时启停、修改定时任务 - -## 组件依赖说明 - -组件整体继承自Components包，所依赖Spring相关组件及通用的公共组件依赖跟随Components版本进行调整管控，相关内容可查看Components的README文档 - -```xml - - com.gcc.container - components - 1.0.0 - -``` - -除基本的SpringAOP、autoconfigure外无其他依赖 - -## 使用说明 - -找到对应版本的Components源码，下载到本地，本地编译安装到私仓中，在你的项目中引入： - -```xml - - - com.gcc.container.components - task-component - 1.0.0 - -``` - -### yaml配置 - -因该组件是基于包扫描去识别定时任务类和默认以JSON文件的形式去存储项目的定时任务信息，需要通过yaml配置文件来指定包路径和文件的存放路径，引入组件后，可在自己的yml文件中追加： - -```yml -gcc-task: - #指定定时任务存放的包路径，默认不填写则扫描全项目 - task-class-package : * - #定时任务管理的数据存放文件及其路径,默认不填写则存放项目运行目录下，如自行扩展实现，则该配置自动失效 - data-file-path: /opt/myproject/task_info.json -``` - -此处的两个配置项都包含默认值，所以不进行yml的`gcc-task`仍旧可以使用该组件 - -### 新建定时任务 - -引入依赖后,需要新增一个定时任务逻辑，则需要实现基类`AbstractBaseCronTask` ，并加入注解 `@TaskJob` - -**TaskJob的参数如下**： - -| 参数 | 说明 | 样例 | -| ------ | --------------------------------------------- | -------------- | -| cron | 定时任务默认的执行周期，仅在首次初始化该任务使用（**必填**） | 10 0/2 * * * ? | -| desc | 任务描述，非必填 | 这是测试任务 | -| bootup | 是否开机自启动，**缺省值为 false** | false | - -*`cron` 属性仅在第一次新增该任务时提供一个默认的执行周期，必须填写，后续任务加载后，定时任务相关数据会被存放在文件或数据库中，此时则以文件或数据库中该任务的cron为主* - -完整一个定时任务demo如下： - -```java -@TaskJob(cron = "10 0/2 * * * ?" ,desc = "这是一个测试任务",bootup = true) -public class TaskMysqlOne extends AbstractBaseCronTask { - - public TaskMysqlOne(TaskEntity taskEntity) { - super(taskEntity); - } - - @Override - public void beforeJob() { - } - - @Override - public void startJob() { - } - - @Override - public void afterJob() { - } -} -``` - -继承`AbstractBaseCronTask` 必须要实现携带TaskEntity参数的`构造函数`、`beforeJob()`、`startJob()` 、`afterJob()` 三个方法即可。**原则上这三个方法是规范定时任务的执行，实际使用，只需要把核心逻辑放在三个方法中任何一个即可**。 - - - -因定时任务类是非SpringBean管理的类，所以**在自定义的定时任务类内无法使用任何Spring相关的注解（如@Autowired）**，**但是却可以通过自带的**`getServer(Class className)`**方法来获取任何Spring上下文中的Bean** - -例如，你有一个UserService的接口及其Impl的实现类 - -```java -@TaskJob(cron = "10 0/2 * * * ?" ,desc = "这是一个测试任务",bootup = true) -public class TaskMysqlOne extends AbstractBaseCronTask { - - public TaskMysqlOne(TaskEntity taskEntity) { - super(taskEntity); - } - - @Override - public void beforeJob() { - } - - @Override - public void startJob() { - List names = getServer(UserService.class).searchAllUserName(); - //后续逻辑…… - //其他逻辑 - } - - @Override - public void afterJob() { - - } -} -``` - -### 服务接口说明 - -定时任务相关的管理操作均封装在`TaskScheduleManagerService`接口中，可直接在外部项目中注入使用即可： - -```java -@RestController -@RequestMapping("/myself/manage") -public class TaskSchedulingController { - - @Autowired - TaskScheduleManagerService taskScheduleManagerService; - - @GetMapping("/detail") - @Operation(summary = "具体任务对象") - public Response searchDetail(String taskId){ - return Response.success(taskScheduleManagerService.searchTaskDetail(taskId)); - } - - @GetMapping("/shutdown") - @Operation(summary = "关闭指定任务") - public Response shutdownTask(String taskId){ - return Response.success(taskScheduleManagerService.shutdownTask(taskId)); - } - - @GetMapping("/open") - @Operation(summary = "开启指定任务") - public Response openTask(String taskId){ - return Response.success(taskScheduleManagerService.openTask(taskId)); - } - -``` - -`TaskScheduleManagerService`的接口定义如下： - -```java -public interface TaskScheduleManagerService { - /** - * 查询在用任务 - * @return - */ - List searchTask(SearchTaskDto dto); - /** - * 查询任务详情 - * @param taskId 任务id - * @return TaskEntity - */ - TaskVo searchTaskDetail(String taskId); - /** - * 运行指定任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo runTask(String taskId); - /** - * 关停任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo shutdownTask(String taskId); - /** - * 开启任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo openTask(String taskId); - /** - * 更新任务信息 - * @param entity 实体 - * @return TaskRunRetDto - */ - TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity); -} -``` - -## 扩展说明 - -定时任务类首次新增被扫描后，会以TaskEntity的形式存在于内存中，TaskEntity如下： - -```java -@Data -public class TaskEntity implements Serializable { - - private String taskId; - - private String taskName; - - private String taskDesc; - - private String taskCron; - - private String taskClass; - - /** - * 任务相关配置 - */ - private String taskOutConfig; - - /** - * 任务注册时间 - */ - private String taskCreateTime; - - /** - * 是否启用 - */ - private Integer taskIsUse; - - /** - * 是否开启自启动 - */ - private Integer taskBootUp; - - /** - * 上次运行状态 - */ - private Integer taskLastRun; - - /** - * 任务是否在内存中 - */ - private Integer taskRamStatus; -``` - -task-component会将内存中的TaskEntity进行持久化，下次再启动项目时，则直接使用持久化的TaskEntity来加载定时任务，task-component默认是以JSON文件进行持久化，实际使用中为了能带来更好的体验，建议扩展为数据库存储，扩展方式如下： - -1、新建数据库表（以Mysql为例） - -```SQL -DROP TABLE IF EXISTS `tb_task_info`; -CREATE TABLE `tb_task_info` ( - `task_id` varchar(100) NOT NULL PRIMARY KEY , - `task_name` varchar(255) DEFAULT NULL, - `task_desc` text, - `task_cron` varchar(20) DEFAULT NULL, - `task_class` varchar(100) DEFAULT NULL COMMENT '定时任务类路径', - `task_is_use` tinyint DEFAULT NULL COMMENT '是否启用该任务，1：启用，0禁用', - `task_boot_up` tinyint DEFAULT NULL COMMENT '是否为开机即运行，1:初始化即运行，0，初始化不运行', - `task_out_config` text CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci COMMENT '定时任务额外配置项,采用json结构存放', - `task_create_time` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL COMMENT '定时任务追加时间', - `task_last_run` tinyint DEFAULT NULL COMMENT '任务上次执行状态；1正常，0执行失败,null未知', - `task_ram_status` tinyint DEFAULT NULL COMMENT '任务当前状态；1内存运行中，0内存移除', - PRIMARY KEY (`task_id`) USING BTREE -) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 ROW_FORMAT=DYNAMIC; -``` - -2、项目中实现`TaskRepository`接口，并使用@Primary注解： - -```java -@Repository -@Primary -public class TaskRepositoryImpl implements TaskRepository { - - @Autowired - private TaskDataMapper taskDataMapper; - - @Override - public int save(TaskEntity entity) { - entity.setTaskCreateTime(DateUtil.now()); - return taskDataMapper.insert(entity); - } - - @Override - public int update(TaskEntity entity) { - UpdateWrapper update = new UpdateWrapper<>(); - update.eq("task_id",entity.getTaskId()); - return taskDataMapper.update(entity,update); - } - - - @Override - public int removeByTaskId(String id) { - QueryWrapper query = new QueryWrapper<>(); - query.eq("task_id",id); - return taskDataMapper.delete(query); - } - - @Override - public List queryAllTask() { - return taskDataMapper.selectList(new QueryWrapper<>()); - } - - @Override - public TaskEntity queryData(String id) { - QueryWrapper query = new QueryWrapper<>(); - query.eq("task_id",id); - return taskDataMapper.selectOne(query); - } - - @Override - public List queryData(TaskEntity entity) { - QueryWrapper query = new QueryWrapper<>(); - query.orderByAsc("task_create_time"); - if(null != entity) { - if (null != entity.getTaskIsUse()) { - query.eq("task_is_use", entity.getTaskIsUse()); - } - if (null != entity.getTaskBootUp()) { - query.eq("task_boot_up", entity.getTaskBootUp()); - } - if (!StringUtils.isEmpty(entity.getTaskDesc())) { - query.like("task_desc", entity.getTaskDesc()); - } - } - return taskDataMapper.selectList(query); - } -} - -``` - - - -只需要实现其中指定的几个持久化和查询方法即可替换component中的JSON文件持久化 - - -- Gitee From 61aa24b094d423d17663c4741b9227c01f07e377 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:54:30 +0000 Subject: [PATCH 03/14] =?UTF-8?q?=E6=9B=B4=E6=96=B0README=E6=96=87?= =?UTF-8?q?=E6=A1=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- task-component/README.md | 467 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 467 insertions(+) create mode 100644 task-component/README.md diff --git a/task-component/README.md b/task-component/README.md new file mode 100644 index 0000000..9f65f24 --- /dev/null +++ b/task-component/README.md @@ -0,0 +1,467 @@ +# task-component + +> 相比于SpringBoot本身自带的定时任务注解的死板（程序一旦运行，无法更改定时任务执行周期、相关配置等问题）和xxl-Job的笨重，该组件从代码级提供了轻量级的定时任务管理解决方案 +> +> 引入该组件，即可完成自动注册定时任务，通过定时任务接口来动态控制任务的状态，使用接口配合页面，可扩展到页面功能，做到随时启停、修改定时任务 + +## 组件依赖说明 + +组件整体继承自Components包，所依赖Spring相关组件及通用的公共组件依赖跟随Components版本进行调整管控，相关内容可查看Components的README文档 + +```xml + + com.gcc.container + components + 1.0.0 + +``` + +除基本的SpringAOP、autoconfigure外无其他依赖 + +## 使用说明 + +找到对应版本的Components源码，下载到本地，本地编译安装到私仓中，在你的项目中引入： + +```xml + + + com.gcc.container.components + task-component + 1.0.0 + +``` + +### yaml配置 + +因该组件是基于包扫描去识别定时任务类和默认以JSON文件的形式去存储项目的定时任务信息，需要通过yaml配置文件来指定包路径和文件的存放路径，引入组件后，可在自己的yml文件中追加： + +```yml +gcc-task: + #指定定时任务存放的包路径，默认不填写则扫描全项目 + task-class-package : * + #定时任务管理的数据存放文件及其路径,默认不填写则存放项目运行目录下，如自行扩展实现，则该配置自动失效 + data-file-path: /opt/myproject/task_info.json +``` + +此处的两个配置项都包含默认值，所以不进行yml的`gcc-task`仍旧可以使用该组件 + +### 新建定时任务 + +#### 类级定时任务 + +引入依赖后,需要新增一个定时任务逻辑，则需要实现基类`AbstractBaseCronTask` ，并加入注解 `@ClassJob` + +**ClassJob的参数如下**： + +| 参数 | 说明 | 样例 | +| ------ | --------------------------------------------- | -------------- | +| cron | 定时任务默认的执行周期，仅在首次初始化该任务使用（**必填**） | 10 0/2 * * * ? | +| desc | 任务描述，非必填 | 这是测试任务 | +| bootup | 是否开机自启动，**缺省值为 false** | false | + +*`cron` 属性仅在第一次新增该任务时提供一个默认的执行周期，必须填写，后续任务加载后，定时任务相关数据会被存放在文件或数据库中，此时则以文件或数据库中该任务的cron为主* + +完整一个定时任务demo如下： + +```java +@TaskJob(cron = "10 0/2 * * * ?" ,desc = "这是一个测试任务",bootup = true) +public class TaskMysqlOne extends AbstractBaseCronTask { + + public TaskMysqlOne(TaskEntity taskEntity) { + super(taskEntity); + } + + @Override + public void beforeJob() { + } + + @Override + public void startJob() { + } + + @Override + public void afterJob() { + } +} +``` + +继承`AbstractBaseCronTask` 必须要实现携带TaskEntity参数的`构造函数`、`beforeJob()`、`startJob()` 、`afterJob()` 三个方法即可。**原则上这三个方法是规范定时任务的执行，实际使用，只需要把核心逻辑放在三个方法中任何一个即可**。 + +因定时任务类是非SpringBean管理的类，所以**在自定义的定时任务类内无法使用任何Spring相关的注解（如@Autowired）**，**但是却可以通过自带的**`getServer(Class className)`**方法来获取任何Spring上下文中的Bean** + +例如，你有一个UserService的接口及其Impl的实现类 + +```java +@TaskJob(cron = "10 0/2 * * * ?" ,desc = "这是一个测试任务",bootup = true) +public class TaskMysqlOne extends AbstractBaseCronTask { + + public TaskMysqlOne(TaskEntity taskEntity) { + super(taskEntity); + } + + @Override + public void beforeJob() { + } + + @Override + public void startJob() { + List names = getServer(UserService.class).searchAllUserName(); + //后续逻辑…… + //其他逻辑 + } + + @Override + public void afterJob() { + + } +} +``` + +#### 方法级别定时任务 + +如果不想使用繁琐的类任务，想像xxl-job一样通过注解指定某个方法为定时执行，则可以使用方法级别的定时任务定义，具体使用方式为`@MethodJob`注解对Bean上的方法进行标注，则可以进行定时任务注册： + +**MethodJob的参数如下**： + +| 参数 | 说明 | 样例 | +| ------ | -------------------------------- | -------------- | +| cron | 定时任务默认的执行周期，仅在首次初始化该任务使用（**必填**） | 10 0/2 * * * ? | +| desc | 任务描述，非必填 | 这是测试任务 | +| bootup | 是否开机自启动，**缺省值为 false** | false | + +*`cron` 属性仅在第一次新增该任务时提供一个默认的执行周期，必须填写，后续任务加载后，定时任务相关数据会被存放在文件或数据库中，此时则以文件或数据库中该任务的cron为主 + +```java +//正常定义的Service接口 +public interface AsyncTestService { + void taskJob(); + +} + +//Service接口实现类 +@Service +public class AsyncTestServiceImpl implements AsyncTestService { + + @MethodJob(cron = "11 0/1 * * * ?",desc = "这是个方法级任务") + @Override + public void taskJob() { + log.info("方法级别任务查询关键字为企业的数据"); + QueryWrapper query = new QueryWrapper<>(); + query.like("art_name","企业"); + List data = articleMapper.selectList(query); + log.info("查出条数为{}",data.size()); + } +} +``` + +**该注解仅支持SpringBoot中标注为`@Component`、`@Service`、`@Repository`的Bean** + + + +运行效果： + +```shell +[main] com.web.test.Application : Started Application in 3.567 seconds (JVM running for 4.561) +[main] .g.c.c.t.c.InitTaskSchedulingApplication : 【定时任务初始化】 容器初始化 +[main] o.s.s.c.ThreadPoolTaskScheduler : Initializing ExecutorService +[main] .g.c.c.t.c.InitTaskSchedulingApplication : 【定时任务初始化】定时任务初始化任务开始 +[main] c.g.c.c.task.compont.TaskScheduleImpl : 【定时任务初始化】装填任务:TaskTwoPerson [ 任务执行周期：15 0/2 * * * ? ] [ bootup：0] +[main] c.g.c.c.task.compont.TaskScheduleImpl : 【定时任务初始化】装填任务:TaskMysqlOne [ 任务执行周期：10 0/2 * * * ? ] [ bootup：1] +[main] c.g.c.c.task.compont.TaskScheduleImpl : 【定时任务初始化】装填任务:taskJob [ 任务执行周期：11 0/1 * * * ? ] [ bootup：0] +[main] .g.c.c.t.c.InitTaskSchedulingApplication : 【定时任务初始化】定时任务初始化任务完成 +[main] c.g.c.c.task.service.AfterAppStarted : 【定时任务自运行】运行开机自启动任务 +[main] TaskMysqlOne : ---------------------任务 TaskMysqlOne 开始执行----------------------- +[main] TaskMysqlOne : 任务描述：这是一个测试任务 +[main] TaskMysqlOne : 我是张三 +[main] TaskMysqlOne : 任务耗时：约 0.0 s +[main] TaskMysqlOne : ---------------------任务 TaskMysqlOne 结束执行----------------------- + +[task-thread-1] taskJob : ---------------------任务 taskJob 开始执行----------------------- +[task-thread-1] taskJob : 任务描述：这是个方法级任务 +[task-thread-1] c.w.t.service.impl.AsyncTestServiceImpl : 方法级别任务查询关键字为企业的数据 +[task-thread-1] c.w.t.service.impl.AsyncTestServiceImpl : 查出条数为1 +[task-thread-1] taskJob : 任务耗时：约 8.45 s +[task-thread-1] taskJob : ---------------------任务 taskJob 结束执行----------------------- + + +``` + +### 服务接口说明 + +定时任务相关的管理操作均封装在`TaskScheduleManagerService`接口中，可直接在外部项目中注入使用即可： + +```java +@RestController +@RequestMapping("/myself/manage") +public class TaskSchedulingController { + + @Autowired + TaskScheduleManagerService taskScheduleManagerService; + + @GetMapping("/detail") + @Operation(summary = "具体任务对象") + public Response searchDetail(String taskId){ + return Response.success(taskScheduleManagerService.searchTaskDetail(taskId)); + } + + @GetMapping("/shutdown") + @Operation(summary = "关闭指定任务") + public Response shutdownTask(String taskId){ + return Response.success(taskScheduleManagerService.shutdownTask(taskId)); + } + + @GetMapping("/open") + @Operation(summary = "开启指定任务") + public Response openTask(String taskId){ + return Response.success(taskScheduleManagerService.openTask(taskId)); + } +``` + +`TaskScheduleManagerService`的接口定义如下： + +```java +public interface TaskScheduleManagerService { + /** + * 查询在用任务 + * @return + */ + List searchTask(SearchTaskDto dto); + /** + * 查询任务详情 + * @param taskId 任务id + * @return TaskEntity + */ + TaskVo searchTaskDetail(String taskId); + /** + * 运行指定任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo runTask(String taskId); + /** + * 关停任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo shutdownTask(String taskId); + /** + * 开启任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo openTask(String taskId); + /** + * 更新任务信息 + * @param entity 实体 + * @return TaskRunRetDto + */ + TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity); +} +``` + +## 扩展说明 + +定时任务类首次新增被扫描后，会以TaskEntity的形式存在于内存中，TaskEntity如下： + +```java +@Data +public class TaskEntity implements Serializable { + + /** + * 任务ID（唯一） + */ + private String taskId; + + /** + * 任务名称 + */ + private String taskName; + + /** + * 任务描述 + */ + private String taskDesc; + + /** + * 遵循cron 表达式 + */ + private String taskCron; + + /** + * 类路径 + */ + private String taskClass; + + /** + * 任务级别 CLASS_LEVEL 类级别，METHOD_LEVEL 方法级别 + */ + private TaskLevel taskLevel; + + /** + * 任务注册时间 + */ + private String taskCreateTime; + /** + * 是否启用，1启用，0不启用 + */ + private Integer taskIsUse; + + /** + * 是否系统启动后立刻运行 1是。0否 + */ + private Integer taskBootUp; + + /** + * 上次运行状态 1：成功，0：失败 + */ + private Integer taskLastRun; + /** + * 任务是否在内存中 1:是，0：否 + */ + private Integer taskRamStatus; + + /** + * 外部配置 （扩展待使用字段） + */ + private String taskOutConfig; + + /** + * 加载配置 + */ + private String loadConfigure; +``` + +task-component会将内存中的TaskEntity进行持久化，下次再启动项目时，则直接使用持久化的TaskEntity来加载定时任务，task-component默认是以JSON文件进行持久化，实际使用中为了能带来更好的体验，建议扩展为数据库存储，扩展方式如下： + +1、基于**TaskEntity类** 新建数据库表（以Mysql为例） + +```SQL +DROP TABLE IF EXISTS `tb_task_info`; +CREATE TABLE `tb_task_info` ( + `task_id` varchar(100) NOT NULL PRIMARY KEY , + `task_name` varchar(255) DEFAULT NULL, + `task_desc` text, + `task_cron` varchar(20) DEFAULT NULL, + `task_class` varchar(100) DEFAULT NULL COMMENT '定时任务类路径', + `task_level` varchar(50) DEFAULT NULL COMMENT '任务级别：类级别（CLASS_LEVEL）、方法级别（METHOD_LEVEL）', + `task_is_use` tinyint DEFAULT NULL COMMENT '是否启用该任务，1：启用，0禁用', + `task_boot_up` tinyint DEFAULT NULL COMMENT '是否为开机即运行，1:初始化即运行，0，初始化不运行', + `task_out_config` text CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci COMMENT '定时任务额外配置项,采用json结构存放', + `task_create_time` varchar(255) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL COMMENT '定时任务追加时间', + `task_last_run` tinyint DEFAULT NULL COMMENT '任务上次执行状态；1正常，0执行失败,null未知', + `task_ram_status` tinyint DEFAULT NULL COMMENT '任务当前状态；1内存运行中，0内存移除', + `loadConfigure` text  COMMENT '加载相关配置', +PRIMARY KEY (`task_id`) USING BTREE +) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3 ROW_FORMAT=DYNAMIC; +``` + +2、项目中实现`TaskRepository`接口，并使用@Primary注解： + +TaskRepository接口如下： + +```java +public interface TaskRepository { + /** + * 新增数据，必须保证entity每个字段都插入 + * @param entity + * @return int + */ + int save(TaskEntity entity); + /** + * 根据TaskId删除整条数据 + * @param id id + * @return int + */ + int removeByTaskId(String id); + /** + * 更新整个任务（除taskId外，其他字段数据均根据实体更新） + * @param entity 实体 + * @return int + */ + int update(TaskEntity entity); + /** + * 查询全部任务 + * @return List + */ + List queryAllTask(); + + /** + * 查询数据：根据实体中的字段进行查询 + * @param entity 查询 + * @return TaskEntity + */ + List queryData(TaskEntity entity); + + /** + * 查询具体的任务实体 + * @param taskId 任务id + * @return TaskEntity + */ + TaskEntity queryData(String taskId); +} +``` + + + + + +3.基于Mybatis-Plus的实现Demo + +```java +@Mapper +public interface TaskDataMapper extends BaseMapper { +} + +@Repository +@Primary +public class TaskRepositoryImpl implements TaskRepository { + @Autowired + private TaskDataMapper taskDataMapper; + @Override + public int save(TaskEntity entity) { + entity.setTaskCreateTime(DateUtil.now()); + return taskDataMapper.insert(entity); + } + @Override + public int update(TaskEntity entity) { + UpdateWrapper update = new UpdateWrapper<>(); + update.eq("task_id",entity.getTaskId()); + return taskDataMapper.update(entity,update); + } + @Override + public int removeByTaskId(String id) { + QueryWrapper query = new QueryWrapper<>(); + query.eq("task_id",id); + return taskDataMapper.delete(query); + } + @Override + public List queryAllTask() { + return taskDataMapper.selectList(new QueryWrapper<>()); + } + @Override + public TaskEntity queryData(String id) { + QueryWrapper query = new QueryWrapper<>(); + query.eq("task_id",id); + return taskDataMapper.selectOne(query); + } + @Override + public List queryData(TaskEntity entity) { + QueryWrapper query = new QueryWrapper<>(); + query.orderByAsc("task_create_time"); + if(null != entity) { + if (null != entity.getTaskIsUse()) { + query.eq("task_is_use", entity.getTaskIsUse()); + } + if (null != entity.getTaskBootUp()) { + query.eq("task_boot_up", entity.getTaskBootUp()); + } + if (!StringUtils.isEmpty(entity.getTaskDesc())) { + query.like("task_desc", entity.getTaskDesc()); + } + } + return taskDataMapper.selectList(query); + } +} +``` + +只需要实现其中指定的几个持久化和查询方法即可替换component中的JSON文件持久化 -- Gitee From 6597d93a66c73d34e0f19b1aff1e2e7088352c23 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:54:52 +0000 Subject: [PATCH 04/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/an?= =?UTF-8?q?notation?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../components/task/annotation/TaskJob.java | 19 ------------------- 1 file changed, 19 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/annotation/TaskJob.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/annotation/TaskJob.java b/task-component/src/main/java/com/gcc/container/components/task/annotation/TaskJob.java deleted file mode 100644 index 39a90f8..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/annotation/TaskJob.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.gcc.container.components.task.annotation; - - -import java.lang.annotation.ElementType; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; -import java.lang.annotation.Target; - -@Target(ElementType.TYPE) -@Retention(RetentionPolicy.RUNTIME) -public @interface TaskJob { - - String desc() default "暂无描述"; - - String cron() default "00 00 00 * * ?"; - - boolean bootup() default false; - -} \ No newline at end of file -- Gitee From ac6f3e2091eb4936af488f2db7ebc53ccd444565 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:55:23 +0000 Subject: [PATCH 05/14] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=96=B9=E6=B3=95?= =?UTF-8?q?=E7=BA=A7=E5=88=AB=E6=B3=A8=E8=A7=A3?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../components/task/annotation/ClassJob.java | 19 +++++++++++++++++ .../components/task/annotation/MethodJob.java | 21 +++++++++++++++++++ 2 files changed, 40 insertions(+) create mode 100644 task-component/src/main/java/com/gcc/container/components/task/annotation/ClassJob.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/annotation/MethodJob.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/annotation/ClassJob.java b/task-component/src/main/java/com/gcc/container/components/task/annotation/ClassJob.java new file mode 100644 index 0000000..cabefce --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/annotation/ClassJob.java @@ -0,0 +1,19 @@ +package com.gcc.container.components.task.annotation; + + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface ClassJob { + + String desc() default "暂无描述"; + + String cron() default "00 00 00 * * ?"; + + boolean bootup() default false; + +} \ No newline at end of file diff --git a/task-component/src/main/java/com/gcc/container/components/task/annotation/MethodJob.java b/task-component/src/main/java/com/gcc/container/components/task/annotation/MethodJob.java new file mode 100644 index 0000000..b04e463 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/annotation/MethodJob.java @@ -0,0 +1,21 @@ +package com.gcc.container.components.task.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +/** + * 定时任务方法 + */ +@Target(ElementType.METHOD) +@Retention(RetentionPolicy.RUNTIME) +public @interface MethodJob { + + String desc() default "暂无描述"; + + String cron() default "00 00 00 * * ?"; + + boolean bootup() default false; + +} -- Gitee From 5b299247e2ba42cf6850eb77beeb76dfa3c95d30 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:55:37 +0000 Subject: [PATCH 06/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/co?= =?UTF-8?q?mpont?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../task/compont/AbstractBaseCronTask.java | 111 ------------ .../InitTaskSchedulingApplication.java | 48 ------ .../components/task/compont/TaskSchedule.java | 62 ------- .../task/compont/TaskScheduleImpl.java | 160 ------------------ .../task/compont/TaskTempFactory.java | 99 ----------- 5 files changed, 480 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskTempFactory.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java b/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java deleted file mode 100644 index 7264f39..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java +++ /dev/null @@ -1,111 +0,0 @@ -package com.gcc.container.components.task.compont; - - -import cn.hutool.core.util.NumberUtil; -import cn.hutool.json.JSONObject; -import cn.hutool.json.JSONUtil; -import com.gcc.container.components.task.dao.TaskRepository; -import com.gcc.container.components.task.model.entity.TaskEntity; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.context.ApplicationContext; - -/** - * 抽象定时任务类 - * 实现定时任务需要继承该类 - * 子类实现时，不要使用Spring的任何注解 - * 若依赖外部的对象，使用 getServer()方法进行手动注入 - * @author GCC - */ -public abstract class AbstractBaseCronTask implements Runnable{ - - public Logger log; - - - private TaskEntity taskEntity; - - - private Double consumptionTime; - - private ApplicationContext applicationContext; - - - public AbstractBaseCronTask(TaskEntity taskEntity){ - log = LoggerFactory.getLogger(taskEntity.getTaskName()); - this.taskEntity = taskEntity; - } - - - //前置操作 - public abstract void beforeJob(); - - - //任务操作 - public abstract void startJob(); - - - //后置操作 - public abstract void afterJob(); - - - @Override - public void run() { - String id = this.taskEntity.getTaskId(); - this.taskEntity = getServer(TaskRepository.class).queryData(id); - log.info("---------------------任务 {} 开始执行-----------------------",taskEntity.getTaskName()); - log.info("任务描述："+taskEntity.getTaskDesc()); - consumptionTime = 0d; - try { - Long start = System.currentTimeMillis(); - beforeJob(); - startJob(); - afterJob(); - Long end = System.currentTimeMillis(); - consumptionTime = NumberUtil.div((end - start),1000); - log.info("任务耗时：约 {} s",consumptionTime); - taskEntity.setTaskLastRun(1); - }catch (Exception e){ - log.error("任务{}计算出错！请及时排查问题！", taskEntity.getTaskName(),e); - taskEntity.setTaskLastRun(0); - } - getServer(TaskRepository.class).update(taskEntity); - log.info("---------------------任务 {} 结束执行-----------------------\n",taskEntity.getTaskName()); - } - - - public Object getSelfConfig(String key){ - try{ - TaskEntity entity = getServer(TaskRepository.class).queryData(taskEntity.getTaskId()); - JSONObject config = JSONUtil.parseObj(entity.getTaskOutConfig()); - return config.get(key); - }catch (Exception e){ - log.error("获取任务 {} 的配置参数失败，请确认参数配置格式是否正确！",taskEntity.getTaskName()); - } - return new JSONObject(); - } - - - public double getRunTime(){ return this.consumptionTime;} - - public TaskEntity getThisTaskInfo(){ - return this.taskEntity; - } - - public void setApplicationContext(ApplicationContext applicationContext) { - this.applicationContext = applicationContext; - } - - - /** - * 为适配反射生成的对象不受Spring容器管辖导致对象不共用问题 - * 提供手动获取系统上下文容器完成依赖注入 - * 通过类名使用Spring容器中的对象 - * @param className 类 - * @param 返回类型 - * @return T - */ - public T getServer(Class className){ - return applicationContext.getBean(className); - } - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java b/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java deleted file mode 100644 index 6085c3a..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java +++ /dev/null @@ -1,48 +0,0 @@ -package com.gcc.container.components.task.compont; - - -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.ApplicationArguments; -import org.springframework.boot.ApplicationRunner; -import org.springframework.core.annotation.Order; -import org.springframework.stereotype.Component; - -/** - * 初始化任务调度机制 - * @author GCC - */ -@Order(1) -@Slf4j -@Component -public class InitTaskSchedulingApplication implements ApplicationRunner { - - private TaskSchedule taskSchedule; - - - private TaskTempFactory taskTempFactory; - - - @Autowired - public void setTaskScheduleServer(TaskSchedule taskSchedule) { - this.taskSchedule = taskSchedule; - } - - @Autowired - public void setTaskTempFactory(TaskTempFactory taskTempFactory) { - this.taskTempFactory = taskTempFactory; - } - - @Override - public void run(ApplicationArguments args) throws Exception { - //开启扫描 - taskTempFactory.scanTaskInfo(); - log.info("【定时任务初始化】 容器初始化"); - taskSchedule.initScheduling(); - log.info("【定时任务初始化】定时任务初始化任务开始"); - taskSchedule.loadAllTask(); - log.info("【定时任务初始化】定时任务初始化任务完成"); - - } - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java deleted file mode 100644 index c2d2949..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java +++ /dev/null @@ -1,62 +0,0 @@ -package com.gcc.container.components.task.compont; - - - - -import com.gcc.container.components.task.model.entity.TaskEntity; - -import java.util.concurrent.ConcurrentHashMap; - -public interface TaskSchedule { - - - - ConcurrentHashMap getTaskSchedulingRam(); - - - /** - * 初始化任务调度 - */ - void initScheduling(); - - /** - * 添加任务至内存及容器 - * @param taskEntity 任务实体 - * @return boolean - */ - boolean addTaskToScheduling(TaskEntity taskEntity); - - /** - * 从任务调度器中移除任务 - * @param id 任务id - * @return Boolean - */ - boolean removeTaskFromScheduling(String id); - - - /** - * 执行指定任务 - * @param id 任务id - * @return double 耗时 - */ - double runTaskById(String id); - - - /** - * 清空任务 - */ - void claearAllTask(); - - - - /** - * 加载所有任务 - */ - void loadAllTask(); - - /** - * 运行开机自启任务 - */ - void runBootUpTask(); - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java deleted file mode 100644 index d9f58a7..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java +++ /dev/null @@ -1,160 +0,0 @@ -package com.gcc.container.components.task.compont; - - -import cn.hutool.core.util.NumberUtil; -import com.gcc.container.components.task.dao.TaskRepository; -import com.gcc.container.components.task.model.entity.TaskEntity; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.context.ApplicationContext; -import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; -import org.springframework.scheduling.support.CronTrigger; -import org.springframework.stereotype.Component; - -import java.lang.reflect.Constructor; -import java.util.List; -import java.util.Objects; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ScheduledFuture; - -@Slf4j -@Component -public class TaskScheduleImpl implements TaskSchedule { - - //正在运行的任务 - private static ConcurrentHashMap runningTasks = new ConcurrentHashMap<>(); - - //线程池任务调度 - private ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler(); - - //内存中任务对象 - private static ConcurrentHashMap ramTasks = new ConcurrentHashMap<>(); - - //Spring容器池,用于注入Spring的bean - private ApplicationContext context; - - - private TaskRepository taskRepository; - - - private TaskTempFactory taskFactory; - - - @Autowired - public void setTaskRepository(TaskRepository taskRepository) { - this.taskRepository = taskRepository; - } - - @Autowired - public void setContext(ApplicationContext context) { - this.context = context; - } - - @Autowired - public void setTaskFactory(TaskTempFactory taskFactory) { - this.taskFactory = taskFactory; - } - - @Autowired - - - @Override - public ConcurrentHashMap getTaskSchedulingRam() { - return ramTasks; - } - - @Override - public void initScheduling() { - int num = taskFactory.mergeTaskEntities().size(); - num = num > 0 ? num:1; - this.threadPoolTaskScheduler.setPoolSize(num); - this.threadPoolTaskScheduler.setThreadNamePrefix("task-thread-"); - this.threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true); - this.threadPoolTaskScheduler.initialize(); - } - - - @Override - public boolean addTaskToScheduling(TaskEntity task) { - if(!runningTasks.containsKey(task.getTaskId())){ - try{ - Class clazz = Class.forName(task.getTaskClass()); - Constructor c = clazz.getConstructor(TaskEntity.class); - AbstractBaseCronTask runnable = (AbstractBaseCronTask) c.newInstance(task); - //反射方式生成对象不属于Spring容器管控，对于Spring的bean使用需要手动注入 - runnable.setApplicationContext(context); - CronTrigger cron = new CronTrigger(task.getTaskCron()); - //put到runTasks - runningTasks.put(task.getTaskId(), Objects.requireNonNull(this.threadPoolTaskScheduler.schedule(runnable, cron))); - //存入内存中，便于外部调用 - ramTasks.put(task.getTaskId(),runnable); - task.setTaskRamStatus(1); - taskRepository.update(task); - return true; - }catch (Exception e){ - log.error("定时任务加载失败..."+e); - } - } - return false; - } - - - @Override - public boolean removeTaskFromScheduling(String id) { - if(runningTasks.containsKey(id)){ - runningTasks.get(id).cancel(true); - runningTasks.remove(id); - ramTasks.remove(id); - TaskEntity entity = taskRepository.queryData(id); - entity.setTaskRamStatus(0); - entity.setTaskLastRun(null); - if( 1 == taskRepository.update(entity) && !runningTasks.containsKey(id)){ - log.info("【定时任务控制器】任务"+id+"从内存进程池中移除，被终止！"); - return true; - } - } - return false; - } - - @Override - public double runTaskById(String id) { - TaskEntity task = taskRepository.queryData(id); - if(null!=task) { - if (runningTasks.containsKey(task.getTaskId())){ - ramTasks.get(task.getTaskId()).run(); - return ramTasks.get(task.getTaskId()).getRunTime(); - } - } - return 0d; - } - - @Override - public void claearAllTask() { - ramTasks.clear(); - log.info("【定时任务控制器】清除内存任务 完成"); - runningTasks.clear(); - log.info("【定时任务控制器】清除线程任务 完成"); - threadPoolTaskScheduler.shutdown(); - } - - @Override - public void loadAllTask() { - List allTask = taskFactory.mergeTaskEntities(); - for (TaskEntity task : allTask) { - if(addTaskToScheduling(task)){ - log.info("【定时任务初始化】装填任务:{} [ 任务执行周期：{} ] [ bootup：{}]",task.getTaskName(),task.getTaskCron(),task.getTaskBootUp()); - } - } - } - - - @Override - public void runBootUpTask() { - List list = taskRepository.queryAllTask(); - for(TaskEntity task:list){ - if(1 == task.getTaskIsUse() && 1 == task.getTaskBootUp()) { - runTaskById(task.getTaskId()); - } - } - } -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskTempFactory.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskTempFactory.java deleted file mode 100644 index 1f0eca5..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskTempFactory.java +++ /dev/null @@ -1,99 +0,0 @@ -package com.gcc.container.components.task.compont; - - -import cn.hutool.core.date.DateUtil; -import cn.hutool.crypto.digest.DigestUtil; - -import com.gcc.container.components.task.annotation.TaskJob; -import com.gcc.container.components.task.dao.TaskRepository; -import com.gcc.container.components.task.model.entity.TaskEntity; -import com.gcc.container.components.task.property.TaskDataProperties; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.config.BeanDefinition; -import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; -import org.springframework.core.type.filter.AnnotationTypeFilter; -import org.springframework.stereotype.Component; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.stream.Collectors; - -@Component -class TaskTempFactory { - - @Autowired - private TaskRepository taskRepository; - - @Autowired - TaskDataProperties taskDataProperties; - - private List tempContainer = new ArrayList<>(); - - - public void scanTaskInfo() throws Exception { - ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); - provider.addIncludeFilter(new AnnotationTypeFilter(TaskJob.class)); - Set beanDefinitions = provider.findCandidateComponents(taskDataProperties.getTaskClassPackage()); - for (BeanDefinition beanDefinition : beanDefinitions) { - Class clazz = Class.forName(beanDefinition.getBeanClassName()); - TaskJob taskJob = clazz.getAnnotation(TaskJob.class); - if (AbstractBaseCronTask.class.isAssignableFrom(clazz)) { - tempContainer.add(builderTaskEntity(clazz,taskJob)); - } else { - throw new IllegalArgumentException("Class " + clazz.getName() + " must extend AbstractBaseCronTask"); - } - } - } - - - public List mergeTaskEntities() { - List db = getIsUseTask(); - Map map = db.stream() - .collect(Collectors.toMap( - TaskEntity::getTaskClass, - task -> task - )); - for(TaskEntity entity:tempContainer){ - if(!map.containsKey(entity.getTaskClass())){ - taskRepository.save(entity); - db.add(entity); - } - } - return db; - } - - - private TaskEntity builderTaskEntity(Class cronTaskClass, TaskJob taskJob) { - String path = cronTaskClass.getName(); TaskEntity entity = new TaskEntity(); - entity.setTaskId(DigestUtil.md5Hex(path)); - entity.setTaskClass(path); - entity.setTaskIsUse(1); - entity.setTaskName(cronTaskClass.getSimpleName()); - entity.setTaskDesc(taskJob.desc()); - entity.setTaskBootUp(converBootUp(taskJob.bootup())); - entity.setTaskCron(taskJob.cron()); - entity.setTaskCreateTime(DateUtil.now()); - //todo 外部配置 - return entity; - } - - - private List getIsUseTask(){ - List list = taskRepository.queryAllTask(); - List result = new ArrayList<>(); - for(TaskEntity entity:list){ - if(entity.isUse()){ - result.add(entity); - } - } - return result; - } - - private Integer converBootUp(Boolean flag){ - if(flag){ - return 1; - } - return 0; - } -} -- Gitee From 0ea1f2272196fee61da41e09b1400a1b16ff4e95 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:56:05 +0000 Subject: [PATCH 07/14] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E6=A0=B8=E5=BF=83?= =?UTF-8?q?=E9=80=BB=E8=BE=91=EF=BC=88=E7=B1=BB=E7=BA=A7=E5=88=AB=E3=80=81?= =?UTF-8?q?=E6=96=B9=E6=B3=95=E7=BA=A7=E5=88=AB=E4=BB=BB=E5=8A=A1=E6=B3=A8?= =?UTF-8?q?=E5=86=8C=EF=BC=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../task/compont/AbstractBaseCronTask.java | 112 ++++++++++ .../task/compont/BaseMethodLevelTask.java | 52 +++++ .../InitTaskSchedulingApplication.java | 48 +++++ .../components/task/compont/TaskFactory.java | 195 ++++++++++++++++++ .../components/task/compont/TaskSchedule.java | 62 ++++++ .../task/compont/TaskScheduleImpl.java | 172 +++++++++++++++ 6 files changed, 641 insertions(+) create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/BaseMethodLevelTask.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskFactory.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java b/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java new file mode 100644 index 0000000..06f6e38 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/AbstractBaseCronTask.java @@ -0,0 +1,112 @@ +package com.gcc.container.components.task.compont; + + +import cn.hutool.core.util.NumberUtil; +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.gcc.container.components.task.dao.TaskRepository; +import com.gcc.container.components.task.model.entity.TaskEntity; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.ApplicationContext; + +/** + * 抽象定时任务类 + * 实现定时任务需要继承该类 + * 子类实现时，不要使用Spring的任何注解 + * 若依赖外部的对象，使用 getServer()方法进行手动注入 + * @author GCC + */ +public abstract class AbstractBaseCronTask implements Runnable{ + + public Logger log; + + + private TaskEntity taskEntity; + + + private Double consumptionTime; + + private ApplicationContext applicationContext; + + + public AbstractBaseCronTask(TaskEntity taskEntity){ + log = LoggerFactory.getLogger(taskEntity.getTaskName()); + this.taskEntity = taskEntity; + } + + + //前置操作 + public abstract void beforeJob(); + + + //任务操作 + public abstract void startJob(); + + + //后置操作 + public abstract void afterJob(); + + + @Override + public void run() { + String id = this.taskEntity.getTaskId(); + this.taskEntity = getServer(TaskRepository.class).queryData(id); + log.info("---------------------任务 {} 开始执行-----------------------",taskEntity.getTaskName()); + log.info("任务描述："+taskEntity.getTaskDesc()); + consumptionTime = 0d; + try { + Long start = System.currentTimeMillis(); + beforeJob(); + startJob(); + afterJob(); + Long end = System.currentTimeMillis(); + consumptionTime = NumberUtil.div((end - start),1000); + log.info("任务耗时：约 {} s",consumptionTime); + taskEntity.setTaskLastRun(1); + }catch (Exception e){ + log.error("任务{}计算出错！请及时排查问题！", taskEntity.getTaskName(),e); + e.printStackTrace(); + taskEntity.setTaskLastRun(0); + } + getServer(TaskRepository.class).update(taskEntity); + log.info("---------------------任务 {} 结束执行-----------------------\n",taskEntity.getTaskName()); + } + + + public Object getSelfConfig(String key){ + try{ + TaskEntity entity = getServer(TaskRepository.class).queryData(taskEntity.getTaskId()); + JSONObject config = JSONUtil.parseObj(entity.getTaskOutConfig()); + return config.get(key); + }catch (Exception e){ + log.error("获取任务 {} 的配置参数失败，请确认参数配置格式是否正确！",taskEntity.getTaskName()); + } + return new JSONObject(); + } + + + public double getRunTime(){ return this.consumptionTime;} + + public TaskEntity getThisTaskInfo(){ + return this.taskEntity; + } + + public void setApplicationContext(ApplicationContext applicationContext) { + this.applicationContext = applicationContext; + } + + + /** + * 为适配反射生成的对象不受Spring容器管辖导致对象不共用问题 + * 提供手动获取系统上下文容器完成依赖注入 + * 通过类名使用Spring容器中的对象 + * @param className 类 + * @param 返回类型 + * @return T + */ + public T getServer(Class className){ + return applicationContext.getBean(className); + } + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/BaseMethodLevelTask.java b/task-component/src/main/java/com/gcc/container/components/task/compont/BaseMethodLevelTask.java new file mode 100644 index 0000000..0d56a45 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/BaseMethodLevelTask.java @@ -0,0 +1,52 @@ +package com.gcc.container.components.task.compont; + +import com.gcc.container.components.task.model.entity.TaskEntity; + +import java.lang.reflect.Method; + +/** + * 方法级别定时任务基类 + * @author GCC + */ +class BaseMethodLevelTask extends AbstractBaseCronTask{ + + + private Class beanPath; + + private String methodName; + + + private Method method = null; + + + public BaseMethodLevelTask(TaskEntity taskEntity, Class className, String methodName) { + super(taskEntity); + this.beanPath = className; + this.methodName = methodName; + } + + @Override + public void beforeJob() { + try { + method = Class.forName(beanPath.getName()).getMethod(methodName); + }catch (Exception e){ + e.printStackTrace(); + } + } + + @Override + public void startJob(){ + if(null != method){ + try { + method.invoke(getServer(beanPath)); + }catch (Exception e){ + e.printStackTrace(); + } + } + } + + @Override + public void afterJob() { + + } +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java b/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java new file mode 100644 index 0000000..f9199ef --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/InitTaskSchedulingApplication.java @@ -0,0 +1,48 @@ +package com.gcc.container.components.task.compont; + + +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.ApplicationArguments; +import org.springframework.boot.ApplicationRunner; +import org.springframework.core.annotation.Order; +import org.springframework.stereotype.Component; + +/** + * 初始化任务调度机制 + * @author GCC + */ +@Order(1) +@Slf4j +@Component +public class InitTaskSchedulingApplication implements ApplicationRunner { + + private TaskSchedule taskSchedule; + + + private TaskFactory taskFactory; + + + @Autowired + public void setTaskScheduleServer(TaskSchedule taskSchedule) { + this.taskSchedule = taskSchedule; + } + + @Autowired + public void setTaskTempFactory(TaskFactory taskFactory) { + this.taskFactory = taskFactory; + } + + @Override + public void run(ApplicationArguments args) throws Exception { + //开启扫描 + taskFactory.scanTaskInfo(); + log.info("【定时任务初始化】 容器初始化"); + taskSchedule.initScheduling(); + log.info("【定时任务初始化】定时任务初始化任务开始"); + taskSchedule.loadAllTask(); + log.info("【定时任务初始化】定时任务初始化任务完成"); + + } + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskFactory.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskFactory.java new file mode 100644 index 0000000..1cabd5e --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskFactory.java @@ -0,0 +1,195 @@ +package com.gcc.container.components.task.compont; + + +import cn.hutool.core.date.DateUtil; +import cn.hutool.crypto.digest.DigestUtil; + +import cn.hutool.json.JSONObject; +import com.gcc.container.components.task.annotation.MethodJob; +import com.gcc.container.components.task.annotation.ClassJob; +import com.gcc.container.components.task.dao.TaskRepository; +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.model.enums.TaskLevel; +import com.gcc.container.components.task.property.TaskDataProperties; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.config.BeanDefinition; +import org.springframework.context.ApplicationContext; +import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; +import org.springframework.core.type.filter.AnnotationTypeFilter; +import org.springframework.stereotype.Component; +import org.springframework.stereotype.Repository; +import org.springframework.stereotype.Service; +import java.lang.reflect.Method; +import java.util.*; +import java.util.stream.Collectors; + +@Component +class TaskFactory { + + private ApplicationContext context; + + + private TaskRepository taskRepository; + + + private TaskDataProperties taskDataProperties; + + + public final String CLASS_PATH = "com.gcc.container.components.task.compont.BaseMethodLevelTask"; + + + private List tempContainer = new ArrayList<>(); + + + @Autowired + public void setContext(ApplicationContext context) { + this.context = context; + } + + @Autowired + public void setTaskRepository(TaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Autowired + public void setTaskDataProperties(TaskDataProperties taskDataProperties) { + this.taskDataProperties = taskDataProperties; + } + + + public void scanTaskInfo() throws Exception { + //扫描类级任务 + ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(false); + provider.addIncludeFilter(new AnnotationTypeFilter(ClassJob.class)); + Set beanDefinitions = provider.findCandidateComponents(taskDataProperties.getTaskClassPackage()); + for (BeanDefinition beanDefinition : beanDefinitions) { + Class clazz = Class.forName(beanDefinition.getBeanClassName()); + ClassJob classJob = clazz.getAnnotation(ClassJob.class); + if (AbstractBaseCronTask.class.isAssignableFrom(clazz)) { + tempContainer.add(buildTaskEntity(clazz, classJob)); + } else { + throw new IllegalArgumentException("Class " + clazz.getName() + " must extend AbstractBaseCronTask"); + } + } + //扫描方法级任务 + //仅支持在 Component、Service、Repository 注解上的定时任务 + Map allBeans = context.getBeansWithAnnotation(Component.class); + allBeans.putAll(context.getBeansWithAnnotation(Service.class)); + allBeans.putAll(context.getBeansWithAnnotation(Repository.class)); + for (Object bean : allBeans.values()) { + Class beanClass = bean.getClass(); + for (Method method : beanClass.getDeclaredMethods()) { + if (method.isAnnotationPresent(MethodJob.class)) { + MethodJob annotation = method.getAnnotation(MethodJob.class); + String className = beanClass.getName(); + String methodName = method.getName(); + tempContainer.add(buildMethodTaskEntity(className,methodName,annotation)); + } + } + } + } + + + public List mergeTaskEntities() { + Map> db = getIsUseTask(); + + List classLevelJob = db.get("ClassLevel"); + + List methodLevelJob =db.get("MethodLevel"); + + Map ClassLevelMap = classLevelJob.stream() + .collect(Collectors.toMap( + TaskEntity::getTaskClass, + task -> task + )); + Map methodLevelMap = methodLevelJob.stream() + .collect(Collectors.toMap( + TaskEntity::getTaskId, + task -> task + )); + + for(TaskEntity entity:tempContainer){ + //类级别任务 + if(TaskLevel.CLASS_LEVEL == entity.getTaskLevel()){ + if(!ClassLevelMap.containsKey(entity.getTaskClass())){ + taskRepository.save(entity); + classLevelJob.add(entity); + } + } + //方法级别任务 + if(TaskLevel.METHOD_LEVEL == entity.getTaskLevel()){ + if(!methodLevelMap.containsKey(entity.getTaskId())){ + taskRepository.save(entity); + methodLevelJob.add(entity); + } + } + } + //合并两处任务 + classLevelJob.addAll(methodLevelJob); + return classLevelJob; + } + + + private TaskEntity buildTaskEntity(Class cronTaskClass, ClassJob classJob) { + String path = cronTaskClass.getName(); + TaskEntity entity = new TaskEntity(); + entity.setTaskId(DigestUtil.md5Hex(path)); + entity.setTaskClass(path); + entity.setTaskIsUse(1); + entity.setTaskName(cronTaskClass.getSimpleName()); + entity.setTaskDesc(classJob.desc()); + entity.setTaskBootUp(converBootUp(classJob.bootup())); + entity.setTaskCron(classJob.cron()); + entity.setTaskCreateTime(DateUtil.now()); + entity.setTaskLevel(TaskLevel.CLASS_LEVEL); + return entity; + } + + private TaskEntity buildMethodTaskEntity(String beanClass,String method, MethodJob methodJob) { + String key = beanClass+"."+method+"()"; + TaskEntity entity = new TaskEntity(); + entity.setTaskId(DigestUtil.md5Hex(key)); + entity.setTaskClass(CLASS_PATH); + entity.setTaskIsUse(1); + entity.setTaskName(method); + entity.setTaskDesc(methodJob.desc()); + entity.setTaskBootUp(converBootUp(methodJob.bootup())); + entity.setTaskCron(methodJob.cron()); + entity.setTaskCreateTime(DateUtil.now()); + entity.setTaskLevel(TaskLevel.METHOD_LEVEL); + entity.setLoadConfigure(new JSONObject() + .set("beanClass",beanClass) + .set("methodName",method).toJSONString(0)); + return entity; + } + + + private Map> getIsUseTask(){ + Map> resultMap = new HashMap<>(); + List list = taskRepository.queryAllTask(); + List methodLevel = new ArrayList<>(); + List classLevel = new ArrayList<>(); + for(TaskEntity entity:list){ + if(entity.isUse()){ + + if(TaskLevel.CLASS_LEVEL == entity.getTaskLevel()){ + classLevel.add(entity); + } + + if(TaskLevel.METHOD_LEVEL == entity.getTaskLevel()){ + methodLevel.add(entity); + } + } + } + resultMap.put("ClassLevel",classLevel); + resultMap.put("MethodLevel",methodLevel); + return resultMap; + } + + private Integer converBootUp(Boolean flag){ + if(flag){ + return 1; + } + return 0; + } +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java new file mode 100644 index 0000000..c2d2949 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskSchedule.java @@ -0,0 +1,62 @@ +package com.gcc.container.components.task.compont; + + + + +import com.gcc.container.components.task.model.entity.TaskEntity; + +import java.util.concurrent.ConcurrentHashMap; + +public interface TaskSchedule { + + + + ConcurrentHashMap getTaskSchedulingRam(); + + + /** + * 初始化任务调度 + */ + void initScheduling(); + + /** + * 添加任务至内存及容器 + * @param taskEntity 任务实体 + * @return boolean + */ + boolean addTaskToScheduling(TaskEntity taskEntity); + + /** + * 从任务调度器中移除任务 + * @param id 任务id + * @return Boolean + */ + boolean removeTaskFromScheduling(String id); + + + /** + * 执行指定任务 + * @param id 任务id + * @return double 耗时 + */ + double runTaskById(String id); + + + /** + * 清空任务 + */ + void claearAllTask(); + + + + /** + * 加载所有任务 + */ + void loadAllTask(); + + /** + * 运行开机自启任务 + */ + void runBootUpTask(); + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java new file mode 100644 index 0000000..1272500 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/compont/TaskScheduleImpl.java @@ -0,0 +1,172 @@ +package com.gcc.container.components.task.compont; + + +import com.gcc.container.components.task.dao.TaskRepository; +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.model.enums.TaskLevel; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; +import org.springframework.scheduling.support.CronTrigger; +import org.springframework.stereotype.Component; + +import java.lang.reflect.Constructor; +import java.util.List; +import java.util.Objects; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ScheduledFuture; + +@Slf4j +@Component +public class TaskScheduleImpl implements TaskSchedule { + + //正在运行的任务 + private static ConcurrentHashMap runningTasks = new ConcurrentHashMap<>(); + + //线程池任务调度 + private ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler(); + + //内存中任务对象 + private static ConcurrentHashMap ramTasks = new ConcurrentHashMap<>(); + + //Spring容器池,用于注入Spring的bean + private ApplicationContext context; + + + private TaskRepository taskRepository; + + + private TaskFactory taskFactory; + + + @Autowired + public void setTaskRepository(TaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Autowired + public void setContext(ApplicationContext context) { + this.context = context; + } + + @Autowired + public void setTaskFactory(TaskFactory taskFactory) { + this.taskFactory = taskFactory; + } + + @Autowired + + + @Override + public ConcurrentHashMap getTaskSchedulingRam() { + return ramTasks; + } + + @Override + public void initScheduling() { + int num = taskFactory.mergeTaskEntities().size(); + num = num > 0 ? num:1; + this.threadPoolTaskScheduler.setPoolSize(num); + this.threadPoolTaskScheduler.setThreadNamePrefix("task-thread-"); + this.threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true); + this.threadPoolTaskScheduler.initialize(); + } + + + @Override + public boolean addTaskToScheduling(TaskEntity task) { + if(!runningTasks.containsKey(task.getTaskId())){ + try{ + Class clazz = Class.forName(task.getTaskClass()); + AbstractBaseCronTask runnable = null; + //类级别任务 + if(TaskLevel.CLASS_LEVEL == task.getTaskLevel()) { + Constructor c = clazz.getConstructor(TaskEntity.class); + runnable = (AbstractBaseCronTask) c.newInstance(task); + } + //方法级别任务 + if(TaskLevel.METHOD_LEVEL == task.getTaskLevel()){ + String className = task.getLoadConfiguration().getStr("beanClass"); + String methodName = task.getLoadConfiguration().getStr("methodName"); + Constructor c = clazz.getConstructor(TaskEntity.class,Class.class,String.class); + runnable = (AbstractBaseCronTask) c.newInstance(task, context.getBean(Class.forName(className)).getClass(),methodName); + } + //反射方式生成对象不属于Spring容器管控，对于Spring的bean使用需要手动注入 + runnable.setApplicationContext(context); + CronTrigger cron = new CronTrigger(task.getTaskCron()); + //put到runTasks + runningTasks.put(task.getTaskId(), Objects.requireNonNull(this.threadPoolTaskScheduler.schedule(runnable, cron))); + //存入内存中，便于外部调用 + ramTasks.put(task.getTaskId(),runnable); + task.setTaskRamStatus(1); + taskRepository.update(task); + return true; + }catch (Exception e){ + log.error("定时任务{}加载失败..."+e,task.getTaskName()); + taskRepository.removeByTaskId(task.getTaskId()); + } + } + return false; + } + + + @Override + public boolean removeTaskFromScheduling(String id) { + if(runningTasks.containsKey(id)){ + runningTasks.get(id).cancel(true); + runningTasks.remove(id); + ramTasks.remove(id); + TaskEntity entity = taskRepository.queryData(id); + entity.setTaskRamStatus(0); + entity.setTaskLastRun(null); + if( 1 == taskRepository.update(entity) && !runningTasks.containsKey(id)){ + log.info("【定时任务控制器】任务"+id+"从内存进程池中移除，被终止！"); + return true; + } + } + return false; + } + + @Override + public double runTaskById(String id) { + TaskEntity task = taskRepository.queryData(id); + if(null!=task) { + if (runningTasks.containsKey(task.getTaskId())){ + ramTasks.get(task.getTaskId()).run(); + return ramTasks.get(task.getTaskId()).getRunTime(); + } + } + return 0d; + } + + @Override + public void claearAllTask() { + ramTasks.clear(); + log.info("【定时任务控制器】清除内存任务 完成"); + runningTasks.clear(); + log.info("【定时任务控制器】清除线程任务 完成"); + threadPoolTaskScheduler.shutdown(); + } + + @Override + public void loadAllTask() { + List allTask = taskFactory.mergeTaskEntities(); + for (TaskEntity task : allTask) { + if(addTaskToScheduling(task)){ + log.info("【定时任务初始化】装填任务:{} [ 任务执行周期：{} ] [ bootup：{}]",task.getTaskName(),task.getTaskCron(),task.getTaskBootUp()); + } + } + } + + + @Override + public void runBootUpTask() { + List list = taskRepository.queryAllTask(); + for(TaskEntity task:list){ + if(1 == task.getTaskIsUse() && 1 == task.getTaskBootUp()) { + runTaskById(task.getTaskId()); + } + } + } +} -- Gitee From 6be3db79f410ce9be7bcb8ebce89a0a9935e5dfa Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:56:20 +0000 Subject: [PATCH 08/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/da?= =?UTF-8?q?o?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../components/task/dao/TaskRepository.java | 57 ------- .../dao/impl/FileOpTaskRepositoryImpl.java | 154 ------------------ 2 files changed, 211 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java b/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java deleted file mode 100644 index c05ea46..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java +++ /dev/null @@ -1,57 +0,0 @@ -package com.gcc.container.components.task.dao; -import com.gcc.container.components.task.model.entity.TaskEntity; -import java.util.List; -/** - * 任务数据操作 - */ -public interface TaskRepository { - - /** - * 新增数据 - * @param entity - * @return int - */ - int save(TaskEntity entity); - - - /** - * 删除任务ID - * @param id id - * @return int - */ - int removeByTaskId(String id); - - - /** - * 更新整个任务 - * @param entity 实体 - * @return int - */ - int update(TaskEntity entity); - - - /** - * 查询全部任务 - * @return List - */ - List queryAllTask(); - - - - /** - * 查询数据 - * @param entity 查询 - * @return TaskEntity - */ - List queryData(TaskEntity entity); - - - - - /** - * 查询具体的任务实体 - * @param taskId 任务id - * @return TaskEntity - */ - TaskEntity queryData(String taskId); -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java b/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java deleted file mode 100644 index 50fefe6..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java +++ /dev/null @@ -1,154 +0,0 @@ -package com.gcc.container.components.task.dao.impl; - -import cn.hutool.core.io.FileUtil; -import cn.hutool.core.util.StrUtil; -import cn.hutool.json.JSONArray; -import cn.hutool.json.JSONUtil; -import com.gcc.container.components.task.dao.TaskRepository; -import com.gcc.container.components.task.model.entity.TaskEntity; -import com.gcc.container.components.task.property.TaskDataProperties; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Repository; -import java.io.File; -import java.util.ArrayList; -import java.util.List; -import java.util.Map; - -@Repository -@Slf4j -public class FileOpTaskRepositoryImpl implements TaskRepository { - - - @Autowired - private TaskDataProperties properties; - - - - @Override - public int save(TaskEntity entity) { - List list = readFileInfo(); - list.add(entity); - writeFileInfo(list); - return 1; - } - - @Override - public int removeByTaskId(String id) { - List list = readFileInfo(); - List data = new ArrayList<>(); - for(TaskEntity entity:list){ - if(!entity.getTaskId().equals(id)){ - data.add(entity); - } - } - writeFileInfo(data); - return list.size() - data.size(); - } - - - @Override - public int update(TaskEntity entity) { - List list = readFileInfo(); - List data = new ArrayList<>(); - for(TaskEntity one:list){ - if(!one.getTaskId().equals(entity.getTaskId())){ - data.add(one); - } - } - data.add(entity); - writeFileInfo(data); - return 1; - } - - @Override - public List queryAllTask() { - return readFileInfo(); - } - - @Override - public List queryData(TaskEntity entity) { - List list = readFileInfo(); - // 获取不为空的属性 - Map nonNullProperties = entity.getNonNullProperties(); - // 进行 AND 查询 - List result = new ArrayList<>(); - for (TaskEntity t : list) { - boolean match = true; - for (Map.Entry entry : nonNullProperties.entrySet()) { - String key = entry.getKey(); - Object value = entry.getValue(); - if ("taskDesc".equals(key) && !StrUtil.equals(t.getTaskDesc(), (String) value)) { - match = false; - break; - } - if ("taskIsUse".equals(key) && t.getTaskIsUse() != (Integer) value) { - match = false; - break; - } - if ("taskBootUp".equals(key) && t.getTaskBootUp() != (Integer) value) { - match = false; - break; - } - } - if (match) { - result.add(t); - } - } - return result; - } - - - - - @Override - public TaskEntity queryData(String id) { - List list = readFileInfo(); - for(TaskEntity entity:list){ - if(1 == entity.getTaskIsUse() && id.equals(entity.getTaskId())){ - return entity; - } - } - return null; - } - - - private List readFileInfo(){ - // 确保文件存在 - File file = FileUtil.file(getDefaultPath()); - if (!file.exists()) { - log.error("FILE is not exists"); - return new ArrayList<>(); - } - // 读取 JSON 文件内容 - String jsonContent = FileUtil.readUtf8String(getDefaultPath()); - // 将 JSON 字符串转换为 JSON 对象 - JSONArray data = JSONUtil.parseArray(jsonContent); - List result = new ArrayList<>(); - for(int i = 0; i < data.size(); i++){ - result.add(JSONUtil.toBean(data.getJSONObject(i),TaskEntity.class)); - } - return result; - } - - - - /** - * 覆盖写入 JSONArray 文件 - */ - private void writeFileInfo(List data) { - JSONArray array = new JSONArray(data); - // 确保文件存在或创建文件 - File file = FileUtil.touch(getDefaultPath()); - FileUtil.writeUtf8String(array.toJSONString(0), file); - } - - - private String getDefaultPath(){ - if(StrUtil.isNotBlank(properties.getDataFilePath())){ - return properties.getDataFilePath(); - } - return "db/task_info.json"; - } - -} -- Gitee From c575f6b125f228a9bf1115b3f47da38ea18530e7 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:56:50 +0000 Subject: [PATCH 09/14] =?UTF-8?q?=E5=9B=A0=E6=A0=B8=E5=BF=83=E9=80=BB?= =?UTF-8?q?=E8=BE=91=E5=8F=98=E5=8A=A8=E5=AF=BC=E8=87=B4=E7=9A=84=E6=95=B0?= =?UTF-8?q?=E6=8D=AE=E6=93=8D=E4=BD=9C=E5=8F=98=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../components/task/dao/TaskRepository.java | 57 +++++++ .../dao/impl/FileOpTaskRepositoryImpl.java | 154 ++++++++++++++++++ 2 files changed, 211 insertions(+) create mode 100644 task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java b/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java new file mode 100644 index 0000000..c05ea46 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/dao/TaskRepository.java @@ -0,0 +1,57 @@ +package com.gcc.container.components.task.dao; +import com.gcc.container.components.task.model.entity.TaskEntity; +import java.util.List; +/** + * 任务数据操作 + */ +public interface TaskRepository { + + /** + * 新增数据 + * @param entity + * @return int + */ + int save(TaskEntity entity); + + + /** + * 删除任务ID + * @param id id + * @return int + */ + int removeByTaskId(String id); + + + /** + * 更新整个任务 + * @param entity 实体 + * @return int + */ + int update(TaskEntity entity); + + + /** + * 查询全部任务 + * @return List + */ + List queryAllTask(); + + + + /** + * 查询数据 + * @param entity 查询 + * @return TaskEntity + */ + List queryData(TaskEntity entity); + + + + + /** + * 查询具体的任务实体 + * @param taskId 任务id + * @return TaskEntity + */ + TaskEntity queryData(String taskId); +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java b/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java new file mode 100644 index 0000000..198aba1 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/dao/impl/FileOpTaskRepositoryImpl.java @@ -0,0 +1,154 @@ +package com.gcc.container.components.task.dao.impl; + +import cn.hutool.core.io.FileUtil; +import cn.hutool.core.util.StrUtil; +import cn.hutool.json.JSONArray; +import cn.hutool.json.JSONUtil; +import com.gcc.container.components.task.dao.TaskRepository; +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.property.TaskDataProperties; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Repository; +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@Repository +@Slf4j +public class FileOpTaskRepositoryImpl implements TaskRepository { + + + @Autowired + private TaskDataProperties properties; + + + + @Override + public int save(TaskEntity entity) { + List list = readFileInfo(); + list.add(entity); + writeFileInfo(list); + return 1; + } + + @Override + public int removeByTaskId(String id) { + List list = readFileInfo(); + List data = new ArrayList<>(); + for(TaskEntity entity:list){ + if(!entity.getTaskId().equals(id)){ + data.add(entity); + } + } + writeFileInfo(data); + return list.size() - data.size(); + } + + + @Override + public int update(TaskEntity entity) { + List list = readFileInfo(); + List data = new ArrayList<>(); + for(TaskEntity one:list){ + if(!one.getTaskId().equals(entity.getTaskId())){ + data.add(one); + } + } + data.add(entity); + writeFileInfo(data); + return 1; + } + + @Override + public List queryAllTask() { + return readFileInfo(); + } + + @Override + public List queryData(TaskEntity entity) { + List list = readFileInfo(); + // 获取不为空的属性 + Map nonNullProperties = entity.getNonNullProperties(); + // 进行 AND 查询 + List result = new ArrayList<>(); + for (TaskEntity t : list) { + boolean match = true; + for (Map.Entry entry : nonNullProperties.entrySet()) { + String key = entry.getKey(); + Object value = entry.getValue(); + if ("taskDesc".equals(key) && !StrUtil.equals(t.getTaskDesc(), (String) value)) { + match = false; + break; + } + if ("taskIsUse".equals(key) && t.getTaskIsUse() != (Integer) value) { + match = false; + break; + } + if ("taskBootUp".equals(key) && t.getTaskBootUp() != (Integer) value) { + match = false; + break; + } + } + if (match) { + result.add(t); + } + } + return result; + } + + + + + @Override + public TaskEntity queryData(String id) { + List list = readFileInfo(); + for(TaskEntity entity:list){ + if(1 == entity.getTaskIsUse() && id.equals(entity.getTaskId())){ + return entity; + } + } + return null; + } + + + private List readFileInfo(){ + // 确保文件存在 + File file = FileUtil.file(getDefaultPath()); + if (!file.exists()) { + log.warn("FILE is not exists"); + return new ArrayList<>(); + } + // 读取 JSON 文件内容 + String jsonContent = FileUtil.readUtf8String(getDefaultPath()); + // 将 JSON 字符串转换为 JSON 对象 + JSONArray data = JSONUtil.parseArray(jsonContent); + List result = new ArrayList<>(); + for(int i = 0; i < data.size(); i++){ + result.add(JSONUtil.toBean(data.getJSONObject(i),TaskEntity.class)); + } + return result; + } + + + + /** + * 覆盖写入 JSONArray 文件 + */ + private void writeFileInfo(List data) { + JSONArray array = new JSONArray(data); + // 确保文件存在或创建文件 + File file = FileUtil.touch(getDefaultPath()); + FileUtil.writeUtf8String(array.toJSONString(0), file); + } + + + private String getDefaultPath(){ + if(StrUtil.isNotBlank(properties.getDataFilePath())){ + return properties.getDataFilePath(); + } + return "db/task_info.json"; + } + +} -- Gitee From b0b06ab02c5e1cd72fb106f9a08da2dd9509abf1 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:56:57 +0000 Subject: [PATCH 10/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/mo?= =?UTF-8?q?del?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../task/model/TaskVoConvertor.java | 40 ------ .../task/model/dto/SearchTaskDto.java | 28 ----- .../task/model/entity/TaskEntity.java | 115 ------------------ .../task/model/vo/TaskRunRetVo.java | 70 ----------- .../components/task/model/vo/TaskVo.java | 55 --------- 5 files changed, 308 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java b/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java deleted file mode 100644 index fe9089c..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java +++ /dev/null @@ -1,40 +0,0 @@ -package com.gcc.container.components.task.model; - - -import com.gcc.container.components.task.model.entity.TaskEntity; -import com.gcc.container.components.task.model.vo.TaskVo; -import org.springframework.stereotype.Component; - -import java.util.List; -import java.util.stream.Collectors; - -@Component -public class TaskVoConvertor { - - - public TaskVo toTaskVo(TaskEntity entity){ - return TaskVo.builder() - .taskId(entity.getTaskId()) - .taskName(entity.getTaskName()) - .taskDesc(entity.getTaskDesc()) - .taskCron(entity.getTaskCron()) - .taskOutConfig(entity.getTaskOutConfig()) - .taskBootUp(entity.getTaskBootUp()) - .taskCreateTime(entity.getTaskCreateTime()) - .status(ramStatusToRunStatus(entity.getTaskRamStatus())) - .build(); - } - - public List toTaskVos(List entities){ - return entities.stream().map(this::toTaskVo).collect(Collectors.toList()); - } - - private TaskVo.TaskRunStatus ramStatusToRunStatus(Integer ramStatus){ - if(1 == ramStatus){ - return TaskVo.TaskRunStatus.open; - }else { - return TaskVo.TaskRunStatus.shutdown; - } - } - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java b/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java deleted file mode 100644 index d4f352c..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java +++ /dev/null @@ -1,28 +0,0 @@ -package com.gcc.container.components.task.model.dto; - -import lombok.Data; -import java.io.Serializable; - - -/** - * 查询参数 - */ -@Data -public class SearchTaskDto implements Serializable { - - - private String filterKey; - - - private Boolean isBootUp; - - - private Integer lastRunStatus; - - - private Integer pageNo; - - - private Integer pageSize; - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java b/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java deleted file mode 100644 index cfb9bcc..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java +++ /dev/null @@ -1,115 +0,0 @@ -package com.gcc.container.components.task.model.entity; - - -import lombok.Data; -import java.io.Serializable; -import java.util.HashMap; -import java.util.Map; - -/** - * 任务实体类 - * @author GCC - */ -@Data -public class TaskEntity implements Serializable { - - //todo 解决外部创建表的操作 - - private String taskId; - - private String taskName; - - private String taskDesc; - - private String taskCron; - - private String taskClass; - - /** - * 任务相关配置 - */ - private String taskOutConfig; - - /** - * 任务注册时间 - */ - private String taskCreateTime; - - /** - * 是否启用 - */ - private Integer taskIsUse; - - /** - * 是否开启自启动 - */ - private Integer taskBootUp; - - /** - * 上次运行状态 - */ - private Integer taskLastRun; - - /** - * 任务是否在内存中 - */ - private Integer taskRamStatus; - - - public TaskEntity taskIsUse(Boolean isUse) { - if(isUse) { - this.taskIsUse = 1; - }else { - this.taskIsUse = 0; - } - return this; - } - - public TaskEntity taskBootUp(Boolean isBootUp) { - if(isBootUp) { - this.taskBootUp = 1; - }else { - this.taskBootUp = 0; - } - return this; - } - - public TaskEntity taskLastRun(Integer taskLastRun) { - this.taskLastRun = taskLastRun; - return this; - } - - public TaskEntity taskRamStatus(Integer taskRamStatus) { - this.taskRamStatus = taskRamStatus; - return this; - } - - - - public Boolean isUse(){ - if(null != this.taskIsUse && 1 == this.taskIsUse){ - return true; - } - return false; - } - - - public Boolean isBootUp(){ - if(null != this.taskBootUp && 1 == this.taskBootUp){ - return true; - } - return false; - } - - - - public Map getNonNullProperties() { - Map properties = new HashMap<>(); - if (taskDesc != null) properties.put("taskDesc", taskDesc); - if (taskIsUse != null) properties.put("taskIsUse", taskIsUse); - if (taskBootUp != null) properties.put("taskBootUp", taskBootUp); - return properties; - } - - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java deleted file mode 100644 index 300d935..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java +++ /dev/null @@ -1,70 +0,0 @@ -package com.gcc.container.components.task.model.vo; - - -import com.gcc.container.components.task.model.entity.TaskEntity; -import lombok.Data; - -import java.io.Serializable; - -/** - * 任务运行状态 - */ -@Data -public class TaskRunRetVo implements Serializable { - - - private String taskId; - - - private String taskName; - - - private TaskOperation taskOperation; - - /** - * 执行状态 - * 1：成功 - * 0：失败 - */ - private Integer result; - - - private String extend = "successful"; - - - public TaskRunRetVo(TaskOperation taskOperation, int result) { - this.taskOperation = taskOperation; - this.result = result; - if(result == 0){ - this.extend = "fail"; - } - } - - public TaskRunRetVo taskInfo(TaskEntity taskEntity){ - this.taskId = taskEntity.getTaskId(); - this.taskName = taskEntity.getTaskName(); - return this; - } - - public TaskRunRetVo extend(Object extend){ - this.extend =String.valueOf(extend); - return this; - } - - public enum TaskOperation{ - - //开启 - open, - - //关闭/停止 - shutdown, - - //更新任务 - update, - - //立即执行 - run; - } - - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java deleted file mode 100644 index 433c27a..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java +++ /dev/null @@ -1,55 +0,0 @@ -package com.gcc.container.components.task.model.vo; - -import lombok.Builder; -import lombok.Data; - -import java.io.Serializable; - -@Data -@Builder -public class TaskVo implements Serializable { - - private String taskId; - - private String taskName; - - private String taskDesc; - - private String taskCron; - - /** - * 任务相关配置 - */ - private String taskOutConfig; - - /** - * 任务注册时间 - */ - private String taskCreateTime; - - - /** - * 是否开启自启动 - */ - private Integer taskBootUp; - - /** - * 启停状态 - */ - private TaskRunStatus status; - - - public enum TaskRunStatus{ - //开启 - open(1), - //关闭 - shutdown(0); - - Integer code; - - TaskRunStatus(Integer code){ - this.code = code; - } - } - -} -- Gitee From 6a0eaa3d76b7e3efc5cc342496df4f057e2d2a69 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:57:28 +0000 Subject: [PATCH 11/14] =?UTF-8?q?=E6=96=B0=E5=A2=9E=E4=BB=BB=E5=8A=A1?= =?UTF-8?q?=E7=AD=89=E7=BA=A7=E6=9E=9A=E4=B8=BE=EF=BC=8C=E5=AE=9E=E4=BD=93?= =?UTF-8?q?=E7=B1=BB=E5=8F=98=E5=8C=96?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../task/model/TaskVoConvertor.java | 40 ++++++ .../task/model/dto/SearchTaskDto.java | 28 ++++ .../task/model/entity/TaskEntity.java | 136 ++++++++++++++++++ .../task/model/enums/TaskLevel.java | 19 +++ .../task/model/vo/TaskRunRetVo.java | 70 +++++++++ .../components/task/model/vo/TaskVo.java | 55 +++++++ 6 files changed, 348 insertions(+) create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/enums/TaskLevel.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java b/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java new file mode 100644 index 0000000..fe9089c --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/TaskVoConvertor.java @@ -0,0 +1,40 @@ +package com.gcc.container.components.task.model; + + +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.model.vo.TaskVo; +import org.springframework.stereotype.Component; + +import java.util.List; +import java.util.stream.Collectors; + +@Component +public class TaskVoConvertor { + + + public TaskVo toTaskVo(TaskEntity entity){ + return TaskVo.builder() + .taskId(entity.getTaskId()) + .taskName(entity.getTaskName()) + .taskDesc(entity.getTaskDesc()) + .taskCron(entity.getTaskCron()) + .taskOutConfig(entity.getTaskOutConfig()) + .taskBootUp(entity.getTaskBootUp()) + .taskCreateTime(entity.getTaskCreateTime()) + .status(ramStatusToRunStatus(entity.getTaskRamStatus())) + .build(); + } + + public List toTaskVos(List entities){ + return entities.stream().map(this::toTaskVo).collect(Collectors.toList()); + } + + private TaskVo.TaskRunStatus ramStatusToRunStatus(Integer ramStatus){ + if(1 == ramStatus){ + return TaskVo.TaskRunStatus.open; + }else { + return TaskVo.TaskRunStatus.shutdown; + } + } + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java b/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java new file mode 100644 index 0000000..d4f352c --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/dto/SearchTaskDto.java @@ -0,0 +1,28 @@ +package com.gcc.container.components.task.model.dto; + +import lombok.Data; +import java.io.Serializable; + + +/** + * 查询参数 + */ +@Data +public class SearchTaskDto implements Serializable { + + + private String filterKey; + + + private Boolean isBootUp; + + + private Integer lastRunStatus; + + + private Integer pageNo; + + + private Integer pageSize; + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java b/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java new file mode 100644 index 0000000..6b34ee2 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/entity/TaskEntity.java @@ -0,0 +1,136 @@ +package com.gcc.container.components.task.model.entity; + + +import cn.hutool.json.JSONObject; +import cn.hutool.json.JSONUtil; +import com.gcc.container.components.task.model.enums.TaskLevel; +import lombok.Data; +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; + +/** + * 任务实体类 + * @author GCC + */ +@Data +public class TaskEntity implements Serializable { + + private String taskId; + + private String taskName; + + private String taskDesc; + + private String taskCron; + + private String taskClass; + + /** + * 任务级别 + */ + private TaskLevel taskLevel; + + /** + * 任务注册时间 + */ + private String taskCreateTime; + + /** + * 是否启用 + */ + private Integer taskIsUse; + + /** + * 是否开启自启动 + */ + private Integer taskBootUp; + + /** + * 上次运行状态 + */ + private Integer taskLastRun; + + /** + * 任务是否在内存中 + */ + private Integer taskRamStatus; + + + /** + * 外部配置 + */ + private String taskOutConfig; + + + /** + * 加载配置 + */ + private String loadConfigure; + + + public TaskEntity taskIsUse(Boolean isUse) { + if(isUse) { + this.taskIsUse = 1; + }else { + this.taskIsUse = 0; + } + return this; + } + + public TaskEntity taskBootUp(Boolean isBootUp) { + if(isBootUp) { + this.taskBootUp = 1; + }else { + this.taskBootUp = 0; + } + return this; + } + + public TaskEntity taskLastRun(Integer taskLastRun) { + this.taskLastRun = taskLastRun; + return this; + } + + public TaskEntity taskRamStatus(Integer taskRamStatus) { + this.taskRamStatus = taskRamStatus; + return this; + } + + public TaskEntity level(TaskLevel level){ + this.taskLevel = level; + return this; + } + + + public Boolean isUse(){ + if(null != this.taskIsUse && 1 == this.taskIsUse){ + return true; + } + return false; + } + + + public Boolean isBootUp(){ + if(null != this.taskBootUp && 1 == this.taskBootUp){ + return true; + } + return false; + } + + + + public Map getNonNullProperties() { + Map properties = new HashMap<>(); + if (taskDesc != null) properties.put("taskDesc", taskDesc); + if (taskIsUse != null) properties.put("taskIsUse", taskIsUse); + if (taskBootUp != null) properties.put("taskBootUp", taskBootUp); + return properties; + } + + + public JSONObject getLoadConfiguration(){ + return JSONUtil.parseObj(this.loadConfigure); + } + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/enums/TaskLevel.java b/task-component/src/main/java/com/gcc/container/components/task/model/enums/TaskLevel.java new file mode 100644 index 0000000..d344c81 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/enums/TaskLevel.java @@ -0,0 +1,19 @@ +package com.gcc.container.components.task.model.enums; + +/** + * 任务级别枚举 + * @author GCC + */ +public enum TaskLevel { + + /** + * 类级别 + */ + CLASS_LEVEL, + + /** + * 方法级别 + */ + METHOD_LEVEL; + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java new file mode 100644 index 0000000..300d935 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskRunRetVo.java @@ -0,0 +1,70 @@ +package com.gcc.container.components.task.model.vo; + + +import com.gcc.container.components.task.model.entity.TaskEntity; +import lombok.Data; + +import java.io.Serializable; + +/** + * 任务运行状态 + */ +@Data +public class TaskRunRetVo implements Serializable { + + + private String taskId; + + + private String taskName; + + + private TaskOperation taskOperation; + + /** + * 执行状态 + * 1：成功 + * 0：失败 + */ + private Integer result; + + + private String extend = "successful"; + + + public TaskRunRetVo(TaskOperation taskOperation, int result) { + this.taskOperation = taskOperation; + this.result = result; + if(result == 0){ + this.extend = "fail"; + } + } + + public TaskRunRetVo taskInfo(TaskEntity taskEntity){ + this.taskId = taskEntity.getTaskId(); + this.taskName = taskEntity.getTaskName(); + return this; + } + + public TaskRunRetVo extend(Object extend){ + this.extend =String.valueOf(extend); + return this; + } + + public enum TaskOperation{ + + //开启 + open, + + //关闭/停止 + shutdown, + + //更新任务 + update, + + //立即执行 + run; + } + + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java new file mode 100644 index 0000000..433c27a --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/model/vo/TaskVo.java @@ -0,0 +1,55 @@ +package com.gcc.container.components.task.model.vo; + +import lombok.Builder; +import lombok.Data; + +import java.io.Serializable; + +@Data +@Builder +public class TaskVo implements Serializable { + + private String taskId; + + private String taskName; + + private String taskDesc; + + private String taskCron; + + /** + * 任务相关配置 + */ + private String taskOutConfig; + + /** + * 任务注册时间 + */ + private String taskCreateTime; + + + /** + * 是否开启自启动 + */ + private Integer taskBootUp; + + /** + * 启停状态 + */ + private TaskRunStatus status; + + + public enum TaskRunStatus{ + //开启 + open(1), + //关闭 + shutdown(0); + + Integer code; + + TaskRunStatus(Integer code){ + this.code = code; + } + } + +} -- Gitee From 16f579fb3ed9bc8250ce5a1b92daf4a20cf8b541 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:57:56 +0000 Subject: [PATCH 12/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/se?= =?UTF-8?q?rvice?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../task/service/AfterAppStarted.java | 29 ---- .../service/TaskScheduleManagerService.java | 55 ------- .../impl/TaskScheduleManagerServiceImpl.java | 142 ------------------ 3 files changed, 226 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java b/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java deleted file mode 100644 index 00e270b..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java +++ /dev/null @@ -1,29 +0,0 @@ -package com.gcc.container.components.task.service; - - - -import com.gcc.container.components.task.compont.TaskSchedule; -import lombok.extern.slf4j.Slf4j; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.context.event.ApplicationReadyEvent; -import org.springframework.context.event.EventListener; -import org.springframework.stereotype.Component; - -@Component -@Slf4j -public class AfterAppStarted { - - TaskSchedule taskSchedule; - - @Autowired - public void setTaskScheduleServer(TaskSchedule taskSchedule) { - this.taskSchedule = taskSchedule; - } - - @EventListener - public void onApplicationEvent(ApplicationReadyEvent event){ - log.info("【定时任务自运行】运行开机自启动任务"); - //运行随系统启动的定时任务 - taskSchedule.runBootUpTask(); - } -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java b/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java deleted file mode 100644 index ec07f9c..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java +++ /dev/null @@ -1,55 +0,0 @@ -package com.gcc.container.components.task.service; - -import com.gcc.container.components.task.model.dto.SearchTaskDto; -import com.gcc.container.components.task.model.entity.TaskEntity; -import com.gcc.container.components.task.model.vo.TaskRunRetVo; -import com.gcc.container.components.task.model.vo.TaskVo; -import java.util.List; -public interface TaskScheduleManagerService { - - /** - * 查询在用任务 - * @return - */ - List searchTask(SearchTaskDto dto); - - /** - * 查询任务详情 - * @param taskId 任务id - * @return TaskEntity - */ - TaskVo searchTaskDetail(String taskId); - - - /** - * 运行指定任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo runTask(String taskId); - - - /** - * 关停任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo shutdownTask(String taskId); - - - /** - * 开启任务 - * @param taskId 任务id - * @return TaskRunRetDto - */ - TaskRunRetVo openTask(String taskId); - - - /** - * 更新任务信息 - * @param entity 实体 - * @return TaskRunRetDto - */ - TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity); - -} diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java b/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java deleted file mode 100644 index e0c0ba5..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java +++ /dev/null @@ -1,142 +0,0 @@ -package com.gcc.container.components.task.service.impl; - -import cn.hutool.json.JSONUtil; -import com.gcc.container.components.task.compont.AbstractBaseCronTask; -import com.gcc.container.components.task.compont.TaskSchedule; -import com.gcc.container.components.task.dao.TaskRepository; -import com.gcc.container.components.task.model.TaskVoConvertor; -import com.gcc.container.components.task.model.dto.SearchTaskDto; -import com.gcc.container.components.task.model.entity.TaskEntity; -import com.gcc.container.components.task.model.vo.TaskRunRetVo; -import com.gcc.container.components.task.model.vo.TaskVo; -import com.gcc.container.components.task.service.TaskScheduleManagerService; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Component; -import org.springframework.util.StringUtils; - -import java.util.List; - - -@Component -public class TaskScheduleManagerServiceImpl implements TaskScheduleManagerService { - - - private TaskSchedule taskSchedule; - - private TaskRepository taskRepository; - - private TaskVoConvertor taskVoConvertor; - - @Autowired - public void setTaskScheduleServer(TaskSchedule taskSchedule) { - this.taskSchedule = taskSchedule; - } - - @Autowired - public void setTaskRepository(TaskRepository taskRepository) { - this.taskRepository = taskRepository; - } - - @Autowired - public void setTaskVoConvertor(TaskVoConvertor taskVoConvertor) { - this.taskVoConvertor = taskVoConvertor; - } - - @Override - public List searchTask(SearchTaskDto dto) { - TaskEntity entity = new TaskEntity() - .taskIsUse(true) - .taskBootUp(dto.getIsBootUp()) - .taskLastRun(dto.getLastRunStatus()); - entity.setTaskDesc(dto.getFilterKey()); - return taskVoConvertor.toTaskVos(taskRepository.queryData(entity)); - } - - - @Override - public TaskVo searchTaskDetail(String taskId) { - if(!StringUtils.isEmpty(taskId)){ - return taskVoConvertor.toTaskVo(taskRepository.queryData(taskId)); - } - return null; - } - - - @Override - public TaskRunRetVo runTask(String taskId) { - AbstractBaseCronTask task = taskSchedule.getTaskSchedulingRam().get(taskId); - TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.run, 0); - if(null != task) { - double time = taskSchedule.runTaskById(taskId); - result.setResult(1); - return result.extend(time).taskInfo(task.getThisTaskInfo()); - } else { - return result.extend("任务未启用"); - } - } - - @Override - public TaskRunRetVo shutdownTask(String taskId) { - AbstractBaseCronTask task = taskSchedule.getTaskSchedulingRam().get(taskId); - TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.shutdown, 0); - if(null != task) { - boolean flag = taskSchedule.removeTaskFromScheduling(taskId); - if(flag) { - result.setResult(1); - } - return result.extend("任务成功关闭").taskInfo(task.getThisTaskInfo()); - } else { - return result.extend("任务未启用"); - } - } - - @Override - public TaskRunRetVo openTask(String taskId) { - TaskEntity task = taskRepository.queryData(taskId); - TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.open, 0); - if(null != task) { - if (!taskSchedule.getTaskSchedulingRam().containsKey(taskId)) { - boolean flag = taskSchedule.addTaskToScheduling(task); - if(flag) { - result.setResult(1); - } - return result.extend("任务开启成功").taskInfo(task); - } else { - return result.extend("任务处于启动状态").taskInfo(task); - } - }else { - return result.extend("任务不存在！"); - } - } - - @Override - public TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity) { - TaskEntity task = taskRepository.queryData(entity.getTaskId()); - TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.update, 0).taskInfo(entity); - String config = entity.getTaskOutConfig(); - if(null != config && !JSONUtil.isJson(config) && !JSONUtil.isJsonArray(config)){ - result.setResult(0); - result.extend("更新任务失败,任务配置必须为JSON或空"); - result.taskInfo(entity); - return result; - } - task.setTaskCron(entity.getTaskCron()); - task.setTaskOutConfig(entity.getTaskOutConfig()); - task.setTaskName(entity.getTaskName()); - task.setTaskDesc(entity.getTaskDesc()); - int num = taskRepository.update(task); - if (num == 1) { - result.setResult(1); - result.extend("成功更新任务"); - result.taskInfo(entity); - //重新刷新任务 - taskSchedule.removeTaskFromScheduling(entity.getTaskId()); - taskSchedule.addTaskToScheduling(task); - } - - return result; - } - - - -} -- Gitee From 02b9dce267f04e5cce395e9e10fe3cf31be6a255 Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:58:03 +0000 Subject: [PATCH 13/14] =?UTF-8?q?=E5=88=A0=E9=99=A4=E6=96=87=E4=BB=B6=20ta?= =?UTF-8?q?sk-component/src/main/java/com/gcc/container/components/task/pr?= =?UTF-8?q?operty?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../task/property/TaskDataProperties.java | 25 ------------------- 1 file changed, 25 deletions(-) delete mode 100644 task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java b/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java deleted file mode 100644 index 20f6cb1..0000000 --- a/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java +++ /dev/null @@ -1,25 +0,0 @@ -package com.gcc.container.components.task.property; - -import cn.hutool.core.util.StrUtil; -import lombok.Data; -import org.springframework.boot.context.properties.ConfigurationProperties; -import org.springframework.context.annotation.Configuration; - -@Configuration -@ConfigurationProperties("gcc-task") -@Data -public class TaskDataProperties { - - - private String dataFilePath; - - - private String taskClassPackage; - - public String getTaskClassPackage() { - if(StrUtil.isBlankIfStr(this.taskClassPackage)){ - return "*"; - } - return taskClassPackage; - } -} -- Gitee From 8ca103ee2904201ab35e8856fdb3b3851516306e Mon Sep 17 00:00:00 2001 From: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> Date: Tue, 19 Nov 2024 08:58:29 +0000 Subject: [PATCH 14/14] =?UTF-8?q?=E5=AE=8C=E5=96=84=E6=8E=A5=E5=8F=A3?= =?UTF-8?q?=E5=8F=8A=E5=BC=80=E6=9C=BA=E8=87=AA=E5=90=AF=E5=8A=A8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: GCC1566 <8714475+gcc1566@user.noreply.gitee.com> --- .../task/property/TaskDataProperties.java | 25 +++ .../task/service/AfterAppStarted.java | 29 ++++ .../service/TaskScheduleManagerService.java | 55 +++++++ .../impl/TaskScheduleManagerServiceImpl.java | 142 ++++++++++++++++++ 4 files changed, 251 insertions(+) create mode 100644 task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java create mode 100644 task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java diff --git a/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java b/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java new file mode 100644 index 0000000..20f6cb1 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/property/TaskDataProperties.java @@ -0,0 +1,25 @@ +package com.gcc.container.components.task.property; + +import cn.hutool.core.util.StrUtil; +import lombok.Data; +import org.springframework.boot.context.properties.ConfigurationProperties; +import org.springframework.context.annotation.Configuration; + +@Configuration +@ConfigurationProperties("gcc-task") +@Data +public class TaskDataProperties { + + + private String dataFilePath; + + + private String taskClassPackage; + + public String getTaskClassPackage() { + if(StrUtil.isBlankIfStr(this.taskClassPackage)){ + return "*"; + } + return taskClassPackage; + } +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java b/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java new file mode 100644 index 0000000..00e270b --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/service/AfterAppStarted.java @@ -0,0 +1,29 @@ +package com.gcc.container.components.task.service; + + + +import com.gcc.container.components.task.compont.TaskSchedule; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.context.event.ApplicationReadyEvent; +import org.springframework.context.event.EventListener; +import org.springframework.stereotype.Component; + +@Component +@Slf4j +public class AfterAppStarted { + + TaskSchedule taskSchedule; + + @Autowired + public void setTaskScheduleServer(TaskSchedule taskSchedule) { + this.taskSchedule = taskSchedule; + } + + @EventListener + public void onApplicationEvent(ApplicationReadyEvent event){ + log.info("【定时任务自运行】运行开机自启动任务"); + //运行随系统启动的定时任务 + taskSchedule.runBootUpTask(); + } +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java b/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java new file mode 100644 index 0000000..ec07f9c --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/service/TaskScheduleManagerService.java @@ -0,0 +1,55 @@ +package com.gcc.container.components.task.service; + +import com.gcc.container.components.task.model.dto.SearchTaskDto; +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.model.vo.TaskRunRetVo; +import com.gcc.container.components.task.model.vo.TaskVo; +import java.util.List; +public interface TaskScheduleManagerService { + + /** + * 查询在用任务 + * @return + */ + List searchTask(SearchTaskDto dto); + + /** + * 查询任务详情 + * @param taskId 任务id + * @return TaskEntity + */ + TaskVo searchTaskDetail(String taskId); + + + /** + * 运行指定任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo runTask(String taskId); + + + /** + * 关停任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo shutdownTask(String taskId); + + + /** + * 开启任务 + * @param taskId 任务id + * @return TaskRunRetDto + */ + TaskRunRetVo openTask(String taskId); + + + /** + * 更新任务信息 + * @param entity 实体 + * @return TaskRunRetDto + */ + TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity); + +} diff --git a/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java b/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java new file mode 100644 index 0000000..e0c0ba5 --- /dev/null +++ b/task-component/src/main/java/com/gcc/container/components/task/service/impl/TaskScheduleManagerServiceImpl.java @@ -0,0 +1,142 @@ +package com.gcc.container.components.task.service.impl; + +import cn.hutool.json.JSONUtil; +import com.gcc.container.components.task.compont.AbstractBaseCronTask; +import com.gcc.container.components.task.compont.TaskSchedule; +import com.gcc.container.components.task.dao.TaskRepository; +import com.gcc.container.components.task.model.TaskVoConvertor; +import com.gcc.container.components.task.model.dto.SearchTaskDto; +import com.gcc.container.components.task.model.entity.TaskEntity; +import com.gcc.container.components.task.model.vo.TaskRunRetVo; +import com.gcc.container.components.task.model.vo.TaskVo; +import com.gcc.container.components.task.service.TaskScheduleManagerService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; +import org.springframework.util.StringUtils; + +import java.util.List; + + +@Component +public class TaskScheduleManagerServiceImpl implements TaskScheduleManagerService { + + + private TaskSchedule taskSchedule; + + private TaskRepository taskRepository; + + private TaskVoConvertor taskVoConvertor; + + @Autowired + public void setTaskScheduleServer(TaskSchedule taskSchedule) { + this.taskSchedule = taskSchedule; + } + + @Autowired + public void setTaskRepository(TaskRepository taskRepository) { + this.taskRepository = taskRepository; + } + + @Autowired + public void setTaskVoConvertor(TaskVoConvertor taskVoConvertor) { + this.taskVoConvertor = taskVoConvertor; + } + + @Override + public List searchTask(SearchTaskDto dto) { + TaskEntity entity = new TaskEntity() + .taskIsUse(true) + .taskBootUp(dto.getIsBootUp()) + .taskLastRun(dto.getLastRunStatus()); + entity.setTaskDesc(dto.getFilterKey()); + return taskVoConvertor.toTaskVos(taskRepository.queryData(entity)); + } + + + @Override + public TaskVo searchTaskDetail(String taskId) { + if(!StringUtils.isEmpty(taskId)){ + return taskVoConvertor.toTaskVo(taskRepository.queryData(taskId)); + } + return null; + } + + + @Override + public TaskRunRetVo runTask(String taskId) { + AbstractBaseCronTask task = taskSchedule.getTaskSchedulingRam().get(taskId); + TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.run, 0); + if(null != task) { + double time = taskSchedule.runTaskById(taskId); + result.setResult(1); + return result.extend(time).taskInfo(task.getThisTaskInfo()); + } else { + return result.extend("任务未启用"); + } + } + + @Override + public TaskRunRetVo shutdownTask(String taskId) { + AbstractBaseCronTask task = taskSchedule.getTaskSchedulingRam().get(taskId); + TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.shutdown, 0); + if(null != task) { + boolean flag = taskSchedule.removeTaskFromScheduling(taskId); + if(flag) { + result.setResult(1); + } + return result.extend("任务成功关闭").taskInfo(task.getThisTaskInfo()); + } else { + return result.extend("任务未启用"); + } + } + + @Override + public TaskRunRetVo openTask(String taskId) { + TaskEntity task = taskRepository.queryData(taskId); + TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.open, 0); + if(null != task) { + if (!taskSchedule.getTaskSchedulingRam().containsKey(taskId)) { + boolean flag = taskSchedule.addTaskToScheduling(task); + if(flag) { + result.setResult(1); + } + return result.extend("任务开启成功").taskInfo(task); + } else { + return result.extend("任务处于启动状态").taskInfo(task); + } + }else { + return result.extend("任务不存在！"); + } + } + + @Override + public TaskRunRetVo updateTaskBusinessInfo(TaskEntity entity) { + TaskEntity task = taskRepository.queryData(entity.getTaskId()); + TaskRunRetVo result = new TaskRunRetVo(TaskRunRetVo.TaskOperation.update, 0).taskInfo(entity); + String config = entity.getTaskOutConfig(); + if(null != config && !JSONUtil.isJson(config) && !JSONUtil.isJsonArray(config)){ + result.setResult(0); + result.extend("更新任务失败,任务配置必须为JSON或空"); + result.taskInfo(entity); + return result; + } + task.setTaskCron(entity.getTaskCron()); + task.setTaskOutConfig(entity.getTaskOutConfig()); + task.setTaskName(entity.getTaskName()); + task.setTaskDesc(entity.getTaskDesc()); + int num = taskRepository.update(task); + if (num == 1) { + result.setResult(1); + result.extend("成功更新任务"); + result.taskInfo(entity); + //重新刷新任务 + taskSchedule.removeTaskFromScheduling(entity.getTaskId()); + taskSchedule.addTaskToScheduling(task); + } + + return result; + } + + + +} -- Gitee