Spring定时任务的几种实现

合集下载

spring定时任务详解（@Scheduled注解）

spring定时任务详解（@Scheduled注解）Spring配置⽂件xmlns加⼊xmlns:task="/schema/task"xsi:schemaLocation中加⼊/schema/task/schema/task/spring-task-3.0.xsd"Spring扫描注解的配置<context:component-scan base-package="com.imwoniu.*" />任务扫描注解<task:executor id="executor" pool-size="5" /><task:scheduler id="scheduler" pool-size="10" /><task:annotation-driven executor="executor" scheduler="scheduler" />代码实现：注解@Scheduled 可以作为⼀个触发源添加到⼀个⽅法中，例如，以下的⽅法将以⼀个固定延迟时间5秒钟调⽤⼀次执⾏，这个周期是以上⼀个调⽤任务的完成时间为基准，在上⼀个任务完成之后，5s后再次执⾏：@Scheduled(fixedDelay = 5000)public void doSomething() {// something that should execute periodically}如果需要以固定速率执⾏，只要将注解中指定的属性名称改成fixedRate即可，以下⽅法将以⼀个固定速率5s来调⽤⼀次执⾏，这个周期是以上⼀个任务开始时间为基准，从上⼀任务开始执⾏后5s再次调⽤：@Scheduled(fixedRate = 5000)public void doSomething() {// something that should execute periodically}如果简单的定期调度不能满⾜，那么cron表达式提供了可能package com.imwoniu.task;import org.springframework.scheduling.annotation.Scheduled;import ponent;@Componentpublic class TaskDemo {@Scheduled(cron = "0 0 2 * * ?") //每天凌晨两点执⾏void doSomethingWith(){("定时任务开始......");long begin = System.currentTimeMillis();//执⾏数据库操作了哦...long end = System.currentTimeMillis();("定时任务结束，共耗时：[" + (end-begin) / 1000 + "]秒");}}关于Cron表达式(转载)表达式⽹站⽣成:按顺序依次为秒（0~59）分钟（0~59）⼩时（0~23）天（⽉）（0~31，但是你需要考虑你⽉的天数）⽉（0~11）天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）7.年份（1970－2099）其中每个元素可以是⼀个值(如6),⼀个连续区间(9-12),⼀个间隔时间(8-18/4)(/表⽰每隔4⼩时),⼀个列表(1,3,5),通配符。

SpringScheduled定时任务+异步执行

