`
hyw520110
  • 浏览: 218628 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

quatrz 任务监控管理 (2)

    博客分类：
  • java
配置管理quartzHibernateBeanSpring 
阅读更多

在《Quartz 任务监控管理 (1)》http://www.iteye.com/topic/441951?page=1中，我们知道实现的因难是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. }  
@PostConstruct
public void init() throws SchedulerException{
     logger.info("init start....................");
     scheduler.addJob(jobDetail, true);	
     logger.info("init end.......................");		
}


并且增加

Java代码 复制代码
  1. <property name="startupDelay" value="60"/>  
<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>     
<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了。

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>  
<?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。

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. }  
	@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

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. }  
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，当然也可以不继承，可以根据自己喜好的方式编写，不再有任何限制

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. }  
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获取

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.     }  
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 获取方法:

Java代码 复制代码
  1. CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao")获取方法;  
CustomerHibernateDao customerDao =springBeanService.getBean(CustomerHibernateDao.class,"customerDao")获取方法;



三个主要问题就这样解决了。

附件中的其它源码介绍可以参考《Quartz 在 Spring 中如何动态配置时间》http://www.iteye.com/topic/399980?page=1和《Quartz任务监控管理 (1)》http://www.iteye.com/topic/441951?page=1。

分享到：
| Quartz任务监控管理 (1)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Spring+Quartz 从数据库中获取定时任务和定时时间，动态实现对定时任务的增删改查

    2. **从数据库中获取定时任务**：Quartz允许将任务和触发器的信息存储在数据库中，这可以通过实现`SchedulerFactoryBean`的`overwriteExistingJobs`属性为`false`来实现。这样，当Quartz启动时，它会从数据库中读取...

    (动态多)定时任务源码自动运行调度后台执行

    2、定时任务(xxl-job)（XXL-JOB是一个分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。） 3、SpringCloudSchedule定时任务（使用...

    spring-boot 2.0.2 数据库配置定时任务

    spring-boot 2.0.2 数据库配置定时任务。spring-boot 2.0.2.RELEASE，将定时任务配置在数据库，启动项目的时候，用mybatis读取数据库，实例化对象，并设定定时任务。如果需要新增，减少，修改定时任务，仅需要修改...

    用Quartz_dll做的多视频播放效果).rar

    DirectShow被广泛用于开发多媒体应用程序，它提供了丰富的API接口，可以处理视频捕获、播放、编辑等多种任务。在VB6中调用Quartz.dll，可以利用其强大的视频处理能力，为应用程序添加高级的视频播放特性。 该示例...

    quart-z 两次执行问题

    ### Quart-Z 两次执行问题详解 #### 一、问题背景及概述 ...此外，还可以利用Spring Profiles来更好地管理不同环境下的配置差异。通过采取这些措施，可以有效地避免定时任务的重复执行问题，确保系统的稳定性和效率。

    postgres-quartz.sql

    postgres quatrz初始化sql脚本文件、pg、quartz、qrtz_开头的表 配置文件需求修改 #org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate org.quartz.jobStore....

    VB自定义版影音播放器.rar

    利用VB开放自定义播放器，基于系统Quatrz.dll的接口将媒体显示到指定的控件容器中，比如PictureBox,实现播放的基本功能，播放，暂停，停止，音量，平衡，进度，媒体的总时间和进度时间……感兴趣的VB发烧友可以下载...

Magicbox
Global site tag (gtag.js) - Google Analytics