spring定时任务

最新推荐文章于 2022-10-21 11:50:52 发布
转载 最新推荐文章于 2022-10-21 11:50:52 发布 · 298 阅读 · 0

本文介绍Spring框架下定时任务的多种实现方法，包括使用Quartz、Spring Task等技术，并提供了详细的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Spring实现定时任务方法  

标签： springquartztask

2017-03-11 02:02 190人阅读 评论(0) 收藏 举报

分类：

spring（3） 

作者同类文章X

task quartz

版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[+]

  1. Quartz
  2. Spring-Task

从 技术上说实现定时任务常见的方法有三种

  • Java自带的java.util.Timer类
  • 使用Quartz调度器，这种方式需要第三方jar支持
  • Spring3.0以后自带的task定时器

第一种方式在这里就不多做说明了，因为timer类功能比较单一，在实际项目中运用也比较少

Quartz

Quartz的使用方式大致有三种，这三种方式的在这里都会和spring进行整合所以都会用到applicationContext.xml进行配置

  • 实现org.quartz.StatefulJob或org.quartz.Job接口
  • 继承org.springframework.scheduling.quartz.QuartzJobBean类
  • 普通类+xml配置文件

1.实现org.quartz.StatefulJob或org.quartz.Job接口 
首先在applicationContext.xml配置定时任务tomcat加载的初始化类，加载时运行init方法

 

  1. <!-- 实现定时任务接口启动类 -->

  2. <bean id="StarJob" class="com.lovo.task.server.impl.StarJob" init-method="init"></bean>

  • 1
  • 2
  • 1
  • 2
  • 1
  • 2

