Quartz任务监控管理

Quartz任务监控管理，类似Windows任务管理器，可以获得运行时的实时监控，查看任务运行状态，动态增加任务，暂停、恢复、移除任务等。对于动态增加任务，可以参加我的前一篇文章《Quartz如何在Spring动态配置时间》，本文在前文的基础上扩展，增加暂停、恢复、移除任务等功能，实现Quartz任务监控管理。 


先看一下最终实现实现效果，只有两个页面 ，如下 

在这个页面查看任务实时运行状态，可以暂停、恢复、移除任务等 


在这个页面可以动态配置调度任务。 


实现任务监控，必须能将数据持久化，这里采用数据库方式，Quartz对任务的数据库持久化有着非常好的支持。我在这里采用quartz 1.6.5，在Quartz发行包的docs\dbTables目录包含有各种数据库对应脚本，我用的是MySql 5.0，所以选用tables_mysql_innodb.sql建表。 

建表完成后，配置数据库连接池，分两步： 
1、配置jdbc.properties文件 

Java代码  

1. jdbc.driverClassName=com.mysql.jdbc.Driver  
2. jdbc.url=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true  
3. jdbc.username=root  
4. jdbc.password=kfs  

2.配置applicationContext.xml文件 

Java代码  

1. <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
2.     <property name="locations">  
3.             <list>  
4.                 <value>classpath:jdbc.properties</value>  
5.             </list>  
6.         </property>  
7. </bean>  
8.       
9.     <!-- 数据源定义,使用c3p0 连接池 -->  
10. <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
11.     <property name="driverClass" value="${jdbc.driverClassName}" />     
12.     <property name="jdbcUrl" value="${jdbc.url}" />     
13.     <property name="user" value="${jdbc.username}" />   
14.     <property name="password" value="${jdbc.password}" />       
15.     <property name="initialPoolSize" value="${cpool.minPoolSize}"/>     
16.     <property name="minPoolSize" value="${cpool.minPoolSize}" />    
17.     <property name="maxPoolSize" value="${cpool.maxPoolSize}" />    
18.     <property name="acquireIncrement" value="${cpool.acquireIncrement}" />   
19.     <property name="maxIdleTime" value="${cpool.maxIdleTime}"/>     
20. </bean>  

配置Quartz，也分两步 
1、配置quartz. properties 

Java代码  

1. …  
2. org.quartz.jobStore.misfireThreshold = 60000  
3. #org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore  
4. org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
5. org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate  
6. #org.quartz.jobStore.useProperties = true  
7. org.quartz.jobStore.tablePrefix = QRTZ_    
8. org.quartz.jobStore.isClustered = false  org.quartz.jobStore.maxMisfiresToHandleAtATime=1  

在这里采用JobStoreTX，将任务持久化到数据中，而不再是简单的内存方式：RAMJobStore 

2、配置applicationContext-quartz.xml 

Java代码  

1. <bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
2.         <property name="dataSource" ref ="dataSource" />         
3.         <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>  
4.         <property name="configLocation" value="classpath:quartz.properties"/>  
5.     </bean>  
6.       
7. <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">  
8.         <property name="jobClass">  
9.             <value>  
10.                 com.sundoctor.example.service.MyQuartzJobBean  
11.             </value>  
12.         </property>  
13.         <property name="jobDataAsMap">  
14.             <map>  
15.                 <entry key="simpleService">  
16.                     <ref bean="simpleService"/>  
17.                 </entry>  
18.             </map>  
19.         </property>      
20. </bean>  

到些，相关配置全部完成，对于配置的具体描述，可以参加我的前一篇文章《Quartz如何在Spring动态配置时间》

实现任务动态添加配置 

请参考com.sundoctor.quartz.service.SchedulerServiceImpl.java中的各种schedule方法，在《Quartz如何在Spring动态配置时间》有具体描述。在这里说一下： 
添加一个Job在表qrtz_job_details插入一条记录 
添加一个Simple Trigger在表qrtz_simple_triggers插入一条记录 
添加一个Cron Trigger 在表qrtz_cron_triggers插入一条记录 
添加Simple Trigger和Cron Trigger都会同进在表qrtz_triggers插入一条记录，开始看的第一个页面调度任务列表数据就是从qrtz_triggers表获取 

实现任务实时监控，暂停、恢复、移除任务等 
在com.sundoctor.quartz.service.SchedulerServiceImpl.java类中 

暂停任务 

Java代码  

1. public void pauseTrigger(String triggerName,String group){        
2.         try {  
3.             scheduler.pauseTrigger(triggerName, group);//停止触发器  
4.         } catch (SchedulerException e) {  
5.             throw new RuntimeException(e);  
6.         }  
7. }  

恢复任务 

Java代码  

