2.Quartz定时任务

目录

---

Java定时任务调度专栏目录（点击进入…）

---

基本介绍

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个、百个、甚至是好几万个Jobs这样复杂的日程序表，Jobs可以做成标准的Java组件或EJBs
Quartz是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统
Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能，这些功能的主要接口（API）是Scheduler接口，它提供了简单的操作
例如：将任务纳入日程或者从日程中取消，开始、停止、暂停日程进度

（1）完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制
（2）可以与J2EE与J2SE应用程序相结合也可以单独使用
（3）允许程序开发人员根据时间的间隔来调度作业
（4）实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联
（5）免费使用，并根据Apache 2.0许可

Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如任务执行前事件、任务执行后事件、触发器触发前事件、触发后事件、调度器开始事件、关闭事件等等，可以注册相应的监听器处理感兴趣的事件。

下载

1.进入官网

http://www.quartz-scheduler.org/

2.选择版本下载

3.文件目录说明

执行流程

Job为作业的接口，为任务调度的对象；JobDetail用来描述Job的实现类及其他相关的静态信息；Trigger做为作业的定时管理工具，一个Trigger只能对应一个作业实例，而一个作业实例可对应多个触发器；Scheduler做为定时任务容器，是Quartz最上层的东西，它提携了所有触发器和作业，使它们协调工作，每个Scheduler都存有JobDetail和Trigger的注册，一个Scheduler中可以注册多个JobDetail和多个Trigger

核心接口

（1）Job（任务接口，无状态）

开发者实现该接口定义运行任务。表示一个工作，要执行的具体内容。此接口中只有一个方法

public interface Job {
    void execute(JobExecutionContext context) throws JobExecutionException;
}

Job是一个执行任务的简单java类。任务可以是任何java代码
只需实现org.quartz.Job接口，并将需要执行的任务代码写在execute()中即可。当Quartz确定该是作业运行的时候，它将调用作业。Quartz提供了一个机制来建立具有不同粒度的、可重复的调度表，于是，只需创建一个java类，这个类被调用而执行任务

类	描述
JobExecutionContext类	提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中

（2）StatefulJob（任务接口，有状态）

任务在执行任务过程中，任何对Job Data Map所作的更改都将丢失而且任务下次执行时也无法看到。
StatefulJob在任务的每次执行之后重新存储JobDataMap

Job vs. StatefulJob
JobDataMap在每次执行之后重新持久化到JobStore中。
两个或多个有状态的JobDetail实例不能并发执行

StatefulJob子接口
Job有一个StatefulJob子接口，代表有状态的任务，该接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。无状态任务在执行时拥有自己的JobDataMap拷贝，对JobDataMap的更改不会影响下次的执行。而有状态任务共享共享同一个 JobDataMap实例，每次任务执行对JobDataMap所做的更改会保存下来，每次执行任务后都会对后面的执行发生影响。
正因为这个原因，无状态的Job可以并发执行，而有状态的StatefulJob不能并发执行，这意味着如果前次的StatefulJob还没有执行完毕，下一次的任务将阻塞等待，直到前次任务执行完毕。有状态任务比无状态任务需要考虑更多的因素，程序往往拥有更高的复杂度，因此除非必要，应该尽量使用无状态的Job
如果Quartz使用了数据库持久化任务调度信息，无状态的JobDataMap仅会在Scheduler注册任务时保持一次，而有状态任务对应的JobDataMap在每次执行任务后都会进行保存。

Trigger自身也可以拥有一个JobDataMap其关联的Job可以通过JobExecutionContext#getTrigger()
.getJobDataMap()获取Trigger中的JobDataMap。不管是有状态还是无状态的任务，在任务执行期间对Trigger的JobDataMap所做的更改都不会进行持久，也即不会对下次的执行产生影响。

（3）JobDetail（任务描述）

表示一个具体的可执行的调度程序。ob是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略
Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色
通过该类的构造函数可以更具体地了解它的功用：JobDetail(java.lang.String name, java.lang.String group, java.lang.Class jobClass)，该构造函数要求指定Job的实现类，以及任务在Scheduler中的组名和Job名称

JobDetail对象由Quartz客户端在Job被加入到scheduler时创建。它包含了Job的各种设置属性以及一个JobDataMap对象，这个对象被用来存储给定Job类实例的状态信息。Scheduler并不保存真正的Job Class，而是通过JobDetail来保存。

