【SpringBoot】廿五、SpringBoot中使用Quartz管理定时任务

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

SpringBoot之旅--定时任务两种（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定时任务的简单实例POM.XML⽂件<!-- 定时器任务 quartz需要导⼊的坐标 --><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项⽬，即可。

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管理定时任务内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

浅谈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三种定时任务实现方式在Spring Boot项目中，实现定时任务是常见需求。

Spring Boot提供了多种灵活的方式来实现定时任务，包括基于注解的方式、基于接口的方式以及使用外部任务调度工具等。

定时任务作为一种系统调度工具，在一些需要有定时作业的系统中应用广泛，如每逢某个时间点统计数据、在将来某个时刻执行某些动作...定时任务在主流开发语言均提供相应的API供开发者调用，在Java中，实现定时任务有很多种方式，原生的方式实现一个完整定时任务需要由Timer、TimerTask两个类，Timer 是定时器类，用来按计划开启后台线程执行指定任务，TimerTask一个抽象类，它的子类代表一个可以被Timer计划的任务。

除此之外，还可以用ScheduledExecutorService类或者使用第三方jar库Quartz，其中Quartz是一个优秀的定时任务框架，发展至今已经非常成熟，以致后来其他的定时任务框架的核心思想或底层大多源于Quartz。

springboot作为Java的一种开发框架，在springboot项目中实现定时任务不仅可以使用Java提供的原生方式，还可以使用springboot提供的定时任务API。

本文将详细介绍三种常用的Spring Boot定时任务实现方式，并提供相应的例子代码。

1. 基于注解的方式（@Scheduled）使用@Scheduled注解是实现Spring Boot定时任务最简单直接的方式。

首先，你需要在Spring Boot的启动类或者配置类上添加@EnableScheduling注解来启用定时任务支持。

然后，在需要定时执行的方法上添加@Scheduled注解，并指定cron表达式或固定间隔。

例子代码：在上面的代码中，@Scheduled注解分别使用了cron表达式和固定频率（fixedRate）两种方式来定义定时任务。

需要注意的是，@EnableScheduling 注解只需要在Spring Boot的启动类或配置类上添加一次。

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实现quartz定时任务可视化管理功能前⾔在实际框架或产品开发过程中，springboot中集成quarzt⽅式基本是以job和trigger的bean对象⽅式直接硬编码完成的，例如以下代码⽰例。

