文章分类:Java编程
使用spring整合quartz实现定时执行任务，是很简单的事，大体需要几个步骤：
1：定义job，即要在项目定时执行的业务逻辑（定时同步数据库，定时汇总数据。。。。）
a:一个继承QuartzJobBean了的类
b:普通的业务逻辑类
2：定义trigger，即触发规则（两种方式）
a:设定间隔时间执行
b：指定具体的时间执行 年 月 日 时 分 秒 （反向定义）
3：定义任务调度
后两步都是在spring中配置完成的
小例子：
Job1:
Java代码
1. package com.tigerlee.schedule.demo;
2.
3. import org.quartz.JobExecutionContext;
4. import org.quartz.JobExecutionException;
5. import org.springframework.scheduling.quartz.QuartzJobBean;
6.
7. /**
8. *
9. * @author TigerLee
10. * @date Oct 20, 2010
11. * @desc 通过监听继承了类QuartzJobBean的类来实现定时任务
12. */
13. public class HandleReporterJob extends QuartzJobBean{
14. //这个属性可以通过spring配置传递过值
15. public String jobName;
16.
17. @Override
18. protected void executeInternal(JobExecutionContext arg0)
19. throws JobExecutionException {
20.
21. System.out.println("报表："+getJobName()+"开始执行...");
22. //处理报表的实际业务逻辑
23.
24. }
25.
26. public String getJobName() {
27. return jobName;
28. }
29.
30. public void setJobName(String jobName) {
31. this.jobName = jobName;
32. }
33.
34.
35.
36.
37.
38. }
package com.tigerlee.schedule.demo;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
/**
*
* @author TigerLee
* @date Oct 20, 2010
* @desc 通过监听继承了类QuartzJobBean的类来实现定时任务
*/
public class HandleReporterJob extends QuartzJobBean{
//这个属性可以通过spring配置传递过值
public String jobName;
@Override
protected void executeInternal(JobExecutionContext arg0)
throws JobExecutionException {
System.out.println("报表："+getJobName()+"开始执行...");
//处理报表的实际业务逻辑
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
}
Job2:
Java代码
1. package com.tigerlee.schedule.demo;
2. /**
3. *
4. * @author TigerLee
5. * @date Oct 20, 2010
6. * @desc 执行定时任务的业务逻辑
7. */
8. public class HandleDBJob {
9. /**
10. * 要定时执行的业务逻辑
11. */
12. public void handleDB(){
13. System.out.println("开始处理数据库...");
14. }
15.
16.
17. }
package com.tigerlee.schedule.demo;
/**
*
* @author TigerLee
* @date Oct 20, 2010
* @desc 执行定时任务的业务逻辑
*/
public class HandleDBJob {
/**
* 要定时执行的业务逻辑
*/
public void handleDB(){
System.out.println("开始处理数据库...");
}
}
spring 配置文件：
Java代码
1. <?xml version="1.0" encoding="UTF-8"?>
2. <beans xmlns="http://www.springframework.org/schema/beans"
3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4. xmlns:aop="http://www.springframework.org/schema/aop"
5. xmlns:tx="http://www.springframework.org/schema/tx"
6. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
7. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
8. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
9. <!-- 定义一个job （第一种方式） -->
10. <bean name="reporterJob"
11. class="org.springframework.scheduling.quartz.JobDetailBean">
12. <property name="jobClass"
13. value="com.tigerlee.schedule.demo.HandleReporterJob">
14. </property>
15. <property name="jobDataAsMap">
16. <map>
17. <entry key="jobName" value="季度总结" />
18. </map>
19. </property>
20. </bean>
21.
22. <bean id="handleDbJob" class="com.tigerlee.schedule.demo.HandleDBJob"></bean>
23.
24. <!-- 定义第二个job 指定执行的方法 -->
25. <bean id="handleDB"
26. class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
27. <property name="targetObject" ref="handleDbJob" />
28. <property name="targetMethod" value="handleDB" />
29. <!-- 设置任务不并发执行 -->
30. <property name="concurrent" value="false" />
31. </bean>
32.
33.
34. <!-- 定义一个trigger（简单的） -->
35. <bean id="simpleTrigger"
36. class="org.springframework.scheduling.quartz.SimpleTriggerBean">
37. <!-- 指定要执行的job -->
38. <property name="jobDetail" ref="reporterJob"></property>
39. <!-- 设置延迟执行时间 毫秒 -->
40. <property name="startDelay" value="10000" />
41. <!-- 设置间隔时间 毫秒 -->
42. <property name="repeatInterval" value="50000" />
43. </bean>
44.
45. <!-- 定义第二个trigger 指定具体执行的时间 -->
46. <bean id="cronTrigger"
47. class="org.springframework.scheduling.quartz.CronTriggerBean">
48. <property name="jobDetail" ref="handleDB" />
49. <!-- 定义執行時間-->
50. <property name="cronExpression" value="0 21 22 * * ?" />
51. </bean>
52.
53.
54. <!-- 定义任务调度器 -->
55. <bean
56. class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
57. <property name="triggers">
58. <list>
59. <ref bean="simpleTrigger" />
60. <ref bean="cronTrigger"/>
61. </list>
62. </property>
63. </bean>
64.
65. </beans>
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 定义一个job （第一种方式） -->
<bean name="reporterJob"
class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass"
value="com.tigerlee.schedule.demo.HandleReporterJob">
</property>
<property name="jobDataAsMap">
<map>
<entry key="jobName" value="季度总结" />
</map>
</property>
</bean>
<bean id="handleDbJob" class="com.tigerlee.schedule.demo.HandleDBJob"></bean>
<!-- 定义第二个job 指定执行的方法 -->
<bean id="handleDB"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="handleDbJob" />
<property name="targetMethod" value="handleDB" />
<!-- 设置任务不并发执行 -->
<property name="concurrent" value="false" />
</bean>
<!-- 定义一个trigger（简单的） -->
<bean id="simpleTrigger"
class="org.springframework.scheduling.quartz.SimpleTriggerBean">
<!-- 指定要执行的job -->
<property name="jobDetail" ref="reporterJob"></property>
<!-- 设置延迟执行时间 毫秒 -->
<property name="startDelay" value="10000" />
<!-- 设置间隔时间 毫秒 -->
<property name="repeatInterval" value="50000" />
</bean>
<!-- 定义第二个trigger 指定具体执行的时间 -->
<bean id="cronTrigger"
class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="jobDetail" ref="handleDB" />
<!-- 定义執行時間-->
<property name="cronExpression" value="0 21 22 * * ?" />
</bean>
<!-- 定义任务调度器 -->
<bean
class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTrigger" />
<ref bean="cronTrigger"/>
</list>
</property>
</bean>
</beans>
测试启动容器类：
Java代码
1. package com.tigerlee.schedule.demo;
2.
3. import org.springframework.context.ApplicationContext;
4. import org.springframework.context.support.ClassPathXmlApplicationContext;
5.
6. public class Test {
7.
8. public static void main(String[] args){
9.
10. ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
11.
12.
13. }
14. }
package com.tigerlee.schedule.demo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
}
}
附上具体时间的定义规则：
Java代码
1. 0 0 12 * * ?---------------在每天中午12：00触发
2. 0 15 10 ? * *---------------每天上午10:15 触发
3. 0 15 10 * * ?---------------每天上午10:15 触发
4. 0 15 10 * * ? *---------------每天上午10:15 触发
5. 0 15 10 * * ? 2005---------------在2005年中的每天上午10:15 触发
6. 0 * 14 * * ?---------------每天在下午2：00至2：59之间每分钟触发一次
7. 0 0/5 14 * * ?---------------每天在下午2：00至2：59之间每5分钟触发一次
8. 0 0/5 14,18 * * ?---------------每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次
9. 0 0-5 14 * * ?---------------每天在下午2：00至2：05之间每分钟触发一次
10. 0 10,44 14 ? 3 WED---------------每三月份的星期三在下午2：00和2：44时触发
11. 0 15 10 ? * MON-FRI---------------从星期一至星期五的每天上午10：15触发
12. 0 15 10 15 * ?---------------在每个月的每15天的上午10：15触发
13. 0 15 10 L * ?---------------在每个月的最后一天的上午10：15触发
14. 0 15 10 ? * 6L---------------在每个月的最后一个星期五的上午10：15触发
15. 0 15 10 ? * 6L 2002-2005---------------在2002, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发
16. 0 15 10 ? * 6#3---------------在每个月的第三个星期五的上午10：15触发
17. 0 0 12 1/5 * ?---------------从每月的第一天起每过5天的中午12：00时触发
18. 0 11 11 11 11 ?---------------在每个11月11日的上午11：11时触发.
分享到：
相关推荐
在Spring整合Quartz的过程中，我们需要完成以下步骤： 1. **引入依赖**：在项目的Maven或Gradle配置文件中添加Quartz和Spring相关库的依赖。 2. **配置Quartz**：在Spring的配置文件（如`applicationContext.xml`...
以上就是Spring整合Quartz实现定时任务调度的基本流程。在实际开发中，你可能需要根据项目需求对触发规则、任务逻辑、并发控制等方面进行更复杂的配置和设计。同时，Quartz还支持集群部署，可以在多台服务器上实现...
通过以上步骤，你就成功地在Spring应用中整合了Quartz定时任务。在实际开发中，你可能还需要根据项目需求调整Quartz的配置，比如设置线程池大小、任务持久化等。同时，`QuartzStudy`这个文件名可能包含了关于Quartz...
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
Spring整合Quartz 2.2.3是Java开发者在实现定时任务时常用的一种技术组合。Quartz是一款开源的作业调度框架，它允许程序在特定时间执行预定的任务，而Spring则是一个强大的企业级应用开发框架，提供了丰富的依赖注入...
三、Spring整合Quartz 1. 添加依赖：在项目中引入Quartz的jar包，如`quartz-all-1.6.0.jar`，这是Quartz的核心库，包含了所有必需的组件。 2. 配置Spring：在Spring的配置文件中，我们需要配置一个`...
本资源"Spring整合Quartz后的简单定时任务示例"提供了如何将这两者结合使用的实例，旨在帮助开发者实现基于Spring的定时任务功能。 首先，我们要理解Spring对定时任务的支持。Spring框架通过`@Scheduled`注解提供了...
在多应用服务器负载均衡环境下，Spring Quartz定时任务的重复执行问题是一个常见的挑战。Spring Quartz是一个强大的、开源的作业调度框架，允许开发者定义和执行复杂的定时任务。然而，当多个服务器实例并行运行时，...
Spring整合Quartz定时任务是企业级应用中常见的一种任务调度技术，它允许开发者在应用程序中设置定时执行的任务，比如数据同步、报表生成等。Quartz是一个功能强大的开源作业调度框架，而Spring则是一个广泛使用的...
Spring和Quartz是两个强大的工具，可以协同工作来实现动态管理的定时任务。本文将深入探讨如何利用Spring框架和Quartz库创建和管理这些任务。 **Spring框架** 是一个广泛应用的Java企业级开发框架，它提供了丰富的...
在Spring中整合Quartz，我们可以利用Spring的依赖注入和管理特性，简化任务的配置和管理。 在配置Spring与Quartz时，我们通常需要以下几个步骤： 1. **引入依赖**：在项目中添加Quartz和Spring的相关依赖，确保...
Spring整合Quartz实现动态定时任务知识点总结 * Spring框架中定时任务的实现方法有多种，包括使用Spring自带的轻量级定时任务实现和整合Quartz框架来实现动态定时任务。 * Quartz框架是一个功能强大且灵活的定时...
### Spring整合Quartz的方式 #### 1. 配置驱动的方式 这种方式主要是通过XML配置来创建和管理Quartz的Scheduler实例。首先，你需要在Spring的配置文件中引入Quartz的Bean定义，包括`SchedulerFactoryBean`，`...
在Java开发中，Spring框架和Quartz库的整合是实现定时任务的一种常见方式。Spring提供了灵活的定时任务支持，而Quartz则是一个强大的作业调度框架，可以用来安排复杂的任务执行计划。下面我们将深入探讨如何在Spring...
Spring整合Quartz是一款常见的任务调度解决方案，它允许开发者在应用程序中安排定时任务的执行。Quartz是一个开源的作业调度框架，而Spring通过提供一个简洁的API使得与Quartz的集成变得简单。以下是对Spring整合...
4. **Spring整合Quartz**: 在Spring中，我们可以使用`@Component`注解声明Job类，并通过`@DisallowConcurrentExecution`或`@PersistJobDataAfterExecution`控制Job的行为。通过Spring的`SchedulerFactoryBean`，我们...
本文将深入探讨如何在Spring 3中整合Quartz 2来实现灵活、可扩展的定时任务系统。 首先，我们要了解Spring 3与Quartz 2的基本概念。Spring 3是Spring框架的一个版本，它提供了诸如依赖注入、面向切面编程、数据访问...
Spring框架则提供了一种优雅的方式来整合Quartz，使我们能够利用Spring的依赖注入和管理功能来处理定时任务。 要实现Java Spring Quartz动态定时任务，首先需要在项目中引入Quartz库，通常通过Maven或Gradle添加...
在"Spring2.5+Quartz定时任务简单例子web工程"中，我们可以看到这两个框架的结合使用，主要目标是实现基于 Web 应用的定时任务管理。以下将详细介绍这个项目中可能涉及的知识点： 1. **Spring 2.5**： - **依赖...