springquartz实现定时任务的配置方法

合集下载

Spring定时器的配置

Spring定时器的配置最近两个项⽬中都⽤到了定时器的功能,选择了spring的Quartz定时器,只需要在xml⽂件中配置后就可以启⽤,相对java中⽤继承java.util.TimerTask,实现run⽅法的定时器,感觉spring的Quartz定时器更加灵活,功能更加强⼤.配置⽅法如下：1.⾸先spring定时器要⽤到的jar包： spring-2.0.6.jar quartz-1.6.0.jar commons-logging-1.1.1.jar commons-collections-3.2.1.jar2.配置你要定时加载的⽬标类<bean id="BusinessTestTime" class=com.sanss.monitor.struts.action.pushAndReward"><property name="liNaDAO" ref="LiNaDAO"></property></bean>3.配置定时器详情<bean id="BusinessTestDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="BusinessTestTime" /></property> <!-- 当指定多个Trigger时, 很可能第⼀个job完成之前第⼆个job就开始了。

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

SpringBoot集成Quartz实现定时任务的方法

SpringBoot集成Quartz实现定时任务的⽅法1 需求在我的前后端分离的实验室管理项⽬中，有⼀个功能是学⽣状态统计。

我的设计是按天统计每种状态的⽐例。

为了便于计算，在每天0点，系统需要将学⽣的状态重置，并插⼊⼀条数据作为⼀天的开始状态。

另外，考虑到学⽣的请假需求，请假的申请往往是提前做好，等系统时间⾛到实际请假时间的时候，系统要将学⽣的状态修改为请假。

显然，这两个⼦需求都可以通过定时任务实现。

在⽹上略做搜索以后，我选择了⽐较流⾏的定时任务框架Quartz。

2 QuartzQuartz是⼀个定时任务框架，其他介绍⽹上也很详尽。

这⾥要介绍⼀下Quartz⾥的⼏个⾮常核⼼的接⼝。

2.1 Scheduler接⼝Scheduler翻译成调度器，Quartz通过调度器来注册、暂停、删除Trigger和JobDetail。

Scheduler还拥有⼀个SchedulerContext，顾名思义就是上下⽂，通过SchedulerContext 我们可以获取到触发器和任务的⼀些信息。

2.2 Trigger接⼝Trigger可以翻译成触发器，通过cron表达式或是SimpleScheduleBuilder等类，指定任务执⾏的周期。

系统时间⾛到触发器指定的时间的时候，触发器就会触发任务的执⾏。

2.3 JobDetail接⼝Job接⼝是真正需要执⾏的任务。

JobDetail接⼝相当于将Job接⼝包装了⼀下，Trigger和Scheduler实际⽤到的都是JobDetail。

3 SpringBoot官⽅⽂档解读SpringBoot官⽅写了spring-boot-starter-quartz。

使⽤过SpringBoot的同学都知道这是⼀个官⽅提供的启动器，有了这个启动器，集成的操作就会被⼤⼤简化。

现在我们来看⼀看SpingBoot2.2.6官⽅⽂档，其中第4.20⼩节Quartz Scheduler就谈到了Quartz，但很可惜⼀共只有两页不到的内容，先来看看这么精华的⽂档⾥能学到些什么。

SpringBoot整合Quartz定时任务的简单实例

