spring任务调度

一、Quartz简介

Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。Spring对Quartz的集成与其对JDK Timer的集成在任务、触发器和调度计划的声明式配置方面等都非常相似。

Quartz的核心由两个接口和两个类组成：Job和Scheduler接口，JobDetail和Trigger类。不同于JDK Timer，任务不是从实现一个Job接口的类实例开始运行，实际上Quartz在需要的时候才创建job类实例。可以使用JobDetail类来包装任务状态，并传递一个信息给Job，或在一个Job的多次执行过程之间保存信息。

二、Quartz任务调度

1. 简单任务调度

在Quartz中创建一个任务并执行，只需要实现Job接口类，在其execute()方法中处理你的业务逻辑。下面举例说明。

HelloWorldJob.java

Java代码
1.package com.learnworld.quartz;
2.
3.import org.quartz.Job;
4.import org.quartz.JobExecutionContext;
5.import org.quartz.JobExecutionException;
6.
7.public class HelloWorldJob implements Job {
8.
9. public void execute(JobExecutionContext context) throws JobExecutionException {
10. //实现你的业务逻辑
11. System.out.println("Hello!");
12.
13. }
14.}
package com.learnworld.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloWorldJob implements Job {

public void execute(JobExecutionContext context) throws JobExecutionException {
//实现你的业务逻辑
System.out.println("Hello!");

}
}

HelloScheduling.java

Java代码
1.package com.learnworld.quartz;
2.
3.import java.util.Date;
4.
5.import org.quartz.JobDetail;
6.import org.quartz.Scheduler;
7.import org.quartz.SimpleTrigger;
8.import org.quartz.Trigger;
9.import org.quartz.impl.StdSchedulerFactory;
10.
11.public class HelloScheduling {
12. public static void main(String[] args) throws Exception {
13.
14. Scheduler scheduler = new StdSchedulerFactory().getScheduler();
15. scheduler.start();
16.
17. JobDetail jobDetail = new JobDetail("helloWorldJob",
18. Scheduler.DEFAULT_GROUP, HelloWorldJob.class);
19.
20. Trigger trigger = new SimpleTrigger("simpleTrigger",
21. Scheduler.DEFAULT_GROUP, new Date(), null,
22. SimpleTrigger.REPEAT_INDEFINITELY, 1000);
23.
24. scheduler.scheduleJob(jobDetail, trigger);
25.
26. }
27.}
package com.learnworld.quartz;

import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class HelloScheduling {
public static void main(String[] args) throws Exception {

Scheduler scheduler = new StdSchedulerFactory().getScheduler();
scheduler.start();

JobDetail jobDetail = new JobDetail("helloWorldJob",
Scheduler.DEFAULT_GROUP, HelloWorldJob.class);

Trigger trigger = new SimpleTrigger("simpleTrigger",
Scheduler.DEFAULT_GROUP, new Date(), null,
SimpleTrigger.REPEAT_INDEFINITELY, 1000);

scheduler.scheduleJob(jobDetail, trigger);

}
}

需要说明几点:

1)开始使用StdSchedulerFactory来获取Scheduler的实例。每一个scheduler可以被启动(start)、中止(stop)和暂停(pause)。如果一个scheduler没有被启动或已经被暂停，则没有触发器会被启用，所以首先使用start()方法启动scheduler。

2)创建JobDetail实例。它的构造参数有三个，第一个是任务名，任务名可以被用作参数来应用需要暂停的任务；第二个是组名，组名可以用来引用一组被集合在一起的任务，这里采用缺省组名，每一个任务名在组内必须是唯一的；第三个参数是实现了特定任务的类。

3)创建Trigger实例。我们使用SimpleTrigger类，它提供了类似JDK Timer风格的触发器行为。它的构造参数有六个，第一个和第二个为触发器名和组名，和上面类似；第三个为任务开始时间；第四个为结束时间，如果设置为空，表示不存在结束时间；第五个为重复次数，允许你指的触发器被触发的最大次数，使用REPEAT_INDEFINITELY允许触发器可以被触发无限次；第六个是触发器运行的时间间隔，是毫秒数。

