Spring Quartz 持久化解决方案

Quartz是实现了序列化接口的，包括接口，所以可以使用标准方式序列化到数据库。

而Spring2.5.6在集成Quartz时却未能考虑持久化问题。

Spring对JobDetail进行了封装，却未实现序列化接口，所以持久化的时候会产生NotSerializable问题，这也是网上一直在那边叫嚣为什么不能持久化到数据库问题，哥今天看了下Spring源码，发现Spring对Quartz持久化的问题.

1. 不知道Spring未来会不会对持久化的支持，不过我们可以有如下解决方案，比如改写

Spring的代码，实现序列化接口.

2. 不使用Spring的Fatory,自己实现任务的初始化.

既然Spring不支持持久化，那么持久化任务还是自己编写实现吧，否则每次都需要打包发布，麻烦，自己编写的类与Quartz完全兼容.

注意:为什么Spring不支持外配置任务，可能也是考虑到这方面问题所以才不提供这些任务的执行化支持.[配置文件配置与数据库配置重复]

直接使用Quartz是支持序列化功能，比如直接使用页面配置Quartz界面，设置任务执行时间等属性。

通过配置实现的是不应该初始化到数据库，否则直接在数据库中配置了。不过也是可以配置的，通过改写JobDetailBean.代码如下:

1. package org.frame.auth.service;
2. import java.util.Map;
3. import org.quartz.Job;
4. import org.quartz.JobDetail;
5. import org.quartz.Scheduler;
6. import org.springframework.beans.factory.BeanNameAware;
7. import org.springframework.beans.factory.InitializingBean;
8. import org.springframework.scheduling.quartz.DelegatingJob;
9. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
10. public class PersistentJobDetailBean extends JobDetail
11. implements BeanNameAware, InitializingBean {
12. private static final long serialVersionUID = -4389885435844732405L;
13. private Class actualJobClass;
14. private String beanName;
15. /**
16. * Overridden to support any job class, to allow a custom JobFactory
17. * to adapt the given job class to the Quartz Job interface.
18. * @see SchedulerFactoryBean#setJobFactory
19. */
20. public void setJobClass(Class jobClass) {
21. if (jobClass != null && !Job.class.isAssignableFrom(jobClass)) {
22. super.setJobClass(DelegatingJob.class);
23. this.actualJobClass = jobClass;
24. }
25. else {
26. super.setJobClass(jobClass);
27. }
28. }
29. /**
30. * Overridden to support any job class, to allow a custom JobFactory
31. * to adapt the given job class to the Quartz Job interface.
32. */
33. public Class getJobClass() {
34. return (this.actualJobClass != null ? this.actualJobClass : super.getJobClass());
35. }
36. /**
37. * Register objects in the JobDataMap via a given Map.
38. * <p>These objects will be available to this Job only,
39. * in contrast to objects in the SchedulerContext.
40. * <p>Note: When using persistent Jobs whose JobDetail will be kept in the
41. * database, do not put Spring-managed beans or an ApplicationContext
42. * reference into the JobDataMap but rather into the SchedulerContext.
43. * @param jobDataAsMap Map with String keys and any objects as values
44. * (for example Spring-managed beans)
45. * @see SchedulerFactoryBean#setSchedulerContextAsMap
46. */
47. public void setJobDataAsMap(Map jobDataAsMap) {
48. getJobDataMap().putAll(jobDataAsMap);
49. }
50. /**
51. * Set a list of JobListener names for this job, referring to
52. * non-global JobListeners registered with the Scheduler.
53. * <p>A JobListener name always refers to the name returned
54. * by the JobListener implementation.
55. * @see SchedulerFactoryBean#setJobListeners
56. * @see org.quartz.JobListener#getName
57. */
58. public void setJobListenerNames(String[] names) {
59. for (int i = 0; i < names.length; i++) {
60. addJobListener(names[i]);
61. }
62. }
63. public void setBeanName(String beanName) {
64. this.beanName = beanName;
65. }
66. public void afterPropertiesSet() {
67. if (getName() == null) {
68. setName(this.beanName);
69. }
70. if (getGroup() == null) {
71. setGroup(Scheduler.DEFAULT_GROUP);
72. }
73. }
74. }

这里把Spring的ApplicationContext去掉了，因为这个属性没有实现序列化接口。其他配置与原告一致:

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 default-autowire="byName">
4. <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource" destroy-method="close">
5. <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
6. <property name="url" >
7. <value><![CDATA[jdbc:mysql://localhost:3306/txl?connectTimeout=1000&useUnicode=true&characterEncoding=utf-8]]></value>
8. </property>
9. <property name="username" value="root"/>
10. <property name="password" value=""/>
11. </bean>
12. <bean id="jobDetail" class = "org.frame.auth.service.PersistentJobDetailBean">
13. <property name="jobClass" value="org.frame.auth.service.PersistentJob"></property>
14. </bean>
15. <!-- <bean id="trigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean" >-->
16. <!--         <property name="jobDetail" ref="jobDetail"></property>-->
17. <!--         <property name="startDelay" value="1000"></property>-->
18. <!--         <property name="repeatInterval" value="3000"></property>-->
19. <!--         <property name="jobDataAsMap">-->
20. <!--             <map>-->
21. <!--                 <entry key="message" value="this is trigger"></entry>-->
22. <!--             </map>-->
23. <!--         </property>-->
24. <!-- </bean>-->
25. <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >
26. <property name="jobDetail" ref="jobDetail"/>
27. <property name="cronExpression">
28. <value>0/10 * * * * ?</value>
29. </property>
30. </bean>
31. <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
32. <property name="dataSource" ref="dataSource"></property>
33. <property name="applicationContextSchedulerContextKey"  value="applicationContextKey" />
34. <property name="configLocation" value="classpath:quartz.properties"/>
35. </bean>
36. </beans>

org.frame.auth.service.PersistentJob这个类很简单，如下:

1. package org.frame.auth.service;
2. import org.quartz.Job;
3. import org.quartz.JobExecutionContext;
4. import org.quartz.JobExecutionException;
5. public class PersistentJob implements Job  {
6. @Override
7. public void execute(JobExecutionContext context) throws JobExecutionException {
8. System.out.println("spring quartz!");
9. }
10. }

有人可能会说，你这种任务调度持久化就没有意义了，是的，一般持久化到数据库的代码如下:

1. package org.frame.auth.service;
2. import java.util.Map;
3. import org.quartz.JobExecutionContext;
4. import org.quartz.JobExecutionException;
5. import org.quartz.StatefulJob;
6. public class PersistentJob implements StatefulJob  {
7. @Override
8. public void execute(JobExecutionContext context) throws JobExecutionException {
9. // TODO Auto-generated method stub
10. Map map = context.getJobDetail().getJobDataMap();
11. System.out.println("["+context.getJobDetail().getName()+"]"+map.get("message"));
12. map.put("message", "updated Message");
13. }
14. }

这样的话，信息message就会持久化到数据库中了.可以建立系统的连锁调度，这根据你的业务需求了.

在Spring中配置的任务通过我这种修改是可以运行，不过每次运行都需要把原先的任务删除，否则会提示任务已经存在，Quartz的优势是就算服务器停止，下次重启能够恢复原先的任务并继续执行.