1. public void resumeTrigger(String triggerName,String group){       
2.         try {  
3.             scheduler.resumeTrigger(triggerName, group);//重启触发器  
4.         } catch (SchedulerException e) {  
5.             throw new RuntimeException(e);  
6.         }  
7.     }  

移除任务 

Java代码  

1. public boolean removeTrigdger(String triggerName,String group){       
2.         try {  
3.             scheduler.pauseTrigger(triggerName, group);//停止触发器  
4.             return scheduler.unscheduleJob(triggerName, group);//移除触发器  
5.         } catch (SchedulerException e) {  
6.             throw new RuntimeException(e);  
7.         }  
8.     }  

其它类的实现请参加《Quartz如何在Spring动态配置时间》，那里有具体说明。 

到此，基本简单实现了Quartz任务监控管理。其实面这里只是实现了Trigger任务的监控管理，没有实现Job任务的监控管理，实现Job任务的监控管理跟Trigger差不多。用Quartz可以很方便实现多样化的任务监控管理，Trigger任务和Job任务都可进行分组管理。 

我们知道实现的因难是Job持久化需要序列化，主要是以处下三个问题： 

一、org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean报 java.io.NotSerializableException异常，需要自己实现QuartzJobBean。 

二、dao必须要实现序列化接口，Hibernate dao不能直接继承自HibernateDaoSupport，因为HibernateDaoSupport没有实现序列化接口，只能通过SessionFactory构造HibernateTemplate。 

三、当库里己存在Trigger，应用启动时会从库里加载己存在Trigger，会报java.io.InvalidObjectException: Could not find a SessionFactory named: null等SessionFactory等相关异常。因为应用每次启动的得到的SessionFactory实例是不一样的，当从库里取到的Job进行反序列化时，Job里包含的SessionFactory与当前的SessionFactory不一致，所以为null。当时解决这问题采用了一个比较笨的方法，在SchedulerServiceImpl增加一个初始化方法 

Java代码  

1. @PostConstruct  
2. public void init() throws SchedulerException{  
3.      logger.info("init start....................");  
4.      scheduler.addJob(jobDetail, true);   
5.      logger.info("init end.......................");          
6. }  

并且增加 

Java代码  

1. <property name="startupDelay" value="60"/>  

让QuartzScheduler延时启动，为了保证init()先执行，init()是更新Job,其实只是为了更新当前的SessionFactory到Job中，保持Job里的SessionFactory与当前SessionFactory一致。我后来发现解决这个问题还有一个更好的方法，在org.springframework.scheduling.quartz.SchedulerFactoryBean是可配置的 

Java代码  

1. <property name="overwriteExistingJobs" value="true"/>  
2. <property name="jobDetails" >  
3. <list>  
4. <ref bean="jobDetail"/>  
5. </list>     
6. </property>     

这样就可以达到与init一样的效果。 

这三个问题，经过研究探索，现在都己经不是问题了。下面我简单说说这个三个问题的解决办法。 

第一个问题：org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean报NotSerializableException异常，这个 spring bug 己经在 http://jira.springframework.org/browse/SPR-3797 找到解决方案，上面有牛人修改过的MethodInvokingJobDetailFactoryBean.java，详细源码请可以参考附件。哇塞，又可以POJO了。 

Java代码  

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">  
3. <beans>  
4.     <bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
5.         <property name="dataSource" ref="dataSource"/>  
6.         <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>  
7.         <property name="configLocation" value="classpath:quartz.properties"/>       
8.         <!--这个是必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动-->  
9.         <property name="startupDelay" value="30"/>          
10.         <!--这个是可选，QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了-->  
11.         <property name="overwriteExistingJobs" value="true"/>  
12.         <property name="jobDetails" >  
13.             <list>  
14.                 <ref bean="jobDetail"/>  
15.             </list>     
16.         </property>             
17.     </bean>      
18.     <bean id="jobDetail" class="frameworkx.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
19.         <!--shouldRecover属性为true，则当Quartz服务被中止后，再次启动任务时会尝试恢复执行之前未完成的所有任务-->  
20.         <property name="shouldRecover" value="true"/>  
21.         <property name="targetObject" ref="customerService"/>  
22.         <property name="targetMethod" value="testMethod1"/>  
23.     </bean>      
24. </beans>  

注意 <bean id="jobDetail" class="frameworkx.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">是修改过的MethodInvokingJobDetailFactoryBean。 

第三个问题：从SchedulerServiceImpl 中去掉不需要的init() 方法，不用在SchedulerServiceImpl初始化后更新jobDeail。 

Java代码  

1. @PostConstruct  
2. public void init() throws SchedulerException{  
3.     logger.info("init start....................");  
4.     scheduler.addJob(jobDetail, true);    
5.     logger.info("init end.......................");       
6. }  

