Spring Quartz 动态配置定时任务 - 海阔凭鱼跃 天高任鸟飞 - ITeye技术网站
博客分类：
1、Quartz在Spring中的简单配置
Spring配置文件quartz.xml：
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&
&bean id="scheduleInfoService" class="com.erry.tntops.web.task.ScheduleInfoService"&
&property name="scheduler" ref="schedulerFactory"/&
&bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject" ref="scheduleInfoService"/&
&property name="targetMethod" value="test"/&
&property name="concurrent" value="false"/&
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" &
&property name="jobDetail" ref="jobDetail"/&
&property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
&bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="cronTrigger"/&
&/property&
&/beans&
在上面的配置中设定：
① targetMethod: 指定需要定时执行scheduleInfoAction中的test()方法
② concurrent：对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，第二个job就开始了。指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。
③ cronExpression：0/10 * * * * ?表示每10秒执行一次，具体可参考附表。
④ triggers：通过再添加其他的ref元素可在list中放置多个触发器。
scheduleInfoAction中的simpleJobTest()方法
注意：此方法没有参数，如果scheduleInfoAction有两个方法test()和test(String argument)，则spring只会去执行无参的test().
public void test() {
log.warn("uh oh, Job is scheduled !'" + "' Success...");
}
2、Quartz在Spring中动态设置cronTrigger方法一
（1）、Spring配置文件quartz.xml：
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&
&bean id="scheduleInfoAction" class="com.erry.tntops.web.task.ScheduleInfoAction"&
&property name="scheduler" ref="schedulerFactory"/&
&!-- ref中的emsService是xml中配置的bean的id --&
&property name="emsService" ref="emsService"/&
&bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject" ref="scheduleInfoAction"/&
&property name="targetMethod" value="reScheduleJob"/&
&property name="concurrent" value="false"/&
&bean id="cronTrigger" class="com.erry.tntops.web.task.InitCronTrigger"&
&property name="jobDetail" ref="jobDetail"/&
&property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
&bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="cronTrigger"/&
&/property&
&/beans&
（2）、类ScheduleInfoAction：
import org.apache.log4j.L
import org.quartz.S
import org.quartz.SchedulerE
import org.springframework.scheduling.quartz.CronTriggerB
import java.text.ParseE
import java.util.D
public class ScheduleInfoAction{
Logger logger = Logger.getLogger(ScheduleInfoAction.class);
// 设值注入，通过setter方法传入被调用者的实例scheduler
public void setScheduler(Scheduler scheduler) {
this.scheduler =
private EmsService emsS
public void setEmsService(EmsService emsService){
this.emsService = emsS
public void reScheduleJob() throws SchedulerException {
// 运行时可通过动态注入的scheduler得到trigger，注意采用这种注入方式在有的项目中会有问题，如果遇到注入问题，可以采取在运行方法时候，获得bean来避免错误发生。
CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);
("*********** trigger: " + trigger);
String dbCronExpression = getCronExpressionFromDB();
("*********** dbCronExpression: " + dbCronExpression);
String originConExpression = trigger.getCronExpression();
("*********** originConExpression: " + originConExpression);
// 判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等
// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
if(!originConExpression.equalsIgnoreCase(dbCronExpression)){
trigger.setCronExpression(dbCronExpression);
scheduler.rescheduleJob("cronTrigger", Scheduler.DEFAULT_GROUP, trigger);
} catch (ParseException e) {
logger.error("------------------- ParseException Error! -------------------");
e.printStackTrace();
logger.error("-------------------------------------------------------------");
//执行task
("task start time: " + new Date());
System.out.println("Task test success!");
task end time: " + new Date());
private String getCronExpressionFromDB(){
String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";
return emsService.getCron(sql);
}
3、Quartz在Spring中动态设置cronTrigger方法二
在2中我们已经能够实现动态配置cronException，但是我们依然需要设定一个默认的cronException：
&&&&&&&&& &property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
如果我们拿掉它，则容器（如Jboss）会报错。
实际上我们希望容器启动时就去数据库获得dbCronException,而不需要再初始化一个cronException。观察CronTriggerBean，需要初始化cronException，我们可以创建类InitCronTrigger继承CronTriggerBean，从DB中获得数据初始化cronException，这样问题就解决了。
（1）、Spring配置文件quartz.xml：
&?xml version="1.0" encoding="UTF-8"?&
&!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&
&bean id="scheduleInfoAction" class="wym.task.ScheduleInfoAction"&
&property name="scheduler" ref="schedulerFactory"/&
&property name="emsService" ref="EmsService"/&
&bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject" ref="scheduleInfoAction"/&
&property name="targetMethod" value="reScheduleJob"/&
&!-- concurrent设为false，多个job不会并发运行 --&
&property name="concurrent" value="false"/&
&bean id="cronTrigger" class="wym.task.InitCronTrigger"&
&property name="jobDetail" ref="jobDetail"/&
&!--&property name="cronExpression"&--&
&!--&value&0/30 * * * * ?&/value&--&
&!--&/property&--&
&property name="emsService" ref="EmsService"/&
&bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="cronTrigger"/&
&/property&
&/beans&
（2）、类InitCronTrigger
注意：在注入scheduleInfoManager属性的时候，我们可以去读取DB任务时间（之所以放在setter方法中，是因为需要在设置scheduleInfoManager后进行getCronExpressionFromDB()，否则，也可以①②逻辑把放在类的构造函数中）.
注意InitializingCronTrigger必须extends CronTriggerBean.
import com.erry.tntops.ems.service.EmsS
import org.springframework.scheduling.quartz.CronTriggerB
import java.io.S
import java.text.ParseE
public class InitCronTrigger extends CronTriggerBean implements Serializable {
private EmsService emsS
public void setEmsService(EmsService emsService) throws ParseException {
this.emsService = emsS
String cronException = getCronExceptionDB();
setCronExpression(cronException);
private String getCronExceptionDB(){
String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";
System.out.println("*****" + sql);
return emsService.getCron(sql);
浏览 11286
博主，你这好像知识查出一个任务执行，我这是多个要咋办啊？不肯能每个名字都叫“cronTrigger”吧？ 博主你的private String getCronExceptionDB()是怎么样引用到 public void reScheduleJob()中的呢？本人菜鸟。请多指教
可以用于多个任务吗？可以的。一个任务一个类。
EmsService 是什么？执行任务的类
浏览: 179058 次
来自: 上海
把service借口和java bean打成jar包放到客户端 ...
非常感谢楼主，在网上找了好几个Spring、RMI的代码例子， ...
按照上述步骤配置不成功啊，报java.lang.ClassNo ...
小鱼不爱水 写道博主，你这好像知识查出一个任务执行，我这是多个 ...
博主，你这好像知识查出一个任务执行，我这是多个要咋办啊？不肯能 ...您现在的位置：&&>>&&>>&&>>&&>>&正文
Spring定时器时间配置
　　Quartz在Spring中动态设置cronExpression （spring设置动态定时任务）
　　 13:52
　　什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。
　　这样总不能修改配置文件每定制个定时任务就增加一个trigger吧，即便允许客户修改配置文件，但总需要重新启动web服务啊，研究了下Quartz在Spring中的动态定时，发现
　　&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" &
　　&property name="jobDetail" ref="schedulerJobDetail"/&
　　&property name="cronExpression"&
　　&value&0/10 * * * * ?&/value&
　　&/property&
　　&/bean&
　　中cronExpression是关键，如果可以动态设置cronExpression的值，也就说如果我们可以直接调用CronTriggerBean中设置cronExpression的方法，就可以顺利解决问题了。
　　熟悉1的朋友可以跳过不看，下面2、3是动态定时任务的具体实现。
　　1、Quartz在Spring中的简单配置
　　Spring配置文件：
　　&bean id="schedulerJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
　　&property name="targetObject" ref="scheduleInfoAction"/&
　　&property name="targetMethod" value="simpleJobTest"/&
　　&property name="concurrent" value="false"/&
　　&/bean&
　　&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" &
　　&property name="jobDetail" ref="schedulerJobDetail"/&
　　&property name="cronExpression"&
　　&value&0/10 * * * * ?&/value&
　　&/property&
　　&/bean&
　　&bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
　　&property name="triggers"&
　　&list&
　　&ref local="cronTrigger"/&
　　&/list&
　　&/property&
　　&/bean&
　　在上面的配置中设定了
　　① targetMethod: 指定需要定时执行scheduleInfoAction中的simpleJobTest()方法
　　② concurrent：对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，第二个job就开始了。指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。
　　③ cronExpression：0/10 * * * * ?表示每10秒执行一次，具体可参考附表。
　　④ triggers：通过再添加其他的ref元素可在list中放置多个触发器。
　　scheduleInfoAction中的simpleJobTest()方法，注意：此方法没有参数，如果scheduleInfoAction有两个方法simpleJobTest()和simpleJobTest(String argument)，则spring只会去执行无参的simpleJobTest().
　　public void simpleJobTest()
　　log.warn("uh oh, Job is scheduled !'" + "' Success...");
　　2．Quartz在Spring中动态设置cronTrigger方法一
　　Spring配置文件：
　　&bean id="scheduleInfoAction" class="com.lively.happyoa.jobs.webapp.action.ScheduleInfoAction"&
　　&property name="scheduler" ref="schedulerFactory"/&
　　&property name="scheduleInfoManager" ref="scheduleInfoManager"/&
　　&/bean&
　　&bean id="schedulerJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
　　&property name="targetObject" ref="scheduleInfoAction"/&
　　&property name="targetMethod" value="reScheduleJob"/&
　　&property name="concurrent" value="false"/&
　　&/bean&
　　&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" &
　　&property name="jobDetail" ref="schedulerJobDetail"/&
　　&property name="cronExpression"&
　　&value&0/10 * * * * ?&/value&
　　&/property&
　　&/bean&
　　&bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
　　&property name="triggers"&
　　&list&
　　&ref local="cronTrigger"/&
　　&/list&
　　&/property&
　　&/bean&
　　scheduleInfoAction中的reScheduleJob ()方法及相关方法
　　① reScheduleJob读取数据库，获得自定义定时器调度时间():
　　private void reScheduleJob() throws SchedulerException, ParseException
　　// 运行时可通过动态注入的scheduler得到trigger
　　CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);
　　String dbCronExpression = getCronExpressionFromDB();
　　String originConExpression = trigger.getCronExpression();
　　// 判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等
　　// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
　　if(!originConExpression.equalsIgnoreCase(dbCronExpression))
　　trigger.setCronExpression(dbCronExpression);
　　scheduler.rescheduleJob("cronTrigger", Scheduler.DEFAULT_GROUP, trigger);
【责编:ivy】
?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]?&[]
相关产品和培训
　友情推荐链接
　认证培训
　专题推荐
　?　?　?　?　?　?　?　?　?　?
　今日更新
?&?&?&?&?&?&?&?&?&?&
　社区讨论
　博客论点
　频道精选
　Java 频道导航Spring定时任务的动态配置 -
- ITeye技术网站
博客分类：
首先吐槽下，去年11月以实习生的身份来到现在的公司，到今年毕业转正，转正还没多久，社保卡都没发下来呢。实习这段时间没有怎么好好的学习工作吧，毕业后工资也不是很高，很多同学都比我高不少，无奈毕业季工作不好找也害怕去找就安稳的呆着，反正还有好多东西要学，工资也能养活自己，不用管家里要钱了吧。可是有的时候还是很不平衡，毕竟自我感觉自己的技术和很多工资比我高的同学相比，还算不赖吧！也算是对自己的考验吧，等把公司的东西都学会了自己的水平也提高了，再要高点，可能公司给多点的几率不大，那就再跳呗。
吐槽下自己，这一段时间太沉迷于游戏了，没有好好的利用时间整理自己的知识系统，有好多工作中领悟的东西都没及时记下来，到现在都忘记了。于是我打算从新来过，好好管理我的IT眼，好好工作学习。
好了，开始正题：Spring定时任务动态配置，我也有好多不懂的，既然来了就留下脚印，交流下把。吐槽下网上的好多动态配置定时任务的帖子，都是一样的，让我好是蛋疼。对比着来把。
首先是我们自己书写的类的Bean创建：
&bean id="logAdd2FARSTask" class="com.thid.business.task.LogAdd2FARSTask" &
&property name="scheduler" ref="schedulerFactory" /&
&property name="personAlarmLogService"&
&ref bean="personAlarmLogService"/&
&/property&
&bean id="logAdd2FARSTaskJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="logAdd2FARSTask" /&
&/property&
&property name="targetMethod"&
&value&addStart&/value&
&/property&
&property name="concurrent" value="false"/&
&bean id="logAdd2FARSTaskJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="logAdd2FARSTaskJob" /&
&/property&
&property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
&bean id="schedulerFactory"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean" &
&property name="triggers" &
&ref bean="logAdd2FARSTaskJobTrigger" /&
&/property&
&bean id="logAdd2FARSTask" class="com.thid.business.task.LogAdd2FARSTask" &
&property name="personAlarmLogService"&
&ref bean="personAlarmLogService"/&
&/property&
&bean id="logAdd2FARSTaskJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&ref bean="logAdd2FARSTask" /&
&/property&
&property name="targetMethod"&
&value&addStart&/value&
&/property&
&property name="concurrent" value="false"/&
&bean id="logAdd2FARSTaskJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail"&
&ref bean="logAdd2FARSTaskJob" /&
&/property&
&property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
&bean id="schedulerFactory"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean" &
&property name="triggers" &
&ref bean="logAdd2FARSTaskJobTrigger" /&
&/property&
本来想弄个颜色把不同的地方标注起来，可是不太会用~说吧，两者的区别就在于第一个Bean中，动态配置的时候需要将schedulerFactory这个类注入到我们写的业务类中，注意观察下就可以发现，这个schedulerFactory就是我们代码最后的对所有定时任务进行管理的定时器工厂类，可以看下哦！之所以要向我们自己写的类中注入工厂类是因为我们要通过工厂类对我们要动态配置的定时任务进行管理。其实动态任务的实现就是通过工厂类对定时任务的cronExpression进行更改管理，从而实现动态配置的目的。下面看下Java代码中是如何配置：
public void setPersonAlarmLogService(PersonAlarmLogService personAlarmLogService) throws ParseException, SchedulerException {
this.personAlarmLogService = personAlarmLogS
String triggerName = "logAdd2FARSTaskJobTrigger";
CronTriggerBean trigger = (CronTriggerBean)scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
if(trigger!=null){
SysParameter param = sysUserService.getSysParam();
String cronExpression = getCronExpressionFromDB(param);
trigger.setCronExpression(cronExpression);
* 自定义定时器调度时间
triggerName 触发器名称
public void updateNotificationInterval(String triggerName,SysParameter sysParameter)
SchedulerException, ParseException
// 得到trigger
CronTriggerBean trigger = (CronTriggerBean)scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
// 得到cron expression
if(trigger!=null){
String cronExpression = getCronExpressionFromDB(sysParameter);
String oldCronExpression = trigger.getCronExpression();
if(!oldCronExpression.equals(cronExpression)){
// 设置trigger的时间规则
trigger.setCronExpression(cronExpression);
// 重置job
scheduler.rescheduleJob(triggerName, Scheduler.DEFAULT_GROUP, trigger);
System.out.println(trigger.getCronExpression());
public String getCronExpressionFromDB(SysParameter sysParameter){
String dbCronExpression =
if(sysParameter==null){
dbCronExpression = "0 0 0 * * * ?";
String hour =sysParameter.getRev7();
dbCronExpression = "0"+" "+"0"+" "+"*/"+hour+" "+"*"+" "+"*"+" "+"?";
return dbCronE
首先如果我们不需要在服务器启动的时候去数据库读定时任务的执行时间的话，那么第一个方法可以直接跳过，但是大多数向做动态定时任务的都应该会在启动的时候去读数据库。简单做下介绍，这个方法是personAlarmLogService的set方法，在程序启动加载到这里的时候，会通过我们注入的scheduler的getTrigger查找名为logAdd2FARSTaskJobTrigger的触发器，如果找到了就从数据库中查询我们添加的执行方案，然后通过setCronExpression方法将执行方案设置到我们查找的trigger中，就形成了启动时的动态配置。
然后我们每次更改时间的时候，都调用下更改触发器的方法，在我的代码里是updateNotificationInterval方法。同样是通过名称获得trigger，然后setCornExpression,都进行完了之后别忘了从新启动定时任务,也就是这行代码
scheduler.rescheduleJob(triggerName, Scheduler.DEFAULT_GROUP, trigger);
还有就是这个类要继承CronTriggerBean类.
---------------------以下是我遇到的问题求解答--------------------
1. 网上的例子启动的时候就从数据库读取规则是不用设置时间规则，也就是下面这段不用配置，可是我把他注释掉会报错。求解答
&property name="cronExpression"&
&value&0/10 * * * * ?&/value&
&/property&
2.为什么我在工厂类的LIST中将这个触发器注释掉，会报错，然后再把下面代码注释掉就不报错了？这个service就是我在启动时设置定时任务的cronExpression的方法。
&property name="personAlarmLogService"&
&ref bean="personAlarmLogService"/&
&/property&
希望走过路过的兄弟姐妹们帮着小弟解答下问题，代码有点水见谅。
浏览: 48277 次
来自: 北京
Ztree教程-采用Jquery Ajax异步加载数据和Ztr ...Spring定时任务的几种实现 -
- ITeye技术网站
博客分类：
Spring定时任务的几种实现
近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合
spring框架来介绍。
从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：
Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。
使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。
从作业类的继承方式来讲，可以分为两类：
作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
作业类即普通的java类，不需要继承自任何基类。
注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。
从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：
每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean
注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。
二．用法说明
详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。
第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。
第一步：定义作业类
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
public class Job1 extends QuartzJobBean {
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout =
* 要调度的具体任务
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("定时任务执行中…");
第二步：spring配置文件中配置作业类JobDetailBean
&bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="com.gy.Job1" /&
&property name="jobDataAsMap"&
&entry key="timeout" value="0" /&
&/property&
说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheduling.quartz.SimpleTriggerBean
org.springframework.scheduling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：
&bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"&
&property name="jobDetail" ref="job1" /&
&property name="startDelay" value="0" /&&!-- 调度工厂实例化后，经过0秒开始执行调度 --&
&property name="repeatInterval" value="2000" /&&!-- 每2秒调度一次 --&
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job1" /&
&!—每天12:00运行一次 --&
&property name="cronExpression" value="0 0 12 * * ?" /&
关于cronExpression表达式的语法参见附录。
第四步：配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。
第二种，作业类不继承特定基类。
Spring能够支持这种方式，归功于两个类：
org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean
org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean
这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。
第一步：编写任务类
public class Job2 {
public void doJob2() {
System.out.println("不继承QuartzJobBean方式-调度进行中...");
可以看出，这就是一个普通的类，并且有一个方法。
第二步：配置作业类
&bean id="job2"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&property name="targetObject"&
&bean class="com.gy.Job2" /&
&/property&
&property name="targetMethod" value="doJob2" /&
&property name="concurrent" value="false" /&&!-- 作业不并发调度 --&
说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheduling.quartz.SimpleTriggerBean
org.springframework.scheduling.quartz.CronTriggerBean
第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。
配置方式如下：
&bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"&
&property name="jobDetail" ref="job2" /&
&property name="startDelay" value="0" /&&!-- 调度工厂实例化后，经过0秒开始执行调度 --&
&property name="repeatInterval" value="2000" /&&!-- 每2秒调度一次 --&
第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。
配置方式如下：
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="job2" /&
&!—每天12:00运行一次 --&
&property name="cronExpression" value="0 0 12 * * ?" /&
以上两种调度方式根据实际情况，任选一种即可。
第四步：配置调度工厂
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
说明：该参数指定的就是之前配置的触发器的名字。
第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。
到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。
其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！
请看我第下文Spring task的介绍。
Spring-Task
上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。
第一种：配置文件方式
第一步：编写作业类
即普通的pojo，如下：
import org.springframework.stereotype.S
public class TaskJob {
public void job1() {
System.out.println(“任务进行中。。。”);
第二步：在spring配置文件头中添加命名空间及描述
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:task="http://www.springframework.org/schema/task"
。。。。。。
xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"&
第三步：spring配置文件中设置具体的任务
&task:scheduled-tasks&
&task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/&
&/task:scheduled-tasks&
&context:component-scan base-package=" com.gy.mytask " /&
说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。
&context:component-scan base-package="com.gy.mytask" /&这个配置不消多说了，spring扫描注解用的。
到这里配置就完成了，是不是很简单。
第二种：使用注解形式
也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：
@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheduled
public abstract String cron();
public abstract long fixedDelay();
public abstract long fixedRate();
可以看出该注解有三个方法或者叫参数，分别表示的意思是：
cron：指定cron表达式
fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。
fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。
下面我来配置一下。
第一步：编写pojo
import org.springframework.scheduling.annotation.S
import org.
@Component(“taskJob”)
public class TaskJob {
@Scheduled(cron = "0 0 3 * * ?")
public void job1() {
System.out.println(“任务进行中。。。”);
第二步：添加task相关的配置：
&?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"
default-lazy-init="false"&
&context:annotation-config /&
&!—spring扫描注解的配置
&context:component-scan base-package="com.gy.mytask" /&
&!—开启这个配置，spring才能识别@Scheduled注解
&task:annotation-driven scheduler="qbScheduler" mode="proxy"/&
&task:scheduler id="qbScheduler" pool-size="10"/&
说明：理论上只需要加上&task:annotation-driven /&这句配置就可以了，这些参数都不是必须的。
Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。
cronExpression的配置说明，具体使用以及参数请百度google
允许的特殊字符
, - * ? / L W C
1-12 或者 JAN-DEC
1-7 或者 SUN-SAT
, - * ? / L C #
年（可选）
? 你不想设置那个字段
下面只例出几个式子
CRON表达式
"0 0 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分每分钟一次触发
"0 0/5 14 * * ?"
每天从下午2点开始到2：55分结束每5分钟一次触发
"0 0/5 14,18 * * ?"
每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发
"0 0-5 14 * * ?"
每天14:00至14:05每分钟一次触发
"0 10,44 14 ? 3 WED"
三月的每周三的14：10和14：44触发
"0 15 10 ? * MON-FRI"
每个周一、周二、周三、周四、周五的10：15触发
浏览 124192
您好，我用的您的第一种方法，然后改掉task之后，一直只是输出& 任务进行中。。。& 根本不执行我修改后的task啊，我把& job1中的 public void job1() {& &&&&&&& System.out.println(“任务进行中。。。”);& &&& }&& 注释掉之后还是输出& 任务进行中。。。请问这是为什么啊，急求您指点 谢谢断点& 打桩& 调试调试咯
& 上一页 1
浏览: 184803 次
来自: 北京
已经实现，谢谢 mark
如果使用黏性Session，应确保loadbalancer中配 ...
jaychang 写道感觉还是没有从根本上理解sticky s ...
感觉还是没有从根本上理解sticky session与non
leo_soul 写道博主，你配置non-sticky模式的时 ...