注意：给scheduler传入了一个JobDetail实例，而且这个JobDetail实例只是简单提供了类名来引用被执行的Job。每次scheduler执行这个任务时，它就创建这个类的新实例，然后调用该实例的execute()。Job不必担心线程安全性，因为同一时刻仅有一个线程去执行给定Job类的实例，甚至是并发执行同一Job也是如此
（1）Job类必须有一个无参数的构造函数
（2）Job类中定义的成员数据失去意义，因为这些成员数据值在每次执行的时候被“清空”了

（4）JobBuilder：定义、创建JobDetail实例

（5）Trigger（触发器）

代表一个调度参数的配置，什么时候去调

1.SimpleTrigger：简单触发

SimpleTrigger用来触发只需执行一次或者在给定时间触发并且重复N次且每次执行延迟一定时间的任务
如果想让触发器在2020年4月25日，上午11: 23:54秒执行，然后每个隔10秒钟重复执行一次，并且这样重复5次，那么SimpleTrigger就可以满足要求

2.CronTrigger：表达式触发

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

Quartz Cron表达式
支持7个域，分别是秒/分/时/日/月/周/年。年是非必须项
Cron表达式用来配置CronTrigger实例。Corn表达式是一个由7个表达式组成的字符串。每个表达式都描述了一个单独的日程细节。这些表达式用空格分隔

注意：cron表达式中不区分大小写
Cron表达式对特殊字符的大小写不敏感，对代表星期的缩写英文大小写也不敏感

名称	是否必须	允许值	特殊字符
秒	是	0-59	, - * /
分	是	0-59	, - * /
时	是	0-23	, - * /
日	是	1-31	, - * ? / L W C
周	是	1-7 或 SUN-SAT	, - * ? / L C #
月	是	1-12 或 JAN-DEC	, - * /
年	否	空 或 1970-2099	, - * /

星号（*）：可用在所有字段中，表示对应时间域的每一个时刻，例如：在分钟字段时，表示“每分钟”
问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符；
减号（-）：表达一个范围，如在小时字段中使用“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，你也可以使用*/y，它等同于0/y；
L（每月/星期的最后一天）：该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；如果L用在星期中，则表示星期六，等同于7。但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后X天”，例如：6L表示该月的最后星期五
W（日期）：该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。W字符串只能指定单一日期，而不能指定日期范围；
LW组合：在日期字段可以组合使用LW，它的意思是当月的最后一个工作日；
井号（#）：该字符只能在星期字段中使用，表示当月某个工作日。如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发；
C：该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天

常用案例

表示式	描述
0 0 12 * * ?	每天12点运行
0 15 10 ? * *	每天10:15运行
0 15 10 * * ?	每天10:15运行
0 15 10 * * ? *	每天10:15运行
0 15 10 * * ? 2008	在2008年的每天10：15运行
0 * 14 * * ?	每天14点到15点之间每分钟运行一次，开始于14:00，结束于14:59
0 0/5 14 * * ?	每天14点到15点每5分钟运行一次，开始于14:00，结束于14:55
0 0/5 14,18 * * ?	每天14点到15点每5分钟运行一次，此外每天18点到19点每5钟也运行一次
0 0-5 14 * * ?	每天14:00点到14:05，每分钟运行一次
0 10,44 14 ? 3 WED	3月每周三的14:10分到14:44，每分钟运行一次
0 15 10 ? * MON-FRI	每周一，二，三，四，五的10:15分运行

（6）TriggerBuilder：定义、创建Trigger实例

（7）Calendar（时间日期包装类）

org.quartz.Calendar和java.util.Calendar不同，它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合，代表一个日历时间点）。一个Trigger可以和多个Calendar关联，以便排除或包含某些时间点

假设：安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用 Calendar进行定点排除
针对不同时间段类型，Quartz在org.quartz.impl.calendar包下提供了若干个Calendar 的实现类，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义

（8）Scheduler（调度器）

代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了

代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据，Trigger的组及名称必须唯一，JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法，允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

Scheduler可以将Trigger绑定到某一JobDetail中，这样当Trigger触发时，对应的Job就被执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。 Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和
Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例
Scheduler接口有两个实现类：StdScheduler（标准默认调度器）、RemoteScheduler（远程调度器）

常用方法

