`
sundoctor
  • 浏览: 326136 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Quartz任务监控管理

quartz配置管理项目管理JavaHibernate 
阅读更多

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


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

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


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


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


1.配置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:jdbc="http://www.springframework.org/schema/jdbc"  
    xsi:schemaLocation="
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
   http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
    " >
  
   <context:component-scan base-package="com.sundoctor">
   		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>

	
	<!-- 使用H2内存数据库并创建quartz数据库表 -->
    <jdbc:embedded-database id="dataSource" type="H2">
        <jdbc:script location="classpath:db/tables_h2.sql"/>       
    </jdbc:embedded-database>	
	
	<!--Hibernate SessionFatory-->
	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
	    <property name="dataSource" ref="dataSource"/>
		<property name="packagesToScan">
			<list>
				<value>com.sundoctor.example.model</value>				
			</list>
		</property>	
	    <property name="hibernateProperties">
	        <props>
	            <prop key="hibernate.dialect">org.hibernate.dialect.H2Dialect</prop>
	            <prop key="hibernate.show_sql">true</prop>
	            <prop key="hibernate.format_sql">true</prop>				
				<prop key="hibernate.hbm2ddl.auto">update</prop>        
	        </props>
	    </property>
	</bean>	
	
	<!--Hibernate TransactionManager-->
	<bean id="transactionManager"  class="org.springframework.orm.hibernate4.HibernateTransactionManager">
	    <property name="sessionFactory" ref="sessionFactory"/>
	</bean>		

	<!-- 使用annotation定义事务 -->
	<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" />		

</beans>

 

配置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

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <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.JobDetailFactoryBean" >
        <property name="jobClass">
            <value>com.sundoctor.example.service.MyQuartzJobBean</value>
        </property>
       <property name="durability" value="true" />	
    </bean>
	 
</beans>

 

到些，相关配置全部完成，对于配置的具体描述，可以参加我的前一篇文章《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类中

暂停任务

	@Override
	public void pauseTrigger(String triggerName, String group) {
		try {
			scheduler.pauseTrigger(new TriggerKey(triggerName, group));// 停止触发器
		} catch (SchedulerException e) {
			throw new RuntimeException(e);
		}
	}

 

恢复任务

	@Override
	public void resumeTrigger(String triggerName, String group) {
		try {
			scheduler.resumeTrigger(new TriggerKey(triggerName, group));// 重启触发器
		} catch (SchedulerException e) {
			throw new RuntimeException(e);
		}
	}


移除任务

	@Override
	public boolean removeTrigdger(String triggerName, String group) {
		TriggerKey triggerKey = new TriggerKey(triggerName, group);
		try {
			scheduler.pauseTrigger(triggerKey);// 停止触发器
			return scheduler.unscheduleJob(triggerKey);// 移除触发器
		} catch (SchedulerException e) {
			throw new RuntimeException(e);
		}
	}



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

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

Quartz很强大，也很简单，只有想不到的，没有做不到的，人有多大胆，地有多高产。

 

分享到：
| Quartz 在 Spring 中如何动态配置时间
评论
16 楼 yanyu510 2009-09-14   
你说的那种方法还是不行，因为注入进去的sessionFactory为空，所以,HibernateTemplate也为空。还有就是按照你的方法改了以后，我原来添加一个tigger是可以的，现在还抛异常了，异常信息如下： Couldn't store job: Unable to serialize JobDataMap for insertion into database because the value of property 'simpleService' is not serializable: org.springframework.orm.hibernate3.AbstractSessionFactoryBean$TransactionAwareInvocationHandler 
我已经实现了序列化接口。不明白怎么回事。

这是我的simpleService类：
package com.sundoctor.example.service;

import java.io.Serializable;

import com.dao.BackupDao;

public class SimpleService implements Serializable {


	private static final long serialVersionUID = 8972659512920450831L;

	private BackupDao backupDao;

	public BackupDao getBackupDao() {
		return backupDao;
	}

	public void setBackupDao(BackupDao backupDao) {
		this.backupDao = backupDao;
	}

	public void testMethod(String triggerName) {
		System.out.println(triggerName);
	}
}

这是我的backupDao:
package com.dao;

import java.io.Serializable;
import java.sql.PreparedStatement;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateCallback;

public class BackupDao implements Serializable {


	/**
	 * 
	 */
	private static final long serialVersionUID = 8933456923281729867L;

	private MyHibernateTemplate hibernateTemlate;

	private SessionFactory sessionFactory;

	public SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;
	}

	public boolean backupDateabase(String dbname, String bfname) {
		 final String dbName = dbname;
		 final String bfname1 = bfname;
		 return (Boolean) hibernateTemlate.execute(new HibernateCallback() {
		 public Object doInHibernate(Session session) {
		 boolean flag = true;
		 PreparedStatement pstmt = null;
		
		 try {
		 pstmt = session.connection().prepareStatement(
		 "{call p_Backup_Or_Restore(?,?,?)}");
		 pstmt.setString(1, bfname1);
		 pstmt.setString(2, dbName);
		 pstmt.setInt(3, 1);
		 pstmt.execute();
		 System.out.println("数据库已备份");
		 } catch (Exception e) {
		 flag = false;
		 e.printStackTrace();
		 }
		 return flag;
		 }
		 });
	}

}

这是我的myHibernateTemplate:
public class MyHibernateTemplate extends HibernateTemplate implements
		Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -6309692794988265208L;

	public MyHibernateTemplate() {
		super();
	}

	public MyHibernateTemplate(SessionFactory sessionFactory) {
		super(sessionFactory);
	}

	public MyHibernateTemplate(SessionFactory sessionFactory,
			boolean allowCreate) {

		super(sessionFactory, allowCreate);
	}
}

这是我的配置文件（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" />
		<property name="autoStartup" value="true" />
	</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>
	<bean id="simpleService"
		class="com.sundoctor.example.service.SimpleService">
		<property name="backupDao">
			<ref bean="backupDao" />
		</property>
	</bean>
	<bean id="schedulerService"
		class="com.sundoctor.quartz.service.SchedulerServiceImpl">
		<property name="scheduler">
			<ref bean="quartzScheduler" />
		</property>
		<property name="jobDetail">
			<ref local="jobDetail" />
		</property>
		<property name="quartzDao">
			<ref bean="quartzDao" />
		</property>
	</bean>
	<!--  
                 容器启动的时候，;
		<bean id="simpleTrigger"
		class="com.internal.InitializingCronTrigger" lazy-init="false">
		<property name="jobDetail" ref="jobDetail" />
		<property name="schedulerService" ref="schedulerService" />
		
		</bean>
	-->
	<bean id="myTemplate" class="com.dao.MyHibernateTemplate">
		<property name="sessionFactory">
			<ref bean="sessionFactory" />
		</property>
	</bean>
	<bean name="/simpleServiceTest"
		class="com.sundoctor.example.test.SimpleServiceTest">
		<property name="schedulerService">
			<ref local="schedulerService" />
		</property>
	</bean>
</beans>

这是另一个配置文件（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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"
	default-lazy-init="false">
	<bean id="dataSource"
		class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName">
			<value>com.microsoft.sqlserver.jdbc.SQLServerDriver</value>
		</property>
		<property name="url">
			<value>
				jdbc:sqlserver://localhost:1433;DatabaseName=test;SelectMethod=cursor
			</value>
		</property>
		<property name="username">
			<value>sa</value>
		</property>
		<property name="password">
			<value>sa</value>
		</property>
		<property name="maxIdle" value="30"></property>
		<property name="minIdle" value="5"></property>
		<!--
			<property name="validationQuery" value="true"></property>
			<property name="loginTimeout" value="1800"></property>
			<property name="poolPreparedStatements" value="true"></property>
		-->
	</bean>

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="dataSource">
			<ref bean="dataSource" />
		</property>
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">
					org.hibernate.dialect.SQLServerDialect
				</prop>
				<prop key="hibernate.show_sql">true</prop>
				<prop key="hibernate.jdbc.fetch_size">50</prop>
				<prop key="hibernate.jdbc.batch_size">50</prop>
			</props>
		</property>
		<property name="mappingResources">
			<list>
				<value>com/pojo/QrtzTriggerListeners.hbm.xml</value>
				<value>com/pojo/QrtzJobDetails.hbm.xml</value>
				<value>com/pojo/QrtzSchedulerState.hbm.xml</value>
				<value>com/pojo/QrtzFiredTriggers.hbm.xml</value>
				<value>com/pojo/QrtzPausedTriggerGrps.hbm.xml</value>
				<value>com/pojo/QrtzCronTriggers.hbm.xml</value>
				<value>com/pojo/QrtzJobListeners.hbm.xml</value>
				<value>com/pojo/QrtzBlobTriggers.hbm.xml</value>
				<value>com/pojo/QrtzLocks.hbm.xml</value>
				<value>com/pojo/QrtzSimpleTriggers.hbm.xml</value>
				<value>com/pojo/QrtzTriggers.hbm.xml</value>
				<value>com/pojo/QrtzCalendars.hbm.xml</value>
			</list>
		</property>
	</bean>
	<bean id="quartzDao" class="com.dao.QuartzDao">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>
	<bean id="backupDao" class="com.dao.BackupDao">
		<property name="sessionFactory">
			<ref local="sessionFactory" />
		</property>
	</bean>
</beans>

InitializingCronTrigger类（容器启动的时候，读取tigger的信息，得到cronExpression）:
package com.internal;

import java.text.ParseException;

import org.springframework.scheduling.quartz.CronTriggerBean;

import com.sundoctor.quartz.service.SchedulerService;

public class InitializingCronTrigger extends CronTriggerBean {

	/**
	 * 
	 */
	private static final long serialVersionUID = 2608510718984483084L;

	private SchedulerService schedulerService;

	public void setSchedulerService(SchedulerService schedulerService) {
		this.schedulerService = schedulerService;
		String cronExpression = schedulerService.getExpression(this.getName(),
				this.getGroup());
		if (cronExpression != null && !cronExpression.equals("")) {
			try {
				setCronExpression(cronExpression);
			} catch (ParseException e) {
				e.printStackTrace();
			}
		}
		}

}
楼主麻烦了，帮我看看，现在晕的不行，我不明白序列化有什么作用，加上序列化后为什么就不能注入了？还有帮我看看为什么WEB容器启动的会调用一次，怎么配置才是最好的配置，楼主太感谢了，这个模块我做了将近一个星期了，就是这个quartz框上卡住了，还有有楼主你啊。如果我的写乱的话，可以给我一个例子吗？582443115@qq.com，可以发到我的邮箱。感谢！·
]
15 楼 sundoctor 2009-09-13  
ningmenglovesoft 写道
谢谢了。。很久没用spring框架。单独使用quartz。这个框架做起来还是比较麻烦。


不用spring，单独使用quartz一样简单。
14 楼 ningmenglovesoft 2009-09-13  
谢谢了。。很久没用spring框架。单独使用quartz。这个框架做起来还是比较麻烦。
13 楼 sundoctor 2009-09-13  
yanyu510 写道
我还想问一下，我做的数据库备份操作话在testMethod里面，服务器启动的时候时间没到也会调用一次,这样不就乱了吗？这个问题怎么解决？

还有就是我把bakcupDao注入到simpleSerivce里了，我的backupDao里是这么写的： 
public boolean backupDateabase(String dbname, String bfname) {
		final String dbName = dbname;
		final String bfname1 = bfname;
		return (Boolean) super.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) {
						boolean flag = true;
						PreparedStatement pstmt = null;

						try {
							pstmt = session.connection().prepareStatement(
									"{call p_Backup_Or_Restore(?,?,?)}");
							pstmt.setString(1, bfname1);
							pstmt.setString(2, dbName);
							pstmt.setInt(3, 1);
							pstmt.execute();
							System.out.println("数据库已备份");
						} catch (Exception e) {
							flag = false;
							e.printStackTrace();
						}
						return flag;
					}
				});
	}

执行这个方法的，super.getHibernateTemplate()得到的hibernateTemplate为空，是什么原因？
我是初学者，有很多问题不懂，还请LZ多多指导，谢啦！


服务器起来时不会调用一次的，调不调用跟你的配置时间有关系，时间不到绝不会自动调用的，这个你放心好了

上面说过simpleService和其中注入各属性需要实现Serializable序列化接口,你的BakcupDao继承自HibernateDaoSupport虽然也实现了序列化接口，但是HibernateDaoSupport里的HibernateTemplate并没有实现序列化接口，所以你取得的HibernateTemplate永远为null。因此获取HibernateTemplate必须换一种方式，你的BakcupDao不能继承自HibernateDaoSupport。HibernateTemplate没有实现序列化接口，而SessionFactory是实现序列化接口的，在bakcupDao注入SessionFactory，通过SessionFactory获取HibernateTemplate。

你的bakcupDao可以这样写 

import java.io.Serializable;

import org.hibernate.SessionFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Repository;

import com.sundoctor.example.service.SimpleService;

@Repository("bakcupDao")
public class BakcupDao implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;	
	private SessionFactory sessionFactory;	

	@Autowired
	public void setSessionFactory(SessionFactory sessionFactory) {
		this.sessionFactory = sessionFactory;		
	}


	public boolean backupDateabase(String dbname, String bfname) {
		final String dbName = dbname;
		final String bfname1 = bfname;
            HibernateTemplate  hibernateTemplate = new HibernateTemplate(sessionFactory);
		return (Boolean)hibernateTemplate.execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				boolean flag = true;
				PreparedStatement pstmt = null;

				try {
					pstmt = session.connection().prepareStatement("{call p_Backup_Or_Restore(?,?,?)}");
					pstmt.setString(1, bfname1);
					pstmt.setString(2, dbName);
					pstmt.setInt(3, 1);
					pstmt.execute();
					System.out.println("数据库已备份");
				} catch (Exception e) {
					flag = false;
					e.printStackTrace();
				}
				return flag;
			}
		});
	}
}



12 楼 yanyu510 2009-09-12  
我还想问一下，我做的数据库备份操作话在testMethod里面，服务器启动的时候时间没到也会调用一次,这样不就乱了吗？这个问题怎么解决？

还有就是我把bakcupDao注入到simpleSerivce里了，我的backupDao里是这么写的： 
public boolean backupDateabase(String dbname, String bfname) {
		final String dbName = dbname;
		final String bfname1 = bfname;
		return (Boolean) super.getHibernateTemplate().execute(
				new HibernateCallback() {
					public Object doInHibernate(Session session) {
						boolean flag = true;
						PreparedStatement pstmt = null;

						try {
							pstmt = session.connection().prepareStatement(
									"{call p_Backup_Or_Restore(?,?,?)}");
							pstmt.setString(1, bfname1);
							pstmt.setString(2, dbName);
							pstmt.setInt(3, 1);
							pstmt.execute();
							System.out.println("数据库已备份");
						} catch (Exception e) {
							flag = false;
							e.printStackTrace();
						}
						return flag;
					}
				});
	}

执行这个方法的，super.getHibernateTemplate()得到的hibernateTemplate为空，是什么原因？
我是初学者，有很多问题不懂，还请LZ多多指导，谢啦！
11 楼 bh_nesta 2009-08-31  
我换了oracle驱动就可以了，
原来是9.0.2.0.0版的不行，
换成10.2.0.1.0版的就可以了
10 楼 sundoctor 2009-08-26  
我用oracle 10g试了一下，没有什么问题，一切正常呀。我没有修改org.quartz.jobStore.driverDelegateClass也没有问题。
9 楼 bh_nesta 2009-08-26  
楼主说的，我已经改过来了。但是还是一样的错误！
使用mysql的时候是可以的！
谢谢楼主的答复！
8 楼 sundoctor 2009-08-25  
bh_nesta 写道
请教楼主：
我使用的是oracle，为什么会报错呢，是不是哪里配置需要修改呢？

java.lang.RuntimeException: org.quartz.impl.jdbcjobstore.LockException: Failure obtaining db row lock: ORA-01002: 读取违反顺序
[See nested exception: java.sql.SQLException: ORA-01002: 读取违反顺序]


oracle 需要修改quartz. properties 文件将
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
改为
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.oracle.OracleDelegate
7 楼 bh_nesta 2009-08-25  
请教楼主：
我使用的是oracle，为什么会报错呢，是不是哪里配置需要修改呢？

java.lang.RuntimeException: org.quartz.impl.jdbcjobstore.LockException: Failure obtaining db row lock: ORA-01002: 读取违反顺序
[See nested exception: java.sql.SQLException: ORA-01002: 读取违反顺序]
6 楼 lxy19791111 2009-08-20  
老兄，我正在找这方面的资料，谢谢。
5 楼 sundoctor 2009-08-10  
引用

<bean id="articleBS" class="com.cms.article.service.impl.ArticleBS">
<property name="tarticleDAO">
<ref bean="article.tarticleDAO" />
</property>
</bean>


不但com.cms.article.service.impl.ArticleBS要实现Serializable序列化接口，其中注入的article.tarticleDAO也必须实现实现Serializable序列化接口。

引用
<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass">
<value>com.cms.quartzpublic.job.ArticleQuartzJobBean</value>
</property>
<property name="jobDataAsMap">
<map>
<entry key="articleBS">
<ref local="articleBS" />
</entry>
</map>
</property>
</bean>


com.cms.quartzpublic.job.ArticleQuartzJobBean类被序列化保存到数据库表qrtz_job_details的job_class_name字段中，quartz在运行时会读取qrtz_job_details表中的job_class_name将其反序列化。这也是为什么com.cms.article.service.impl.ArticleB和其中注入各属性需要实现Serializable序列化接口的原因，所以你每次修改ArticleQuartzJobBean类或者其中的articleBS都要删除qrtz_job_details表对应的job记录，否则可能会出现空指针异常，因为你如果你没有删除qrtz_job_details表中的记录，你修改的东东并不会自动更新到qrtz_job_details中，你用的还是原来旧版本的ArticleQuartzJobBean类。



4 楼 derpvail 2009-08-09  
我的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">

<bean id="articleBS" class="com.cms.article.service.impl.ArticleBS">
<property name="tarticleDAO">
<ref bean="article.tarticleDAO" />
</property>
</bean>

<bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
</bean>

<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass">
<value>com.cms.quartzpublic.job.ArticleQuartzJobBean</value>
</property>
<property name="jobDataAsMap">
<map>
<entry key="articleBS">
<ref local="articleBS" />
</entry>
</map>
</property>

</bean>

<!-- cms 定时发布文章模块service层ioc及事务配置 start -->
<bean id="articleQuartzBS" lazy-init="true"
class="com.cms.quartzpublic.serivce.impl.ArticleQuartzBS">

        <property name="articleQuartzDAO">
<ref bean="article.articleQuartzDAO" />
</property>

       
        <property name="scheduler">
        <ref bean="quartzScheduler" />
        </property>
<property name="jobDetail">
<ref bean="jobDetail" />
        </property>
       
</bean>
    
    <bean id="article.quartzBSTrans" parent="cmsBaseTransationProxy">
<property name="target">
<ref local="articleQuartzBS" />
</property>
</bean>
<!-- cms 定时发布文章模块service层ioc及事务配置 end -->
</beans>

ArticleQuartzJobBean 类如下
package com.cms.quartzpublic.job;

import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Trigger;
import org.springframework.scheduling.quartz.QuartzJobBean;

import com.cms.article.service.IArticleBS;
import com.cms.article.service.impl.ArticleBS;
import com.cms.article.vo.TarticleVO;
import com.cms.po.Tarticle;
import com.cms.quartzpublic.serivce.impl.ArticleQuartzBS;

public class ArticleQuartzJobBean extends QuartzJobBean {

private ArticleBS articleBS;


public void setArticleBS(ArticleBS articleBS) {
this.articleBS = articleBS;
}


@Override
protected void executeInternal(JobExecutionContext jobexecutioncontext)
throws JobExecutionException {
Trigger trigger = jobexecutioncontext.getTrigger();
String triggerName = trigger.getName();
String group = trigger.getGroup();
String[] triggerNameArray = triggerName.split("\\$");
String articleId = triggerNameArray[1];
try {
TarticleVO tarticleVO = articleBS.lookArticleById(articleId);
String fileNamePath = articleBS.createHtmlDir(tarticleVO, tarticleVO.getChannleName());
String articlehref = articleBS.jspTOhtml(fileNamePath,"",tarticleVO);
if(articlehref != null && !articlehref.equals("")){
tarticleVO.setArticlehref(articlehref);
Tarticle tarticle2 = articleBS.saveOrUpdateArticle(tarticleVO);
}

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}

}
private ArticleBS articleBS;这个一直是null值
这个articleBS实现了序列化接口了。。。。
问题在哪里。。。。。郁闷了，盼解决
3 楼 derpvail 2009-08-09  
还是null直
2 楼 sundoctor 2009-08-09  
不用acnntion，这样就行了
<bean name="simpleService" class="com.sundoctor.example.service.SimpleService" />
1 楼 derpvail 2009-08-09  
<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>
中
<map>  
                <entry key="simpleService">  
                    <ref bean="simpleService"/>  
                </entry>  
            </map>
这段，如果不用anntion，在配置文件里面怎么配制？因为我quartz调用的时候，simpleService为null，set了也不行。。。我的类似simpleService的serivce实现了序列化接口了。。。为什么还是null？期待解答
发表评论

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

相关推荐

    quartz动态任务管理

    这个"quartz动态任务管理"源码包很可能是针对Quartz框架的实现，旨在帮助开发者更方便地管理和控制任务的生命周期。 Quartz的核心概念包括作业（Job）、触发器（Trigger）和计划程序（Scheduler）。作业是你要执行...

    基于SSM+quartz的定时任务管理demo

    为了方便管理和监控定时任务，可以开发一个Web界面，利用Quartz提供的API查询Job和Trigger信息，支持新增、修改、删除等操作。此外，还可以查看任务执行日志，以便于排查问题。 总结，本Demo旨在通过SSM+Quartz的...

    基于Spring和Quartz的任务调度监控管理平台设计源码

    本源码为基于Spring和Quartz的任务调度监控管理平台设计，共包含553个文件，其中css文件190个，png文件111个，java文件96个，js文件63个，sql文件22个，html文件20个，jsp文件17个，gif文件15个，xml文件9个，...

    Quartz定时任务图形界面的系统

    在本系统中，SpringMVC用于处理前端请求，实现与后端服务的交互，同时也可能利用Spring的依赖注入特性来管理Quartz任务相关的bean。 3. **MyBatis**: MyBatis是一个持久层框架，它简化了SQL操作，将SQL语句与Java...

    定时任务quartz实现分组串行并行动态配置

    2. **分组管理**：Quartz允许我们为Job分配不同的组，这有助于分类和管理任务。我们可以在创建JobDetail时指定Job的组名，以便于后续的查询和操作。 3. **串行执行**：如果希望同一组内的Job按顺序执行，可以使用`...

    .net Quartz 任务调度平台源码

    5. **监控与管理**：提供了监控界面，可以查看当前运行的任务状态，包括任务的执行进度、异常情况等，方便进行问题排查和性能优化。 6. **日志记录**：任务执行过程中的信息会被记录下来，包括成功、失败、警告等，...

    Quartz如何实现判断某个任务是否正在运行,在项目中用到的,已经测试过了

    Quartz是一款广泛应用于Java开发中的开源任务调度框架，它提供了强大的定时任务管理功能，支持复杂的调度策略和分布式部署。在实际项目中，有时我们需要判断一...通过上述步骤，你可以有效地管理和监控你的Quartz任务。

    WEB管理的Quartz定时任务

    在Web管理的Quartz定时任务中，我们通常会结合SpringMVC和MyBatis来构建一个完善的后台管理系统，以便于管理和监控定时任务。下面将详细介绍这个系统的组成部分和实现方式。 **1. Quartz简介** Quartz是Java平台上...

    Quartz.net作业调度自定义定时执行任务多任务执行c#

    总的来说，Quartz.NET为.NET开发者提供了一套强大且灵活的定时任务解决方案，使得系统可以自动执行各种业务逻辑，如订单管理和库存控制等，极大地提高了系统的自动化程度和效率。通过熟练掌握Quartz.NET，开发者可以...

    windows版本的进程监控，C#基于多线程Quartz实现，每10秒监测一次.zip

    这可以通过NuGet包管理器进行操作，搜索并安装"Quartz"即可。 2. 创建一个Job类，表示我们的进程监控任务。这个类需要继承自`IJob`接口，并实现`Execute`方法。在这个方法中，我们将编写检查Windows进程的代码，...

    quartz任务调度使用手册

    Quartz任务调度是一款开源的Java定时任务框架，广泛应用于企业级应用系统中，用于执行周期性的后台任务。这款工具提供了一种灵活的方式来安排和管理任务，使得开发者无需在业务代码中处理时间相关的逻辑，而是通过...

    Quartz 定时任务web使用

    Quartz 是一个开源的作业调度框架，常用于Java应用程序中实现定时任务的管理。它提供了丰富的API和功能，使得开发者可以灵活地定义和控制任务的执行。本篇将重点介绍如何在Web环境中集成并使用Quartz，以及相关的...

    Quartz.Net任务调度

    Quartz.Net的设计灵感来源于Java的Quartz库，它允许开发者灵活地定义和管理作业（Jobs）以及触发器（Triggers），实现任务的自动化执行。 1. **Quartz.Net基本概念** - **作业（Jobs）**：作业是实际需要执行的...

    C#Quartz定时任务

    7. **监控与管理**：Quartz.NET提供了Web管理界面（如`DotNetScheduler`），可以实时查看和管理任务状态，也可以通过API接口进行远程控制。 通过上述知识，你不仅可以理解C# Quartz定时任务的基本原理，还能构建...

    Spring+Quartz实现任务调度的小例子

    Quartz提供了一个Web界面（JMX支持）用于监控和管理任务，但这个例子中没有包含这部分。如果需要，可以集成Quartz的AdminServlet或使用其他方式监控任务状态。 综上所述，Spring与Quartz的结合使用能够轻松实现复杂...

    quartz界面化持久化管理

    通过结合文章《quartz界面化持久化管理》（链接：https://blog.csdn.net/super_sys/article/details/88384259）我们可以了解到，为了更好地管理和监控Quartz作业，我们需要对其进行一些自定义的改造，以实现界面化的...

    Springboot2-Quartz 后台可动态配置的定时任务

    本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...

    springMVC+quartz任务调度

    在实际项目中，SpringMVC 和 Quartz 的结合可以帮助开发者构建出高效、灵活的应用程序，尤其是对于那些需要定期执行后台任务的系统，如数据分析、监控报警等。同时，由于 Spring 提供了对 Quartz 的良好支持，使得...

    quartZ定时任务.zip

    下面将详细介绍如何利用Quartz在SpringBoot项目中创建、管理和停止定时任务，并根据业务需求配置cron表达式来设定执行周期。 1. **Quartz简介** - Quartz是Java平台上的一个强大、灵活的作业调度库，它可以与Java...

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