Spring定时任务配置

合集下载

Spring注解配置定时任务task：annotation-driven

@Component @Lazy(value=false) public class MyQuartzs {
@Scheduled(cron = "*/5 * * * * ?")//每隔5秒执行一次 public void test() throws Exception {
System.out.println("Test is working......"); }
网络错误421Spring注解配置定时任务task：annotation-driven /article/details?id=50945311
首先在配置文件头部的必须要有： xmlns:task="/schema/task" 1 其次xsi:schemaLocation必须为其添加： /schema/task /schema/task/spring-task.xsd 1 2 然后spring扫描过程必须涵盖定时任务类所在的目录： <context:component-scan base-package="com.xx.xx" /> 1 com.xx.xx属于定时任务类的父级甚至更高级然后设置动作启用定时任务 <task:annotation-driven/> 1 最后设置任务类 import zy; import org.springframework.scheduling.annotation.Scheduled; import ponent;
//@Scheduled(cron = "0 0 1 * * ?")//每天凌晨1点整 //@Scheduled(cron = "0 30 0 * * ?")//每天凌晨0点30分 //@Scheduled(cron = "0 */60 * * * ?")//1小时处理一次 }

Spring配置定时器（注解+xml）方式—整理

Spring配置定时器（注解+xml）⽅式—整理⼀、注解⽅式1. 在Spring的配置⽂件ApplicationContext.xml，⾸先添加命名空间1 xmlns:task="/schema/task"2 /schema/task3 /schema /task/springtask3.1.xsd42. 最后是我们的task任务扫描注解1<task:annotation-driven/>3. spring扫描位置1<context:annotation-config/>2<context:component-scan base-package="com.test"/>4.写⾃⼰的定时任务1 @Component //import ponent;2public class MyTestServiceImpl implements IMyTestService {3 @Scheduled(cron="0/5 * * * * ? ") //每5秒执⾏⼀次4public void myTest(){5 System.out.println("进⼊测试");6 }7 }♦注意：定时器的任务⽅法不能有返回值（如果有返回值，spring初始化的时候会告诉你有个错误、需要设定⼀个proxytargetclass的某个值为true）⼆、XML⽅式1.在spring配置⽂件中创建bean，创建schedule1<bean id="schedule"class="org.springframework.scheduling.quartz.SchedulerFactoryBean">3<property name="triggers">4<list>5<ref bean="testTrigger"/>6</list>7</property>8</bean>2. 在spring配置⽂件中创建bean，创建你的triggers1<bean id="testTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean">3<property name="jobDetail" ref="testJobDetail"/>4<property name="cronExpression" value="0 1/5 * * * ?"/>5</bean>3. 在spring配置⽂件中创建bean，指定定时器作⽤在那个类那个⽅法上⾯1<bean id="testJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">3<property name="targetObject" ref="targetTestService"/>4<property name="targetMethod" value="timerTest"/>5</bean>♦注明：把定时器作⽤在targetTestService对象中的timerTest⽅法上⾯4. 当然还得把你作⽤的对象交Spring来管理，所以在spring配置⽂件中创建作⽤类的 bean1<bean id="targetTestService" class=".service.TargetTestService" scope="prototype"></bean>♦这是时间的设置规则org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运⾏时间，只需要设置其cronExpression属性。

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>这样的配置几本就可以运转了，但是有一个地方可能是你需要根据你的需求来确定的，那就是触发时间。

spring cron配置定时任务

