Quartz 在 Spring 中如何动态配置时间--转

原文地址：http://www.iteye.com/topic/399980

在项目中有一个需求，需要灵活配置调度任务时间，并能*启动或停止调度。 
有关调度的实现我就第一就想到了Quartz这个开源调度组件，因为很多项目使用过，Spring结合Quartz静态配置调度任务时间，非常easy。比如：每天凌晨几点定时运行一个程序，这只要在工程中的spring配置文件中配置好spring整合quartz的几个属性就好。

Spring配置文件

引用

<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 
<property name="targetObject" ref="simpleService" /> 
<property name="targetMethod" value="test" /> 
</bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
<property name="jobDetail" ref="jobDetail" /> 
<property name="cronExpression" value="0 0/50 * ? * * *" /> 
</bean> 
<bean  id="schedulerTrigger" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
<property name="triggers"> 
<list>
<ref bean="cronTrigger"/>      
</list> 
</property> 
</bean> 

这种配置就是对quartz的一种简单的使用了，调度任务会在spring启动的时候加载到内存中，按照cronTrigger中定义的 cronExpression定义的时间按时触发调度任务。但是这是quartz使用“内存”方式的一种配置，也比较常见，当然对于不使用spring的项目，也可以单独整合quartz。方法也比较简单，可以从quartz的doc中找到配置方式，或者看一下《Quartz Job Scheduling Framework 》。

但是对于想持久化调度任务的状态，并且灵活调整调度时间的方式来说，上面的内存方式就不能满足要求了，正如本文开始我遇到的情况，需要采用数据库方式集成 Quartz，这部分集成其实在《Quartz Job Scheduling Framework 》中也有较为详细的介绍，当然doc文档中也有，但是缺乏和spring集成的实例。

一、需要构建Quartz数据库表，建表脚本在Quartz发行包的docs\dbTables目录，里面有各种数据库建表脚本，我采用的Quartz 1.6.5版本，总共12张表，不同版本，表个数可能不同。我用mysql数据库，执行了Quartz发行包的docs\dbTables\tables_mysql_innodb.sql建表。

二、建立java project，完成后目录如下 

三、配置数据库连接池 
配置jdbc.properties文件

引用

jdbc.driverClassName=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true 
jdbc.username=root 
jdbc.password=kfs 
cpool.checkoutTimeout=5000 
cpool.minPoolSize=10 
cpool.maxPoolSize=25 
cpool.maxIdleTime=7200 
cpool.acquireIncrement=5 
cpool.autoCommitOnClose=true 

配置applicationContext.xml文件

引用

<?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:tx="http://www.springframework.org/schema/tx" 
    xmlns:context="http://www.springframework.org/schema/context" 
     xmlns:jee="http://www.springframework.org/schema/jee" 
    xsi:schemaLocation=" 
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd 
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd 
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd 
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd 
     http://www.springframework.org/schema/jee 
       http://www.springframework.org/schema/jee/spring-jee-2.5.xsd"  > 
  
   <context:component-scan base-package="com.sundoctor"/>

<!-- 属性文件读入 --> 
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
<property name="locations"> 
<list> 
<value>classpath:jdbc.properties</value> 
</list> 
</property> 
</bean>

<!-- 数据源定义,使用c3p0 连接池 --> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> 
<property name="driverClass" value="${jdbc.driverClassName}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.username}" />
<property name="password" value="${jdbc.password}" />
<property name="initialPoolSize" value="${cpool.minPoolSize}"/>
<property name="minPoolSize" value="${cpool.minPoolSize}" />
<property name="maxPoolSize" value="${cpool.maxPoolSize}" />
<property name="acquireIncrement" value="${cpool.acquireIncrement}" /> 
    <property name="maxIdleTime" value="${cpool.maxIdleTime}"/>   
</bean>

</beans>

这里只是配置了数据连接池，我使用c3p0 连接池，还没有涉及到Quartx有关配置，下面且听我慢慢道来。

四、实现动态定时任务 
  什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。 
这样总不能修改配置文件每定制个定时任务就增加一个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> 

中cronExpression是关键，如果可以动态设置cronExpression的值，就可以顺利解决问题了。这样我们就不能直接使用org.springframework.scheduling.quartz.CronTriggerBean，需要自己实现一个动态调度服务类，在其中构建CronTrigger或SimpleTrigger，动态配置时间。 
动态调度服务接口：

