原

Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

2018年05月25日 11:16:07 loveLifeLoveCoding 阅读数：2192

本案例采用quartz-2.2.3.jar

入门案例，执行比较简单的任务

QuartzManager.java (任务的管理)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.Trigger.TriggerState;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.TriggerUtils;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;
public class QuartzManager {
private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
private static String JOB_GROUP_NAME = "MY_JOBGROUP_NAME";
private static String TRIGGER_GROUP_NAME = "MY_TRIGGERGROUP_NAME";
/**
* @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
* @param jobName
* 任务名
* @param cls
* 任务
* @param time
* 时间设置，参考quartz说明文档
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void addJob(String jobName, Class cls, String cron) {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
JobDetail job = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 按新的cronExpression表达式构建一个新的trigger
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
.withSchedule(scheduleBuilder).build();
// 交给scheduler去调度
sched.scheduleJob(job, trigger);
// 启动
if (!sched.isShutdown()) {
sched.start();
System.err.println( "添加任务:"+jobName);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 添加一个定时任务
* @param jobName
* 任务名
* @param jobGroupName
* 任务组名
* @param triggerName
* 触发器名
* @param triggerGroupName
* 触发器组名
* @param jobClass
* 任务
* @param time
* 时间设置，参考quartz说明文档
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
Class jobClass, String cron) {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 按新的cronExpression表达式构建一个新的trigger
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
.withSchedule(scheduleBuilder).build();
sched.scheduleJob(job, trigger);
// 启动
if (!sched.isShutdown()) {
sched.start();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
* @param jobName
* @param time
*/
public static void modifyJobTime(String jobName, String cron) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(cron)) {
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
sched.rescheduleJob(triggerKey, trigger);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description:修改任务，（可以修改任务名，任务类，触发时间）
* 原理：移除原来的任务，添加新的任务
* @param oldJobName ：原任务名
* @param jobName
* @param jobclass
* @param cron
* @date 2018年5月23日上午9:13:10
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public static void modifyJob(String oldJobName, String jobName, Class jobclass, String cron) {
/*
* removeJob(oldJobName);
* addJob(jobName, jobclass, cron);
* System.err.println("修改任务"+oldJobName);
*/
TriggerKey triggerKey = TriggerKey.triggerKey(oldJobName, TRIGGER_GROUP_NAME);
JobKey jobKey = JobKey.jobKey(oldJobName, JOB_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}
sched.pauseTrigger(triggerKey); // 停止触发器
sched.unscheduleJob(triggerKey); // 移除触发器
sched.deleteJob(jobKey); // 删除任务
System.err.println( "移除任务:" + oldJobName);
JobDetail job = JobBuilder.newJob(jobclass).withIdentity(jobName, JOB_GROUP_NAME).build();
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 按新的cronExpression表达式构建一个新的trigger
Trigger newTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
.withSchedule(scheduleBuilder).build();
// 交给scheduler去调度
sched.scheduleJob(job, newTrigger);
// 启动
if (!sched.isShutdown()) {
sched.start();
System.err.println( "添加新任务:" + jobName);
}
System.err.println( "修改任务【" + oldJobName + "】为:" + jobName);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 修改一个任务的触发时间
* @param triggerName
* @param triggerGroupName
* @param time
*/
public static void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(cron)) {
// trigger已存在，则更新相应的定时设置
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
sched.resumeTrigger(triggerKey);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
* @param jobName
*/
public static void removeJob(String jobName) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}
sched.pauseTrigger(triggerKey); // 停止触发器
sched.unscheduleJob(triggerKey); // 移除触发器
sched.deleteJob(jobKey); // 删除任务
System.err.println( "移除任务:"+jobName);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 移除一个任务
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
*/
public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, triggerGroupName);
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.pauseTrigger(triggerKey); // 停止触发器
sched.unscheduleJob(triggerKey); // 移除触发器
sched.deleteJob(jobKey); // 删除任务
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description:暂停一个任务(使用默认组名)
* @param jobName
*/
public static void pauseJob(String jobName) {
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.pauseJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description:暂停一个任务
* @param jobName
* @param jobGroupName
*/
public static void pauseJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.pauseJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description:恢复一个任务(使用默认组名)
* @param jobName
*/
public static void resumeJob(String jobName) {
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.resumeJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description:恢复一个任务
* @param jobName
* @param jobGroupName
* @date 2018年5月17日上午9:56:09
*/
public static void resumeJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.resumeJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description:启动所有定时任务
*/
public static void startJobs() {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description 关闭所有定时任务
*/
public static void shutdownJobs() {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
if (!sched.isShutdown()) {
sched.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 立即运行任务，这里的立即运行，只会运行一次，方便测试时用。
* @param jobName
* @param jobGroupName
* @date 2018年5月17日上午10:03:26
*/
public static void triggerJob(String jobName) {
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.triggerJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description: 立即运行任务，这里的立即运行，只会运行一次，方便测试时用。
* @param jobName
* @param jobGroupName
* @date 2018年5月17日上午10:03:26
*/
public static void triggerJob(String jobName, String jobGroupName) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.triggerJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* @Description: 获取任务状态
* NONE: 不存在
* NORMAL: 正常
* PAUSED: 暂停
* COMPLETE:完成
* ERROR : 错误
* BLOCKED : 阻塞
* @param jobName 触发器名
* @date 2018年5月21日下午2:13:45
*/
public static String getTriggerState(String jobName){
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
String name = null;
try {
Scheduler sched = gSchedulerFactory.getScheduler();
TriggerState triggerState = sched.getTriggerState(triggerKey);
name = triggerState.name();
} catch (SchedulerException e) {
e.printStackTrace();
}
return name;
}
/**
* @Description:获取最近8次执行时间
* @param cron
* @date 2018年5月24日下午5:13:03
*/
public static List getRecentTriggerTime(String cron) {
List list = new ArrayList();
try {
CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
cronTriggerImpl.setCronExpression(cron);
// 这个是重点，一行代码搞定
List dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, 8);
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
for (Date date : dates) {
list.add(dateFormat.format(date));
}
} catch (ParseException e) {
e.printStackTrace();
}
return list;
}
}

MyJob.java 执行的任务

import java.text.SimpleDateFormat;
import java.util.Calendar;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
* @Description:
* @date 2018年5月16日
*/
public class MyJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.err.println( "任务运行开始-------- start --------");
try {
String jobName = context.getJobDetail().getKey().getName();
String jobGroup = context.getJobDetail().getKey().getGroup();
String triggerName = context.getTrigger().getKey().getName();
String triggerGroup = context.getTrigger().getKey().getGroup();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
System.err.println( "触发器Key:" + triggerName + ".." + triggerGroup + " 正在执行...");
System.err.println( "任务Key:" + jobName + ".." + jobGroup + " 正在执行，执行时间: "
+ dateFormat.format(Calendar.getInstance().getTime()));
} catch (Exception e) {
System.err.println( "捕获异常==="+e);
}
System.err.println( "任务运行结束-------- end --------");
}
}

测试类 LoadTask.java

public class LoadTask {
public static void main(String[] args) {
System.err.println( "【系统启动】");
String corn = "0/5 * * * * ?";
//QuartzManager.addJob("job1", "jobGooup", "trigger1", "triggerGroup", MyJob.class, corn);
QuartzManager.addJob( "job1", MyJob.class, corn);
System.err.println( "添加任务一");
QuartzManager.getTriggerState( "jobs");
//睡眠一分钟
try {
Thread.sleep( 60L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
QuartzManager.modifyJobTime( "job1", "0/3 * * * * ?");
System.out.println( "修改触发时间");
try {
Thread.sleep( 15L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
QuartzManager.removeJob( "job1");
//QuartzManager.removeJob("job1", "jobGooup", "trigger1", "triggerGroup");
System.out.println( "删除任务");
try {
Thread.sleep( 5L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( "【添加定时任务】");
QuartzManager.addJob( "job1", MyJob.class, corn);
//QuartzManager.shutdownJobs();
//System.out.println("停止所有任务");
try {
Thread.sleep( 5L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( "【暂停定时任务】");
QuartzManager.pauseJob( "job1");
System.out.println( "【立即运行一次】");
QuartzManager.triggerJob( "job1");
try {
Thread.sleep( 5L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println( "【恢复定时任务】");
QuartzManager.resumeJob( "job1");
try {
Thread.sleep( 5L * 1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
QuartzManager.shutdownJobs();
}
}

Quartz2实现任务的临时启动/暂停/恢复

6052

在项目中需要手动启停某些服务，那么需要有一个控制这些任务的类。由于任务是有Quartz控制的，我们只需要通过Quartz的相关的API实现相关的功能即可。 Java代码 package c...来自： zmx729618

溪雪：你好，请问任务状态为什么会一直处在“不存在”的状态呢？（任务名和TRIGGER_GROUP_NAME没问题）(1个月前#1楼)

0

loveLifeLoveCoding

关注

原创: 38

粉丝: 4

喜欢: 8

评论: 3

等级：

访问：: 2万+

积分：: 581

排名：: 11万+

勋章：

个人分类

Oracle3篇
Extjs4.21篇
加密3篇
webService1篇
nginx1篇
设计模式1篇
bat1篇

展开

Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

Quartz2实现任务的临时启动/暂停/恢复

最新文章

个人分类

归档

热门文章

最新评论

你可能感兴趣的:(Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间))

Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

quartz_Cron表达式一分钟教程

quartz定时任务中常用的cron表达式

Quartz2实现任务的临时启动/暂停/恢复

quartz 获取正在执行的任务

在spring中实现quartz的动态调度（开始、暂停、停止等）

SpringQuartz定时任务的cron表达式书写

定时任务Quartz_之_cron表达式（时间表达式）

查看Quartz 调度任务 job 的状态

Quartz-基础

spring quartz 根据开始时间 结束时间 动态设置任务

Quartz任务调度原理简析

Quartz_Cron表达式_每周、每月执行一次

得到quartz中Job的执行状态

quartz定时:修改时间及时生效的定时任务

Quartz任务调度的Cron表达式

cron表达式（Quartz中的使用）

quartz_时间表达式之Cron表达式详解

quartz中cron表达式

quartz任务停止最佳实践方式

Spring+Quartz 实现任务动态管理监控

Quartz-中断正在执行的任务

spring-boot+quartz的CRUD动态任务管理系统

Quartz_Cron表达式（定时任务）

java时间操作

TimeUtil工具类

随机生成日期

quartz2.x的动态管理类

去除节假日，周末，获取当月的工作日

java_日期的操作汇总

DateUtil

cron表达式获取上次执行时间和下次执行时间

POI导出excel表格优化

java_时间处理

JAVA获取某段时间内的所有日期

逐页缓存查询（串行，避免OOM）导出Excel，zip压缩

Quartz动态添加，修改，删除任务(暂停，任务状态，恢复，最近触发时间)

Quartz2实现任务的临时启动/暂停/恢复

Quartz-中断正在执行的任务

quartz任务停止最佳实践方式

以代码的方式管理quartz定时任务的暂停、重启、删除、添加等

Quartz调度、终止执行的任务

java quartz 停止正在进行的任务解决方案

对于quartz定时任务设置结束时间

Quartz的任务的临时启动和暂停和恢复

quartz定时任务执行一段时间停止了

Spring+Quartz定时器使用方法(任务的添加删除修改暂停..._CSDN博客

quartz 定时任务的删除 恢复 已经暂停 - taizhen/blog - CSDN博客

quartz 定时器的动态加载和取消定时任务

java系统中使用调度器Quartz实现对正在执行任务的停止

quartz配置动态任务,从数据库读取相应的类及方法,执行..._CSDN博客

...Scheduler (Quartz) 动态添加,删除,修改任务的例子 ..._CSDN博客

使用Spring Quartz做自动任务 启动和关闭

Spring3整合Quartz2实现定时任务及动态任务调整(添加删..._CSDN博客

SpringBoot整合Quartz之动态控制任务(暂停,启动,修改执..._CSDN博客

quartz在job间隔期间内，保证上一个任务执行完后，再去执行下一个任务

Quartz之手动启动和关闭定时器简单示例

任务调度开源框架Quartz动态添加、修改和删除定时任务 ..._CSDN博客

Quartz1.7 动态添加、修改和删除定时任务(非spring集成..._CSDN博客

任务调度开源框架Quartz动态添加、修改和删除定时任务

关于quartz暂停恢复后,job执行多次的异常情况 - u01375..._CSDN博客

spring+quartz新增,删除,暂停,恢复定时任务

quartz 暂停后重新启动，在暂停时 被暂停后的任务，在启动后会补偿执行即 会连续多次调用job中的execute方法。

quartz 定时任务的删除 恢复 已经暂停

Spring+Quartz定时器使用方法（任务的添加删除修改暂停恢复）

Quartz的简化（只要一张表，动态启停任务）

Spring Quartz 动态暂停、恢复、修改定时任务

Spring3整合Quartz2实现定时任务及动态任务调整(添加删除暂停恢复)--推荐

查看Quartz 调度任务 job 的状态

得到quartz中Job的执行状态

Spring+Quartz 实现任务动态管理监控

quartz 获取正在执行的任务

Quartz任务监控管理

Quartz——有状态的job和无状态的job

获取Quartz中Job的执行状态

Quartz+Spring 实现任务监控

Quartz任务监控管理

作业调度框架 Quartz 学习笔记(四) -- 接收参数和维护状态

Quartz 2.2 的实现原理和运行过程固定时间后删除任务

quartz 对于有状态的任务处理

spring quartz 根据开始时间结束时间动态设置任务

quartz 定时任务的删除恢复已经暂停 - taizhen/blog - CSDN博客

使用Spring Quartz做自动任务启动和关闭

quartz 暂停后重新启动，在暂停时被暂停后的任务，在启动后会补偿执行即会连续多次调用job中的execute方法。

quartz 定时任务的删除恢复已经暂停

Cron+Trigger+Quartz 任务启动暂停恢复修改实例

WSAEventSelect模型编程详解

IDEA 中如何通过数据库表生成带注解的实体类