对于系统内定义的所有定时任务类型，具体执⾏类，执⾏策略，运⾏状态都没有⼀个动态全局的管理，所有决定将quartz做成可视化配置管理，便于统⼀管理，也降低了使⽤门槛，只需要关⼼job类的实现即可@Beanpublic JobDetail SMSJobDetail() {return JobBuilder.newJob(SMSJob.class).withIdentity("SMSJob").storeDurably().build();}// 把jobDetail注册到trigger上去@Beanpublic Trigger myJobTrigger() {SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever();return TriggerBuilder.newTrigger().forJob(SMSJobDetail()).withIdentity("myJobTrigger").withSchedule(scheduleBuilder).build();}表结构⽤于存储quartz配置DROP TABLE IF EXISTS `f_quartztask`;CREATE TABLE `f_quartztask` (`TaskID` varchar(50) NOT NULL,`TaskName` varchar(200) DEFAULT NULL,`TaskType` int(11) DEFAULT NULL,`TaskTag` varchar(100) DEFAULT NULL,`JobClassPath` varchar(200) DEFAULT NULL,`ExecutePeroid` int(11) DEFAULT NULL,`ExecuteUnit` int(11) DEFAULT NULL,`CornExpress` varchar(200) DEFAULT NULL,`Enviroment` varchar(50) DEFAULT NULL,`TaskStatus` int(11) DEFAULT NULL,`SortNum` int(11) DEFAULT NULL,`Remark` varchar(500) DEFAULT NULL,PRIMARY KEY (`TaskID`)) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;枚举类public class QuartzEnum {public enum TaskType implements IConvertEnumToCodeItem {Cycle(10, "循环任务"), Corn(20, "Corn表达式任务");private int _value;private String _name;private TaskType(int value, String name) {set_value(value);set_name((name));}public int get_value() {return _value;}public void set_value(int _value) {this._value = _value;}public String get_name() {return _name;}public void set_name(String _name) {this._name = _name;}@Overridepublic String toString() {return _name;}@Overridepublic String getCodeName() {return "Quartz任务类别";}}public enum ExecuteUnit implements IConvertEnumToCodeItem {Second(10, "秒"), Minute(20, "分"), Hour(30, "时");private int _value;private String _name;private ExecuteUnit(int value, String name) {set_value(value);set_name((name));}public int get_value() {return _value;}public void set_value(int _value) {this._value = _value;}public String get_name() {return _name;}public void set_name(String _name) {this._name = _name;}@Overridepublic String toString() {return _name;@Overridepublic String getCodeName() {return "Quartz间隔单位";}}public enum TaskStatus implements IConvertEnumToCodeItem {Open(10, "开启"), Close(20, "关闭");private int _value;private String _name;private TaskStatus(int value, String name) {set_value(value);set_name((name));}public int get_value() {return _value;}public void set_value(int _value) {this._value = _value;}public String get_name() {return _name;}public void set_name(String _name) {this._name = _name;}@Overridepublic String toString() {return _name;}@Overridepublic String getCodeName() {return "Quartz任务状态";}}public enum TaskEnviroment implements IConvertEnumToCodeItem {All("全部", "全部"), Dev("dev", "开发环境"), Pro("pro", "正式环境");private String _value;private String _name;private TaskEnviroment(String value, String name) {set_value(value);set_name((name));}public String get_value() {return _value;}public void set_value(String _value) {this._value = _value;}public String get_name() {return _name;}public void set_name(String _name) {this._name = _name;}@Overridepublic String toString() {return _name;}@Overridepublic String getCodeName() {return "Quartz任务执⾏环境";}}}QuartzFactory⽀持Job类注bean⼊对象@Componentpublic class QuartzFactory extends AdaptableJobFactory {@Autowiredprivate AutowireCapableBeanFactory capableBeanFactory;@Overrideprotected Object createJobInstance(TriggerFiredBundle bundle) throws Exception { // 调⽤⽗类的⽅法Object jobInstance = super.createJobInstance(bundle);// 进⾏注⼊capableBeanFactory.autowireBean(jobInstance);return jobInstance;}}QuartzConfig注⼊QuartzFactory对象@Configurationpublic class QuartzConfig {@Autowiredprivate QuartzFactory quartzFactory;@Beanpublic SchedulerFactoryBean schedulerFactoryBean(){SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setJobFactory(quartzFactory);//将job实例化，能够操作进⾏Spring 注⼊return schedulerFactoryBean;}QuartzUtil定时任务动态添加/删除操作类，initQuartzTask⽅法在系统启动时执⾏，根据配置⾃动开启相关符合条件的任务@Componentpublic class QuartzUtil {@Autowiredprivate SchedulerFactoryBean schedulerFactoryBean;@Autowiredprivate F_QuartzTaskService quartzTaskService;@Value("${spring.profiles.active}")private String active;private static String JOB_GROUP_NAME = "DEFAULT_JOB_GROUP_NAME";private static String TRIGGER_GROUP_NAME = "DEFAULT_TRIGGER_GROUP_NAME";public void initQuartzTask() {List<F_QuartzTaskDO> openTaskList = quartzTaskService.selectAllList();if(openTaskList.size()>0){openTaskList = openTaskList.stream().filter(a -> a.getTaskStatus() == QuartzEnum.TaskStatus.Open.get_value() &&(a.getEnviroment().equals(QuartzEnum.TaskEnviroment.All.get_name()) || a.getEnviroment().equals(active))).collect(Collectors.toList());}for (F_QuartzTaskDO taskDO : openTaskList) {try {Class<Job> jobClass = (Class<Job>) Class.forName(taskDO.getJobClassPath());if (taskDO.getTaskType() == QuartzEnum.TaskType.Cycle.get_value()) {addIntervalJob(taskDO.getTaskTag(), jobClass, taskDO.getExecutePeroid(), taskDO.getExecuteUnit());} else {addCornJob(taskDO.getTaskTag(), jobClass, taskDO.getCornExpress());}} catch (Exception e) {e.printStackTrace();}}if (openTaskList.size() > 0) {System.out.println("扫描并初始化开启quartz定时任务成功，任务数量：" + openTaskList.size() + "个");}}public void startTask( F_QuartzTaskDO taskDO){try {Class<Job> jobClass = (Class<Job>) Class.forName(taskDO.getJobClassPath());if (taskDO.getTaskType() == QuartzEnum.TaskType.Cycle.get_value()) {addIntervalJob(taskDO.getTaskTag(), jobClass, taskDO.getExecutePeroid(), taskDO.getExecuteUnit());} else {addCornJob(taskDO.getTaskTag(), jobClass, taskDO.getCornExpress());}} catch (Exception e) {e.printStackTrace();}}//增加定时任务任务public void addIntervalJob(String jobName, Class<? extends Job> cls, int peroid, int timeUnit) {try {SimpleScheduleBuilder scheduleBuilder = null;if (timeUnit == QuartzEnum.ExecuteUnit.Second.get_value()) {scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(peroid).repeatForever();} else if (timeUnit == QuartzEnum.ExecuteUnit.Minute.get_value()) {scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInMinutes(peroid).repeatForever();} else if (timeUnit == QuartzEnum.ExecuteUnit.Hour.get_value()) {scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInHours(peroid).repeatForever();}Scheduler sched = schedulerFactoryBean.getScheduler();JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).storeDurably().build();Trigger trigger = TriggerBuilder.newTrigger().forJob(jobDetail).withIdentity(jobName, TRIGGER_GROUP_NAME).withSchedule(scheduleBuilder).build(); sched.scheduleJob(jobDetail, trigger);if (!sched.isShutdown()) {sched.start(); // 启动}} catch (Exception e) {throw new RuntimeException(e);}}//增加corn表达式任务public void addCornJob(String jobName, Class<? extends Job> cls, String cornExpress) {try {Scheduler sched = schedulerFactoryBean.getScheduler();JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME).withSchedule(CronScheduleBuilder.cronSchedule(cornExpress)).build();sched.scheduleJob(jobDetail, trigger);if (!sched.isShutdown()) {sched.start(); // 启动}} catch (Exception e) {throw new RuntimeException(e);}}//停⽌任务public void deleteJob(String jobName) {try {Scheduler sched = schedulerFactoryBean.getScheduler();TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);sched.pauseTrigger(triggerKey); // 停⽌触发器sched.unscheduleJob(triggerKey);// 移除触发器sched.deleteJob(jobKey); // 删除任务} catch (Exception e) {throw new RuntimeException(e);}}}界⾯展⽰到此这篇关于SpringBoot实现quartz定时任务可视化管理的⽂章就介绍到这了,更多相关SpringBoot 定时任务可视化内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

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分钟执⾏⼀次。

