算法设计者

这个屌丝很懒，什么也没留下！

热门标签

2022-02-20-Quartz分布式定时任务(上)_quartz最大支持多少任务

作者：算法设计者 | 2024-01-29 10:46:12

踩

quartz最大支持多少任务

Quartz理解

Quartz简介

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。
quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用，小到独立的应用，大至电子商业系统。quartz能够创建亦简单亦复杂的调度，以执行上十、上百，甚至上万的任务。任务job被定义为标准的java组件，能够执行任何你想要实现的功能。quartz调度框架包含许多企业级的特性，如JTA事务、集群的支持。简而言之，quartz就是基于java实现的任务调度框架，用于执行你想要执行的任何任务。
Quartz官网：http://www.quartz-scheduler.org/

Quartz运行环境

Quartz 可以运行嵌入在另一个独立式应用程序
Quartz 可以在应用程序服务器(或servlet容器)内被实例化，并且参与事务
Quartz 可以作为一个独立的程序运行(其自己的Java虚拟机内)，可以通过RMI使用
Quartz 可以被实例化，作为独立的项目集群(负载平衡和故障转移功能)，用于作业的执行

Quartz的设计模式

Builder模式
Factory模式
组件模式
链式编程

Quartz的核心概念

任务job：job就是你想要实现的任务类，每一个job必须实现org.quartz.job接口，且只需要实现接口定义的execute()方法。
触发器Trigger：Trigger为你执行任务的触发器，比如你想每天定时3点发送一份统计邮件，Trigger将会设置3点进行执行该任务。Trigger注意包含两种SimpleTrigger和CronTrigger两种。两者用于不同的使用场景。
调度器Scheduler：Scheduler为任务的调度器，它会将任务job及触发器Trigger整合起来，负责基于Trigger设定的时间来执行job。

Quartz的体系结构

Quartz的结构

Quartz的组件

CronTrigger又称为日历触发器

Quartz的常用API

Scheduler是用于开发人员与调度程序交互的主程序接口。
Scheduler调度程序–任务执行计划表，只有安排进执行计划的任务Job(通过Scheduler.Schedulejob方法安排进执行计划)，当它预先定义的执行时间到了的时候(任务触发Trigger)，该任务才会执行。
Job我们预先定义的希望在未来时间能被调度程序执行的任务类，我们可以自定义。
JobDetail 使用JobDetail来定义定时任务的实例，JobDetail实例是通过JobBuilder类创建的。
JobDataMap可以包含不限量的（序列化的）数据对象，在job实例执行的时候，可以使用其中的数据；JobDataMap是Java Map接口的一个实现，额外增加了一些便于存取基本类型的数据的方法。
Trigger 触发器，Trigger对象是用来触发执行Job的。当调度一个job时，我们实例一个触发器然后调整它的属性来满足job执行的条件。表明任务在什么时候会执行。定义了一个已经被安排的任务将会在什么时候执行的时间条件，比如每2秒就执行一次。
JobBuilder -用于声明一个任务实例，也可以定义关于该任务的详情比如任务名、组名等，这个声明的实例将会作为一个实际执行的任务。
TriggerBuilder 触发器创建器，用于创建触发器trigger实例。
JobListener、TriggerListener、SchedulerListener监听器，用于对组件的监听。

Quartz应用

简单实现Quartz

创建job,需要实现Quartz的job类

/**
 * @Author: zkfgyzy@163.com
 * @Date: 2022/1/6 22:05
 */
public class HelloJob implements Job {
    
     public HelloJob(){
        System.out.println("我是HelloJob");
    }
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //输出当前时间的job
        Date date = new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = simpleDateFormat.format(date);
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是："+dateString);

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

创建调度器，将JobDetail，Trigger整合到调度器中

/**
 * @Author: zkfgyzy@163.com
 * @Date: 2022/1/6 22:09
 */
public class HelloSchedulerDemo {