1. package com.sundoctor.quartz.service;
2. import java.util.Date;
3. import org.quartz.CronExpression;
4. public interface SchedulerService {
5. /**
6. * 根据 Quartz Cron Expression 调试任务
7. * @param cronExpression  Quartz Cron 表达式，如 "0/10 * * ? * * *"等
8. */
9. void schedule(String cronExpression);
10. /**
11. * 根据 Quartz Cron Expression 调试任务
12. * @param name  Quartz CronTrigger名称
13. * @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等
14. */
15. void schedule(String name,String cronExpression);
16. /**
17. * 根据 Quartz Cron Expression 调试任务
18. * @param cronExpression Quartz CronExpression
19. */
20. void schedule(CronExpression cronExpression);
21. /**
22. * 根据 Quartz Cron Expression 调试任务
23. * @param name Quartz CronTrigger名称
24. * @param cronExpression Quartz CronExpression
25. */
26. void schedule(String name,CronExpression cronExpression);
27. /**
28. * 在startTime时执行调试一次
29. * @param startTime 调度开始时间
30. */
31. void schedule(Date startTime);
32. /**
33. * 在startTime时执行调试一次
34. * @param name Quartz SimpleTrigger 名称
35. * @param startTime 调度开始时间
36. */
37. void schedule(String name,Date startTime);
38. /**
39. * 在startTime时执行调试，endTime结束执行调度
40. * @param startTime 调度开始时间
41. * @param endTime 调度结束时间
42. */
43. void schedule(Date startTime,Date endTime);
44. /**
45. * 在startTime时执行调试，endTime结束执行调度
46. * @param name Quartz SimpleTrigger 名称
47. * @param startTime 调度开始时间
48. * @param endTime 调度结束时间
49. */
50. void schedule(String name,Date startTime,Date endTime);
51. /**
52. * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
53. * @param startTime 调度开始时间
54. * @param endTime 调度结束时间
55. * @param repeatCount 重复执行次数
56. */
57. void schedule(Date startTime,Date endTime,int repeatCount);
58. /**
59. * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
60. * @param name Quartz SimpleTrigger 名称
61. * @param startTime 调度开始时间
62. * @param endTime 调度结束时间
63. * @param repeatCount 重复执行次数
64. */
65. void schedule(String name,Date startTime,Date endTime,int repeatCount);
66. /**
67. * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
68. * @param startTime 调度开始时间
69. * @param endTime 调度结束时间
70. * @param repeatCount 重复执行次数
71. * @param repeatInterval 执行时间隔间
72. */
73. void schedule(Date startTime,Date endTime,int repeatCount,long repeatInterval) ;
74. /**
75. * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
76. * @param name Quartz SimpleTrigger 名称
77. * @param startTime 调度开始时间
78. * @param endTime 调度结束时间
79. * @param repeatCount 重复执行次数
80. * @param repeatInterval 执行时间隔间
81. */
82. void schedule(String name,Date startTime,Date endTime,int repeatCount,long repeatInterval);
83. }

动态调度服务实现类：

1. package com.sundoctor.quartz.service;
2. import java.text.ParseException;
3. import java.util.Date;
4. import java.util.UUID;
5. import org.quartz.CronExpression;
6. import org.quartz.CronTrigger;
7. import org.quartz.JobDetail;
8. import org.quartz.Scheduler;
9. import org.quartz.SchedulerException;
10. import org.quartz.SimpleTrigger;
11. import org.springframework.beans.factory.annotation.Autowired;
12. import org.springframework.beans.factory.annotation.Qualifier;
13. import org.springframework.stereotype.Service;
14. @Service("schedulerService")
15. public class SchedulerServiceImpl implements SchedulerService {
16. private Scheduler scheduler;
17. private JobDetail jobDetail;
18. @Autowired
19. public void setJobDetail(@Qualifier("jobDetail") JobDetail jobDetail) {
20. this.jobDetail = jobDetail;
21. }
22. @Autowired
23. public void setScheduler(@Qualifier("quartzScheduler") Scheduler scheduler) {
24. this.scheduler = scheduler;
25. }
26. @Override
27. public void schedule(String cronExpression) {
28. schedule(null, cronExpression);
29. }
30. @Override
31. public void schedule(String name, String cronExpression) {
32. try {
33. schedule(name, new CronExpression(cronExpression));
34. } catch (ParseException e) {
35. throw new RuntimeException(e);
36. }
37. }
38. @Override
39. public void schedule(CronExpression cronExpression) {
40. schedule(null, cronExpression);
41. }
42. @Override
43. public void schedule(String name, CronExpression cronExpression) {
44. if (name == null || name.trim().equals("")) {
45. name = UUID.randomUUID().toString();
46. }
47. try {
48. scheduler.addJob(jobDetail, true);
49. CronTrigger cronTrigger = new CronTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
50. Scheduler.DEFAULT_GROUP);
51. cronTrigger.setCronExpression(cronExpression);
52. scheduler.scheduleJob(cronTrigger);
53. scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, cronTrigger);
54. } catch (SchedulerException e) {
55. throw new RuntimeException(e);
56. }
57. }
58. @Override
59. public void schedule(Date startTime) {
60. schedule(startTime, null);
61. }
62. @Override
63. public void schedule(String name, Date startTime) {
64. schedule(name, startTime, null);
65. }
66. @Override
67. public void schedule(Date startTime, Date endTime) {
68. schedule(startTime, endTime, 0);
69. }
70. @Override
71. public void schedule(String name, Date startTime, Date endTime) {
72. schedule(name, startTime, endTime, 0);
73. }
74. @Override
75. public void schedule(Date startTime, Date endTime, int repeatCount) {
76. schedule(null, startTime, endTime, 0);
77. }
78. @Override
79. public void schedule(String name, Date startTime, Date endTime, int repeatCount) {
80. schedule(name, startTime, endTime, 0, 0L);
81. }
82. @Override
83. public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval) {
84. schedule(null, startTime, endTime, repeatCount, repeatInterval);
85. }
86. @Override
87. public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval) {
88. if (name == null || name.trim().equals("")) {
89. name = UUID.randomUUID().toString();
90. }
91. try {
92. scheduler.addJob(jobDetail, true);
93. SimpleTrigger SimpleTrigger = new SimpleTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
94. Scheduler.DEFAULT_GROUP, startTime, endTime, repeatCount, repeatInterval);
95. scheduler.scheduleJob(SimpleTrigger);
96. scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, SimpleTrigger);
97. } catch (SchedulerException e) {
98. throw new RuntimeException(e);
99. }
100. }
101. }