方法	描述
shutdown()	关闭定时任务调度器
Date scheduleJob(JobDetail jobDetail,Trigger trigger)	添加一个定时任务
Date rescheduleJob(String triggerName,String groupName, Trigger newTrigger)	修改一个定时任务，主要是更改trigger
boolean deleteJob(String jobName,String jobGroup)	删除一个定时任务，同时也会将于该jobDetail关联的trigger一并删除
String[] getJobGroupNames()	取得所有的jobDetail组
String[] getJobNames(String groupName)	取得某个group下的所有的jobDetail
JobDetail getJobDetail(String jobName,String jobGroup)	取得指定的jobDetail
Trigger[] getTriggersOfJob(String jobName,String groupName)	取得指定的jobDetail的所有的Trigger
Trigger getTrigger(String triggerName,String triggerGroup)	取得指定的Trigger

（9）ThreadPool（线程池）

Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率

基本使用

1.导入依赖

<!-- quartz任务调度 -->
<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.3.2</version>
</dependency>
<dependency>
	<groupId>com.zaxxer</groupId>
	<artifactId>HikariCP-java7</artifactId>
	<version>2.4.13</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-api</artifactId>
	<version>1.7.7</version>
</dependency>
<!-- c3p0依赖，已导入 -->
<dependency>
	<groupId>com.mchange</groupId>
	<artifactId>c3p0</artifactId>
	<version>0.9.5.4</version>
</dependency>
<dependency>
	<groupId>com.mchange</groupId>
	<artifactId>mchange-commons-java</artifactId>
	<version>0.2.15</version>
</dependency>

2.创建一个实现Job类的execute()，存放具体的任务

public class HelloJob implements Job {
	public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		// 打印当前的执行时间
		Date date = new Date();
		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("现在的时间是：" + sf.format(date));
		// 具体的业务逻辑
		System.out.println("Hello Quartz");
	}
}

3.使用SimpleTrigger（简单触发器）、Scheduler（调度器）

public class HelloScheduler {
    public static void main(String[] args) throws SchedulerException {
        //创建一个jobDetail的实例，将该实例与HelloJob Class绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
			.withIdentity("myJob")
			.build();
			
        //创建一个Trigger触发器的实例，定义该job立即执行，并且之后每2秒执行一次，一直执行
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
			.withIdentity("myTrigger")
			.startNow().withSchedule(SimpleScheduleBuilder
			.simpleSchedule()
			.withIntervalInSeconds(2)
			.repeatForever())
			.build();
        //创建schedule实例。调度器
        StdSchedulerFactory factory = new StdSchedulerFactory();
        Scheduler scheduler = factory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail,trigger);
    }
}

Spring中使用

1.导入依赖

<!-- spring后需要context-support -->
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
	<version>4.3.26.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-log4j12</artifactId>
	<version>1.7.7</version>
</dependency>
<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>2.3.0</version>
</dependency>
<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz-jobs</artifactId>
	<version>2.3.0</version>
</dependency> 

2.三种方式

方式一

（1）继承QuartzJobBean，并重写executeInternal(JobExecutionContext context)

//继承QuartzJobBean，并重写executeInternal方法  
public class QuartzTask extends QuartzJobBean {
	private int timeout;
	private static int i = 0;

	// 调度工厂实例化后，经过timeout时间开始执行调度
	public void setTimeout(int timeout) {
		this.timeout = timeout;
	}

	@Override
	protected void executeInternal(JobExecutionContext context) 
throws JobExecutionException {
		System.out.println("task running..." + ++i + "进行中...");
	}
}

（2）配置spring-quratz.xml文件
1.任务调用类；2.任务调用方式；3.任务调用工厂

<!-- 1.配置任务类 -->
<bean id="myJobDetail"
	class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
	<!-- 指定job的名称 -->
	<property name="name" value="exampleJob"/>
	<!-- 指定具体的job类 -->
	<property name="quartzClass" value="com.my.pojo.QuartzTask"/>
	<property name="jobDataAsMap">
		<map>
			<entry key="timeout" value="0" />
		</map>
	</property>
	<!-- 指定job的分组 -->
	<property name="group" value="jobs" />
	<!-- 必须设置为true，如果为false，当没有活动的触发器与之关联时会在调度器中删除该任务 -->
	<property name="durability" value="true" />
	<!-- 指定spring容器的key，如果不设定在job中的jobmap中是获取不到spring容器的 -->
	<property name="applicationContextJobDataKey" value="applicationContext" />
</bean>
	
<!-- 2.调度触发器方式 -->
<bean id="cronTriggerBean"
		class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
	
	<property name="jobDetail">
		<ref bean="myJobDetail" />
	</property>
	<!-- cron表达式 -->
	<!-- 每一分钟执行一次 -->
	<property name="cronExpression" value="0 */1 * * * ?" />