    public static void main(String[] args) throws SchedulerException {
        //1:调度器（Scheduler)，从工厂中获取调度实例,默认是实例化了new StdSchedulerFactory
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //2:任务实例(JobDetail)
        //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
                .withIdentity("job1", "group1")
                .build();

        //3:触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                //参数1：触发器名称，触发器组的名称
                .withIdentity("trigger1", "group1")
                .startNow()//马上启动
                //每5秒重复执行一次
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
                .build();

        //4. 使用调度器将触发器和任务jobdetail关联
        scheduler.scheduleJob(jobDetail,trigger);
        //5. 启动触发器
        scheduler.start();
    }
}
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

1、创建调度器
2、将要执行的程序作为job，放入jobDetail中。job只是定义的一个死任务，jobDetail才是要被触发器执行的任务，jobDetail类似一个包装类，有更多的方法去处理job
3、定义触发器，触发器用来触发任务的，因此触发器包含更多的功能，例如每隔多长时间去执行任务等
4、调度器：调度器用于JobDetail和Trigger的整合，比如：调度器A和那个JobDetail进行匹配，此外，调度器是整个任务的启动按钮

Job和JobDeatil

工作任务调度的接口，任务类需要实现该接口。该接口中定义execute方法，类似JDK提供的TimeTask类的run方法。在里面编写任务执行的业务逻辑。
Job实例在Quartz中的生命周期：每次调度器执行Job时，它在调用execute方法前会创建一个新的Job实例，当调用完成后，关联的Job对象实例会被释放，释放的实例会被垃圾回收机制回收。
对于每次job是否会创建一个新的实例，可以添加一个构造函数来查看，构造函数打印一句话，如果每次执行任务都会打印这句话，表明每次执行job都会创建一个实例。

JobDetail

JobDetail为Job实例提供了许多设置属性，以及JobDetaMap成员变量属性，它用来存储特定Job实例的状态信息，调度器需要借助JobDetail对象来添加Job实例
JobDetail重要属性：name、group、jobClass、jobDataMap

JobDetail job = JobBuilder.newJob(HelloJob.class)
        .withIdentity("job1", "group1") // 定义该实例唯一标识，并指定一个组。
        .build();
  
System.out.println("name:"+job.getKey().getName());
System.out.println("group:"+job.getKey().getGroup());
System.out.println("jobClass:"+job.getJobClass().getName());
1
2
3
4
5
6
7

JobDetail如果没有指定组名，会生成DEFAULT的组名

JobExecutionContext

当Scheduler调用一个job，就会将JobExecutionContext传递给Job的execute()方法。
Job能够通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据

/**
 * @Author: zkfgyzy@163.com
 * @Date: 2022/1/6 22:05
 */
public class HelloJob implements Job {


    public HelloJob(){
        System.out.println("我是HelloJob");
    }
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //输出当前时间的job
        Date date = new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = simpleDateFormat.format(date);

        JobKey key = jobExecutionContext.getJobDetail().getKey();
        System.out.println("工作任务名称："+key.getName()+"     "+"工作内容组："+key.getGroup());
        System.out.println("任务类名称（带路径)："+jobExecutionContext.getJobDetail().getJobClass().getName());
        System.out.println("任务类的名称: "+jobExecutionContext.getJobDetail().getJobClass().getSimpleName());
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是："+dateString);

    }
}
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

name:job1
group:group1
jobClass:net.toposphere.quartz.springbootquartz.job.HelloJob
我是HelloJob
工作任务名称：job1 工作内容组：group1
任务类名称（带路径)：net.toposphere.quartz.springbootquartz.job.HelloJob
任务类的名称: HelloJob
正在进行数据库的备份工作，备份数据库的时间是：2022-01-13 01:44:34
我是HelloJob
工作任务名称：job1 工作内容组：group1
任务类名称（带路径)：net.toposphere.quartz.springbootquartz.job.HelloJob
任务类的名称: HelloJob

JobDataMap

JobDataMap是JobDetail的一个方法，可以存储任何数据，Job接口的execute()方法可以通过JobExecutionContext获取jobDataMap中数据，进而可以操作对应的数据内容

在进行任务调度时，JobDataMap存储在JobExecutionContext中，非常方便获取。
JobDataMap可以用来装载任何可序列化的数据对象，当job实例对象被执行时这些参数对象会传递给它。
JobDataMap实现了JDK的Map接口，并且添加了非常方便的方法用来存取基本数据类型。

jobDataMap的使用

JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
    //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
    .withIdentity("job1", "group1")
    .usingJobData("message","打印JobDetail日志")
    .build();

System.out.println("name:"+jobDetail.getKey().getName());
System.out.println("group:"+jobDetail.getKey().getGroup());
System.out.println("jobClass:"+jobDetail.getJobClass().getName());

//3:触发器（Trigger）
Trigger trigger = TriggerBuilder.newTrigger()
    //参数1：触发器名称，触发器组的名称
    .withIdentity("trigger1", "group1")
    .startNow()//马上启动
    //每5秒重复执行一次
    .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
    .usingJobData("message","打印Trigger日志")
    .build();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

job实现类中获取对应的jobdataMap数据

/**
 * @Author: zkfgyzy@163.com
 * @Date: 2022/1/6 22:05
 */
public class HelloJob implements Job {