4)最后通过scheduler.scheduleJob()方法调度任务。

2. 使用JobDetail传递数据

每个JobDetail实例都有关联的JobDataMap实例，它实现了Map接口并允许通过键值来传递任务相关的数据。任务也可以修改JobDataMap中的数据，在同一任务的多次执行之间传递数据。下面举例说明。

MessageJob.java

Java代码
1.package com.learnworld.quartz;
2.
3.import java.util.Map;
4.
5.import org.quartz.Job;
6.import org.quartz.JobExecutionContext;
7.import org.quartz.JobExecutionException;
8.
9.public class MessageJob implements Job {
10.
11. public void execute(JobExecutionContext context) throws JobExecutionException {
12.
13. Map properties = context.getJobDetail().getJobDataMap();
14.
15. System.out.println("Previous Fire Time: " + context.getPreviousFireTime());
16. System.out.println("Current Fire Time: " + context.getFireTime());
17. System.out.println("Next Fire Time: " + context.getNextFireTime());
18. System.out.println(properties.get("message"));
19.
20. }
21.}
package com.learnworld.quartz;

import java.util.Map;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MessageJob implements Job {

public void execute(JobExecutionContext context) throws JobExecutionException {

Map properties = context.getJobDetail().getJobDataMap();

System.out.println("Previous Fire Time: " + context.getPreviousFireTime());
System.out.println("Current Fire Time: " + context.getFireTime());
System.out.println("Next Fire Time: " + context.getNextFireTime());
System.out.println(properties.get("message"));

}
}

MessageScheduling.java

Java代码
1.package com.learnworld.quartz;
2.
3.import java.util.Date;
4.import java.util.Map;
5.
6.import org.quartz.JobDetail;
7.import org.quartz.Scheduler;
8.import org.quartz.SimpleTrigger;
9.import org.quartz.Trigger;
10.import org.quartz.impl.StdSchedulerFactory;
11.
12.public class MessageScheduling {
13. public static void main(String[] args) throws Exception {
14.
15. Scheduler scheduler = new StdSchedulerFactory().getScheduler();
16. scheduler.start();
17.
18. JobDetail jobDetail = new JobDetail("messageJob",
19. Scheduler.DEFAULT_GROUP, MessageJob.class);
20.
21. Map map = jobDetail.getJobDataMap();
22. map.put("message", "This is a message from Quartz");
23.
24. Trigger trigger = new SimpleTrigger("simpleTrigger",
25. Scheduler.DEFAULT_GROUP, new Date(), new Date("Sat, 12 Aug 2011 13:30:00 GMT+0430"),
26. SimpleTrigger.REPEAT_INDEFINITELY, 5000);
27.
28. scheduler.scheduleJob(jobDetail, trigger);
29.
30. }
31.}
package com.learnworld.quartz;

import java.util.Date;
import java.util.Map;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class MessageScheduling {
public static void main(String[] args) throws Exception {

Scheduler scheduler = new StdSchedulerFactory().getScheduler();
scheduler.start();

JobDetail jobDetail = new JobDetail("messageJob",
Scheduler.DEFAULT_GROUP, MessageJob.class);

Map map = jobDetail.getJobDataMap();
map.put("message", "This is a message from Quartz");

Trigger trigger = new SimpleTrigger("simpleTrigger",
Scheduler.DEFAULT_GROUP, new Date(), new Date("Sat, 12 Aug 2011 13:30:00 GMT+0430"),
SimpleTrigger.REPEAT_INDEFINITELY, 5000);

scheduler.scheduleJob(jobDetail, trigger);

}
}

3. 使用CronTrigger

上面提到了SimpleTrigger类，它提供了类似JDK Timer风格的触发器功能。Quartz的出色在于它使用CronTrigger提供了对复杂触发器的支持。

一个CronTrigger表达式，包含六个必须组件和一个可选组件。关于cron表达式，可以参考这篇文档:http://www.quartz-scheduler.org/docs/tutorials/crontrigger.html

下面举例说明CronTrigger的使用。

