Quartz

本文介绍了Quartz定时任务框架的原理,如何在SpringBoot项目中集成,重点讲解了Cron表达式用于灵活定义时间规则,并演示了如何创建Job、Trigger和整合到Spring中的步骤。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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位

秒 分 时 日 月 星期几 [年份]

位置时间域允许值特殊值
10-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 * * ? 20082008年的每天的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-20092207年、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、任务的控制:

暂停 恢复 删除

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值