    public HelloJob(){
        System.out.println("我是HelloJob");
    }
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        //输出当前时间的job
        Date date = new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = simpleDateFormat.format(date);

        JobKey key = jobExecutionContext.getJobDetail().getKey();
        System.out.println("工作任务名称："+key.getName()+"     "+"工作内容组："+key.getGroup());
        System.out.println("任务类名称（带路径)："+jobExecutionContext.getJobDetail().getJobClass().getName());
        System.out.println("任务类的名称: "+jobExecutionContext.getJobDetail().getJobClass().getSimpleName());
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是："+dateString);

        //TODO   此处获取jobDataMap
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        String message = jobDataMap.getString("message");
        System.out.println(message);

        JobDataMap jobDataMap1 = jobExecutionContext.getTrigger().getJobDataMap();
        String message1 = jobDataMap1.getString("message");
        System.out.println(message1);

    }
}
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

获取当前任务的执行时间和下次执行时间

//获取其他内容
System.out.println("当前任务的执行时间："+jobExecutionContext.getFireTime());
System.out.println("下次任务的执行时间："+jobExecutionContext.getNextFireTime());
1
2
3

Job实现类中添加setter方法对应JobDataMap的键值，Quartz框架默认的JobFactory实现类在初始化job实例对象时会自动地调用这些setter方法。

这里注意：如果遇到同名的key，Trigger中的.usingJobData(“message”, “simple触发器”)会覆盖JobDetail中的.usingJobData(“message”, “打印日志”)。

public class HelloJob implements Job {


    private String message;

