Quartz+spring定时器实例用

合集下载

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执行定时任务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定时任务的简单实例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项⽬，即可。

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

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

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

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

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

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

⼆、开发前戏1、引⼊ maven 依赖<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>这⾥引⼊了 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管理定时任务内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

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

Spring+Quartz实现定时任务的配置方法第一步：.导入相关的jar包(1)spring.jar(2)quartz-1.6.0.jar(3)相关包commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar第二步：创建一个类来定义工作定义Quartz工作的第一步是创建一个类来定义工作。

要做到这一点，你需要从Spring 的QuartzJobBean中派生子类。

第三步：配置JobDetail值得注意的是，在这里你并没有直接声明一个TopTenTask Bean，而是声明了一个JobDetailBean。

这是使用Quartz时的一个特点。

JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。

使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。

JobDetail的jobDataAsMap属性接受一个java.util.Map，其中包含了需要设置给jobClass的各种属性。

在这里，这个map包含了一个键值为timeout。

当JobDetailBean实例化时，它会将5注入到EmailReportJob的timeout属性中。

第四步：配置Trigger工作已经被定义好了，接下来你需要调度这个工作。

Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。

Spring提供了两个触发器，SimpleTriggerBean和CronTriggerBean。

SimpleTriggerBean与ScheduledTimerTask类似。

你可以用它来指定一个工作应该以怎样的频度运行，以及（可选地）在第一次运行工作之前应该等待多久。

例如，要调度报表工作每24小时运行一次，第一次在1小时之后开始运行，可以按照以下方式进行声明：<bean id="topTenTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail"><ref bean="topTenTask"/></property><property name="startDelay"><value>3600000</value></property><property name="repeatInterval"><value>86400000</value></property></bean>属性jobDetail装配了将要被调度的工作，在这个例子中是topTenTask Bean。

Spring Quartz定时器的动态调度

Spring Quartz定时器的动态调度众所周知spring的Quartz定时器的功能非常强大，可以在特定的年月日小时分秒的时间点触发时间，完成事件的调度，就像windows中得计划任务一样。