</bean>
	
<!-- 一个job可以有多个trigger -->
<bean id="cronTriggerBeanTwo"
	class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
	<property name="jobDetail" ref="myJobDetailTwo" />
	<property name="cronExpression" value="0 */1 * * * ?" />
</bean>
	
<!-- 3.调度工厂 -->
<bean id="SpringJobSchedulerFactoryBean"
	class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="triggers">
		<list>
			<ref bean="cronTriggerBean" />
			<ref bean="cronTriggerBeanTwo" />
		</list>
	</property>
</bean>

方式二

（1）不需要继承基类，仍然是POJO

public class QuartzJob {  
    public void work(){  
        System.out.println("work running...");
    }
}

（2）在spring-quratz.xml配置文件中，配置包装类

<!-- 1.包装工作类 -->
<bean id="quartzJob" class="spring.demo.pojo.QuartzJob"></bean>

<!-- 2.调度触发器方式 -->
<bean id="jobTask"
	class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	<!-- 需要包装的类,即调度类 -->
	<property name="targetObject">
		<ref bean="quartzJob" />
	</property>
	<!-- 调用类中的方法 -->
	<property name="targetMethod">
		<!-- 具体的方法 -->
		<value>work</value>
	</property>
</bean>

<!-- 3.调度触发器方式 -->
<bean id="cronTriggerBean"
	class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
	<property name="jobDetail">
		<ref bean="jobTask" />
	</property>
	<!-- cron表达式 -->
	<property name="cronExpression">
		<value>10,15,20,25,30,35,40,45,50,55 * * * * ?</value>
	</property>
</bean>

<!-- 4.调度工厂 -->
<bean id="SpringJobSchedulerFactoryBean"
	class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="triggers">
		<list>
			<ref bean="cronTriggerBean" />
		</list>
	</property>
</bean>

方式三

（1）配置applicationContext.xml
通过@Scheduled注解的方式实现，需要修改applicationContext.xml三个部分内容
applicationContext.xml中添加task命名空间，然后添加如下代码

<task:annotation-driven/>

（2）使用@Scheduled注解
最后在定时任务上添加上@Scheduled注解即可，一般都采用cronTrigger方式，即@Scheduled（cron=“相应的定时表达式”）

@Service
public class QuartzService {
	@Scheduled(cron = "0/2 * * * * *")
	public void process() {
		System.out.println("job run...");
	}

	public static void main(String[] args) throws InterruptedException {
		ClassPathXmlApplicationContext context = 
new ClassPathXmlApplicationContext("applicationContext.xml");
		while (true) {
			System.out.println("main running..." + context);
			Thread.sleep(10000);
		}
	}
}

Spring Boot整合Quartz任务调度

1.导入依赖

<!--spring boot集成quartz -->
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

2.实现QuartzJobBean，提供具体任务（DateTimeJob.java，具体的业务逻辑代码）

public class DateTimeJob extends QuartzJobBean {
	@Override
	protected void executeInternal(JobExecutionContext jobExecutionContext) 
throws JobExecutionException {
		// 获取JobDetail中关联的数据
		String msg = (String) jobExecutionContext.getJobDetail()
.getJobDataMap()
.get("msg");
		System.out.println("current time :" + new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + "---" + msg);
	}
}

3.@Configuration配置类（QuartzConfig.java，配置触发器、调度器）

@Configuration
public class QuartzConfig {
	
	// 任务描述，具体可执行的程序
	@Bean
	public JobDetail printTimeJobDetail() {
		return JobBuilder.newJob(DateTimeJob.class) // PrintTimeJob业务类
				.withIdentity("DateTimeJob") // 可以给该JobDetail起一个id
				// 每个JobDetail内都有一个Map，包含了关联到这个Job的数据，在Job类中可以通过context获取
				.usingJobData("msg", "Hello Quartz") // 关联键值对
				.storeDurably() // 即使没有Trigger关联时，也不需要删除该JobDetail
				.build();
	}

    // 触发器关联调度器
	@Bean
	public Trigger printTimeJobTrigger() {
		// 表达式调度器
		CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
.cronSchedule("0/1 * * * * ?");
		return TriggerBuilder.newTrigger()
						.forJob(printTimeJobDetail()) // 关联上述的JobDetail
						.withSchedule(cronScheduleBuilder) // 关联触发器
						.withIdentity("quartzTaskService") // 给Trigger（触发器）起个名字
						.build();
	}
}