1、任务,调度

Former-commit-id: c3e05986ce25ddc865e87a712d4540f104ca5469
master
王兵 4 years ago
parent f5c4ad557c
commit e1b6e32c72

@ -258,8 +258,7 @@ public class SpringBootCallable implements Callable {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "CacheConfig.java"), "SpringBoot/java/config/CacheConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "FreeMarkerConfig.java"), "SpringBoot/java/config/FreeMarkerConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "SecurityConfig.java"), "SpringBoot/java/config/SecurityConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ScheduleConfig.java"), "SpringBoot/java/config/ScheduleConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "TaskSqlConfig.java"), "SpringBoot/java/config/TaskSqlConfig.java", ctx);
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "TaskConfig.java"), "SpringBoot/java/config/TaskConfig.java", ctx);
if (project.isNeedAsync()) {
freeMarkerManager.outputTemp(Tool.createFile(root.getAbsolutePath(), "ThreadPoolConfig.java"), "SpringBoot/java/config/ThreadPoolConfig.java", ctx);
}

@ -0,0 +1,34 @@
package ${basePackage}.action.ajax.system;
import ${basePackage}.frame.schedule.Scheduler;
import ${basePackage}.module.system.ent.Schedule;
import ${basePackage}.module.system.req.ScheduleFindRequest;
import ${basePackage}.module.system.rsp.ScheduleFindResponse;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
public class ScheduleAjax {
@Autowired
private Scheduler scheduler;
// public TaskSqlCreateResponse create(TaskSqlCreateRequest request) {
// return taskSqlManager.create(request, LocalData.getToken());
// }
//
// public TaskSqlDeleteResponse delete(TaskSqlDeleteRequest request) {
// return taskSqlManager.delete(request, LocalData.getToken());
// }
//
// public TaskSqlUpdateResponse update(TaskSqlUpdateRequest request) {
// return taskSqlManager.update(request, LocalData.getToken());
// }
public ScheduleFindResponse find(ScheduleFindRequest request) {
ScheduleFindResponse response = new ScheduleFindResponse();
List<Schedule> schedules = scheduler.taskList();
response.setResult(schedules);
return response;
}
}

@ -1,91 +0,0 @@
package ${basePackage}.config;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanDefinitionRegistryPostProcessor;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.core.type.filter.AssignableTypeFilter;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;
import ${basePackage}.frame.schedule.RunTask;
import ${basePackage}.frame.utils.LogUtil;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* ,
* :@Profile("dev")
*/
@Configuration
@Component
public class ScheduleConfig extends ThreadPoolTaskScheduler implements BeanDefinitionRegistryPostProcessor {
private Map<String, Class<RunTask>> classMap;
private Map<String, ScheduledFuture<?>> futureMap;
public ScheduleConfig() {
classMap = new HashMap<>();
futureMap = new HashMap<>();
setPoolSize(4);
initialize();
}
public boolean createOrRepeat(RunTask task) {
if (futureMap.containsKey(task.taskId())) {
ScheduledFuture<?> scheduledFuture = futureMap.get(task.taskId());
scheduledFuture.cancel(false);
}
classMap.put(task.taskId(), (Class<RunTask>) task.getClass());
futureMap.put(task.taskId(), task.schedule(this));
return true;
}
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry) throws BeansException {
String aPackage = this.getClass().getPackage().getName();
Pattern compile = Pattern.compile("(.*)\\.config");
Matcher matcher = compile.matcher(aPackage);
if (matcher.find()) {
String basePackage = matcher.group(1);
registryTask(basePackage, beanDefinitionRegistry);
}
}
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
}
private int registryTask(String basePackage, BeanDefinitionRegistry beanDefinitionRegistry) {
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(beanDefinitionRegistry);
classPathBeanDefinitionScanner.resetFilters(false);
classPathBeanDefinitionScanner.addIncludeFilter(new AssignableTypeFilter(RunTask.class));
classPathBeanDefinitionScanner.setBeanNameGenerator(new BeanNameGenerator() {
@Override
public String generateBeanName(BeanDefinition beanDefinition, BeanDefinitionRegistry beanDefinitionRegistry) {
String beanClassName = beanDefinition.getBeanClassName();
try {
Class<?> aClass = Class.forName(beanClassName);
Object instance = aClass.newInstance();
RunTask task = (RunTask) instance;
ScheduleConfig.this.createOrRepeat(task);
} catch (Exception e) {
e.printStackTrace();
}
LogUtil.i("registry task " + beanClassName);
return beanClassName;
}
});
return classPathBeanDefinitionScanner.scan(basePackage);
}
}