SchedulerService 只有一个多态方法schedule，SchedulerServiceImpl实现SchedulerService接口，注入org.quartz.Schedulert和org.quartz.JobDetail，schedule方法可以动态配置org.quartz.CronExpression或org.quartz.SimpleTrigger调度时间。

五、实现自己的org.quartz.JobDetail 
在上一步中SchedulerServiceImpl需要注入org.quartz.JobDetail，在以前的静态配置中

引用

<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 
<property name="targetObject" ref="simpleService" /> 
<property name="targetMethod" value="testMethod" /> 
</bean>

中使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。在这里使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。会报

引用

Caused by: java.io.NotSerializableException: Unable to serialize JobDataMap for insertion into database because the value of property 'methodInvoker' is not serializable: org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean 
at org.quartz.impl.jdbcjobstore.StdJDBCDelegate.serializeJobData(StdJDBCDelegate.java:3358) 
at org.quartz.impl.jdbcjobstore.StdJDBCDelegate.insertJobDetail(StdJDBCDelegate.java:515) 
at org.quartz.impl.jdbcjobstore.JobStoreSupport.storeJob(JobStoreSupport.java:1102) 
... 11 more

异常，google了一下，没有找到解决方法。所以在这里不能使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。，不能pojo了，需要使用org.springframework.scheduling.quartz.JobDetailBean和org.springframework.scheduling.quartz.QuartzJobBean实现自己的QuartzJobBean，如下：

1. package com.sundoctor.example.service;
2. import org.quartz.JobExecutionContext;
3. import org.quartz.JobExecutionException;
4. import org.quartz.Trigger;
5. import org.springframework.scheduling.quartz.QuartzJobBean;
6. public class MyQuartzJobBean extends QuartzJobBean {
7. private SimpleService simpleService;
8. public void setSimpleService(SimpleService simpleService) {
9. this.simpleService = simpleService;
10. }
11. @Override
12. protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException {
13. Trigger trigger = jobexecutioncontext.getTrigger();
14. String triggerName = trigger.getName();
15. simpleService.testMethod(triggerName);
16. }
17. }

MyQuartzJobBean继承org.springframework.scheduling.quartz.QuartzJobBean，注入的SimpleService如下：

1. package com.sundoctor.example.service;
2. import java.io.Serializable;
3. import org.slf4j.Logger;
4. import org.slf4j.LoggerFactory;
5. import org.springframework.stereotype.Service;
6. @Service("simpleService")
7. public class SimpleService implements Serializable{
8. private static final long serialVersionUID = 122323233244334343L;
9. private static final Logger logger = LoggerFactory.getLogger(SimpleService.class);
10. public void testMethod(String triggerName){
11. //这里执行定时调度业务
12. logger.info(triggerName);
13. }
14. public void testMethod2(){
15. logger.info("testMethod2");
16. }
17. }

SimpleService主要执行定时调度业务，在这里我只是简单打印一下log日志。SimpleService需要实现java.io.Serializable接口，否则会报

引用

Caused by: java.io.InvalidClassException: com.sundoctor.example.service.SimpleService; class invalid for deserialization
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:587) 
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1583) 
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1496) 
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1732) 
... 64 more

