spring quartz2.2.1 100个jobs怎么同时运行_百度知道
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。
spring quartz2.2.1 100个jobs怎么同时运行
我有更好的答案
xml&);作业到时间执行时因为ApplicationContext context = new ClassPathXmlApplicationContext(&spring-*。。。。，每new一次，都会开启一个定时器。这样导致在作业到时时有多个作业同时进行。
为您推荐：
其他类似问题
spring的相关知识
等待您来回答158 人点赞
前面，我们已经对Spring 3和Quartz 2用配置文件的方式进行了整合，如果需求比较简单的话应该已经可以满足了。但是很多时候，我们常常会遇到需要动态的添加或修改任务，而spring中所提供的定时任务组件却只能够通过修改xml中trigger的配置才能控制定时任务的时间以及任务的启用或停止，这在带给我们方便的同时也失去了动态配置任务的灵活性。我搜索了一些网上的解决方法，都没有很好的解决这个问题，而且大多数提到的解决方案都停留在Quartz 1.x系列版本上，所用到的代码和API已经不能适用于新版本的Spring和Quartz。没办法只能靠自己了，花了点时间好好研究了一下Spring和Quartz中相关的代码。
首先我们来回顾一下spring中使用quartz的配置代码：
&!-- 使用MethodInvokingJobDetailFactoryBean，任务类可以不实现Job接口，通过targetMethod指定调用方法--&
&bean id=&taskJob& class=&com.tyyd.dw.task.DataConversionTask&/&
&bean id=&jobDetail& class=&org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean&&
&property name=&group& value=&job_work&/&
&property name=&name& value=&job_work_name&/&
&!--false表示等上一个任务执行完后再开启新的任务--&
&property name=&concurrent& value=&false&/&
&property name=&targetObject&&
&ref bean=&taskJob&/&
&/property&
&property name=&targetMethod&&
&value&execute&/value&
&/property&
调度触发器 --&
&bean id=&myTrigger&
class=&org.springframework.scheduling.quartz.CronTriggerFactoryBean&&
&property name=&name& value=&work_default_name&/&
&property name=&group& value=&work_default&/&
&property name=&jobDetail&&
&ref bean=&jobDetail& /&
&/property&
&property name=&cronExpression&&
&value&0/5 * * * * ?&/value&
&/property&
&!-- 调度工厂 --&
&bean id=&scheduler& class=&org.springframework.scheduling.quartz.SchedulerFactoryBean&&
&property name=&triggers&&
&ref bean=&myTrigger&/&
&/property&
所有的配置都在xml中完成，包括cronExpression表达式，十分的方便。但是如果我的任务信息是保存在数据库的，想要动态的初始化，而且任务较多的时候不是得有一大堆的xml配置？或者说我要修改一下trigger的表达式，使原来5秒运行一次的任务变成10秒运行一次，这时问题就来了，试过在配置文件中不传入cronExpression等参数，但是启动时就报错了，难道我每次都修改xml文件然后重启应用吗，这显然不合适的。最理想的是在与spring整合的同时又能实现动态任务的添加、删除及修改配置。
我们来看一下spring实现quartz的方式，先看一下上面配置文件中定义的jobDetail。其实上面生成的jobDetail并不是我们定义的Bean，因为在Quartz 2.x版本中JobDetail已经是一个接口（当然以前的版本也并非直接生成JobDetail）：
public interface JobDetail extends Serializable, Cloneable {...｝
Spring是通过将其转换为MethodInvokingJob或StatefulMethodInvokingJob类型来实现的，这两个都是静态的内部类，MethodInvokingJob类继承于QuartzJobBean，而StatefulMethodInvokingJob则直接继承于MethodInvokingJob。 这两个类的实现区别在于有状态和无状态，对应于quartz的Job和StatefulJob，具体可以查看quartz文档，这里不再赘述。先来看一下它们实现的QuartzJobBean的主要代码：
* This implementation applies the passed-in job data map as bean property
* values, and delegates to &code&executeInternal&/code& afterwards.
* @see #executeInternal
public final void execute(JobExecutionContext context) throws JobExecutionException {
// Reflectively adapting to differences between Quartz 1.x and Quartz 2.0...
Scheduler scheduler = (Scheduler) ReflectionUtils.invokeMethod(getSchedulerMethod, context);
Map mergedJobDataMap = (Map) ReflectionUtils.invokeMethod(getMergedJobDataMapMethod, context);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
MutablePropertyValues pvs = new MutablePropertyValues();
pvs.addPropertyValues(scheduler.getContext());
pvs.addPropertyValues(mergedJobDataMap);
bw.setPropertyValues(pvs, true);
catch (SchedulerException ex) {
throw new JobExecutionException(ex);
executeInternal(context);
* Execute the actual job. The job data map will already have been
* applied as bean property values by execute. The contract is
* exactly the same as for the standard Quartz execute method.
* @see #execute
protected abstract void executeInternal(JobExecutionContext context) throws JobExecutionE
还有MethodInvokingJobDetailFactoryBean中的代码：
public void afterPropertiesSet() throws ClassNotFoundException, NoSuchMethodException {
prepare();
// Use specific name if given, else fall back to bean name.
String name = (this.name != null ? this.name : this.beanName);
// Consider the concurrent flag to choose between stateful and stateless job.
Class jobClass = (this.concurrent ? MethodInvokingJob.class : StatefulMethodInvokingJob.class);
// Build JobDetail instance.
if (jobDetailImplClass != null) {
// Using Quartz 2.0 JobDetailImpl class...
this.jobDetail = (JobDetail) BeanUtils.instantiate(jobDetailImplClass);
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this.jobDetail);
bw.setPropertyValue(&name&, name);
bw.setPropertyValue(&group&, this.group);
bw.setPropertyValue(&jobClass&, jobClass);
bw.setPropertyValue(&durability&, true);
((JobDataMap) bw.getPropertyValue(&jobDataMap&)).put(&methodInvoker&, this);
// Using Quartz 1.x JobDetail class...
this.jobDetail = new JobDetail(name, this.group, jobClass);
this.jobDetail.setVolatility(true);
this.jobDetail.setDurability(true);
this.jobDetail.getJobDataMap().put(&methodInvoker&, this);
// Register job listener names.
if (this.jobListenerNames != null) {
for (String jobListenerName : this.jobListenerNames) {
if (jobDetailImplClass != null) {
throw new IllegalStateException(&Non-global JobListeners not supported on Quartz 2 - & +
&manually register a Matcher against the Quartz ListenerManager instead&);
this.jobDetail.addJobListener(jobListenerName);
postProcessJobDetail(this.jobDetail);
上面主要看我们目前用的Quartz 2.0版本的实现部分，到这里或许你已经明白Spring对Quartz的封装原理了。Spring就是通过这种方式在最后Job真正执行时反调用到我们所注入的类和方法。
现在，理解了Spring的实现原理后，我们就可以来设计我们自己的了。在设计时我想到以下几点：
1、减少spring的配置文件，为了实现一个定时任务，spring的配置代码太多了。
2、用户可以通过页面等方式添加、启用、禁用某个任务。
3、用户可以修改某个已经在运行任务的运行时间表达式，CronExpression。
4、为方便维护，简化任务的运行调用处理，任务的运行入口即Job实现类最好只有一个，该Job运行类相当于工厂类，在实际调用时把任务的相关信息通过参数方式传入，由该工厂类根据任务信息来具体执行需要的操作。
在上面的思路下来进行我们的开发吧。
一、spring配置文件
通过研究，发现要实现我们的功能，只需要以下配置：
&bean id=&schedulerFactoryBean& class=&org.springframework.scheduling.quartz.SchedulerFactoryBean& /&
二、任务运行入口，即Job实现类，在这里我把它看作工厂类：
* 定时任务运行工厂类
* User: liyd
* Date: 14-1-3
* Time: 上午10:11
public class QuartzJobFactory implements Job {
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println(&任务成功运行&);
ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get(&scheduleJob&);
System.out.println(&任务名称 = [& + scheduleJob.getJobName() + &]&);
这里我们实现的是无状态的Job，如果要实现有状态的Job在以前是实现StatefulJob接口，在我使用的quartz 2.2.1中，StatefulJob接口已经不推荐使用了，换成了注解的方式，只需要给你实现的Job类加上注解@DisallowConcurrentExecution即可实现有状态：
* 定时任务运行工厂类
* User: liyd
* Date: 14-1-3
* Time: 上午10:11
@DisallowConcurrentExecution
public class QuartzJobFactory implements Job {...}
三、创建任务
既然要动态的创建任务，我们的任务信息当然要保存在某个地方了，这里我们新建一个保存任务信息对应的实体类：
* 计划任务信息
* User: liyd
* Date: 14-1-3
* Time: 上午10:24
public class ScheduleJob {
/** 任务id */
private String jobId;
/** 任务名称 */
private String jobN
/** 任务分组 */
private String jobG
/** 任务状态 0禁用 1启用 2删除*/
private String jobS
/** 任务运行时间表达式 */
private String cronE
/** 任务描述 */
getter and setter ....
接下来我们创建测试数据，实际应用中该数据可以保存在数据库等地方，我们把任务的分组名+任务名作为任务的唯一key，和quartz中的实现方式一致：
/** 计划任务map */
private static Map&String, ScheduleJob& jobMap = new HashMap&String, ScheduleJob&();
for (int i = 0; i & 5; i++) {
ScheduleJob job = new ScheduleJob();
job.setJobId(&10001& + i);
job.setJobName(&data_import& + i);
job.setJobGroup(&dataWork&);
job.setJobStatus(&1&);
job.setCronExpression(&0/5 * * * * ?&);
job.setDesc(&数据导入任务&);
addJob(job);
* 添加任务
* @param scheduleJob
public static void addJob(ScheduleJob scheduleJob) {
jobMap.put(scheduleJob.getJobGroup() + &_& + scheduleJob.getJobName(), scheduleJob);
有了调度工厂，有了任务运行入口实现类，有了任务信息，接下来就是创建我们的定时任务了，在这里我把它设计成一个Job对应一个trigger，两者的分组及名称相同，方便管理，条理也比较清晰，在创建任务时如果不存在新建一个，如果已经存在则更新任务，主要代码如下：
//schedulerFactoryBean 由spring创建注入
Scheduler scheduler = schedulerFactoryBean.getScheduler();
//这里获取任务信息数据
List&ScheduleJob& jobList = DataWorkContext.getAllJob();
for (ScheduleJob job : jobList) {
TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
//获取trigger，即在spring配置文件中定义的 bean id=&myTrigger&
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//不存在，创建一个
if (null == trigger) {
JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
.withIdentity(job.getJobName(), job.getJobGroup()).build();
jobDetail.getJobDataMap().put(&scheduleJob&, job);
//表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
.getCronExpression());
//按新的cronExpression表达式构建一个新的trigger
trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
// Trigger已存在，那么更新相应的定时设置
//表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
.getCronExpression());
//按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
.withSchedule(scheduleBuilder).build();
//按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
如此，可以说已经完成了我们的动态任务创建，大功告成了。有了上面的代码，添加和修改任务是不是也会了，顺道解决了？
上面我们创建的5个测试任务，都是5秒执行一次，都将调用QuartzJobFactory的execute方法，但是传入的任务信息参数不同，execute方法中的如下代码就是得到具体的任务信息，包括任务分组和任务名：
ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get(&scheduleJob&);
有了任务分组和任务名即确定了该任务的唯一性，接下来需要什么操作实现起来是不是就很容易了？
以后需要添加新的定时任务只需要在任务信息列表中加入记录即可，然后在execute方法中通过判断任务分组和任务名来实现你具体的操作。
以上已经初始实现了我们需要的功能，增加和修改也已经可以通过源代码举一反三出来，但是我们在实际开发的时候需要进行测试，如果一个任务是1个小时运行一次的，测试起来是不是很不方便？当然你可以修改任务的运行时间表达式，但相信这不是最好的方法，接下来我们就要实现在不对当前任务信息做任何修改的情况下触发任务，并且该触发只会运行一次作测试用。待续，，，
本文标题：Spring 3整合Quartz 2实现定时任务二：动态添加任务
本文地址：
本文来自，转载请注明出处
交流QQ群：在Java的Spring框架中配置Quartz的教程
作者：huazhizui
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了在Java的Spring框架中配置Quartz的教程,Quartz是一款高人气的开源作业调度框架,需要的朋友可以参考下
Spring中配置Quartz的过程：
1.导入JAR包
quartz需要的JAR包，已经包含在spring中,位置在spring解压后目录的 \lib\quartz 下的quartz-all-1.6.1.jar，
将其拷贝到工程 的 WEB-INF/lib 下就行了。
2.配置web.xml,让spring启动时加载quartz的配置文件
&?xml version="1.0" encoding="UTF-8"?&
&web-app version="2.5" xmlns="/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="/xml/ns/javaee
/xml/ns/javaee/web-app_2_5.xsd"&
&!-- spring --&
&context-param&
&param-name&contextConfigLocation&/param-name&
&param-value&classpath:application-*.xml&/param-value&
&/context-param&
&!-- spring监听 --&
&listener&
&listener-class&
org.springframework.web.context.ContextLoaderListener
&/listener-class&
&/listener&
&/web-app&
3.编写quartz的配置文件: application-quartz.xml 其实这些配置完全可以写在其他的spring配置文件里
&?xml version="1.0" encoding="UTF-8"?&
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"&
&!-- 任务实体 --&
&bean id="testTaskBean" class="com.jp.task.TestTask" /&
&!-- 定时更新政策任务方法 --&
&bean id="testTaskTimerMethod"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject" ref="testTaskBean" /&
&!-- targetMethod 配置定时执行的方法名 --&
&property name="targetMethod" value="executeAction" /&
&property name="concurrent" value="false" /&
&!-- 定时更新政策触发器 --&
&bean id="testTaskTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="syncPolicyTaskTimerMethod" /&
&!-- 每个3分钟的第0秒执行 --&
&property name="cronExpression" value="0 0/3 * * * ?" /&
&!-- 订制任务列表 --&
&bean id="scheduler"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="testTaskTrigger" /&
&/property&
4.编写执行任务的JAVA类 TestTask
package com.jp.
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
public class TestTask extends QuartzJobBean{
Logger log = Logger.getLogger( PolicyServiceTest.class );
public void executeAction(){
("Hello quartz");
protected void executeInternal(JobExecutionContext arg0)
throws JobExecutionException {
5.所有工作准备完毕，一运行。基本上就报错了。大约是NoSuchMethod这样的错误。
这是由于commons-collections.jar版本太低引起的。要commons-collections-3.2.jar以上。
这时你找工程中却是有个commons-collections-3.2.jar。 怎么回事呢，再找会发现在hibernate的里有个commons-collections-2.1.1.jar。
将commons-collections-2.1.1.jar删掉就行了。
PS:cronExpression——Cron表达式说明
年（可选字段）&
Cron 触发器利用一系列特殊字符，如下所示：&
反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。&
问号（?）字符和字母 L 字符只有在月内日期和周内日期字段中可用。问号表示这个字段不包含具体值。所以，如果指定月内日期，可以在周内日期字段中插入“?”，表示周内日期值无关紧要。字母 L 字符是 last 的缩写。放在月内日期字段中，表示安排在当月最后一天执行。在周内日期字段中，如果“L”单独存在，就等于“7”，否则代表当月内周内日期的最后一个实例。所以“0L”表示安排在当月的最后一个星期日执行。&
在月内日期字段中的字母（W）字符把执行安排在最靠近指定值的工作日。把“1W”放在月内日期字段中，表示把执行安排在当月的第一个工作日内。&
井号（#）字符为给定月份指定具体的工作日实例。把“MON#2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。&
星号（*）字符是通配字符，表示该字段可以接受任何可能的值。&
字段 允许值 允许的特殊字符&&：
秒 0-59 , - * /&&
分 0-59 , - * /&&
小时 0-23 , - * /&&
日期 1-31 , - * ? / L W C&&
月份 1-12 或者 JAN-DEC , - * /&&
星期 1-7 或者 SUN-SAT , - * ? / L C #&&
年（可选） 留空,
表达式意义&&
"0 0 12 * * ?" 每天中午12点触发&&
"0 15 10 ? * *" 每天上午10:15触发&&
"0 15 10 * * ?" 每天上午10:15触发&&
"0 15 10 * * ? *" 每天上午10:15触发&&
"0 15 10 * * ? 年的每天上午10:15触发&&
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发&&
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发&&
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发&&
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发&&
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发&&
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发&&
"0 15 10 15 * ?" 每月15日上午10:15触发&&
"0 15 10 L * ?" 每月最后一日的上午10:15触发&&
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发&&
"0 15 10 ? * 6L " 2002年至2005年的每月的最后一个星期五上午10:15触发&&
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发&&
每天早上6点&
0 6 * * *&
每两个小时&
0 */2 * * *&&
晚上11点到早上8点之间每两个小时，早上八点&
0 23-7/2，8 * * *&
每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点&
0 11 4 * 1-3&&
1月1日早上4点&
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具quartz2.2.1的基本操作 - CSDN博客
quartz2.2.1的基本操作
* 添加任务到任务队列
* @param scheduleJob
* @throws SchedulerException
* @throws ClassNotFoundException
public ScheduleJob addJob(ScheduleJob job) throws SchedulerException, ClassNotFoundException {
if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
log.debug(scheduler
+ &.......................................................................................add&);
TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
// 不存在，创建一个
if (null == trigger) {
Class clazz = Class.forName(job.getBeanClass());
JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();
jobDetail.getJobDataMap().put(&scheduleJob&, job);
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup())
.withSchedule(scheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
// Trigger已存在，那么更新相应的定时设置
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
// 得到任务下一次的计划执行时间
Date nextProcessTime = trigger.getNextFireTime();
job.setNextProcessTime(nextProcessTime);
* 服务器启动，加载job_status=1的任务到任务队列中
* @throws Exception
@PostConstruct
public void init() throws Exception {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
// 这里获取任务信息数据
List&ScheduleJob& jobList = scheduleJobMapper.getAllJobs();
for (ScheduleJob job : jobList) {
addJob(job);
* 获取所有计划中的任务列表
* @throws SchedulerException
@Deprecated
public List&ScheduleJob& getAllJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
GroupMatcher&JobKey& matcher = GroupMatcher.anyJobGroup();
Set&JobKey& jobKeys = scheduler.getJobKeys(matcher);
List&ScheduleJob& jobList = new ArrayList&ScheduleJob&();
for (JobKey jobKey : jobKeys) {
List&? extends Trigger& triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
ScheduleJob job = new ScheduleJob();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setDescription(&触发器:& + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger)
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
jobList.add(job);
return jobL
* 获取所有正在运行的job
* @throws SchedulerException
@Deprecated
public List&ScheduleJob& getRunningJob() throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
List&JobExecutionContext& executingJobs = scheduler.getCurrentlyExecutingJobs();
List&ScheduleJob& jobList = new ArrayList&ScheduleJob&(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.setDescription(&触发器:& + trigger.getKey());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setJobStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger)
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
jobList.add(job);
return jobL
* 暂停一个job
* @param scheduleJob
* @throws SchedulerException
@Deprecated
public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.pauseJob(jobKey);
* 恢复一个job
* @param scheduleJob
* @throws SchedulerException
@Deprecated
public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.resumeJob(jobKey);
* 删除一个job
* @param scheduleJob
* @throws SchedulerException
public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.deleteJob(jobKey);
* 立即执行job
* @param scheduleJob
* @throws SchedulerException
public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
scheduler.triggerJob(jobKey);
* 更新job时间表达式
* @param scheduleJob
* @throws SchedulerException
public ScheduleJob updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
Scheduler scheduler = schedulerFactoryBean.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
scheduler.rescheduleJob(triggerKey, trigger);
// 得到任务下一次的计划执行时间
Date nextProcessTime = trigger.getNextFireTime();
scheduleJob.setNextProcessTime(nextProcessTime);
return scheduleJ
}Schdulejob实体类:&pre name=&code& class=&java&&public class ScheduleJob {
public static final String STATUS_RUNNING = &1&;
public static final String STATUS_NOT_RUNNING = &0&;
private Long jobId;
* 任务创建时间
private Date createT
* 任务更新时间
private Date updateT
* 上一次执行时间
private Date lastProcessT
* 下次计划执行时间
private Date nextProcessT
* 任务名称
private String jobN
* 任务分组
private String jobG
* 任务状态 是否启动任务
private String jobS
* cron表达式
private String cronE
* 任务执行时调用哪个类的方法 包名+类名
private String beanC
private List&JobParam& JobParamL
public Long getJobId() {
return jobId;
public void setJobId(Long jobId) {
this.jobId = jobId;
public Date getCreateTime() {
return createT
public void setCreateTime(Date createTime) throws ParseException {
this.createTime = createT
public Date getUpdateTime() {
return updateT
public void setUpdateTime(Date updateTime) {
this.updateTime = updateT
public String getJobName() {
return jobN
public void setJobName(String jobName) {
this.jobName = jobN
public String getJobGroup() {
return jobG
public void setJobGroup(String jobGroup) {
this.jobGroup = jobG
public String getJobStatus() {
return jobS
public void setJobStatus(String jobStatus) {
this.jobStatus = jobS
public String getCronExpression() {
return cronE
public void setCronExpression(String cronExpression) {
this.cronExpression = cronE
public String getDescription() {
public void setDescription(String description) {
this.description =
public String getBeanClass() {
return beanC
public void setBeanClass(String beanClass) {
this.beanClass = beanC
public List&JobParam& getJobParamList() {
return JobParamL
public void setJobParamList(List&JobParam& jobParamList) {
JobParamList = jobParamL
public Date getNextProcessTime() {
return nextProcessT
public void setNextProcessTime(Date nextProcessTime) {
this.nextProcessTime = nextProcessT
public Date getLastProcessTime() {
return lastProcessT
public void setLastProcessTime(Date lastProcessTime) {
this.lastProcessTime = lastProcessT
本文已收录于以下专栏：
相关文章推荐
最近项目中需要用到定时任务的功能，虽然Spring 也自带了一个轻量级的定时任务实现，但感觉不够灵活，功能也不够强大。在考虑之后，决定整合更为专业的Quartz来实现定时任务功能。普通定时任务首先，当...
　　系列文章：[传送门]
　　项目需求：
　　　　　/Alandre/p/3733249.html
　　　　　上一博客写的是基...
1.创建动态定时任务实体import java.util.D
import javax.persistence.C
import javax.persistence.E...
1：引入spring调度工厂类
   
2：编写调度管理类
@Service(&quartzManagerJob&)
@Scope(ConfigurableBeanFactory.SCOPE...
说在前面：Spring Quartz动态添加、修改、删除、关闭定时任务， 无非就是将
《Spring task quartz 示例
一文中的Spring quartz示例
《Quartz ...
今天在做Spring Quarter动态设置触发时间时，需要在Service中注入org.springframework.scheduling.quartz.SchedulerFactoryBean使...
一般情况下，quartz的job中使用autowired注解注入的对象为空，这时候我们就要使用spring-quartz提供的AdaptableJobFactory类。
自定义一个类:public ...
quartz分布式
当定时任务越来越多时，集中管理Job越有必要。Quartz提供了一组API，来管理Job。
他的最新文章
讲师：宋宝华
讲师：何宇健
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)