SpringScheduled定时任务+异步执⾏Spring定时任务 + 异步执⾏1.实现spring定时任务的执⾏import org.springframework.scheduling.annotation.Scheduled;import ponent;import java.text.SimpleDateFormat;import java.util.Date;@Componentpublic class ScheduledTasks {private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");@Scheduled(fixedDelay = 5000)public void first() throws InterruptedException {System.out.println("第⼀个定时任务开始 : " + sdf.format(new Date()) + "\r\n线程 : " + Thread.currentThread().getName());System.out.println();Thread.sleep(1000 * 10); //模拟第⼀个任务执⾏的时间}@Scheduled(fixedDelay =3000)public void second() {System.out.println("第⼆个定时任务开始 : " + sdf.format(new Date()) + "\r\n线程 : " + Thread.currentThread().getName());System.out.println();}}由于执⾏定时任务默认的是单线程，存在的问题是：线程资源被第⼀个定时任务占⽤,第⼆个定时任务并不是3秒执⾏⼀次;解决⽅法，创建定时任务的线程调度器，交给spring管理调度import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.TaskScheduler;import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;@Configurationpublic class ScheduleConfig {@Beanpublic TaskScheduler taskScheduler() {ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();scheduler.setPoolSize(10);return scheduler;}}这样就可以保证定时任务之间是多线程，⽽每个定时任务之间是单线程，保证了定时任务的异步，同时保证了消息的幂等性。

Spring提供的三种定时任务机制及其比较

Spring提供的三种定时任务机制及其比较定时任务的需求在众多应用系统中广泛存在，在Spring中，我们可以使用三种不同的定时机制，下面一一描述并加以比较1. 基于Quartz的定时机制下面详细解释这个类图中涉及的关键类及其使用场景1.1. SchedulerFactoryBean这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定义在这个类中的所有triggerSpring配置范例：[xhtml]view plaincopy1.<bean id="sfb"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">2.3.<property name="triggers">4.<list>5.<ref local="appSubscTrigger"/>6.</list>7.</property>8.9.10.<property name="globalTriggerListeners">11.<list>12.<ref local="myTaskTriggerListener"/>13.</list>14.</property>15.</bean>1.2. CronTriggerBean实现了Trigger接口，基于Cron表达式的触发器这种触发器的好处是表达式与linux下的crontab一致，能够满足非常复杂的定时需求，也容易配置Spring配置范例：[xhtml]view plaincopy1.<bean id="notifyTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">2.<property name="jobDetail"ref="notifyJobDetail"/>3.<property name="cronExpression"value="${notify_trigger_cron_expression}"/>4.</bean>1.3. SimpleTriggerBean该类也实现了Trigger接口，基于配置的定时调度这个触发器的优点在于很容易配置一个简单的定时调度策略Spring配置范例：[xhtml]view plaincopy1.<bean id="simpleReportTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean">2.<property name="jobDetail">3.<ref bean="reportJob"/>4.</property>5.<property name="startDelay">6.<value>3600000</value>7.</property>8.<property name="repeatInterval">9.<value>86400000</value>10.</property>11.</bean>1.4. JobDetailBeanJobDetail类的简单扩展，能够包装一个继承自QuartzJobBean的普通Bean，使之成为定时运行的Job缺点是包装的Bean必须继承自一个指定的类，通用性不强，对普通Job的侵入性过强，不推荐使用1.5. MethodInvokingJobDetailFactoryBeanSpring提供的一个不错的JobDetail包装工具，能够包装任何bean，并执行类中指定的任何stati或非static的方法，避免强制要求bean去实现某接口或继承某基础类Spring配置范例：[xhtml]view plaincopy1.<bean id="notifyJobDetail"parent="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">2.<property name="targetObject"ref="notifyServerHandler"/>3.<property name="targetMethod"value="execute"/>4.</bean>1.6. 关于TriggerListener和JobListenerQuartz中提供了类似WebWork的拦截器的功能，系统执行任务前或任务执行完毕后，都会检查是否有对应的Listener需要被执行，这种AOP的思想为我们带来了灵活的业务需求实现方式。

如何在spring中配置定时任务（job）-zxs9999的专栏-CSDN博客

如何在spring中配置定时任务（job）-zxs9999的专栏-CSDN博客如何在spring中配置定时任务(job) 收藏一、在web.xml文件中进行如下配置：<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext-*.xml</param-value></context-param>那么需要在工程下创建一个以applicationContext- 为开头的xml 文件eg:applicationContext-jobconfig.xmlxml的头和结尾部分跟其他spring配置文件相似，就不赘述，正文如下：<bean id="youJobName(类别名)" class="com.******.YourJobClassLocation(类的定位)" /> <bean id="doYourJob(别名)" class="org.springframework.scheduling.quartz.MethodInvoking JobDetailFactoryBean"><property name="targetObject"><ref bean="youJobName(类别名)""/></property><property name="targetMethod"><value>runMethodName(定时执行的方法名)</value></property></bean><bean id="youJobNameTrigger(触发器别名)" class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail"><ref bean="doYourJob(别名)""/></property><property name="cronExpression"><value>0 0/20 * * * ?(定时的时间配置)</value></property></bean><bean id="doScheduler" class="org.springframework.scheduling.quartz.SchedulerFactory Bean"><property name="triggers"><list><ref local="youJobNameTrigger(触发器别名)"/></list></property></bean>这样的配置几本就可以运转了，但是有一个地方可能是你需要根据你的需求来确定的，那就是触发时间。

SpringBoot执行定时任务@Scheduled的方法

SpringBoot执⾏定时任务@Scheduled的⽅法在做项⽬时，需要⼀个定时任务来接收数据存⼊数据库，后端再写⼀个接⼝来提供该该数据的最新的那⼀条。

数据保持最新：设计字段sign的值（0，1）来设定是否最新定时任务插⼊数据：⾸先进⾏更新，将所有为1即新数据设置过期，然后插⼊新数据，设置sign为1。

这两个操作是原⼦操作。

通过添加事务来进⾏控制。

Java 定时任务的⼏种实现⽅式基于 java.util.Timer 定时器，实现类似闹钟的定时任务使⽤ Quartz、elastic-job、xxl-job 等开源第三⽅定时任务框架，适合分布式项⽬应⽤使⽤ Spring 提供的⼀个注解： @Schedule，开发简单，使⽤⽐较⽅便，也是本⽂介绍的⼀种⽅式Spring 提供的⼀个注解： @Schedule，开发简单，使⽤⽐较⽅便，也是本⽂介绍的⼀种⽅式Spring ⾃⾝提供了对定时任务的⽀持，本⽂将介绍 Spring Boot 中 @Scheduled 定时器的使⽤。

创建定时任务⾸先，在项⽬启动类上添加@EnableScheduling注解，开启对定时任务的⽀持@SpringBootApplication@EnableSchedulingpublic class ScheduledApplication {public static void main(String[] args) {SpringApplication.run(ScheduledApplication.class, args);}}其中@EnableScheduling注解的作⽤是发现注解@Scheduled的任务并后台执⾏。

其次，编写定时任务类和⽅法，定时任务类通过Spring IOC 加载，使⽤@Component注解，定时⽅法使⽤@Scheduled注解。

@Componentpublic class ScheduledTask {@Scheduled(fixedRate = 3000)public void scheduledTask() {System.out.println("任务执⾏时间：" + LocalDateTime.now());}}fixedRate 是 long 类型，表⽰任务执⾏的间隔毫秒数，以上代码中的定时任务每 3 秒执⾏⼀次。

Spring@Scheduled定时任务的fixedRate,fixedDelay,cro。。。

Spring@Scheduled定时任务的fixedRate,fixedDelay,cro。

⼀. 三种定时类型。

1.cron --@Scheduled（cron="0/5 * * * *？"）当时间达到设置的时间会触发事件。

上⾯那个例⼦会每5秒执⾏⼀次。

2018/1/4 14:27:302018/1/4 14:27:352018/1/4 14:27:402018/1/4 14:27:452018/1/4 14:27:502.fixedRate --@Scheduled（fixedRate=2000）每两秒执⾏⼀次时间。

3.fixedDelay --@Scheduled（fixedDelay=2000）每次任务执⾏完之后的2s后继续执⾏看字⾯意思容易理解，但是任务执⾏长度超过周期会怎样呢？不多说，直接上图：import java.text.DateFormat;import java.text.SimpleDateFormat;import java.util.Date;import org.springframework.scheduling.annotation.Scheduled;import ponent;@Componentpublic class MyProcessor{DateFormat sdf = new SimpleDateFormat("HH:mm:ss");int[] delays = new int[]{8,3,6,2,2};int index = 0;@Scheduled(cron = "0/5 * * * * ?}")public void process() {try {if(index > delays.length - 1){if(index == delays.length){System.out.println("---------- test end at " + sdf.format(new Date()) + " ---------");}index ++;return;}else{System.out.println(index + ":start run at" + sdf.format(new Date()));}Thread.sleep(delays[index] * 1000);System.out.println(index + ":end run at " + sdf.format(new Date()));index ++;} catch (InterruptedException e) {e.printStackTrace();}}}。

spring定时任务（@Scheduled注解）

spring定时任务（@Scheduled注解）（⼀）在xml⾥加⼊task的命名空间1. xmlns:task="/schema/task"2. /schema/task /schema/task/spring-task-4.1.xsd（⼆）启⽤注解驱动的定时任务<task:annotation-driven scheduler="scheduler" executor="executor" proxy-target-class="true"/>（三）配置定时任务的线程池<task:executor id="executor" pool-size="10"/> <task:scheduler id="scheduler" pool-size="10"/>（四）写我们的定时任务Cron Expressionscron的表达式被⽤来配置CronTrigger实例。

cron的表达式是字符串，实际上是由七⼦表达式，描述个别细节的时间表。

这些⼦表达式是分开的空⽩，代表：1. 1. Seconds2. 2. Minutes3. 3. Hours4. 4. Day-of-Month5. 5. Month6. 6. Day-of-Week7. 7. Year (可选字段)例 "0 0 12 ? * WED" 在每星期三下午12:00 执⾏,个别⼦表达式可以包含范围, 例如，在前⾯的例⼦⾥("WED")可以替换成 "MON-FRI", "MON, WED, FRI"甚⾄"MON-WED,SAT".“*” 代表整个时间段.每⼀个字段都有⼀套可以指定有效值，如Seconds (秒) ：可以⽤数字0－59 表⽰，Minutes(分) ：可以⽤数字0－59 表⽰，Hours(时) ：可以⽤数字0-23表⽰,Day-of-Month(天) ：可以⽤数字1-31 中的任⼀⼀个值，但要注意⼀些特别的⽉份Month(⽉) ：可以⽤0-11 或⽤字符串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表⽰Day-of-Week(每周)：可以⽤数字1-7表⽰（1 ＝星期⽇）或⽤字符⼝串“SUN, MON, TUE, WED, THU, FRI and SAT”表⽰“/”：为特别单位，表⽰为“每”如“0/15”表⽰每隔15分钟执⾏⼀次,“0”表⽰为从“0”分开始, “3/20”表⽰表⽰每隔20分钟执⾏⼀次，“3”表⽰从第3分钟开始执⾏“?”：表⽰每⽉的某⼀天，或第周的某⼀天“L”：⽤于每⽉，或每周，表⽰为每⽉的最后⼀天，或每个⽉的最后星期⼏如“6L”表⽰“每⽉的最后⼀个星期五”“W”：表⽰为最近⼯作⽇，如“15W”放在每⽉（day-of-month）字段上表⽰为“到本⽉15⽇最近的⼯作⽇”““#”：是⽤来指定“的”每⽉第n个⼯作⽇,例在每周（day-of-week）这个字段中内容为"6#3" or "FRI#3" 则表⽰“每⽉第三个星期五”1）Cron表达式的格式：秒分时⽇⽉周年(可选)。

SpringBoot三种定时任务实现方式

SpringBoot三种定时任务实现方式在Spring Boot项目中，实现定时任务是常见需求。

Spring Boot提供了多种灵活的方式来实现定时任务，包括基于注解的方式、基于接口的方式以及使用外部任务调度工具等。

定时任务作为一种系统调度工具，在一些需要有定时作业的系统中应用广泛，如每逢某个时间点统计数据、在将来某个时刻执行某些动作...定时任务在主流开发语言均提供相应的API供开发者调用，在Java中，实现定时任务有很多种方式，原生的方式实现一个完整定时任务需要由Timer、TimerTask两个类，Timer 是定时器类，用来按计划开启后台线程执行指定任务，TimerTask一个抽象类，它的子类代表一个可以被Timer计划的任务。

除此之外，还可以用ScheduledExecutorService类或者使用第三方jar库Quartz，其中Quartz是一个优秀的定时任务框架，发展至今已经非常成熟，以致后来其他的定时任务框架的核心思想或底层大多源于Quartz。

springboot作为Java的一种开发框架，在springboot项目中实现定时任务不仅可以使用Java提供的原生方式，还可以使用springboot提供的定时任务API。

本文将详细介绍三种常用的Spring Boot定时任务实现方式，并提供相应的例子代码。

1. 基于注解的方式（@Scheduled）使用@Scheduled注解是实现Spring Boot定时任务最简单直接的方式。

首先，你需要在Spring Boot的启动类或者配置类上添加@EnableScheduling注解来启用定时任务支持。

然后，在需要定时执行的方法上添加@Scheduled注解，并指定cron表达式或固定间隔。

例子代码：在上面的代码中，@Scheduled注解分别使用了cron表达式和固定频率（fixedRate）两种方式来定义定时任务。

需要注意的是，@EnableScheduling 注解只需要在Spring Boot的启动类或配置类上添加一次。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

Spring定时任务的几种实现一．分类∙从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：1.Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。

使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。

一般用的较少，这篇文章将不做详细介绍。

2.使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。

3.Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

∙从作业类的继承方式来讲，可以分为两类：1.作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。

2.作业类即普通的java类，不需要继承自任何基类。

注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。

∙从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：1.每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean2.每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。

Quartz和spring task都可以支持这两种触发条件。

二．用法说明详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。

Quartz第一种，作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

第一步：定义作业类Java代码1.import org.quartz.JobExecutionContext;2.import org.quartz.JobExecutionException;3.import org.springframework.scheduling.quartz.QuartzJobBean;4.public class Job1 extends QuartzJobBean {5.6.private int timeout;7.private static int i = 0;8.//调度工厂实例化后，经过timeout时间开始执行调度9.public void setTimeout(int timeout) {10.this.timeout = timeout;11.}12.13./**14.* 要调度的具体任务15.*/16.@Override17.protected void executeInternal(JobExecutionContext context)18.throws JobExecutionException {19. System.out.println("定时任务执行中…");20.}21.}第二步：spring配置文件中配置作业类JobDetailBeanXml代码1.<bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean">2.<property name="jobClass" value="com.gy.Job1" />3.<property name="jobDataAsMap">4.<map>5.<entry key="timeout" value="0" />6.</map>7.</property>8.</bean>说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。

第三步：配置作业调度的触发方式（触发器）Quartz的作业触发器有两种，分别是org.springframework.scheduling.quartz.SimpleTriggerBeanorg.springframework.scheduling.quartz.CronTriggerBean第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：Xml代码1.<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">2.<property name="jobDetail" ref="job1" />3.<property name="startDelay" value="0" />4.<property name="repeatInterval" value="2000" />5.</bean>第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

配置方式如下：Xml代码1.<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">2.<property name="jobDetail" ref="job1" />3.<!—每天12:00运行一次 -->4.<property name="cronExpression" value="0 0 12 * * ?" />5.</bean>关于cronExpression表达式的语法参见附录。

第四步：配置调度工厂Xml代码1.<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">2.<property name="triggers">3.<list>4.<ref bean="cronTrigger" />5.</list>6.</property>7.</bean>说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

第二种，作业类不继承特定基类。

Spring能够支持这种方式，归功于两个类：org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBe anorg.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java 自带的timer task方式和Quartz方式。

这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。

第一步：编写任务类Java代码1.public class Job2 {2.public void doJob2() {3.System.out.println("不继承QuartzJobBean方式-调度进行中...");4.}5.}可以看出，这就是一个普通的类，并且有一个方法。

第二步：配置作业类Xml代码1.<bean id="job2"2.class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">3.<property name="targetObject">4.<bean class="com.gy.Job2" />5.</property>6.<property name="targetMethod" value="doJob2" />7.<property name="concurrent" value="false" />8.</bean>说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。

往下的步骤就与方法一相同了，为了完整，同样贴出。