SpringBoot整合Quartz定时任务的简单实例POM.XML⽂件<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>1.8.5</version></dependency>类似于控制器代码:package com.xiaowu.quartz.demo;import java.util.Date;import org.springframework.scheduling.annotation.Scheduled;import ponent;/***** Quartz设置项⽬全局的定时任务** @Component注解的意义泛指组件，当组件不好归类的时候，我们可以使⽤这个注解进⾏标注。

⼀般公共的⽅法我会⽤上这个注解*** @author WQ**/@Componentpublic class QuartzDemo {@Scheduled(cron = "0 0/1 * * * ?") // 每分钟执⾏⼀次public void work() throws Exception {System.out.println("执⾏调度任务："+new Date());}@Scheduled(fixedRate = 5000)//每5秒执⾏⼀次public void play() throws Exception {System.out.println("执⾏Quartz定时器任务："+new Date());}@Scheduled(cron = "0/2 * * * * ?") //每2秒执⾏⼀次public void doSomething() throws Exception {System.out.println("每2秒执⾏⼀个的定时任务："+new Date());}@Scheduled(cron = "0 0 0/1 * * ? ") // 每⼀⼩时执⾏⼀次public void goWork() throws Exception {System.out.println("每⼀⼩时执⾏⼀次的定时任务："+new Date());}}启动SpringBoot项⽬，即可。

使用SpringQuartz执行定时任务的表达式

使用SpringQuartz执行定时任务的表达式使用Spring Quartz执行定时任务的表达式附：cronExpression配置说明一个Cron-表达式是一个由六至七个字段组成由空格分隔的字符串，其中6个字段是必须的而一个是可选的，如下：字段名允许的值允许的特殊字符字段允许值允许的特殊字符秒0-59, - * /分0-59, - * /小时0-23, - * /日期1-31, - * ? / L W C月份1-12 或者 JAN-DEC, - * /星期1-7 或者 SUN-SAT, - * ? / L C #年（可选）留空, 1970-2099, - * /表达式意义"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触发。

SpringBoot定时任务（schedule、quartz）

SpringBoot定时任务（schedule、quartz）Scheduled 只适合处理简单的计划任务，不能处理分布式计划任务。

优势：是spring框架提供的计划任务，开发简单，执⾏效率⽐较⾼。

且在计划任务数量太多的时候，可能出现阻塞，崩溃，延迟启动等问题。

Scheduled定时任务是spring3.0版本之后⾃带的⼀个定时任务。

其所属Spring的资源包为：spring-context-support。

所以需要使⽤Scheduled定时任务机制时，需要在⼯程中依赖对应资源，具体如下：<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId></dependency> 如果在spring应⽤中需要启⽤Scheduled定时任务，则需要在启动类上增加注解@EnableScheduling，代表启⽤Scheduled定时任务机制。

具体如下：@SpringBootApplication@EnableSchedulingpublic class AppStarter { public static void main(String[] args) { SpringApplication.run(AppStarter.class, args); }} Scheduled定时任务的核⼼在于注解@Scheduled，这个注解的核⼼属性是cron，代表定时任务的触发计划表达式。

这个表达式的格式为：@Scheduled(cron="seconds minutes hours day month week") 或@Scheduled(cron="seconds minutes hours day month week year") 推荐使⽤第⼀种表达式形式，因为在很多其他技术中都有不同的定时任务机制，其中⽤于设置触发计划的表达式都是第⼀种cron表达式。

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")；//如果我们没有使用一些特殊的机制，那么返回的只能是一个固定的字符串。

Spring集成Quartz定时任务框架介绍和Cron表达式详解

在JavaEE系统中，我们会经常用到定时任务，比如每天凌晨生成前天报表，每一小时生成汇总数据等等。

我们可以使用java.util.Timer结合java.util.TimerTask来完成这项工作，但时调度控制非常不方便，并且我们需要大量的代码。

使用Quartz框架无疑是非常好的选择，并且与Spring可以非常方便的集成，下面介绍它们集成方法和Cron表达式的详细介绍。

一、增加所依赖的JAR包1、增加Spring的Maven依赖<dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>3.0.5.RELEASE</version></dependency>2、增加Quartz的Maven依赖<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>1.8.4</version></dependency>二、增加定时业务逻辑类publicclass ExpireJobTask {/** Logger */privatestaticfinal Logger logger =LoggerFactory.getLogger(ExpireJobTask.class);/*** 业务逻辑处理*/publicvoid doBiz() {// 执行业务逻辑// ........}}ExpireJobTask业务逻辑类与一般普通的类没有任务区别，它定义的doBiz方法即为调度业务方法。

java中spring与Quartz 整合定时任务

现在想要获得在特定时间或者指定时间执行相应功能有两种做法在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><property name="timerTask"><ref bean="task" /></property><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();}}}使用Quartz定时<bean id="methodInvokingJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="changeService"/></property><property name="targetMethod"><value>changeAll</value></property></bean><bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="methodInvokingJobDetail"/></property><property name="cronExpression"><value>0 0 23 * * ?</value></property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref local="cronTrigger"/></list></property></bean>简单定时<bean id="methodInvokingJobDetail"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="sgService"/></property><property name="targetMethod"><value>updateNowSgList</value></property></bean><bean id="simpleTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail"><ref bean="methodInvokingJobDetail"/></property><property name="startDelay"><value>10000</value> </property><property name="repeatInterval"><value>1296000000</value> </property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref local="simpleTrigger"/></list></property></bean>一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。

基于Spring的最简单的定时任务实现与配置（一）

基于Spring的最简单的定时任务实现与配置（⼀）朋友的项⽬中有点问题。

他那边是Spring架构的，有⼀个⽐较简单的需要定时的任务执⾏。

在了解了他的需求之后，于是提出了⽐较简单的Spring+quartz的实现⽅式。

（本⽂所述⽅法不适⽤于分布式环境）注意本⽂只是讨论，在已搭建完毕的Spring⼯程下，完成最简单的定时任务。

