Quartz结合SPRING多任务定时调用

合集下载

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

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,但很可惜⼀共只有两页不到的内容,先来看看这么精华的⽂档⾥能学到些什么。

使用Spring Quartz执行定时任务

使用Spring Quartz执行定时任务

使用Spring Quartz执行定时任务Quartz是OpenSymphony下的一个开源项目,提供了比JDK的TimeTask更强大的定时任务执行功能。

Spring在Quartz的基础上包装了一层,使得在不使用数据库配置Quartz的情况下,不必再用Quartz的JavaBean设置参数,代码更优雅,可配置性高。

下面我就举个简单的例子。

首先,配置Spring的配置文件,起名叫applicationContext.xml然后编写具体操作代码最后编写运行程序编译后运行RandomPrice就OK了。

需要注意的是,必须使用main函数才能运行,不能使用JUnit。

附:cronExpression配置说明字段允许值允许的特殊字符秒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触发posted on 2006-04-27 15:53 冰雨阅读(62) 评论(0)编辑收藏引用所属分类: Spring。

关于springboot集成quartz完成自动调度

关于springboot集成quartz完成自动调度
@Configuration public class QuartzConfig {
@Bean public JobDetail jobDetail1(){
return JobBuilder.newJob(QuartzJob1.class).storeDurably().build(); }
@Bean public Trigger trigger1(){
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println("QuartzJob1----" + sdf.format(new Date())); }
}
三、创建QuartzConfig,接着定义JobDetail,JobDetail由JobBuilder构建,同时关联了任务。
二、创建任务类,继承QuartzJobBean实现executeInternal(调用所需实现的方法)
public class QuartzJob1 extends QuartzJobBean {
@Override protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
博客园 用户登录 代码改变世界 密码登录 短信登录 忘记登录用户名 忘记密码 记住我 登录 第三方登录/注册 没有账户, 立即注册
关于 springboot集成 quartz完成自动调度
一、添加依赖
<!--quartz定时调度依赖--> <dependency>

Quartz+spring定时器实例用

Quartz+spring定时器实例用

Spring+Quartz定时器例子如下:1. javabean类在Test.QuartzJob中1.package Test;2.3.public class QuartzJob {4.public void work()5. {6. System.out.println("Quartz的任务调度!!!");7. }8. }1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:jee="/schema/jee"5.xsi:schemaLocation="/schema/beans http://w/schema/beans/spring-beans-2.0.xsd6./schema/jee /schema/jee/spring-jee-2.0.xsd">7.8.<!-- 要调用的工作类 -->9.<bean id="quartzJob"class="org.huajun.utils.QuartzJob"></bean>10.<!-- 定义调用对象和调用对象的方法 -->11.<bean id="jobtask"12.class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">13.<!-- 调用的类 -->14.<property name="targetObject">15.<ref bean="quartzJob"/>16.</property>17.<!-- 调用类中的方法 -->18.<property name="targetMethod">19.<value>work</value>20.</property>21.</bean>22.<!-- 定义触发时间 -->23.<bean id="doTime"24.class="org.springframework.scheduling.quartz.CronTriggerBean">25.<property name="jobDetail">26.<ref bean="jobtask"/>27.</property>28.<!-- cron表达式 -->29.<property name="cronExpression">30.<!-- 第 10、30 、50 分钟各执行一次-->31.<value>0 10/20 * * * ?</value>32.</property>33.</bean>34.<!-- 总管理类如果将lazy-init='false'那么容器启动就会执行调度程序 -->35.<bean id="startQuertz"lazy-init="false"autowire="no"36.class="org.springframework.scheduling.quartz.SchedulerFactoryBean">37.<property name="triggers">38.<list>39.<ref bean="doTime"/>40.</list>41.</property>42.</bean>43.44.</beans>3. 设置web.xml对Spring加载1.<?xml version="1.0"encoding="UTF-8"?>2.<web-app version="2.5"xmlns="/xml/ns/javaee"3.xmlns:xsi="/2001/XMLSchema-instance"4.xsi:schemaLocation="/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">5.6.<!-- 加载spring -->7.<context-param>8.<param-name>contextConfigLocation</param-name>9.<param-value>10. /WEB-INF/classes/applicationContext*.xml11.</param-value>12.</context-param>13.<servlet>14.<servlet-name>context</servlet-name>15.<servlet-class>16. org.springframework.web.context.ContextLoaderServlet17.</servlet-class>18.<load-on-startup>1</load-on-startup>19.</servlet>20.21.<welcome-file-list>22.<welcome-file>index.html</welcome-file>23.</welcome-file-list>24.</web-app>注意:1.导入quartz-all-1.5.2.jar 下载2.导入spring.jar(我用的是spring2.0以前的版本)下载如果不导入的话org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBeanorg.springframework.scheduling.quartz.CronTriggerBeanorg.springframework.scheduling.quartz.SchedulerFactoryBeanspring中的这三个类找不到,spring不能正常加载,由于第一次使用Quartz,我就是当时忽略了这一点,浪费了很多时间来调配置,其实配置一点没有错误。

Quartz任务调度说明 CronTrigger + Spring

Quartz任务调度说明 CronTrigger + Spring

触发器中两个重要的触发器1,SimpleTrigger :可以精确到毫秒,如果需要让任务只在某个时刻执行一次,或者,在某个时刻开始,然后按照某个时间间隔重复执行例如:public SimpleTrigger(String name, //名称String group, //组名Date startTime, //开始时间Date endTime, //结束时间(控制权高于重复次数属性)为null时直到永远int repeatCount, //重复次数(可能是0)long repeatInterval) //重复间隔(以毫秒为单位)2,CronTrigger :像日历那样按日程来触发任务。

可以指定诸如“每个周五中午”,或者“每个工作日的9:30”或者“从每个周一、周三、周五的上午9:00到上午10:00之间每隔五分钟”这样日程安排来触发。

也可以像SimpleTrigger一样,CronTrigger也有一个startTime以指定日程从什么时候开始,也有一个(可选的)endTime以指定何时日程不再继续.Cron表达式被用来配置CronTrigger实例.Cron表达式是一个由7个子表达式组成的字符串。

每个子表达式都描述了一个单独的日程细节。

这些子表达式用空格分隔,分别表示:秒分钟小时月中的天天周中的天年秒---例如:3/5从第3秒开始每隔5秒触发一次通配符('*')可以被用来表示域中“每个”可能的值'?'字符可以用在day-of-month及day-of-week域中,它用来表示“没有指定值”。

'L'字符可以在day-of-month及day-of-week中使用,L是last的缩写。

如时在day-of-month 中L表示的月的最后一天。

在day-of-week中,表示"当月的最后的周XXX",例如:"6L" 或者"FRIL"都表示本月的最后一个周五。

Quartzspring定时任务开发初步

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

java中spring与Quartz 整合定时任务

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><!--注入要监控的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();}}}使用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 6,12,20 * * ?</value>--><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> <!-- 10 s--></property><property name="repeatInterval"><value>1296000000</value> <!-- 1296000000 6 hours--></property></bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref local="simpleTrigger"/></list></property></bean>一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。