    public void setMessage(String message) {
        this.message = message;
    }
      @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {


        System.out.println(message);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

有状态的Job和无状态的Job

有状态的Job可以理解为多次Job调用期间可以持有一些状态信息，这些状态信息存储在JobDataMap中，而默认的无状态job每次调用时都会创建一个新的JobDataMap。
有状态的Job可以通过@PersistJobDataAfterExecution注解来实现
例子：JobDetail处定义了一个计数器，count=0; job实现类执行完以后，进行累加，由于Quartz的特性，每次执行job都是重新实例化一个对象，那么count最多永远为1，此时可以通过添加注解@PersistJobDataAfterExecution来解决。这个注解会保留上一次执行的值。等下次调用时会拿出累加的值
代码

JobDetail初始化count=0;

JobDetail job = JobBuilder.newJob(HelloJob.class)
    		.withIdentity("job1", "group1") // 定义该实例唯一标识
    		.usingJobData("message", "打印日志")
    		.usingJobData("count", 0)
    		.build();
1
2
3
4
5

Job实现类HelloJob添加属性

//添加count的setting和getting方法。
private Integer count;
public void setCount(Integer count) {
    this.count = count;
}
//执行execute()方法中累加count

++count;
System.out.println("count数量："+count);
context.getJobDetail().getJobDataMap().put("count", count);

1
2
3
4
5
6
7
8
9
10
11

HelloJob类没有添加@PersistJobDataAfterExecution注解，每次调用时都会创建一个新的JobDataMap。不会累加；
HelloJob类添加@PersistJobDataAfterExecution注解，多次Job调用期间可以持有一些状态信息，即可以实现count的累加。

Trigger

Trigger的架构图

Trigger结构图

Quartz有一些不同的触发器类型，不过，用得最多的是SimpleTrigger和CronTrigger。
Trigger有下面几个属性：

jobKey：表示job实例的标识，触发器被触发时，该指定的job实例会被执行
startTime：表示触发器的时间表，第一次开始被触发的时间，它的数据类型为java.util.Date
endTime：指定触发器终止被触发的时间，它的数据类型是java.util.Date

代码实现获取jobkey、startTime、endTime，以及设置触发器的开始时间结束时间

// 调度类
public class HelloSchedulerDemoTrigger {

    public static void main(String[] args) throws SchedulerException {
        //1:调度器（Scheduler)，从工厂中获取调度实例,默认是实例化了new StdSchedulerFactory
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        //开始时间
        Date startDate = new Date();
        startDate.setTime(startDate.getTime()+3000);
        //结束时间
        Date endDate = new Date();
        endDate.setTime(endDate.getTime()+10000);


        //2:任务实例(JobDetail)

        //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
        JobDetail jobDetail = JobBuilder.newJob(HelloJobTrigger.class)
                //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
                .withIdentity("job1", "group1")
                .usingJobData("message","打印JobDetail日志")
                .usingJobData("count",0)
                .build();

        //3:触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                //参数1：触发器名称，触发器组的名称
                .withIdentity("trigger1", "group1")
                //.startNow()//马上启动
                //每5秒重复执行一次,如果没有下面这个，表示立即执行，且执行一次
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
                //指定时间启动
                .startAt(startDate)
                //设置任务的结束触发时间
                .endAt(endDate)
                .usingJobData("message","打印Trigger日志")
                .build();

        //4. 使用调度器将触发器和任务jobdetail关联
        scheduler.scheduleJob(jobDetail,trigger);
        //5. 启动触发器
        scheduler.start();
    }
}
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
43
44
45

JobDetail类

public class HelloJobTrigger implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {


        //输出当前时间的job
        Date date = new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = simpleDateFormat.format(date);


        System.out.println("正在进行数据库备份工作，备份数据库的时间是"+dateString);

        //获取jobkey,startTime,endTime
        Trigger trigger = jobExecutionContext.getTrigger();
        System.out.println("jobkey的名称"+trigger.getJobKey().getName()+"  ;job的组名"+trigger.getJobKey().getGroup());
        System.out.println("jobkey的开始时间"+simpleDateFormat.format(trigger.getStartTime())+"  ;jobkey的结束时间"+simpleDateFormat.format(trigger.getEndTime()));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

SimpleTrigger简单触发器

SimpleTrigger对于设置和使用是最为简单的一种QuartzTrigger。它是为那种需要在特定的日期/时间启动，且以一个可能的间隔时间重复执行n次的Job设计的。

案例一：表示一个指定时间段内执行一次作业任务
案例二：在指定时间间隔内多次执行作业任务，注意默认值是0

// 3：定义触发器 ，马上执行, 然后每5秒重复执行一次
Trigger trigger = TriggerBuilder.newTrigger()
    .withIdentity("trigger1", "group1") // 定义该实例唯一标识
    .startAt(startDate)
    .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5)
                  .withRepeatCount(2)) // 每5秒执行一次，连续执行3次后停止，默认值是0
    .build();
1
2
3
4
5
6
7

SimpleTrigger的注意点

SimpleTrigger的属性有：开始时间、结束时间、重复次数和重复的时间间隔。
重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY。
重复的时间间隔属性值必须为大于0或长整型的正整数，以毫秒作为时间单位，当重复的时间间隔为0时，意味着与Trigger同时触发执行。—不能为0，为0会报错
如果有指定结束时间属性值，则结束时间属性优先于重复次数属性，这样的好处在于：当我们需要创建一个每间隔10秒钟触发一次直到指定的结束时间的 Trigger，而无需去计算从开始到结束的所重复的次数，我们只需简单的指定结束时间和使用REPEAT_INDEFINITELY作为重复次数的属性值即可。

CronTrigger触发器

如果你需要像日历那样按日程来触发任务，而不是像SimpleTrigger 那样每隔特定的间隔时间触发，CronTriggers通常比SimpleTrigger更有用,因为它是基于日历的作业调度器。
使用CronTrigger，你可以指定诸如“每个周五中午”，或者“每个工作日的9:30”或者“从每个周一、周三、周五的上午9：00到上午10：00之间每隔五分钟”这样日程安排来触发。甚至，象SimpleTrigger一样，CronTrigger也有一个startTime以指定日程从什么时候开始，也有一个（可选的）endTime以指定何时日程不再继续。

CRON表达式

Cron表达式被用来配置CronTrigger实例。Cron表达式是一个由7个子表达式组成的字符串。每个子表达式都描述了一个单独的日程细节。这些子表达式用空格分隔，分别表示：

1、Seconds 秒
2、Minutes 分钟
3、Hours 小时
4、Day-of-Month 月中的天
5、Month 月
6、Day-of-Week 周中的天
7、Year (optional field) 年（可选的域）----这个可以省略

cron表达式1

cron表达式语法

常用练习

"0 0 10,14,16 * * ?" 每天上午10点，下午2点，4点
"0 0/30 9-17 * * ?"   朝九晚五工作时间内每半小时，从0分开始每隔30分钟发送一次
"0 0 12 ? * WED" 表示每个星期三中午12点 
"0 0 12 * * ?" 每天中午12点触发 
"0 15 10 ? * *" 每天上午10:15触发 
"0 15 10 * * ?" 每天上午10:15触发 
"0 15 10 * * ? *" 每天上午10:15触发 
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发 
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发 
"0 0/55 14 * * ?" 在每天下午2点到下午2:55期间，从0开始到55分钟触发 
"0 0/55 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的，从0开始到55分钟触发 
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发 
"0 15 10 15 * ?" 每月15日上午10:15触发 
"0 15 10 L * ?" 每月最后一日的上午10:15触发 
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

案例：CronTragger触发器

定义任务类

// 定义任务类
public class HelloJobCronTrigger implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 定义时间
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = dateFormat.format(date);