第⼀步，要知道Spring这个架构，很有趣很有意思。

可以做到⾃由插拔功能模块的效果。

⼯程项⽬是基于MAVEN包依赖管理的，所以把这次需要的依赖包引⽤列出来：12<dependency>3<groupId>org.springframework</groupId>4<artifactId>spring-context-support</artifactId>5<version>4.0.2.RELEASE</version>6</dependency>78910<dependency>11<groupId>org.quartz-scheduler</groupId>12<artifactId>quartz</artifactId>13<version>2.2.1</version>14</dependency>15当然，这是要跟对应的Spring的版本是要匹配的。

我们这⾥的⼯程是4.0.2。

前⼀个包spring-context-support，主要的作⽤是作为Spring与quartz的沟通管理的部件，如果注释掉就会报这样的错误在MAVEN配置完所需要添加的包之后（其他的包，这⾥暂时不扩展开说了，本⽂只讨论在完整Spring⼯程项⽬下的配置），我们就可以开始动⼿给这个项⽬添加，定时任务的功能模块了。

spring定时任务(整合了quartz插件)

spring定时任务（整合了quartz插件）2009-09-29 10:08在applicationContext-quartz.xml中进行配置就可以了：(在spring-context-support.jar 包中)<bean id="quartzJob"class="com.founder.sipossp.webapp.action.search.HotWordsAction"><property name="searchHotWordsService"><ref bean="searchHotWordsService"/></property><property name="searchIllegalWordsService"><ref bean="searchIllegalWordsService"/></property></bean><bean id="dayJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateDayhotWordBase</value></property></bean><bean id="weekJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateWeekhotWordBase</value></property></bean><bean id="monthJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateMonthhotWordBase</value></property></bean><bean id="govJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateGov</value></property></bean><bean id="polJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updatePol</value></property></bean><bean id="sciJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB ean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateSci</value></property></bean><bean id="totalJobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="quartzJob" /></property><property name="targetMethod"><value>updateTotalHotWord</value></property></bean> <bean id="doTimeDay"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="dayJobtask" /></property><property name="cronExpression"><value>0 0 1 ? * *</value></property></bean><bean id="doTimeTotal"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="totalJobtask" /></property><property name="cronExpression"><value>0 0 1 ? * *</value></property></bean><bean id="doTimeWeek"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="weekJobtask" /></property><property name="cronExpression"><value>0 0 2 ? * MON</value></property></bean><bean id="doTimeMonth"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="monthJobtask" /></property><property name="cronExpression"><value>0 0 3 1 * ?</value></property></bean> <bean id="doGov"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="govJobtask" /></property><property name="cronExpression"><value>0 30 3 1 * ?</value></property></bean><bean id="doPol"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="polJobtask" /></property><property name="cronExpression"><value>0 30 3 1 * ?</value></property></bean><bean id="doSci"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="sciJobtask" /></property><property name="cronExpression"><value>0 30 3 1 * ?</value></property></bean> <bean id="startQuertz" lazy-init="false" autowire="no"class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref bean="doTimeDay" /><ref bean="doTimeWeek" /><ref bean="doTimeMonth" /><ref bean="doGov" /><ref bean="doPol" /><ref bean="doSci" /><ref bean="doTimeTotal" /></list></property></bean>Spring定时器，主要有两种实现方式，包括Java Timer定时和Quartz定时器！1.Java Timer定时首先继承java.util.TimerTask类实现run方法package nd;import java.util.Date;import java.util.TimerTask;public class TimerTest extends TimerTask {@Overridepublic void run() {// TODO Auto-generated method stubSystem.out.println("TimerTest"+(new Date()).toString());}}Spring配置<bean id="TimerTest" class="nd.TimerTest"></bean><bean id="TimerTestTask" class="org.springframework.scheduling.timer.ScheduledTimerTask"> <property name="delay" value="10000" /><property name="period" value="72000" /><property name="timerTask" ref="TimerTest" /></bean><bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean"> <property name="scheduledTimerTasks"><list><ref bean="TimerTestTask" /></list></property></bean>2.Quartz定时器首先继承QuartzJobBean类实现executeInternal方法public class SchedulerTest extends QuartzJobBean{@Overrideprotected void executeInternal(JobExecutionContext arg0) throws JobExecutionException { // TODO Auto-generated method stub//System.out.println("-----------");System.out.println("1111111"+(new Date()).toString());}}-------------------------------------------public class SchedulerTest2 extends QuartzJobBean{@Overrideprotected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {// TODO Auto-generated method stub//System.out.println("-----------");System.out.println("22222222"+(new Date()).toString());}}Spring配置<bean id="SchedulerTask" class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass"><value>nd.SchedulerTest</value></property></bean><bean id="SchedulerTask2" class="org.springframework.scheduling.quartz.JobDetailBean"> <property name="jobClass"><value>nd.SchedulerTest2</value></property></bean><bean id="SchedulerTaskTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail" ref="SchedulerTask" /><property name="cronExpression"><value>0/10 * * * * ?</value></property></bean><bean id="SchedulerTaskTrigger2"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail" ref="SchedulerTask2" /><property name="startDelay"><value>1000</value></property><property name="repeatInterval"><value>20000</value></property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"><list><ref bean="SchedulerTaskTrigger" /><ref bean="SchedulerTaskTrigger2" /></list></property></bean>3.其他说明Java Timer定时有一种配置启动的方org.springframework.scheduling.timer.ScheduledTimerTask，Quartz定时器有两种配置启动的方式：org.springframework.scheduling.quartz.SimpleTriggerBean，org.springframework.scheduling.quartz.CronTriggerBean。

springboot整合Quartz实现动态配置定时任务

https:///liuchuanhong1/article/details/60873295前⾔在我们⽇常的开发中，很多时候，定时任务都不是写死的，⽽是写到数据库中，从⽽实现定时任务的动态配置，下⾯就通过⼀个简单的⽰例，来实现这个功能。

⼀、新建⼀个springboot⼯程，并添加依赖 <dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>com.h2database</groupId><artifactId>h2</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency><dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.2.1</version><exclusions><exclusion><artifactId>slf4j-api</artifactId><groupId>org.slf4j</groupId></exclusion></exclusions></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId></dependency>⼆、配置⽂件application.properties# 服务器端⼝号server.port=7902# 是否⽣成ddl语句spring.jpa.generate-ddl=false# 是否打印sql语句spring.jpa.show-sql=true# ⾃动⽣成ddl，由于指定了具体的ddl，此处设置为nonespring.jpa.hibernate.ddl-auto=none# 使⽤H2数据库spring.datasource.platform=h2# 指定⽣成数据库的schema⽂件位置spring.datasource.schema=classpath:schema.sql# 指定插⼊数据库语句的脚本位置spring.datasource.data=classpath:data.sql# 配置⽇志打印信息logging.level.root=INFO.hibernate=INFO.hibernate.type.descriptor.sql.BasicBinder=TRACE.hibernate.type.descriptor.sql.BasicExtractor=TRACE.itmuch=DEBUG三、Entity类package com.chhliu.springboot.quartz.entity;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;@Entitypublic class Config {@Id@GeneratedValue(strategy = GenerationType.AUTO)private Long id;@Columnprivate String cron;/*** @return the id*/public Long getId() {return id;}……此处省略getter和setter⽅法……}四、任务类package com.chhliu.springboot.quartz.entity;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.EnableScheduling;import ponent;@Configuration@Component // 此注解必加@EnableScheduling // 此注解必加public class ScheduleTask {private static final Logger LOGGER = LoggerFactory.getLogger(ScheduleTask.class);public void sayHello(){("Hello world, i'm the king of the world");}}五、Quartz配置类由于springboot追求零xml配置，所以下⾯会以配置Bean的⽅式来实现package com.chhliu.springboot.quartz.entity;import org.quartz.Trigger;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.quartz.CronTriggerFactoryBean;import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;import org.springframework.scheduling.quartz.SchedulerFactoryBean;@Configurationpublic class QuartzConfigration {/*** attention:* Details：配置定时任务*/@Bean(name = "jobDetail")public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask为需要执⾏的任务 MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();/** 是否并发执⾏* 例如每5s执⾏⼀次任务，但是当前任务还没有执⾏完，就已经过了5s了，* 如果此处为true，则下⼀个任务会执⾏，如果此处为false，则下⼀个任务会等待上⼀个任务执⾏完后，再开始执⾏ */jobDetail.setConcurrent(false);jobDetail.setName("srd-chhliu");// 设置任务的名字jobDetail.setGroup("srd");// 设置任务的分组，这些属性都可以存储在数据库中，在多任务的时候使⽤/** 为需要执⾏的实体类对应的对象*/jobDetail.setTargetObject(task);/** sayHello为需要执⾏的⽅法* 通过这⼏个配置，告诉JobDetailFactoryBean我们需要执⾏定时执⾏ScheduleTask类中的sayHello⽅法*/jobDetail.setTargetMethod("sayHello");return jobDetail;}/*** attention:* Details：配置定时任务的触发器，也就是什么时候触发执⾏定时任务*/@Bean(name = "jobTrigger")public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) { CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();tigger.setJobDetail(jobDetail.getObject());tigger.setCronExpression("0 30 20 * * ?");// 初始时的cron表达式tigger.setName("srd-chhliu");// trigger的namereturn tigger;}/*** attention:* Details：定义quartz调度⼯⼚*/@Bean(name = "scheduler")public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {SchedulerFactoryBean bean = new SchedulerFactoryBean();// ⽤于quartz集群,QuartzScheduler 启动时更新⼰存在的Jobbean.setOverwriteExistingJobs(true);// 延时启动，应⽤启动1秒后bean.setStartupDelay(1);// 注册触发器bean.setTriggers(cronJobTrigger);return bean;}}六、定时查库，并更新任务package com.chhliu.springboot.quartz.entity;import javax.annotation.Resource;import org.quartz.CronScheduleBuilder;import org.quartz.CronTrigger;import org.quartz.JobDetail;import org.quartz.Scheduler;import org.quartz.SchedulerException;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import org.springframework.scheduling.annotation.EnableScheduling;import org.springframework.scheduling.annotation.Scheduled;import ponent;import com.chhliu.springboot.quartz.repository.ConfigRepository;@Configuration@EnableScheduling@Componentpublic class ScheduleRefreshDatabase {@Autowiredprivate ConfigRepository repository;@Resource(name = "jobDetail")private JobDetail jobDetail;@Resource(name = "jobTrigger")private CronTrigger cronTrigger;@Resource(name = "scheduler")private Scheduler scheduler;@Scheduled(fixedRate = 5000) // 每隔5s查库，并根据查询结果决定是否重新设置定时任务public void scheduleUpdateCronTrigger() throws SchedulerException {CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());String currentCron = trigger.getCronExpression();// 当前Trigger使⽤的String searchCron = repository.findOne(1L).getCron();// 从数据库查询出来的System.out.println(currentCron);System.out.println(searchCron);if (currentCron.equals(searchCron)) {// 如果当前使⽤的cron表达式和从数据库中查询出来的cron表达式⼀致，则不刷新任务} else {// 表达式调度构建器CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);// 按新的cronExpression表达式重新构建triggertrigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey()).withSchedule(scheduleBuilder).build();// 按新的trigger重新设置job执⾏scheduler.rescheduleJob(cronTrigger.getKey(), trigger);currentCron = searchCron;}}}六、相关脚本1、data.sqlinsert into config(id,cron) values(1,'0 0/2 * * * ?'); # 每2分钟执⾏⼀次定时任务2、schema.sqldrop table config if exists;create table config(id bigint generated by default as identity,cron varchar(40),primary key(id));六、运⾏测试测试结果如下：(Quartz默认的线程池⼤⼩为10)0 30 20 * * ?0 0/2 * * * ?2017-03-08 18:02:00.025 INFO 5328 --- [eduler_Worker-1] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world2017-03-08 18:04:00.003 INFO 5328 --- [eduler_Worker-2] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world2017-03-08 18:06:00.002 INFO 5328 --- [eduler_Worker-3] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world2017-03-08 18:08:00.002 INFO 5328 --- [eduler_Worker-4] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world从上⾯的⽇志打印时间来看，我们实现了动态配置，最初的时候，任务是每天20:30执⾏，后⾯通过动态刷新变成了每隔2分钟执⾏⼀次。

Spring Quartz 定时任务

使用Quartz调度器Quartz调度器为调度工作提供了更丰富的支持。

和Java定时器一样，可以使用Quartz来每隔多少毫秒执行一个工作。

但Quartz比Java Timer更先进之处在于它允许你调度一个工作在某个特定的时间或日期执行。

创建一个类来定义工作定义Quartz工作的第一步是创建一个类来定义工作。

要做到这一点，你需要从Spring的QuartzJobBean中派生子类，如程序清单7.3所示：程序清单7.3 定义一个Quartz工作public class EmailReportJob extends QuartzJobBean {public EmailReportJob() {}protected void executeInternal(JobExecutionContext context)throws JobExecutionException {courseService.sendCourseEnrollmentReport();}private CourseService courseService;public void setCourseService(CourseService courseService) {this.courseService = courseService;}}<bean id="reportJob"class="org.springframework.scheduling.quartz.JobDetailBean" ><property name="jobClass"><value>xxx.xxx.EmailReportJob</value></property><property name="jobDataAsMap"><map><entry key="courseService"><ref bean="courseService"/></entry></map></property></bean>值得注意的是，在这里你并没有直接声明一个EmailReportJob Bean，而是声明了一个JobDetailBean。

Quartz+Spring简单实现定时任务

}
}
2、spring的配置文件：
xml/html代码
<?xml version="1.0" encoding="utf-8"?>
<!doctype beans public "-//spring//dtd bean//en" "/dtd/spring-beans.dtd">
<property name="triggers"> Biblioteka <list>
<ref bean="dotime"/>
</list>
</property>
</bean>
</beans>
3、测试程序：
</property>

