hyw520110
- 浏览: 221118 次
- 性别:
- 来自: 杭州
-
文章分类
最新评论
-
Wangwei86609：
非常好的规则引擎框架，支持决策树和多线程运行规则https:/ ...
规则引擎 -
hzxlb910：
真详细，收藏哈
maven setting.xml配置说明 -
东方胜：
[b][/b]
脚本语言 Tcl -
345161974：
hyw520110 写道345161974 写道这个Visua ...
Visual Tcl Binary 完整版（完美中文支持） -
hyw520110：
345161974 写道这个Visual Tcl Binary ...
Visual Tcl Binary 完整版（完美中文支持）
转载：
http://sundoctor.iteye.com/blog/399980
在项目中有一个需求，需要灵活配置调度任务时间，并能自由启动或停止调度。
有关调度的实现我就第一就想到了Quartz这个开源调度组件，因为很多项目使用过，Spring结合Quartz静态配置调度任务时间，非常easy。比如：每天凌晨几点定时运行一个程序，这只要在工程中的spring配置文件中配置好spring整合quartz的几个属性就好。
Spring配置文件
引用
<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="simpleService" />
<property name="targetMethod" value="test" />
</bean>
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="jobDetail" />
<property name="cronExpression" value="0 0/50 * ? * * *" />
</bean>
<bean id="schedulerTrigger" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger"/>
</list>
</property>
</bean>
这种配置就是对quartz的一种简单的使用了，调度任务会在spring启动的时候加载到内存中，按照cronTrigger中定义的 cronExpression定义的时间按时触发调度任务。但是这是quartz使用“内存”方式的一种配置，也比较常见，当然对于不使用spring的项目，也可以单独整合quartz。方法也比较简单，可以从quartz的doc中找到配置方式，或者看一下《Quartz Job Scheduling Framework 》。
但是对于想持久化调度任务的状态，并且灵活调整调度时间的方式来说，上面的内存方式就不能满足要求了，正如本文开始我遇到的情况，需要采用数据库方式集成 Quartz，这部分集成其实在《Quartz Job Scheduling Framework 》中也有较为详细的介绍，当然doc文档中也有，但是缺乏和spring集成的实例。
一、需要构建Quartz数据库表，建表脚本在Quartz发行包的docs\dbTables目录，里面有各种数据库建表脚本，我采用的Quartz 1.6.5版本，总共12张表，不同版本，表个数可能不同。我用mysql数据库，执行了Quartz发行包的docs\dbTables\tables_mysql_innodb.sql建表。
二、建立java project，完成后目录如下 
三、配置数据库连接池
配置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
cpool.checkoutTimeout=5000
cpool.minPoolSize=10
cpool.maxPoolSize=25
cpool.maxIdleTime=7200
cpool.acquireIncrement=5
cpool.autoCommitOnClose=true
配置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:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
http://www.springframework.org/schema/jee
http://www.springframework.org/schema/jee/spring-jee-2.5.xsd" >
<context:component-scan base-package="com.sundoctor"/>
<!-- 属性文件读入 -->
<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>
</beans>
这里只是配置了数据连接池，我使用c3p0 连接池，还没有涉及到Quartx有关配置，下面且听我慢慢道来。
四、实现动态定时任务
什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。
这样总不能修改配置文件每定制个定时任务就增加一个trigger吧，即便允许客户修改配置文件，但总需要重新启动web服务啊，研究了下Quartz在Spring中的动态定时，发现
引用
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >
<property name="jobDetail" ref="schedulerJobDetail"/>
<property name="cronExpression">
<value>0/10 * * * * ?</value>
</property>
中cronExpression是关键，如果可以动态设置cronExpression的值，就可以顺利解决问题了。这样我们就不能直接使用org.springframework.scheduling.quartz.CronTriggerBean，需要自己实现一个动态调度服务类，在其中构建CronTrigger或SimpleTrigger，动态配置时间。
动态调度服务接口：
Java代码 
- package com.sundoctor.quartz.service;
- import java.util.Date;
- import org.quartz.CronExpression;
- public interface SchedulerService {
- /**
- * 根据 Quartz Cron Expression 调试任务
- * @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等
- */
- void schedule(String cronExpression);
- /**
- * 根据 Quartz Cron Expression 调试任务
- * @param name Quartz CronTrigger名称
- * @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等
- */
- void schedule(String name,String cronExpression);
- /**
- * 根据 Quartz Cron Expression 调试任务
- * @param cronExpression Quartz CronExpression
- */
- void schedule(CronExpression cronExpression);
- /**
- * 根据 Quartz Cron Expression 调试任务
- * @param name Quartz CronTrigger名称
- * @param cronExpression Quartz CronExpression
- */
- void schedule(String name,CronExpression cronExpression);
- /**
- * 在startTime时执行调试一次
- * @param startTime 调度开始时间
- */
- void schedule(Date startTime);
- /**
- * 在startTime时执行调试一次
- * @param name Quartz SimpleTrigger 名称
- * @param startTime 调度开始时间
- */
- void schedule(String name,Date startTime);
- /**
- * 在startTime时执行调试，endTime结束执行调度
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- */
- void schedule(Date startTime,Date endTime);
- /**
- * 在startTime时执行调试，endTime结束执行调度
- * @param name Quartz SimpleTrigger 名称
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- */
- void schedule(String name,Date startTime,Date endTime);
- /**
- * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- * @param repeatCount 重复执行次数
- */
- void schedule(Date startTime,Date endTime,int repeatCount);
- /**
- * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
- * @param name Quartz SimpleTrigger 名称
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- * @param repeatCount 重复执行次数
- */
- void schedule(String name,Date startTime,Date endTime,int repeatCount);
- /**
- * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- * @param repeatCount 重复执行次数
- * @param repeatInterval 执行时间隔间
- */
- void schedule(Date startTime,Date endTime,int repeatCount,long repeatInterval) ;
- /**
- * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
- * @param name Quartz SimpleTrigger 名称
- * @param startTime 调度开始时间
- * @param endTime 调度结束时间
- * @param repeatCount 重复执行次数
- * @param repeatInterval 执行时间隔间
- */
- void schedule(String name,Date startTime,Date endTime,int repeatCount,long repeatInterval);
- }
package com.sundoctor.quartz.service;
import java.util.Date;
import org.quartz.CronExpression;
public interface SchedulerService {
/**
* 根据 Quartz Cron Expression 调试任务
* @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等
*/
void schedule(String cronExpression);
/**
* 根据 Quartz Cron Expression 调试任务
* @param name Quartz CronTrigger名称
* @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等
*/
void schedule(String name,String cronExpression);
/**
* 根据 Quartz Cron Expression 调试任务
* @param cronExpression Quartz CronExpression
*/
void schedule(CronExpression cronExpression);
/**
* 根据 Quartz Cron Expression 调试任务
* @param name Quartz CronTrigger名称
* @param cronExpression Quartz CronExpression
*/
void schedule(String name,CronExpression cronExpression);
/**
* 在startTime时执行调试一次
* @param startTime 调度开始时间
*/
void schedule(Date startTime);
/**
* 在startTime时执行调试一次
* @param name Quartz SimpleTrigger 名称
* @param startTime 调度开始时间
*/
void schedule(String name,Date startTime);
/**
* 在startTime时执行调试，endTime结束执行调度
* @param startTime 调度开始时间
* @param endTime 调度结束时间
*/
void schedule(Date startTime,Date endTime);
/**
* 在startTime时执行调试，endTime结束执行调度
* @param name Quartz SimpleTrigger 名称
* @param startTime 调度开始时间
* @param endTime 调度结束时间
*/
void schedule(String name,Date startTime,Date endTime);
/**
* 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
* @param startTime 调度开始时间
* @param endTime 调度结束时间
* @param repeatCount 重复执行次数
*/
void schedule(Date startTime,Date endTime,int repeatCount);
/**
* 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次
* @param name Quartz SimpleTrigger 名称
* @param startTime 调度开始时间
* @param endTime 调度结束时间
* @param repeatCount 重复执行次数
*/
void schedule(String name,Date startTime,Date endTime,int repeatCount);
/**
* 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
* @param startTime 调度开始时间
* @param endTime 调度结束时间
* @param repeatCount 重复执行次数
* @param repeatInterval 执行时间隔间
*/
void schedule(Date startTime,Date endTime,int repeatCount,long repeatInterval) ;
/**
* 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次
* @param name Quartz SimpleTrigger 名称
* @param startTime 调度开始时间
* @param endTime 调度结束时间
* @param repeatCount 重复执行次数
* @param repeatInterval 执行时间隔间
*/
void schedule(String name,Date startTime,Date endTime,int repeatCount,long repeatInterval);
}
动态调度服务实现类：
Java代码
- package com.sundoctor.quartz.service;
- import java.text.ParseException;
- import java.util.Date;
- import java.util.UUID;
- import org.quartz.CronExpression;
- import org.quartz.CronTrigger;
- import org.quartz.JobDetail;
- import org.quartz.Scheduler;
- import org.quartz.SchedulerException;
- import org.quartz.SimpleTrigger;
- import org.springframework.beans.factory.annotation.Autowired;
- import org.springframework.beans.factory.annotation.Qualifier;
- import org.springframework.stereotype.Service;
- @Service("schedulerService")
- public class SchedulerServiceImpl implements SchedulerService {
- private Scheduler scheduler;
- private JobDetail jobDetail;
- @Autowired
- public void setJobDetail(@Qualifier("jobDetail") JobDetail jobDetail) {
- this.jobDetail = jobDetail;
- }
- @Autowired
- public void setScheduler(@Qualifier("quartzScheduler") Scheduler scheduler) {
- this.scheduler = scheduler;
- }
- @Override
- public void schedule(String cronExpression) {
- schedule(null, cronExpression);
- }
- @Override
- public void schedule(String name, String cronExpression) {
- try {
- schedule(name, new CronExpression(cronExpression));
- } catch (ParseException e) {
- throw new RuntimeException(e);
- }
- }
- @Override
- public void schedule(CronExpression cronExpression) {
- schedule(null, cronExpression);
- }
- @Override
- public void schedule(String name, CronExpression cronExpression) {
- if (name == null || name.trim().equals("")) {
- name = UUID.randomUUID().toString();
- }
- try {
- scheduler.addJob(jobDetail, true);
- CronTrigger cronTrigger = new CronTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
- Scheduler.DEFAULT_GROUP);
- cronTrigger.setCronExpression(cronExpression);
- scheduler.scheduleJob(cronTrigger);
- scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, cronTrigger);
- } catch (SchedulerException e) {
- throw new RuntimeException(e);
- }
- }
- @Override
- public void schedule(Date startTime) {
- schedule(startTime, null);
- }
- @Override
- public void schedule(String name, Date startTime) {
- schedule(name, startTime, null);
- }
- @Override
- public void schedule(Date startTime, Date endTime) {
- schedule(startTime, endTime, 0);
- }
- @Override
- public void schedule(String name, Date startTime, Date endTime) {
- schedule(name, startTime, endTime, 0);
- }
- @Override
- public void schedule(Date startTime, Date endTime, int repeatCount) {
- schedule(null, startTime, endTime, 0);
- }
- @Override
- public void schedule(String name, Date startTime, Date endTime, int repeatCount) {
- schedule(name, startTime, endTime, 0, 0L);
- }
- @Override
- public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval) {
- schedule(null, startTime, endTime, repeatCount, repeatInterval);
- }
- @Override
- public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval) {
- if (name == null || name.trim().equals("")) {
- name = UUID.randomUUID().toString();
- }
- try {
- scheduler.addJob(jobDetail, true);
- SimpleTrigger SimpleTrigger = new SimpleTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
- Scheduler.DEFAULT_GROUP, startTime, endTime, repeatCount, repeatInterval);
- scheduler.scheduleJob(SimpleTrigger);
- scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, SimpleTrigger);
- } catch (SchedulerException e) {
- throw new RuntimeException(e);
- }
- }
- }
package com.sundoctor.quartz.service;
import java.text.ParseException;
import java.util.Date;
import java.util.UUID;
import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleTrigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service("schedulerService")
public class SchedulerServiceImpl implements SchedulerService {
private Scheduler scheduler;
private JobDetail jobDetail;
@Autowired
public void setJobDetail(@Qualifier("jobDetail") JobDetail jobDetail) {
this.jobDetail = jobDetail;
}
@Autowired
public void setScheduler(@Qualifier("quartzScheduler") Scheduler scheduler) {
this.scheduler = scheduler;
}
@Override
public void schedule(String cronExpression) {
schedule(null, cronExpression);
}
@Override
public void schedule(String name, String cronExpression) {
try {
schedule(name, new CronExpression(cronExpression));
} catch (ParseException e) {
throw new RuntimeException(e);
}
}
@Override
public void schedule(CronExpression cronExpression) {
schedule(null, cronExpression);
}
@Override
public void schedule(String name, CronExpression cronExpression) {
if (name == null || name.trim().equals("")) {
name = UUID.randomUUID().toString();
}
try {
scheduler.addJob(jobDetail, true);
CronTrigger cronTrigger = new CronTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
Scheduler.DEFAULT_GROUP);
cronTrigger.setCronExpression(cronExpression);
scheduler.scheduleJob(cronTrigger);
scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, cronTrigger);
} catch (SchedulerException e) {
throw new RuntimeException(e);
}
}
@Override
public void schedule(Date startTime) {
schedule(startTime, null);
}
@Override
public void schedule(String name, Date startTime) {
schedule(name, startTime, null);
}
@Override
public void schedule(Date startTime, Date endTime) {
schedule(startTime, endTime, 0);
}
@Override
public void schedule(String name, Date startTime, Date endTime) {
schedule(name, startTime, endTime, 0);
}
@Override
public void schedule(Date startTime, Date endTime, int repeatCount) {
schedule(null, startTime, endTime, 0);
}
@Override
public void schedule(String name, Date startTime, Date endTime, int repeatCount) {
schedule(name, startTime, endTime, 0, 0L);
}
@Override
public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval) {
schedule(null, startTime, endTime, repeatCount, repeatInterval);
}
@Override
public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval) {
if (name == null || name.trim().equals("")) {
name = UUID.randomUUID().toString();
}
try {
scheduler.addJob(jobDetail, true);
SimpleTrigger SimpleTrigger = new SimpleTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),
Scheduler.DEFAULT_GROUP, startTime, endTime, repeatCount, repeatInterval);
scheduler.scheduleJob(SimpleTrigger);
scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, SimpleTrigger);
} catch (SchedulerException e) {
throw new RuntimeException(e);
}
}
}
SchedulerService 只有一个多态方法schedule，SchedulerServiceImpl实现SchedulerService接口，注入org.quartz.Schedulert和org.quartz.JobDetail，schedule方法可以动态配置org.quartz.CronExpression或org.quartz.SimpleTrigger调度时间。
五、实现自己的org.quartz.JobDetail
在上一步中SchedulerServiceImpl需要注入org.quartz.JobDetail，在以前的静态配置中
引用
<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="simpleService" />
<property name="targetMethod" value="testMethod" />
</bean>
中使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。在这里使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。会报
引用
Caused by: java.io.NotSerializableException: Unable to serialize JobDataMap for insertion into database because the value of property 'methodInvoker' is not serializable: org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean
at org.quartz.impl.jdbcjobstore.StdJDBCDelegate.serializeJobData(StdJDBCDelegate.java:3358)
at org.quartz.impl.jdbcjobstore.StdJDBCDelegate.insertJobDetail(StdJDBCDelegate.java:515)
at org.quartz.impl.jdbcjobstore.JobStoreSupport.storeJob(JobStoreSupport.java:1102)
... 11 more
异常，google了一下，没有找到解决方法。所以在这里不能使用org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean。，不能pojo了，需要使用org.springframework.scheduling.quartz.JobDetailBean和org.springframework.scheduling.quartz.QuartzJobBean实现自己的QuartzJobBean，如下：
Java代码
- package com.sundoctor.example.service;
- import org.quartz.JobExecutionContext;
- import org.quartz.JobExecutionException;
- import org.quartz.Trigger;
- import org.springframework.scheduling.quartz.QuartzJobBean;
- public class MyQuartzJobBean extends QuartzJobBean {
- private SimpleService simpleService;
- public void setSimpleService(SimpleService simpleService) {
- this.simpleService = simpleService;
- }
- @Override
- protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException {
- Trigger trigger = jobexecutioncontext.getTrigger();
- String triggerName = trigger.getName();
- simpleService.testMethod(triggerName);
- }
- }
package com.sundoctor.example.service;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Trigger;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class MyQuartzJobBean extends QuartzJobBean {
private SimpleService simpleService;
public void setSimpleService(SimpleService simpleService) {
this.simpleService = simpleService;
}
@Override
protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException {
Trigger trigger = jobexecutioncontext.getTrigger();
String triggerName = trigger.getName();
simpleService.testMethod(triggerName);
}
}
MyQuartzJobBean继承org.springframework.scheduling.quartz.QuartzJobBean，注入的SimpleService如下：
Java代码
- package com.sundoctor.example.service;
- import java.io.Serializable;
- import org.slf4j.Logger;
- import org.slf4j.LoggerFactory;
- import org.springframework.stereotype.Service;
- @Service("simpleService")
- public class SimpleService implements Serializable{
- private static final long serialVersionUID = 122323233244334343L;
- private static final Logger logger = LoggerFactory.getLogger(SimpleService.class);
- public void testMethod(String triggerName){
- //这里执行定时调度业务
- logger.info(triggerName);
- }
- public void testMethod2(){
- logger.info("testMethod2");
- }
- }
package com.sundoctor.example.service;
import java.io.Serializable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
@Service("simpleService")
public class SimpleService implements Serializable{
private static final long serialVersionUID = 122323233244334343L;
private static final Logger logger = LoggerFactory.getLogger(SimpleService.class);
public void testMethod(String triggerName){
//这里执行定时调度业务
logger.info(triggerName);
}
public void testMethod2(){
logger.info("testMethod2");
}
}
SimpleService主要执行定时调度业务，在这里我只是简单打印一下log日志。SimpleService需要实现java.io.Serializable接口，否则会报
引用
Caused by: java.io.InvalidClassException: com.sundoctor.example.service.SimpleService; class invalid for deserialization
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:587)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1583)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1496)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1732)
... 64 more
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:587)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1583)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1496)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1732)
... 64 more
异常。
配置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"/>
</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>
</beans>
quartzScheduler中没有了
引用
<property name="triggers">
<list>
...
</list>
/property>
配置，通过SchedulerService动态加入CronTrigger或SimpleTrigger。
在红色的
引用
<property name="jobDataAsMap">
<map>
<entry key="simpleService">
<ref bean="simpleService" />
</entry>
</map>
</property>
中需要注入调度业务类，否则会报空指指错误。
dataSource：项目中用到的数据源，里面包含了quartz用到的12张数据库表；
applicationContextSchedulerContextKey： 是org.springframework.scheduling.quartz.SchedulerFactoryBean这个类中把spring上下文以key/value的方式存放在了quartz的上下文中了，可以用applicationContextSchedulerContextKey所定义的key得到对应的spring上下文；
configLocation：用于指明quartz的配置文件的位置，如果不用spring配置quartz的话，本身quartz是通过一个配置文件进行配置的，默认名称是quartz.properties，里面配置的参数在quartz的doc文档中都有介绍，可以调整quartz，我在项目中也用这个文件部分的配置了一些属性，代码如下：
引用
org.quartz.scheduler.instanceName = DefaultQuartzScheduler
org.quartz.scheduler.rmi.export = false
org.quartz.scheduler.rmi.proxy = false
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
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.HSQLDBDelegate
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
这里面没有数据源相关的配置部分，采用spring注入datasource的方式已经进行了配置。
六、测试
运行如下测试类
Java代码
- package com.sundoctor.example.test;
- import java.text.ParseException;
- import java.text.SimpleDateFormat;
- import java.util.Date;
- import org.springframework.context.ApplicationContext;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- import com.sundoctor.quartz.service.SchedulerService;
- public class MainTest {
- /**
- * @param args
- */
- public static void main(String[] args) {
- ApplicationContext springContext = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext.xml","classpath:applicationContext-quartz.xml"});
- SchedulerService schedulerService = (SchedulerService)springContext.getBean("schedulerService");
- //执行业务逻辑...
- //设置调度任务
- //每10秒中执行调试一次
- schedulerService.schedule("0/10 * * ? * * *");
- Date startTime = parse("2009-06-01 22:16:00");
- Date endTime = parse("2009-06-01 22:20:00");
- //2009-06-01 21:50:00开始执行调度
- schedulerService.schedule(startTime);
-
<s
分享到：
发表评论
-
pushlet
2012-05-31 14:56 1176基于pushlet的文件监控系统的研究与实现 http ... -
@Transactional spring 配置事务
2012-04-25 11:15 2095@Transactional spring 配置事 ... -
Spring的组件自动扫描机制
2012-04-09 17:47 0Spring将所有的bean都纳入到IOC中创建、管理和维护。 ... -
struts&rest
2012-04-03 00:11 799深入浅出REST http://www.infoq. ... -
文件转码
2011-11-16 09:55 2024工程项目太多，各工程或各文件编码不统一时，可运行本工具类，把工 ... -
安装和使用SpringIDE-------III
2011-07-29 10:40 8612. 编写类文件 · ... -
安装和使用SpringIDE-------II
2011-07-29 10:39 687显示图表，如图： 发表于 @ 2006 ... -
安装和使用SpringIDE
2011-07-29 10:36 1135这篇文章谈谈如何安装与使用SpringIDE。作为辅助Sp ... -
使用AJDT简化AspectJ开发
2011-07-29 10:05 1054面向方面编程(AOP)可用来解决当今的 许多 应用需求 ... -
利用Apache的CLI来处理命令行
2011-05-16 17:02 987CLI是Jakarta Commons中的一个子类。如果你仅仅 ... -
CGlib简单介绍
2011-04-28 08:37 867CGlib概述：cglib（Code Generation L ... -
Java ClassLoader
2011-04-25 18:24 1012当Java编译器编译好.class ... -
Template模式与Strategy模式
2011-04-20 16:23 687template method模式和stra ... -
Ibatis读写CLOB数据
2011-03-21 14:21 1053转载：http://www.iteye.com/topic/7 ... -
轻松构建和运行多线程的单元测试
2011-03-18 22:09 982背景 并行程序 并行程序是指控制计算机系统中两个或多个分别 ... -
Cairngorm3中文简介
2011-03-18 22:07 1029官方原文地址：http://opensource.adobe. ... -
ibator改造之返回数据库注释和数据库分页
2010-12-23 17:24 2239转载：http://www.iteye.com ... -
quatrz 任务监控管理 (2)
2010-10-28 23:28 1448在《Quartz 任务监控管理 (1)》http://www. ... -
Quartz任务监控管理 (1)
2010-10-28 23:27 1316转载：http://sundoctor.iteye.com/b ... -
使用org.apache.commons.net.ftp包开发FTP客户端，实现进度汇报，实现断点续传，中文支持
2010-10-28 21:09 1027使用org.apache.commons.net.ftp包开发 ...
相关推荐
在本文中，我们将讨论如何使用 Spring Quartz 实现动态配置时间，并提供了详细的实现步骤和实践经验。 动态配置时间的目的 在实际应用中，任务的执行时间往往需要根据业务需求进行动态调整，以满足不同的需求场景...
在这个“quartz_springbatch_dynamic”项目中，我们将看到如何将这两个强大的工具结合起来，以实现动态集群环境中的定时任务执行，并使用MySQL作为数据存储。 Quartz是一个开源的作业调度框架，允许开发者创建、...
标题与描述均聚焦于“Quartz在Spring中动态设置cronExpression”的主题，这涉及到了两个主要的开源项目：Quartz，一个强大的作业调度框架；以及Spring，一个广泛使用的Java平台框架，用于构建企业级应用程序。Quartz...
通过上述配置，不仅可以在 Spring 应用中实现定时任务的管理，还能根据实际需求动态调整任务的执行时间和状态。这种方式特别适用于需要频繁变更调度规则的应用场景，如 Web 应用中的报表生成、数据同步等任务。使用...
在本篇文章中，我们将讨论如何在 Spring 中配置 Quartz，以实现 Java 定时器的功能。 Quartz 介绍 Quartz 是一个开源的作业调度器，可以让开发者轻松地实现任务的定时执行。它提供了强大的调度功能，可以满足复杂...
在Spring配置文件（如`applicationContext.xml`）中配置Quartz的SchedulerFactoryBean。 ```xml <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> ...
在Spring配置文件（如`applicationContext.xml`）中，定义`SchedulerFactoryBean`来实例化和配置Quartz Scheduler： ```xml <bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz....
这个压缩包“Spring Quartz动态配置时间.rar”包含的PDF文档很可能是关于如何在Spring框架中使用Quartz进行动态配置时间的详细教程。下面将详细介绍Spring集成Quartz进行动态任务调度的相关知识点。 1. **Quartz...
- 在`web.xml`中，通过`contextConfigLocation`参数指定了Spring配置文件的位置，这样Spring会自动加载`applicationContext-quartz.xml`。 3. **业务逻辑**： - `SysScheduleServiceImpl`类实现了`...
最后，启动Spring容器，Quartz会自动加载数据库中的Job和Trigger配置，按照设定的时间执行相应的任务。 通过这种方式，我们可以构建一个高度可扩展和可配置的定时任务系统，只需在数据库中修改Job和Trigger的配置，...
在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合...
学习Quartz和Spring-Quartz，不仅需要理解它们的基本概念，还要掌握如何在实际项目中进行配置和使用。例如，创建一个定时任务，你需要定义Job类，配置Trigger，然后在Spring的配置文件中设置Scheduler。此外，熟悉...
接下来是在Spring配置文件中对Quartz进行配置。以下是配置示例： ```xml <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> <!-- 要调用的工作类 --> ...
在Spring配置文件中，可以使用`SchedulerFactoryBean`来初始化并管理Scheduler。这个bean将负责启动、停止Scheduler，以及处理其他相关的生命周期事件。 在非配置动态定时任务中，我们不再在XML或Java配置中硬编码...
- 如何在Spring中配置Quartz - 如何创建和配置JobDetail和Trigger - Cron表达式的使用和理解 - 如何在Job类中注入依赖 - 如何启动和停止Scheduler - 如何调试和管理定时任务 总的来说，"Quartz+Spring定时触发器...
在这个项目中，Hibernate可能被用来存储和检索quartz的作业和触发器信息，包括时间规则，这样就可以在数据库中动态更新任务配置，而无需修改代码。 4. **Quartz库**：Quartz是Java中广泛使用的任务调度库，它可以...
2. 配置Scheduler：在Spring的配置文件中，使用`SchedulerFactoryBean`来初始化和配置Quartz Scheduler。可以设置如数据库存储、线程池大小等参数。 3. 创建Job类：定义一个实现了`org.quartz.Job`接口的类，这是...