Quartz

一、引言

1、简介

Quartz ：http://www.quartz-scheduler.org/
是一个定时任务调度框架。
Quartz是要做定时任务的调度，设置好触发时间规则，以及相应的任务(Job)即可。

二、使用

1、导入依赖

<dependencies>
	<dependency>
    	<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			 <version>2.3.2</version>
	</dependency>
</dependencies>

2、定义Job

public class QuartzJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {

        //创建工作详情
        JobDetail jobDetail = context.getJobDetail();

        //获取工作名称
        String name = jobDetail.getKey().getName();//任务名
        String group = jobDetail.getKey().getGroup();//任务小组

        System.out.println("job执行，job:"+name+"    group:"+group + new Date());
    }
}

3、API测试

public class Triggle {
    public static void main(String[] args) throws Exception {

        //创建调度器
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        //定义一个工作
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class)
                .withIdentity("job1","group1")
                .build();

        //定义一个Trigger，触发条件类
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()//一旦加入调度器，立即生效，即开始计时
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().
                        withIntervalInSeconds(2).//每隔两秒执行一次
                        repeatForever())//一直执行
                .endAt(new GregorianCalendar(2020, 5,
                        30, 10, 1, 1).
                        getTime())//设置结束时间
                .build();

        //在调度器中加入任务和触发器
        scheduler.scheduleJob(jobDetail, trigger);

        //启动任务调度器
        scheduler.start();
    }
}

4、配置

# 指定调度器名称，实际类型为：QuartzScheduler
org.quartz.scheduler.instanceName = MyScheduler
# 指定连接池
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
# 连接池线程数量
org.quartz.threadPool.threadCount = 11
# 优先级
org.quartz.threadPool.threadPriority = 5
# 不持久化job
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

5、核心类说明

1. Scheduler：调度器。所有的调度都由调度器来完成，相当于Quartz的大脑，所有任务都由它来管理。
2. Job：任务，即像定时执行的事情。
3. JobDetail：基于Job，进一步进行包装。其中关联一个Job，并为其指定更详细的属性，比如标识等。
4. Trigger：触发器，可以给某个指定任务。指定任务的触发机制。

三、触发器Trigger

1、SimpleTrigger

以一定的时间间隔执行的任务（单位：毫秒）。

• 指定起始和截至时间（时间段）
• 指定时间间隔、执行次数

//定义一个SimpleTrigger，触发条件类
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()//一旦加入调度器，立即生效，即开始计时
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().
                        withIntervalInSeconds(2).//每隔两秒执行一次
//                        repeatForever())//一直执行
                        withRepeatCount(3))//执行次数不超过3次
                .endAt(new GregorianCalendar(2020, 5, 30, 16, 1, 1).
        		getTime())//设置结束时间
        		.build();

2、CronTrigger

适合于更复杂的任务，它支持类型于Linux Cron的语法

• 指定Cron表达式即可

CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity("cronTrigger1","group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("*/2 36 10 30 6 ?"))
                .build();

Cron表达式组成（重点）

“秒 分 时 日 月 周 年”，其中“年”可选，一般不指定。

如：“10 20 15 30 6 ?” 表示 6月30日15点20分10秒，周几不确定。

• 秒 允许值：0~59
• 分钟 允许值：0~59
• 小时 允许值：0~23
• 日期 允许值：1~31
• 月份 允许值：1~12
• 星期 允许值：1~7
• 年份（可选）

特殊符号

（*） 对应时间域的每一个时刻
（?）通常只在日期和星期字段使用，指定为“不确定值”
（-）表达一个范围，10-12，即10，11，12
（,）表达一个列表式，10，23，8，即10，23，8
（/）x/y表达一个等步长序列，x为起始值，y为增量步长值，0/15，即1，15，30，45，同样，5/15，即5，20，35，50
（#）只用在星期字段中，“4#2”，即第二个星期三，“5#4”，即第四个星期四
（L）只在日期和星期字段使用，代表Last，在星期中表示星期六，等同于7；在日期中表示一个月的最后一天，如1月的31号，4月的30号
（W）只在日期字段，是对前导日期的修饰，表示离该日期最近的工作日，15W，假如15号是星期六，则15W匹配14号星期五；假如15号是星期日，则15W匹配16号星期一，但注意，关联日期不能跨月
（LW）在日期字段里组合使用，当月的最后一个工作日

四、Spring整合Quartz（重点）

1、导入依赖

<dependencies>
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context-support</artifactId>
		<version>5.2.6.RELEASE</version>
	</dependency>

	 <dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-tx</artifactId>
		<version>5.2.6.RELEASE</version>
	</dependency>

	<dependency>
		<groupId>org.quartz-scheduler</groupId>
		<artifactId>quartz</artifactId>
		<version>2.3.2</version>
	</dependency>
</dependencies>

2、定义Job类

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("job执行：" + new Date());
    }
}

3、配置

调度器 SchedulerFactoryBean
触发器 CronTriggerFactoryBean
JobDetail JobDetailFactoryBean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans

        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--
        spring整合Quartz进行配置的步骤：
        1.定义工作任务的Job;
        2.定义触发器Trigger，并将触发器与工作任务绑定；
        3.定义调度器，并将触发器注册到调度器
      -->

    <!--  1.定义工作任务的bean  也可以使用MethodInvokingJobDetailFactoryBean-->
    <bean name="job" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="name" value="job1"></property>
        <property name="group" value="group1"></property>
        <property name="jobClass" value="com.job.MyJob"></property>
    </bean>

    <!--  2.定义触发器Trigger  -->
    <bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="name" value="trigger1"></property>
        <property name="group" value="group1"></property>
        <property name="jobDetail" ref="job"></property>
        <property name="cronExpression" value="* * * * * ?"></property>
    </bean>

    <!--  3.定义调度器，并将trigger注册到调度器  -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="trigger"/>
            </list>
        </property>
        <!--    添加 quartz 配置    -->
        <property name="quartzProperties">
            <value>
                # 指定调度器名称，实际类型为：QuartzScheduler
                org.quartz.scheduler.instanceName = MyScheduler
                # 指定连接池
                org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
                # 连接池线程数量
                org.quartz.threadPool.threadCount = 11
                # 优先级
                org.quartz.threadPool.threadPriority = 5
                # 不持久化job
                org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
            </value>
        </property>
    </bean>

</beans>

4、操作

4.1 启动任务

  //工厂启动，任务启动
     ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

4.2 删除任务

scheduler.deleteJob(JobKey.jobKey("job1","group1"));

4.3 暂停 恢复

   scheduler.pauseJob(JobKey.jobKey("job1","group1"));
    scheduler.resumeJob(JobKey.jobKey("job1","group1"));

4.4 批量操作

GroupMatcher<JobKey> group1 = GroupMatcher.groupEquals("group1");
scheduler.pauseJobs(group1);
scheduler.resumeJobs(group1);