SpringBoot中定时任务的3种实现⽅式Ref定时任务的实现⽅式⽅式1：基于java.util.Timer定时器，实现类似闹钟的定时任务⽅式2：使⽤ Quartz、elastic-job、xxl-job 等开源第三⽅定时任务框架，适合分布式项⽬应⽤。

该⽅式的缺点是配置复杂。

⽅式3：使⽤ Spring 提供的⼀个注解@Schedule，开发简单，使⽤⽐较⽅便。

java.util.Timer实现定时任务基于java.util.Timer定时器，实现类似闹钟的定时任务。

这种⽅式在项⽬中使⽤较少，参考如下Demo。

import java.util.Date;import java.util.Timer;import java.util.TimerTask;public class SpringbootAppApplication {/*** main⽅法* @param args*/public static void main(String[] args) {SpringApplication.run(SpringbootAppApplication.class, args);System.out.println("Server is running ...");TimerTask timerTask = new TimerTask() {@Overridepublic void run() {System.out.println("task run:"+ new Date());}};Timer timer = new Timer();timer.schedule(timerTask,10,3000);}}复制代码ScheduledExecutorService实现定时任务该⽅法类似Timer，参考如下Demo。

public class TestScheduledExecutorService {public static void main(String[] args) {ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();/*** @param command the task to execute 任务体* @param initialDelay the time to delay first execution ⾸次执⾏的延时时间* @param period the period between successive executions 任务执⾏间隔* @param unit the time unit of the initialDelay and period parameters 间隔时间单位*/service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);}}复制代码@Schedule实现定时任务Demo1. ⾸先，在项⽬启动类上添加@EnableScheduling注解，开启对定时任务的⽀持。