Quartz 基本使用

一，定时任务

在很多情况下任务并非需要立即执行 , 而是需要往后或定期执行 , 这不可能人工去操作 , 所以定时任务就出现了

使用定时任务的情况 :

每周末凌晨备份数据
触发条件 5 分钟后发送邮件通知
30 分钟未支付取消订单
每 1 小时去拉取数据

Scheduled 创建定时任务

在 SpringBoot 的启动类类中加⼊ @EnableScheduling 注解 , 启⽤定时任务的配置

package com.lgs.code;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class QuartzApplication {

    public static void main(String[] args) {
        SpringApplication.run(QuartzApplication.class, args);
    }

}

创建定时任务实现类

package com.lgs.code;

import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @author lgs
 */
@Component
@Slf4j
public class Task {

    //fixedRate 上⼀次开始执⾏时间点之后1秒再执⾏
    //每隔一个小时 的第10分  第10秒 执行一次
    @Scheduled(cron = "10 10 * * * ?")
    public void text(){
        log.warn("当前时间："+ LocalDateTime.now());
    }

}

Scheduled 参数

@Scheduled(fixedRate=5000): 上⼀次开始执⾏时间点之后 5 秒再执⾏

@Scheduled(fixedDelay=5000): 上⼀次执⾏完毕时间点之后 5 秒再执⾏

@Scheduled(initialDelay=1000, fixedRate=5000): 第⼀次延迟 1 秒后执⾏ , 之后按 fixedRate 的规则

每 5 秒执⾏⼀次

@Scheduled(cron="*/5 * * * * *"): 通过 cron 表达式定义规则

cron 表达式

cron 表达式是一个字符串 , 以 5 或者 6 个空格隔开 ( 示例中是被 5 个空格隔开 ), 字符串被切割为 6 个或者 7 个域 ,

每个域都代表不同的含义

@Component

@Slf4j

public class Task {

@Scheduled ( fixedRate = 2000 )

public void work () {

log . warn ( " 现在时间： " + LocalDateTime . now ());

}

}

{Seconds} {Minutes} {Hours} {DayofMonth} {Month} {DayofWeek} {Year}

{Seconds} {Minutes} {Hours} {DayofMonth} {Month} {DayofWeek}

每个域都可以用数字表示,还可以出现如下特殊字符

* : 表示匹配该域的任意值 , 比如 Minutes 域使用 *, 就表示每分钟都会触发

- : 表示范围 , 比如 Minutes 域使用 10-20, 就表示从 10 分钟到 20 分钟每分钟都会触发一次

, : 表示列出枚举值 , 比如 Minutes 域使用 1,3. 就表示 1 分钟和 3 分钟都会触发一次

/ : 表示间隔时间触发 ( 开始时间 / 时间间隔 ), 例如在 Minutes 域使用 5/10, 就表示从第 5 分钟开始 , 每隔 10

分钟触发一次

? : 表示不指定值 , 简单理解就是忽略该字段的值 , 直接根据另一个字段的值触发执行

# : 表示该月第 n 个星期 x(x#n), 仅用星期域 , 如：星期： 6#3, 表示该月的第三个星期五

L : 表示最后 , 是单词 "last" 的缩写（最后一天或最后一个星期几）；仅出现在日和星期的域中 , 用在日则表

示该月的最后一天 , 用在星期则表示该月的最后一个星期 , 如：星期域上的值为 5L, 则表示该月最后一个星期的

星期四 , 在使用 'L' 时 , 不要指定列表 ',' 或范围 '-', 否则易导致出现意料之外的结果

W: 仅用在日的域中 , 表示距离当月给定日期最近的工作日（周一到周五） , 是单词 "weekday" 的缩写

星期里， 1 表示的是星期天， 2 表示的是星期一，以此类推， 7 表示的是星期六

？只存在于某天或某星期中，且不能同时存在 ( 还不支持同时指定某天和星期 )