浅谈SpringBoot集成Quartz动态定时任务

浅谈SpringBoot集成Quartz动态定时任务

浅谈SpringBoot集成Quartz动态定时任务SpringBoot⾃带schedule沿⽤的springboot少xml配置的优良传统,本⾝⽀持表达式等多种定时任务注意在程序启动的时候加上@EnableScheduling@Scheduled(cron="0/5 * * * * ?")public void job(){System.out.println("每五秒执⾏⼀次");}为什么要使⽤Quartz多任务情况下,quartz更容易管理,可以实现动态配置执⾏时间表达式:表达式⽰例:集成Quartz如何搭建springboot就不再细说,官⽹和⽹上的教程很多。

maven依赖<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.2.1</version></dependency>测试Job类SchedulerQuartzJob1和SchedulerQuartzJob2代码差不多就不⼀⼀列出package com.yvan.quartz.job;import org.quartz.Job;import org.quartz.JobExecutionContext;import org.quartz.JobExecutionException;/*** 实现Job接⼝* @author yvan**/public class SchedulerQuartzJob1 implements Job{private void before(){System.out.println("任务开始执⾏");}@Overridepublic void execute(JobExecutionContext arg0) throws JobExecutionException {before();System.out.println("开始:"+System.currentTimeMillis());// TODO 业务System.out.println("结束:"+System.currentTimeMillis());after();}private void after(){System.out.println("任务开始执⾏");}}任务调⽤处理将其拆分成两个部分实例化Job,将任务触发器加⼊任务调度中private void startJob1(Scheduler scheduler) throws SchedulerException {// 通过JobBuilder构建JobDetail实例,JobDetail规定只能是实现Job接⼝的实例// JobDetail 是具体Job实例JobDetail jobDetail = JobBuilder.newJob(SchedulerQuartzJob1.class).withIdentity("job1", "group1").build(); // 基于表达式构建触发器CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");// CronTrigger表达式触发器继承于Trigger// TriggerBuilder ⽤于构建触发器实例CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1").withSchedule(cronScheduleBuilder).build();scheduler.scheduleJob(jobDetail, cronTrigger);}private void startJob2(Scheduler scheduler) throws SchedulerException {JobDetail jobDetail = JobBuilder.newJob(SchedulerQuartzJob2.class).withIdentity("job2", "group2").build(); CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/5 * * * ?");CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job2", "group2").withSchedule(cronScheduleBuilder).build();scheduler.scheduleJob(jobDetail, cronTrigger);}对外提供关于动态管理任务的⽅法/*** 开始执⾏所有任务** @throws SchedulerException*/public void startJob() throws SchedulerException {startJob1(scheduler);startJob2(scheduler);scheduler.start();}/*** 获取Job信息** @param name* @param group* @return* @throws SchedulerException*/public String getJobInfo(String name, String group) throws SchedulerException {TriggerKey triggerKey = new TriggerKey(name, group);CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),scheduler.getTriggerState(triggerKey).name());}/*** 修改某个任务的执⾏时间** @param name* @param group* @param time* @return* @throws SchedulerException*/public boolean modifyJob(String name, String group, String time) throws SchedulerException {Date date = null;TriggerKey triggerKey = new TriggerKey(name, group);CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);String oldTime = cronTrigger.getCronExpression();if (!oldTime.equalsIgnoreCase(time)) {CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(cronScheduleBuilder).build();date = scheduler.rescheduleJob(triggerKey, trigger);}return date != null;}/*** 暂停所有任务** @throws SchedulerException*/public void pauseAllJob() throws SchedulerException {scheduler.pauseAll();}/*** 暂停某个任务** @param name* @param group* @throws SchedulerException*/public void pauseJob(String name, String group) throws SchedulerException { JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.pauseJob(jobKey);}/*** 恢复所有任务** @throws SchedulerException*/public void resumeAllJob() throws SchedulerException {scheduler.resumeAll();}/*** 恢复某个任务** @param name* @param group* @throws SchedulerException*/public void resumeJob(String name, String group) throws SchedulerException { JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.resumeJob(jobKey);}/*** 删除某个任务** @param name* @param group* @throws SchedulerException*/public void deleteJob(String name, String group) throws SchedulerException { JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.deleteJob(jobKey);}完整代码package com.yvan.quartz;import java.util.Date;import org.quartz.CronScheduleBuilder;import org.quartz.CronTrigger;import org.quartz.JobBuilder;import org.quartz.JobDetail;import org.quartz.JobKey;import org.quartz.Scheduler;import org.quartz.SchedulerException;import org.quartz.TriggerBuilder;import org.quartz.TriggerKey;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.annotation.Configuration;import com.yvan.quartz.job.SchedulerQuartzJob1;import com.yvan.quartz.job.SchedulerQuartzJob2;/*** 任务调度处理* @author yvan**/@Configurationpublic class QuartzScheduler {// 任务调度@Autowiredprivate Scheduler scheduler;/*** 开始执⾏所有任务** @throws SchedulerException*/public void startJob() throws SchedulerException {startJob1(scheduler);startJob2(scheduler);scheduler.start();}/*** 获取Job信息** @param name* @param group* @return* @throws SchedulerException*/public String getJobInfo(String name, String group) throws SchedulerException {TriggerKey triggerKey = new TriggerKey(name, group);CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);return String.format("time:%s,state:%s", cronTrigger.getCronExpression(),scheduler.getTriggerState(triggerKey).name());}/*** 修改某个任务的执⾏时间** @param name* @param group* @param time* @return* @throws SchedulerException*/public boolean modifyJob(String name, String group, String time) throws SchedulerException { Date date = null;TriggerKey triggerKey = new TriggerKey(name, group);CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);String oldTime = cronTrigger.getCronExpression();if (!oldTime.equalsIgnoreCase(time)) {CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(time);CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(cronScheduleBuilder).build();date = scheduler.rescheduleJob(triggerKey, trigger);}return date != null;}/*** 暂停所有任务** @throws SchedulerException*/public void pauseAllJob() throws SchedulerException {scheduler.pauseAll();}/*** 暂停某个任务** @param name* @param group* @throws SchedulerException*/public void pauseJob(String name, String group) throws SchedulerException {JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.pauseJob(jobKey);}/*** 恢复所有任务** @throws SchedulerException*/public void resumeAllJob() throws SchedulerException {scheduler.resumeAll();}/*** 恢复某个任务** @param name* @param group* @throws SchedulerException*/public void resumeJob(String name, String group) throws SchedulerException {JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.resumeJob(jobKey);}/*** 删除某个任务** @param name* @param group* @throws SchedulerException*/public void deleteJob(String name, String group) throws SchedulerException {JobKey jobKey = new JobKey(name, group);JobDetail jobDetail = scheduler.getJobDetail(jobKey);if (jobDetail == null)return;scheduler.deleteJob(jobKey);}private void startJob1(Scheduler scheduler) throws SchedulerException {// 通过JobBuilder构建JobDetail实例,JobDetail规定只能是实现Job接⼝的实例// JobDetail 是具体Job实例JobDetail jobDetail = JobBuilder.newJob(SchedulerQuartzJob1.class).withIdentity("job1", "group1").build(); // 基于表达式构建触发器CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");// CronTrigger表达式触发器继承于Trigger// TriggerBuilder ⽤于构建触发器实例CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1").withSchedule(cronScheduleBuilder).build();scheduler.scheduleJob(jobDetail, cronTrigger);}private void startJob2(Scheduler scheduler) throws SchedulerException {JobDetail jobDetail = JobBuilder.newJob(SchedulerQuartzJob2.class).withIdentity("job2", "group2").build(); CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/5 * * * ?");CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job2", "group2").withSchedule(cronScheduleBuilder).build();scheduler.scheduleJob(jobDetail, cronTrigger);}}Scheduler 注⼊这⾥采⽤监听spring容器加载完毕后事件,启动任务调⽤将Scheduler交给spring初始化管理package com.yvan.quartz;import org.quartz.Scheduler;import org.quartz.SchedulerException;import org.quartz.SchedulerFactory;import org.quartz.impl.StdSchedulerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.context.ApplicationListener;import org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration;import org.springframework.context.event.ContextRefreshedEvent;@Configurationpublic class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent>{@Autowiredprivate QuartzScheduler quartzScheduler;/*** 初始启动quartz*/@Overridepublic void onApplicationEvent(ContextRefreshedEvent event) {try {quartzScheduler.startJob();System.out.println("任务已经启动...");} catch (SchedulerException e) {e.printStackTrace();}}/*** 初始注⼊scheduler* @return* @throws SchedulerException*/@Beanpublic Scheduler scheduler() throws SchedulerException{SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();return schedulerFactoryBean.getScheduler();}}封装API这⾥封装的API主要是为了⽅便动态管理执⾏任务,当然依赖这些接⼝也可以做⼀个界⾯来更直观的操作管理任务,这个就不再赘述。

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

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

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><!-- 该依赖必加,⾥⾯有sping对schedule的⽀持 --><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分钟执⾏⼀次。

定时任务任务的三种方法

定时任务任务的三种方法

定时任务任务的三种⽅法1,spring整合quartz⽅式,这种⽹上资料太多,简单引⽤⼀下就ok。

<bean id="taskJob" class="com.tyyd.dw.task.DataConversionTask"/><bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="group" value="job_work"/><property name="name" value="job_work_name"/><!--false表⽰等上⼀个任务执⾏完后再开启新的任务--><property name="concurrent" value="false"/><property name="targetObject"><ref bean="taskJob"/></property><property name="targetMethod"><value>run</value></property></bean><!-- 调度触发器 --><bean id="myTrigger"class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"><property name="name" value="work_default_name"/><property name="group" value="work_default"/><property name="jobDetail"><ref bean="jobDetail"/></property><property name="cronExpression"><value>0/5 * * * * ?</value></property></bean><!-- 调度⼯⼚ --><bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref bean="myTrigger"/></list></property></bean>2.spring task⽅式的定时任务(最为简单,功能也简单)<!-- 定时器配置开始--><bean id="task1" class="com.XXX.Task1"></bean><bean id="task2" class="com.XXX.Task2"></bean><task:scheduled-tasks><task:scheduled ref="task1" method="execute" cron="0 */1 * * * ?"/><task:scheduled ref="task2" method="execute" cron="0 */1 * * * ?"/></task:scheduled-tasks><!-- 定时器配置结束-->使⽤的时候,直接写⼀个类,⼀个⽅法就可以了,简单快捷。

Quartz+Spring简单实现定时任务

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>
<!-- cron表达式 -->
<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-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集群环境实现动态定时任务配置【原】

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,将任务持久化到数据中。

分布式定时任务QUARTZ-SPRING分享

分布式定时任务QUARTZ-SPRING分享

分享内容概述
Spring与Quartz的 集成方式
Quartz集群部署和 配置
Quartz基本概念和 原理
分布式定时任务的 实现和注意事项
常见问题及解决方 案
REPORT
CATALOG
DATE
ANALYSIS
SUMMAR Y
02
Quartz定时任务框架 介绍
Quartz概述
01
Quartz是一个开源的作业调度库,它可以让你在
采用基于Quartz的分布式定时任务调度架 构,结合Spring框架提供的管理和配置功 能。
使用Quartz的Scheduler作为任务调度器 ,负责任务的调度和执行。
任务存储
任务执行器
采用数据库作为任务存储介质,实现任务 的持久化和分布式处理。
设计任务执行器接口和实现类,用于处理 不同类型的定时任务。
可扩展性
Quartz支持自定义JobStore和Trigger,可以根据业务需求 进行扩展。
基于Quartz的分布式解决方案设计
数据库设计
使用数据库存储定时任务的配置、执行状态和日 志等信息。需要设计相应的表结构,包括任务配 置表、任务状态表、任务日志表等。
任务调度
使用Quartz的API创建和配置定时任务,包括任 务的执行逻辑、触发条件、并发策略等。可以使 用Spring等框架来简化任务的创建和配置过程。
集群部署
在多个节点上部署Quartz,并配置为集群模式。需 要指定集群中的节点数量和选举算法等参数。
任务监控
通过Quartz提供的API或第三方工具对定时任务 进行监控和管理,包括任务的运行状态、执行结 果、异常处理等。可以使用日志、告警等方式来 通知相关人员。

spring多个定时任务quartz配置

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实现定时任务的配置方法

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类。

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

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><!-- 定义每日触发时间日榜,总榜更新时间每日凌晨1点--> <bean id="doTimeDay"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="dayJobtask" /></property><!-- cron表达式--><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><!-- cron表达式--><property name="cronExpression"><value>0 0 1 ? * *</value></property></bean><!-- 定义每周触发时间周榜更新时间每周1凌晨2点--><bean id="doTimeWeek"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="weekJobtask" /></property><!-- cron表达式--><property name="cronExpression"><value>0 0 2 ? * MON</value></property></bean><!-- 定义每月触发时间月榜更新时间每月1日凌晨3点--><bean id="doTimeMonth"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="monthJobtask" /></property><!-- cron表达式--><property name="cronExpression"><value>0 0 3 1 * ?</value></property></bean><!-- 定义政府,政策,学术每月更新时间每月1日凌晨3:30--> <bean id="doGov"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"><ref bean="govJobtask" /></property><!-- cron表达式--><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><!-- cron表达式--><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><!-- cron表达式--><property name="cronExpression"><value>0 30 3 1 * ?</value></property></bean><!-- 总管理类如果将lazy-init='false'那么容器启动就会执行调度程序--> <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"> <!-- wait 10 seconds before starting repeated execution --><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><!-- see the example above --><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的整合

SpringBoot中的定时任务与Quartz的整合

SpringBoot中的定时任务与Quartz的整合SpringBoot集成Quartz定时任务Quartz : 就是在指定的时间执⾏⼀次或者循环执⾏,在项⽬的开发中有时候会需要的, 还是很有⽤的.SpringBoot内置的定时1. 添加依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency>2. 启动类上添加注解@SpringBootApplication@EnableSchedulingpublic class SpringbootQuartzApplication {}3. 创建定时执⾏的任务类(两种⽅式)⽅式⼀:@Componentpublic class SchedulerTask {private int count = 0;/*** @Author Smith* @Description 设置没6秒执⾏⼀次* @Date 14:23 2019/1/24* @Param* @return void**/@Scheduled(cron = "*/6 * * * * ?")private void process(){System.out.println("this is scheduler task running " + (count++));}}⽅式⼆:@Componentpublic class SchedulerTask2 {private static final SimpleDateFormat dateFormat =new SimpleDateFormat("HH:mm:ss");/*** @Author Smith* @Description 设置没6秒执⾏⼀次* @Date 14:22 2019/1/24* @Param* @return void**/@Scheduled(fixedRate = 6000)private void process(){System.out.println("now time is " + dateFormat.format(new Date()));}}参数说明@Scheduled 参数可以接受两种定时的设置,⼀种是我们常⽤的 cron="*/6 * * * * ?",⼀种是 fixedRate = 6000,两种都可表⽰固定周期执⾏定时任务。

SpringBoot之旅--定时任务两种(SpringSchedule与Quartz整合)实现

SpringBoot之旅--定时任务两种(SpringSchedule与Quartz整合)实现

SpringBoot之旅--定时任务两种(SpringSchedule与Quartz整合)实现相关⽂章前⾔最近在项⽬中使⽤到定时任务,之前⼀直都是使⽤Quartz 来实现,最近看Spring 基础发现其实Spring 提供 Spring Schedule 可以帮助我们实现简单的定时任务功能。

下⾯说⼀下两种⽅式在Spring Boot 项⽬中的使⽤。

Spring Schedule 实现定时任务Spring Schedule 实现定时任务有两种⽅式 1. 使⽤XML配置定时任务, 2. 使⽤ @Scheduled 注解。

因为是Spring Boot 项⽬可能尽量避免使⽤XML配置的形式,主要说注解的形式.Spring Schedule 提供三种形式的定时任务:固定等待时间 @Scheduled(fixedDelay = 时间间隔 )@Componentpublic class ScheduleJobs {public final static long SECOND = 1 * 1000;FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");@Scheduled(fixedDelay = SECOND * 2)public void fixedDelayJob() throws InterruptedException {TimeUnit.SECONDS.sleep(2);System.out.println("[FixedDelayJob Execute]"+fdf.format(new Date()));}}固定间隔时间 @Scheduled(fixedRate = 时间间隔 )@Componentpublic class ScheduleJobs {public final static long SECOND = 1 * 1000;FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");@Scheduled(fixedRate = SECOND * 4)public void fixedRateJob() {System.out.println("[FixedRateJob Execute]"+fdf.format(new Date()));}}Corn表达式 @Scheduled(cron = Corn表达式)@Componentpublic class ScheduleJobs {public final static long SECOND = 1 * 1000;FastDateFormat fdf = FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss");@Scheduled(cron = "0/4 * * * * ?")public void cronJob() {System.out.println("[CronJob Execute]"+fdf.format(new Date()));}}Spring Boot 整合 Quartz 实现定时任务添加Maven依赖<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-context-support</artifactId></dependency>Spring Boot 整合 QuartzSpring 项⽬整合 Quartz 主要依靠添加 SchedulerFactoryBean 这个 FactoryBean ,所以在maven 依赖中添加 spring-context-support 。

SpringBoot中使用Quartz管理定时任务的方法

SpringBoot中使用Quartz管理定时任务的方法

SpringBoot中使⽤Quartz管理定时任务的⽅法定时任务在系统中⽤到的地⽅很多,例如每晚凌晨的数据备份,每⼩时获取第三⽅平台的 Token 信息等等,之前我们都是在项⽬中规定这个定时任务什么时候启动,到时间了便会⾃⼰启动,那么我们想要停⽌这个定时任务的时候,就需要去改动代码,还得启停服务器,这是⾮常不友好的事情直⾄遇见 Quartz,利⽤图形界⾯可视化管理定时任务,使得我们对定时任务的管理更加⽅便,快捷⼀、Quartz 简介Quartz是⼀个开源的作业调度框架,它完全由Java写成,并设计⽤于J2SE和J2EE应⽤中。

它提供了巨⼤的灵活性⽽不牺牲简单性。

你能够⽤它来为执⾏⼀个作业⽽创建简单的或复杂的调度。

它有很多特征,如:数据库⽀持,集群,插件,EJB作业预构建,JavaMail及其它,⽀持cron-like表达式等等。

⼆、开发前戏1、引⼊ maven 依赖<!-- web⽀持 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- Quartz 定时任务 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId></dependency>这⾥引⼊了 web 的依赖,以及 Quartz 的依赖,其余依赖请根据需求⾃⾏引⼊2、创建数据表数据模型:SQL语句:drop table if exists sys_quartz;/*==============================================================*//* Table: sys_quartz *//*==============================================================*/create table sys_quartz(id bigint(20) not null auto_increment comment '主键id',class_name varchar(32) comment '任务类名',cron_expression varchar(32) comment 'cron表达式',param varchar(32) comment '参数',descript varchar(11) comment '描述',quartz_status varchar(255) comment '启动状态(0--启动1--停⽌)',create_time datetime comment '创建时间',create_user bigint(20) comment '创建⼈',status tinyint(1) default 0 comment '状态(0--正常1--停⽤)',del_flag tinyint(1) default 0 comment '删除状态(0,正常,1已删除)',primary key (id))type = InnoDB;alter table sys_quartz comment '定时任务信息表';三、开发进⾏中1、创建实体类import com.baomidou.mybatisplus.annotation.*;import com.baomidou.mybatisplus.extension.activerecord.Model;import mon.annotation.Dict;import io.swagger.annotations.ApiModel;import io.swagger.annotations.ApiModelProperty;import lombok.Data;import lombok.EqualsAndHashCode;import lombok.experimental.Accessors;import java.io.Serializable;/*** <p>* 定时任务信息表* </p>** @author lizhou* @since 2020-07-21*/@Data@EqualsAndHashCode(callSuper = false)@Accessors(chain = true)@TableName("sys_quartz")@ApiModel(value="SysQuartz对象", description="定时任务信息表")public class SysQuartz extends Model<SysQuartz> {@ApiModelProperty(value = "主键id")@TableId(value = "id", type = IdType.AUTO)private Long id;@ApiModelProperty(value = "任务类名")@TableField("class_name")private String className;@ApiModelProperty(value = "cron表达式")@TableField("cron_expression")private String cronExpression;@ApiModelProperty(value = "参数")@TableField("param")private String param;@ApiModelProperty(value = "描述")@TableField("descript")private String descript;@ApiModelProperty(value = "启动状态(0--启动1--停⽌)")@TableField("quartz_status")private Integer quartzStatus;@ApiModelProperty(value = "状态(0--正常1--停⽤)")@TableField("status")private Integer status;@ApiModelProperty(value = "删除状态(0--未删除1--已删除)")@TableField("del_flag")@TableLogicprivate Integer delFlag;@ApiModelProperty(value = "创建者")@TableField("create_user")private Long createUser;@ApiModelProperty(value = "创建时间")@TableField("create_time")private String createTime;@Overrideprotected Serializable pkVal() {return this.id;}}2、实现定时任务的 CRUD下⾯我们就要完成定时任务的新增、修改、删除、启停等基本操作了,由于不是很复杂,这⾥的代码就不贴出来了,贴⼏张图吧列表页:新增页:四、定时任务1、定时任务类我们把定时任务都放在 job 包下⾯,⼀个定时任务就是⼀个⽂件,写⼀个测试的类 TestJob.javaimport mon.utils.DateUtils;import lombok.extern.slf4j.Slf4j;import org.quartz.Job;import org.quartz.JobExecutionContext;import org.quartz.JobExecutionException;/*** @ClassName TestJob* 测试定时任务* @Author Lizhou* @Date 2020-07-21 10:58:58**/@Slf4jpublic class TestJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {System.out.println("定时任务启动:" + DateUtils.getYmdHms());}}TestJob 这个类实现了 Job 接⼝,实现了 execute ⽅法,这⾥还可以接收参数这个⽂件在 com.zyxx.sbm.job 包下⾯,那么在页⾯新增定时任务的时候,就需要填写任务类名为:com.zyxx.sbm.job.TestJob cron 表达式的知识这⾥就不⼀⼀介绍了2、页⾯添加定时任务那么我们的任务类名就是:com.zyxx.sbm.job.TestJobcron 表达式:*/2 * * * * ?,表⽰两秒钟执⾏⼀次参数:我们没有传⼊参数3、后台添加定时任务package com.zyxx.sbm.service.impl;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import mon.shiro.SingletonLoginUtils;import mon.utils.DateUtils;import yTableResult;import mon.utils.ResponseResult;import com.zyxx.sbm.entity.SysQuartz;import com.zyxx.sbm.mapper.SysQuartzMapper;import com.zyxx.sbm.service.SysQuartzService;import lombok.extern.slf4j.Slf4j;import ng3.StringUtils;import org.quartz.*;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;/*** <p>* 定时任务信息表服务实现类* </p>** @author lizhou* @since 2020-07-21*/@Slf4j@Servicepublic class SysQuartzServiceImpl extends ServiceImpl<SysQuartzMapper, SysQuartz> implements SysQuartzService {@Autowiredprivate Scheduler scheduler;/*** 添加定时任务*/@Overridepublic ResponseResult add(SysQuartz sysQuartz) {QueryWrapper<SysQuartz> queryWrapper = new QueryWrapper<>();queryWrapper.eq("class_name", sysQuartz.getClassName());List<SysQuartz> sysQuartzList = list(queryWrapper);if (null != sysQuartzList && !sysQuartzList.isEmpty()) {return ResponseResult.getInstance().error("该任务类名已经存在");}sysQuartz.setCreateTime(DateUtils.getYmdHms());sysQuartz.setCreateUser(SingletonLoginUtils.getUserId());save(sysQuartz);// 启动if (0 == sysQuartz.getQuartzStatus()) {this.schedulerAdd(sysQuartz.getClassName().trim(), sysQuartz.getCronExpression().trim(), sysQuartz.getParam());}return ResponseResult.getInstance().success();}/*** 添加定时任务** @param className* @param cronExpression* @param param*/@Overridepublic void schedulerAdd(String className, String cronExpression, String param) {try {// 启动调度器scheduler.start();// 构建job信息JobDetail jobDetail = JobBuilder.newJob(getClass(className).getClass()).withIdentity(className).usingJobData("param", param).build(); // 表达式调度构建器(即任务执⾏的时间)CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);// 按新的cronExpression表达式构建⼀个新的triggerCronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(className).withSchedule(scheduleBuilder).build();scheduler.scheduleJob(jobDetail, trigger);} catch (SchedulerException e) {log.error(e.getMessage());} catch (RuntimeException e) {log.error(e.getMessage());} catch (Exception e) {log.error(e.getMessage());}}/*** 删除定时任务** @param className*/@Overridepublic void schedulerDelete(String className) {try {scheduler.pauseTrigger(TriggerKey.triggerKey(className));scheduler.unscheduleJob(TriggerKey.triggerKey(className));scheduler.deleteJob(JobKey.jobKey(className));} catch (Exception e) {log.error(e.getMessage(), e);}}private static Job getClass(String className) throws Exception {Class<?> class1 = Class.forName(className);return (Job) class1.newInstance();}}需要注⼊ Scheduler 对象,使⽤该对象开启或停⽌定时任务在启动定时任务之前,我们应先删除该任务类名开启的定时任务,防⽌该任务类名已经添加过了// 删除定时任务schedulerDelete(sysQuartz.getClassName().trim());// 添加定时任务schedulerAdd(sysQuartz.getClassName().trim(), sysQuartz.getCronExpression().trim(), sysQuartz.getParam());添加定时任务,传⼊任务类名,cron 表达式,参数停⽌定时任务,只需要:scheduler.pauseJob(JobKey.jobKey(sysQuartz.getClassName().trim()));根据任务类名,停⽌定时任务即可五、开发测试启动项⽬,在管理界⾯,开启定时任务,即可在控制台看到打印的信息表⽰我们的定时任务已经启动成功了六、优化建议当我们添加了定时任务并启动后,重新启动项⽬的时候,定时任务却不会⾃动启动,这时候,我们就需要在项⽬启动的时候做⼀些事情了,也就是系统启动任务不清楚的同学可以复习⼀下之前我的博客【SpringBoot】⼗九、SpringBoot中实现启动任务import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.zyxx.sbm.entity.SysQuartz;import com.zyxx.sbm.service.SysQuartzService;import org.springframework.beans.factory.annotation.Autowired;import mandLineRunner;import org.springframework.core.annotation.Order;import ponent;import java.util.List;/*** @ClassName SystemStartTask* 项⽬启动任务--启动定时任务* @Author Lizhou* @Date 2020-07-21 12:56:56**/@Component@Order(100)public class SystemQuartzStartTask implements CommandLineRunner {@Autowiredprivate SysQuartzService sysQuartzService;@Overridepublic void run(String... args) throws Exception {// 查询启动的定时任务QueryWrapper<SysQuartz> queryWrapper = new QueryWrapper<>();queryWrapper.eq("status", 0);queryWrapper.eq("quartz_status", 0);List<SysQuartz> list = sysQuartzService.list(queryWrapper);if (null != list && !list.isEmpty()) {for (SysQuartz item : list) {// 删除定时任务sysQuartzService.schedulerDelete(item.getClassName().trim());// 添加定时任务sysQuartzService.schedulerAdd(item.getClassName().trim(), item.getCronExpression().trim(), item.getParam());}}}}从数据库查询出启动的定时任务,并将他们添加到定时任务启动中,这样项⽬⼀启动时,就会⾃动启动我们定义的定时任务了最后任务类名的正则表达式/^[a-zA-Z]+(\.([a-zA-Z])+)+$/cron 表达式的验证使⽤正则太⿇烦,可以使⽤ Quartz ⾃带验证⽅法CronExpression.isValidExpression(cron)SpringBoot 中使⽤ Quartz 管理定时任务的学习就到这⼉了,其实也并不难理解,相⽐于之前⽤的定时任务是不是好很多了呢,别忘了最后加上系统启动任务哦总结到此这篇关于SpringBoot中使⽤Quartz管理定时任务的⽂章就介绍到这了,更多相关SpringBoot管理定时任务内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持!。

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

Quartz结合SPRING多任务定时调用定义两个被调度的类public class QuartzJob{public void work(){System.out.println(Spring Quartz的任务调度1被调用!");//定时调用的业务逻辑}}public class QuartzJob2{public void work(){System.out.println(Spring Quartz的任务调度2被调用!");//定时调用的业务逻辑}}Spring的配置文件<?xml version="1.0" encoding="UTF-8"?><!-- - Application context definition for JPetStore's business layer. - Containsbean references to the transaction manager and to the DAOs in - dataAccessContext-local/jta.xml(see web.xml's "contextConfigLocation"). --><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.0.xsd/schema/aop/schema/aop/spring-aop-2.0.xsd/schema/tx/schema/tx/spring-tx-2.0.xsd"><!-- 要调用的工作类 --><bean id="quartzJob"class="com.writchie.quartz.QuartzJob"></bean><bean id="quartzJobTwo"class="com.writchie.quartz.QuartzJobTwo"></bean><!-- 可继续加新的任务 --><!-- 要调用的工作类结束 --><!-- 定义调用对象和调用对象的方法 --><bean id="jobtask"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailF actoryBean"><!-- 调用的类 --><property name="targetObject"><ref bean="quartzJob"/></property><!-- 调用类中的方法 --><property name="targetMethod"><value>work</value></property></bean><bean id="jobtask2"class="org.springframework.scheduling.quartz.MethodInvokingJobDetailF actoryBean"><!-- 调用的类 --><property name="targetObject"><ref bean="quartzJobTwo"/></property><!-- 调用类中的方法 --><property name="targetMethod"><value>work</value></property></bean><!-- 可继续加新的 --><!-- 定义调用对象和调用对象的方法结束 --><!-- 定义触发时间 --><bean id="doTime"class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail"><ref bean="jobtask"/></property><!-- cron表达式此处定义为一直触发执行任务 --><property name="cronExpression"><value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value> </property></bean><bean id="doTime2"class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail"><ref bean="jobtask2"/></property><!-- cron表达式此处定义周一至周日的下午13:15触发--> <property name="cronExpression"><value>0 15 13 ? * SUN-SAT</value></property></bean><!-- 可继续加新的 --><!-- 定义触发时间结束 --><!-- 总管理类如果将lazy-init='false'那么容器启动就会执行调度程序--><bean id="startQuertz" lazy-init="false" autowire="no"class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"><list><ref bean="doTime"/><ref bean="doTime2"/><!-- 可继续加新的 --></list></property></bean><!-- 总管理类结束 --></beans>测试程序import org.springframework.context.ApplicationContext;importorg.springframework.context.support.ClassPathXmlApplicationContext; public class QuartzService {public static void main(String[] args) {System.out.println("测试任务调度开始...");ApplicationContext context = new ClassPathXmlApplicationContext( "applicationContext.xml");// 如果配置文件中将startQuertz bean的lazy-init设置为false 则不用实例化// context.getBean("startQuertz");System.out.print("测试任务调度结束!\n");}}如果是web程序可以在web.xml 加载spring配置文件。

项目启动时启动。

关于cron表达式(参考资料):Cron 表达式包括以下7 个字段:秒分小时月内日期月周内日期年(可选字段)特殊字符Cron 触发器利用一系列特殊字符,如下所示:反斜线(/)字符表示增量值。

例如,在秒字段中“5/15”代表从第5 秒开始,每15 秒一次。

问号(?)字符和字母L 字符只有在月内日期和周内日期字段中可用。

问号表示这个字段不包含具体值。

所以,如果指定月内日期,可以在周内日期字段中插入“?”,表示周内日期值无关紧要。

字母L 字符是last 的缩写。

放在月内日期字段中,表示安排在当月最后一天执行。

在周内日期字段中,如果“L”单独存在,就等于“7”,否则代表当月内周内日期的最后一个实例。

所以“0L”表示安排在当月的最后一个星期日执行。

在月内日期字段中的字母(W)字符把执行安排在最靠近指定值的工作日。

把“1W”放在月内日期字段中,表示把执行安排在当月的第一个工作日内。

井号(#)字符为给定月份指定具体的工作日实例。

把“MON#2”放在周内日期字段中,表示把任务安排在当月的第二个星期一。

星号(*)字符是通配字符,表示该字段可以接受任何可能的值。

字段允许值允许的特殊字符秒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触发每天早上6点0 6 * * *每两个小时0 */2 * * *晚上11点到早上8点之间每两个小时,早上八点0 23-7/2,8 * * *每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点0 11 4 * 1-31月1日早上4点0 4 1 1 *。

相关文档
最新文档