CronWithCalendarScheduling.java

Java代码
1.package com.learnworld.quartz;
2.
3.import java.util.Calendar;
4.import java.util.Date;
5.import java.util.Map;
6.
7.import org.quartz.CronTrigger;
8.import org.quartz.JobDetail;
9.import org.quartz.Scheduler;
10.import org.quartz.SimpleTrigger;
11.import org.quartz.Trigger;
12.import org.quartz.impl.StdSchedulerFactory;
13.import org.quartz.impl.calendar.HolidayCalendar;
14.
15.public class CronWithCalendarScheduling {
16. public static void main(String[] args) throws Exception {
17.
18. Calendar cal = Calendar.getInstance();
19. cal.set(2010, Calendar.OCTOBER, 31);
20.
21. HolidayCalendar calendar = new HolidayCalendar();
22. calendar.addExcludedDate(cal.getTime());
23.
24. Scheduler scheduler = new StdSchedulerFactory().getScheduler();
25. scheduler.start();
26.
27. scheduler.addCalendar("calendar", calendar, true, false);
28.
29. JobDetail jobDetail = new JobDetail("messageJob",
30. Scheduler.DEFAULT_GROUP, MessageJob.class);
31.
32. Map map = jobDetail.getJobDataMap();
33. map.put("message", "This is a message from Quartz");
34.
35. String cronExpression = "3/5 * 17,18,19,20 * * ?";
36.
37. Trigger trigger = new CronTrigger("cronTrigger",
38. Scheduler.DEFAULT_GROUP, cronExpression);
39.
40. scheduler.scheduleJob(jobDetail, trigger);
41. }
42.}
package com.learnworld.quartz;

import java.util.Calendar;
import java.util.Date;
import java.util.Map;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.calendar.HolidayCalendar;

public class CronWithCalendarScheduling {
public static void main(String[] args) throws Exception {

Calendar cal = Calendar.getInstance();
cal.set(2010, Calendar.OCTOBER, 31);

HolidayCalendar calendar = new HolidayCalendar();
calendar.addExcludedDate(cal.getTime());

Scheduler scheduler = new StdSchedulerFactory().getScheduler();
scheduler.start();

scheduler.addCalendar("calendar", calendar, true, false);

JobDetail jobDetail = new JobDetail("messageJob",
Scheduler.DEFAULT_GROUP, MessageJob.class);

Map map = jobDetail.getJobDataMap();
map.put("message", "This is a message from Quartz");

String cronExpression = "3/5 * 17,18,19,20 * * ?";

Trigger trigger = new CronTrigger("cronTrigger",
Scheduler.DEFAULT_GROUP, cronExpression);

scheduler.scheduleJob(jobDetail, trigger);
}
}

需要说明几点：

1)创建了HolidayCalendar实例，使用addExcluderData()方法排除了2010年10月31日。再使用addCalendar()方法，将这个Calendar加入到Scheduler中。

2)这个cron表达式的含义是，每天17:00-20:59之间每一分钟的第三秒开始运行，每五秒执行一次。

三. Spring对Quartz调度的支持

Spring对Quartz集成与其对JDK Timer调度集成类似，你可以在配置文件中配置任务调度。仅需要在程序里加载ApplicationContext，Spring会自动启动调度器。

quartz.xml

Java代码
1.<?xml version="1.0" encoding="UTF-8"?>
2.<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
3.<beans>
4. <bean id="job"
5. class="org.springframework.scheduling.quartz.JobDetailBean">
6. <property name="jobClass">
7. <value> com.learnworld.quartz.MessageJob </value>
8. </property>
9. <property name="jobDataAsMap">
10. <map>
11. <entry key="message">
12. <value>This is a message from Spring Quartz configuration!</value>
13. </entry>
14. </map>
15. </property>
16. </bean>
17. <bean id="trigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
18. <property name="startDelay">
19. <value>1000</value>
20. </property>
21. <property name="repeatInterval">
22. <value>3000</value>
23. </property>
24. <property name="jobDetail">
25. <ref local="job" />
26. </property>
27. </bean>
28.
29. <bean id="schdulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
30. <property name="triggers">
31. <list>
32. <ref local="trigger" />
33. </list>
34. </property>
35. </bean>
36.</beans>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="job"
class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass">
<value> com.learnworld.quartz.MessageJob </value>
</property>
<property name="jobDataAsMap">
<map>
<entry key="message">
<value>This is a message from Spring Quartz configuration!</value>
</entry>
</map>
</property>
</bean>
<bean id="trigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<property name="startDelay">
<value>1000</value>
</property>
<property name="repeatInterval">
<value>3000</value>
</property>
<property name="jobDetail">
<ref local="job" />
</property>
</bean>

