Spring 3 调度器示例 -
JDK 定时器和 Quartz 展示
-------------
新增文件夹...
新增文件夹
(多个标签用逗号分隔)
Spring框架提供了执行和调度任务的抽象,支持线程池或者在应用服务器环境中代理给. Spring也集成了支持使用JDK Timer和Quartz调度库提供的Quartz Scheduler来实现任务调度的类.两种调度器通过分别引用可选的Timer或者org.quartz.Trigger实例的工厂Bean来进行设置. 另外,还有一个可以同时满足Timer和Quartz Scheduler的类允许我们调用一个存在的目标对象的方法.
在这篇教程中，我们将向你展示在Spring中如何实现一个JDK Timer的例子，然后我们将使用Quartz Scheduler来丰富这个例子.
我们首选的开发环境是. 我们使用的Eclipse版本是Eclipse Juno (4.2)同时集成了版本为&3.1.0的插件. 你可以从下载Eclipse,然后从下载Maven插件.Eclipse中Maven插件的安装不在本教程的范围之内,我们将不在此进行讨论. 我们还用到了Spring3.2.3和JDK 7_u_21.
让我们开始吧.
1. 创建一个新的maven项目
Go to File -& Project -&Maven -& Maven Project.
在 “Select project name and location”向导页, 选择 “Create a simple project (skip archetype selection)”这个选项, 其他默认，点击“Next”.
在 “Enter an artifact id” 这个页面, 你可以定义你的项目名称和主包. 我们将设置 “Group Id” 的值为"com.javacodegeeks.snippets.enterprise"以及 “Artifact Id” 的值为"springexample". 这亮相是项目的所在包"com.javacodegeeks.snippets.enterprise.springexample"和项目名称"springexample".点击 “Finish”退出向导，会自动简历项目.
Maven 项目结构:
It consists of the following folders:
/src/main/java 文件夹,包含程序源文件信息 ,
/src/test/java 文件夹是所有测试信息contains all source files for unit tests,
/src/main/resources文件夹放置所有配置文件
/target 文件夹 放置编译和打包好的文件
&pom.xml是项目对象模型(POM)文件. 这一个文件包含项目所有的相关配置信息
2. 添加Spring 3.2.3依赖
在POM编辑器的&“Overview” 页中，定位到“Properties”一节，进行下列变更:
创建一个新的名为org.springframework.version的属性把其值设置为3.2.3.RELEASE.
切换到“Dependencies”页上，创建下面的依赖(你需要在该页的“Dependency Details”部分中填写“GroupId”, “Artifact Id”和“Version”等字段):
Group Id : org.springframework Artifact Id : spring-web Version : ${org.springframework.version}
或者，你也可以直接在Maven的pom.xml文件中添加Spring依赖，即直接在POM编辑器的“Pom.xml”页上进行编辑，如下所示:
&project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&com.javacodegeeks.snippets.enterprise&/groupId&
&artifactId&springexample&/artifactId&
&version&0.0.1-SNAPSHOT&/version&
&dependencies&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-core&/artifactId&
&version&${spring.version}&/version&
&/dependency&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-context&/artifactId&
&version&${spring.version}&/version&
&/dependency&
&/dependencies&
&properties&
&spring.version&3.2.3.RELEASE&/spring.version&
&/properties&
&/project& 正如你所见，Maven通过声明的方式来管理包依赖。一个本地库会被创建(默认在{user_home}/.m2 目录中)，所有需要的类库会从共有库中下载下来放置到本地库中。进而在其内部&– 库依赖关系会被自动的处理和控制。
3.添加 Quartz 依赖
在项目的pom.xml文件中添加 Quartz 依赖，下面是添加后的pom.xml文件内容
&project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&com.javacodegeeks.snippets.enterprise&/groupId&
&artifactId&springexample&/artifactId&
&version&0.0.1-SNAPSHOT&/version&
&dependencies&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-core&/artifactId&
&version&${spring.version}&/version&
&/dependency&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-context&/artifactId&
&version&${spring.version}&/version&
&/dependency&
&dependency&
&groupId&org.springframework&/groupId&
&artifactId&spring-tx&/artifactId&
&version&3.1.2.RELEASE&/version&
&/dependency&
&!-- 这里是 Quartz 框架依赖--&
&dependency&
&groupId&org.quartz-scheduler&/groupId&
&artifactId&quartz&/artifactId&
&version&1.8.6&/version&
&/dependency&
&/dependencies&
&properties&
&spring.version&3.2.3.RELEASE&/spring.version&
&/properties&
&/project& 4. 在Spring 中使用JDK 自带的定时任务
4.1 创建一个简单的任务
下面的MyTask.java 是个简单的可以执行的任务 MyTask.java
package com.javacodegeeks.snippets.
public class MyTask {
public void sayHello() {
System.out.println("Hello !!! ");
} 4.2 在applicationContext.xml中配置Scheduler和Timer
Spring 使用自己实现的Task取代了JDK中的,Spring的Task是可以被定时调用或者通过来重复调用的，它就是org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean。它也提供了对于JDK 的一个实现，它是一个后台线程用来调度任务的工具类，这个类就是org.springframework.scheduling.timer.ScheduledTimerTask。
另外,还定义了一个TimerFactoryBean, 来启动计划任务的执行. 它是一个工厂Bean，它设置了一个暴露给其他bean引用的Timer. 它允许注册ScheduledTimerTask,在容器启动的时候开启Timer然后在容器销毁的时候将它取消。
需要执行计划任务的时候，我们需要做的就是在applicationContext.xml文件中定义上面所有提到过的类. 我们在myTask bean中指定MyTask.java类. 我们也需要定义schedulerBean, 它引用TimerTask类. 它有两个属性需要配置. targetObject的值引用我们自己实现的任务bean,也就是myTask. targetMethod属性的值是需要被计划执行的任务方法.
timerTask这个bean是个Timer类型的bean。它有一个timerTask属性，我们可以通过它设置对上面定义好的名为timerTask的bean的引用。这里我们可以使用delay参数来配置第一次开始任务前的延时时间，单位是毫秒。我们也可以使用period参数来设置重复执行任务之间的间隔，单位也是毫秒。我们把它配置成每5秒钟执行一次，首次延时1秒钟。
TimerFactoryBean也定义在applicationContext.xml中。我们可以使用FactoryBean创建的Timer通过scheduledTimerTask参数，来注册一系列ScheduledTimerTask对象。这里，我们注册了定义好的timerTask。
applicationContext.xml
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd"&
&bean id="myTask" class="com.javacodegeeks.snippets.enterprise.MyTask" /&
&bean id="schedulerTask"
class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean"&
&property name="targetObject" ref="myTask" /&
&property name="targetMethod" value="sayHello" /&
&bean id="timerTask"
class="org.springframework.scheduling.timer.ScheduledTimerTask"&
&property name="timerTask" ref="schedulerTask" /&
&property name="delay" value="1000" /&
&property name="period" value="5000" /&
&bean class="org.springframework.scheduling.timer.TimerFactoryBean"&
&property name="scheduledTimerTasks"&
&ref local="timerTask" /&
&/property&
&/beans& 5 Quartz调度器
5.1 Quartz调度器任务
为了使用Quartz调度器来丰富我们的例子，首先我们必须设置一个Quartzs调度器任务。可以用两种方式实现这一工作。第一种方式是在applicationContext.xml中把调度任务定义成Spring的一个bean。这个bean可以是一个org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean类，有两个配置参数targetObject和targetMethod，就像我们在上一步中所做的一样。不过，让我们来尝试一个更加复杂的调度器吧。我们仅需创建一个类来继承org.springframework.scheduling.quartz.QuartzJobBean，就可以实现我们自己的两个调度器。MyTask.java可以通过一个setter方法传递给调度器。随后，任务里的方法会在继承自QuartzJobBean的调度任务的executeInternal(JobExecutionContext context)方法中被调用。
QuartzJob.java
package com.javacodegeeks.snippets.enterprise.
import org.quartz.JobExecutionC
import org.quartz.JobExecutionE
import org.springframework.scheduling.quartz.QuartzJobB
import com.javacodegeeks.snippets.enterprise.MyT
public class QuartzJob extends QuartzJobBean {
private MyTask myT
public void setMyTask(MyTask myTask) {
this.myTask = myT
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
myTask.sayHello();
} 5.2 Quartz触发器
现在我们必须要来定义运行调度任务的Quartz触发器了。Quartz提供了两个类来实现触发器部分。在org.springframework.scheduling.quartz.SimpleTriggerBean中我们可以设置startTime，endTime和intervals来运行任务，而在org.springframework.scheduling.quartz.CronTriggerBean则支持UNIX的cron表达式来指定任务运行的时间。两种触发器类型都被定义成Spring的bean，而且两者都提供了一个jobDetail参数来设置对调度任务的引用。
还有一个配置工作是创建一个SchedulerFactoryBean，它可以整合调度任务和触发器。所以两个bean都被包含在SchedulerFactoryBean的定义中。
在applicationContext.xml中我们定义了所有的的bean，包括调度任务、触发器和SchedulerFactoryBean。
applicationContext.xml
&beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.2.xsd"&
&bean id="myTask" class="com.javacodegeeks.snippets.enterprise.MyTask" /&
&!-- quartz --&
&bean name="quartzJob" class="org.springframework.scheduling.quartz.JobDetailBean"&
&property name="jobClass" value="com.javacodegeeks.snippets.enterprise.quartz.QuartzJob" /&
&property name="jobDataAsMap"&
&entry key="myTask" value-ref="myTask" /&
&/property&
&bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"&
&property name="jobDetail" ref="quartzJob" /&
&property name="repeatInterval" value="5000" /&
&property name="startDelay" value="1000" /&
&bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"&
&property name="jobDetail" ref="quartzJob" /&
&property name="cronExpression" value="0/5 * * * * ?" /&
&bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="jobDetails"&
&ref bean="quartzJob" /&
&/property&
&property name="triggers"&
&ref bean="cronTrigger" /&
&/property&
&/beans& 注意，我们添加的两个触发器的实现，在SchedulerFactoryBean中只使用了其中一个。cronTrigger是org.springframework.scheduling.quartz.CronTriggerBean类型的实现，而simpleTrigger是org.springframework.scheduling.quartz.SimpleTriggerBean类型的实现。在SchedulerFactoryBean类型的bean的triggers参数中设置了对cronTrigger的引用，而在jobDetails参数中设置了对调度任务的引用。
需要注意的另外一件事是，名为quartzJob的bean的定义。这里通过一个参数把Quartz任务类设定为org.springframework.scheduling.quartz.JobDetailBean类。该类有一个jobDataAsMap参数，任务会在这里进行注册。
6. 运行应用
在App.java类里，我们装载了applicationContext.xml文件并使运行应用程序的线程休眠30秒后再关闭上下文。一旦上下文被打开，任务就会像上面安排的那样开始运行。sayHello()方法每5秒钟被调用一次，两个案例都是。
package com.javacodegeeks.snippets.
import org.springframework.context.ConfigurableApplicationC
import org.springframework.context.support.ClassPathXmlApplicationC
public class App {
public static void main(String[] args) throws InterruptedException {
ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Thread.sleep(30000);
context.close();
} 这是关于Spring 3 Scheduler的两个实现JDK 和的一个例子。
可以下载该教程的Eclipse项目 :
本文地址：
原文地址：
相关资讯 　—　
相关文档 　—　
发布时间： 14:08:11
同类热门经验
10065次浏览
13431次浏览
13239次浏览
6737次浏览
14552次浏览
5553次浏览
OPEN-OPEN, all rights reserved.编程爱好者社区
使用自定义注解配置Quartz定时器
&&& 本文参考了博客网的博文《spring + quartz 定时器实现》,该博文地址为&&&& &&&& 原博文使用的是Quartz 2.X以下的版本，我使用的是Quartz 2.2.1版本，Spring版本请使用3.1以上的版本。原博文Cron表达式是配置在方法级别的@interface上面，一个方法只能使用相同的Cron表达式，我把Cron表达式放在方法@interface上，个人觉得更符合实际，这样同一个类上面可以配置多个不同时间运行的定时器。下面是代码：&& 首先定义注解：
import java.lang.annotation.D
import java.lang.annotation.ElementT
import java.lang.annotation.R
import java.lang.annotation.RetentionP
import java.lang.annotation.T
import org.
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface MyTriggerType {
String value() default &&;
&& 方法层面的注解：
import java.lang.annotation.D
import java.lang.annotation.ElementT
import java.lang.annotation.R
import java.lang.annotation.RetentionP
import java.lang.annotation.T
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface MyTriggerMethod {
/** 定义定时器触发时间 */
String cronExpression() default &&;
&&& Job类：
@MyTriggerType
public class MyAnnoJob {
@MyTriggerMethod(cronExpression = &0/1 * * * * ?&)
public void execute() {
System.out.println(&定时任务,每秒执行一次----------------&);
@MyTriggerMethod(cronExpression = &0/3 * * * * ?&)
public void execute2() {
System.out.println(&定时任务,每三秒执行一次----------------&);
&&& 重新SchedulerFactoryBean类：
import java.lang.reflect.M
import java.util.ArrayL
import java.util.L
import mons.logging.L
import mons.logging.LogF
import org.quartz.CronT
import org.quartz.JobD
import org.quartz.SchedulerE
import org.quartz.T
import org.springframework.context.ApplicationC
import org.springframework.scheduling.quartz.CronTriggerFactoryB
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB
import org.springframework.scheduling.quartz.SchedulerFactoryB
public class MyTriggerSchedulerFactoryBean extends SchedulerFactoryBean {
/** 日志 */
protected Log log = LogFactory.getLog(MySchedulerFactoryBean.class
.getName());
/** Spring 上下文 */
private ApplicationContext applicationC
public void setApplicationContext(ApplicationContext applicationContext) {
this.applicationContext = applicationC
public void registerJobsAndTriggers() throws SchedulerException {
// 获取所有bean name
String[] beanNames = applicationContext
.getBeanNamesForType(Object.class);
for (String beanName : beanNames) {
Class&?& targetClass = applicationContext.getType(beanName);
// 循环判断是否标记了MyTriggerType注解
if (targetClass.isAnnotationPresent(MyTriggerType.class)) {
Object targetObject = applicationContext.getBean(beanName);
// 获取时间表达式
String cronExpression = &&;
String targetMethod = &&;
MyTriggerMethod triggerMethod =
// 确定标记了MyTriggerMethod注解的方法名
Method[] methods = targetClass.getDeclaredMethods();
for (Method method : methods) {
if (method.isAnnotationPresent(MyTriggerMethod.class)) {
targetMethod = method.getName();
triggerMethod = (MyTriggerMethod) method
.getAnnotation(MyTriggerMethod.class);
cronExpression = triggerMethod.cronExpression();
// 注册定时器业务类
registerJobs(targetObject, targetMethod, beanName,
cronExpression);
} catch (Exception e) {
log.error(e);
* 注册定时器
* @param targetObject
* @param targetMethod
* @param beanName
* @param cronExpression
* @throws Exception
private void registerJobs(Object targetObject, String targetMethod,
String beanName, String cronExpression) throws Exception {
// 声明包装业务类
MethodInvokingJobDetailFactoryBean jobDetailFactoryBean = new MethodInvokingJobDetailFactoryBean();
jobDetailFactoryBean.setTargetObject(targetObject);
jobDetailFactoryBean.setTargetMethod(targetMethod);
jobDetailFactoryBean.setBeanName(beanName + &_& + targetMethod
+ &_Task&);
jobDetailFactoryBean.setName(beanName + &_& + targetMethod + &_Task&);
jobDetailFactoryBean.setConcurrent(false);
jobDetailFactoryBean.afterPropertiesSet();
//System.out.println(beanName + &_& + targetMethod+&-----cron=& + cronExpression);
// 获取JobDetail
JobDetail jobDetail = jobDetailFactoryBean.getObject();
// 声明定时器
CronTriggerFactoryBean cronTriggerBean = new CronTriggerFactoryBean();
cronTriggerBean.setJobDetail(jobDetail);
cronTriggerBean.setCronExpression(cronExpression);
cronTriggerBean.setName(beanName + &_& + targetMethod + &_Trigger&);
cronTriggerBean.setBeanName(beanName + &_& + targetMethod + &_Trigger&);
cronTriggerBean.afterPropertiesSet();
CronTrigger trigger = cronTriggerBean.getObject();
// 将定时器注册到factroy
List&Trigger& triggerList = new ArrayList&Trigger&();
triggerList.add(trigger);
Trigger[] triggers = (Trigger[]) triggerList
.toArray(new Trigger[triggerList.size()]);
setTriggers(triggers);
super.registerJobsAndTriggers();
&&& quartz配置：
&?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:jee=&http://www.springframework.org/schema/jee&
xsi:schemaLocation=&http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.1.xsd&&
&bean id=&job2& class=&com.anno.MyAnnoJob& /&
&bean id=&MyTriggerScheduler& class=&com.anno.MyTriggerSchedulerFactoryBean& /&
&&& 测试方法：
import java.util.concurrent.TimeU
import javax.annotation.R
import org.junit.T
import org.junit.runner.RunW
import org.quartz.SchedulerE
import org.springframework.context.ApplicationC
import org.springframework.context.support.ClassPathXmlApplicationC
import org.springframework.test.context.ContextC
import org.springframework.test.context.junit4.SpringJUnit4ClassR
public class TestAnnoTrigger {
ApplicationC
public static void main(String[] args) throws Exception {
TestAnnoTrigger t=new TestAnnoTrigger();
t.TestMyCron();
public void TestMyCron() throws Exception{
context=new ClassPathXmlApplicationContext(&classpath:config/myquartz-annoconfig.xml&);
TimeUnit.MINUTES.sleep(2);
&&& 没有使用Junit原因是我的电脑点击Run As Junit Test半天没反应，只好这样写了。
&& &全文完。
系统分类：&>>&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触发
浏览 55841
lj830723 写道我想知道，如果在项目运行过程中动态的增加定时任务，Spring-Task方式如何实现？这也是我想知道的，目前我们项目中的定时任务都没交给spring管理，全quartz的api，这样做到运行时修改调度策略。首先感谢各位支持~关于动态控制定时任务，这里没有提到。首先明确一点是，并不是动态增加定时任务，任务是你事先写好在项目中的，只不过是可以动态的开关而已。这里提供一个思路是：只要能够动态注入cronExpression的值就可以，而这是可以做到的。过程较复杂，三言两语也说不清，感兴趣同学可以自己研究下。
写的太好了，终于搞明白了事务 哪里提到事务了
& 上一页 1
浏览: 95858 次
来自: 北京
大赞啊，楼主逻辑思维很强，说道太清晰了！
Timer可以定时执行的，其他的都不错~
关于你的文章我看了一下，就第一点就是有漏洞的，关于Java.u ...
不错，正好用到，收了！}