Spring定时器的入门
spring定时任务配置
定时任务解决方案两种方案,基本上都是一样,就是配置时间规则的时候,不一致。
两种方案:CronTrigger基于日历和时间,SimpleTrigger基于时间。
方案一是CronTrigger 配置,方案二是SimpleTrigger配置。
Quartz 是个开源的作业调度框架,为在 Java 应用程序中进行作业调度提供了简单却强大的机制。
Quartz 允许开发人员根据时间间隔(或天)来调度作业。
它实现了作业和触发器的多对多关系,还能把多个作业与不同的触发器关联。
整合了 Quartz 的应用程序可以重用来自不同事件的作业,还可以为一个事件组合多个作业。
SimpleTrigger当需要在规定的时间执行一次或在规定的时间段以一定的时间间隔重复触发执行Job时,SimpleTrigger就可以满足要求;SimpleTrigger的属性有:开始时间、结束时间、重复次数和重复的时间间隔,重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY,重复的时间间隔属性值必须为0或长整型的正整数,以毫秒作为时间单位,当重复的时间间隔为0时,意味着与Trigger 同时触发执行(或几乎与Scheduler开始时同时触发执行)。
如果有指定结束时间属性值,则结束时间属性优先于重复次数属性,这样的好处在于:当我们需要创建一个每间隔10秒钟触发一次直到指定的结束时间的 Trigger,而无需去计算从开始到结束的所重复的次数,我们只需简单的指定结束时间和使用REPEAT_INDEFINITELY作为重复次数的属性值即可(我们也可以指定一个比在指定结束时间到达时实际执行次数大的重复次数)。
方案一先写一个业务类,然后进行如下配置,一步都不能少,这样就能完成一个定时任务。
第一步写一个业务类这个业务很简单,不需要实现任务spring的接口。
就是一个普通业务类,然后写一个业务方法。
到时候配置定时任务,就会定时的执行这个业务方法。
定时器使用方法
定时器使用方法定时器是一种非常常见的功能,我们可以通过定时器来实现一些定时执行的任务,比如定时发送邮件、定时清理数据等。
在编程中,定时器也是一个非常重要的组件,它可以帮助我们实现一些定时执行的逻辑。
接下来,我将介绍一些定时器的使用方法,希望对大家有所帮助。
首先,我们需要了解定时器的基本原理。
定时器其实就是一个计时器,它可以在设定的时间间隔内执行特定的任务。
在编程中,我们可以通过调用系统提供的定时器接口来创建和启动定时器。
一般来说,定时器的使用可以分为以下几个步骤:1. 创建定时器,首先,我们需要创建一个定时器对象。
在大多数编程语言中,都提供了相应的定时器类或接口,我们可以通过实例化这些类或调用接口来创建定时器对象。
2. 设置定时器的时间间隔,接下来,我们需要设置定时器的时间间隔,即定时器多久执行一次任务。
一般来说,时间间隔可以以毫秒为单位进行设置,比如1000毫秒表示1秒钟。
3. 编写定时器任务,然后,我们需要编写定时器要执行的任务。
这个任务可以是一个函数或一个代码块,定时器会在设定的时间间隔内执行这个任务。
4. 启动定时器,最后,我们需要启动定时器,让它开始按照设定的时间间隔执行任务。
一旦定时器启动,它就会按照设定的时间间隔一直执行任务,直到我们手动停止它。
在实际的编程中,定时器的使用方法可能会有所不同,但基本原理是相似的。
下面,我将以Python语言为例,介绍一下如何使用定时器:```python。
import threading。
def task():print("定时器任务执行")。
# 创建定时器,设置时间间隔为3秒,指定定时器任务为task函数。
timer = threading.Timer(3, task)。
# 启动定时器。
timer.start()。
```。
在这个例子中,我们首先导入了Python的threading模块,然后定义了一个名为task的函数作为定时器的任务。
Quartzspring定时任务开发初步
Quartz spring 定时任务开发初步主要参考:、SchedulerFactoryBean会自动启动。
当在spring文件中定义了多个SchedulerFactoryBean实例时,一定要小心,因为这些ScheduleFactoryBean自从load进程序里,就会自动启动。
如果要手动控制,注意要将autoStartup属性设置为false。
2、SchedulerFactoryBean暴露的是Scheduler,而不是SchedulerFactoryBean。
SchedulerFactoryBean实现了FactoryBean接口,必须实现两个方法,一个是getObjectType,另外一个则是getObject;其中getObjectType定义了返回的类型应该为Scheduler,而getObject指定了返回的是其一个重要属性scheduler,这个scheduler就是我们要获得的调度。
若在配置文件里为SchedulerFactoryBean定义了id属性为"scheduler",则在程序里调用getBean时,需要注意getBean("scheduler")返回的是Scheduler对象3、SchedulerFactoryBean中有两个很重要的属性,一个是scheduler,另外一个是schedulerFactoryClass,spring通过用schedulerFactoryClass做代理来产生调度,并把它赋给scheduler。
private Class schedulerFactoryClass=StdSchedulerFactory.class;//如果你没有指定schedulerFactoryClass,那么它用的是quartz中自带的调度工厂,this.scheduler=createScheduler(schedulerFactory,this.schedulerNam e);//这里的schedulerName默认传进来是空的,其实如果你不是用自己定义的schedulerFactoryClass//恐怕也没有什么意义,因为createScheduler是这样调用的return schedulerFactory.getScheduler();//显然schedulerName并没有用到,除非是你自行写一个schedulerFactory,并做好相应处理,//否则返回的这个scheduler一定是一个指定名称的调度Scheduler sched=schedRep.lookup(getSchedulerName());//这个sched就是要代理生成的scheduler,getSchedulerName只有一句话,如下:cfg.getStringProperty(PROP_SCHED_INSTANCE_NAME,"QuartzScheduler");//如果我们没有使用一些特殊的机制,那么返回的只能是一个固定的字符串。
SpringTask定时任务配置与使用
SpringTask定时任务配置与使⽤
1、cron表达式格式
{秒} {分} {时} {⽇} {⽉} {周} {年(可选)}
2、cron各位置取值符
"*" 代表每隔1分/秒/时触发;
"," 代表在指定的分/秒/时触发,⽐如"10,20,40"代表10分/秒/时、20分/秒/时和40分/秒/时时触发任务
"-" 代表在指定的范围内触发,⽐如"5-30"代表从5分/秒/时开始触发到30分/秒/时结束触发,每隔1分/秒/时触发
"/" 代表触发步进(step),"/"前⾯的值代表初始值("*"等同"0"),后⾯的值代表偏移量,⽐如"0/25"或者"*/25"代表从0分/秒/时开始,每隔25分/秒/时触发1次,即0分/秒/时触发1次,第25分/秒/时触发1次,第50分/秒/时触发1次;"5/25"代表5分/秒/时触发1参考博客:
(1)
(2)。
springquartz实现定时任务的配置方法
Spring+Quartz实现定时任务的配置方法第一步:.导入相关的jar包(1)spring.jar(2)quartz-1.6.0.jar(3)相关包commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar第二步:创建一个类来定义工作定义Quartz工作的第一步是创建一个类来定义工作。
要做到这一点,你需要从Spring 的QuartzJobBean中派生子类。
第三步:配置JobDetail值得注意的是,在这里你并没有直接声明一个TopTenTask Bean,而是声明了一个JobDetailBean。
这是使用Quartz时的一个特点。
JobDetailBean是Quartz的org.quartz.JobDetail的子类,它要求通过jobClass属性来设置一个Job对象。
使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。
JobDetail的jobDataAsMap属性接受一个java.util.Map,其中包含了需要设置给jobClass的各种属性。
在这里,这个map包含了一个键值为timeout。
当JobDetailBean实例化时,它会将5注入到EmailReportJob的timeout属性中。
第四步:配置Trigger工作已经被定义好了,接下来你需要调度这个工作。
Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。
Spring提供了两个触发器,SimpleTriggerBean和CronTriggerBean。
SimpleTriggerBean与ScheduledTimerTask类似。
你可以用它来指定一个工作应该以怎样的频度运行,以及(可选地)在第一次运行工作之前应该等待多久。
例如,要调度报表工作每24小时运行一次,第一次在1小时之后开始运行,可以按照以下方式进行声明:<bean id="topTenTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail"><ref bean="topTenTask"/></property><property name="startDelay"><value>3600000</value></property><property name="repeatInterval"><value>86400000</value></property></bean>属性jobDetail装配了将要被调度的工作,在这个例子中是topTenTask Bean。
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"/>(四)写我们的定时任务<!-- 计划任务配置,⽤ @Service @Lazy(false)标注类,⽤@Scheduled(cron = "0 0 2 * * ?")标注⽅法 -->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">
spring quartz定时器的简单配置和使用
</bean>
<!-- 第三步: 定义好调用模式: 如每隔2秒钟调用一次或每天的哪个时间调用一次等 -->
<bean id="printTimerTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
<property name="applicationContextSchedulerContextKey" value="applicationContext"/>
<property name="triggers">
<list>
<property name="jobDetail" ref="printTimerJob" />
<property name="cronExpression" value="0/2 * * * * ?" />
</bean>
<!-- 启动定时器 -->
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
<!-- 加载spring的配置文件(一个或者多个) -->
<context-param>
<param-name>contextConfigLocation</param-name>
Spring中配置定时器详解
现在想要获得在特定时间或者指定时间执行相应功能有两种做法在applicationContext.xml中写入如下Bean<bean id="repeatingTrigger"class="org.springframework.scheduling.timer.ScheduledTimerTask"> <!--启动一秒后执行 --><property name="delay"><value>1000</value></property><!--每隔一小时执行一次 --><property name="period"><value>3600000</value></property><!--注入要监控的javaBean --><property name="timerTask"><ref bean="task" /></property><!--类型是否为fixedRate型,默认为fixedDelay--><property name="fixedRate"><value>true</value></property></bean><bean id="scheduler"class="org.springframework.scheduling.timer.TimerFactoryBean"> <property name="scheduledTimerTasks"><list><ref bean="repeatingTrigger" /></list></property></bean><bean id="task" class="com.css.wam.portlet.SampleTask"><property name="workService"><ref bean="workService" /></property><property name="work"><ref bean="work" /></property></bean>然后写SampleTask类,如下:package com.css.wam.portlet;import java.util.ArrayList;import java.util.Calendar;import java.util.Iterator;import java.util.List;import java.util.TimerTask;import javax.servlet.ServletContext; 字串2import org.apache.jetspeed.security.SecurityException; 字串9 import com.css.wam.service.WorkService; 字串1@SuppressWarnings("unused")class SampleTask extends TimerTask{ 字串2private static final int C_SCHEDULE_HOUR = 23;//设置指定时间private WorkService workService;private List users;private List teams;private WorkPortlet work;public void setWorkService(WorkService workService) {this.workService = workService;} 字串7public void setWork(WorkPortlet work) {this.work = work;} 字串4public SampleTask(){}@SuppressWarnings("unchecked")public void run() {Calendar cal = Calendar.getInstance();try {users = work.getUsers();teams = new ArrayList();for(Iterator it = users.iterator(); it.hasNext();){String teamname = work.getGroupsByUser((String)it.next()); teams.add(teamname);}//查看当前时间与指定是否一致,一致则执行任务if (C_SCHEDULE_HOUR == cal.get(Calendar.HOUR_OF_DAY) ) 字串6workService.autoWorkOff(users, teams); 字串8} catch (SecurityException e) {e.printStackTrace();}}}Spring定时器配置详解完整的这是时间的设置规则org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运行时间,只需要设置其cronExpression属性。
spring定时器的使用(注解方式)
spring定时器的使⽤(注解⽅式)Spring定时器注解⽅式的实现Spring定时器注解⽅式的实现需要添加⼀下配置1.⾸先要配置我们的spring.xmlXmlns中需要配置:xmlns:task="/schema/task"然后xsi:schemaLocation多加下⾯的内容:2.配置是我们的task任务扫描注解<task:annotation-driven/>3.指定扫描位置<context:annotation-config/><bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor"/><context:component-scan base-package="com.sxt.mvc.quartz"/>base-package:⾥⾯配置的是你要扫描的位置4.下⾯我们就要编写我们java的⽅法@Scheduled(cron="0/5 * * * * ? ")的意思是:没5秒钟执⾏⼀次这⾥需要注意的是:1、spring的@Scheduled注解需要写在实现上、2、定时器的任务⽅法不能有返回值(如果有返回值,spring初始化的时候会告诉你有个错误、需要设定⼀个 proxytargetclass的某个值为true、具体就去百度google吧)3、实现类上要有组件的注解@Component,不然不会执⾏启动容器后⾃动扫描执⾏:关于corn表达式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触发。
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的启动类或配置类上添加一次。
定时器的使用方法
定时器的使用方法定时器是一种非常常见的程序设计工具,它可以在特定的时间间隔内执行某些任务,或者在特定的时间点执行某些任务。
在各种编程语言和开发平台中,定时器都扮演着非常重要的角色。
本文将介绍定时器的使用方法,帮助大家更好地理解和应用定时器。
首先,我们需要了解定时器的基本原理。
定时器通常由一个时钟和一个计数器组成。
时钟用来产生时间间隔的信号,计数器用来记录经过的时间。
当计数器的数值达到设定的时间间隔时,定时器就会触发相应的事件或任务。
在使用定时器之前,我们需要先初始化定时器。
这包括设置定时器的时间间隔、选择定时器的工作模式(单次触发还是周期触发)、以及注册定时器触发时要执行的任务或事件。
不同的编程语言和开发平台对于定时器的初始化方法可能有所不同,但基本的原理是相通的。
接下来,我们需要启动定时器。
启动定时器意味着开始计时,并且在达到设定的时间间隔时触发相应的事件或任务。
在启动定时器之后,定时器会根据设定的时间间隔不断地计数,直到达到设定的触发条件。
定时器的停止也是非常重要的。
在某些情况下,我们可能需要手动停止定时器的计数,以防止不必要的触发。
定时器的停止方法通常包括手动停止和自动停止两种方式,具体取决于编程语言和开发平台的支持。
除了基本的初始化、启动和停止,定时器还可以进行一些高级的操作。
比如修改定时器的时间间隔、动态注册和注销定时器事件、以及处理定时器触发时可能出现的异常情况。
这些高级操作可以帮助我们更灵活地应用定时器,满足不同的需求。
在实际的应用中,定时器经常被用来处理定时任务、定时轮询、定时触发事件等场景。
比如在游戏开发中,我们可以使用定时器来控制游戏中的动画效果和角色行为;在网络编程中,定时器可以用来定时发送心跳包和定时检测网络连接;在系统管理中,定时器可以用来定时清理垃圾文件和定时备份数据等。
总的来说,定时器是一种非常有用的程序设计工具,它可以帮助我们在特定的时间点执行任务,或者在特定的时间间隔内重复执行任务。
spring定时任务
Chapter 23. Spring中的定时调度(Scheduling)和线程池(Thread Pooling)23.1. 简介Spring包含了对定时调度服务的内置支持类。
当前,Spring支持从JDK1.3开始内置的Timer类和QuartzScheduler(/quartz/)。
二者都可以通过FactoryBean,分别指向Timer或Trigger实例的引用进行配置。
更进一步,有个对Quartz Scheduler和Timer都有效的工具类可以让你调用某个目标对象的方法(类似通常的MethodInvokingFactoryBean操作)。
Spring 还包含有用于线程池调度的类,它针对Java 1.3,1.4,5和JEE环境的差异都进行了抽象。
23.2. 使用OpenSymphony Quartz 调度器Quartz使用Trigger, Job以及JobDetail等对象来进行各种类型的任务调度。
关于Quartz的基本概念,请参阅/quartz。
为了让基于Spring的应用程序方便使用,Spring提供了一些类来简化uartz的用法。
23.2.1. 使用JobDetailBeanJobDetail对象保存运行一个任务所需的全部信息。
Spring提供一个叫作JobDetailBean的类让JobDetail能对一些有意义的初始值进行初始化。
让我们来看个例子:<bean name="exampleJob"class="org.springframework.scheduling.quartz.JobDetailBean"><property name="jobClass" value="example.ExampleJob" /><property name="jobDataAsMap"><map><entry key="timeout" value="5" /></map></property></bean>Job detail bean拥有所有运行job(ExampleJob)的必要信息。
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() 实现单线程的执⾏器。
springmvc定时器
SpringMVC之定时器刚做了个项目,其中用到了定时器,对定时器使用的一个简单总结。
1,首先在配置文件头部的必须要有:xmlns:task="/schema/task" 2,其次xsi:schemaLocation必须为其添加/schema/task/schema/task/spring-task.xsd<context:component-scan base-package="com.xx.xx"/>com.xx.xx属于定时任务类的父级甚至更高级4,然后设置动作启用定时任务<task:annotation-driven/>5,程序注解设置@Componentpublic class TaskJOB {具体的执行内容不在贴出/*** 每隔20秒执行一次*/@Scheduled(fixedRate = 1000*20)public void print(){}配置mxl的文件启动定时器注:多了创建bean和时间配置,每隔5秒触发一次,代码如下:<bean id="agentExcelTask" class="com.timer.TimerController1"/><task:scheduled-tasks><task:scheduled ref="agentExcelTask" method="print" cron="0/5 * * * * ?"/> </task:scheduled-tasks>//@Scheduled(cron = "0 0 1 * * ?")//每天凌晨1点整//@Scheduled(cron = "0 30 0 * * ?")//每天凌晨0点30分//@Scheduled(cron = "0 */60 * * * ?")//1小时处理一次CronTrigger配置格式:格式: [秒] [分] [小时] [日] [月] [周] [年]序号说明是否必填允许填写的值允许的通配符1 秒是0-59 , - * /2 分是0-59 , - * /3 小时是0-23 , - * /4 日是1-31 , - * ? / L W5 月是1-12 or JAN-DEC , - * /6 周是1-7 or SUN-SAT , - * ? / L #7 年否empty 或1970-2099 , - * /通配符说明:* 表示所有值. 例如:在分的字段上设置"*",表示每一分钟都会触发。
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注解的⼀个缺点就是其定时时间不能动态更改,它适⽤于具有固定任务周期的任务,若要修改任务执⾏周期,只能⾛“停服务→修改任务执⾏周期→重启服务”这条路。
spring定时服务和事务管理培训
spring事务管理培训VOS工程陈冲目录1前言 (3)2事务管理 (3)2.1什么是事务 (3)2.2为什么需要事务 (4)2.3 Java事务类型 (4)JBDC事务 (4)JTA(Java Transaction API)事务 (4)容器事务 (5)3 VOS的事务应用 (5)3.1事务现状 (5)3.2事务配置 (5)配置文件 (5)事务说明 (6)3.3数据源配置 (7)配置文件 (7)数据源说明 (7)1前言本文档是描绘vos 中的事务管理方式,用于开发人员培训和交流,有缺乏之处还望谅解和指出。
2事务管理2.1什么是事务事务是现代数据库理论中的核心概念之一。
假设一组处理步骤或者全部发生或者一步也不执行,我们称该组处理步骤为一个事务。
当所有的步骤像一个操作一样被完好地执行,我们称该事务被提交。
由于其中的一部分或多步执行失败,导致没有步骤被提交,那么事务必须回滚到最初的系统状态。
事务必须服从ISO/IEC所制定的ACID原那么。
ACID是原子性〔atomicity〕、一致性〔consistency〕、隔离性〔isolation〕和持久性〔durability〕的缩写。
事务原子性:表示事务执行过程中的任何失败都将导致事务所做的任何修改失效。
一致性:表示当事务执行失败时,所有被该事务影响的数据都应该恢复到事务执行前的状态。
隔离性:表示在事务执行过程中对数据的修改,在事务提交之前对其他事务不可见。
持久性:表示当系统或介质发生故障时,确保已提交事务的更新不能丧失。
持久性通过数据库备份和恢复来保证。
2.2为什么需要事务事务是为解决数据平安操作提出的,事务控制实际上就是控制数据的平安访问。
具一个简单例子:比方银行转帐业务,账户A要将自己账户上的1000 元转到B账户下面,A账户余额首先要减去1000元,然后B 账户要增加1000元。
假设在中间网络出现了问题,A账户减去1000元已经完毕,B因为网络中断而操作失败,那么整个业务失败,必须做出控制,要求A账户转帐业务撤销。
spring定时器--代码解读
applicationContext.xmlXml代码1. <?xml version="1.0"encoding="UTF-8"?>2. <beans3. xmlns="/schema/beans"4. xmlns:xsi="/2001/XMLSchema-instance"5. xsi:schemaLocation="/schema/beans http://www.spri/schema/beans/spring-beans-2.0.xsd">6.7.8. <bean id="mesBean"class="cn.xg.spring.Message"abstract="false"9. lazy-init="default"autowire="default"dependency-check="default">10. <property name="title">11. <value>标题</value>12. </property>13. </bean>14.15. <!-- spring定时器 -->16. <!-- 方法一 -->17. <!-- 第一步声明一个定时任务,该类extends java.util.TimerTask -->18. <bean id="clock"class="cn.xg.spring.Clock"></bean>19.20. <!-- 第二步调度定时任务,把声明的定时任务注入进来,并设置定时参数 -->21. <bean id="scheduledClock"class="org.springframework.scheduling.timer.ScheduledTimerTask">22. <property name="timerTask">23. <ref bean="clock"></ref>24. </property>25. <property name="period">26. <value>5000</value>27. <!--这里是每隔多长时间就进行一次计时任务,单位ms-->28. </property>29. <property name="delay">30. <value>5000</value>31. <!--这里是服务启动后延时多少时间,开始计时任务,单位ms-->32. </property>33. </bean>34.35. <!-- 启动定时任务,如果有多个定时任务,则重复步骤一,二,然后把第二步设置的beany放在下面的list列表中.此方法不能精确几点运行定时任务 -->36. <bean class="org.springframework.scheduling.timer.TimerFactoryBean">37. <property name="scheduledTimerTasks">38. <list>39. <ref bean="scheduledClock"></ref>40. </list>41. </property>42. </bean>43.44. <!-- 方法二 -->45. <!-- 第一步声明一个定时任务,注意不是直接声明,而是声明一个JobDetailBean,通过jobClass属性设置一个定时对象 -->46. <bean id="quartzClock"class="org.springframework.scheduling.quartz.JobDetailBean">47. <property name="jobClass">48. <value>cn.xg.spring.QuartzClock</value>49. </property>50. </bean>51.52. <!-- 第二步调度定时任务 -->53. <!--这种配置与第一种方法效果一样54. <bean id="quartzClockTask"class="org.springframework.scheduling.quartz.SimpleTriggerBean">55. <property name="jobDetail">56. <ref bean="quartzClock"/>57. </property>58. <property name="startDelay">59. <value>6000</value>60. 这里是服务启动后延时多少时间,开始计时任务,单位ms61. </property>62. <property name="repeatInterval">63. <value>6000</value>64. 这里是每隔多长时间就进行一次计时任务,单位ms65. </property>66. </bean>67. -->68. <!-- 这种配置可以精确几点执行定时任务 -->69. <bean id="cronQuartzClock"class="org.springframework.scheduling.quartz.CronTriggerBean">70. <property name="jobDetail">71. <ref bean="quartzClock"></ref>72. </property>73. <property name="cronExpression">74. <value>0 52 22 * * ?</value><!--定时在任何月份任何日期(不管星期几)的22点52分0秒 -->75. <!-- 一个cron表达式有到少6个(也可能是7个)由空格分隔的时间元素.从左到右,这些元素的定义如下:76. 1.秒(0-59)77. 2.分钟(0-59)78. 3.小时(0-23)79. 4.月份中的是期(1-31)80. 5.月份(1-12或SUN-DEC)81. 6.星期中的日期(1-7或SUN-SAT)82. 7.年份(1970-2099)83. 例子:84. 0 0 10,14,16 * * ? 每天上午10点,下午2点和下午4点85. 0 0,15,30,45 * 1-10 * ? 每月前10天每隔15分钟86. 30 0 0 1 1 ? 2012 在2012年1月1日午夜过30秒时87. 0 0 8-5 ? * MON-FRI 每个工作日的工作时间88.89. - 区间90. * 通配符91. ? 你不想设置那个字段92. -->93. </property>94.95. </bean>96. <!--第三步启动定时任务,注意这里的ref bean -->97. <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">98. <property name="triggers">99. <list>100. <ref bean="cronQuartzClock"></ref>101. </list>102. </property>103. </bean>104. </beans>clock.javaJava代码1. import java.util.TimerTask;2.3. public class Clock extends TimerTask{4.5. @Override6. public void run() {7.8. System.out.println("clock..!clock....!.......");9.10. }11.12. }QuartzClock .javaJava代码1. import org.quartz.JobExecutionContext;2. import org.quartz.JobExecutionException;3. import org.springframework.scheduling.quartz.QuartzJobBean;4.5. public class QuartzClock extends QuartzJobBean {6.7. @Override8. protected void executeInternal(JobExecutionContext arg0)9. throws JobExecutionException {10.11. System.out.println("QuartzClock..!QuartzClock....!.......");12. }13.14. }15.16.17. SpringTest .java18. package cn.xg.spring;19.20. import org.apache.log4j.Logger;21. import org.springframework.context.ApplicationContext;22. import org.springframework.context.support.ClassPathXmlApplicationContext;23.24. public class SpringTest {25.26. /**27. * @param args28. */29. public static Logger log = Logger.getLogger(SpringTest.class);30.31. public static void main(String[] args) {32.33.34.35. //第一种写法(加载配置文件)36. ApplicationContext ctx = new37. ClassPathXmlApplicationContext("applicationContext.xml");38.39. //第二种写法40. //ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");41. //ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");42.43. //加载多个配置文件44. // ApplicationContext ctx = new ClassPathXmlApplicationContext(45. //new String[]{"applicationContext.xml","applicationContext2.xml"} );46.47.48. }49.50. }当有任务触发时,spring会去调用quartzJob的execute()方法,在这个方法里我们就可以写一些我们自己的业务操作。
springcron表达式(定时器)
springcron表达式(定时器)写定时器时⽤到,记录⼀下:Cron表达式是⼀个字符串,字符串以5或6个空格隔开,分开⼯6或7个域,每⼀个域代表⼀个含义,Cron有如下两种语法格式:Seconds Minutes Hours DayofMonth Month DayofWeek Year 或Seconds Minutes Hours DayofMonth Month DayofWeek每⼀个域可出现的字符如下:代码Seconds:可出现,- * / 四个字符,有效范围为0-59的整数Minutes:可出现,- * / 四个字符,有效范围为0-59的整数Hours:可出现,- * / 四个字符,有效范围为0-23的整数DayofMonth:可出现,- * / ? L W C⼋个字符,有效范围为0-31的整数Month:可出现,- * / 四个字符,有效范围为1-12的整数或JAN-DEcDayofWeek:可出现,- * / ? L C #四个字符,有效范围为1-7的整数或SUN-SAT两个范围。
1表⽰星期天,2表⽰星期⼀,依次类推Year:可出现,- * / 四个字符,有效范围为1970-2099年每⼀个域都使⽤数字,但还可以出现如下特殊字符,它们的含义是:(1)*:表⽰匹配该域的任意值,假如在Minutes域使⽤*,即表⽰每分钟都会触发事件。
(2)?:只能⽤在DayofMonth和DayofWeek两个域。
它也匹配域的任意值,但实际不会。
因为DayofMonth和DayofWeek会相互影响。
例如想在每⽉的20⽇触发调度,不管20⽇到底是星期⼏,则只能使⽤如下写法: 13 13 15 20 * ?,其中最后⼀位只能⽤?,⽽不能使⽤*,如果使⽤*表⽰不管星期⼏都会触发,实际上并不是这样。
(3)-:表⽰范围,例如在Minutes域使⽤5-20,表⽰从5分到20分钟每分钟触发⼀次(4)/:表⽰起始时间开始触发,然后每隔固定时间触发⼀次,例如在Minutes域使⽤5/20,则意味着5分钟触发⼀次,⽽25,45等分别触发⼀次.(5),:表⽰列出枚举值值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
环境配置:需加入Spring.jar, quartz.jar,jta.jar,commons-collections.jar,commons-logging.jar到Classpath。
一、建立任务,实现Quartz的Job接口,并重写其execute方法。
package test;import org.quartz.Job;import org.quartz.JobExecutionContext;import org.quartz.JobExecutionException;public class HelloWorldJob implements Job{@Overridepublic void execute(JobExecutionContext arg0) throws JobExecutionException {// TODO Auto-generated method stubSystem.out.println("Hello World");}}二、在applicationContext.xml文件中配置触发器。
<?xml version="1.0"encoding="UTF-8"?><beansxmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:p="/schema/p"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd"><bean id="jobDetail"class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass"value="test.HelloWorldJob"/> </bean><bean id="trigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"> <property name="startDelay"value="1000"/><property name="repeatInterval"value="1000"/><property name="jobDetail"ref="jobDetail"/></bean><bean id="triggerFactory"class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"><list><ref local="trigger"/></list></property></bean></beans>在trigger bean中,startDelay为1秒,重复的间隔为1秒,即repeatInterval.三、编写主程序,测试。
package test;import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext; public class HelloWorldSpring {/*** @param args*/public static void main(String[] args) {// TODO Auto-generated method stubApplicationContext ctx = newClassPathXmlApplicationContext("applicationContext.xml");}}第二种实现方式:在Quartz实现定时器是通过Scheduler类实现的,由该类的实例来管理jobDetail 和Trigger的实例,因此以上通过Spring配置文件实现的定时器也可以由以下的代码来实现。
package test;import java.util.Date;import org.quartz.JobDetail;import org.quartz.Scheduler;import org.quartz.SimpleTrigger;import org.quartz.Trigger;import org.quartz.impl.StdSchedulerFactory;public class HelloWorldScheduling {public static void main(String args[])throws Exception{Scheduler scheduler = new StdSchedulerFactory().getScheduler();scheduler.start();JobDetail jobDetail = new JobDetail("helloWorld",scheduler.DEFAULT_GROUP, HelloWorldJob.class);Trigger trigger = newSimpleTrigger("simpleTrigger",scheduler.DEFAULT_GROUP,newDate(),null,SimpleTrigger.REPEAT_INDEFINITELY,1000);scheduler.scheduleJob(jobDetail,trigger);}}四、在Spring配置文件中使用CronTrigger触发器<!-- CronTrigger的实现 --><bean id="trigger"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="cronExpression"><value>0/2 * * 22 11 ? 2011</value></property><property name="jobDetail"ref="jobDetail"></property> </bean>其余文件同上。
在CronTriggerBean中,需要配置cronExpression其格式如下*[/*] *[/*] *[/*] * * * *有七部分组成,分别为秒,分,时,日,月,星期,年。
0/2 * * * * ? * 表示每两秒执行一次"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触发"0 15 10 15 * ?" 每月15号的10:15触发"0 15 10 L * ?" 每月的最后一天的10:15触发"0 15 10 ? * 6L" 每月最后一个周五的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触发。