第二个问题与第三个是互相关联的，我想到要解决这两个问题的一个方案是Job中不要包含SessionFactory就没一切OK了， 因为SessionFactory是hibernate dao的属性，而hibernate dao是SimpleService的属性，因此SimpleService不能有任何hibernate dao属性了。如此SimpleService业务方法里需要的hibernate dao又如何获取呢？对 spring 的了解，我们知道可以通过ApplicationContext获取到任何spring bean，但是在这里ApplicationContext又怎么获取呢？ ... 查看org.springframework.web.context.ContextLoaderListener找到org.springframework.web.context.ContextLoader.getCurrentWebApplicationContext()可以获取到ApplicationContext，增加一个SpringBeanService类，实现序列化接口，通过SpringBeanService可以获取到web己经加载的spring bean 

Java代码  

1. package com.sundoctor.example.service;  
2.   
3. import java.io.Serializable;  
4.   
5. import org.springframework.context.ApplicationContext;  
6. import org.springframework.stereotype.Service;  
7. import org.springframework.web.context.ContextLoader;  
8.   
9. @SuppressWarnings("unchecked")  
10. @Service("springBeanService")  
11. public class SpringBeanService implements Serializable{  
12.   
13.     private static final long serialVersionUID = -2228376078979553838L;  
14.   
15.     public <T> T getBean(Class<T> clazz,String beanName){  
16.         ApplicationContext context = ContextLoader.getCurrentWebApplicationContext();  
17.         return (T)context.getBean(beanName);  
18.     }  
19. }  

因为Hibernate Dao不再持久到Job中，所在不再需要实现序列化接口，可以继承HibernateDaoSupport，当然也可以不继承，可以根据自己喜好的方式编写，不再有任何限制 

Java代码  

1. package com.sundoctor.example.dao;  
2.   
3. import org.hibernate.Session;  
4. import org.slf4j.Logger;  
5. import org.slf4j.LoggerFactory;  
6. import org.springframework.orm.hibernate3.HibernateCallback;  
7. import org.springframework.orm.hibernate3.support.HibernateDaoSupport;  
8. import org.springframework.stereotype.Repository;  
9.   
10. import com.sundoctor.example.model.Customer;  
11. import com.sundoctor.example.service.CustomerService;  
12.   
13. @Repository("customerDao")  
14. public class CustomerHibernateDao extends HibernateDaoSupport {  
15.   
16.     private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);  
17.   
18.     public Customer getCustomer2() {      
19.         return (Customer) this.getHibernateTemplate().execute(new HibernateCallback() {  
20.             public Object doInHibernate(Session session) {  
21.                 Customer customer = (Customer) session.createQuery("from Customer where id = 1").uniqueResult();  
22.                 logger.info("Customer2={}", customer);  
23.                 return customer;  
24.             }  
25.         });  
26.     }  
27.   
28.     public Customer getCustomer1() {          
29.         Customer customer = (Customer) this.getHibernateTemplate().get(Customer.class, 1);  
30.         logger.info("Customer1={}", customer);  
31.         return customer;  
32.     }  
33.   
34. }  

因为hibernate dao 不再实现序列化接口和继承自HibernateDaoSupport，不能再注入到业务类中了。在业务类中注入以上的SpringBeanService,业务方法需要的hibernate dao通过以上的SpringBeanService.getBean获取 

Java代码  

1. package com.sundoctor.example.service;  
2.   
3. import java.io.Serializable;  
4.   
5. import org.slf4j.Logger;  
6. import org.slf4j.LoggerFactory;  
7. import org.springframework.beans.factory.annotation.Autowired;  
8. import org.springframework.beans.factory.annotation.Qualifier;  
9. import org.springframework.stereotype.Service;  
10.   
11. import com.sundoctor.example.dao.CustomerHibernateDao;  
12. import com.sundoctor.example.model.Customer;  
13.   
14. @Service("customerService")  
15. public class CustomerService implements Serializable {  
16.   
17.     private static final long serialVersionUID = -6857596724821490041L;  
18.     private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);  
19.     private SpringBeanService springBeanService;  
20.   
21.     @Autowired  
22.     public void setSpringBeanService(@Qualifier("springBeanService") SpringBeanService springBeanService) {  
23.         this.springBeanService = springBeanService;  
24.     }  
25.   
26.     public void testMethod1() {  
27.         // 这里执行定时调度业务         
28.         CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao");  
29.         Customer customer = customerDao.getCustomer1();  
30.         logger.info("AAAA:{}", customer);  
31.   
32.     }  
33.   
34.     public void testMethod2() {  
35.         // 这里执行定时调度业务  
36.         CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao");  
37.         Customer customer = customerDao.getCustomer2();  
38.         logger.info("BBBB:{}", customer);  
39.     }  

以上代码中hibernate dao 获取方法: 

Java代码  

1. CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao")获取方法;  

附件中的其它源码介绍可以参考《Quartz 在 Spring 中如何动态配置时间》http://www.iteye.com/topic/399980?page=1