定时任务配置说明第一步：Spring-context.xml中配置<beans xmlns="/schema/beans"......xmlns:task="/schema/task"xsi:schemaLocation="....../schema/task/schema/task/spring-task-3.0.xsd"><task:executor id="executor" pool-size="5" /><task:scheduler id="scheduler" pool-size="5" /><task:annotation-driven executor="executor" scheduler="scheduler" />第二步：类名上面加@Service@Lazy(false)如图：第三步：方法名前加@Scheduled(cron = "0/5 * * * * ?")时间设置：// */5 * * * * ? 每隔5秒执行一次// 0 */1 * * * ? 每隔1分钟执行一次// 0 0 5-15 * * ? 每天5-15点整点触发// 0 0/3 * * * ? 每三分钟触发一次// 0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发// 0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发// 0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发// 0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时// 0 0 10,14,16 * * ? 每天上午10点，下午2点，4点//// 0 0 12 ? * WED 表示每个星期三中午12点// 0 0 17 ? * TUES,THUR,SAT 每周二、四、六下午五点// 0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发// 0 15 10 ? * MON-FRI 周一至周五的上午10:15触发// 0 0 23 L * ? 每月最后一天23点执行一次// 0 15 10 L * ? 每月最后一日的上午10:15触发// 0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发// 0 15 10 * * ? 2005 2005年的每天上午10:15触发// 0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发// 0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发////// "30 * * * * ?" 每半分钟触发任务// "30 10 * * * ?" 每小时的10分30秒触发任务// "30 10 1 * * ?" 每天1点10分30秒触发任务// "30 10 1 20 * ?" 每月20号1点10分30秒触发任务// "30 10 1 20 10 ? *" 每年10月20号1点10分30秒触发任务// "30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务// "30 10 1 ? 10 * 2011" 2011年10月每天1点10分30秒触发任务// "30 10 1 ? 10 SUN 2011" 2011年10月每周日1点10分30秒触发任务// "15,30,45 * * * * ?" 每15秒，30秒，45秒时触发任务// "15-45 * * * * ?" 15到45秒内，每秒都触发任务// "15/5 * * * * ?" 每分钟的每15秒开始触发，每隔5秒触发一次// "15-30/5 * * * * ?" 每分钟的15秒到30秒之间开始触发，每隔5秒触发一次// "0 0/3 * * * ?" 每小时的第0分0秒开始，每三分钟触发一次// "0 15 10 ? * MON-FRI" 星期一到星期五的10点15分0秒触发任务// "0 15 10 L * ?" 每个月最后一天的10点15分0秒触发任务// "0 15 10 LW * ?" 每个月最后一个工作日的10点15分0秒触发任务// "0 15 10 ? * 5L" 每个月最后一个星期四的10点15分0秒触发任务// "0 15 10 ? * 5#3" 每个月第三周的星期四的10点15分0秒触发任务。

Spring中的线程池和定时任务功能

Spring中的线程池和定时任务功能1.功能介绍Spring框架提供了线程池和定时任务执⾏的抽象接⼝：TaskExecutor和TaskScheduler来⽀持异步执⾏任务和定时执⾏任务功能。

同时使⽤框架⾃⼰定义的抽象接⼝来屏蔽掉底层JDK版本间以及Java EE中的线程池和定时任务处理的差异。

另外Spring还⽀持集成JDK内部的定时器Timer和Quartz Scheduler框架。

2.线程池的抽象：TaskExecutorTaskExecutor涉及到的相关类图如下：TaskExecutor接⼝源代码如下所⽰：public interface TaskExecutor extends Executor {/*** Execute the given {@code task}.* The call might return immediately if the implementation uses* an asynchronous execution strategy, or might block in the case* of synchronous execution.* @param task the {@code Runnable} to execute (never {@code null})* @throws TaskRejectedException if the given task was not accepted*/@Overridevoid execute(Runnable task);}此接⼝和Executor⼏乎完全⼀样，只定义了⼀个接收Runnable参数的⽅法，据Spring官⽅介绍此接⼝最初是为了在其他组建中使⽤线程时，将JKD抽离出来⽽设计的。

在Spring的⼀些其他组件中⽐如ApplicationEventMulticaster，Quartz都是使⽤TaskExecutor来作为线程池的抽象的。

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表达式的格式：秒分时⽇⽉周年(可选)。

spring定时器的说明

<property name="jobClass" value="com.zb.job.PlanJob"/>

<property name="jobDataAsMap"&;entry key="planService" value-ref="planService"></entry>
<entry key="name" value="王二"></entry>
</map>
</property>
</bean>
7.注入触发器
第一种：间隔时间发生事情
<bean id="mytrig" class="org.springframework.scheduling.quartz.SimpleTriggerBean">

<property name="repeatInterval" value="3000"></property>
</bean>
第二种：每天的某个时间发生
<bean id="mytrig" class="org.springframework.scheduling.quartz.CronTriggerBean">

@Scheduled（cron=）spring定时任务时间设置

@Scheduled（cron=）spring定时任务时间设置⼀个cron表达式有⾄少6个（也可能7个）有空格分隔的时间元素。

按顺序依次为秒（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),通配符。