初始化类代码

 

  1. package com.lovo.task.server.impl;

  2.  

  3. import org.quartz.Scheduler;

  4. import org.quartz.SchedulerException;

  5. import org.quartz.SchedulerFactory;

  6. import org.quartz.impl.StdSchedulerFactory;

  7.  

  8. public class StarJob {

  9.  

  10. public void init() throws SchedulerException{

  11. //TestImpl为定时任务的配置实现类

  12. TestImpl impl=new TestImpl();

  13. SchedulerFactory factory = new StdSchedulerFactory();

  14. Scheduler scheduler = factory.getScheduler();

  15. try {

  16. //触发作业类及触发器方法

  17. impl.startJob(scheduler);

  18. } catch (Throwable e) {

  19. // TODO Auto-generated catch block

  20. e.printStackTrace();

  21. }

  22. //启动定时任务

  23. scheduler.start();

  24. }

  25. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

 

作业及调度实现类

 

  1. package com.lovo.task.server.impl;

  2.  

  3. import java.text.ParseException;

  4.  

  5. import org.quartz.CronTrigger;

  6. import org.quartz.JobDetail;

  7. import org.quartz.JobExecutionContext;

  8. import org.quartz.JobExecutionException;

  9. import org.quartz.Scheduler;

  10. import org.quartz.SchedulerException;

  11. import org.quartz.SchedulerFactory;

  12. import org.quartz.StatefulJob;

  13. import org.quartz.Trigger;

  14. import org.quartz.TriggerUtils;

  15. import org.quartz.impl.StdSchedulerFactory;

  16.  

  17. import com.lovo.task.server.ITest;

  18.  

  19. public class TestImpl implements StatefulJob,ITest {

  20.  
  21.  
  22.  

  23. @Override

  24. public void execute(JobExecutionContext arg0) throws JobExecutionException {

  25. // TODO Auto-generated method stub

  26. test();

  27. }

  28.  

  29. @Override

  30. public void startJob(Scheduler scheduler) throws Throwable {

  31. //配置作业类

  32. JobDetail JobDetail=new JobDetail("TestImpl",Scheduler.DEFAULT_GROUP, TestImpl.class);

  33. //任意每分钟类从0开始55结束，每5秒执行一次

  34. String rex="0/5 * * * * ?";

  35. //触发器，配置调度工厂

  36. CronTrigger trigger=new CronTrigger("testTrigger","testGroup", rex);

  37. scheduler.scheduleJob(JobDetail, trigger);

  38.  

  39. //固定每10秒执行一次

  40. // Trigger simplerTrigger = TriggerUtils.makeSecondlyTrigger(10);

  41. // simplerTrigger.setName("SimpleTrigger");

  42. // scheduler.scheduleJob(JobDetail, simplerTrigger);

  43.  

  44. }

  45.  

  46. public void test(){

  47. System.out.println("测试");

  48. }

  49.  

  50. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

 

 

2.继承org.springframework.scheduling.quartz.QuartzJobBean类 
首先在xml中进行配置

 

  1. <!-- 配置计时任务 -->

  2. <!-- 配置作业bean -->

  3. <bean id="TestTaskImpl" class="org.springframework.scheduling.quartz.JobDetailBean">

  4. <!-- value为类路径 -->

  5. <property name="jobClass" value="com.lovo.task.server.impl.TestTaskImpl"></property>

  6. <!-- 此属性定义方法需注入的属性值，time为工厂调度后多久开始执行 -->

  7. <property name="jobDataAsMap">

  8. <map>

  9. <entry key="timeout" value="0"></entry>

  10. </map>

  11. </property>

  12. </bean>

  13.  

  14. <!-- 配置调度触发器 触发器有两种配置方式，一直是固定多少时间循环一次，一种是每天固定几点执行一次，-->

  15. <!-- 固定频率执行 -->

  16. <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">

  17. <property name="jobDetail" ref="TestTaskImpl"></property>

  18. <!-- 实例化后多久开始执行 -->

  19. <property name="startDelay" value="0"></property>

  20. <!-- 间隔频率，单位毫秒 -->

  21. <property name="repeatInterval" value="1000"></property>

  22. </bean>

  23. <!-- 固定时间 每天12:00运行一次-->

  24. <!-- <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">

  25. <property name="jobDetail" ref="TestTaskImpl" />

  26. <property name="cronExpression" value="0 0 12 * * ?" />

  27. </bean> -->

  28.  

  29. <!-- 配置调度工厂 -->

  30. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

  31. <property name="triggers">

  32. <list>

  33. <ref bean="simpleTrigger" />

  34. </list>

  35. </property>

  36. </bean>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
 

 

作业类代码

 

  1. package com.lovo.task.server.impl;

  2.  

  3. import org.quartz.JobExecutionContext;

  4. import org.quartz.JobExecutionException;

  5. import org.springframework.scheduling.quartz.QuartzJobBean;

  6.  

  7. import com.lovo.task.server.TestTask;

  8.  

  9. public class TestTaskImpl extends QuartzJobBean implements TestTask{

  10.  

  11. //time为工厂调度后多久开始执行

  12. private int timeout;

  13. public static int INDEX;

  14.  

  15. public void setTime(int timeout) {

  16. this.timeout = timeout;

  17. }

  18.  
  19.  

  20. @Override

  21. protected void executeInternal(JobExecutionContext arg0)

  22. throws JobExecutionException {

  23. // TODO Auto-generated method stub

  24. testTask();

  25. }

  26.  

  27. @Override

  28. public void testTask() {

  29. // TODO Auto-generated method stub

  30. INDEX++;

  31. System.out.println("执行计时任务第"+INDEX+"次");

  32.  

  33. }

  34.  

  35. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
 
  • 1

 

3.普通类+xml配置文件 
首先定义个普通Java类

 

  1. package com.lovo.task.server;

  2.  

  3. public class TestTask02 {

  4.  

  5. public void Task(){

  6. System.out.println("普通类实现定时任务");

  7. }

  8.  

  9. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

 

在xml中进行配置

 

  1. <!-- 普通类实现定时任务 -->

  2. <!-- 配置作业类 -->

  3. <bean id="Task02" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

  4. <!-- targetObject指定任务类 -->

  5. <property name="targetObject">

  6. <bean class="com.lovo.task.server.TestTask02"></bean>

  7. </property>

  8. <!-- targetMethod指定运行的方法 -->

  9. <property name="targetMethod" value="Task"></property>

  10. <!-- 不并发调度 -->

  11. <property name="concurrent" value="false"></property>

  12. </bean>

  13.  

  14. <!-- 配置调度触发器 触发器有两种配置方式，一直是固定多少时间循环一次，一种是每天固定几点执行一次 -->

  15. <bean id="simpleTrigger02" class="org.springframework.scheduling.quartz.SimpleTriggerBean">

  16. <property name="jobDetail" ref="Task02"></property>

  17. <!-- 实例化后多久开始执行 -->

  18. <property name="startDelay" value="0"></property>

  19. <!-- 间隔频率，单位毫秒 -->

  20. <property name="repeatInterval" value="1000"></property>

  21. </bean>

  22. <!-- 固定时间 每天12:00运行一次-->

  23. <!-- <bean id="cronTrigger02" class="org.springframework.scheduling.quartz.CronTriggerBean">

  24. <property name="jobDetail" ref="Task02" />

  25. <property name="cronExpression" value="0 0 12 * * ?" />

  26. </bean> -->

  27. <!-- 配置调度工厂 -->

  28. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

  29. <property name="triggers">

  30. <list>

  31. <ref bean="simpleTrigger02" />

  32. </list>

  33. </property>

  34. </bean>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
 
  • 1

 

Spring-Task

Spring自带的Task实现定时任务也有两种方式，一种是xml配置的方式，一种是使用注解@Scheduled，不管是那种方式，首先都需要在xml开头声明task

 

  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" xmlns:p="http://www.springframework.org/schema/p"

  4. xmlns:context="http://www.springframework.org/schema/context"

  5. xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"

  6. xmlns:task="http://www.springframework.org/schema/task"

  7. xsi:schemaLocation="http://www.springframework.org/schema/beans

  8. http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

  9. http://www.springframework.org/schema/context

  10. http://www.springframework.org/schema/context/spring-context-4.0.xsd

  11. http://www.springframework.org/schema/aop

  12. http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

  13. http://www.springframework.org/schema/tx

  14. http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

  15. http://www.springframework.org/schema/task

  16. http://www.springframework.org/schema/task/spring-task-3.0.xsd">

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
 
  • 1

配置定时器开关

 

  1. <!-- 配置定时器开关 里面可以配置很多参数，这里只是简单的打开task,并支持@Scheduled -->

  2. <!-- 配置定时器注解开关 里面可以配置很多参数，这里只是简单的打开task,并支持@Scheduled -->

  3. <task:scheduler id="Scheduler" pool-size="10"/>

  4. <task:annotation-driven scheduler="Scheduler" proxy-target-class="true"/>

  • 1
  • 2
  • 3
  • 4
 
  • 1

基于注解的任务类

 

  1. package com.lovo.task.server;

  2.  

  3. import org.springframework.scheduling.annotation.Scheduled;

  4. import org.springframework.stereotype.Component;

  5.  

  6. @Component

  7. public class Task03 {

  8.  

  9. @Scheduled(cron="0/3 * * * * ?")

  10. public void test(){

  11. System.out.println("task定时任务");

  12. }

  13.  

  14. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

如果不习惯注解的，追求代码的简洁性，也可以在xml中配置task定时任务

 

  1. <!-- 配置作业bean -->

  2. <bean id="xmlTask" class="com.lovo.task.server.Task04"></bean>

  3.  

  4. <!-- 配置执行规则 method为作业方法-->

  5. <task:scheduled-tasks>

  6. <task:scheduled ref="xmlTask" method="test" cron="0/2 * * * * ?"/>

  7. </task:scheduled-tasks>

  8.  

  9. <!-- 配置定时器注解开关 里面可以配置很多参数，这里只是简单的打开task,并支持@Scheduled -->

  10. <task:scheduler id="Scheduler" pool-size="10"/>

  11. <task:annotation-driven scheduler="Scheduler" proxy-target-class="true"/>

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
 
  • 1

定时任务

 

  1. package com.lovo.task.server;

  2.  

  3. public class Task04 {

  4.  

  5. public void test(){

  6. System.out.println("xml中配置Task");

  7. }

  8.  

  9. }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
 
  • 1

参考来源： 
http://gong1208.iteye.com/blog/1773177 
cronExpression语法 
字段 允许值 允许的特殊字符 
秒 0-59 , - * / 
分 0-59 , - * / 
小时 0-23 , - * / 
日期 1-31 , - * ? / L W C 
月份 1-12 或者 JAN-DEC , - * / 
星期 1-7 或者 SUN-SAT , - * ? / L C # 
年（可选） 留空, 1970-2099 , - * / 
- 区间 
* 通配符 
? 你不想设置那个字段 
下面只例出几个式子

CRON表达式 含义 
“0 0 12 * * ?” 每天中午十二点触发 
“0 15 10 ? * *” 每天早上10：15触发 
“0 15 10 * * ?” 每天早上10：15触发 
“0 15 10 * * ? *” 每天早上10：15触发 
“0 15 10 * * ? 2005” 2005年的每天早上10：15触发 
“0 * 14 * * ?” 每天从下午2点开始到2点59分每分钟一次触发 
“0 0/5 14 * * ?” 每天从下午2点开始到2：55分结束每5分钟一次触发 
“0 0/5 14,18 * * ?” 每天的下午2点至2：55和6点至6点55分两个时间段内每5分钟一次触发 
“0 0-5 14 * * ?” 每天14:00至14:05每分钟一次触发 
“0 10,44 14 ? 3 WED” 三月的每周三的14：10和14：44触发 
“0 15 10 ? * MON-FRI” 每个周一、周二、周三、周四、周五的10：15触发

KK凯凯
关注
java statefuljob_Spring+quartz 实现定时任务job集群配置【原】
weixin_35133814的博客
02-13 653
packageking.springframework.scheduling.quartz;importorg.apache.commons.logging.Log;importorg.apache.commons.logging.LogFactory;importorg.quartz.Job;importorg.quartz.JobDetail;importorg.quartz.JobExecu...
Spring定时任务
02-17
Spring定时任务是Spring框架中的一个强大特性，它允许开发者在应用程序中设置定时任务，以便在预定义的时间间隔执行特定的任务。这个功能对于实现自动化、批处理、数据同步、监控等多种业务场景非常有用。在本篇中，...
Spring Quartz定时任务所需要的6个jar包
09-27
Spring Quartz定时任务所需要的6个jar包，找到6个可是不容易哦。commons-collections.jar.zip+commons-logging.jar+jta.jar+log4j-1.2.14.jar.zip+quartz-all-1.6.0.jar+spring-2.0.6.jar
spring定时任务配置详解
newMyStyle的博客
01-12 1078
自己备用的两种spring定时任务配置 1.使用spring配置文件方式进行配置 2.使用spring注解方式进行配置接下来咱们就用配置文件的方式进行配置 1、Scheduler的配置<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="trigger
spring定时任务必须要的10个jar包
04-30
commons-collections.jar commons-logging.jar jta.jar log4j-1.2.14.jar quartz-all-1.6.0.jar spring-asm-3.2.0.M1.jar spring-beans-3.2.0.M1.jar spring-context-3.2.0.M1.jar spring-context-support-3.2.0.M1.jar spring-core-3.2.0.M1.jar 以上是jar列表，如果需要实例或配置信息给我留言
spring集成Quartz(JobDetailBean和MethodInvokeJobDetailFactoryBean)
yk10010的博客
04-28 800
1： 添加Quartz依赖jar包 添加Quartz包的依赖 <!-- quartz --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId&...
Spring定时任务实现（非Web项目）
12-24
在非Web项目中实现Spring定时任务，主要步骤如下： 1. **配置Spring Task**：在Spring的配置文件（如`applicationContext.xml`或使用Java配置类）中，我们需要启用任务调度功能并配置相应的执行器或调度器。例如，...
Spring定时任务实现与配置（一）
08-30
Spring定时任务实现与配置（一） 本文主要介绍了Spring定时任务的实现与配置，涵盖了基本概念、依赖管理、配置文件设置、Quartz配置、Job配置等方面的知识点。 Spring定时任务的基本概念 在Spring中，定时任务是...
Spring 定时任务
11-03
### Spring 定时任务 在Spring框架中，定时任务是一个非常重要的特性，它允许开发者以简单的方式实现周期性任务的调度。Spring通过`@Scheduled`注解提供了对定时任务的支持，该注解可以轻松地应用于任何Java方法上...
spring定时任务关键jar包（齐全）
02-09
本文将详细探讨Spring定时任务的关键知识点，并与提供的jar包列表关联。 首先，Spring定时任务主要依赖于`spring-context-support`模块，这个模块包含了处理定时任务所需的类和接口。在压缩包`lib`中，应该包含了这...
Spring整合Quartz（JobDetailBean方式）
dos_186的博客
08-19 3881
http://my.oschina.net/u/1157906/blog/193612 目录[-] 一、Spring创建JobDetail的两种方式 二、整合方式一示例步骤    1、将spring核心jar包、quartz.jar和Spring-context-support.jar导入类路径。    2、编写Job类PunchJob（该类必须继承QuartzJobBe
Spring结合Quartz进行任务调度
Wilson的专栏
06-06 1037
Spring结合Quartz进行任务调度
Quartz 基本使用,任务调度quartz详解,动态定时任务,job,Trigger,Scheduler
鹏神丶明月天
09-19 4948
如一个OA系统需要在每周五9点自动生成数据报表，或者想每月10号自动还款，又或者每周给暗恋的女生定时发送邮件等等。Quartz是什么？Quartz是一个强大任务调度。
quartz定时任务（05）—— 运行流程源码解析
四维大脑的博客
10-21 890
可了解Quartz框架中的正式开始运行部分源码
Quartz 定时器 定时任务
qq_30436011的博客
04-26 5722
https://blog.youkuaiyun.com/noaman_wgs/article/details/80984873 一、什么是Quartz 车票购票，当你下单后，后台就会插入一条待支付的task(job)，一般是30分钟，超过30min后就会执行这个job，去判断你是否支付，未支付就会取消此次订单；当你支付完成之后，后台拿到支付回调后就会再插入一条待消费的task（job），Job触发日期为火车票上的出发日期，超过这个时间就会执行这个job，判断是否使用等。 （1）首先我们需要定义实现一个定时功能的接
Quartz源码节选（三）添加Job和Trigger到Scheduler中
无意中流逝的博客
03-16 651
参考资料 Quartz文档译文 Quartz官方文档 Quartz源码解析 第一篇配合第二篇阅读，讲解一些基本概念。若已了解可跳过。 推荐阅读第三篇，因为本文是基于第三篇的笔记。 DEMO 一个DEMO，每3秒输出helloworld public class MyJob implements Job { @Override public void execute(JobExe...
JavaEE进阶知识学习-----定时任务调度Quartz-3
疾风知劲草，智者必怀仁
01-24 384
Scheduler的主要函数 Date scheduleJob = scheduler.scheduleJob(jobDetail, trigger); 绑定jobDetail和trigger，将它注册进Scheduler中，将trigger中的时间来触发jobDetail中的业务逻辑，返回的时间是最近一次的执行时间。 void start();启动Scheduler void sta
定时任务组件Quartz
qq_45228323的博客
12-16 3564
1.1 Quartz介绍 Quartz是OpenSymphony开源组织在Job scheduling领域的一个开源项目，由Java开发，可以用来执行定时任务，类似于java.util.Timer。Quartz是功能强大的开源作业调度库，几乎可以集成到任何Java应用程序中。Quartz包含许多企业级功能，例如对JTA事务和集群的支持。Quartz作为定时任务组件，既可以单独使用，也可以整合Spring使用。 官网：http://www.quartz-scheduler.org/ maven坐标： <
quartz定时任务不执行不报错处理
热门推荐
qq_25104587的博客
03-26 3万+
用开源定时任务框架Quartz搭建定时任务，任务启动后无任何错误信息输出，也不执行任务。 quartz版本 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId&...
Spring 定时任务配置与使用详解
在提供的内容中，虽然没有直接展示这些注解的使用，但它们是Spring定时任务常用的配置方式。例如，你可以使用`@Scheduled(fixedRate = 120000)`来设定任务每两分钟执行一次，这里的`fixedRate`参数表示间隔时间，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值