@ -0,0 +1,80 @@
package com.example.config;
import com.example.frame.auth.LocalData;
import com.example.frame.schedule.RunTask;
import com.example.frame.schedule.Scheduler;
import com.example.frame.utils.LogUtil;
import com.example.module.system.ent.TaskSql;
import com.example.module.system.mgr.TaskSqlManager;
import com.example.module.system.req.TaskSqlFindRequest;
import com.example.module.system.rsp.TaskSqlFindResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.BeanNameGenerator;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ClassPathBeanDefinitionScanner;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.filter.AssignableTypeFilter;
import javax.annotation.PostConstruct;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@Configuration
public class TaskConfig {
@Autowired
private Scheduler scheduler;
@Autowired
private TaskSqlManager taskSqlManager;
@Bean
public Scheduler registerScheduler() {
return new Scheduler();
}
@PostConstruct
public void registryTask() {
{// 扫描类任务
String aPackage = this.getClass().getPackage().getName();
Pattern compile = Pattern.compile("(.*)\\.config");
Matcher matcher = compile.matcher(aPackage);
if (matcher.find()) {
DefaultListableBeanFactory simpleBeanDefinitionRegistry = new DefaultListableBeanFactory();
ClassPathBeanDefinitionScanner classPathBeanDefinitionScanner = new ClassPathBeanDefinitionScanner(simpleBeanDefinitionRegistry);
classPathBeanDefinitionScanner.resetFilters(false);
classPathBeanDefinitionScanner.addIncludeFilter(new AssignableTypeFilter(RunTask.class));
classPathBeanDefinitionScanner.setBeanNameGenerator(new BeanNameGenerator() {
@Override
public String generateBeanName(BeanDefinition beanDefinition, BeanDefinitionRegistry beanDefinitionRegistry) {
String beanClassName = beanDefinition.getBeanClassName();
try {
Class<?> aClass = Class.forName(beanClassName);
Object instance = aClass.newInstance();
RunTask task = (RunTask) instance;
scheduler.createOrRepeat(task);
} catch (Exception e) {
e.printStackTrace();
}
LogUtil.i("registry task " + beanClassName);
return beanClassName;
}
});
classPathBeanDefinitionScanner.scan(matcher.group(1));
}
}
{// 实例化SQL任务
TaskSqlFindRequest taskSqlFindRequest = new TaskSqlFindRequest();
taskSqlFindRequest.setValid(true);
taskSqlFindRequest.setPageSize(0);
TaskSqlFindResponse taskSqlFindResponse = taskSqlManager.find(taskSqlFindRequest, LocalData.getSysToken());
for (TaskSql taskSql : taskSqlFindResponse.getResult()) {
taskSqlManager.createOrRepeat(taskSql);
}
}
}
}

@ -1,55 +0,0 @@
package ${basePackage}.config;
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.frame.schedule.RunDelayRepeatTask;
import ${basePackage}.module.system.ent.TaskSql;
import ${basePackage}.module.system.mgr.TaskSqlManager;
import ${basePackage}.module.system.req.TaskSqlFindRequest;
import ${basePackage}.module.system.rsp.TaskSqlFindResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import javax.annotation.PostConstruct;
import java.time.Duration;
/**
* Sql
*/
@Configuration
public class TaskSqlConfig {
@Autowired
private ScheduleConfig scheduleConfig;
@Autowired
private TaskSqlManager taskSqlManager;
@PostConstruct
public void ss() {
TaskSqlFindRequest taskSqlFindRequest = new TaskSqlFindRequest();
taskSqlFindRequest.setValid(true);
taskSqlFindRequest.setPageSize(0);
TaskSqlFindResponse taskSqlFindResponse = taskSqlManager.find(taskSqlFindRequest, LocalData.getSysToken());
for (TaskSql taskSql : taskSqlFindResponse.getResult()) {
if ("DelayRepeat".equals(taskSql.getTaskType())) {
scheduleConfig.createOrRepeat(new RunDelayRepeatTask() {
@Override
public Duration interval() {
String typeValue = taskSql.getTypeValue();
return Duration.ofSeconds(Integer.parseInt(typeValue));
}
@Override
public String taskId() {
return String.valueOf(taskSql.getId());
}
@Override
public void run() {
}
});
}
}
}
}