由于"⽉份中的⽇期"和"星期中的⽇期"这两个元素互斥的,必须要对其中⼀个设置?.0 0 10,14,16 * * ? 每天上午10点，下午2点，4点0 0/30 9-17 * * ? 朝九晚五⼯作时间内每半⼩时0 0 12 ? * WED 表⽰每个星期三中午12点"0 0 12 * * ?" 每天中午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期间的每1分钟触发"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发"0 10,44 14 ? 3 WED" 每年三⽉的星期三的下午2:10和2:44触发"0 15 10 ? * MON-FRI" 周⼀⾄周五的上午10:15触发"0 15 10 15 * ?" 每⽉15⽇上午10:15触发"0 15 10 L * ?" 每⽉最后⼀⽇的上午10:15触发"0 15 10 ? * 6L" 每⽉的最后⼀个星期五上午10:15触发"0 15 10 ? * 6L 2002-2005" 2002年⾄2005年的每⽉的最后⼀个星期五上午10:15触发"0 15 10 ? * 6#3" 每⽉的第三个星期五上午10:15触发有些⼦表达式能包含⼀些范围或列表例如：⼦表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”“*”字符代表所有可能的值因此，“*”在⼦表达式（⽉）⾥表⽰每个⽉的含义，“*”在⼦表达式（天（星期））表⽰星期的每⼀天“/”字符⽤来指定数值的增量例如：在⼦表达式（分钟）⾥的“0/15”表⽰从第0分钟开始，每15分钟在⼦表达式（分钟）⾥的“3/20”表⽰从第3分钟开始，每20分钟（它和“3，23，43”）的含义⼀样“？”字符仅被⽤于天（⽉）和天（星期）两个⼦表达式，表⽰不指定值当2个⼦表达式其中之⼀被指定了值以后，为了避免冲突，需要将另⼀个⼦表达式的值设为“？”“L” 字符仅被⽤于天（⽉）和天（星期）两个⼦表达式，它是单词“last”的缩写但是它在两个⼦表达式⾥的含义是不同的。

SpringBoot配置ShedLock分布式定时任务

SpringBoot配置ShedLock分布式定时任务什么是ShedLockShedLock是⼀个在分布式环境中使⽤的定时任务框架，⽤于解决在分布式环境中的多个实例的相同定时任务在同⼀时间点重复执⾏的问题，解决思路是通过对公⽤的数据库中的某个表进⾏记录和加锁，使得同⼀时间点只有第⼀个执⾏定时任务并成功在数据库表中写⼊相应记录的节点能够成功执⾏⽽其他节点直接跳过该任务。

当然不只是数据库，⽬前已经实现的⽀持数据存储类型除了经典的关系型数据库，还包括MongoDB，Zookeeper，Redis，Hazelcast。

如何使⽤ShedLock采⽤⾮侵⼊式编程的思想，通过注解的⽅式来实现相应的功能。

要使⽤ShedLock，请执⾏以下操作启⽤并配置计划锁定注释您的计划任务配置锁提供程序1.启⽤并配置计划锁定⾸先，引⼊依赖< dependency >< groupId > net.javacrumbs.shedlock </ groupId >< artifactId > shedlock-spring </ artifactId >< version > 2.5.0 </ version ></ dependency >现在我们需要将库集成到Spring中。