<bean id="schdulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref local="trigger" />
</list>
</property>
</bean>
</beans>

SimpleSpringQuartzIntegration.java

Java代码
1.package com.learnworld.quartz;
2.
3.import org.springframework.context.ApplicationContext;
4.import org.springframework.context.support.FileSystemXmlApplicationContext;
5.
6.public class SimpleSpringQuartzIntegration {
7.
8. public static void main(String[] args) {
9.
10. ApplicationContext ac = new FileSystemXmlApplicationContext("src/conf/quartz.xml");
11. }
12.
13.}
package com.learnworld.quartz;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;

public class SimpleSpringQuartzIntegration {

public static void main(String[] args) {

ApplicationContext ac = new FileSystemXmlApplicationContext("src/conf/quartz.xml");
}

}

需要说明几点：

1)采用JobDetailBean类，它扩展了JobDetai类，采用可声明方式配置任务数据。缺省情况下，采用<bean>标签的id作为任务名，使用缺省组作为组名，通过jobDataAsMap作为配置任务数据。

2)建立触发器。可以选择SimpleTriggerBean或CronTriggerBean类。SimpleTriggerBean缺省情况下把可重复执行次数设为无限。

3)创建schedulerFactory。缺省情况下，SchedulerFactoryBean创建一个StdSchedulerFactory的实例，后者创建Scheduler的实现。可以通过设置schedulerFactoryClass属性来覆盖这个行为，需要继承SchedulerFactory接口来实现你自己的版本


Spring的任务调度服务实例讲解
记的以前在做一家人才招聘网站时遇到的一个问题，因为白天的流量非常大为了减轻网站的压力所以客户要求一些不是太急手的任务（如，给注册用户发送邮件、清理日常垃圾信息等等）都放在凌晨流量最小的时间段去执行，当时我们借助java.util.Timer来实现的。但是对于更加复杂的任务调度Timer就不太容易了，后来了解了Quartz（OpenSymphony的提供任务调务类库）可以大大弥补Timer的不足可以使开发者能够完成各种复杂的任务调度。Spring又对其提供了很好的支持使得开发者不用另外去学习这套全新的类库就能很方便的使用。

下面提供一个实例来讲解：

1. 首先把spring.jar包放到classpath下

2. 编辑spring配制文件，ApplicationContext.xml内容如下：


Java代码
1.<?xml version="1.0" encoding="UTF-8"?>
2.<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd" >
3.<beans>
4. <!—要调度的对象-->
5. <bean id="testQuarz" class="springtimer.TestQuarz" />
6.
7. <!--定义定时执行testQuarz 这个bean中的sayHello()方法-->
8. <bean id="helloworldTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
9. <property name="targetObject">
10. <ref bean="testQuarz" />
11. </property>
12. <property name="targetMethod">
13. <value>sayHello</value>
14. </property>
15. </bean>
16.
17. <!--触发器的bean的设置，在这里我们设置了我们要触发的jobDetail是哪个。这里我们定义了要触发的jobDetail是helloworldTask，即触发器去触发哪个bean..并且我们还定义了触发的时间:每天5:17pm-->
18. <bean id="cronTrigger"
19. class="org.springframework.scheduling.quartz.CronTriggerBean">
20. <property name="jobDetail">
21. <ref bean=" helloworldTask " />
22. </property>
23. <property name="cronExpression">
24. <!-- 关键在配置此表达式 -->
25. <value>0 17 17 * * ?</value>
26. </property>
27. </bean>
28.
29. <!--管理触发器的总设置,管理我们的触发器列表,可以在bean的list中放置多个触发器。
30. -->
31. <bean autowire="no"
32. class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
33. <property name="triggers">
34. <list>
35. <ref local="cronTrigger" />
36. </list>
37. </property>
38. </bean>
39.</beans>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "spring-beans.dtd" >
<beans>
<!—要调度的对象-->
<bean id="testQuarz" class="springtimer.TestQuarz" />

