SpringBoot版本:2.0.4.RELEASE
redis版本:redis-5.0.3
JDK:1.8
工具:idea
版本管理:maven
quartz版本:2.2.1
前言
SpringCloud项目多实例部署中,调度中心需实现分布式调度。以避免自动任务重复执行。
实现过程
- 创建SpringBoot项目
- 添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.0.4.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>net.joelinn</groupId>
<artifactId>quartz-redis-jobstore</artifactId>
<version>1.1.13</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
- 配置jedis
参考:https://blog.csdn.net/qq_32486913/article/details/85253933 - 配置yml
org:
quartz:
jobStore:
class: net.joelinn.quartz.jobstore.RedisJobStore
host: 192.168.1.11:7000,192.168.1.11:7000,192.168.1.11:7000
misfireThreshold: 60000
password:
port: 7000
redisCluster: true
redisSentinel: true
masterGroupName: quartz_redis_
database: 0
keyPrefix: a_prefix_quartz_key_
lockTimeout: 30000
ssl: false
- 配置quartz
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import java.io.IOException;
import java.util.Properties;
@Configuration
public class SchedulerConfiguration {
@Value("${org.quartz.jobStore.class}")
private String jobStoreClass;
@Value("${org.quartz.jobStore.host}")
private String jobStoreHost;
@Value("${org.quartz.jobStore.misfireThreshold}")
private String jobStoreMisfireThreshold;
@Value("${org.quartz.jobStore.password}")
private String jobStorePassword;
@Value("${org.quartz.jobStore.port}")
private String jobStorePort;
@Value("${org.quartz.jobStore.redisCluster}")
private String jobStoreRedisCluster;
@Value("${org.quartz.jobStore.redisSentinel}")
private String jobStoreRedisSentinel;
@Value("${org.quartz.jobStore.masterGroupName}")
private String jobStoreMasterGroupName;
@Value("${org.quartz.jobStore.database}")
private String jobStoreDataBase;
@Value("${org.quartz.jobStore.keyPrefix}")
private String jobStoreKeyPrefix;
@Value("${org.quartz.jobStore.lockTimeout}")
private String jobStoreLockTimeout;
@Value("${org.quartz.jobStore.ssl}")
private String jobStoreSsl;
@Bean
public JobFactory jobFactory(ApplicationContext applicationContext) {
AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
@Bean
public Scheduler scheduler(SchedulerFactoryBean schedulerFactoryBean) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
scheduler.start();
return scheduler;
}
/**
*
* @param jobFactory
* @return
* @throws IOException
*/
@Bean
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws IOException {
SchedulerFactoryBean factory = new SchedulerFactoryBean();
factory.setOverwriteExistingJobs(true);
//设置自行启动
factory.setAutoStartup(true);
factory.setJobFactory(jobFactory);
factory.setQuartzProperties(quartzProperties());
return factory;
}
@Bean
public Properties quartzProperties() {
Properties prop = new Properties();
prop.put("org.quartz.jobStore.class", jobStoreClass);
prop.put("org.quartz.jobStore.host", jobStoreHost);
prop.put("org.quartz.jobStore.misfireThreshold", jobStoreMisfireThreshold);
prop.put("org.quartz.jobStore.password", jobStorePassword);
prop.put("org.quartz.jobStore.port", jobStorePort);
prop.put("org.quartz.jobStore.redisCluster", jobStoreRedisCluster);
prop.put("org.quartz.jobStore.redisSentinel", jobStoreRedisSentinel);
prop.put("org.quartz.jobStore.masterGroupName", jobStoreMasterGroupName);
prop.put("org.quartz.jobStore.database", jobStoreDataBase);
prop.put("org.quartz.jobStore.keyPrefix", jobStoreKeyPrefix);
prop.put("org.quartz.jobStore.lockTimeout", jobStoreLockTimeout);
prop.put("org.quartz.jobStore.ssl", jobStoreSsl);
return prop;
}
/**
* 配置JobFactory,为quartz作业添加自动连接支持
*/
public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
ApplicationContextAware {
private transient AutowireCapableBeanFactory beanFactory;
@Override
public void setApplicationContext(final ApplicationContext context) {
beanFactory = context.getAutowireCapableBeanFactory();
}
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
beanFactory.autowireBean(job);
return job;
}
}
}
- 创建实体
public class TaskInfo implements Serializable {
private int id = 0;
/**任务名称*/
private String jobName;
/**任务分组*/
private String jobGroup;
/**任务描述*/
private String jobDescription;
/**任务状态*/
private String jobStatus;
/**任务表达式*/
private String cronExpression;
private String createTime;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getJobDescription() {
return jobDescription;
}
public void setJobDescription(String jobDescription) {
this.jobDescription = jobDescription;
}
public String getJobStatus() {
return jobStatus;
}
public void setJobStatus(String jobStatus) {
this.jobStatus = jobStatus;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public String getCreateTime() {
return createTime;
}
public void setCreateTime(String createTime) {
this.createTime = createTime;
}
@Override
public String toString() {
return "TaskInfo{" +
"id=" + id +
", jobName='" + jobName + '\'' +
", jobGroup='" + jobGroup + '\'' +
", jobDescription='" + jobDescription + '\'' +
", jobStatus='" + jobStatus + '\'' +
", cronExpression='" + cronExpression + '\'' +
", createTime='" + createTime + '\'' +
'}';
}
- 创建service接口调用
import cn.ce.ebiz.framework.core.context.ContextHolder;
import cn.ce.ebiz.quartz.job.entity.TaskInfo;
import cn.ce.ebiz.quartz.job.util.ResponseCode;
import org.apache.commons.lang3.time.DateFormatUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
@RestController
@RequestMapping(value = "quartz")
public class TaskServiceImpl {
private Logger logger = LoggerFactory.getLogger(TaskServiceImpl.class);
@Autowired(required = false)
private Scheduler scheduler;
/**
* 所有任务列表
*/
@RequestMapping(value = "find")
public String list() {
List<TaskInfo> list = new ArrayList<>();
try {
for (String groupJob : scheduler.getJobGroupNames()) {
for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.<JobKey>groupEquals(groupJob))) {
List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
String cronExpression = "", createTime = "";
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
cronExpression = cronTrigger.getCronExpression();
createTime = cronTrigger.getDescription();
}
TaskInfo info = new TaskInfo();
info.setJobName(jobKey.getName());
info.setJobGroup(jobKey.getGroup());
info.setJobDescription(jobDetail.getDescription());
info.setJobStatus(triggerState.name());
info.setCronExpression(cronExpression);
info.setCreateTime(createTime);
list.add(info);
}
}
}
} catch (SchedulerException e) {
e.printStackTrace();
return ResponseCode.responsebodyErr();
}
return ResponseCode.responsebody(list);
}
/**
* 添加定时任务
*
* @param info
*/
@RequestMapping(value = "add")
@SuppressWarnings("unchecked")
public String addJob(TaskInfo info) {
String jobName = info.getJobName(),
jobGroup = info.getJobGroup(),
cronExpression = info.getCronExpression(),
jobDescription = info.getJobDescription(),
createTime = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
try {
if (checkExists(jobName, jobGroup)) {
logger.info("add job fail, job already exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
return ResponseCode.responsebodyErr("job already exist");
}
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
CronScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionDoNothing();
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withDescription(createTime).withSchedule(schedBuilder).build();
Class<? extends Job> clazz = (Class<? extends Job>) Class.forName(jobName);
JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobKey).withDescription(jobDescription).build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException | ClassNotFoundException e) {
logger.error("类名不存在或执行表达式错误,exception:{}", e.getMessage());
return ResponseCode.responsebodyErr("类名不存在或执行表达式错误");
}
return ResponseCode.responsebody();
}
/**
* 修改定时任务
*
* @param info
*/
@RequestMapping(value = "update")
public String edit(TaskInfo info) {
String jobName = info.getJobName(),
jobGroup = info.getJobGroup(),
cronExpression = info.getCronExpression(),
jobDescription = info.getJobDescription(),
createTime = DateFormatUtils.format(new Date(), "yyyy-MM-dd HH:mm:ss");
try {
if (!checkExists(jobName, jobGroup)) {
logger.info("edit job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
return ResponseCode.responsebodyErr("job is not exist");
}
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
JobKey jobKey = new JobKey(jobName, jobGroup);
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression).withMisfireHandlingInstructionDoNothing();
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withDescription(createTime).withSchedule(cronScheduleBuilder).build();
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
jobDetail.getJobBuilder().withDescription(jobDescription);
HashSet<Trigger> triggerSet = new HashSet<>();
triggerSet.add(cronTrigger);
scheduler.scheduleJob(jobDetail, triggerSet, true);
} catch (SchedulerException e) {
logger.error("类名不存在或执行表达式错误,exception:{}", e.getMessage());
return ResponseCode.responsebodyErr("类名不存在或执行表达式错误");
}
return ResponseCode.responsebody();
}
/**
* 删除定时任务
*
* @param jobName
*/
@RequestMapping(value = "delete")
public String delete(String jobName, String jobGroup) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (!checkExists(jobName, jobGroup)) {
logger.info("delete job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
return ResponseCode.responsebodyErr("job is not exist");
}
scheduler.pauseTrigger(triggerKey);
scheduler.unscheduleJob(triggerKey);
logger.info("delete job, triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
} catch (SchedulerException e) {
logger.error(e.getMessage());
return ResponseCode.responsebodyErr();
}
return ResponseCode.responsebody();
}
/**
* 暂停定时任务
*
* @param jobName
*/
@RequestMapping(value = "pause")
public String pause(String jobName, String jobGroup) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (!checkExists(jobName, jobGroup)) {
logger.info("pause job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
return ResponseCode.responsebodyErr("job is not exist");
}
scheduler.pauseTrigger(triggerKey);
logger.info("pause job success, triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
} catch (SchedulerException e) {
logger.error(e.getMessage());
return ResponseCode.responsebodyErr();
}
return ResponseCode.responsebody();
}
/**
* 重新开始任务
*
* @param jobName
*/
@RequestMapping(value = "resume")
public String resume(String jobName, String jobGroup) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (!checkExists(jobName, jobGroup)) {
logger.info("resume job fail, job is not exist, jobGroup:{}, jobName:{}", jobGroup, jobName);
return ResponseCode.responsebodyErr("job is not exist");
}
scheduler.resumeTrigger(triggerKey);
logger.info("resume job success,triggerKey:{},jobGroup:{}, jobName:{}", triggerKey, jobGroup, jobName);
} catch (SchedulerException e) {
logger.error(e.getMessage());
return ResponseCode.responsebodyErr();
}
return ResponseCode.responsebody();
}
/**
* 验证是否存在
*
* @param jobName
* @param jobGroup
* @throws SchedulerException
*/
@RequestMapping(value = "checkExists")
public boolean checkExists(String jobName, String jobGroup) throws SchedulerException {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
return scheduler.checkExists(triggerKey);
}
}
- 创建job
mport org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class ScheduledJobDemoOne implements Job {
private SimpleDateFormat dateFormat() {
return new SimpleDateFormat("HH:mm:ss");
}
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("ScheduledJobDemoOne-----,quartz ScheduledJobOne Tasks: " + dateFormat().format(new Date()));
}
}