为了启⽤计划锁定，请使⽤@EnableSchedulerLock注释@Configuration@EnableScheduling@EnableSchedulerLock（defaultLockAtMostFor = “ PT30S ”）类 MySpringConfiguration {...}注释您的计划任务import net.javacrumbs.shedlock.core.SchedulerLock ;...@Scheduled（...）@SchedulerLock（name = “ scheduledTaskName ”）public void scheduledTask（）{//做某事}@SchedulerLock注解⼀共⽀持五个参数，分别是name ⽤来标注⼀个定时服务的名字，被⽤于写⼊数据库作为区分不同服务的标识，如果有多个同名定时任务则同⼀时间点只有⼀个执⾏成功lockAtMostFor 成功执⾏任务的节点所能拥有独占锁的最长时间，单位是毫秒mslockAtMostForString 成功执⾏任务的节点所能拥有的独占锁的最长时间的字符串表达，例如“PT14M”表⽰为14分钟lockAtLeastFor 成功执⾏任务的节点所能拥有独占所的最短时间，单位是毫秒mslockAtLeastForString 成功执⾏任务的节点所能拥有的独占锁的最短时间的字符串表达，例如“PT14M”表⽰为14分钟与Spring进⾏整合,ShedLock⽀持两种Spring集成模式。

spring-boot通过@Scheduled配置定时任务及定时任务@Scheduled注解的方法

spring-boot通过@Scheduled配置定时任务及定时任务@Scheduled注解的⽅法串⾏的定时任务@Componentpublic class ScheduledTimer {private Logger logger = Logger.getLogger(this.getClass());/*** 定时任务，1分钟执⾏1次，更新潜在客户超时客户共享状态*/@Scheduled(cron="0 0/1 8-20 * * ?")public void executeUpdateCuTask() {Thread current = Thread.currentThread();(" 定时任务1:"+current.getId()+ ",name:"+current.getName());}@Scheduled(cron="0 0/1 8-20 * * ?")public void executeGetRepayTask() {Thread current = Thread.currentThread();(" 定时任务2:"+current.getId()+ ",name:"+current.getName());}}并⾏的定时任务需要添加配置⽂件因为spring-boot的⽬的就是⼲掉配置⽂件，我在⽹上看到的很多都是通过配置⽂件来实现的，这⾥通过代码配置实现：@Configurationpublic class ScheduleConfig implements SchedulingConfigurer{@Overridepublic void configureTasks(ScheduledTaskRegistrar taskRegistrar){TaskScheduler taskScheduler = taskScheduler();taskRegistrar.setTaskScheduler(taskScheduler);}@Bean(destroyMethod = "shutdown")public ThreadPoolTaskScheduler taskScheduler() {ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();scheduler.setPoolSize(20);scheduler.setThreadNamePrefix("task-");scheduler.setAwaitTerminationSeconds(60);scheduler.setWaitForTasksToCompleteOnShutdown(true);return scheduler;}}⽹上教程说的需要在启动类上加上@EnableScheduling注解来发现注解@Scheduled的任务并后台执⾏。

Spring内置定时任务调度@Scheduled使用详解

Spring内置定时任务调度@Scheduled使⽤详解Spring提供了@Scheduled注解⽤于定时任务。

⼀、@Scheduled的基本使⽤启⽤调度⽀持：@EnableScheduling可以将@Scheduled注释与触发器元数据⼀起添加到⽅法中。

例如，以下⽅法每隔5秒调⽤⼀次，并具有固定的延迟，这意味着周期是从前⾯每次调⽤的完成时间开始计算的@Scheduled(fixedDelay=5000)public void doSomething() {// something that should execute periodically}如果需要固定速率执⾏，可以更改批注中指定的属性名。

以下⽅法每5秒调⽤⼀次（在每次调⽤的连续开始时间之间计算）@Scheduled(fixedRate=5000)public void doSomething() {// something that should execute periodically}对于固定延迟和固定速率任务，可以通过指⽰在⾸次执⾏⽅法之前要等待的毫秒数来指定初始延迟@Scheduled(initialDelay=1000, fixedRate=5000)public void doSomething() {// something that should execute periodically}如果简单的周期性调度不够表达，可以提供cron表达式。

例如，以下命令仅在⼯作⽇执⾏：@Scheduled(cron="*/5 * * * * MON-FRI")public void doSomething() {// something that should execute on weekdays only}实现SchedulingConfigurer接⼝，重写configureTasks⽅法：@Schedule注解的⼀个缺点就是其定时时间不能动态更改，它适⽤于具有固定任务周期的任务，若要修改任务执⾏周期，只能⾛“停服务→修改任务执⾏周期→重启服务”这条路。

SpringBoot中配置定时任务、线程池与多线程池执行的方法

SpringBoot中配置定时任务、线程池与多线程池执⾏的⽅法配置基础的定时任务最基本的配置⽅法，⽽且这样配置定时任务是单线程串⾏执⾏的，也就是说每次只能有⼀个定时任务可以执⾏，可以试着声明两个⽅法，在⽅法内写⼀个死循环，会发现⼀直卡在⼀个任务上不动，另⼀个也没有执⾏。

1、启动类添加@EnableScheduling开启对定时任务的⽀持@EnableScheduling@SpringBootApplicationpublic class TestScheduledApplication extends SpringBootServletInitializer {@Overrideprotected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {return builder.sources(this.getClass());}public static void main(String[] args) {new SpringApplicationBuilder(TestScheduledApplication.class).web(true).run(args);}}2、配置执⾏定时任务的类添加@Component扫描本类，在⽅法上添加@Scheduled注解声明定时任务，配置时间周期@Componentpublic class TestTask1 {private static final Logger logger = LogManager.getLogger();// 间隔1秒执⾏⼀次@Scheduled(cron = "0/1 * * * * ?")public void method1() {("——————————method1 start——————————");("——————————method1 end——————————");}}配置线程池执⾏定时任务因为有时候需要执⾏的定时任务会很多，如果是串⾏执⾏会带来⼀些问题，⽐如⼀个很耗时的任务阻塞住了，⼀些需要短周期循环执⾏的任务也会卡住，所以可以配置⼀个线程池来并⾏执⾏定时任务1、配置线程池添加@EnableAsync开启对异步的⽀持@Configuration@EnableAsyncpublic class ExecutorConfig {@Beanpublic Executor executor1() {ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();executor.setThreadNamePrefix("test-schedule2-");executor.setMaxPoolSize(20);executor.setCorePoolSize(15);executor.setQueueCapacity(0);executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());return executor;}}2、配置定时任务异步执⾏添加@Async注解，表⽰该定时任务是异步执⾏的，因为上⾯线程池配置了名字，所以可以看到打印的⽇志是该线程池中的线程在执⾏任务，如果没有配置线程池的话会默认使⽤SimpleAsyncTaskExecutor，这个异步执⾏器每次都会开启⼀个⼦线程执⾏，性能消耗⽐较⼤，所以最好是⾃⼰配置线程池@Async@Scheduled(cron = "0/1 * * * * ?")public void method1() {("——————————method1 start——————————");("——————————method1 end——————————");}配置多个线程池分别执⾏不同的定时任务因为有些定时任务是⽐较重要的，有些则是不太重要的，想把定时任务分别放到不同的线程池中，也是可以实现的。

SpringBoot动态配置定时任务cron（动态改变执行周期）

SpringBoot动态配置定时任务cron（动态改变执⾏周期）package model;public class SpringScheduledCron {private String cronId;private String cronKey;private String cronExpression;private String taskExplain;private String status;@Overridepublic String toString() {return"SpringScheduledCron{" + "cronId=" + cronId + ", cronKey='" + cronKey + '\'' + ", cronExpression='"+ cronExpression + '\'' + ", taskExplain='" + taskExplain + '\'' + ", status=" + status + '}';}public String getCronId() {return cronId;}public void setCronId(String cronId) {this.cronId = cronId;}public String getCronKey() {return cronKey;}public void setCronKey(String cronKey) {this.cronKey = cronKey;}public String getCronExpression() {return cronExpression;}public void setCronExpression(String cronExpression) {this.cronExpression = cronExpression;}public String getTaskExplain() {return taskExplain;}public void setTaskExplain(String taskExplain) {this.taskExplain = taskExplain;}public String getStatus() {return status;}public void setStatus(String status) {this.status = status;}public SpringScheduledCron() {// TODO Auto-generated constructor stub}public SpringScheduledCron(String cronId, String cronKey, String cronExpression, String taskExplain,String status) {this.cronId = cronId;this.cronKey = cronKey;this.cronExpression = cronExpression;this.taskExplain = taskExplain;this.status = status;}}import java.io.BufferedReader;import java.io.File;import java.io.FileReader;import java.util.ArrayList;import java.util.List;import ponent;@Componentpublic class SpringScheduledCronRepository {static int i = 0;static {System.out.println("in=="+(i++));}public SpringScheduledCron findByCronKey(String cronKey) {SpringScheduledCron cron = null;List<SpringScheduledCron> list = findAll();for (SpringScheduledCron springScheduledCron : list) {if(springScheduledCron.getCronKey().equals(cronKey)) {cron = springScheduledCron;}}return cron;};public List<SpringScheduledCron> findAll(){List<SpringScheduledCron> list = new ArrayList<SpringScheduledCron>();try {File cronFile = new File("./config/cron.txt");FileReader in = new FileReader(cronFile);BufferedReader bufIn = new BufferedReader(in);// 替换String line = null;while ((line = bufIn.readLine()) != null) {String[] ls = line.split("\\|");if(ls.length == 5) {SpringScheduledCron cron = new SpringScheduledCron(ls[0],ls[1],ls[2],ls[3],ls[4]);list.add(cron);}}// 关闭输⼊流bufIn.close();} catch (Throwable e) {System.out.println(e.getMessage());}return list;};}import org.springframework.beans.BeansException;import org.springframework.context.ApplicationContext;import org.springframework.context.ApplicationContextAware;import ponent;@Componentpublic class SpringUtils implements ApplicationContextAware {private static ApplicationContext context;@Overridepublic void setApplicationContext(ApplicationContext applicationContext) throws BeansException { SpringUtils.context = applicationContext;}public static <T> T getBean(Class<T> clz) {return context.getBean(clz);}public static Object getBean(String name) {return context.getBean(name);}public ApplicationContext getApplicationContext() {return context;}}import org.springframework.beans.BeansException;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationContext;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.SchedulingConfigurer;import org.springframework.scheduling.config.ScheduledTaskRegistrar;import org.springframework.scheduling.support.CronTrigger;import org.springframework.util.Assert;import java.util.concurrent.Executor;import java.util.concurrent.Executors;@Configurationpublic class ScheduledConfig implements SchedulingConfigurer {@Autowiredprivate ApplicationContext context;@Autowiredprivate SpringScheduledCronRepository cronRepository;@Overridepublic void configureTasks(ScheduledTaskRegistrar taskRegistrar) {for (SpringScheduledCron springScheduledCron : cronRepository.findAll()) {Class<?> clazz;Object task;try {clazz = Class.forName(springScheduledCron.getCronKey());task = context.getBean(clazz);} catch (ClassNotFoundException e) {throw new IllegalArgumentException("" + springScheduledCron.getCronKey() + "有误", e);} catch (BeansException e) {throw new IllegalArgumentException(springScheduledCron.getCronKey() + "未纳⼊到spring管理", e);}Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接⼝");// 可以通过改变数据进⽽实现动态改变执⾏周期taskRegistrar.addTriggerTask(((Runnable) task),triggerContext -> {String cronExpression = cronRepository.findByCronKey(springScheduledCron.getCronKey()).getCronExpression(); return new CronTrigger(cronExpression).nextExecutionTime(triggerContext);});}}@Beanpublic Executor taskExecutor() {return Executors.newScheduledThreadPool(10);}}public interface ScheduledOfTask extends Runnable {/*** 定时任务⽅法*/void execute();/*** 实现控制定时任务启⽤或禁⽤的功能*/@Overridedefault void run() {SpringScheduledCronRepository repository = SpringUtils.getBean(SpringScheduledCronRepository.class);SpringScheduledCron scheduledCron = repository.findByCronKey(this.getClass().getName());if ("".equals(scheduledCron.getStatus())) {return;}execute();}}@Componentpublic class DynamicPrintTask implements ScheduledOfTask {private Logger logger = LoggerFactory.getLogger(getClass());private int i;@Overridepublic void execute() {("thread id:{},DynamicPrintTask execute times:{}", Thread.currentThread().getId(), ++i); }}1|com.schedule.DynamicPrintTask|*/10 * * * * ?|5s执⾏⼀次|1。

spring自带的定时任务功能@EnableScheduling

spring⾃带的定时任务功能@EnableScheduling1 demopackage com.test.domi.config;import org.springframework.beans.factory.annotation.Configurable;import org.springframework.scheduling.annotation.EnableScheduling;import org.springframework.scheduling.annotation.Scheduled;import ponent;import java.text.SimpleDateFormat;import java.util.Date;@Component@Configurable@EnableSchedulingpublic class ScheduledTasks {//每30秒执⾏⼀次@Scheduled(fixedRate = 1000 * 30)public void reportCurrentTime(){System.out.println ("Scheduling Tasks Examples: The time is now " + dateFormat ().format (new Date ()));}//在固定时间执⾏@Scheduled(cron = "0 */1 * * * * ")public void reportCurrentByCron(){System.out.println ("Scheduling Tasks Examples By Cron: The time is now " + dateFormat ().format (new Date()));}private SimpleDateFormat dateFormat(){return new SimpleDateFormat ("HH:mm:ss");}}Scheduling Tasks Examples: The time is now 11:55:54Scheduling Tasks Examples By Cron: The time is now 11:56:00Scheduling Tasks Examples: The time is now 11:56:24Scheduling Tasks Examples: The time is now 11:56:54Scheduling Tasks Examples By Cron: The time is now 11:57:002 详解1.cron是设置定时执⾏的表达式,如 0 0/5 * * * ?每隔五分钟执⾏⼀次2.zone表⽰执⾏时间的时区3.fixedDelay 和fixedDelayString ⼀个固定延迟时间执⾏,上个任务完成后,延迟多久执⾏4.fixedRate 和fixedRateString⼀个固定频率执⾏,上个任务开始后多长时间后开始执⾏5.initialDelay 和initialDelayString表⽰⼀个初始延迟时间,第⼀次被调⽤前延迟的时间3 总结常见问题a: 单线程任务丢失，转为异步线程池默认的 ConcurrentTaskScheduler 计划执⾏器采⽤Executors.newSingleThreadScheduledExecutor() 实现单线程的执⾏器。

spring定时任务.线程池,自定义多线程配置

spring定时任务.线程池,⾃定义多线程配置定时任务及多线程配置xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/mvc/schema/mvc/spring-mvc-4.0.xsd"><bean id="ruleBean"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject" ref<property name="targetMethod" value</bean><bean id="rule" class<property name="jobDetail" ref<property name="cronExpression" value<sp </bean><bean id="startQuertz" lazy-init="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="jobDetails"><list><ref bean="ruleBean" /></list></property><property name="triggers"><list><ref bean="rule" /></list></property><property name="startupDelay" value</bean><bean id="threadPoolTaskExecutor"class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"><property name="corePoolSize" value<property name="maxPoolSize" value<property name="keepAliveSeconds" value<s <property name="rejectedExecutionHandler"></spa <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" </property></bean><bean id="contextUtil" class定时任务JAVA类RuleService.java@Servicepublic class RuleService {public void updateRule(){System.out.println("定时任务启动");}}多线程配置StartTaskThread.javapublic class StartTaskThread implements Runnable {private List<String> list;public StartTaskThread(List<String> list) {this.list= list;}@Overridepublic synchronized void run() {System.out.println(list.size());}}修改定时任务类，分配数据，并发布到各个线程⾥。

Springboot自带定时任务实现动态配置Cron参数方式

Springboot⾃带定时任务实现动态配置Cron参数⽅式⽬录Springboot⾃带定时任务实现动态配置Cron参数SpringBoot定时任务的四种实现⽅式(主要)spring动态配置cron表达式，不需要停服SchedulingConfigurer接⼝实现动态加载cron表达式Springboot⾃带定时任务实现动态配置Cron参数同学们，我今天分享⼀下SpringBoot动态配置Cron参数。

场景是这样⼦的：后台管理界⾯对定时任务进⾏管理，可动态修改执⾏时间，然后保存⼊库，每次任务执⾏前从库⾥查询时间，以达到动态修改Cron参数的效果。

好，咱们⼀起来看看是怎么回事。

SpringBoot定时任务的四种实现⽅式(主要)Timer：这是java⾃带的java.util.Timer类，这个类允许你调度⼀个java.util.TimerTask任务。

使⽤这种⽅式可以让你的程序按照某⼀个频度执⾏，但不能在指定时间运⾏。

⼀般⽤的较少。

ScheduledExecutorService：也jdk⾃带的⼀个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的⼀个线程去执⾏,也就是说,任务是并发执⾏,互不影响。

Spring Task：Spring3.0以后⾃带的task，可以将它看成⼀个轻量级的Quartz，⽽且使⽤起来⽐Quartz简单许多。

Quartz：这是⼀个功能⽐较强⼤的的调度器，可以让你的程序在指定时间执⾏，也可以按照某⼀个频度执⾏，配置起来稍显复杂。

1.1使⽤Timer这是让你按照固定的频率去执⾏⼀个任务，不能指定时间。

public class TestTimer {public static void main(String[] args) {TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.println("task run:"+ new Date());}};Timer timer = new Timer();//安排指定的任务在指定的时间开始进⾏重复的固定延迟执⾏。

spring自带的定时任务功能基于注解和xml配置

1、spring的配置文件[html] view plain copy <beans xmlns="/schema/beans" xmlns:xsi="/2001/XMLSchema-instance" xmlns:p="/schema/p" xmlns:task="/schema/task" xmlns:context="/schema/conte xt"xmlns:aop="/schema/aop" xsi:schemaLocation="/schema/ beans/schema/beans/spring-beans-3.0.xsd /schema/tx /schema/tx/spring-tx-3.0.xsd /schema/jee/schema/jee/spring-jee-3.0.xsd /schema/context/schema/context/spring-context -3.0.xsd /schema/aop /schema/aop/spring-aop-3.0.xsd /schema/task /schema/task/spring-task-3.0.xs d"> <task:annotation-driven />  <bean id="myTaskXml"class="com.spring.task.MyTaskXml"></bean><task:scheduled-tasks> <task:scheduled ref="myTaskXml" method="show"cron="*/5 * * * * ?" /> <task:scheduledref="myTaskXml" method="print" cron="*/10 * * * * ?"/> </task:scheduled-tasks>  <context:component-scanbase-package="com.spring.task" /> </beans>2、基于xml的定时器任务[java] view plain copy package com.spring.task; /** * 基于xml的定时器* @author hj */ public class MyTaskXml { public void show(){ System.out.println("XMl:is show run"); } public voidprint(){ System.out.println("XMl:printrun"); } } 3、基于注解的定时器任务[java] view plain copy package com.spring.task; importorg.springframework.scheduling.annotation.Scheduled; importponent; /** * 基于注解的定时器* @author hj */ @Component public class MyTaskAnnotation { /** * 定时计算。

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

Spring框架中的定时器如何使用和配置1.包∙spring-2.0.6.jar Spring框架的核心包∙jta.jar 会用到包中的usertransaction,具体什么用此处暂时不论∙quartz-1.6.0.jar 会用到CronTrigger这个类，通过表达式实现精确的定时∙commons-logging-1.1.1.jar 日志管理包∙commons-collections-3.2.1.jar 集合工具包2.首先是配置你要定时加载的目标类第一种方法：xml方式，例如：<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd"> <bean id="smsSendService" class="com.timer.smsSendService"/><beans>第二种方法：基于注解的方式。

例如：@Service(smsSendService) 注：此注解用于Service层3.配置你的定时器详情<bean id="smsSendServiceJob"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailF actoryBean"p:targetObject-ref="smsSendService"p:targetMethod="autoSmsTime" p:concurrent="false"/>解释：p:targetObject-ref：指向你要定时加载的目标类。

p:targetMethod：指向定时加载目标类中需要执行的方法。

即定时执行smsSendService类的autoSmsTime()方法。

p:concurrent="false"：表示不并发操作。

对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，第二个job 就开始了。

指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。

注意：smsSendService类的autoSmsTime()方法没有参数，如果smsSendService有两个方法autoSmsTime()和autoSmsTime(String argument)，则spring只会去执行无参的autoSmsTime().例如：123public void autoSmsTime(){System.out.println("无参......");}4.配置定时器时间间隔<bean id="smsSendServiceTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean"p:jobDetail-ref="smsSendServiceJob"p:cronExpression="*/10 * * * * ?"/>解释：p:cronExpression：指定定时器什么时候触发。

上面是每10秒触发一次。

详细参考下面附表。

5.配置启动定时器<bean id="schedulerFactoryBean"class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="applicationContextSchedulerContextKey"value="applicationContext"/><property name="triggers"><list><ref bean="smsSendServiceTrigger"/></list></property></bean>解释：triggers：通过再添加其他的ref元素可在list中放置多个触发器。

6.在web中配置配置文件地址和类加载监听器<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener>解释：ContextLoader可以由ContextLoaderListener和ContextLoaderServlet生成。

如果查看ContextLoaderServlet的API，可以看到它也关联了ContextLoader这个类而且它实现了HttpServlet这个接口。

ContextLoader创建的是XmlWebApplicationContext这样一个类，它实现的接口是WebApplicationContext->ConfigurableWebApplicationContext->ApplicationContext->BeanFactory 这样一来spring中的所有bean都由这个类来创建讲如何部署applicationContext的xml文件。

如果在web.xml中不写任何参数配置信息，默认的路径是/WEB-INF/applicationContext.xml，在WEB-INF目录下创建的xml文件的名称必须是applicationContext.xml；如果是要自定义文件名可以在web.xml里加入contextConfigLocation这个context参数：<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/classes/applicationContext-*.xml</param-value></context-param>在<param-value> </param-value>里指定相应的xml文件名，如果有多个xml文件，可以写在一起并一“,”号分隔。

上面的applicationContext-*.xml采用通配符，比如这那个目录下有applicationContext-ibatis- base.xml，applicationContext-action.xml，applicationContext-ibatis-dao.xml 等文件，都会一同被载入。

由此可见applicationContext.xml的文件位置就可以有两种默认实现：第一种：直接将之放到/WEB-INF下，之在web.xml中声明一个listener；第二种：将之放到classpath下，但是此时要在web.xml中加入<context-param>，用它来指明你的applicationContext.xml的位置以供web容器来加载。

按照Struts2 整合spring的官方给出的档案，写成：<context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/applicationContext-*.xml,classpath*:application Context-*.xml</param-value></context-param>附表："0 0 12 * * ?" 每天中午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期间的每1分钟触发"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发"0 15 10 15 * ?" 每月15日上午10:15触发"0 15 10 L * ?" 每月最后一日的上午10:15触发"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发每隔5秒执行一次：*/5 * * * * ?每隔1分钟执行一次：0 */1 * * * ?每天23点执行一次：0 0 23 * * ?每天凌晨1点执行一次：0 0 1 * * ?每月1号凌晨1点执行一次：0 0 1 1 * ?每月最后一天23点执行一次：0 0 23 L * ?每周星期天凌晨1点实行一次：0 0 1 ? * L标签: spring。