下面看一个典型的Quartz定时器的实现：1、首先实现一个用于被执行的类，这个类用于被定时器调度，这个类不需要继承任何类或者接口，代码如下：public TestQuartz{public void doSomething(){//TODO}}2、spring配置文件，具体配置<bean id="testQuarzt"class="test.testQuarzt"/><bean id="testQuartzJob"class="org.springframework.scheduling.quartz.MethodInvokingJobDet ailFactoryBean"><property name="targetObject"ref="testQuarzt"/><property name="targetMethod"value="doSomething"/><property name="concurrent"value="false"/></bean><bean id="testTrigger"class="org.springframework.scheduling.quartz.CronTriggerBean"> <property name="jobDetail"ref="testQuartzJob"/><property name="cronExpression"><value>006**?<value><property><bean><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"><list><ref bean="testTrigger"/></list></property></bean>这样一来，一个简单的Spring Quartz定时器就完成了，这个定时器会在每天早上6点去调testQuarzt类中得doSomething方法，至于为什么是早上六点钟将在最后解释。

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定时任务(整合了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。

quartz实现定时功能实例详解（servlet定时器配置方法）

quartz实现定时功能实例详解（servlet定时器配置⽅法）复制代码代码如下:public class TestJob implements Job{public TestJob(){}public void execute(JobExecutionContext arg0) throws JobExecutionException{String name = context.getJobDetail().getJobDataMap().getString("name");System.out.println("job executing..."+name); }}public class QuartzTest{public static void main(String[] args){QuartzTest test = new QuartzTest();try{test.startSchedule();}catch (Exception e){e.printStackTrace();}}public void startSchedule() throws Exception{Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();JobDetail jobDetail =new JobDetail("testJob", Scheduler.DEFAULT_GROUP, TestJob.class);//结束时间long end = System.currentTimeMillis() + 9000L;//执⾏10次，每3秒执⾏⼀次，到9秒后结束SimpleTrigger trigger = new SimpleTrigger("test",null,new Date(),new Date(end),10,3000L);scheduler.scheduleJob(jobDetail, trigger);scheduler.start();}}执⾏上⾯这个类基本实现了⼀个简单的定时程序。

springquartz定时器

springquartz定时器说到定时器，在现实⽣活肯定有很多地⽅都需要的，⽐如，股票的刷新啦、⼿机app⾥的天⽓状态啦等等。

万能的java肯定也是可以实现定时器功能的，但是，纯粹的java定时器，是有点缺陷的，⽐如，不能随着服务器的部署或者重启⽽⾃动启动，⽽且，如果是复杂的逻辑，⽐如我只希望⼯作⽇执⾏，周末就不执⾏，这样的case使⽤java定时器就不能实现，或者很难实现了。

所以，这⾥就使⽤⼀个叫quartz的定时器。

我的环境是JDK1.7Tomcat 7quartz 1.8.5spring 3.0.2实现步骤1.编写⾃⼰的任务类因为只是简单⽰例，就写的很简单了package com.zy.timer;public class HotWaterTask{private static Long lastTime = System.currentTimeMillis();public void execute(){Long nowTime = System.currentTimeMillis();System.out.println("定时器执⾏，间隔" + (nowTime - lastTime )+"毫秒");lastTime = nowTime;}}2.添加需要的spring的jar和quartz的jar3.指定加载spring⽂件因为我们是web项⽬，所以，我们就在web.xm⾥配置spring的xml⽂件位置<context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext.xml</param-value></context-param><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener-class></listener>4.配置applicationContext.xml的定时器<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:util="/schema/util"xmlns:p="/schema/p"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-3.0.xsd/schema/util /schema/util/spring-util-3.0.xsd/schema/tx /schema/tx/spring-tx-3.0.xsd/schema/aop /schema/aop/spring-aop-3.0.xsd"><bean id="qtzJob" class="com.zy.timer.HotWaterTask"/><bean id="qtzJobMethod" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject"><ref bean="qtzJob"/> </property><property name="targetMethod"> <value>execute</value></property></bean><bean id="qtzJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail" ref="qtzJobMethod"></property> <property name="cronExpression" value="0/5 * * * * ?"></property> </bean><bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"> <list><ref bean="qtzJobTrigger"/> </list></property></bean></beans>5.运⾏效果因为机器的配置或者内存使⽤等情况，⽆法精确到毫秒，但是误差在⼏毫秒之内，完全是我们能接受的了！。

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：标注启动定时任务。

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

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是⼀款功能强⼤的任务调度器，可以实现较为复杂的调度功能，如每⽉⼀号执⾏、每天凌晨执⾏、每周五执⾏等等，还⽀持分布式调度。

本⽂使⽤Springboot+Mybatis+Quartz实现对定时任务的增、删、改、查、启⽤、停⽤等功能。

并把定时任务持久化到数据库以及⽀持集群。

Quartz的3个基本要素1. Scheduler：调度器。

所有的调度都是由它控制。

2. Trigger：触发器。

决定什么时候来执⾏任务。

3. JobDetail & Job： JobDetail定义的是任务数据，⽽真正的执⾏逻辑是在Job中。

使⽤JobDetail + Job⽽不是Job，这是因为任务是有可能并发执⾏，如果Scheduler直接使⽤Job，就会存在对同⼀个Job实例并发访问的问题。

⽽JobDetail & Job ⽅式，sheduler每次执⾏，都会根据JobDetail创建⼀个新的Job实例，这样就可以规避并发访问的问题。

如何使⽤Quartz1.添加依赖<dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><version>2.2.3</version></dependency><dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz-jobs</artifactId><version>2.2.3</version></dependency>2.创建配置⽂件在maven项⽬的resource⽬录下创建quartz.propertiesorg.quartz.scheduler.instanceName = MySchedulerorg.quartz.scheduler.instanceId = AUTOorg.quartz.scheduler.rmi.export = falseorg.quartz.scheduler.rmi.proxy = falseorg.quartz.scheduler.wrapJobExecutionInUserTransaction = false#线程池配置org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPoolorg.quartz.threadPool.threadCount = 10org.quartz.threadPool.threadPriority = 5org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true#持久化配置org.quartz.jobStore.misfireThreshold = 50000org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX#⽀持集群org.quartz.jobStore.isClustered = trueeProperties:trueorg.quartz.jobStore.clusterCheckinInterval = 15000#使⽤weblogic连接Oracle驱动org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.weblogic.WebLogicOracleDelegate#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegateorg.quartz.jobStore.tablePrefix = QRTZ_org.quartz.jobStore.dataSource = qzDS#数据源连接信息，quartz默认使⽤c3p0数据源可以被⾃定义数据源覆盖org.quartz.dataSource.qzDS.driver = oracle.jdbc.driver.OracleDriverorg.quartz.dataSource.qzDS.URL = jdbc:oracle:thin:@localhost:1521/XEer = rootorg.quartz.dataSource.qzDS.password = 123456org.quartz.dataSource.qzDS.maxConnections = 10说明：在使⽤quartz做持久化的时候需要⽤到quartz的11张表，可以去quartz官⽹下载对应版本的quartz，解压打开docs/dbTables⾥⾯有对应数据库的建表语句。

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 以⽰⽀持谢谢参考。

quartz定时任务实例

quartz定时任务实例⼀、spring注解⽅式import org.springframework.scheduling.annotation.Scheduledclass XXX{@Scheduled(cron="0 */2 * * * ?") //这⾥是两分钟触发⼀次public void METHOD(){//⽅法要做的事}}⼆、XML⽅式<?xml version="1.0"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "/dtd/spring-beans.dtd"> <beans><bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="quartzProperties"><props><prop key="org.quartz.jobStore.class">org.quartz.simpl.RAMJobStore</prop></props></property><property name="triggers"><list><ref bean="XXXTrigger"/></list></property></bean><bean id="taskJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject" ref="XXX" /> //要调⽤的对象<property name="targetMethod" value="METHOD" />//要调⽤的⽅法<property name="concurrent" value="false" /></bean><!-调⽤对应触发器-><bean id="XXXTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail" ref="taskJob" />//要调度的任务对象BEAN<property name="cronExpression" value="0 */2 * * * " />//每两分钟执⾏⼀次</bean><bean id="XXX" class="com.xx.xx.xx.task.xxxQuartz"/></beans>。

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

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.29.<property name="cronExpression">30.31.<value>0 10/20 * * * ?</value>32.</property>33.</bean>34.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.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，我就是当时忽略了这一点，浪费了很多时间来调配置，其实配置一点没有错误。

3. 你会问为什么用spring后就不用quartz.propertiesquartz-jobsxml这两个文件了么？我回答：是的，它会自动找到quartz包中默认的这两个文件，如果你有特殊需要，也可以自己定义这两个文件。

附：quartz.properties1.#2.# Configure Main Scheduler Properties3.#4..quartz.scheduler.instanceName = TestScheduler.quartz.scheduler.instanceId = one7.8.#9.# Configure ThreadPool10.#11..quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool.quartz.threadPool.threadCount = 5.quartz.threadPool.threadPriority = 415.16.#17.# Configure JobStore18.#19.20.#org.quartz.jobStore.misfireThreshold = 500021.22.#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore23.24.# ===========================================================================25.# Configure SchedulerPlugins ===============================================26.# ===========================================================================27.#org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingTriggerHistoryPlugin28.#org.quartz.plugin.triggHistory.triggerFiredMessage = Trigger {1}.{0} firedjob {6}.{5} at: {4, date, HH:mm:ss MM/dd/yyyy}29.#org.quartz.plugin.triggHistory.triggerCompleteMessage = Trigger {1}.{0} completed firing job {6}.{5} at {4, date, HH:mm:ss MM/dd/yyyy} with resulting t rigger instruction code: {9}30..quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.JobInitializationPlugin.quartz.plugin.jobInitializer.fileName =quartz_jobs.xml.quartz.plugin.jobInitializer.overWriteExistingJobs = false.quartz.plugin.jobInitializer.failOnFileNotFound = true35..quartz.plugin.shutdownhook.class = org.quartz.plugins.management.ShutdownHookPlugin.quartz.plugin.shutdownhook.cleanShutdown = true系统会根据配置文件找到quartz_jobs.xml。