本文介绍了Quartz定时任务框架的原理，如何在SpringBoot项目中集成，重点讲解了Cron表达式用于灵活定义时间规则，并演示了如何创建Job、Trigger和整合到Spring中的步骤。
1、认识Quartz
Quartz是一个定时任务框架，在指定的时间自动执行特定的任务
例如：今日头条，微信，QQ，在每天早晨8:00，推送推荐新闻
秒杀
原理：
1、任务Job 要执行的业务逻辑
2、时间规则：声明在何时执行任务
例如：30分钟后 每天早晨8:00 每个月的最后一天，每个月的最后一个工作日等
3、调度：在满足时间规则时，去执行任务
2、搭建Quartz环境，及简单应用
1、新建SpringBoot项目
2、添加Quartz的依赖
<!--Quartz任务调度-->
<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</dependency>
<!--xxl-->
<dependency>
<groupId>com.xuxueli</groupId>
<artifactId>xxl-job-core</artifactId>
<version>2.3.0</version>
</dependency>
、编写执行的任务Job
package com.qf.quartzpro2105.jobs;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Date;
public class FirstJob implements Job {
//execute方法会被调度器自动调用
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
//任务的逻辑代码
//获取任务的相关信息
//获取到任务的详情对象
JobDetail jobDetail=context.getJobDetail();
//通过任务详情对象获取任务的信息
System.out.println("任务的名称："+jobDetail.getKey().getName());
System.out.println("任务所在组："+jobDetail.getKey().getGroup());
System.out.println("在"+new Date()+"时间执行了测试任务");
}
}
4、任务执行的业务逻辑代码
package com.qf.quartzpro2105.service.impl;
import com.qf.quartzpro2105.jobs.FirstJob;
import com.qf.quartzpro2105.service.FirstJobService;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.stereotype.Service;
import java.util.GregorianCalendar;
@Service
public class FirstJobServiceImpl implements FirstJobService {
@Override
public void firstJob() {
//执行任务
try {
//创建调度器
Scheduler scheduler= StdSchedulerFactory.getDefaultScheduler();
//创建时间规则---在触发器Trigger中指定时间规则
Trigger trigger= TriggerBuilder.newTrigger()
.withIdentity("trigger1","group1")
.startNow() //即刻开始执行 .startAt(指定时间)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(2) //重复的规则
.repeatForever() ) //重复的次数
.endAt(new GregorianCalendar(2022,5,5,10,10,0).getTime())
.build();
//定义任务详情---把任务类放进去
JobDetail jobDetail=JobBuilder.newJob(FirstJob.class)
.withIdentity("job1","jobgroup1")
.build();
//调度任务---把时间规则和任务 捏合在一起
scheduler.scheduleJob(jobDetail,trigger);
//开始执行
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
3、Trigger
Trigger触发器，声明时间规则，在Quartz中，共有两种触发器
1、SimpleTrigger:简单触发器，通过调用方法来实现，时间规则的定义
缺点：不够灵活
//创建时间规则---在触发器Trigger中指定时间规则
Trigger trigger= TriggerBuilder.newTrigger()
.withIdentity("trigger1","group1")
.startNow() //即刻开始执行 .startAt(指定时间)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(2) //重复的规则
.repeatForever() ) //重复的次数
.endAt(new GregorianCalendar(2022,5,5,10,10,0).getTime())
.build();
2、CronTrigger-重点：通过使用Cron表达式来声明时间规则，比较灵活
组成：6位或7位
秒 分 时 日 月 星期几 [年份]
| 位置 | 时间域 | 允许值 | 特殊值 |
|---|---|---|---|
| 1 | 秒 | 0-59 | , - * / |
| 2 | 分钟 | 0-59 | , - * / |
| 3 | 小时 | 0-23 | , - * / |
| 4 | 日期 | 1-31 | , - * ? / L W |
| 5 | 月份 | 1-12 | , - * / |
| 6 | 星期 | 1-7 | , - * ? / L # |
| 7 | 年份（可选） | , - * / |
3-5 3 4 5表示范围
1,3,59 多个值之间使用,分隔
* 每一秒/分/时
1/4 斜杠后的是增量，没过几 秒/分/时 1 5 9 13 17
？ 任意值 只能出现在日期 和星期上，当指定了日期或星期中的某一个时，那么另一个就可以使用?
# 只能用在星期中 1代表星期天 2代表星期1
4#3 4代表星期三，3代表第三个 当月的第三个星期三
L：last 最后一个
用在星期中 * 0 8 ？ * L 每个星期六(每个星期的最后一天)
* * * * * 7 L 当月的最后一个星期六(当月的最后一个星期几)
用在日期中，表示这个月的最后一天
W：用字日期中 用法 数字W 离该数字最近的工作日
LW:当月的最后一个工作日
| 符号 | 语义 |
|---|---|
| 星号(*) | 可用在所有字段中，表示对应时间域的每一个时刻，例如， 在分钟字段时，表示“每分钟” |
| 问号(?) | 该字符只在日期和星期字段中使用，它通常指定为“不确定值” |
| 减号(-) | 表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12 |
| 逗号(,) | 表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五 |
| 斜杠(/) | x/y表达一个等步长序列，x为起始值，y为增量步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段 中表示5,20,35,50 |
| 井号(#) | 该字符只用在星期字段中，"4#2"代表第二个星期3，“5#4”代表第4个星期四 |
| L | 该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。 |
| 如果L用在星期字段里，则表示星期六，等同于7 | |
| L出现在星期字段里，而且在前面有一个数值x，则表示“这个月的最后一个周x”，例如，6L表示该月的最后星期五 | |
| L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号 | |
| W | 该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日 |
| 例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号 是星期二，那结果就是15号星期二；但必须注意关联的匹配日期不能够跨月 | |
| LW组合 | 在日期字段可以组合使用LW，它的意思是当月的最后一个工作日 |
| 表示式 | 说明 |
|---|---|
| 0 0 12 * * ? | 每天12时0分0秒 |
| 0 15 10 * * ? | 每天的10:15:00秒 |
| 0 15 10 * * ? 2008 | 2008年的每天的10:15:00运行 |
| 0 * 14 * * ? | 在14:00到15:00之间每分钟的0秒时刻运行一次 |
| 0 0/5 14 * * ? | 从14:00到15:00之间从0分开始每隔5分钟运行一次 |
| 0 0/5 14,18 * * ? | 两个时间段，14:00 18:00 从0分开始，每隔5分执行一次 |
| 0 0-5 14 * * ? | 每天14:00 0,1,2,3,4,5的0秒开始执行一次 |
| 0 0-5/2 14 * * ? | 每天14:00到14:05之间，没过2分钟执行一次 14:00 14:02 14:04 |
| 0 10,44 14 ? 3 4 | 每年的3月份的星期三的14点 10分0分，44分0秒 运行 |
| 0 15 10 ? * 2-6 | 每个星期的星期一、二、三、四、五的10时15分0秒执行 |
| 0 15 10 15 * ? | 每个月的15号的10:15:00 运行 |
| 0 15 10 L * ? | 每个月的最后一天的10:15:00运行 |
| 0 15 10 ? * 6L | 每个月的最后一个星期五的10:15:00运行 |
| 0 15 10 ? * 6L 2007-2009 | 2207年、2008年、2009年每个月的最后一个星期五的10:15:00运行 |
Cron表达式的应用
//使用Cron表达式声明时间规则
CronTrigger trigger=TriggerBuilder.newTrigger()
.withIdentity("trigger2","group1")
.withSchedule(CronScheduleBuilder.cronSchedule("5/3 32 14 5 5 ? 2022"))
.build();
4、Springboot整合Quartz
1、新建maven项目
2、添加依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.qf</groupId>
<artifactId>quartzpro</artifactId>
<version>1.0-SNAPSHOT</version>
<packaging>war</packaging>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<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>
</dependencies>
</project>
3、新建Quartz的配置文件
【说明】定时任务框架是多线程的应用，每一个任务对应着一个线程，在线程内，根据时间规则进行计时
quartz.properties 配置quartz的线程池信息
# 名字必须是quartz.properties 放置在classpath路径下，如果没有此配置文件，则按默认配置启动
# 指定线程池的实现类
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
# 指定线程池种线程的数量
org.quartz.threadPool.threadCount = 10
# 指定线程默认的优先级
org.quartz.threadPool.threadPriority = 5
# 非持久化的Job
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
4、编写Quartz的配置类
package com.qf.quartz.conf;
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.boot.autoconfigure.quartz.SchedulerFactoryBeanCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
@Configuration
public class QuartzConfig implements SchedulerFactoryBeanCustomizer {
//配置：读取quartz配置文件的bean
@Bean
public Properties properties() throws IOException {
//读取Quartz的配置文件
PropertiesFactoryBean propertiesFactoryBean=new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
//根据读取到的内容注入属性
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
}
//配置Scheduler的bean
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
SchedulerFactoryBean schedulerFactoryBean=new SchedulerFactoryBean();
schedulerFactoryBean.setQuartzProperties(properties());
return schedulerFactoryBean;
}
//初始化Quartz的监听器---
@Bean
public QuartzInitializerListener executorListener(){
return new QuartzInitializerListener();
}
//创建一个Scheduler
@Bean
public Scheduler createSchduler() throws IOException {
return schedulerFactoryBean().getScheduler();
}
@Override
public void customize(SchedulerFactoryBean schedulerFactoryBean) {
schedulerFactoryBean.setStartupDelay(2);//任务的延迟时间
schedulerFactoryBean.setAutoStartup(true); //自动启动
schedulerFactoryBean.setOverwriteExistingJobs(true); //相同的任务会覆盖
}
}
5、任务调度
package com.qf.quartz.service.impl;
import com.qf.quartz.jobs.FirstJob;
import com.qf.quartz.service.JobService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class JobServiceImpl implements JobService {
@Autowired
private Scheduler scheduler;
@Override
public void firstJob() {
//声明Cron表达式
CronTrigger trigger= TriggerBuilder.newTrigger()
.withIdentity("trigger","qf")
.withSchedule(CronScheduleBuilder.cronSchedule("5/3 50 15 5 5 ? 2022"))
.build();
//声明任务
JobDetail jobDetail=JobBuilder.newJob(FirstJob.class)
.withIdentity("job1","jobgroup1")
.build();
try {
scheduler.scheduleJob(jobDetail,trigger);
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
6、定时任务的控制
@Override
public void deleteJob(String jobName) {
try {
//删除任务
this.scheduler.deleteJob(JobKey.jobKey(jobName,"jobgroup1"));
} catch (SchedulerException e) {
e.printStackTrace();
}
}
@Override
public void pauseJob(String jobName) {
try {
//暂停任务
this.scheduler.pauseJob(JobKey.jobKey(jobName,"jobgroup1"));
} catch (SchedulerException e) {
e.printStackTrace();
}
}
@Override
public void resumeJob(String jobName) {
try {
//恢复任务
this.scheduler.resumeJob(JobKey.jobKey(jobName,"jobgroup1"));
} catch (SchedulerException e) {
e.printStackTrace();
}
}
5、总结
1、什么时候做指定的事情
2、定时任务的结构：Job任务 时间规则Trigger 调度 Scheduler
3、声明任务 实现Job接口里的execute方法即可
4、声明时间规则Trigger
SimpleTrigger:不够灵活，通过调用方法的方式来定义时间规则
CronTrigger:通过Cron表达式来定义时间规则---重点
5、Scheduler:把二者捏合在一起，每个任务都是一个独立的线程
6、SpringBoot整合Quartz
7、任务的控制：
暂停 恢复 删除
扫一扫
762
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