@ -8,7 +8,7 @@ import java.util.concurrent.ScheduledFuture;
public abstract class RunCronTask extends RunTask {
abstract String cron();
public abstract String cron();
@Override
public ScheduledFuture<?> schedule(ThreadPoolTaskScheduler poolTaskScheduler) {

@ -0,0 +1,82 @@
package ${basePackage}.frame.schedule;
import ${basePackage}.module.system.ent.Schedule;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;
public class Scheduler extends ThreadPoolTaskScheduler {
private Map<String, TaskWrapper> taskMap;
public Scheduler() {
taskMap = new HashMap<>();
setPoolSize(4);
initialize();
}
public boolean createOrRepeat(RunTask task) {
if (taskMap.containsKey(task.taskId())) {
ScheduledFuture<?> scheduledFuture = taskMap.get(task.taskId()).future;
scheduledFuture.cancel(false);
}
taskMap.put(task.taskId(), new TaskWrapper(
task.taskId(),
task.taskName(),
true,
(Class<RunTask>) task.getClass(),
task.schedule(this)
));
return true;
}
public boolean remove(String taskId) {
if (taskMap.containsKey(taskId)) {
ScheduledFuture<?> scheduledFuture = taskMap.get(taskId).future;
scheduledFuture.cancel(false);
taskMap.remove(taskId);
}
return true;
}
public boolean stop(String taskId) {
if (taskMap.containsKey(taskId)) {
taskMap.get(taskId).run = false;
ScheduledFuture<?> scheduledFuture = taskMap.get(taskId).future;
scheduledFuture.cancel(false);
}
return true;
}
public List<Schedule> taskList() {
List<Schedule> result = new ArrayList<>();
for (TaskWrapper taskWrapper : taskMap.values()) {
Schedule schedule = new Schedule();
schedule.setId(taskWrapper.taskId);
schedule.setName(taskWrapper.taskName);
schedule.setRun(taskWrapper.run);
result.add(schedule);
}
return result;
}
class TaskWrapper {
String taskId;
String taskName;
boolean run;
Class<RunTask> target;
ScheduledFuture<?> future;
public TaskWrapper(String taskId, String taskName, boolean run, Class<RunTask> target, ScheduledFuture<?> future) {
this.taskId = taskId;
this.taskName = taskName;
this.run = run;
this.target = target;
this.future = future;
}
}
}

@ -0,0 +1,49 @@
package ${basePackage}.module.system.ent;
/**
* Schedule -
*
* @author author
* @version 0.0.1
* @since 2020-05-24
*/
public class Schedule {
/**
* ID - ID
*/
private String id;
/**
* NAME -
*/
private String name;
/**
* run -
*/
private boolean run;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isRun() {
return run;
}
public void setRun(boolean run) {
this.run = run;
}
}

@ -1,6 +1,7 @@
package ${basePackage}.module.system.mgr;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.module.system.ent.TaskSql;
import ${basePackage}.module.system.req.TaskSqlCreateRequest;
import ${basePackage}.module.system.req.TaskSqlDeleteRequest;
import ${basePackage}.module.system.req.TaskSqlFindRequest;
@ -65,4 +66,12 @@ public interface TaskSqlManager {
* @return
*/
TaskSqlGetResponse get(TaskSqlGetRequest request, Token token);
/**
* Sql
*
* @param taskSql Sql
* @return
*/
boolean createOrRepeat(TaskSql taskSql);
}

@ -2,9 +2,14 @@ package ${basePackage}.module.system.mgr;
import ${basePackage}.frame.auth.Token;
import ${basePackage}.frame.base.ErrorType;
import ${basePackage}.frame.schedule.RunCronTask;
import ${basePackage}.frame.schedule.RunDelayRepeatTask;
import ${basePackage}.frame.schedule.RunFixRepeatTask;
import ${basePackage}.frame.schedule.Scheduler;
import ${basePackage}.frame.utils.IDgenerator;
import ${basePackage}.frame.utils.MapperUtil;
import ${basePackage}.frame.utils.Message;
import ${basePackage}.frame.utils.SqlUtil;
import ${basePackage}.frame.utils.ValidationUtil;
import ${basePackage}.module.system.ent.TaskSql;
import ${basePackage}.module.system.mpr.TaskSqlMapper;
@ -26,6 +31,8 @@ import org.springframework.scheduling.support.CronSequenceGenerator;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.time.Duration;
/**
* TASK_SQL - SQL
*
@ -39,6 +46,8 @@ public class TaskSqlManagerImpl implements TaskSqlManager {
@Autowired
private TaskSqlMapper taskSqlMapper;
@Autowired
private Scheduler scheduler;
/**
*
@ -82,6 +91,7 @@ public class TaskSqlManagerImpl implements TaskSqlManager {
return response;
}
response.setId(id);
createOrRepeat(entity);
return response;
}
@ -107,6 +117,7 @@ public class TaskSqlManagerImpl implements TaskSqlManager {
return response;
}
response.setResult(result);
scheduler.remove(String.valueOf(request.getId()));
return response;
}
@ -149,6 +160,11 @@ public class TaskSqlManagerImpl implements TaskSqlManager {
return response;
}
response.setResult(result);
if (request.getValid()) {
createOrRepeat(MapperUtil.map(request, TaskSql.class));
} else {
scheduler.remove(String.valueOf(request.getId()));
}
return response;
}
@ -209,4 +225,102 @@ public class TaskSqlManagerImpl implements TaskSqlManager {
return response;
}
/**
* Sql
*
* @param taskSql Sql
* @return
*/
public boolean createOrRepeat(TaskSql taskSql) {
try {
if ("Cron".equals(taskSql.getTaskType())) {
scheduler.createOrRepeat(new RunCronTask() {
@Override
public String cron() {
return taskSql.getTypeValue();
}
@Override
public String taskName() {
return taskSql.getTaskName();
}
@Override
public String taskId() {
return String.valueOf(taskSql.getId());
}
@Override
public void run() {
try {
SqlUtil.exec(taskSql.getTaskSql());
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
if ("DelayRepeat".equals(taskSql.getTaskType())) {
scheduler.createOrRepeat(new RunDelayRepeatTask() {
@Override
public Duration interval() {
String typeValue = taskSql.getTypeValue();
return Duration.ofSeconds(Integer.parseInt(typeValue));
}
@Override
public String taskName() {
return taskSql.getTaskName();
}
@Override
public String taskId() {
return String.valueOf(taskSql.getId());
}
@Override
public void run() {
try {
SqlUtil.exec(taskSql.getTaskSql());
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
if ("FixRepeat".equals(taskSql.getTaskType())) {
scheduler.createOrRepeat(new RunFixRepeatTask() {
@Override
public Duration interval() {
String typeValue = taskSql.getTypeValue();
return Duration.ofSeconds(Integer.parseInt(typeValue));
}
@Override
public String taskName() {
return taskSql.getTaskName();
}
@Override
public String taskId() {
return String.valueOf(taskSql.getId());
}
@Override
public void run() {
try {
SqlUtil.exec(taskSql.getTaskSql());
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
} catch (Exception e) {
return false;
}
return true;
}
}

@ -0,0 +1,67 @@
package ${basePackage}.module.system.req;
import ${basePackage}.frame.base.BaseFindRequest;
import ${basePackage}.frame.validation.Dict;
/**
* TaskSqlRequest - SQL
*
* @author author
* @version 0.0.1
* @since 2020-05-24
*/
public class ScheduleFindRequest extends BaseFindRequest {
/**
*
*/
private String taskName;
/**
*
*/
private String taskNote;
/**
*
*/
@Dict(name = "TASK_TYPE")
private String taskType;
/**
*
*/
private Boolean valid;
public String getTaskName() {
return this.taskName;
}
public void setTaskName(String taskName) {
this.taskName = taskName;
}
public String getTaskNote() {
return this.taskNote;
}
public void setTaskNote(String taskNote) {
this.taskNote = taskNote;
}
public String getTaskType() {
return this.taskType;
}
public void setTaskType(String taskType) {
this.taskType = taskType;
}
public Boolean getValid() {
return this.valid;
}
public void setValid(Boolean valid) {
this.valid = valid;
}
}

@ -0,0 +1,14 @@
package ${basePackage}.module.system.rsp;
import ${basePackage}.frame.base.BaseFindResponse;
import ${basePackage}.module.system.ent.Schedule;
/**
* TaskSqlFindResponse -
*
* @author author
* @version 0.0.1
* @since 2020-05-24
*/
public class ScheduleFindResponse extends BaseFindResponse<Schedule> {
}

@ -2,6 +2,7 @@ package ${basePackage}.task;
import ${basePackage}.frame.auth.LocalData;
import ${basePackage}.frame.schedule.RunDelayRepeatTask;
import ${basePackage}.frame.utils.IDgenerator;
import ${basePackage}.module.system.ent.Tokens;
import ${basePackage}.module.system.mgr.TokensManager;
import ${basePackage}.module.system.req.TokensFindRequest;
@ -16,7 +17,12 @@ public class TokenTask extends RunDelayRepeatTask {
@Override
public String taskId() {
return "task1";
return String.valueOf(IDgenerator.nextId());
}
@Override
public String taskName() {
return "登录凭证处理任务";
}
@Override

@ -51,7 +51,7 @@
<span slot="title">监控运行</span>
</template>
<el-menu-item index="${tool.uuid()}" @click="addTab({title: '错误日志', name: 'logErr', url: '${r'${context}'}/system/logErr.htm'})">错误日志</el-menu-item>
<el-menu-item index="${tool.uuid()}" @click="addTab({title: '计划调度', name: 'schedule', url: '${r'${context}'}/system/schedule.htm'})">计划调度</el-menu-item>
<el-menu-item index="${tool.uuid()}" @click="addTab({title: '调度监控', name: 'schedule', url: '${r'${context}'}/system/schedule.htm'})">调度监控</el-menu-item>
</el-submenu>
${print('</#if>')}
</#if>

@ -1,6 +1,73 @@
<div id="app" v-cloak>
</div>
<el-card class="box-card">
<el-form class="search" :inline="true" :model="vm" ref="vm" label-position="right" label-width="90px">
<el-form-item label="任务ID" prop="id">
<el-input v-model="vm.id" clearable size="mini" placeholder="请输入任务名称"></el-input>
</el-form-item>
<el-form-item label="任务名称" prop="name">
<el-input v-model="vm.name" clearable size="mini" placeholder="请输入任务名称"></el-input>
</el-form-item>
<el-form-item label="是否有效" prop="run">
<el-radio-group v-model="vm.run" clearable size="mini">
<el-radio :label="true">是</el-radio>
<el-radio :label="false">否</el-radio>
</el-radio-group>
</el-form-item>
<el-form-item>
<el-button type="primary" size="mini" icon="el-icon-search" @click="onSearch">搜索</el-button>
<el-button type="warning" size="mini" icon="el-icon-refresh-left" @click="onReset('vm')">重置</el-button>
</el-form-item>
</el-form>
</el-card>
<el-card class="box-card">
<el-table
class="data"
@selection-change="onSelectionChange"
empty-text="无数据"
:data="result"
size="mini">
<el-table-column
align="center"
type="selection"
width="45">
</el-table-column>
<el-table-column
align="center"
prop="id"
label="主键"
width="140">
</el-table-column>
<el-table-column
align="center"
width="140"
prop="name"
label="任务名称">
</el-table-column>
<el-table-column
align="center"
prop="run"
label="是否有效">
<template slot-scope="scope">
<el-tag size="mini" effect="dark" type="success" v-if="scope.row.run">运行</el-tag>
<el-tag size="mini" effect="dark" type="danger" v-if="!scope.row.run">暂停</el-tag>
</template>
</el-table-column>
<el-table-column
align="center"
fixed="right"
width="120"
label="操作">
<template slot-scope="scope">
<wb-dropdown :arg="scope.row">
<wb-dropdown-item value="编辑" icon="el-icon-edit" @click="onEdit"></wb-dropdown-item>
<wb-dropdown-item value="删除" icon="el-icon-delete" @click="onDelete"></wb-dropdown-item>
</wb-dropdown>
</template>
</el-table-column>
</el-table>
</el-card>
</div>
<script>
var app = new Vue({
mixins: [mixin],
@ -76,7 +143,7 @@
},
},
mounted: function () {
this.onFind();
}
})
</script>

Loading…
Cancel
Save

Powered by TurnKey Linux.