SpringBoot2.0整合Quartz实现动态设置定时任务时间
作者：互联网
一. 引入依赖
<!-- 引入quartz依赖 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>二. Quartz配置类
package com.example.demo.quartztask;
import org.quartz.JobDetail;
import org.quartz.spi.JobFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import java.io.IOException;
/**
* @program: demo
* @description: quartz动态定时任务配置类
* @author: guoxu
* @create: 2019-12-31 09:43
*/
@Configuration
public class SchedulerConfig {
@Bean
public JobFactory jobFactory(ApplicationContext applicationContext) {
SpringBeanJobFactory jobFactory = new SpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
/**调度工厂bean
* @param jobFactory
* @throws IOException
*/
@Bean
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws IOException {
SchedulerFactoryBean factory = new SchedulerFactoryBean();
factory.setJobFactory(jobFactory);
//QuartzScheduler 延时启动，应用启动完5秒后 QuartzScheduler 再启动
factory.setStartupDelay(5);
// this allows to update triggers in DB when updating settings in config file:
//用于quartz集群,QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
// factory.setOverwriteExistingJobs(true);
//用于quartz集群,加载quartz数据源
// factory.setDataSource(dataSource);
//用于quartz集群,加载quartz数据源配置
// factory.setQuartzProperties(quartzProperties());
//注册触发器
//factory.setTriggers(cronJobTrigger);
return factory;
}
/**加载quartz数据源配置,quartz集群时用到
* @return
* @throws IOException
*/
// @Bean
// public Properties quartzProperties() throws IOException {
// PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
// propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
// propertiesFactoryBean.afterPropertiesSet();
// return propertiesFactoryBean.getObject();
// }
/**
* 创建触发器工厂
* @param jobClass
* @return
*/
private static JobDetailFactoryBean createJobDetail(Class jobClass) {
JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
factoryBean.setJobClass(jobClass);
factoryBean.setDurability(true);
return factoryBean;
}
/**创建定时器工厂
* @param jobDetail
* @return
*/
private static CronTriggerFactoryBean createTrigger(JobDetail jobDetail) {
CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
factoryBean.setJobDetail(jobDetail);
factoryBean.setStartDelay(0L);
factoryBean.setCronExpression ("0/5 * * * * ? ");//每5秒执行一次
return factoryBean;
}
}
三. MgrScheduleJob定时任务实体类
数据库SQL：
CREATE TABLE `t_schedule_job` (
`ID` char(32) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '任务主键',
`TASK_NAME` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务名称',
`TASK_GROUP` char(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务分组',
`CLASS_NAME` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'class类名称地址',
`DESCRIPTION` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '任务描述',
`CRON_EXPRESSION` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '时间设置（定时器时间格式）',
`TASK_STATUS` int(1) NULL DEFAULT NULL COMMENT '0: 执行 1: 暂停',
`IS_ENABLE` int(1) NULL DEFAULT NULL COMMENT '0：启用 1：停用',
`UPDATE_TIME` datetime(6) NULL DEFAULT NULL COMMENT '更新时间',
`CREATE_TIME` datetime(6) NULL DEFAULT NULL COMMENT '创建时间',
`CREATE_USER` varchar(32) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '创建人',
PRIMARY KEY (`ID`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;实体类：
package com.example.demo.domin;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.nutz.dao.entity.annotation.*;
import java.io.Serializable;
import java.util.Date;
/**
* @Description
* @Author GuoXu
* @Date 2019-12-31
*/
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table ( "t_schedule_job" )
public class MgrScheduleJob implements Serializable {
private static final long serialVersionUID = 515061450646512139L;
/**
* 任务主键
*/
@Name
@Prev(els = @EL("uuid(32)"))
@Column("ID" )
private String id;
/**
* 任务名称
*/
@Column("TASK_NAME" )
private String taskName;
/**
* 任务分组
*/
@Column("TASK_GROUP" )
private String taskGroup;
/**
* class类名称地址
*/
@Column("CLASS_NAME" )
private String className;
/**
* 任务描述
*/
@Column("DESCRIPTION")
private String description;
/**
* 时间设置（定时器时间格式）
*/
@Column("CRON_EXPRESSION" )
private String cronExpression;
/**
* 0:执行 1:暂停
*/
@Column("TASK_STATUS" )
private Integer taskStatus;
/**
* 0:启用 1:停用
*/
@Column("IS_ENABLE")
private Integer isEnable;
/**
* 更新时间
*/
@Column("UPDATE_TIME" )
private Date updateTime;
/**
* 创建时间
*/
@Column("CREATE_TIME" )
private Date createTime;
/**
* 创建人
*/
@Column("CREATE_USER" )
private String createUser;
}
四. Quartz定时任务方法类
这里是为了更好的区分业务逻辑，故分为定时任务基础方法类，和定时任务控制实现方法类
以下的IBaseService和BaseService类，是基于nutzDao的curd方法进行了再封装，想详细了解的可以看我的另外一篇文章
接口：
package com.example.demo.quartztask;
import com.example.demo.base.IBaseService;
import com.example.demo.domin.MgrScheduleJob;
import org.quartz.SchedulerException;
import java.util.List;
/**
* @program: demo
* @description: quartz定时任务Service
* @author: guoxu
* @create: 2019-12-31 10:21
*/
public interface IJobAndTriggerService extends IBaseService<MgrScheduleJob> {
/**
* 新增任务
* @param scheduleJob
* @throws Exception
*/
void addOrUpdateJob(MgrScheduleJob scheduleJob) throws Exception;
/**
* Scheduler 删除定时任务
* @param scheduleJob
* @throws Exception
*/
void stopJob(MgrScheduleJob scheduleJob) throws SchedulerException;
/**
* Scheduler 暂停定时任务
* @param scheduleJob
* @throws Exception
*/
void pauseJob(MgrScheduleJob scheduleJob) throws SchedulerException;
/**
* Scheduler 恢复定时任务
* @param scheduleJob
* @throws Exception
*/
void resumejob(MgrScheduleJob scheduleJob) throws SchedulerException;
/**
* 立即执行一个job
* @param scheduleJob
* @throws SchedulerException
*/
void runAJobNow(MgrScheduleJob scheduleJob) throws SchedulerException;
/**
* 获取所有计划中的任务列表
* @return
* @throws SchedulerException
*/
List<MgrScheduleJob> getAllJob() throws SchedulerException;
/**
* 获取所有执行中的任务列表
* @return
* @throws SchedulerException
*/
List<MgrScheduleJob> getRunningJob() throws SchedulerException;
/**
* 暂停所有任务
* @throws SchedulerException
*/
void pauseAllJobs() throws SchedulerException;
/**
* 恢复所有任务
* @throws SchedulerException
*/
void resumeAllJobs() throws SchedulerException;
}
实现：
package com.example.demo.quartztask;
import com.example.demo.base.BaseServiceImpl;
import com.example.demo.domin.MgrScheduleJob;
import lombok.extern.slf4j.Slf4j;
import org.nutz.dao.Cnd;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
/**
* @program: demo
* @description: quartz定时任务实现类
* @author: guoxu
* @create: 2019-12-31 10:45
*/
/**
* Scheduler：调度器，进行任务调度；quartz的大脑
* Job：业务job，亦可称业务组件；定时任务的具体执行业务需要实现此接口，调度器会调用此接口的execute方法完成我们的定时业务
* JobDetail：用来定义业务Job的实例，我们可以称之为quartz job，很多时候我们谈到的job指的是JobDetail
* Trigger：触发器，用来定义一个指定的Job何时被执行
* JobBuilder：Job构建器，用来定义或创建JobDetail的实例；JobDetail限定了只能是Job的实例
* TriggerBuilder：触发器构建器，用来定义或创建触发器的实例
*/
@Slf4j
@Service
public class JobAndTriggerServiceImpl extends BaseServiceImpl<MgrScheduleJob> implements IJobAndTriggerService{
@Autowired
private SchedulerFactoryBean schedulerFactoryBean;
/**
* 被@PostConstruct修饰的方法会在服务器加载Servlet的时候运行，并且只会被服务器执行一次。
* @throws Exception
*/
@PostConstruct
public void init() {
// 这里获取任务信息数据
List<MgrScheduleJob> jobList = nutzDao.query(MgrScheduleJob.class, Cnd.where("isEnable", "=", 0));
jobList.forEach(job -> {
try {
if (job.getTaskStatus() == 1){
job.setTaskStatus(0);
nutzDao.update(job);
}
addOrUpdateJob(job);
} catch (Exception e) {
e.printStackTrace();
log.error("初始化定时任务列表异常->{}",e.getMessage());
}
});
}
@Override
public void addOrUpdateJob(MgrScheduleJob mgrScheduleJob) throws Exception {
//获去调度器实例
Scheduler scheduler = schedulerFactoryBean.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(mgrScheduleJob.getTaskName(), mgrScheduleJob.getTaskGroup());
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//trigger不存在，创建一个
if (null == trigger) {
//新增定时任务
Class clazz = Class.forName(mgrScheduleJob.getClassName());
//判断clazz是否为null，是则抛出异常
Assert.notNull(clazz, "定时任务执行类为NULL");
//初始化一个类，生成一个实例
clazz.newInstance();
// 构建job信息
JobDetail jobDetail = JobBuilder.newJob(clazz)
.withIdentity(mgrScheduleJob.getTaskName(),mgrScheduleJob.getTaskGroup()).build();
// 表达式调度构建器(即任务执行的时间)
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(mgrScheduleJob.getCronExpression());
// 按新的cronExpression表达式构建一个新的trigger
trigger = TriggerBuilder.newTrigger().withIdentity(mgrScheduleJob.getTaskName(),mgrScheduleJob.getTaskGroup())
.withSchedule(scheduleBuilder).build();
//设置job执行
scheduler.scheduleJob(jobDetail, trigger);
} else {
// Trigger已存在，那么更新相应的定时设置
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(mgrScheduleJob.getCronExpression());
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
}
}
@Override
public void stopJob(MgrScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getTaskName(), scheduleJob.getTaskGroup());
scheduler.deleteJob(jobKey);
}
@Override
public void pauseJob(MgrScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getTaskName(), scheduleJob.getTaskGroup());
scheduler.pauseJob(jobKey);
}
@Override
public void resumejob(MgrScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getTaskName(), scheduleJob.getTaskGroup());
scheduler.resumeJob(jobKey);
}
@Override
public void runAJobNow(MgrScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getTaskName(), scheduleJob.getTaskGroup());
scheduler.triggerJob(jobKey);
}
@Override
public List<MgrScheduleJob> getAllJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
List<MgrScheduleJob> jobList = new ArrayList<MgrScheduleJob>();
GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
jobKeys.forEach(jobKey -> {
List<? extends Trigger> triggers = null;
try {
triggers = scheduler.getTriggersOfJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
if (triggers != null) {
triggers.forEach(trigger -> {
MgrScheduleJob job = new MgrScheduleJob();
job.setTaskName(jobKey.getName());
job.setTaskGroup(jobKey.getGroup());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
});
}
});
return jobList;
}
@Override
public List<MgrScheduleJob> getRunningJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
List<MgrScheduleJob> jobList = new ArrayList<MgrScheduleJob>(executingJobs.size());
for (JobExecutionContext executingJob : executingJobs) {
MgrScheduleJob job = new MgrScheduleJob();
JobDetail jobDetail = executingJob.getJobDetail();
JobKey jobKey = jobDetail.getKey();
job.setTaskName(jobKey.getName());
job.setTaskGroup(jobKey.getGroup());
Trigger trigger = executingJob.getTrigger();
// Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
return jobList;
}
@Override
public void pauseAllJobs() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
scheduler.pauseAll();
}
@Override
public void resumeAllJobs() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
scheduler.resumeAll();
}
}
五. MgrScheduleJob定时任务控制Service类
接口：
package com.example.demo.quartztask;
import com.example.demo.base.IBaseService;
import com.example.demo.domin.MgrScheduleJob;
/**
* @program: demo
* @description: 定时任务实体Service类
* @author: guoxu
* @create: 2019-12-31 14:48
*/
public interface IScheduleJobService extends IBaseService<MgrScheduleJob> {
/**
* 添加或新增定时任务
* @param mgrScheduleJob
* @throws Exception
*/
void addOrUpdateScheduleJob(MgrScheduleJob mgrScheduleJob) throws Exception;
/**
* 修改定时任务启用状态 0 启用 1 停用
* @param id
* @throws Exception
*/
void isEnableScheduleJob(String id) throws Exception;
/**
* 暂停/恢复 定时任务
* @param id
* @throws Exception
*/
void pauseScheduleJob(String id) throws Exception;
/**
* 删除定时任务
* @param id
* @throws Exception
*/
void deleteScheduleJob(String id) throws Exception;
/**
* 立即运行定时任务
* @param id
* @throws Exception
*/
void runScheduleJob(String id) throws Exception;
}
实现：
package com.example.demo.quartztask;
import com.example.demo.base.BaseServiceImpl;
import com.example.demo.domin.MgrScheduleJob;
import com.example.demo.utils.StringUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Date;
/**
* @program: demo
* @description: 定时任务Service实现类
* @author: guoxu
* @create: 2019-12-31 15:17
*/
@Service
public class ScheduleJobServiceImpl extends BaseServiceImpl<MgrScheduleJob> implements IScheduleJobService {
@Autowired
private IJobAndTriggerService jobAndTriggerService;
@Override
public void addOrUpdateScheduleJob(MgrScheduleJob mgrScheduleJob) throws Exception {
if (StringUtil.isNotEmpty(mgrScheduleJob.getId())){
//更新任务
mgrScheduleJob.setTaskStatus(0);
mgrScheduleJob.setIsEnable(0);
mgrScheduleJob.setUpdateTime(new Date());
update(mgrScheduleJob);
}else {
//新增任务
mgrScheduleJob.setTaskStatus(0);
mgrScheduleJob.setIsEnable(0);
mgrScheduleJob.setCreateTime(new Date());
mgrScheduleJob.setUpdateTime(new Date());
add(mgrScheduleJob);
}
jobAndTriggerService.addOrUpdateJob(mgrScheduleJob);
}
@Override
public void isEnableScheduleJob(String id) throws Exception {
MgrScheduleJob mgrScheduleJob = load(id);
if (mgrScheduleJob.getIsEnable() == 0){
//停用任务
mgrScheduleJob.setIsEnable(1);
update(mgrScheduleJob);
jobAndTriggerService.stopJob(mgrScheduleJob);
}else if (mgrScheduleJob.getIsEnable() == 1){
//启用任务
mgrScheduleJob.setIsEnable(0);
update(mgrScheduleJob);
jobAndTriggerService.addOrUpdateJob(mgrScheduleJob);
}
}
@Override
public void pauseScheduleJob(String id) throws Exception {
MgrScheduleJob mgrScheduleJob = load(id);
if (mgrScheduleJob.getTaskStatus() == 0){
//暂停任务
mgrScheduleJob.setTaskStatus(1);
update(mgrScheduleJob);
jobAndTriggerService.pauseJob(mgrScheduleJob);
}else if (mgrScheduleJob.getTaskStatus() == 1){
//执行任务
mgrScheduleJob.setTaskStatus(0);
update(mgrScheduleJob);
jobAndTriggerService.resumejob(mgrScheduleJob);
}
}
@Override
public void deleteScheduleJob(String id) throws Exception {
MgrScheduleJob mgrScheduleJob = load(id);
jobAndTriggerService.stopJob(mgrScheduleJob);
deleteById(id);
}
@Override
public void runScheduleJob(String id) throws Exception {
jobAndTriggerService.runAJobNow(load(id));
}
}
六. 定时任务控制接口调用ScheduleJobController
package com.example.demo.quartztask;
import com.example.demo.domin.MgrScheduleJob;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* @program: demo
* @description: 定时任务Controller
* @author: guoxu
* @create: 2019-12-31 16:53
*/
@Api(tags = "定时任务管理模块",description = "ScheduleJobController")
@Slf4j
@RestController
@RequestMapping("sys/schedule")
public class ScheduleJobController {
@Autowired
private IScheduleJobService scheduleJobService;
@ApiOperation("添加或更新定时任务")
@PostMapping("add")
public String addOrUpdate(@RequestBody MgrScheduleJob mgrScheduleJob){
try {
scheduleJobService.addOrUpdateScheduleJob(mgrScheduleJob);
return "定时任务添加或更新成功";
} catch (Exception e) {
log.error("定时任务新增或更新失败==>【{}】",e.getMessage());
return "定时任务添加或更新失败";
}
}
@ApiOperation("删除定时任务")
@PostMapping("delete")
public String delete(@ApiParam(value = "",required = true) @RequestParam String id){
try {
scheduleJobService.deleteScheduleJob(id);
return "删除定时任务成功";
} catch (Exception e) {
log.error("删除定时任务失败==>【{}】",e.getMessage());
return "删除定时任务失败";
}
}
@ApiOperation("启用或停用定时任务")
@PostMapping("isEnable")
public String isEnable(@ApiParam(value = "",required = true) @RequestParam String id){
try {
scheduleJobService.isEnableScheduleJob(id);
return "启用或停用定时任务成功";
} catch (Exception e) {
log.error("启用或停用定时任务失败==>【{}】",e.getMessage());
return "启用或停用定时任务失败";
}
}
@ApiOperation("暂停或执行定时任务")
@PostMapping("pauseJob")
public String pauseJob(@ApiParam(value = "",required = true) @RequestParam String id){
try {
scheduleJobService.pauseScheduleJob(id);
return "暂停或执行定时任务成功";
} catch (Exception e) {
log.error("暂停或执行定时任务失败==>【{}】",e.getMessage());
return "暂停或执行定时任务失败";
}
}
}
七. 创建定时任务执行类
自定义定时任务执行类须继承QuartzJobBean：
package com.example.demo.quartztask.job;
import com.example.demo.utils.DateUtil;
import lombok.extern.slf4j.Slf4j;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
/**
* @program: demo
* @description: 测试定时任务类
* @author: guoxu
* @create: 2019-12-31 10:13
*
* QuartzJobBean implements Job
*/
@Slf4j
public class TestSchedulerJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
log.info("执行测试定时任务==>【{}】", DateUtil.getTodayTimeString());
}
}
新增定时任务SQL示例：
-- ----------------------------
-- Records of t_schedule_job
-- ----------------------------
INSERT INTO `t_schedule_job` VALUES ('rl857upqqsgdio86kpdnmuf95b', '测试任务', 'test', 'com.example.demo.quartztask.job.TestSchedulerJob', '测试创建的定时任务', '0/5 * * * * ?', 0, 1, '2019-12-31 18:50:26.674000', '2019-12-31 18:50:26.674000', 'admin');来源：站长平台
标签：Quartz,SpringBoot2.0,public,mgrScheduleJob,任务,import,定时,throws 来源： https://www.cnblogs.com/1994july/p/12163935.html