'L' 和 'W' 字符也可以在日期字段中组合以产生 'LW' ，这转换为 “ 最后一个工作日 ”

法定字符以及月份和星期的名称不区分大小写，如 MON

Quartz 创建定时任务

<dependency>

<groupId> org.springframework.boot </groupId>

<artifactId> spring-boot-starter-quartz </artifactId>

</dependency>

任务存储方式

内存方式 (RAMJobStore) ：将任务临时存储到内存中，仅支持单项目部署，项目重启后任务会失效，不

支持由调度器控制任务漂移，不建议使用。

数据库方式 (JDBCJobStore) ： Quartz 提供了多种数据库的所需表结构脚本，它内部通过 DataSource 来

操作数据，支持分布式方式部署、支持任务漂移，项目重启后任务不会丢失，直到任务执行完成后才会

被从数据库内清除

二，内存存储

SchedulerFactory 调度器工厂

SchedulerFactory factory = new StdSchedulerFactory();

Scheduler 调度器

Scheduler scheduler = factory.getScheduler();

用于与调度程序交互的主程序接口

Scheduler 维护了一个 JobDetails 和 Triggers 的注册表。

一旦在 Scheduler 注册过了，当定时任务触发时间一到，调度程序就会负责执行预先定义的 Job

调度程序创建之后，处于 “ 待机 ” 状态，必须调用 scheduler 的 start() 方法启用调度程序

可以使用 shutdown() 方法关闭调度程序，使用 isShutdown() 方法判断该调度程序是否已经处于关闭状

态

通过 Scheduler.scheduleJob(…) 方法将任务纳入调度程序中，当任务触发时间到了的时候，该任务将被

执行

Job 定时任务

任务是一个实现 org.quartz.Job 接口的类，任务类必须含有空构造器

当关联这个任务实例的触发器表明的执行时间到了的时候，调度程序 Scheduler 会调用这个方法来执行

任务，任务内容就可以在这个方法中执行

@Slf4j

public class MyJob implements Job {

@Override

public void execute ( JobExecutionContext jobExecutionContext ) throws

JobExecutionException {

Object name =

jobExecutionContext . getJobDetail (). getJobDataMap (). get ( "name" );

log . error ( name + " 正在努力的搞卫生 ………………" );

}

}

JobDataMap 提供了一种 “ 初始化成员属性数据的机制 ”, 在实现该 Job 接口的时候可以取到需要的数据

实例化的过程

创建一个 Job 类，在调度程序中可以创建很多个 JobDetai ，分别设置不同的 JobDataMap

创建一个类 SalesReportJob 实现 Job 接口，用做销售报表使用。

可以通过 JobDataMap 指定销售员的名称和销售报表的依据等等。

这就会创建多个 JobDetails ，例如 SalesReportForJoe ， SalesReportForMike 分别对应在

JobDataMap 中指定的名字 joe 和 mike 。

JobBuilder 用于创建 JobDetail ，如果没有调用 withIdentity 指定 job 的名字，会自动生成一个。

JobDetail jobDetail = newJob ( MyJob . class )

. withDescription ( " 开年大扫除 " )

. withIdentity ( " 大扫除 " , " 厕所 " )

. usingJobData ( "name" , " 王阿姨 " )

. build ();

context.getJobDetail().getKey() = name + group

Trigger 触发器

触发器使用 TriggerBuilder 来实例化，有一个 TriggerKey 关联，在一个 Scheduler 中必须是唯一的。

多个触发器可以指向同一个工作，但一个触发器只能指向一个工作。

触发器可以传送数据给 job ，通过将数据放进触发器的 JobDataMap 。

触发器常用属性

触发器也有很多属性，这些属性都是在使用 TriggerBuilder 定义触发器时设置的。

TriggerKey ，唯一标识，在一个 Scheduler 中必须是唯一的

startTime ，开始时间，通常使用 startAt(java.util.Date)

endTime ，结束时间，设置了结束时间则在这之后，不再触发