异常。

配置applicationContext-quartz.xml文件：

引用

<?xml version="1.0" encoding="UTF-8"?> 
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">

<beans> 
<bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
<property name="dataSource">  
<ref bean="dataSource" />  
</property> 
<property name="applicationContextSchedulerContextKey"  value="applicationContextKey" /> 
<property name="configLocation" value="classpath:quartz.properties"/> 
</bean>

<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean"> 
<property name="jobClass"> 
<value>com.sundoctor.example.service.MyQuartzJobBean</value> 
</property>

<property name="jobDataAsMap"> 
<map> 
<entry key="simpleService"> 
<ref bean="simpleService" /> 
</entry> 
</map> 
</property>

</bean>
</beans> 

quartzScheduler中没有了

引用

<property name="triggers"> 
<list> 
...      
</list> 
/property> 

配置，通过SchedulerService动态加入CronTrigger或SimpleTrigger。

在红色的

引用

<property name="jobDataAsMap"> 
<map> 
<entry key="simpleService"> 
<ref bean="simpleService" /> 
</entry> 
</map> 
</property>

中需要注入调度业务类，否则会报空指指错误。

dataSource：项目中用到的数据源，里面包含了quartz用到的12张数据库表； 
applicationContextSchedulerContextKey： 是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类中把spring上下文以key/value的方式存放在了quartz的上下文中了，可以用applicationContextSchedulerContextKey所定义的key得到对应的spring上下文； 
configLocation：用于指明quartz的配置文件的位置，如果不用spring配置quartz的话，本身quartz是通过一个配置文件进行配置的，默认名称是quartz.properties，里面配置的参数在quartz的doc文档中都有介绍，可以调整quartz，我在项目中也用这个文件部分的配置了一些属性，代码如下：

引用

org.quartz.scheduler.instanceName = DefaultQuartzScheduler 
org.quartz.scheduler.rmi.export = false 
org.quartz.scheduler.rmi.proxy = false 
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool 
org.quartz.threadPool.threadCount = 10 
org.quartz.threadPool.threadPriority = 5 
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

org.quartz.jobStore.misfireThreshold = 60000

#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX 
#org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.HSQLDBDelegate 
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate 
#org.quartz.jobStore.useProperties = true 
org.quartz.jobStore.tablePrefix = QRTZ_  
org.quartz.jobStore.isClustered = false  
org.quartz.jobStore.maxMisfiresToHandleAtATime=1 

这里面没有数据源相关的配置部分，采用spring注入datasource的方式已经进行了配置。

六、测试 
运行如下测试类

1. package com.sundoctor.example.test;
2. import java.text.ParseException;
3. import java.text.SimpleDateFormat;
4. import java.util.Date;
5. import org.springframework.context.ApplicationContext;
6. import org.springframework.context.support.ClassPathXmlApplicationContext;
7. import com.sundoctor.quartz.service.SchedulerService;
8. public class MainTest {
9. /**
10. * @param args
11. */
12. public static void main(String[] args) {
13. ApplicationContext springContext = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext.xml","classpath:applicationContext-quartz.xml"});
14. SchedulerService schedulerService = (SchedulerService)springContext.getBean("schedulerService");
15. //执行业务逻辑...
16. //设置调度任务
17. //每10秒中执行调试一次
18. schedulerService.schedule("0/10 * * ? * * *");
19. Date startTime = parse("2009-06-01 22:16:00");
20. Date endTime =  parse("2009-06-01 22:20:00");
21. //2009-06-01 21:50:00开始执行调度
22. schedulerService.schedule(startTime);
23. //2009-06-01 21:50:00开始执行调度，2009-06-01 21:55:00结束执行调试
24. //schedulerService.schedule(startTime,endTime);
25. //2009-06-01 21:50:00开始执行调度，执行5次结束
26. //schedulerService.schedule(startTime,null,5);
27. //2009-06-01 21:50:00开始执行调度，每隔20秒执行一次，执行5次结束
28. //schedulerService.schedule(startTime,null,5,20);
29. //等等，查看com.sundoctor.quartz.service.SchedulerService
30. }
31. private static Date parse(String dateStr){
32. SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
33. try {
34. return format.parse(dateStr);
35. } catch (ParseException e) {
36. throw new RuntimeException(e);
37. }
38. }
39. }

输出

引用

[2009-06-02 00:08:50]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:10:20]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:10:30]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:10:40]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:10:50]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:11:00]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 
[2009-06-02 00:11:10]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f 

这样只是简单的将quartz trigger名称打印出来。

这样通过SchedulerService就可以动态配置调度时间。其实SchedulerService 还可扩展，比如可以注入多个JobDetail，调度不同的JobDetail。