先看一下最终实现实现效果,只有两个页面 ,如下
在这个页面查看任务实时运行状态,可以暂停、恢复、移除任务等
在这个页面可以动态配置调度任务。
实现任务监控,必须能将数据持久化,这里采用数据库方式,Quartz对任务的数据库持久化有着非常好的支持。我在这里采用quartz 1.6.5,在Quartz发行包的docs\dbTables目录包含有各种数据库对应脚本,我用的是MySql 5.0,所以选用tables_mysql_innodb.sql建表。
建表完成后,配置数据库连接池,分两步:
1、配置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
2.配置applicationContext.xml文件
- <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>
配置Quartz,也分两步
1、配置quartz. properties
- …
- 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.StdJDBCDelegate
- #org.quartz.jobStore.useProperties = true
- org.quartz.jobStore.tablePrefix = QRTZ_
- org.quartz.jobStore.isClustered = false org.quartz.jobStore.maxMisfiresToHandleAtATime=1
在这里采用JobStoreTX,将任务持久化到数据中,而不再是简单的内存方式:RAMJobStore
2、配置applicationContext-quartz.xml
- <bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
- <property name="dataSource" ref ="dataSource" />
- <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>
到些,相关配置全部完成,对于配置的具体描述,可以参加我的前一篇文章《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类中
暂停任务
- public void pauseTrigger(String triggerName,String group){
- try {
- scheduler.pauseTrigger(triggerName, group);//停止触发器
- } catch (SchedulerException e) {
- throw new RuntimeException(e);
- }
- }
恢复任务
- public void resumeTrigger(String triggerName,String group){
- try {
- scheduler.resumeTrigger(triggerName, group);//重启触发器
- } catch (SchedulerException e) {
- throw new RuntimeException(e);
- }
- }
移除任务
- public boolean removeTrigdger(String triggerName,String group){
- try {
- scheduler.pauseTrigger(triggerName, group);//停止触发器
- return scheduler.unscheduleJob(triggerName, group);//移除触发器
- } catch (SchedulerException e) {
- throw new RuntimeException(e);
- }
- }
其它类的实现请参加《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增加一个初始化方法
- @PostConstruct
- public void init() throws SchedulerException{
- logger.info("init start....................");
- scheduler.addJob(jobDetail, true);
- logger.info("init end.......................");
- }
并且增加
- <property name="startupDelay" value="60"/>
让QuartzScheduler延时启动,为了保证init()先执行,init()是更新Job,其实只是为了更新当前的SessionFactory到Job中,保持Job里的SessionFactory与当前SessionFactory一致。我后来发现解决这个问题还有一个更好的方法,在org.springframework.scheduling.quartz.SchedulerFactoryBean是可配置的
- <property name="overwriteExistingJobs" value="true"/>
- <property name="jobDetails" >
- <list>
- <ref bean="jobDetail"/>
- </list>
- </property>
这样就可以达到与init一样的效果。
这三个问题,经过研究探索,现在都己经不是问题了。下面我简单说说这个三个问题的解决办法。
第一个问题:org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean报NotSerializableException异常,这个 spring bug 己经在 http://jira.springframework.org/browse/SPR-3797 找到解决方案,上面有牛人修改过的MethodInvokingJobDetailFactoryBean.java,详细源码请可以参考附件。哇塞,又可以POJO了。
- <?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="dataSource"/>
- <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
- <property name="configLocation" value="classpath:quartz.properties"/>
- <!--这个是必须的,QuartzScheduler 延时启动,应用启动完后 QuartzScheduler 再启动-->
- <property name="startupDelay" value="30"/>
- <!--这个是可选,QuartzScheduler 启动时更新己存在的Job,这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了-->
- <property name="overwriteExistingJobs" value="true"/>
- <property name="jobDetails" >
- <list>
- <ref bean="jobDetail"/>
- </list>
- </property>
- </bean>
- <bean id="jobDetail" class="frameworkx.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
- <!--shouldRecover属性为true,则当Quartz服务被中止后,再次启动任务时会尝试恢复执行之前未完成的所有任务-->
- <property name="shouldRecover" value="true"/>
- <property name="targetObject" ref="customerService"/>
- <property name="targetMethod" value="testMethod1"/>
- </bean>
- </beans>
注意 <bean id="jobDetail" class="frameworkx.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">是修改过的MethodInvokingJobDetailFactoryBean。
第三个问题:从SchedulerServiceImpl 中去掉不需要的init() 方法,不用在SchedulerServiceImpl初始化后更新jobDeail。
- @PostConstruct
- public void init() throws SchedulerException{
- logger.info("init start....................");
- scheduler.addJob(jobDetail, true);
- logger.info("init end.......................");
- }
第二个问题与第三个是互相关联的,我想到要解决这两个问题的一个方案是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
- package com.sundoctor.example.service;
- import java.io.Serializable;
- import org.springframework.context.ApplicationContext;
- import org.springframework.stereotype.Service;
- import org.springframework.web.context.ContextLoader;
- @SuppressWarnings("unchecked")
- @Service("springBeanService")
- public class SpringBeanService implements Serializable{
- private static final long serialVersionUID = -2228376078979553838L;
- public <T> T getBean(Class<T> clazz,String beanName){
- ApplicationContext context = ContextLoader.getCurrentWebApplicationContext();
- return (T)context.getBean(beanName);
- }
- }
因为Hibernate Dao不再持久到Job中,所在不再需要实现序列化接口,可以继承HibernateDaoSupport,当然也可以不继承,可以根据自己喜好的方式编写,不再有任何限制
- package com.sundoctor.example.dao;
- import org.hibernate.Session;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import org.springframework.orm.hibernate3.HibernateCallback;
- import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
- import org.springframework.stereotype.Repository;
- import com.sundoctor.example.model.Customer;
- import com.sundoctor.example.service.CustomerService;
- @Repository("customerDao")
- public class CustomerHibernateDao extends HibernateDaoSupport {
- private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);
- public Customer getCustomer2() {
- return (Customer) this.getHibernateTemplate().execute(new HibernateCallback() {
- public Object doInHibernate(Session session) {
- Customer customer = (Customer) session.createQuery("from Customer where id = 1").uniqueResult();
- logger.info("Customer2={}", customer);
- return customer;
- }
- });
- }
- public Customer getCustomer1() {
- Customer customer = (Customer) this.getHibernateTemplate().get(Customer.class, 1);
- logger.info("Customer1={}", customer);
- return customer;
- }
- }
因为hibernate dao 不再实现序列化接口和继承自HibernateDaoSupport,不能再注入到业务类中了。在业务类中注入以上的SpringBeanService,业务方法需要的hibernate dao通过以上的SpringBeanService.getBean获取
- package com.sundoctor.example.service;
- import java.io.Serializable;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import org.springframework.beans.factory.annotation.Autowired;
- import org.springframework.beans.factory.annotation.Qualifier;
- import org.springframework.stereotype.Service;
- import com.sundoctor.example.dao.CustomerHibernateDao;
- import com.sundoctor.example.model.Customer;
- @Service("customerService")
- public class CustomerService implements Serializable {
- private static final long serialVersionUID = -6857596724821490041L;
- private static final Logger logger = LoggerFactory.getLogger(CustomerService.class);
- private SpringBeanService springBeanService;
- @Autowired
- public void setSpringBeanService(@Qualifier("springBeanService") SpringBeanService springBeanService) {
- this.springBeanService = springBeanService;
- }
- public void testMethod1() {
- // 这里执行定时调度业务
- CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao");
- Customer customer = customerDao.getCustomer1();
- logger.info("AAAA:{}", customer);
- }
- public void testMethod2() {
- // 这里执行定时调度业务
- CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao");
- Customer customer = customerDao.getCustomer2();
- logger.info("BBBB:{}", customer);
- }
以上代码中hibernate dao 获取方法:
- CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao")获取方法;
附件中的其它源码介绍可以参考《Quartz 在 Spring 中如何动态配置时间》http://www.iteye.com/topic/399980?page=1