<property name="cronexpression">
<value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>
</property>
class="org.springframework.scheduling.quartz.methodinvokingjobdetailfactorybean">

<property name="targetobject">
<ref bean="quartzjob"/>

【spring-boot】springboot整合quartz实现定时任务

【spring-boot】springboot整合quartz实现定时任务在做项⽬时有时候会有定时器任务的功能，⽐如某某时间应该做什么，多少秒应该怎么样之类的。

spring⽀持多种定时任务的实现。

我们来介绍下使⽤spring的定时器和使⽤quartz定时器 1.我们使⽤spring-boot作为基础框架，其理念为零配置⽂件，所有的配置都是基于注解和暴露bean的⽅式。

2.使⽤spring的定时器: spring⾃带⽀持定时器的任务实现。

其可通过简单配置来使⽤到简单的定时任务。

@Component@Configurable@EnableSchedulingpublic class ScheduledTasks{@Scheduled(fixedRate = 1000 * 30)public void reportCurrentTime(){System.out.println ("Scheduling Tasks Examples: The time is now " + dateFormat ().format (new Date ()));}//每1分钟执⾏⼀次@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");}}没了，没错，使⽤spring的定时任务就这么简单，其中有⼏个⽐较重要的注解： @EnableScheduling：标注启动定时任务。

springboot整合quartz集群环境实现动态定时任务配置【原】

springboot整合quartz集群环境实现动态定时任务配置【原】/*** 设置quartz属性** @author XW* @create_date 2016年12月28日* @return Properties*/public Properties quartzProperties() {Properties prop = new Properties();// org.quartz.scheduler.instanceName属性可为任何值，用在JDBC JobStore// 中来唯一标识实例，但是所有集群节点中必须相同。

prop.put("quartz.scheduler.instanceName", "ServerScheduler");// instanceId 属性为 AUTO即可，基于主机名和时间戳来产生实例 ID。

prop.put("org.quartz.scheduler.instanceId", "AUTO");//// Quartz内置了一个“更新检查”特性，因此Quartz项目每次启动后都会检查官网，Quartz是否存在新版本。

这个检查是异步的，不影响Quartz项目本身的启动和初始化。

// 设置org.quartz.scheduler.skipUpdateCheck的属性为true 来跳过更新检查prop.put("org.quartz.scheduler.skipUpdateCheck", "false");//prop.put("org.quartz.scheduler.jobFactory.class","org.quartz.simpl.SimpleJobFactory");// org.quartz.jobStore.class属性为 JobStoreTX，将任务持久化到数据中。

spring多个定时任务quartz配置

spring多个定时任务quartz配置spring多个定时任务quartz配置2010-12-08 1034 A.M.xmlversion1.0encodingUTF-8 beans xmlns beanidjob1classcom.job.Job1///任务1 beanidjob2classcom.job.Job2///任务2 bean idjobDetail_1 classorg.springframework.scheduling.quartz.MethodInvokingJo bDetailFactoryBean property nametargetObject ref beanjob1/ /property property nametargetMethod value jobMethod1/value//执行的方法/property /bean bean idjobDetail_2classorg.springframework.scheduling.quartz.MethodInvokingJo bDetailFactoryBean property nametargetObject ref beanjob2/ /property property nametargetMethod value jobMethod2/value /property /bean bean idcronTrigger_1classorg.springframework.scheduling.quartz.CronTriggerBean property namejobDetail ref beanjobDetail_1/ /property property namecronExpression value 00 0/value//每天凌晨12点执行一次/property /bean bean idcronTrigger_2classorg.springframework.scheduling.quartz.CronTriggerBean property namejobDetail ref beanjobDetail_2/ /property property namecronExpression value 00/1/value//每小时执行一次/property /bean beanclassorg.springframework.scheduling.quartz.SchedulerFactoryBean property nametriggers list ref localcronTrigger_1/ ref localcronTrigger_2/ /list /property /bean /beans 一个cronExpression表达式有至少6个也可能是7个由空格分隔的时间元素。

Spring+Quartz实现定时任务的配置方法

1、Scheduler的配置说明：Scheduler包含一个Trigger列表，每个Trigger表示一个作业。

2、Trigger的配置说明：1）Cron表达式的格式：秒分时日月周年(可选)。

字段名允许的值允许的特殊字符秒0-59 , - * /分0-59 , - * /小时0-23 , - * /日1-31 , - * ? / L W C月1-12 or JAN-DEC , - * /周几1-7 or SUN-SAT , - * ? / L C #年(可选字段) empty, 1970-2099 , - * /“?”字符：表示不确定的值“,”字符：指定数个值“-”字符：指定一个值的范围“/”字符：指定一个值的增加幅度。

n/m表示从n开始，每次增加m“L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X“W”字符：指定离给定日期最近的工作日(周一到周五)“#”字符：表示该月第几个周X。

6#3表示该月第3个周五2）Cron表达式范例：每隔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在26分、29分、33分执行一次：0 26,29,33 * * * ?每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?3、JobDetail的配置4、业务类的配置<bean id="testJob" class="com.cjm.web.service.quartz.TestJob"/>5、业务类源代码说明：业务类不需要继承任何父类，也不需要实现任何接口，只是一个普通的java类。

SpringBoot定时任务Quartz使用教程

SpringBoot定时任务Quartz使⽤教程Quartz是⼀个完全由java编写的开源作业调度框架，他使⽤⾮常简单。

本章主要讲解 Quartz在Spring Boot 中的使⽤。

1. 快速集成 Quartz2. 介绍 Quartz ⼏个主要技术点3. Quartz 在 Spring Boot 的配置4. Quartz 在 Spring Boot 中整合 Mybatis本着⼀篇⽂章⼀个⽰例的原则，2、3、4 将在下⼀章节说明1 新建 Spring Boot Maven ⽰例⼯程项⽬注意：是⽤来 IDEA 开发⼯具1. File > New > Project，如下图选择Spring Initializr然后点击【Next】下⼀步2. 填写GroupId（包名）、Artifact（项⽬名）即可。

点击下⼀步groupId=com.fishproartifactId=quartz3. 选择依赖Spring Web Starter前⾯打钩。

4. 项⽬名设置为spring-boot-study-quartz.2 依赖引⼊ Pom<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId><scope>test</scope></dependency></dependencies>3 使⽤ Quartz3.1 在启动⽂件中编写⼀个简单的使⽤QuartzApplication 中直接编写⼀启动关闭类代码@SpringBootApplicationpublic class QuartzApplication {public static void main(String[] args) {SpringApplication.run(QuartzApplication.class, args);try {// Grab the Scheduler instance from the FactoryScheduler scheduler = StdSchedulerFactory.getDefaultScheduler();//启动scheduler.start();//关闭scheduler.shutdown();} catch (SchedulerException se) {se.printStackTrace();}}}运⾏在控制台观察结果2019-08-08 15:09:01.313 INFO 21565 --- [ main] org.quartz.impl.StdSchedulerFactory : Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties' 2019-08-08 15:09:01.313 INFO 21565 --- [ main] org.quartz.impl.StdSchedulerFactory : Quartz scheduler version: 2.3.12019-08-08 15:09:01.314 INFO 21565 --- [ main] org.quartz.core.QuartzScheduler : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.2019-08-08 15:09:01.314 INFO 21565 --- [ main] org.quartz.core.QuartzScheduler : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutting down.2019-08-08 15:09:01.314 INFO 21565 --- [ main] org.quartz.core.QuartzScheduler : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED paused.2019-08-08 15:09:01.314 INFO 21565 --- [ main] org.quartz.core.QuartzScheduler : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutdown complete.3.2 使⽤ Job 和 Trigger1. 新建⼀个 Job 类 WelcomeJob2. 在启动类中调⽤他WelcomeJob （路径 src/main/java/com/fishpro/quartz/job/WelcomeJob.java）public class WelcomeJob implements Job {@Overridepublic void execute(JobExecutionContext arg0) throws JobExecutionException {System.out.println("这是⼀个quartz 任务");}}QuartzApplication （路径 src/main/java/com/fishpro/quartz/QuartzApplication.java）@SpringBootApplicationpublic class QuartzApplication {public static void main(String[] args) {SpringApplication.run(QuartzApplication.class, args);try {// Grab the Scheduler instance from the FactoryScheduler scheduler = StdSchedulerFactory.getDefaultScheduler();//启动scheduler.start();//新建⼀个 Job WelcomeJobJobDetail job = JobBuilder.newJob(WelcomeJob.class).withIdentity("mySimpleJob", "simpleGroup").build();// 触发器定义多长时间触发 JobDetailTrigger trigger = org.quartz.TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "simpleGroup").startNow().withSchedule(simpleSchedule().withIntervalInSeconds(10).repeatForever()).build();scheduler.scheduleJob(job,trigger);//关闭//scheduler.shutdown();} catch (SchedulerException se) {se.printStackTrace();}}}运⾏结果2019-08-08 16:46:36.599 INFO 21695 --- [ main] org.quartz.impl.StdSchedulerFactory : Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties' 2019-08-08 16:46:36.599 INFO 21695 --- [ main] org.quartz.impl.StdSchedulerFactory : Quartz scheduler version: 2.3.12019-08-08 16:46:36.599 INFO 21695 --- [ main] org.quartz.core.QuartzScheduler : Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务这是⼀个quartz 任务如果您觉得本系列⽰例对您有帮助，请点击右上⾓按钮 watch 以⽰⽀持谢谢参考。

SpringBoot配置Quartz定时任务的方法

SpringBoot配置Quartz定时任务的⽅法Quartz有四个核⼼概念:Job：是⼀个接⼝，只定义⼀个⽅法 execute（JobExecutionContext context），在实现接⼝的 execute ⽅法中编写所需要定时执⾏的 Job（任务）Double slongitude = Double.valueOf(jobExecutionContext.getJobDetail().getJobDataMap().get("slongitude").toString()); JobDetail：Quartz 每次调度 Job 时，都重新创建⼀个 Job 实例，因此它不接受⼀个 Job 的实例，相反它接收⼀个 Job 实现类（JobDetail，描述 Job 的实现类及其他相关的静态信息，如 Job 名字、描述、关联监听器等信息），以便运⾏时通过newInstance() 的反射机制实例化 Job。

rigger：是⼀个类，描述触发 Job 执⾏的时间触发规则，主要有 SimpleTrigger 和 CronTrigger 这两个⼦类。

当且仅当需调度⼀次或者以固定时间间隔周期执⾏调度，SimpleTrigger 是最适合的选择；⽽ CronTrigger 则可以通过 Cron 表达式定义出各种复杂时间规则的调度⽅案：如⼯作⽇周⼀到周五的 15：00 ~ 16：00 执⾏调度等。

Scheduler：调度器就相当于⼀个容器，装载着任务和触发器，该类是⼀个接⼝，代表⼀个 Quartz 的独⽴运⾏容器，Trigger 和 JobDetail 可以注册到 Scheduler 中，两者在 Scheduler 中拥有各⾃的组及名称，组及名称是 Scheduler 查找定位容器中某⼀对象的依据，Trigger 的组及名称必须唯⼀，JobDetail 的组和名称也必须唯⼀（但可以和 Trigger 的组和名称相同，因为它们是不同类型的）。

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

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。

属性repeatInterval告诉触发器以怎样的频度运行这个工作（以毫秒作为单位）。

这里，我们
设置它为86400000，因此每隔24小时它会被触发一次。

你也可以选择设置startDelay 属性来延迟工作的第一次执行。

我们设置它为3600000，因此在第一次触发之前它会等待1小时。

CronTriggerBean允许你更精确地控制任务的运行时间。

和SimpleTriggerBean一样，jobDetail属性告诉触发器调度哪个工作。

这里我们又一次装配了一个topTenTask Bean。

属性cronExpression告诉触发器何时触发。

如果你不熟悉cron，这个属性可能看上去有点神秘，因此让我们进一步考察一下这个属性。

字段允许值允许的特殊字符
秒0-59, - * /
分0-59, - * /
小时0-23, - * /
日0-31, - * ? / L W C
月1-12 或者JAN-DEC , - * /
周几1-7 或者SUN-SAT, - * ? / L C #
年(可选字段)留空, 1970-2099, - * /
(1)
(2)“-”字符：指定一个值的范围
(3)“*”字符可以用于所有字段，在“分”字段中设为"*"表示"每一分钟"的含义。

(4)“/”字符：指定一个值的增加幅度。

n/m表示从n开始，每次增加m
(5)“?”字符：表示不确定的值
(6)“L”字符：用在日表示一个月中的最后一天，用在周表示该月最后一个星期X
(7)“W”字符：指定离给定日期最近的工作日(周一到周五)
(8)“C”字符可用于“日”和“周几”字段，它是"calendar"的缩写。

它表示为基于相关
的日历所计算出的值（如果有的话）。

如果没有关联的日历, 那它等同于包含全部日历。

“日”字段值为"5C"表示"日历中的第一天或者5号以后"，“周几”字段值为"1C"则表示"日历中的第一天或者周日以后"。

(9)“#”字符：表示该月第几个周X。

6#3表示该月第3个周五
cronExpression表达式的示例：
"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触发
第五步：启动工作
属性triggers接受一组触发器。

此处配置了两个触发器，其中一个就是之前配置的topTenTrigger。