`
齐晓威_518
  • 浏览: 617996 次
  • 性别: Icon_minigender_1
  • 来自: 郑州
社区版块
存档分类
最新评论

Quartz 在 Spring 中如何动态配置时间

阅读更多
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 代码

   1. package com.sundoctor.example.service; 
   2.  
   3. import org.quartz.JobExecutionContext; 
   4. import org.quartz.JobExecutionException; 
   5. import org.quartz.Trigger; 
   6. import org.springframework.scheduling.quartz.QuartzJobBean; 
   7.  
   8. public class MyQuartzJobBean extends QuartzJobBean { 
   9.  
  10.     private SimpleService simpleService; 
  11.      
  12.     public void setSimpleService(SimpleService simpleService) { 
  13.         this.simpleService = simpleService; 
  14.     } 
  15.  
  16.     @Override 
  17.     protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException { 
  18.         Trigger trigger = jobexecutioncontext.getTrigger(); 
  19.         String triggerName = trigger.getName();      
  20.         simpleService.testMethod(triggerName); 
  21.     } 
  22.  
  23. } 

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 代码

   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.stereotype.Service; 
   8.  
   9. @Service("simpleService") 
  10. public class SimpleService implements Serializable{ 
  11.      
  12.     private static final long serialVersionUID = 122323233244334343L; 
  13.     private static final Logger logger = LoggerFactory.getLogger(SimpleService.class); 
  14.      
  15.     public void testMethod(String triggerName){ 
  16.         //这里执行定时调度业务 
  17.         logger.info(triggerName); 
  18.     } 
  19.      
  20.     public void testMethod2(){ 
  21.         logger.info("testMethod2"); 
  22.     } 
  23. } 

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

异常。

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

   1. package com.sundoctor.example.test; 
   2.  
   3. import java.text.ParseException; 
   4. import java.text.SimpleDateFormat; 
   5. import java.util.Date; 
   6.  
   7. import org.springframework.context.ApplicationContext; 
   8. import org.springframework.context.support.ClassPathXmlApplicationContext; 
   9.  
  10. import com.sundoctor.quartz.service.SchedulerService; 
  11.  
  12. public class MainTest { 
  13.  
  14.     
  17.     public static void main(String[] args) { 
  18.         ApplicationContext springContext = new ClassPathXmlApplicationContext(new String[]{"classpath:applicationContext.xml","classpath:applicationContext-quartz.xml"}); 
  19.         SchedulerService schedulerService = (SchedulerService)springContext.getBean("schedulerService"); 
  20.          
  21.         //执行业务逻辑... 
  22.          
  23.         //设置调度任务 
  24.         //每10秒中执行调试一次 
  25.         schedulerService.schedule("0/10 * * ? * * *");  
  26.          
  27.         Date startTime = parse("2009-06-01 22:16:00"); 
  28.         Date endTime =  parse("2009-06-01 22:20:00"); 
  29.          
  30.         //2009-06-01 21:50:00开始执行调度 
  31.         schedulerService.schedule(startTime); 
  32.  
  33.         //2009-06-01 21:50:00开始执行调度,2009-06-01 21:55:00结束执行调试 
  34.         //schedulerService.schedule(startTime,endTime); 
  35.          
  36.         //2009-06-01 21:50:00开始执行调度,执行5次结束 
  37.         //schedulerService.schedule(startTime,null,5); 
  38.  
  39.         //2009-06-01 21:50:00开始执行调度,每隔20秒执行一次,执行5次结束 
  40.         //schedulerService.schedule(startTime,null,5,20); 
  41.          
  42.         //等等,查看 com.sundoctor.quartz.service.SchedulerService         
  43.     } 
  44.      
  45.     private static Date parse(String dateStr){ 
  46.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); 
  47.         try { 
  48.             return format.parse(dateStr); 
  49.         } catch (ParseException e) { 
  50.             throw new RuntimeException(e); 
  51.         } 
  52.     } 
  53.  
  54. } 

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 {

   
    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);

        //2009-06-01 21:50:00开始执行调度,2009-06-01 21:55:00结束执行调试
        //schedulerService.schedule(startTime,endTime);
       
        //2009-06-01 21:50:00开始执行调度,执行5次结束
        //schedulerService.schedule(startTime,null,5);

        //2009-06-01 21:50:00开始执行调度,每隔20秒执行一次,执行5次结束
        //schedulerService.schedule(startTime,null,5,20);
       
        //等等,查看com.sundoctor.quartz.service.SchedulerService       
    }
   
    private static Date parse(String dateStr){
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            return format.parse(dateStr);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

}


输出
引用

[2009-06-02 00:08:50]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:10:20]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:10:30]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:10:40]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:10:50]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:11:00]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f
[2009-06-02 00:11:10]INFO  com.sundoctor.example.service.SimpleService(line:17) -2059c26f-9462-49fe-b4ce-be7e7a29459f

这样只是简单的将quartz trigger名称打印出来。

这样通过SchedulerService就可以动态配置调度时间。其实SchedulerService 还可扩展,比如可以注入多个JobDetail,调度不同的JobDetail。
分享到:
评论

相关推荐

    Spring Quartz如何动态配置时间

    在本文中,我们将讨论如何使用 Spring Quartz 实现动态配置时间,并提供了详细的实现步骤和实践经验。 动态配置时间的目的 在实际应用中,任务的执行时间往往需要根据业务需求进行动态调整,以满足不同的需求场景...

    quartz整合springbatch动态集群定时实现mysql参考

    在这个“quartz_springbatch_dynamic”项目中,我们将看到如何将这两个强大的工具结合起来,以实现动态集群环境中的定时任务执行,并使用MySQL作为数据存储。 Quartz是一个开源的作业调度框架,允许开发者创建、...

    Quartz在Spring中动态设置cronExpression

    标题与描述均聚焦于“Quartz在Spring中动态设置cronExpression”的主题,这涉及到了两个主要的开源项目:Quartz,一个强大的作业调度框架;以及Spring,一个广泛使用的Java平台框架,用于构建企业级应用程序。Quartz...

    quartz在Spring中的配置

    通过上述配置,不仅可以在 Spring 应用中实现定时任务的管理,还能根据实际需求动态调整任务的执行时间和状态。这种方式特别适用于需要频繁变更调度规则的应用场景,如 Web 应用中的报表生成、数据同步等任务。使用...

    Spring中的Quartz配置-Spring-定时器-java定时器.doc

    在本篇文章中,我们将讨论如何在 Spring 中配置 Quartz,以实现 Java 定时器的功能。 Quartz 介绍 Quartz 是一个开源的作业调度器,可以让开发者轻松地实现任务的定时执行。它提供了强大的调度功能,可以满足复杂...

    定时器的配置文件(两种方式:springmvc自带定时,Quartz与spring结合的定时)

    在Spring配置文件(如`applicationContext.xml`)中配置Quartz的SchedulerFactoryBean。 ```xml &lt;bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&gt; ...

    关于spring中quartz的配置

    在Spring配置文件(如`applicationContext.xml`)中,定义`SchedulerFactoryBean`来实例化和配置Quartz Scheduler: ```xml &lt;bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz....

    Spring Quartz动态配置时间.rar

    这个压缩包“Spring Quartz动态配置时间.rar”包含的PDF文档很可能是关于如何在Spring框架中使用Quartz进行动态配置时间的详细教程。下面将详细介绍Spring集成Quartz进行动态任务调度的相关知识点。 1. **Quartz...

    spring mvc quartz 动态设置时间

    - 在`web.xml`中,通过`contextConfigLocation`参数指定了Spring配置文件的位置,这样Spring会自动加载`applicationContext-quartz.xml`。 3. **业务逻辑**: - `SysScheduleServiceImpl`类实现了`...

    spring整合java quartz实现动态定时任务的前台网页配置与管理

    在实际项目应用中经常会用到定时任务,可以通过quartz和spring的简单配置即可完成,但如果要改变任务的执行时间、频率,废弃任务等就需要改变配置甚至代码需要重启服务器,这里介绍一下如何通过quartz与spring的组合...

    quartz和spring-quartz

    学习Quartz和Spring-Quartz,不仅需要理解它们的基本概念,还要掌握如何在实际项目中进行配置和使用。例如,创建一个定时任务,你需要定义Job类,配置Trigger,然后在Spring的配置文件中设置Scheduler。此外,熟悉...

    Spring中Quartz的配置

    接下来是在Spring配置文件中对Quartz进行配置。以下是配置示例: ```xml &lt;!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"&gt; &lt;!-- 要调用的工作类 --&gt; ...

    spring quartz 非配置动态定时

    在Spring配置文件中,可以使用`SchedulerFactoryBean`来初始化并管理Scheduler。这个bean将负责启动、停止Scheduler,以及处理其他相关的生命周期事件。 在非配置动态定时任务中,我们不再在XML或Java配置中硬编码...

    Spring整合quartz2.2.3总结,quartz动态定时任务,Quartz定时任务集群配置

    2. 配置Scheduler:在Spring的配置文件中,使用`SchedulerFactoryBean`来初始化和配置Quartz Scheduler。可以设置如数据库存储、线程池大小等参数。 3. 创建Job类:定义一个实现了`org.quartz.Job`接口的类,这是...

    定时器(quartz+spring)读取数据库配置

    最后,启动Spring容器,Quartz会自动加载数据库中的Job和Trigger配置,按照设定的时间执行相应的任务。 通过这种方式,我们可以构建一个高度可扩展和可配置的定时任务系统,只需在数据库中修改Job和Trigger的配置,...

    Quartz+Spring定时触发器例子

    - 如何在Spring中配置Quartz - 如何创建和配置JobDetail和Trigger - Cron表达式的使用和理解 - 如何在Job类中注入依赖 - 如何启动和停止Scheduler - 如何调试和管理定时任务 总的来说,"Quartz+Spring定时触发器...

    SSH+quartz实现的可动态配置时间规则的定时任务

    在这个项目中,Hibernate可能被用来存储和检索quartz的作业和触发器信息,包括时间规则,这样就可以在数据库中动态更新任务配置,而无需修改代码。 4. **Quartz库**:Quartz是Java中广泛使用的任务调度库,它可以...

Global site tag (gtag.js) - Google Analytics