189 8069 5689
Spring利用Quartz实现一个动态定时任务？很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。
创新互联公司专注为客户提供全方位的互联网综合服务，包含不限于网站设计制作、网站设计、屏山网络推广、重庆小程序开发公司、屏山网络营销、屏山企业策划、屏山品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联公司为所有大学生创业者提供屏山建站搭建服务，24小时服务热线：13518219792，官方网址：www.cdcxhl.com
普通定时任务
首先，当然是添加依赖的jar文件，我的项目是maven管理的，以下的我项目的依赖：
org.springframework spring-core ${spring.version} org.springframework spring-context ${spring.version} org.springframework spring-web ${spring.version} org.springframework spring-tx ${spring.version} org.springframework spring-jdbc ${spring.version} org.mybatis mybatis ${mybatis.version} org.aspectj aspectjweaver 1.7.4 org.mybatis mybatis-spring ${mybatis.spring.version} org.slf4j slf4j-log4j12 ${slf4j.version} commons-lang commons-lang ${commons.lang.version} commons-dbcp commons-dbcp ${commons.dbcp.version} com.oracle ojdbc14 ${ojdbc.version} org.springframework spring-context-support ${spring.version} org.quartz-scheduler quartz ${quartz.version}
或许你应该看出来了，我的项目是spring整合了mybatis，目前spring的最新版本已经到了4.x系列，但是最新版的mybatis-spring的整合插件所依赖推荐的依然是spring 3.1.3.RELEASE，所以这里没有用spring的最新版而是用了推荐的3.1.3.RELEASE，毕竟最新版本的功能一般情况下也用不到。
至于quartz，则是用了目前的最新版2.2.1
之所以在这里特别对版本作一下说明，是因为spring和quartz的整合对版本是有要求的。
spring3.1以下的版本必须使用quartz1.x系列，3.1以上的版本才支持quartz 2.x，不然会出错。
至于原因，则是spring对于quartz的支持实现，org.springframework.scheduling.quartz.CronTriggerBean继承了org.quartz.CronTrigger，在quartz1.x系列中org.quartz.CronTrigger是个类，而在quartz2.x系列中org.quartz.CronTrigger变成了接口，从而造成无法用spring的方式配置quartz的触发器（trigger）。
在Spring中使用Quartz有两种方式实现：第一种是任务类继承QuartzJobBean，第二种则是在配置文件里定义任务类和要执行的方法，类和方法可以是普通类。很显然，第二种方式远比第一种方式来的灵活。
这里采用的就是第二种方式。
spring配置文件：
Task类则是一个普通的Java类，没有继承任何类和实现任何接口(当然可以用注解方式来声明bean)：
//@Component
public class DataConversionTask{
/** 日志对象 */
private static final Logger LOG = LoggerFactory.getLogger(DataConversionTask.class);
public void run() {
if (LOG.isInfoEnabled()) {
LOG.info("数据转换任务线程开始执行");
}
}
}至此，简单的整合大功告成，run方法将每隔5秒执行一次，因为配置了concurrent等于false，所以假如run方法的执行时间超过5秒，在执行完之前即使时间已经超过了5秒下一个定时计划执行任务仍不会被开启，如果是true，则不管是否执行完，时间到了都将开启。
接下去，将实现如何动态的修改定时执行的时间，以及如何停止正在执行的任务。
顺便贴一下cronExpression表达式备忘：
字段 允许值 允许的特殊字符
表达式意义
"0 0 12 * * ?" 每天中午12点触发 "0 15 10 ? * *" 每天上午10:15触发 "0 15 10 * * ?" 每天上午10:15触发 "0 15 10 * * ? *" 每天上午10:15触发 "0 15 10 * * ? 2005" 2005年的每天上午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" 2002年至2005年的每月的最后一个星期五上午10:15触发 "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 0 6 * * * 每天早上6点 0 */2 * * * 每两个小时 0 23-7/2，8 * * * 晚上11点到早上8点之间每两个小时，早上八点 0 11 4 * 1-3 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点 0 4 1 1 * 1月1日早上4点
动态添加定时任务
前面，我们已经对Spring和Quartz用配置文件的方式进行了整合，如果需求比较简单的话应该已经可以满足了。但是很多时候，我们常常会遇到需要动态的添加或修改任务，而spring中所提供的定时任务组件却只能够通过修改xml中trigger的配置才能控制定时任务的时间以及任务的启用或停止，这在带给我们方便的同时也失去了动态配置任务的灵活性。我搜索了一些网上的解决方法，都没有很好的解决这个问题，而且大多数提到的解决方案都停留在Quartz 1.x系列版本上，所用到的代码和API已经不能适用于新版本的Spring和Quartz。没办法只能靠自己了，花了点时间好好研究了一下Spring和Quartz中相关的代码。
首先我们来回顾一下spring中使用quartz的配置代码：
所有的配置都在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 executeInternal afterwards.
* @see #executeInternal
*/
public final void execute(JobExecutionContext context) throws JobExecutionException {
try {
// 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 JobExecutionException;
//还有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);
}
else {
// 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配置文件
通过研究，发现要实现我们的功能，只需要以下配置：
二、任务运行入口，即Job实现类，在这里我把它看作工厂类：
/**
* 定时任务运行工厂类
*
* @author tq
* @date 2016/5/1
*/
public class QuartzJobFactory implements Job {
@Override
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即可实现有状态：
/**
* 定时任务运行工厂类
* @author tq
* @date 2016/5/1
*/
@DisallowConcurrentExecution
public class QuartzJobFactory implements Job {...}三、创建任务
既然要动态的创建任务，我们的任务信息当然要保存在某个地方了，这里我们新建一个保存任务信息对应的实体类：
/**
* 计划任务信息
*
* @author tq
* @date 2016/5/1
*/
public class ScheduleJob {
/** 任务id */
private String jobId;
/** 任务名称 */
private String jobName;
/** 任务分组 */
private String jobGroup;
/** 任务状态 0禁用 1启用 2删除*/
private String jobStatus;
/** 任务运行时间表达式 */
private String cronExpression;
/** 任务描述 */
private String desc;
getter and setter ....
}接下来我们创建测试数据，实际应用中该数据可以保存在数据库等地方，我们把任务的分组名+任务名作为任务的唯一key，和quartz中的实现方式一致：