Trigger trigger = TriggerBuilder . newTrigger ()

. withDescription ( " 大扫除触发器 " )

. withIdentity ( " 大扫除 " , " 厕所 " )

. startAt ( new Date ())

. build ();

如果没有使用 withIdentity(..) 会自动生成一个触发器名称。

触发器的优先级

有时候，会安排很多任务，但是 Quartz 并没有更多的资源去处理它。

这种情况下，必须需要很好地控制哪个任务先执行。这时候可以设置 priority 属性（使用方法

withPriority(int) ）来控制触发器的优先级。

优先级只有触发器出发时间一样的时候才有意义。

当一个任务请求恢复执行时，它的优先级和原始优先级是一样的。

常见触发器

TriggerBuilder 用于创建 Trigger ，如果没有调用 withSchedule(..) 方法，会使用默认的 schedule

简单触发器 SimpleTrigger

SimpleTrigger 包含几个特点：开始时间、结束时间、重复次数以及重复执行的时间间隔。

Trigger trigger = TriggerBuilder . newTrigger ()

. withDescription ( "" )

. withIdentity ( "clean" , "clean1" )

. startAt ( new Date ())

. withSchedule (

simpleSchedule ()

. withIntervalInSeconds ( 10 )

. withRepeatCount ( 10 ) //SimpleTrigger.REPEAT_INDEFINITELY

)

. build ();

基于 Cron 表达式的触发器 CronTrigger

Trigger trigger = TriggerBuilder . newTrigger ()

. withIdentity ( "test" , "test" )

. withDescription ( " 测试的触发器 " )

. withSchedule ( CronScheduleBuilder . cronSchedule ( "2 * * * * *" ))

. build ();

Cron在线表达式生成器

Cron - 在线Cron表达式生成器

绑定与启动

scheduler . scheduleJob ( jobDetail , trigger );

scheduler . start ();

总代码：

首先先建一个任务类

package com.lgs.code;

import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @author lgs
 */
@Slf4j
public class MyJob implements Job {


    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
//        拿到当前任务实例
          Object name = context.getJobDetail().getJobDataMap().get("name");
          log.warn(name+"搞卫生");
//        log.warn("搞卫生");
        }
}

测试类：

package com.lgs.code;

import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.Date;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;

@SpringBootTest
class QuartzApplicationTests {

    @Test
    void contextLoads() throws Exception{
//  while (true){}
//  1,实例化调度器工厂
        SchedulerFactory factory = new StdSchedulerFactory();
//  2,得到调度器
        Scheduler scheduler = factory.getScheduler();
//  3,创建任务
        //  Job（模板） 和 JobDetail（实例）
        JobDetail jobDetail01 = newJob(MyJob.class)
                .withDescription("大扫除任务") //描述
                .withIdentity("a", "b") //任务id => ab
                .usingJobData("name","张三")
                .build(); //构建
        JobDetail jobDetail02 = newJob(MyJob.class)
                .withDescription("大扫除任务") //描述
                .withIdentity("a", "b") //任务id => ab
                .usingJobData("name","张三")
                .build(); //构建
//  4,创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withDescription("创建触发器")
                .withIdentity("b", "c") // bc
                .startAt(new Date())
//              简单触发器
//                .withSchedule(
//                        simpleSchedule()
//                                .withIntervalInSeconds(1) //间隔几秒
//                                .withRepeatCount(10) // withRepeatCount重复几次 SimpleTrigger.REPEAT_INDEFINITELY一直重复
//                 )
//              cron触发器
                .withSchedule(
                        CronScheduleBuilder.cronSchedule("* * * * * ?")
                )
//              提高优先级
//              .withPriority(10)
                .build();
//  5,将触发器和任务绑定到调度器
        scheduler.scheduleJob(jobDetail01,trigger);
//  6,启动调度器
        scheduler.start();
        while (true){}
    }

}

OK！到这就结束了，希望能帮到你！！！