        // 定义工作任务内容
        System.out.println("进行数据库备份操作。当前任务执行的时间："+dateString);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

定义触发器，并调度

public class HelloSchedulerDemoCronTrigger {

	public static void main(String[] args) throws Exception {
		// 1：从工厂中获取任务调度的实例
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 2：定义一个任务调度实例，将该实例与HelloJob绑定，任务类需要实现Job接口
        JobDetail job = JobBuilder.newJob(HelloJobCronTrigger.class)
        		.withIdentity("job1", "group1") // 定义该实例唯一标识
        		.build();

        // 3：定义触发器 ，马上执行, 然后每5秒重复执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
        		.withIdentity("trigger1", "group1") // 定义该实例唯一标识
        		.withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * 6 4 ?"))// 定义表达式
        		.build();

        // 4：使用触发器调度任务的执行
        scheduler.scheduleJob(job, trigger);
        
        // 5：开启
        scheduler.start();
        // 关闭
        // 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

细节注意：

1、‘L’和‘W’可以一起使用。（企业可用在工资计算）
2、‘#’可表示月中第几个周几。（企业可用在计算母亲节和父亲节）
3、周字段英文字母不区分大小写，例如MON==mon。
4、利用工具，在线生成。

Scheduler调度器

Quartz以模块方式构架，因此，要使它运行，几个组件必须很好的咬合在一起。幸运的是，已经有了一些现存的助手可以完成这些工作。

所有的Scheduler实例由SchedulerFactory创建

所有的Scheduler实例由SchedulerFactory来创建
Quartz的三个核心概念：调度器、任务、触发器。三者之间的关系是

Quartz的三个核心概念

一个Job可以有多个触发器Trigger，但是一个触发器Trigger只能对应一个Job。如果你需要一个更复杂的触发计划，你可以创建多个Trigger并指派它们给同一个Job

Scheduler的创建方式

StdSchedulerFactory

Quartz默认的SchedulerFactory

使用一组参数（java.util.Properties）来创建和初始化Quartz调度器
配置参数一般存储在quartz.properties文件中
调用getScheduler方法就能创建和初始化调度器对象

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

用法1：输出调度器开始的时间（重要：使得任务和触发器进行关联）：

public class HelloSchedulerDemoScheduler {

    public static void main(String[] args) throws SchedulerException {
        //1:调度器（Scheduler)，从工厂中获取调度实例,默认是实例化了new StdSchedulerFactory
        //Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        StdSchedulerFactory stdSchedulerFactory=new StdSchedulerFactory();
        Scheduler scheduler=stdSchedulerFactory.getScheduler();
        //2:任务实例(JobDetail)

        //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
        JobDetail jobDetail = JobBuilder.newJob(HelloJobScheduler.class)
                //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
                .withIdentity("job1", "group1")
                .usingJobData("message","打印JobDetail日志")
                .usingJobData("count",0)
                .build();

        //3:触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                //参数1：触发器名称，触发器组的名称
                .withIdentity("trigger1", "group1")
                //.startNow()//马上启动
                //使用日历触发器
                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))
              //  .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
                //指定时间启动
                .usingJobData("message","打印Trigger日志")
                .build();

        //4. 使用调度器将触发器和任务jobdetail关联
        Date date = scheduler.scheduleJob(jobDetail, trigger);
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("调度器开始调度时间"+dateFormat.format(date));
        //5. 启动触发器
        scheduler.start();
    }
}
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

用法2：启动任务调度：

//5. 启动触发器
scheduler.start();
1
2

用法3：任务调度挂起，即暂停操作

// Scheduler执行2秒后自动挂起
Thread.sleep(2000L);
scheduler.standby();	
// Scheduler执行5秒后自动开启
Thread.sleep(5000L);
scheduler.start();	
1
2
3
4
5
6

用法4：关闭任务调度

shutdown(true)：表示等待所有正在执行的job执行完毕之后，再关闭Scheduler；
shutdown(false)：表示直接关闭Scheduler
1
2

DirectSchedulerFactory和StdSchedulerFactory差不多，了解一下就行

DirectSchedulerFactory directSchedulerFactory = DirectSchedulerFactory.getInstance();
Scheduler scheduler = directSchedulerFactory.getScheduler();
1
2

Quartz.properties

在org.quartz的jar包内存在Quartz.properties的配置文件

org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000

org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
1
2
3
4
5
6
7
8
9
10
11
12
13

调度器部分

org.quartz.scheduler.instanceName属性用来区分特定的调度器实例，可以按照功能用途来给调度器起名。
org.quartz.scheduler.instanceId属性和前者一样，也允许任何字符串，但这个值必须在所有调度器实例中是唯一的，尤其是在一个集群环境中，作为集群的唯一key。假如你想Quartz帮你生成这个值的话，可以设置为AUTO。

线程池属性

threadCount：处理Job的线程个数，至少为1，但最多的话最好不要超过100，在多数机器上设置该值超过100的话就会显得相当不实用了，特别是在你的 Job 执行时间较长的情况下
threadPriority：线程的优先级，优先级别高的线程比级别低的线程优先得到执行。最小为1，最大为10，默认为5
org.quartz.threadPool.class：一个实现了 org.quartz.spi.ThreadPool 接口的类，Quartz 自带的线程池实现类是 org.quartz.smpl.SimpleThreadPool

作业调度设置

Quartz的插件设置

Quartz.properties案例

#===============================================================     
#Configure Main Scheduler Properties     调度器属性
#===============================================================  
#调度器的实例名     
org.quartz.scheduler.instanceName = QuartzScheduler     
#调度器的实例ID，大多数情况设置为auto即可  
org.quartz.scheduler.instanceId = AUTO     
 
#===============================================================     
#Configure ThreadPool     线程池属性
#===============================================================   
#处理Job的线程个数，至少为1，但最多的话最好不要超过100，在多数机器上设置该值超过100的话就会显得相当不实用了，特别是在你的 Job 执行时间较长的情况下
org.quartz.threadPool.threadCount =  5     
#线程的优先级，优先级别高的线程比级别低的线程优先得到执行。最小为1，最大为10，默认为5
org.quartz.threadPool.threadPriority = 5 
#一个实现了 org.quartz.spi.ThreadPool 接口的类，Quartz 自带的线程池实现类是 org.quartz.smpl.SimpleThreadPool      
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool     
 
#===============================================================     
#Configure JobStore 作业存储设置
#===============================================================      
#要使 Job 存储在内存中需通过设置  org.quartz.jobStrore.class 属性为 org.quartz.simpl.RAMJobStore 
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore     
 
#===============================================================     
#Configure Plugins    插件配置 
#===============================================================       
org.quartz.plugin.jobInitializer.class =       
org.quartz.plugins.xml.JobInitializationPlugin       
      
org.quartz.plugin.jobInitializer.overWriteExistingJobs = true      
org.quartz.plugin.jobInitializer.failOnFileNotFound = true      
org.quartz.plugin.jobInitializer.validating=false  
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

也可以编写程序代码操作quartz.properties文件的内容：

public class QuartzProperties {

