- 浏览: 315285 次
- 性别:
- 来自: 济南
文章分类
最新评论
-
poterliu:
太棒了,这正是我要的效果
带复选框(checkbox)的下拉列表 -
no_bao:
a164906480 写道不好意思啊,不少东西,我用的时候就是 ...
java使用Map进行分组统计 -
a164906480:
不好意思啊,不少东西,我用的时候就是转int的时候光报异常。 ...
java使用Map进行分组统计 -
a164906480:
String[] strArr=null;
4 ...
java使用Map进行分组统计 -
a164906480:
问一下你后面的数是怎么加的吗
java使用Map进行分组统计
本文转载于:
http://sundoctor.iteye.com/blog/399980
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,动态配置时间。
动态调度服务接口:
- 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.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,如下:
- 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如下:
- 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的方式已经进行了配置。
六、测试
运行如下测试类
- 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);
- //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。
- quartzWithSpring.rar (5 MB)
- 下载次数: 20
发表评论
-
quartz报错java.lang.NoSuchMethodError: org.apache.commons.collections.SetUtils.ord
2013-08-19 14:02 1054quartz报错:Caused by: java.lang.N ... -
Quartz使用指南(七)-----Spring中使用Quartz进行作业调度
2012-10-22 09:10 18301 Spring中使用Qu ... -
Quartz使用指南(六)-----监听器及存储
2012-10-22 09:10 17011 触发器的监听器和作业的监听器(Trigge ... -
Quartz使用指南(五)-----Cron触发器(CronTrigger)
2012-10-22 09:09 2093<!--[if !supportLists]--> ... -
Quartz使用指南(四)-----触发器(Triggers)
2012-10-19 18:04 31724 触发器(Triggers) 与Job相比,Trig ... -
Quartz使用指南(三)-----标识符、 作业和作业详情(Identifiers&Jobs&JobDetails)
2012-10-19 17:54 1529标识 ... -
Quartz使用指南(二)-----作业和触发器Job&Trigger
2012-10-19 17:49 1824我们可以使Scheduler简单地执行一个实现了Job接 ... -
Quartz使用指南(一)-----Quartz简介
2012-10-19 17:47 2021<!--[endif]--> ... -
Quartz在Spring中集群 Quartz引用外部数据源
2012-10-19 17:40 2641转载于 http://www.iteye.com/topic ...
相关推荐
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例,它展示了如何在后台管理系统中动态地创建、更新和删除定时任务,以及监控这些任务的状态,为...
这个压缩包“Spring Quartz动态配置时间.rar”包含的PDF文档很可能是关于如何在Spring框架中使用Quartz进行动态配置时间的详细教程。下面将详细介绍Spring集成Quartz进行动态任务调度的相关知识点。 1. **Quartz...
通过整合SpringBoot和Quartz,我们可以利用Spring的自动配置能力,方便地在Spring应用中集成定时任务功能。 二、Quartz动态配置 1. 引入依赖:首先,在`pom.xml`文件中引入SpringBoot的SpringBoot-starter-quartz...
Quartz是一款开源的作业调度框架,它允许程序在特定时间执行预定的任务,而Spring则是一个强大的企业级应用开发框架,提供了丰富的依赖注入(DI)和面向切面编程(AOP)等功能。将两者结合,可以方便地在Spring应用...
在Spring框架中集成Quartz是一款常见的任务调度解决方案,它允许开发者在应用中安排定时任务的执行。Quartz是一个开源的作业调度框架,可以用来在Java应用程序中安排复杂的作业任务。以下将详细介绍如何在Spring中...
本文将深入探讨如何在Spring环境中集成Quartz以实现集群配置,以便于在分布式环境中进行高效的任务调度。 首先,理解Spring集成Quartz的核心在于Spring的Job接口和Quartz的Scheduler。Spring提供了`org.spring...
本话题主要关注如何在Spring中结合Quartz实现非配置动态定时任务,这允许我们在运行时动态地添加、修改或删除定时任务,而无需修改配置文件。 首先,我们需要理解Spring对Quartz的支持。Spring通过`org.spring...
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz,并通过MySQL数据库实现定时任务的动态配置。 首先,我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中,引入Spring Boot的`spring-boot-starter-...
SSH+quartz实现的可动态配置时间规则的定时任务是一个在IT行业中常见的需求,尤其是在企业级应用和服务中,为了实现自动化运维、数据处理或者业务触发等目的。SSH指的是Spring、Struts和Hibernate这三个Java开发框架...
Quartz的JobDetail和Trigger可以被配置为动态加载,这样就能根据业务逻辑或外部输入来决定何时执行特定任务。MyBatis可以用来执行这些任务中的数据库操作,而Spring MVC则负责处理与前端的交互,展示任务状态和结果...
接着,我们创建一个服务类`JobConfigService`,用于根据配置动态添加、修改或删除任务: ```java @Service public class JobConfigService { @Autowired private Scheduler scheduler; @Autowired private ...
需要注意的是,Quartz的灵活性允许你根据需求配置多个Job和Trigger,甚至可以在运行时动态调整调度策略。结合Spring的DI和AOP特性,Quartz可以很好地适应各种复杂的定时任务场景。 总之,Spring与Quartz的整合是...
在Quartz配置类中,将Job和Trigger注册到Scheduler中,使其生效。 ```java Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); scheduler.scheduleJob(jobDetail, trigger); scheduler.start(); ``...
Spring集成quartz跑定时任务实例 自己写的例子并为实现job 有测试的主函数,请参考...springCon.quartz文件夹下 为对上诉博客理解透彻 结合spring看其配置的相关信息 就可以明白。
本篇文章将深入探讨如何在Spring与Quartz结合的环境中动态设置定时时间。 首先,Spring框架提供了方便的依赖注入和AOP(面向切面编程)功能,使得集成其他库变得更加容易。Quartz是一个强大的作业调度框架,它可以...
在传统的Quartz配置中,定时任务通常静态地定义在代码或者XML配置文件中。这种方式虽然简单明了,但在需求变化频繁或任务数量庞大的情况下,静态配置就显得不够灵活。因此,通过从数据库动态获取任务信息,我们可以...
SSM(Spring、SpringMVC、MyBatis)框架与Quartz的集成是Java开发中常见的一种实现定时任务的方法。Quartz是一个强大的开源作业调度框架,可以用来执行定时任务,而SSM作为主流的Java Web开发框架,为业务逻辑处理...
标题中的“spring quartz集群配置”指的是在Spring框架中集成Quartz定时任务调度器,并实现其在集群环境下的配置。Quartz是一款开源的工作调度框架,它允许开发者创建、调度和执行计划任务。在Spring中整合Quartz,...
Quartz 的优点在于,它可以实现任务的定时执行,且可以灵活地配置任务的执行时间。同时,Quartz 也提供了强大的调度功能,可以满足复杂的任务调度需求。 总结 在本篇文章中,我们讨论了如何在 Spring 中配置 ...
在Web工程中集成Quartz,可以实现诸如定时发送邮件、数据同步、清理过期数据等自动化操作。 1. **Quartz的安装与引入** 在Web工程中使用Quartz,首先需要将其依赖库添加到项目中。如果你使用的是Maven,可以在pom....