DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;
CREATE TABLE QRTZ_JOB_DETAILS
(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);
CREATE TABLE QRTZ_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);
CREATE TABLE QRTZ_SIMPLE_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
CREATE TABLE QRTZ_CRON_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
CRON_EXPRESSION VARCHAR(200) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
CREATE TABLE QRTZ_SIMPROP_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
STR_PROP_1 VARCHAR(512) NULL,
STR_PROP_2 VARCHAR(512) NULL,
STR_PROP_3 VARCHAR(512) NULL,
INT_PROP_1 INT NULL,
INT_PROP_2 INT NULL,
LONG_PROP_1 BIGINT NULL,
LONG_PROP_2 BIGINT NULL,
DEC_PROP_1 NUMERIC(13,4) NULL,
DEC_PROP_2 NUMERIC(13,4) NULL,
BOOL_PROP_1 VARCHAR(1) NULL,
BOOL_PROP_2 VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
CREATE TABLE QRTZ_BLOB_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
CREATE TABLE QRTZ_CALENDARS
(
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);
CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);
CREATE TABLE QRTZ_FIRED_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);
CREATE TABLE QRTZ_SCHEDULER_STATE
(
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);
CREATE TABLE QRTZ_LOCKS
(
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);
commit;
CREATE TABLE schedule_job(
id int(11) not null PRIMARY KEY AUTO_INCREMENT,
job_name varchar(50) not null COMMENT '任务名称',
job_group varchar(50) not null COMMENT '任务组',
job_status int(1) COMMENT '0:待运行, 1:运行, 2:暂停',
cron_expression varchar(100) COMMENT 'cron表达式',
bean_name varchar(50) COMMENT '注入容器中的beanName',
bean_class varchar(100) COMMENT '包名+类名',
method_name varchar(50) COMMENT '任务调用的方法名',
parameter_types varchar(100) COMMENT '方法参数类型',
params varchar(100) COMMENT '方法实参',
job_msg varchar(200) COMMENT '备注',
create_time timestamp,
update_time timestamp
)
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="configLocation" value="classpath:config/quartz.properties"/>
</bean>
# 固定前缀org.quartz
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
#持久化
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.dataSource = qzDS
org.quartz.jobStore.misfireThreshold = 5000
org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL = jdbc:mysql://127.0.0.1:3306/test?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&useSSL=false&zeroDateTimeBehavior=convertToNull
org.quartz.dataSource.qzDS.user = test
org.quartz.dataSource.qzDS.password = test
org.quartz.dataSource.qzDS.maxConnections = 10
/**
*
* @date 2020-02-19 16:11
*/
@Service
public class QuartzTaskServiceImplimplements IQuartzTaskService {
private static Loggerlog = LoggerFactory.getLogger(QuartzTaskServiceImpl.class);
@Autowired
private SchedulerFactoryBeanschedulerFactoryBean;
/***
* 添加任务
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void addTask(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl addTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
CronTrigger trigger = (CronTrigger)scheduler.getTrigger(triggerKey);
JobDetail jobDetail = JobBuilder.newJob(JobFactory.class).withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup()).build();
jobDetail.getJobDataMap().put("scheduleJob", scheduleJob);
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
trigger = TriggerBuilder.newTrigger().withIdentity(scheduleJob.getJobName(), scheduleJob.getJobGroup())
.withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
}
/***
* 暂停任务
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void pauseTask(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl pauseTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.pauseJob(jobKey);
}
/***
* 恢复任务
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void resumeTask(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl resumeTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.resumeJob(jobKey);
}
/***
* 删除任务，先暂停触发器，在暂停任务的执行，最后删除
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void deleteTask(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl deleteTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
scheduler.pauseTrigger(TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup()));
scheduler.unscheduleJob(TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup()));
scheduler.deleteJob(JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup()));
}
/***
* 立即运行任务
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void runTaskNow(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl runTaskNow");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
JobDataMap jobDataMap =new JobDataMap();
jobDataMap.put("scheduleJob", scheduleJob);
scheduler.triggerJob(jobKey, jobDataMap);
}
/***
* 更新任务的cron表达式
* @date 2020/2/20
* @param scheduleJob
**/
@Override
public void updateTaskCron(ScheduleJob scheduleJob)throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl updateTaskCron");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
//获取触发器key
TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
//获取触发器
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//创建新的表达式
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
trigger.getJobDataMap().put("scheduleJob", scheduleJob);
//更新触发器的表达式
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(cronScheduleBuilder).build();
//重新执行任务
scheduler.rescheduleJob(triggerKey, trigger);
}
/***
* 获取所有任务
* @date 2020/2/20
**/
@Override
public ListgetAllTask()throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl getAllTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
GroupMatcher matcher = GroupMatcher.anyJobGroup();
Set jobKeys = scheduler.getJobKeys(matcher);
List jobList =new ArrayList();
for (JobKey jobKey : jobKeys) {
List triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
ScheduleJob job =new ScheduleJob();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setJobMsg("触发器:" + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(Integer.valueOf(triggerState.name()));
if (triggerinstanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
}
return jobList;
}
/***
* 获取正在运行的任务
* @date 2020/2/20
**/
@Override
public ListgetRunningTask()throws SchedulerException {
log.info("<<<<<<<=====QuartzTaskServiceImpl getRunningTask");
Scheduler scheduler =schedulerFactoryBean.getScheduler();
List executingJobs = scheduler.getCurrentlyExecutingJobs();
List jobList =new ArrayList(executingJobs.size());
for (JobExecutionContext executingJob : executingJobs) {
ScheduleJob job =new ScheduleJob();
JobDetail jobDetail = executingJob.getJobDetail();
JobKey jobKey = jobDetail.getKey();
Trigger trigger = executingJob.getTrigger();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setJobMsg("触发器:" + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(Integer.valueOf(triggerState.name()));
if (triggerinstanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
return jobList;
}
}
/**
* @date 2020-02-20 11:31
*/
@Service
public class ScheduleJobServiceImplimplements IScheduleJobService {
private static Loggerlog = LoggerFactory.getLogger(ScheduleJobServiceImpl.class);
@Autowired
private IQuartzTaskServiceiQuartzTaskService;
@Autowired
private ScheduleJobDaoscheduleJobDao;
@Override
@Transactional(rollbackFor = Exception.class)
public void addJob(ScheduleJobDto scheduleJobDto)throws Exception {
log.info("============ScheduleJobServiceImpl addJob start=========");
validateOperate(scheduleJobDto);
ScheduleJobExample example =new ScheduleJobExample();
ScheduleJobExample.Criteria criteria = example.createCriteria();
criteria.andJobNameEqualTo(scheduleJobDto.getJobName())
.andJobGroupEqualTo(scheduleJobDto.getJobGroup());
List scheduleJobs =scheduleJobDao.selectByExample(example);
if (scheduleJobs !=null && scheduleJobs.size() >0) {
throw new Exception("创建失败，已经存在" + scheduleJobDto.getJobName() +"和" + scheduleJobDto.getJobGroup());
}
ScheduleJob scheduleJob =new ScheduleJob();
BeanCopierUtil.copy(scheduleJobDto, scheduleJob);
scheduleJob.setJobStatus(ScheduleJobEnum.STOP.getStatus());
scheduleJob.setCreateTime(new Date());
scheduleJob.setUpdateTime(new Date());
scheduleJobDao.insertSelective(scheduleJob);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void startJob(Integer id)throws Exception {
log.info("============ScheduleJobServiceImpl startJob start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(id);
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
if (ScheduleJobEnum.RUNNING.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务正在运行, 无需启动");
}else if (ScheduleJobEnum.PAUSE.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务已经暂停, 请选择重新启动");
}
scheduleJob.setJobStatus(ScheduleJobEnum.RUNNING.getStatus());
scheduleJob.setUpdateTime(new Date());
scheduleJobDao.updateByPrimaryKeySelective(scheduleJob);
iQuartzTaskService.addTask(scheduleJob);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void pauseJob(Integer id)throws Exception {
log.info("============ScheduleJobServiceImpl pauseJob start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(id);
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
if (ScheduleJobEnum.STOP.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务还未启动过");
}
scheduleJob.setJobStatus(ScheduleJobEnum.PAUSE.getStatus());
scheduleJob.setUpdateTime(new Date());
scheduleJobDao.updateByPrimaryKeySelective(scheduleJob);
iQuartzTaskService.pauseTask(scheduleJob);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void resumeJob(Integer id)throws Exception {
log.info("============ScheduleJobServiceImpl resumeJob start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(id);
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
if (ScheduleJobEnum.STOP.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务还未启动过");
}else if (ScheduleJobEnum.RUNNING.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务正在运行, 无需重新启动");
}
scheduleJob.setJobStatus(ScheduleJobEnum.RUNNING.getStatus());
scheduleJob.setUpdateTime(new Date());
scheduleJobDao.updateByPrimaryKeySelective(scheduleJob);
iQuartzTaskService.resumeTask(scheduleJob);
}
@Override
@Transactional(rollbackFor = Exception.class)
public void deleteJob(Integer id)throws Exception {
log.info("============ScheduleJobServiceImpl deleteJob start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(id);
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
scheduleJobDao.deleteByPrimaryKey(scheduleJob.getId());
if (!ScheduleJobEnum.STOP.getStatus().equals(scheduleJob.getJobStatus())) {
iQuartzTaskService.deleteTask(scheduleJob);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void updateJob(ScheduleJobDto scheduleJobDto)throws Exception {
log.info("============ScheduleJobServiceImpl updateJob start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(scheduleJobDto.getId());
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
validateOperate(scheduleJobDto);
ScheduleJob vo =new ScheduleJob();
BeanCopierUtil.copy(scheduleJobDto, vo);
vo.setUpdateTime(new Date());
scheduleJobDao.updateByPrimaryKeySelective(vo);
scheduleJob =scheduleJobDao.selectByPrimaryKey(scheduleJobDto.getId());
if (!ScheduleJobEnum.STOP.getStatus().equals(scheduleJob.getJobStatus())) {
iQuartzTaskService.updateTaskCron(scheduleJob);
}
}
@Override
@Transactional(rollbackFor = Exception.class)
public void runJobNow(Integer id)throws Exception {
log.info("============ScheduleJobServiceImpl runTaskNow start=========");
ScheduleJob scheduleJob =scheduleJobDao.selectByPrimaryKey(id);
if (scheduleJob ==null) {
throw new Exception("没有该任务!");
}
if (ScheduleJobEnum.STOP.getStatus().equals(scheduleJob.getJobStatus())) {
throw new Exception("该任务还未启动过");
}
scheduleJob.setUpdateTime(new Date());
scheduleJobDao.updateByPrimaryKeySelective(scheduleJob);
iQuartzTaskService.runTaskNow(scheduleJob);
}
@Override
public PageViewgetAllJob(long page, long pageSize, String jobName) {
log.info("============ScheduleJobServiceImpl getAllJob start=========");
PageView pv =new PageView<>(page,pageSize);
int count =0;
try {
pv.setRecords(null);
pv.setTotalrecord(count);
if (StringUtils.isNotBlank(jobName)) {
ScheduleJobExample example =new ScheduleJobExample();
ScheduleJobExample.Criteria criteria = example.createCriteria();
criteria.andJobNameEqualTo(jobName);
count =scheduleJobDao.countByExample(example);
}else {
count =scheduleJobDao.countByExample(null);
}
if (count <=0) {
return pv;
}
pv.setTotalrecord(count);
}catch (Exception e) {
log.error("select schedule count error:" + e);
return pv;
}
Map paramMap =new HashMap<>();
paramMap.put("start", pv.getFirstResult());
paramMap.put("pageSize", pageSize);
paramMap.put("jobName", jobName);
List list =null;
try {
list =scheduleJobDao.selectAll(paramMap);
List resultList =new ArrayList<>();
ScheduleJobDto scheduleJobDto =null;
for (ScheduleJob scheduleJob : list) {
scheduleJobDto =new ScheduleJobDto();
BeanCopierUtil.copy(scheduleJob, scheduleJobDto);
resultList.add(scheduleJobDto);
}
pv.setRecords(resultList);
return pv;
}catch (Exception e) {
log.error("select schedule data error:" + e);
return pv;
}
}
private void validateOperate(ScheduleJobDto dto)throws Exception {
if(StringUtils.isBlank(dto.getJobName())) {
throw new Exception("任务名称不能为空!");
}else if (StringUtils.isBlank(dto.getJobGroup())) {
throw new Exception("任务组不能为空!");
}else if (StringUtils.isBlank(dto.getBeanClass()) && StringUtils.isBlank(dto.getBeanName())) {
throw new Exception("BeanClass与BeanName不能都为空!");
}if (StringUtils.isNotBlank(dto.getBeanClass()) && StringUtils.isNotBlank(dto.getBeanName())) {
throw new Exception("BeanClass与BeanName只能填写其中一个!");
}else if (StringUtils.isBlank(dto.getCronExpression())) {
throw new Exception("cron表达式不能为空!");
}else if (StringUtils.isBlank(dto.getMethodName())) {
throw new Exception("方法名不能为空!");
}
}
}
/**定时任务控制层
* @date 2020-02-20 17:56
*/
@Controller
@RequestMapping("/schedule")
public class ScheduleControllerextends BaseController{
private static final Loggerlog = LoggerFactory.getLogger(ScheduleController.class);
@Autowired
private IScheduleJobServiceiScheduleJobService;
private final static IntegerPARAM_ERROR_CODE =999;
@RequestMapping("/addJob")
@ResponseBody
public HttpResponseaddJob(@RequestBody ScheduleJobDto scheduleJobDto) {
log.info("ScheduleController addJob scheduleJobDto={}" + JSON.toJSONString(scheduleJobDto));
if (scheduleJobDto ==null) {
log.info("addJob 参数不能都为空");
return new HttpResponse(false, "参数不能都为空" , PARAM_ERROR_CODE);
}
try {
iScheduleJobService.addJob(scheduleJobDto);
}catch (Exception e) {
log.error("addJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/startJob")
@ResponseBody
public HttpResponsestartJob(@RequestParam Integer id) {
log.info("ScheduleController startJob id={}", id);
try {
iScheduleJobService.startJob(id);
}catch (Exception e) {
log.error("startJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/pauseJob")
@ResponseBody
public HttpResponsepauseJob(@RequestParam Integer id) {
log.info("ScheduleController pauseJob id={}", id);
try {
iScheduleJobService.pauseJob(id);
}catch (Exception e) {
log.error("pauseJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/resumeJob")
@ResponseBody
public HttpResponseresumeJob(@RequestParam Integer id) {
log.info("ScheduleController resumeJob id={}", id);
try {
iScheduleJobService.resumeJob(id);
}catch (Exception e) {
log.error("resumeJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/deleteJob")
@ResponseBody
public HttpResponsedeleteJob(@RequestParam Integer id) {
log.info("ScheduleController deleteJob id={}", id);
try {
iScheduleJobService.deleteJob(id);
}catch (Exception e) {
log.error("deleteJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/runJobNow")
@ResponseBody
public HttpResponserunJobNow(@RequestParam Integer id) {
log.info("ScheduleController runTaskNow id={}", id);
try {
iScheduleJobService.runJobNow(id);
}catch (Exception e) {
log.error("runTaskNow error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/updateJob")
@ResponseBody
public HttpResponseupdateJob(@RequestBody ScheduleJobDto scheduleJobDto) {
log.info("ScheduleController runTaskNow scheduleJobDto={}", JSON.toJSONString(scheduleJobDto));
try {
iScheduleJobService.updateJob(scheduleJobDto);
}catch (Exception e) {
log.error("updateJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS);
}
@RequestMapping("/getAllJob")
@ResponseBody
public HttpResponsegetAllJob(HttpServletRequest request) {
try {
final long page = getLongParam(request,"page", 1L);
final long pageSize = getLongParam(request,"pageSize", CommonConstant.DEFAULT_PAGESIZE);
final String jobName = getStrParam(request,"jobName", null);
log.info("ScheduleController runTaskNow page={}, pageSize={}", page, pageSize );
PageView allJob =iScheduleJobService.getAllJob(page, pageSize, jobName);
return HttpResponse.newHttpResponse(OperateEnum.SUCCESS, allJob);
}catch (Exception e) {
log.error("getAllJob error:" + e);
return new HttpResponse(false, e.getMessage(), PARAM_ERROR_CODE);
}
}
}
public class JobFactoryimplements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext)throws JobExecutionException {
ScheduleJob scheduleJob = (ScheduleJob)jobExecutionContext.getMergedJobDataMap().get("scheduleJob");
TaskUtil.invokMethod(scheduleJob);
}
}
public class TaskUtil {
private static Loggerlog = LoggerFactory.getLogger(TaskUtil.class);
public static void invokMethod(ScheduleJob scheduleJob) {
if (StringUtils.isBlank(scheduleJob.getMethodName())) {
log.error("methodName is empty!");
return;
}
Class clazz =null;
Object object =null;
try {
if (StringUtils.isNotBlank(scheduleJob.getBeanClass())) {
clazz = Class.forName(scheduleJob.getBeanClass());
object = clazz.newInstance();
}
if (object ==null && StringUtils.isNotBlank(scheduleJob.getBeanName())) {
object = SpringContextUtil.getBean(scheduleJob.getBeanName());
clazz = object.getClass();
}
}catch (Exception e) {
log.error("newInstance fail" + e);
return;
}
if (object ==null) {
log.error("create object instance is empty!");
return;
}
Method method =null;
try {
Class[] parameterTypes =getParameterTypes(scheduleJob.getParameterTypes());
if (parameterTypes !=null) {
method = clazz.getMethod(scheduleJob.getMethodName(), parameterTypes);
Object[] params =getParams(scheduleJob.getParams());
if (params !=null) {
log.info("========methodName={},params={}, execute start========", scheduleJob.getMethodName(), scheduleJob.getParams());
method.invoke(object, params);
}else {
log.error("params in method is empty, methodName={}", scheduleJob.getMethodName());
return;
}
}else {
log.info("========methodName={}, execute start========", scheduleJob.getMethodName());
method = clazz.getMethod(scheduleJob.getMethodName());
method.invoke(object);
}
}catch (NoSuchMethodException e) {
log.error("no this methodName={}",scheduleJob.getMethodName());
return;
}catch (Exception e1) {
log.error("method execute error:" + e1);
return;
}
}
/***
* 获取参数类型数组
* @date 2020/2/20
* @param parameterTypes
**/
private static Class[]getParameterTypes(String parameterTypes) {
Class[] newParameterTypes =null;
if (StringUtils.isNotBlank(parameterTypes)) {
String[] str = parameterTypes.trim().split("\\|");
newParameterTypes =new Class[str.length];
for (int i =0; i < str.length; i++) {
newParameterTypes[i] = String.class;
}
}
return newParameterTypes;
}
/***
* 获取实参数组
* @date 2020/2/20
* @param parames
**/
private static Object[]getParams(String parames) {
Object[] newParames =null;
if (StringUtils.isNotBlank(parames)) {
String[] str = parames.trim().split("\\|");
newParames =new Object[str.length];
for (int i =0; i < str.length; i++) {
newParames[i] = str[i].trim();
}
}
return newParames;
}
}
