Spring Quartz 英文原文：Spring 3 Scheduler Example – JDK Timer and Quartz Showcase

Spring框架供应了实行和调解Task的笼统,支持线程池也许在运用Server状况中代理给CommonJ. Spring也集成了支持应用JDK Timer和Quartz调解库供应的Quartz Scheduler来完成Task调解的类.两种调解器颠末区分引用可选的Timer也许org.quartz.Trigger实例的工厂Bean来履行设置. 此外,还有一个可以同时满足Timer和Quartz Scheduler的类容许我们调用一个存在的目标Tools的方法.

在这篇教程中，我们将向你展示在Spring中怎样完成一个JDK Timer的例子，然后我们将应用Quartz Scheduler来丰富这个例子.

我们首选的开拓状况是Eclipse. 我们应用的Eclipse版本是Eclipse Juno (4.2)同时集成了版本为 3.1.0的Maven插件. 你可以从这里下载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 *** 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是项目Tools模型(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”页出息行编辑，以下所示:
 
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 自带的定时Task

4.1 创建一个轻易的Task

下面的MyTask.java 是个轻易的可以实行的Task

MyTask.java

package com.javacodegeeks.snippets.enterprise;

public class MyTask {
	public void sayHello() {
		System.out.println("Hello !!! ");
	}
}

4.2 在applicationContext.xml中建设Scheduler和Timer

Spring 应用自己完成的Task替代了JDK中的TimerTask,Spring的Task是可以被定时调用也许颠末Timer来重复调用的，它就是org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean。它也供应了关于JDK Timer的一个完成，它是一个后台线程用来调解Task的Tools类，这个类就是org.springframework.scheduling.timer.ScheduledTimerTask。
此外,还界说了一个TimerFactoryBean, 来启动计划Task的实行. 它是一个工厂Bean，它设置了一个流露给其他bean引用的Timer. 它容许注册ScheduledTimerTask,在容器启动的时离开启Timer然后在容器销毁的时分将它吊销。

需求实行计划Task的时分，我们需求做的就是在applicationContext.xml文件中界说上面一切提到过的类. 我们在myTask bean中指定MyTask.java类. 我们也需求界说schedulerBean, 它引用TimerTask类. 它有两个属性需求建设. targetObject的值引用我们自己完成的Taskbean,也就是myTask. targetMethod属性的值是需求被计划实行的Task方法.

timerTask这个bean是个Timer类型的bean。它有一个timerTask属性，我们可以颠末它设置对上面界说好的名为timerTask的bean的引用。这里我们可以使用delay参数来建设第一次末尾Task前的延不时间，单位是毫秒。我们也可以应用period参数来设置重复实行Task之间的间隔，单位也是毫秒。我们把它建设成每5秒钟实行一次，初度延时1秒钟。

TimerFactoryBean也界说在applicationContext.xml中。我们可以使用FactoryBean创建的Timer颠末scheduledTimerTask参数，来注册一系列ScheduledTimerTaskTools。这里，我们注册了界说好的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>

<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>

<bean class="org.springframework.scheduling.timer.TimerFactoryBean">
	<property name="scheduledTimerTasks">
		<list>
			<ref local="timerTask" />
		</list>
	</property>
</bean>
</beans>

5 Quartz调解器

5.1 Quartz调解器Task

为了应用Quartz调解器来丰富我们的例子，首先我们必须设置一个Quartzs调解器Task。可以用两种办法完成这一Task。第一种办法是在applicationContext.xml中把调解Task界说成Spring的一个bean。这个bean可所以一个org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean类，有两个建设参数targetObject和targetMethod，就像我们在上一步中所做的一样。不过，让我们来检验测验一个越发复杂的调解器吧。我们仅需创建一个类来承袭org.springframework.scheduling.quartz.QuartzJobBean，就可以够完成我们自己的两个调解器。MyTask.java可以颠末一个setter方法传递给调解器。随后，Task里的方法会在承袭自QuartzJobBean的调解Task的executeInternal(JobExecutionContext context)方法中被调用。

QuartzJob.java

package com.javacodegeeks.snippets.enterprise.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import com.javacodegeeks.snippets.enterprise.MyTask;

public class QuartzJob extends QuartzJobBean {
	
	private MyTask myTask;

	public void setMyTask(MyTask myTask) {
		this.myTask = myTask;
	}

	protected void executeInternal(JobExecutionContext context)
		throws JobExecutionException {
		myTask.sayHello(); 
	}
}

5.2 Quartz触发器

现在我们必须要来界说运转调解Task的Quartz触发器了。Quartz供应了两个类来完成触发器部分。在org.springframework.scheduling.quartz.SimpleTriggerBean中我们可以设置startTime，endTime和intervals来运转Task，而在org.springframework.scheduling.quartz.CronTriggerBean则支持UNIX的cron表达式来指定Task运转的时间。两种触发器类型都被界说成Spring的bean，而且两者都供应了一个jobDetail参数来设置对调度Task的引用。

还有一个建设Task是创建一个SchedulerFactoryBean，它可以整合调解Task和触发器。所以两个bean都被包含在SchedulerFactoryBean的界说中。

在applicationContext.xml中我们界说了一切的的bean，包括调解Task、触发器和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">
		  <map>
			<entry key="myTask" value-ref="myTask" />
		  </map>
		</property>
	</bean>
	
	<bean id="***Trigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean"> 
		<property name="jobDetail" ref="quartzJob" />
		<property name="repeatInterval" value="5000" />
		<property name="startDelay" value="1000" />
	</bean>
 
	<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
 		<property name="jobDetail" ref="quartzJob" />
		<property name="cronExpression" value="0/5 * * * * ?" /> 
	</bean>
 
	<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="jobDetails">
			<list>
				<ref bean="quartzJob" />
			</list>
		</property> 
		<property name="triggers">
			<list>
				<ref bean="cronTrigger" />
			</list>
		</property>
	</bean>
</beans>

留心，我们添加的两个触发器的完成，在SchedulerFactoryBean中只应用了其中一个。cronTrigger是org.springframework.scheduling.quartz.CronTriggerBean类型的完成，而***Trigger是org.springframework.scheduling.quartz.SimpleTriggerBean类型的完成。在SchedulerFactoryBean类型的bean的triggers参数中设置了对cronTrigger的引用，而在jobDetails参数中设置了对调度Task的引用。

需求留心的此外一件事是，名为quartzJob的bean的界说。这里颠末一个参数把QuartzTask类设定为org.springframework.scheduling.quartz.JobDetailBean类。该类有一个jobDataAsMap参数，Task会在这里履行注册。

6. 运转运用

在App.java类里，我们装载了applicationContext.xml文件并使运转运用次序的线程休眠30秒后再封锁上下文。一旦上下文被掀开，Task就会像上面安排的那样末尾运转。sayHello()方法每5秒钟被调用一次，两个案例都是。

App.java

package com.javacodegeeks.snippets.enterprise;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

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 Timer和Quartz的一个例子。

可以下载该教程的Eclipse项目 : SpringSchedulerQuartzExample.zip

本文中的一切译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接。 2KB翻译Task依照 CC 协议，假设我们的Task有侵犯到您的权益，请及时联系我们。

2KB项目（www.2kb.com，源码交易平台）,提供担保交易、源码交易、虚拟商品、在家创业、在线创业、任务交易、网站设计、软件设计、网络兼职、站长交易、域名交易、链接买卖、网站交易、广告买卖、站长培训、建站美工等服务