	public static void main(String[] args) {
        // 创建工厂实例
        StdSchedulerFactory factory = new StdSchedulerFactory();
        
        // 创建配置工厂的属性对象
        Properties props = new Properties();
        props.put(StdSchedulerFactory.PROP_THREAD_POOL_CLASS, "org.quartz.simpl.SimpleThreadPool"); // 线程池定义
        props.put("org.quartz.threadPool.threadCount", "5"); // 默认Scheduler的线程数
        
        try {
            // 使用定义的属性初始化工厂
            factory.initialize(props);
            
            Scheduler scheduler = factory.getScheduler();
            
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

通过Properties设置工厂属性的缺点在用硬编码，假如需要修改例子中线程数量，将不得不修改代码，然后重新编译。我们这里不推荐使用。

Quartz的监听器

Quartz的监听器用于当任务调度中你所关注事件发生时，能够及时获取这一事件的通知。类似于任务执行过程中的邮件、短信类的提醒。Quartz监听器主要有JobListener、TriggerListener、SchedulerListener三种，顾名思义，分别表示任务、触发器、调度器对应的监听器。三者的使用方法类似，在开始介绍三种监听器之前，需要明确两个概念：全局监听器与非全局监听器，二者的区别在于：

全局监听器能够接收到所有的Job/Trigger的事件通知，
非全局监听器只能接收到在其上注册的Job或Trigger的事件，不在其上注册的Job或Trigger则不会进行监听。

JobListener job监听器

任务调度过程中，与任务Job相关的事件包括：job开始要执行的提示; job执行完成的提示。
JobListener监听器：

public interface JobListener {
    String getName();

    void jobToBeExecuted(JobExecutionContext var1);

    void jobExecutionVetoed(JobExecutionContext var1);

    void jobWasExecuted(JobExecutionContext var1, JobExecutionException var2);
}
1
2
3
4
5
6
7
8
9

getName方法：用于获取该JobListener的名称。
jobToBeExecuted方法：Scheduler在JobDetail将要被执行时调用这个方法。
jobExecutionVetoed方法：Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
jobWasExecuted方法：Scheduler在JobDetail被执行之后调用这个方法

案例使用JobListener

自定义一个Job

public class HelloJobListener implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {


        //输出当前时间的job
        Date date = new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString = simpleDateFormat.format(date);


        System.out.println("正在进行数据库备份工作，备份数据库的时间是"+dateString);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

自定义一个JobListener

public class MyListener implements JobListener {
    @Override
    public String getName() {
        String simpleName = this.getClass().getSimpleName();
        System.out.println("监听器的名称是："+simpleName);
        return simpleName;
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {

        String name = jobExecutionContext.getJobDetail().getKey().getName();
        System.out.println("Scheduler在jobDetail将要被执行时调用的方法"+name);

    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {

        String name = jobExecutionContext.getJobDetail().getKey().getName();
        System.out.println("job将要被执行，但是又被trigger否决时执行的方法："+name);

    }

    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {

        String name = jobExecutionContext.getJobDetail().getKey().getName();
        System.out.println("job被执行后调用的方法："+name);

    }
}
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

注册监听器到Scheduler

public class HelloSchedulerDemoListener {

    public static void main(String[] args) throws SchedulerException {
        //1:调度器（Scheduler)，从工厂中获取调度实例,默认是实例化了new StdSchedulerFactory
        //Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        StdSchedulerFactory stdSchedulerFactory=new StdSchedulerFactory();
        Scheduler scheduler=stdSchedulerFactory.getScheduler();
        //2:任务实例(JobDetail)

        //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
        JobDetail jobDetail = JobBuilder.newJob(HelloJobListener.class)
                //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
                .withIdentity("job1", "group1")
                .usingJobData("message","打印JobDetail日志")
                .usingJobData("count",0)
                .build();

        //3:触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                //参数1：触发器名称，触发器组的名称
                .withIdentity("trigger1", "group1")
                .startNow()//马上启动
                //使用日历触发器
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
              //  .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
                //指定时间启动
                .usingJobData("message","打印Trigger日志")
                .build();

        //4. 使用调度器将触发器和任务jobdetail关联
        Date date = scheduler.scheduleJob(jobDetail, trigger);
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("调度器开始调度时间"+dateFormat.format(date));
        // 6. 创建并注册一个全局的Job Listener
        //scheduler.getListenerManager().addJobListener(new MyListener(), EverythingMatcher.allJobs());

        //7. 创建一个局部的Job Listener 所谓的局部就是指定的job
        scheduler.getListenerManager().addJobListener(new MyListener(), KeyMatcher.keyEquals(JobKey.jobKey("job1","group1")));
        //5. 启动触发器
        scheduler.start();

    }
}
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
43

TriggerListener 触发器监听器

使用方法和JobListener相同，主要是监听触发器的一些情况：任务调度过程中，与触发器Trigger相关的事件包括：触发器触发、触发器未正常触发、触发器完成等。

public interface TriggerListener {

    public String getName();

    public void triggerFired(Trigger trigger, JobExecutionContext context);

    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context);

    public void triggerMisfired(Trigger trigger);

    public void triggerComplete(Trigger trigger, JobExecutionContext context,
            int triggerInstructionCode);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

getName方法：用于获取触发器的名称
triggerFired方法：当与监听器相关联的Trigger被触发，Job上的execute()方法将被执行时，Scheduler就调用该方法。
vetoJobExecution方法：在 Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行。
triggerMisfired方法：Scheduler 调用这个方法是在 Trigger 错过触发时。你应该关注此方法中持续时间长的逻辑：在出现许多错过触发的 Trigger 时，长逻辑会导致骨牌效应。你应当保持这上方法尽量的小。
triggerComplete方法：Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法。

案例 TriggerListener

job
TriggerListener

public class MyTriggerListener implements TriggerListener {


    private String name;

    public MyTriggerListener(String name) {
        this.name = name;
    }

    @Override
    public String getName() {
        return name;
    }

    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        String triggerName = trigger.getKey().getName();
        System.out.println(triggerName + " 被触发");
    }

    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        String triggerName = trigger.getKey().getName();
        System.out.println(triggerName + " 没有被触发");
        return true; // true：表示不会执行Job的方法
    }

    @Override
    public void triggerMisfired(Trigger trigger) {
        String triggerName = trigger.getKey().getName();
        System.out.println(triggerName + " 错过触发");
    }

    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context,
                                Trigger.CompletedExecutionInstruction triggerInstructionCode) {
        String triggerName = trigger.getKey().getName();
        System.out.println(triggerName + " 完成之后触发");
    }

}
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

Scheduler调度

public class HelloSchedulerDemoListener {

    public static void main(String[] args) throws SchedulerException {
        //1:调度器（Scheduler)，从工厂中获取调度实例,默认是实例化了new StdSchedulerFactory
        //Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        StdSchedulerFactory stdSchedulerFactory=new StdSchedulerFactory();
        Scheduler scheduler=stdSchedulerFactory.getScheduler();
        //2:任务实例(JobDetail)

        //加载任务类，与HelloJob完成绑定，要求HelloJob实现Job接口
        JobDetail jobDetail = JobBuilder.newJob(HelloJobListener.class)
                //参数1：任务的名称，(唯一实例)。参数2：任务组的名称
                .withIdentity("job1", "group1")
                .usingJobData("message","打印JobDetail日志")
                .usingJobData("count",0)
                .build();

        //3:触发器（Trigger）
        Trigger trigger = TriggerBuilder.newTrigger()
                //参数1：触发器名称，触发器组的名称
                .withIdentity("trigger1", "group1")
                .startNow()//马上启动
                //使用日历触发器
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
              //  .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatForever().withIntervalInSeconds(5))
                //指定时间启动
                .usingJobData("message","打印Trigger日志")
                .build();

        //4. 使用调度器将触发器和任务jobdetail关联
        Date date = scheduler.scheduleJob(jobDetail, trigger);
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("调度器开始调度时间"+dateFormat.format(date));
        // 6. 创建并注册一个全局的Job Listener
        //scheduler.getListenerManager().addJobListener(new MyListener(), EverythingMatcher.allJobs());

        //7. 创建一个局部的Job Listener 所谓的局部就是指定的job
      //  scheduler.getListenerManager().addJobListener(new MyListener(), KeyMatcher.keyEquals(JobKey.jobKey("job1","group1")));

        // 8. 创建并注册一个全局的Trigger Listener
        scheduler.getListenerManager().addTriggerListener(new MyTriggerListener("simpleTrigger"), EverythingMatcher.allTriggers());

        // 9. 创建并注册一个局部的Trigger Listener
        // scheduler.getListenerManager().addTriggerListener(new MyTriggerListener("simpleTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey("trigger1", "group1")));
        //5. 启动触发器
        scheduler.start();


    }
}

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
43
44
45
46
47
48
49
50
51

SchedulerListener 调度监听

SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用。与Scheduler有关的事件包括：增加一个job/trigger，删除一个job/trigger，scheduler发生严重错误，关闭scheduler等

public interface SchedulerListener {

    public void jobScheduled(Trigger trigger);

    public void jobUnscheduled(String triggerName, String triggerGroup);

    public void triggerFinalized(Trigger trigger);

    public void triggersPaused(String triggerName, String triggerGroup);

    public void triggersResumed(String triggerName, String triggerGroup);

    public void jobsPaused(String jobName, String jobGroup);

    public void jobsResumed(String jobName, String jobGroup);

    public void schedulerError(String msg, SchedulerException cause);

    public void schedulerStarted();

    public void schedulerInStandbyMode();

    public void schedulerShutdown();

    public void schedulingDataCleared();
}
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

方法介绍

其中：

jobScheduled方法：用于部署JobDetail时调用
jobUnscheduled方法：用于卸载JobDetail时调用
triggerFinalized方法：当一个 Trigger 来到了再也不会触发的状态时调用这个方法。除非这个 Job 已设置成了持久性，否则它就会从 Scheduler 中移除。
triggersPaused方法：Scheduler 调用这个方法是发生在一个 Trigger 或 Trigger 组被暂停时。假如是 Trigger 组的话，triggerName 参数将为 null。
triggersResumed方法：Scheduler 调用这个方法是发生成一个 Trigger 或 Trigger 组从暂停中恢复时。假如是 Trigger 组的话，假如是 Trigger 组的话，triggerName 参数将为 null。参数将为 null。
jobsPaused方法：当一个或一组 JobDetail 暂停时调用这个方法。
jobsResumed方法：当一个或一组 Job 从暂停上恢复时调用这个方法。假如是一个 Job 组，jobName 参数将为 null。
schedulerError方法：在 Scheduler 的正常运行期间产生一个严重错误时调用这个方法。
schedulerStarted方法：当Scheduler 开启时，调用该方法
schedulerInStandbyMode方法：当Scheduler处于StandBy模式时，调用该方法
schedulerShutdown方法：当Scheduler停止时，调用该方法
schedulingDataCleared方法：当Scheduler中的数据被清除时，调用该方法。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/42739?site