<!--定义定时执行testQuarz 这个bean中的sayHello()方法-->
<bean id="helloworldTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject">
<ref bean="testQuarz" />
</property>
<property name="targetMethod">
<value>sayHello</value>
</property>
</bean>

<!--触发器的bean的设置，在这里我们设置了我们要触发的jobDetail是哪个。这里我们定义了要触发的jobDetail是helloworldTask，即触发器去触发哪个bean..并且我们还定义了触发的时间:每天5:17pm-->
<bean id="cronTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail">
<ref bean=" helloworldTask " />
</property>
<property name="cronExpression">
<!-- 关键在配置此表达式 -->
<value>0 17 17 * * ?</value>
</property>
</bean>

<!--管理触发器的总设置,管理我们的触发器列表,可以在bean的list中放置多个触发器。
-->
<bean autowire="no"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref local="cronTrigger" />
</list>
</property>
</bean>
</beans>

3.以下是被调度的类代码

Java代码
1.package springtimer;
2.
3.ublic class TestQuarz {
4.
5. public void sayHello() {
6. System.out.println("HelloWorld! ");
7. }
package springtimer;

public class TestQuarz {

public void sayHello() {
System.out.println("HelloWorld! ");
}
}

4,提供测试类


Java代码
1.public class TestHello {
2.
3.public static void main(String[] args) {
4.// 只要加载配置文件就可以了,
5.ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
6.System.out.println("*****完毕******");
7.}
public class TestHello {

public static void main(String[] args) {
// 只要加载配置文件就可以了,
ApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
System.out.println("*****完毕******");
}

5,Ok自已可以设置sping-config文件中<value>0 17 17 * * ?</value>的调度表达式,可以测试啦!

6, 下面简单的介绍一下cron expressions（调度表达式）

格式列表：

Java代码
1.Field Name | Mandatory? | Allowed Values | Allowed Special Characters
2.Seconds | YES | 0-59 | , - * /
3.Minutes | YES | 0-59 | , - * /
4.Hours | YES | 0-23 | , - * /
5.Day of month | YES | 1-31 | , - * ? / L W C
6.Month | YES | 1-12 or JAN-DEC | , - * /
7.Day of week | YES | 1-7 or SUN-SAT | , - * ? / L C #
8.Year | NO | empty, 1970-2099 | , - * /
Field Name | Mandatory? | Allowed Values | Allowed Special Characters
Seconds | YES | 0-59 | , - * /
Minutes | YES | 0-59 | , - * /
Hours | YES | 0-23 | , - * /
Day of month | YES | 1-31 | , - * ? / L W C
Month | YES | 1-12 or JAN-DEC | , - * /
Day of week | YES | 1-7 or SUN-SAT | , - * ? / L C #
Year | NO | empty, 1970-2099 | , - * /

至于详细的解释你一看例子就会明白

例子列表如下：
表达式 解释
0 0 12 * * ? 在每天中午12：00触发
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：00至2：59之间每分钟触发一次
0 0/5 14 * * ? 每天在下午2：00至2：59之间每5分钟触发一次
0 0/5 14,18 * * ? 每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次
0 0-5 14 * * ? 每天在下午2：00至2：05之间每分钟触发一次
0 10,44 14 ? 3 WED 每三月份的星期三在下午2：00和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, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发
0 15 10 ? * 6#3 在每个月的第三个星期五的上午10：15触发
0 0 12 1/5 * ? 从每月的第一天起每过5天的中午12：00时触发
0 11 11 11 11 ? 在每个11月11日的上午11：11时触发.