1、作用

Quartz是一个定时任务调度框架，可以将其理解为一个闹钟，可以设置在具体的某个时间，同样可以设置是否按某种规则循环

2、Quartz核心要素

2.1、Scheduler

调度容器，所有的调度都由他控制，所有的任务都是从这里开始的

2.2、JobDetail、Job

JobDetail：任务数据
Job：真正的执行逻辑

2.3、Trigger

调度任务的时间规则

3、简单的demo（基于SpringBoot）

3.1、pom文件中引入依赖

    org.quartz-scheduler
    quartz
    2.3.2



1
2
3
4
5
6
7
8
9
10

3.2、实现一个job

import org.quartz.*;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Random;
/**
 * @author Dora
 * @since 2022/8/1 16:46
 */
public class TestJob  implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        System.out.println(jobDetail.getKey());
        Trigger trigger = jobExecutionContext.getTrigger();
        System.out.println(trigger.getKey());
        String printTime = new SimpleDateFormat("yy-MM-dd HH-mm-ss").format(new Date());
        System.out.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.3、写触发job的规则

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * @author Dora
 * @since 2022/8/1 17:25
 */
public class Test {
    public static void main(String[] args) throws SchedulerException {

        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        //1、得到对应的Scheduler对象
        Scheduler scheduler = schedulerFactory.getScheduler();

        //2、定义一个JobDetail
        // jobDetail中携带自定义参数
        JobDataMap dataMap = new JobDataMap();
        dataMap.put("msgRuleConfig", "msgRuleConfig");

        JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
                .withIdentity("job", "jobGroup") // JobKey，如果需要通过Scheduler停止Job，需要用到这个JobKey，所以JobKey需要唯一
                .usingJobData(dataMap)
                .build();

        //3、定义一个Trigger
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger", "triggerGroup") //triggerKey
                .startNow()//立即生效
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(1)//每隔1s执行一次
                        .repeatForever()).build();//一直执行

        //4、整合jobDetail和trigger
        scheduler.scheduleJob(jobDetail, trigger);

        //5、启动任务
        scheduler.start();
        
        //删除job：scheduler.deleteJob(JobKey));
        //停止Scheduler：scheduler.shutdown();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

3.4、运行效果

4、关于任务的启动和停止

首先，一个Scheduler可以同时管理多个Job
其次Scheduler可以启动和停止，是通过Scheduler的start和shutdown；Job本身是通过trigger设置的时间规则来启动和运行，同时也可有通过Scheduler来停止Job

4.1、Scheduler的启动和停止

启动Scheduler：
scheduler.start();

停止Scheduler：
scheduler.shutdown()
1
2
3
4
5

4.2、手动停止Job

//1、暂停trigger触发器
scheduler.pauseTrigger(triggerKey);
//2、移除trigger触发器
scheduler.unscheduleJob(triggerKey);
//3、删除任务
scheduler.deleteJob(jobKey);
1
2
3
4
5
6

5、Scheduler详解

5.1、创建

1、Scheduler是Quartz的核心所在，所有的任务都是通过Scheduler开始的
2、Scheduler是一个接口类，所有的具体实现都是通过SchedulerFactory实现的；如果是Spring管理的，通过@Autowired注入也是可以的

SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
1
2

5.2、常用属方法,三类

5.2.1、操作调度器本身

1. 调度器的启动：start()
2. 调度器的停止：shutdown()
3. 调度器的暂停：standby()

5.2.2、操作Trigger

1. 暂停：pauseTriggers()
2. 重启：resumeTrigger()

5.2.3、操作Job

1. 设置job：scheduleJob()、
2. 移除Trigger：unscheduleJob()
3. 重启：rescheduleJob()
4. 删除：deleteJob()

5.3、移除一个job的方法

//1、暂停trigger触发器
scheduler.pauseTrigger(triggerKey);
//2、移除trigger触发器
scheduler.unscheduleJob(triggerKey);
//3、删除任务
scheduler.deleteJob(jobKey);
1
2
3
4
5
6

6、JobDetail、Job详解

6.1、Job

具体的业务逻辑，定义类继承Job， 重写execute方法完善业务逻辑

import org.quartz.*;
public class TestJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
    }
}
1
2
3
4
5
6

6.2、JobDetail

为Job实例提供了许多设置属性
重要属性：name，group，jobClass，jobDataMap

JobDataMap dataMap = new JobDataMap();
dataMap.put("msgRuleConfigData", msgRuleConfig);

JobDetail jobDetail = 
        // JobClass
        JobBuilder.newJob(SendMsgJob.class)
        //设置jobName和JobGroup,jobName是唯一的，可以通过withIdentity(String name, String group)，也可以先构建JobKey然后通过withIdentity(JobKey jobKey)设置
        .withIdentity("jobName", "jobGroup") 
        //JobDataMap,job成员变量属性
        .usingJobData(dataMap)  
        .build();
1
2
3
4
5
6
7
8
9
10
11

7、Trigger

定时任务的时间触发规则,主要两个实现类：CronTriggerImpl与SimpleTriggerImpl。

1. .startNow()：立即生效
2. .startAt(Date)：生效时间
3. .endAt(Date)： 结束触发时间

SimpleTrigger，精确指定间隔时间

1. 触发时间间隔：
   .withIntervalInHours(long) ：设置定时器间隔时间，以小时为单位
   .withIntervalInMilliseconds(long)：设置定时器间隔时间，以毫秒为单位
   .withIntervalInSeconds(long)：设置定时器间隔时间，以秒为单位
   .withIntervalInMinutes(long)： 设置定时器间隔时间，以分钟为单位
2. 触发间隔
   .withRepeatCount(int)：重复次数
   .repeatForever()：始终重复

Trigger trigger = TriggerBuilder.newTrigger().withIdentity(TriggerKey)
        //立即生效
        .startNow()
        // 设置Trigger模式为SimpleTrigger
        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
            // 设置定时器间隔时间，以小时为单位
            .withIntervalInHours(long) 
            // 始终重复
            .repeatForever()
        ).build();//一直执行

1
2
3
4
5
6
7
8
9
10
11

CronTrigger，基于日历的作业调度器

//创建一个CronTrigger实例
CronTrigger trigger=(CronTrigger)TriggerBuilder.newTrigger()
.withIdentity("trigger", "group")//定义name/group
.withSchedule(CronScheduleBuilder.cronSchedule("0 5 21 * * ? *")) //填写cron表达式
.build();
1
2
3
4
5

关于cron表达式，参考文章：java 定时任务 @Scheduled的表达式