配置见前面两篇博客
- RAMJobStore方式配置，https://blog.csdn.net/llmys/article/details/81069445
- JobStoreTX方式持久化在数据库中，https://blog.csdn.net/llmys/article/details/81069638
首先我需要的quartz相关的信息包括任务名称、任务组名称、作业开始时间、作业结束时间等，定义一个类UniQuartzBean用于保存这些属性：
import java.util.Date;
public class UniQuartzBean {
private String jobName; // 作业名称
private String jobGroupName; // 作业组名称
private String oldJobName; // 作业名称
private String oldJobGroupName; // 作业组名称
private String schedulerInstanceId; // 调度器ID
private String schedulerName; // 调度器名称
private String triggerName; // 触发器名称
private String triggerGroupName; // 触发器组名称
private String jobClass; // 处理类名称
private String description; // 任务描述
private Date startTime; // 作业开始启动时间
private Date previousTime; // 上一次启动时间
private Date nextTime; // 下一次启动时间
private Date endTime; // 结束时间
private int repeatCount; // 作业需要执行的次数（计数任务）
private long repeatInterval; // 执行时间间隔
private int timesTriggered; // 已经执行的次数
private String cronExpression; // 执行的时间表达式（定时任务）
private String triggerState; // 作业状态
private String jobId; // FireInstanceId 独一无二的标识，在获取正在运行的任务时用到
private Long jobRunTime; // 作业的运行时间，只有当作业完成时才会获取到值，没有完成时返回-1
/**
*
None：Trigger已经完成，且不会在执行，或者找不到该触发器，或者Trigger已经被删除<br />
NORMAL:正常状态<br />
PAUSED：暂停状态<br />
COMPLETE：触发器完成，但是任务可能还正在执行中<br />
BLOCKED：线程阻塞状态<br />
ERROR：出现错误<br />
*/
private String triggerType; // 触发器类型
private String timeZone; // timeZone
private boolean isConcurrent; // 是否支持并发执行
public UniQuartzBean() {
super();
}
// 暂停、恢复时可以使用
public UniQuartzBean(String jobName, String jobGroupName) {
super();
this.jobName = jobName;
this.jobGroupName = jobGroupName;
}
// 修改作业调度时间可以用到
public UniQuartzBean(String jobName, String jobGroupName, String oldJobName, String oldJobGroupName) {
super();
this.jobName = jobName;
this.jobGroupName = jobGroupName;
this.oldJobName = oldJobName;
this.oldJobGroupName = oldJobGroupName;
}
...Set、Get函数
}此外修改配置任务需要配置其任务时间间隔、任务次数、何时结束等，定义一个类来保存这些属性
public class UniQuartzConfig {
/**
* 是否是定时任务? <br/>
* 如果是定时任务,设置true;默认为true<br/>
* 如果是即时任务或计数执行,则设置为false;
* @return
*/
private boolean isTimedTask = true;
/**
* 定时任务执行时,设置一个时间的正则表达式;<br />
* 如:'0/5 * * * * ?'
* @return
*/
private String cron = "";
/**
* 即时任务或计数执行需要设置,表示在当前时间之后间隔delayTime后执行;<br />
* 时间间隔类型见delayTimeType;<br />
* 默认延时启动时间为0,表示立即开始执行;
* @return
*/
private int delayTime = 0;
/**
* 设置延时启动时间间隔的时间是什么类型的，默认为'秒';<br />
* IntervalUnit.MILLISECOND 毫秒<br />
* IntervalUnit.SECOND 秒<br />
* IntervalUnit.MINUTE 分<br />
* IntervalUnit.HOUR 小时<br />
* IntervalUnit.DAY 天<br />
* IntervalUnit.WEEK 周<br />
* IntervalUnit.MONTH 月<br />
* IntervalUnit.YEAR 年
* @return
*/
private IntervalUnit delayTimeType = IntervalUnit.SECOND;
/**
* 计数执行每次执行任务之间的“间隔时间”设置，默认为1<br/>
* “间隔时间”类型,见“intervalTimeType”
* @return
*/
private int intervalTime = 1;
/**
* 计数执行“间隔时间”是什么类型的，默认为'秒';<br />
* IntervalUnit.MILLISECOND 毫秒<br />
* IntervalUnit.SECOND 秒<br />
* IntervalUnit.MINUTE 分<br />
* IntervalUnit.HOUR 小时<br />
* @return
*/
private IntervalUnit intervalTimeType = IntervalUnit.SECOND;
/**
* “计数执行”的重复次数,默认为1; <br />
* 当设置为“0”时,表示一直重复; <br />
* 当这是为“-1”时,表示在某一刻时间结束,需要设置结束的时间endTime,endTimeType;
* @return
*/
private int repeatCount = 1;
/**
* 多少时间之后，该任务停止; <br />
* 时间类型见“endTimeType”
* @return
*/
private int endTime = 0;
/**
* 结束时间间隔类型 ,默认设置为秒;其他时间设置如下 <br />
* IntervalUnit.MILLISECOND 毫秒<br />
* IntervalUnit.SECOND 秒<br />
* IntervalUnit.MINUTE 分<br />
* IntervalUnit.HOUR 小时<br />
* IntervalUnit.DAY 天<br />
* IntervalUnit.WEEK 周<br />
* IntervalUnit.MONTH 月<br />
* IntervalUnit.YEAR 年
* @return
*/
private IntervalUnit endTimeType = IntervalUnit.SECOND;
public static UniQuartzConfig newInstance() {
return new UniQuartzConfig();
}
private UniQuartzConfig() {
super();
}
...Set、Get函数
}
接下来就是service类，实现对任务的增删改查：
@Component
public class UniQuartzService implements UniQuartz {
@Autowired
private Scheduler quartzScheduler;
/**
*
* @param uqb
* 任务名称、任务组名称
* @param uqc
* 任务的配置信息
* @param quartzClass
* 任务执行的类
* @param parameter
* 给任务传递的参数上下文
* @return
*/
@Override
public boolean addJob(UniQuartzBean uqb, UniQuartzConfig uqc, Class<? extends Job> quartzClass, Object parameter) {
try {
// 判断触发器是否存在
boolean exist = isTriggerExist(uqb);
// 获取触发器，不存在触发器时创建一个
Trigger trigger = getTrigger(uqb, uqc);
if (exist) {
if (!ObjectUtils.isEmpty(parameter)) {
trigger.getJobDataMap().put("context", parameter); // 传递上下文数据给定时任务
}
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
quartzScheduler.rescheduleJob(triggerKey, trigger);
} else {
// 创建JobDetail,并传递参数
JobDetail jobDetail = getNewJob(uqb, quartzClass);
if (!ObjectUtils.isEmpty(parameter)) {
jobDetail.getJobDataMap().put("context", parameter);
}
// 调度任务
quartzScheduler.scheduleJob(jobDetail, trigger);
//quartzScheduler.start();
}
System.out.println(JSON.toJSONString(uqc));
} catch (SchedulerException e) {
e.printStackTrace();
}
return true;
}
/**
* 修改任务的时间
*
* @param uqb
* @param uqc
* @return
*/
@Override
public boolean modifyJobTime(UniQuartzBean uqb, UniQuartzConfig uqc) {
try {
if (isTriggerExist(uqb) == false) {
System.err.println("不存在[JobName=" + uqb.getJobName() + ",JobGroupName=" + uqb.getJobGroupName());
return false;
} else {
addJob(uqb, uqc, null, null);
return true;
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return false;
}
/**
* 修改任务的时间
*
* @param jobName
* @param jobGroupName
* @param uqc
* @return
*/
@Override
public boolean modifyJobTime(String jobName, String jobGroupName, UniQuartzConfig uqc) {
UniQuartzBean uqb = new UniQuartzBean(jobName, jobGroupName);
return modifyJobTime(uqb, uqc);
}
/**
* 暂停任务
*/
@Override
public boolean pauseJob(UniQuartzBean uqb) {
return pauseJob(uqb.getJobName(), uqb.getJobGroupName());
}
/**
* 暂停任务
*/
@Override
public boolean pauseJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
// 暂停触发器
quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
quartzScheduler.pauseJob(jobKey);
return true;
} catch (SchedulerException e) {
e.printStackTrace();
}
return false;
}
/**
* 暂停所有任务
*/
@Override
public boolean pauseAllJob() {
try {
quartzScheduler.pauseAll();
} catch (SchedulerException e) {
e.printStackTrace();
}
return true;
}
/**
* 恢复任务
*/
@Override
public boolean resumeJob(UniQuartzBean uqb) {
return resumeJob(uqb.getJobName(), uqb.getJobGroupName());
}
/**
* 恢复任务
*/
@Override
public boolean resumeJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
// 恢复触发器
quartzScheduler.resumeTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
quartzScheduler.resumeJob(jobKey);
return true;
} catch (SchedulerException e) {
e.printStackTrace();
}
return false;
}
/**
* 恢复任务
*/
@Override
public void resumeAllJob() {
try {
quartzScheduler.resumeAll();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 删除任务
*/
@Override
public boolean deleteJob(UniQuartzBean uqb) {
return deleteJob(uqb.getJobName(), uqb.getJobGroupName());
}
/**
* 删除任务
*/
@Override
public boolean deleteJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
// 停止触发器
quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
// 移除触发器
quartzScheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
// 删除任务
quartzScheduler.deleteJob(jobKey);
return true;
} catch (SchedulerException e) {
e.printStackTrace();
}
return false;
}
/**
* 停止调度器触发触发器，清理与调度器相关的所有资源。相当于关闭(false)。无法重新启动调度程序。
*/
@Override
public void shutdown() {
try {
quartzScheduler.shutdown();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 判断触发器是否存在
*
* @param uqb
* @param trigName
* @param trigGroupName
* @return
* @throws SchedulerException
*/
private boolean isTriggerExist(UniQuartzBean uqb) throws SchedulerException {
boolean bExist = false;
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
Trigger trigger = quartzScheduler.getTrigger(triggerKey);
if (!ObjectUtils.isEmpty(trigger)) {
bExist = true;
}
return bExist;
}
/**
* 获取触发器，触发器之前存在则返回；不存在，则创建之后返回；
*
* @param uqb
* @param uqc
* @return
* @throws SchedulerException
*/
private Trigger getTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
return uqc.isTimedTask() ? configCronTrigger(uqb, uqc) : configSimpleTrigger(uqb, uqc);
}
/**
* 定时任务-配置触发器
*
* @param uqb
* @param uqc
* @return
* @throws SchedulerException
*/
private Trigger configCronTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
Trigger trigger = null;
ScheduleBuilder<?> scheduleBuilder = getScheduleBuilder(uqc);
if (isTriggerExist(uqb)) { // 存在
System.out.println("定时任务-配置触发器---存在");
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
trigger = quartzScheduler.getTrigger(triggerKey);
trigger = ((CronTrigger) trigger).getTriggerBuilder().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.withSchedule((CronScheduleBuilder) scheduleBuilder).withDescription(uqb.getDescription()).build();
} else { // 不存在
System.out.println("定时任务-配置触发器---不存在");
trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.withSchedule(scheduleBuilder).withDescription(uqb.getDescription()).build();
}
return trigger;
}
/**
* 创建调度器
*
* @param uqa
* @return
*/
private ScheduleBuilder<?> getScheduleBuilder(UniQuartzConfig uqc) {
ScheduleBuilder<?> scheduleBuilder = null;
if (uqc.isTimedTask()) { // 定时任务
scheduleBuilder = CronScheduleBuilder.cronSchedule(uqc.getCron());
} else { // 即时任务、计数任务
scheduleBuilder = SimpleScheduleBuilder.simpleSchedule();
}
return scheduleBuilder;
}
/**
* 配置即时任务、定时任务的延时、延时种类、执行间隔、执行间隔种类、重复次数、结束时间、结束时间种类
*
* @param uqb
* @param uqc
* @return
* @throws SchedulerException
*/
private Trigger configSimpleTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
System.out.println("配置Simple触发器.循环次数" + uqc.getRepeatCount());
if (uqc.getRepeatCount() == -1) { // 表示在某一时刻结束，需要设置结束时间
System.out.println("在某一刻结束-触发器");
return configSimpleTriggerEnd(uqb, uqc);
} else if (uqc.getRepeatCount() == 0) { // 表示一直重复
System.out.println("一直重复执行-触发器....");
return configSimpleTriggerForever(uqb, uqc);
} else { // 计数执行
System.out.println("计数执行-触发器...");
return configSimpleTriggerCount(uqb, uqc);
}
}
/**
* 在某一时刻结束
*
* @param trigName
* @param trigGroupName
* @param uqa
* @return
* @throws SchedulerException
*/
private Trigger configSimpleTriggerEnd(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
Trigger trigger = null;
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
// 延时启动时间
Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
// 结束时间
Date endDate = DateBuilder.futureDate(uqc.getEndTime(), uqc.getEndTimeType());
// 配置时间间隔
scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
scheduleBuilder = scheduleBuilder.repeatForever();
if (isTriggerExist(uqb)) {
trigger = quartzScheduler.getTrigger(triggerKey);
trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
.withDescription(uqb.getDescription()).startAt(startDate).endAt(endDate).build();
System.out.println("即时任务-某时间结束-配置触发器---存在");
} else {
System.out.println("即时任务-某时间结束-配置触发器---不存在");
// 构建调度器
trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate)
.endAt(endDate).build();
}
return trigger;
}
/**
* 配置触发器启动时间间隔、间隔类型
*
* @param scheduleBuilder
* @param uqa
*/
private SimpleScheduleBuilder configSimpleTriggerInterval(SimpleScheduleBuilder scheduleBuilder,
UniQuartzConfig uqc) {
SimpleScheduleBuilder res = scheduleBuilder;
if (uqc.getIntervalTime() > 0) { // 间隔时间大于0时设置
System.out.println("设置的间隔时间大于0");
switch (uqc.getIntervalTimeType()) {
case MILLISECOND:
System.out.println("时间间隔为毫秒:" + uqc.getIntervalTime());
res = scheduleBuilder.withIntervalInMilliseconds(uqc.getIntervalTime());
break;
case SECOND:
System.out.println("时间间隔为秒:" + uqc.getIntervalTime());
res = scheduleBuilder.withIntervalInSeconds(uqc.getIntervalTime());
break;
case MINUTE:
System.out.println("时间间隔为分:" + uqc.getIntervalTime());
res = scheduleBuilder.withIntervalInMinutes(uqc.getIntervalTime());
break;
case HOUR:
System.out.println("时间间隔为小时:" + uqc.getIntervalTime());
res = scheduleBuilder.withIntervalInHours(uqc.getIntervalTime());
break;
default:
System.err.println("这是不支持的调度间隔时间：" + uqc.getIntervalTimeType());
break;
}
} else {
System.err.println("设置的时间间隔必须大于0.");
}
return res;
}
/**
* 一直重复执行
*
* @param uqb
* @param uqc
* @return
* @throws SchedulerException
*/
private Trigger configSimpleTriggerForever(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
Trigger trigger = null;
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
// 延时启动时间
Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
// 配置时间间隔
scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
scheduleBuilder = scheduleBuilder.repeatForever();// 一直重复
if (isTriggerExist(uqb)) {
trigger = quartzScheduler.getTrigger(triggerKey);
trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
.withDescription(uqb.getDescription()).startAt(startDate).build();
System.out.println("即时任务-重复执行-配置触发器---存在");
} else {
System.out.println("即时任务-重复执行-配置触发器---不存在");
// 构建调度器
trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate).build();
}
return trigger;
}
/**
* 执行一定的次数
*
* @param uqb
* @param uqc
* @return
* @throws SchedulerException
*/
private Trigger configSimpleTriggerCount(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
Trigger trigger = null;
TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
// 延时启动时间
Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
// 配置时间间隔
scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
scheduleBuilder = scheduleBuilder.withRepeatCount(uqc.getRepeatCount() - 1); // 设置重复次数
if (isTriggerExist(uqb)) {
System.out.println("是否存在---------------------2:" + "存在");
trigger = quartzScheduler.getTrigger(triggerKey);
trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
.withDescription(uqb.getDescription()).startAt(startDate).build();
} else {
System.out.println("是否存在---------------------2:" + "不存在");
// 构建调度器
trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate).build();
}
return trigger;
}
/**
* 创建一个新的作业
*
* @param uniSchTrig
* @param quartzClass
* @return
*/
private JobDetail getNewJob(UniQuartzBean uqb, Class<? extends Job> quartzClass) {
JobDetail jobDetail = JobBuilder.newJob(quartzClass).withIdentity(uqb.getJobName(), uqb.getJobGroupName())
.build();
return jobDetail;
}
private UniQuartzBean getJob(JobKey jobKey, Trigger trigger) {
UniQuartzBean uniQuartzBean = null;
try {
String jobName = jobKey.getName();
String jobGroupName = jobKey.getGroup();
// Trigger trigger = quartzScheduler.getTrigger(triggerKey);
if (!ObjectUtils.isEmpty(trigger)) {
uniQuartzBean = new UniQuartzBean();
// 获取任务基本信息，作业名称、作业组名称、触发器名称、触发器组名称
uniQuartzBean.setJobName(jobName).setJobGroupName(jobGroupName).setTriggerName(jobName)
.setTriggerGroupName(jobGroupName);
// 获取调度器基本信息，调度器ID、调度器名称、处理类名称、任务描述、作业状态
uniQuartzBean.setSchedulerInstanceId(quartzScheduler.getSchedulerInstanceId())
.setSchedulerName(quartzScheduler.getSchedulerName());
JobDetail jobDetail = quartzScheduler.getJobDetail(jobKey);
uniQuartzBean.setJobClass("" + jobDetail.getJobClass()).setDescription(trigger.getDescription())
.setTriggerState(quartzScheduler.getTriggerState(trigger.getKey()).name());
// 获取作业的启动时间信息
uniQuartzBean.setStartTime(trigger.getStartTime()).setPreviousTime(trigger.getPreviousFireTime())
.setNextTime(trigger.getNextFireTime()).setEndTime(trigger.getEndTime());
// 是否支持并发
uniQuartzBean.setConcurrent(jobDetail.isConcurrentExectionDisallowed());
// 获取需要执行的次数、执行间隔、已经执行的次数、时间表达式
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
uniQuartzBean.setTriggerType("CronTrigger");
uniQuartzBean.setCronExpression(cronTrigger.getCronExpression())
.setTimeZone(cronTrigger.getTimeZone().getID());
} else if (trigger instanceof SimpleTrigger) {
SimpleTrigger simpleTrigger = (SimpleTrigger) trigger;
uniQuartzBean.setTriggerType("SimpleTrigger");
uniQuartzBean.setRepeatCount(simpleTrigger.getRepeatCount() + 1)
.setRepeatInterval(simpleTrigger.getRepeatInterval())
.setTimesTriggered(simpleTrigger.getTimesTriggered());
}
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return uniQuartzBean;
}
/**
* 获取任务信息
* @param uqb
* @return
*/
@Override
public UniQuartzBean getJob(UniQuartzBean uqb) {
return getJob(uqb.getJobName(), uqb.getJobGroupName());
}
/**
* 获取任务信息
* @param jobName
* @param jobGroupName
* @return
*/
@Override
public UniQuartzBean getJob(String jobName, String jobGroupName) {
UniQuartzBean uniQuartzBean = null;
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
Trigger trigger = quartzScheduler.getTrigger(triggerKey);
if (!ObjectUtils.isEmpty(trigger)) {
JobKey jobKey = trigger.getJobKey();
uniQuartzBean = getJob(jobKey, trigger);
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return uniQuartzBean;
}
/**
* 获取所有的任务,指那些添加到quartz调度器中的任务
* @return
*/
@Override
public List<UniQuartzBean> getAllJob() {
List<UniQuartzBean> listUniQuartzBean = new ArrayList<>();
try {
GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
Set<JobKey> jobKeys = quartzScheduler.getJobKeys(matcher);
if (!CollectionUtils.isEmpty(jobKeys)) {
jobKeys.forEach(jobKey -> {
try {
List<? extends Trigger> listTrigger = quartzScheduler.getTriggersOfJob(jobKey);
if (!CollectionUtils.isEmpty(listTrigger)) {
listTrigger.forEach(trigger->{
UniQuartzBean uniQuartzBean = getJob(jobKey, trigger);
if (!ObjectUtils.isEmpty(uniQuartzBean)) {
listUniQuartzBean.add(uniQuartzBean);
}
});
}
} catch (SchedulerException e) {
e.printStackTrace();
}
});
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return listUniQuartzBean;
}
/**
* 获取所有任务中-正在执行的实例
*
* @return
*/
@Override
public List<UniQuartzBean> getAllJobInstance() {
List<UniQuartzBean> listUniQuartzBean = new ArrayList<>();
try {
List<JobExecutionContext> listExecJob = quartzScheduler.getCurrentlyExecutingJobs();
if (!CollectionUtils.isEmpty(listExecJob)) {
listExecJob.forEach(execJob->{
JobKey jobKey = execJob.getJobDetail().getKey();
try {
List<? extends Trigger> listTrigger = quartzScheduler.getTriggersOfJob(jobKey);
if (!CollectionUtils.isEmpty(listTrigger)) {
listTrigger.forEach(trigger->{
//UniQuartzBean uniQuartzBean = getJob(jobKey, trigger);
UniQuartzBean uniQuartzBean = getRuningJob(execJob, trigger);
if (!ObjectUtils.isEmpty(uniQuartzBean)) {
listUniQuartzBean.add(uniQuartzBean);
}
});
}
} catch (SchedulerException e) {
e.printStackTrace();
}
});
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return listUniQuartzBean;
}
/**
* 获取正在运行的任务信息
* @param execJob
* @param trigger
* @return
*/
private UniQuartzBean getRuningJob(JobExecutionContext execJob, Trigger trigger) {
UniQuartzBean uniQuartzBean = null;
try {
JobKey jobKey = trigger.getJobKey();
String jobName = jobKey.getName();
String jobGroupName = jobKey.getGroup();
if (!ObjectUtils.isEmpty(trigger)) {
uniQuartzBean = new UniQuartzBean();
// 获取任务基本信息，作业名称、作业组名称、触发器名称、触发器组名称
uniQuartzBean.setJobName(jobName).setJobGroupName(jobGroupName).setTriggerName(jobName)
.setTriggerGroupName(jobGroupName);
JobDetail jobDetail = quartzScheduler.getJobDetail(jobKey);
// 获取作业“实际”开始的时间、上次运行的时间、下次运行的时间
uniQuartzBean.setStartTime(execJob.getFireTime()).setPreviousTime(execJob.getPreviousFireTime())
.setNextTime(execJob.getNextFireTime());
// 获取作业状态
uniQuartzBean.setJobClass("" + jobDetail.getJobClass()).setDescription(trigger.getDescription());
// 获取执行时间、实例ID
uniQuartzBean.setJobRunTime(execJob.getJobRunTime()).setJobId(execJob.getFireInstanceId());
}
} catch (SchedulerException e) {
e.printStackTrace();
}
return uniQuartzBean;
}
}
测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath*:/spring-context*.xml", "classpath*:/quartz_jobs.xml" })
public class UniQuartz2Test {
@Autowired
UniQuartz uniQuartz2;
@Test
public void testAddJob_TimedTask() throws InterruptedException {
System.out.println("--------添加定时器------start---------");
UniQuartzConfig uqc =UniQuartzConfig.newInstance().setCron("0/3 * * * * ?");
UniQuartzBean uqb = new UniQuartzBean("jobName2", "jobGroupName1");
uniQuartz2.addJob(uqb, uqc, TimedTaskJob.class, "每隔3秒执行一次.");
uqb.setDescription("定时器");
System.out.println("--------添加定时器------stop---------");
int i= 0;
while (true) {
i++;
Thread.sleep(1000);
if (i >= 16)
break;
}
}
}参考博客：
http://itindex.net/detail/53315-spring-quartz-%E7%AE%A1%E7%90%86