Quartz定时器与定时任务知识概括@TOC 定时任务调度什么是定时任务：定时任务是指调度程序在指定的时间或周期触发

定时任务调度

什么是定时任务：

定时任务是指调度程序在指定的时间或周期触发执行的任务
使用场景：发送邮件、统计、状态修改、消息推送、活动开启、增量索引

定时任务实现技术：

Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。使用较少。
ScheduledExecutorService：也是jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
Spring3.0以后自主开发的定时任务工具spring task，使用简单，支持线程池，可以高效处理许多不同的定时任务，除spring相关的包外不需要额外的包，支持注解和配置文件两种形式。不能处理过于复杂的任务
专业的定时框架quartz，功能强大，可以让你的程序在指定时间执行，也可以按照某一个频度执行，支持数据库、监听器、插件、集群。一般使用spring整合quartz或者springboot整合quartz。

其他定时器

Timer：

/**
 * java timer 测试类
 * Created by gaozhy on 2017/6/24.
 */
public class JavaTimer {

    public static void main(String[] args) {
        try {
            // 创建定时器
            Timer timer = new Timer();

            // 添加调度任务
            // 安排指定的任务在指定的时间开始进行重复的 固定延迟执行
            timer.schedule(new MyTask(),new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2017-06-24 22:31:10"),10*1000);
            // 安排指定的任务在指定的延迟后开始进行重复的 固定速率执行
            //timer.scheduleAtFixedRate(new MyTask(),new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2017-06-24 22:31:10"),10*1000);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

/**
 * 任务类
 * Created by gaozhy on 2017/6/24.
 */
public class MyTask extends TimerTask{

    // 定义调度任务
    public void run() {
        System.out.println("log2:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }
}

ScheduledExecutorService:

该方法跟Timer类似，直接看demo：

public class TestScheduledExecutorService {

   public static void main(String[] args) {

       ScheduledExecutorService service = Executors.newSingleThreadScheduledExecutor();

       // 参数：1、任务体 2、首次执行的延时时间
       //      3、任务执行间隔 4、间隔时间单位
       service.scheduleAtFixedRate(()->System.out.println("task ScheduledExecutorService "+new Date()), 0, 3, TimeUnit.SECONDS);

   }

}

Spring Task：

基于配置：

/**
 * Spring Task 任务类
 * Created by gaozhy on 2017/6/24.
 */

public class SpringTask {

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    public void m1(){
        System.out.println("m1:"+simpleDateFormat.format(new Date()));
    }

    public void m2(){
        System.out.println("m2:"+simpleDateFormat.format(new Date()));
    }

    public void m3(){
        System.out.println("m2:"+simpleDateFormat.format(new Date()));
    }
}

<!--spring-task.xml配置-->
<bean id="springTask" class="com.baizhi.task.SpringTask"></bean>
   <!--注册调度任务-->
   <task:scheduled-tasks>
       <!--延迟8秒 执行任务-->
       <!--<task:scheduled ref="springTask" method="m1" fixed-delay="8000" />-->

       <!--固定速度5秒 执行任务-->
       <!--<task:scheduled ref="springTask" method="m2" fixed-rate="5000"/>-->

       <!--
           使用cron表达式 指定触发时间
           spring task 只支持6位的cron表达式 秒 分 时 日 月 星期
       -->
       <task:scheduled ref="springTask" method="m3" cron="50-59 * * ? * *"/>
   </task:scheduled-tasks>

   <!--执行器配置-->
   <task:executor id="threadPoolTaskExecutor" pool-size="10" keep-alive="5"></task:executor>

   <!--调度器配置-->
   <task:scheduler id="threadPoolTaskScheduler" pool-size="10"></task:scheduler>

基于注解

/**
 * Spring Task 任务类
 * Created by gaozhy on 2017/6/24.
 */
public class SpringAnnotationTask {

    private SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

   /* @Scheduled(fixedDelay = 8000)
    public void m1(){
        System.out.println("m1:"+simpleDateFormat.format(new Date()));
    }

    @Scheduled(fixedRateString = "5000")
    public void m2(){
        System.out.println("m2:"+simpleDateFormat.format(new Date()));
    }
    */
    @Scheduled(cron = "0-30 * * * * ?")
    public void m3(){
        System.out.println("m2:"+simpleDateFormat.format(new Date()));
    }
}

<!--开启基于注解的spring task-->
<task:annotation-driven></task:annotation-driven>

<bean id="springAnnotationTask" class="com.baizhi.task.SpringAnnotationTask"></bean>

Spring Task任务执行和调度（TaskExecutor,TaskSchedule）：

介绍： ①Spring Framework分别使用TaskExecutor和TaskScheduler接口提供异步执行和任务调度的抽象。Spring还具有支持线程池或在应用程序服务器环境中委托给CommonJ的接口的实现。最终，在公共接口背后使用这些实现抽象出了JavaSE 5，Java SE 6和Java EE环境之间的差异。 ②Spring还提供了集成类，用于支持使用Timer（自1.3以来的JDK的一部分）和Quartz Scheduler（quartz-scheduler.org）进行调度。这两个调度程序都是使用FactoryBean设置的，它们分别具有对Timer或Trigger实例的可选引用。此外，还提供了Quartz Scheduler和Timer的便捷类，它允许您调用现有目标对象的方法（类似于正常的MethodInvokingFactoryBean操作）。
Spring官方对TaskExecutor的相关解释： ①Spring的TaskExecutor接口与java.util.concurrent.Executor接口相同。该接口具有单个方法(execute(Runnable task))，该方法根据线程池的语义和配置接受要执行的任务。 ②TaskExecutor接口相关实现类：

实现类名	对应解释(直接甩翻译了)
SyncTaskExecutor	该实现类不会执行异步调用。相反，每次调用都在调用的线程中进行(翻译过来也即同步任务执行器)。它主要用于不需要多线程的情况，例如在简单的测试用例中。
SimpleAsyncTaskExecutor	此实现不会重用任何线程。相反，它为每次调用启动一个新线程。但是，它确实支持并发限制，该限制会阻止超出限制的任何调用，直到释放插槽为止。(说简单了，就是要使用了直接创建一个线程)
ConcurrentTaskExecutor	此实现是java.util.concurrent.Executor实例的适配器。很少需要直接使用ConcurrentTaskExecutor(官网自己都觉得很少使用，不过相对于ThreadPoolTaskExecutor，官网推荐如果ThreadPoolTaskExecutor不够灵活，无法满足需求，则可以使用ConcurrentTaskExecutor)。
ThreadPoolTaskExecutor	杀手锏级的任务调度器(最常用)，可以说已经足够满足我们的需求了(除非,非常非常特例才使用ConcurrentTaskExecutor)。官网翻译重要片段:公开了bean属性，用于配置java.util.concurrent.ThreadP	oolExecutor并将其包装在TaskExecutor中
WorkManagerTaskExecutor	此实现使用CommonJ WorkManager作为其后备服务提供程序，并且是在Spring应用程序上下文中在WebLogic或WebSphere上设置基于CommonJ的线程池集成的中心便利类。
DefaultManagedTaskExecutor	此实现在JSR-236兼容的运行时环境（例如Java EE 7+应用程序服务器）中使用JNDI获取的ManagedExecutorService，为此目的替换CommonJ WorkManager。(说明了就是依赖环境)

Spring官方对TaskSheduler接口的相关解释： ①用于在将来的某个时间点调度任务。 ②TaskScheduler接口相关实现类：

实现类名	对应解释
ConcurrentTaskScheduler	该类实际继承了ConcurrentTaskExecutor对象。只是实现了TaskScheduler接口，增加了相关定时调度任务的方法。
ThreadPoolTaskScheduler	spring对该类设计原则同ThreadPoolTaskExecutor类。是为了定时调度任务不依赖相关的运行容器(例如weblogic、WebSphere等)。其底层委托给ScheduledExecutorService，向外暴露相关的常见bean配置属性。

总结： ①链接： <1>spring任务执行器与任务调度器 <2>JAVA定时任务Timer、Spring Task、Quartz ②Quartz与Spring Task对比： <1>Quartz： 1、默认多线程异步执行 2、单个任务时，在上一个调度未完成时，下一个调度时间到时，会另起一个线程开始新的调度。业务繁忙时，一个任务会有多个调度，可能导致数据处理异常。 3、多个任务时，任务之间没有直接影响，多任务执行的快慢取决于CPU的性能 4、触发方式 : (1)SimpleTrigger (2)CronTrigger 5、能被集群实例化，支持分布式部署 6、使用JobStoreCMT（JDBCJobStore的子类），Quartz 能参与JTA事务；Quartz 能管理JTA事务(开始和提交)在执行任务之间，这样，任务做的事就可以发生在JTA事务里。 <2>Task： 1、默认单线程同步执行 2、单个任务时，当前次的调度完成后，再执行下一次任务调度 3、多个任务时，一个任务执行完成后才会执行下一个任务。若需要任务能够并发执行，需手动设置线程 4、触发方式：与Quartz的CronTrigger的表达式类似，可以使用注解标注定时任务。

Quartz简介

Quartz简介：

Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。
Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能。这些功能的主要接口(API)是Scheduler接口。它提供了简单的操作，例如：将任务纳入日程或者从日程中取消，开始/停止/暂停日程进度。

springboot定时任务(与Quartz整合)：

直接加入集成好的starter

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

定时器种类：

Quartz 中五种类型的Trigger：SimpleTrigger，CronTirgger，DateIntervalTrigger，NthIncludedDayTrigger和Calendar类（ org.quartz.Calendar）。
最常用的： ①SimpleTrigger：用来触发只需执行一次或者在给定时间触发并且重复N次且每次执行延迟一定时间的任务。 ②CronTrigger：按照日历触发，例如“每个周五”，每个月10日中午或者10：15分。

存储方式：

RAMJobStore和JDBCJobStore对比：

类型	优点	缺点
RAMJobStore	不要外部数据库，配置容易，运行速度快	因为调度程序信息是存储在被分配给JVM的内存里面，所以，当应用程序停止运行时，所有调度信息将被丢失。另外因为存储到JVM内存里面，所以可以存储多少个Job和Trigger将会受到限制
JDBCJobStore	支持集群，因为所有的任务信息都会保存到数据库中，可以控制事物，还有就是如果应用服务器关闭或者重启，任务信息都不会丢失，并且可以恢复因服务器关闭或者重启而导致执行失败的任务	运行速度的快慢取决与连接数据库的快慢

表关系和解释：

表关系：
解释：

表名称	说明
qrtz_blob_triggers	Trigger作为Blob类型存储(用于Quartz用户用JDBC创建他们自己定制的Trigger类型，JobStore 并不知道如何存储实例的时候)
qrtz_calendars	以Blob类型存储Quartz的Calendar日历信息， quartz可配置一个日历来指定一个时间范围
qrtz_cron_triggers	存储Cron Trigger，包括Cron表达式和时区信息。
qrtz_fired_triggers	存储与已触发的Trigger相关的状态信息，以及相联Job的执行信息
qrtz_job_details	存储每一个已配置的Job的详细信息
qrtz_locks	存储程序的非观锁的信息(假如使用了悲观锁)
qrtz_paused_trigger_graps	存储已暂停的Trigger组的信息
qrtz_scheduler_state	存储少量的有关 Scheduler的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)
qrtz_simple_triggers	存储简单的 Trigger，包括重复次数，间隔，以及已触的次数
qrtz_triggers	存储已配置的 Trigger的信息

核心类和关系：

核心类： ①QuartzSchedulerThread：负责执行向QuartzScheduler注册的触发Trigger的工作的线程。 ②ThreadPool：Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提供运行效率。 ③QuartzSchedulerResources：包含创建QuartzScheduler实例所需的所有资源（JobStore，ThreadPool等）。 ④SchedulerFactory ：提供用于获取调度程序实例的客户端可用句柄的机制。 ⑤JobStore： 通过类实现的接口，这些类要为org.quartz.core.QuartzScheduler的使用提供一个org.quartz.Job和org.quartz.Trigger存储机制。作业和触发器的存储应该以其名称和组的组合为唯一性。 ⑥QuartzScheduler ：这是Quartz的核心，它是org.quartz.Scheduler接口的间接实现，包含调度org.quartz.Jobs，注册org.quartz.JobListener实例等的方法。 ⑦Scheduler ：这是Quartz Scheduler的主要接口，代表一个独立运行容器。调度程序维护JobDetails和触发器的注册表。一旦注册，调度程序负责执行作业，当他们的相关联的触发器触发（当他们的预定时间到达时）。 ⑧Trigger ：具有所有触发器通用属性的基本接口，描述了job执行的时间出发规则。 - 使用TriggerBuilder实例化实际触发器。 ⑨JobDetail ：传递给定作业实例的详细信息属性。 JobDetails将使用JobBuilder创建/定义。 ⑩Job：要由表示要执行的“作业”的类实现的接口。只有一个方法 void execute(jobExecutionContext context)(jobExecutionContext 提供调度上下文各种信息，运行时数据保存在jobDataMap中) <1>Job有个子接口StatefulJob ,代表有状态任务。有状态任务不可并发，前次任务没有执行完，后面任务处于阻塞等到。
关系： ①一个job可以被多个Trigger 绑定，但是一个Trigger只能绑定一个job！

配置文件：

quartz.properties
//调度标识名 集群中每一个实例都必须使用相同的名称 （区分特定的调度器实例）
org.quartz.scheduler.instanceName：DefaultQuartzScheduler
//ID设置为自动获取 每一个必须不同 （所有调度器实例中是唯一的）
org.quartz.scheduler.instanceId ：AUTO
//数据保存方式为持久化 
org.quartz.jobStore.class ：org.quartz.impl.jdbcjobstore.JobStoreTX
//表的前缀 
org.quartz.jobStore.tablePrefix ： QRTZ_
//设置为TRUE不会出现序列化非字符串类到 BLOB 时产生的类版本问题
//org.quartz.jobStore.useProperties ： true
//加入集群 true 为集群 false不是集群
org.quartz.jobStore.isClustered ： false
//调度实例失效的检查时间间隔 
org.quartz.jobStore.clusterCheckinInterval：20000 
//容许的最大作业延长时间 
org.quartz.jobStore.misfireThreshold ：60000
//ThreadPool 实现的类名 
org.quartz.threadPool.class：org.quartz.simpl.SimpleThreadPool
//线程数量 
org.quartz.threadPool.threadCount ： 10
//线程优先级 
org.quartz.threadPool.threadPriority ： 5（threadPriority 属性的最大值是常量 java.lang.Thread.MAX_PRIORITY，等于10。最小值为常量 java.lang.Thread.MIN_PRIORITY，为1）
//自创建父线程
//org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread： true 
//数据库别名
org.quartz.jobStore.dataSource ： qzDS
//设置数据源
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:123456
org.quartz.dataSource.qzDS.maxConnection:10

JDBC插入表顺序：

主要的JDBC操作类，执行sql顺序。

Simple_trigger ：插入顺序
qrtz_job_details --->  qrtz_triggers --->  qrtz_simple_triggers
qrtz_fired_triggers
Cron_Trigger：插入顺序
qrtz_job_details --->  qrtz_triggers --->  qrtz_cron_triggers
qrtz_fired_triggers

Quartz简单入门

Job：

public class MyJob implements Job{
	private static final Logger log = LoggerFactory.getLogger(MyJob.class);

	@Override
	public void execute(JobExecutionContext context)throws JobExecutionException {
		log.info("MyJob  is start ..................");
		
		log.info("Hello quzrtz  "+
				new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));
		
		log.info("MyJob  is end .....................");
	}
}

RAM方式：

public class RAMQuartz {

	private static Logger _log = LoggerFactory.getLogger(RAMQuartz.class);
	
	public static void main(String[] args) throws SchedulerException {
		//1.创建Scheduler的工厂
		SchedulerFactory sf = new StdSchedulerFactory();
		//2.从工厂中获取调度器实例
		Scheduler scheduler = sf.getScheduler();
		
		
		//3.创建JobDetail
		JobDetail jb = JobBuilder.newJob(MyJob.class)
				.withDescription("this is a ram job") //job的描述
				.withIdentity("ramJob", "ramGroup") //job 的name和group
				.build();
		
		//任务运行的时间，SimpleSchedle类型触发器有效
		long time=  System.currentTimeMillis() + 3*1000L; //3秒后启动任务
		Date statTime = new Date(time);
		
		//4.创建Trigger
			//使用SimpleScheduleBuilder或者CronScheduleBuilder
		Trigger t = TriggerBuilder.newTrigger()
					.withDescription("")
					.withIdentity("ramTrigger", "ramTriggerGroup")
					//.withSchedule(SimpleScheduleBuilder.simpleSchedule())
					.startAt(statTime)  //默认当前时间启动
					.withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")) //两秒执行一次
					.build();
		
		//5.注册任务和定时器
		scheduler.scheduleJob(jb, t);
		
		//6.启动 调度器
		scheduler.start();
		_log.info("启动时间 ： " + new Date());
			
	}
}

JDBC方式：

public class QuartzJdbcTest {
	
	public static void main(String[] args) throws SchedulerException,
			ParseException {
		startSchedule();
		//resumeJob();
	}
	/**
	 * 开始一个simpleSchedule()调度
	 */
	public static void startSchedule() {
		try {
			// 1、创建一个JobDetail实例，指定Quartz
			JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
			// 任务执行类
					.withIdentity("job1_1", "jGroup1")
					// 任务名，任务组
					.build();
		
			
			//触发器类型
			SimpleScheduleBuilder builder = SimpleScheduleBuilder
					// 设置执行次数
				    .repeatSecondlyForTotalCount(5);
			
			//CronScheduleBuilder builder = CronScheduleBuilder.cronSchedule("0/2 * * * * ?");
			// 2、创建Trigger
			Trigger trigger = TriggerBuilder.newTrigger()
					.withIdentity("trigger1_1", "tGroup1").startNow()
					.withSchedule(builder)
					.build();
			
			// 3、创建Scheduler
			Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
			scheduler.start();
			// 4、调度执行
			scheduler.scheduleJob(jobDetail, trigger);
			try {
				Thread.sleep(60000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

			//关闭调度器
			scheduler.shutdown();

		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 从数据库中找到已经存在的job，并重新开户调度
	 */
	public static void resumeJob() {
		try {

			SchedulerFactory schedulerFactory = new StdSchedulerFactory();
			Scheduler scheduler = schedulerFactory.getScheduler();
			JobKey jobKey = new JobKey("job1_1", "jGroup1");
			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
			//SELECT TRIGGER_NAME, TRIGGER_GROUP FROM {0}TRIGGERS WHERE SCHED_NAME = {1} AND JOB_NAME = ? AND JOB_GROUP = ?
			// 重新恢复在jGroup1组中，名为job1_1的 job的触发器运行
			if(triggers.size() > 0){
				for (Trigger tg : triggers) {
					// 根据类型判断
					if ((tg instanceof CronTrigger) || (tg instanceof SimpleTrigger)) {
						// 恢复job运行
						scheduler.resumeJob(jobKey);
					}
				}
				scheduler.start();
			}
			
		} catch (Exception e) {
			e.printStackTrace();

		}
	}
}

Spring和Quartz集成

RAM存储方式的xml配置文件：

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

	<!-- 
		Spring整合Quartz进行配置遵循下面的步骤：
		1：定义工作任务的Job
		2：定义触发器Trigger，并将触发器与工作任务绑定
		3：定义调度器，并将Trigger注册到Scheduler
	 -->
	<!-- 1：定义任务的bean ，这里使用JobDetailFactoryBean,也可以使用MethodInvokingJobDetailFactoryBean ，配置类似-->
	<bean name="hwJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<!-- 指定job的名称 -->
		<property name="name" value="hw_job"/>
		<!-- 指定job的分组 -->
		<property name="group" value="hw_group"/>
		<!-- 指定具体的job类 -->
		<property name="jobClass" value="com.dufy.spring.quartz.chapter01.job.HelloWorldJob"/>
		<!-- 必须设置为true，如果为false，当没有活动的触发器与之关联时会在调度器中会删除该任务  -->
		<property name="durability" value="true"/>
		<!-- 指定spring容器的key，如果不设定在job中的jobmap中是获取不到spring容器的 -->
		<property name="applicationContextJobDataKey" value="applicationContext"/>
	</bean>
	<!-- 2.1：定义触发器的bean，定义一个Simple的Trigger，一个触发器只能和一个任务进行绑定 -->
	<!-- <bean name="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
		指定Trigger的名称
		<property name="name" value="hw_trigger"/>
		指定Trigger的名称
		<property name="group" value="hw_trigger_group"/>
		指定Tirgger绑定的Job
		<property name="jobDetail" ref="hwJob"/>
		指定Trigger的延迟时间 1s后运行
		<property name="startDelay" value="1000"/>
		指定Trigger的重复间隔  5s
		<property name="repeatInterval" value="5000"/>
		指定Trigger的重复次数
		<property name="repeatCount" value="5"/>
	</bean> -->
	
	<!-- 2.2：定义触发器的bean，定义一个Cron的Trigger，一个触发器只能和一个任务进行绑定 -->
	<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<!-- 指定Trigger的名称 -->
		<property name="name" value="hw_trigger"/>
		<!-- 指定Trigger的名称 -->
		<property name="group" value="hw_trigger_group"/>
		<!-- 指定Tirgger绑定的Job -->
		<property name="jobDetail" ref="hwJob"/>
		<!-- 指定Cron 的表达式 ，当前是每隔1s运行一次 -->
		<property name="cronExpression" value="0/1 * * * * ?" />
	</bean>
	
	
	<!-- 3.定义调度器，并将Trigger注册到调度器中 -->
	<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<!-- <ref bean="simpleTrigger"/> -->
				<ref bean="cronTrigger"/>
			</list>
		</property>
		<!-- <property name="autoStartup" value="true" /> -->
	</bean>
	
</beans>

JDBC存储方式的xml配置文件：

Spring配置文件：

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


	<!-- =========JDBC版=========== -->
	<!-- 
		持久化数据配置，需要添加quartz.properties
	 -->
	<bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
        <property name="configLocation" value="classpath:quartz.properties"/>	
	</bean>
	
</beans>

quartz.properties：

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

#============================================================================
# Configure Main Scheduler Properties
#============================================================================
org.quartz.scheduler.instanceName: dufy_test
org.quartz.scheduler.instanceId = AUTO

org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
#============================================================================
# Configure ThreadPool
#============================================================================
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 2
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================
 
#default config
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#持久化配置
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties:true

#============================================================================
#havent cluster spring
#============================================================================
org.quartz.jobStore.isClustered = false  

#数据库表前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS

#============================================================================
# Configure Datasources
#============================================================================
#JDBC驱动
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz_test
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:root
org.quartz.dataSource.qzDS.maxConnection:10

SSMM和Quartz集成

配置文件介绍：

在ApplicationContext.xml中添加下面的配置： ①dataSource：配置了dataSource会读取spring配置的数据库，不会去加载quartz.properties配置的数据源。 ②applicationContextSchedulerContextKey：配置这个可以获取spring容器中的context。 ③加载quartz配置文件信息。

<bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" >
   <property name="dataSource" ref ="dataSource" />       
   <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
   <property name="configLocation" value="classpath:quartz.properties"/>			
</bean>

添加quartz.properties配置文件：

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

#============================================================================
# Configure Main Scheduler Properties
#============================================================================
org.quartz.scheduler.instanceName: quartzScheduler
org.quartz.scheduler.instanceId = AUTO

org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
#============================================================================
# Configure ThreadPool
#============================================================================
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 2
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================
 
#default config
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#持久化配置
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties:true

#============================================================================
#havent cluster spring
#============================================================================
org.quartz.jobStore.isClustered = false  

#数据库表前缀
org.quartz.jobStore.tablePrefix:qrtz_
#org.quartz.jobStore.dataSource:qzDS

#============================================================================
# Configure Datasources
#============================================================================
#JDBC驱动  Sping去管理dataSource ，这里不在配置数据源信息
#org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz_test
#org.quartz.dataSource.qzDS.user:root
#org.quartz.dataSource.qzDS.password:root
#org.quartz.dataSource.qzDS.maxConnection:10

BAO和Service接口：

Dao主要是用户的一些操作：

public interface IUserDao {
    int deleteByPrimaryKey(Integer id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);
    
    User findUser(User user);
}

Service主要是对定时任务的一些操作：

package org.ssm.dufy.service;

public interface QuartzService {

	/**
	 * addJob(方法描述：添加一个定时任务) <br />
	 * (方法适用条件描述： – 可选)
	 * 
	 * @param jobName
	 *            作业名称
	 * @param jobGroupName
	 *            作业组名称
	 * @param triggerName
	 *            触发器名称
	 * @param triggerGroupName
	 *            触发器组名称
	 * @param cls
	 *            定时任务的class
	 * @param cron
	 *            时间表达式 void
	 * @exception
	 * @since 1.0.0
	 */
	public void addJob(String jobName, String jobGroupName,String triggerName, String triggerGroupName, Class cls, String cron);

	/**
	 * 
	 * @param oldjobName 原job name
	 * @param oldjobGroup 原job group
	 * @param oldtriggerName 原 trigger name
	 * @param oldtriggerGroup 原 trigger group
	 * @param jobName
	 * @param jobGroup
	 * @param triggerName
	 * @param triggerGroup
	 * @param cron
	 */
	public boolean modifyJobTime(String oldjobName,String oldjobGroup, String oldtriggerName, String oldtriggerGroup, String jobName, String jobGroup,String triggerName, String triggerGroup, String cron);

	/**
	 * 修改触发器调度时间
	 * @param triggerName  触发器名称
	 * @param triggerGroupName  触发器组名称
	 * @param cron cron表达式
	 */
	public void modifyJobTime(String triggerName,
			String triggerGroupName, String cron);

	
	/**
	 * 暂停指定的任务
	 * @param jobName 任务名称
	 * @param jobGroupName 任务组名称 
	 * @return
	 */
	public void pauseJob(String jobName,String jobGroupName);
	
	/**
	 * 恢复指定的任务
	 * @param jobName 任务名称
	 * @param jobGroupName 任务组名称 
	 * @return
	 */
	public void resumeJob(String jobName,String jobGroupName);
	
	/**
	 * 删除指定组任务
	 * @param jobName 作业名称
	 * @param jobGroupName 作业组名称
	 * @param triggerName 触发器名称
	 * @param triggerGroupName 触发器组名称
	 */
	public void removeJob(String jobName, String jobGroupName,
			String triggerName, String triggerGroupName);

	
	/**
	 * 开始所有定时任务。启动调度器
	 */
	public void startSchedule();

	/**
	 * 关闭调度器
	 */
	public void shutdownSchedule();
}

Quartz集群

Quartz集群原理与架构：

一个Quartz集群中的每个节点是一个独立的Quartz应用，它又管理着其他的节点。这就意味着你必须对每个节点分别启动或停止。Quartz集群中，独立的Quartz节点并不与另一其的节点或是管理节点通信，而是通过相同的数据库表来感知到另一Quartz应用的。
集群通过故障切换和负载平衡的功能，能给调度器带来高可用性和伸缩性。目前集群只能工作在JDBC-JobStore（JobStore TX或者JobStoreCMT）方式下，从本质上来说，是使集群上的每一个节点通过共享同一个数据库来工作的（ Quartz通过启动两个维护线程来维护数据库状态实现集群管理，一个是检测节点状态线程，一个是恢复任务线程）。 ①负载平衡是自动完成的，集群的每个节点会尽快触发任务。当一个触发器的触发时间到达时，第一个节点将会获得任务（通过锁定），成为执行任务的节点。 ②故障切换的发生是在当一个节点正在执行一个或者多个任务失败的时候。当一个节点失败了，其他的节点会检测到并且标识在失败节点上正在进行的数据库中的任务。任何被标记为可恢复（任务详细信息的"requests recovery"属性）的任务都会被其他的节点重新执行。没有标记可恢复的任务只会被释放出来，将会在下次相关触发器触发时执行。

注意事项：

时间同步问题： ①Quartz实际并不关心你是在相同还是不同的机器上运行节点。当集群放置在不同的机器上时，称之为水平集群。节点跑在同一台机器上时，称之为垂直集群。对于垂直集群，存在着单点故障的问题。这对高可用性的应用来说是无法接受的，因为一旦机器崩溃了，所有的节点也就被终止了。对于水平集群，存在着时间同步问题。 ②节点用时间戳来通知其他实例它自己的最后检入时间。假如节点的时钟被设置为将来的时间，那么运行中的Scheduler将再也意识不到那个结点已经宕掉了。另一方面，如果某个节点的时钟被设置为过去的时间，也许另一节点就会认定那个节点已宕掉并试图接过它的Job重运行。最简单的同步计算机时钟的方式是使用某一个Internet时间服务器(Internet Time Server ITS)。
节点争抢Job问题： ①因为Quartz使用了一个随机的负载均衡算法， Job以随机的方式由不同的实例执行。Quartz官网上提到当前，还不存在一个方法来指派(钉住) 一个 Job 到集群中特定的节点。
从集群获取Job列表问题： ①当前，如果不直接进到数据库查询的话，还没有一个简单的方式来得到集群中所有正在执行的Job列表。请求一个Scheduler实例，将只能得到在那个实例上正运行Job的列表。Quartz官网建议可以通过写一些访问数据库JDBC代码来从相应的表中获取全部的Job信息。

Quartz配置

quartz.properties：

#quartz集群配置  
#调度标识名 集群中每一个实例都必须使用相同的名称    
org.quartz.scheduler.instanceName=DefaultQuartzScheduler
#ID设置为自动获取 每一个必须不同  
org.quartz.scheduler.instanceId=AUTO
org.quartz.scheduler.makeSchedulerThreadDaemon=true
#线程池的实现类（一般使用SimpleThreadPool即可满足需求）  
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
#指定在线程池里面创建的线程是否是守护线程
org.quartz.threadPool.makeThreadsDaemons=true
#指定线程数，至少为1（无默认值）
org.quartz.threadPool.threadCount:20
#设置线程的优先级（最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1，默认为5） 
org.quartz.threadPool.threadPriority:5
#数据保存方式为数据库持久化  
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#数据库代理类，一般org.quartz.impl.jdbcjobstore.StdJDBCDelegate可以满足大部分数据库  
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#表的前缀，默认QRTZ_  
org.quartz.jobStore.tablePrefix=QRTZ_
#是否加入集群
org.quartz.jobStore.isClustered=true
# 信息保存时间 默认值60秒   
org.quartz.jobStore.misfireThreshold=25000

Quartz分布式

分布式定时任务：

什么是分布式定时任务：把分散的，可靠性差的计划任务纳入统一的平台，并实现集群管理调度和分布式部署的一种定时任务的管理方式。叫做分布式定时任务。
常见开源方案： ①elastic-job ②xxl-job ③quartz ④saturn ⑤opencron ⑥antares
链接：分布式定时任务

feature	quartz	elastic-job-cloud	xxl-job	antares	opencron
依赖	mysql	jdk1.7+, zookeeper 3.4.6+ ,maven3.0.4+ ,mesos	mysql ,jdk1.7+ , maven3.0+	jdk 1.7+ , redis , zookeeper	jdk1.7+ , Tomcat8.0+
HA	多节点部署，通过竞争数据库锁来保证只有一个节点执行任务	通过zookeeper的注册与发现，可以动态的添加服务器。支持水平扩容	集群部署	集群部署	—
任务分片	—	支持	支持	支持	—
文档完善	完善	完善	完善	文档略少	文档略少
管理界面	无	支持	支持	支持	支持
难易程度	简单	较复杂	简单	一般	一般
公司	OpenSymphony	当当网	个人	个人	个人
高级功能	—	弹性扩容，多种作业模式，失效转移，运行状态收集，多线程处理数据，幂等性，容错处理，spring命名空间支持	弹性扩容，分片广播，故障转移，Rolling实时日志，GLUE（支持在线编辑代码，免发布）,任务进度监控，任务依赖，数据加密，邮件报警，运行报表，国际化	任务分片，失效转移，弹性扩容，	时间规则支持quartz和crontab ，kill任务，现场执行，查询任务运行状态
缺点	没有管理界面，以及不支持任务分片等。不适用于分布式场景	需要引入zookeeper , mesos, 增加系统复杂度, 学习成本较高	调度中心通过获取 DB锁来保证集群中执行任务的唯一性，如果短任务很多，随着调度中心集群数量增加，那么数据库的锁竞争会比较厉害，性能不好。	不支持动态添加任务	不适用于分布式场景
使用企业	大众化产品，对分布式调度要求不高的公司大面积使用	36氪，当当网，国美，金柚网，联想，唯品会，亚信，平安，猪八戒	大众点评，运满满，优信二手车，拍拍贷	—	—
分布式定时任务方案：

方案一：单独设置任务调度服务 ①任务调度服务部署在单结点，定时任务以Http请求的方式去向网关调用任务请求，网关将请求分发到集群中的某一个节点，某一个节点执行任务。
方案二：使用Redis分布式锁实现 ①每个定时任务都在Redis中设置一个Key-Value的分布式锁，Key为自定义的每个定时任务的名字（如task1:redis:lock），Value为服务器Ip，同时设置合适的过期时间（例如设置为5min），只有获取到锁的服务才能执行任务，其他服务则只能等待轮询。 ②每个节点在执行时，都要进行以下操作： 1.是否存在Key，若不存在，则设置Key-Value，Value为当前节点的IP 2.若存在Key，则比较Value是否是当前Ip，若是则获取到了锁继续执行定时任务，若不是，则没有获取到锁就不往下执行并定时任务轮询直到它抢到锁为止。
方案三：开源分布式框架（推荐） ①使用XXL-JOB实现 xxl-job是一个轻量级的分布式任务调度框架，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。 <1>xxl-job的设计思想为：（1）将调度行为抽象形成“调度中心”公共平台，而平台自身并不承担业务逻辑，“调度中心”负责发起调度请求（2）将任务抽象成分散的JobHandler，交由执行器统一管理，执行器负责接收调度请求并执行对应的JobHandler中业务逻辑 <2>因此，“调度”和“任务”可以互相解偶，提高系统整体的稳定性和扩展性。 ②Elastic-Job：Elastic-job在2.x之后，出现了两个相互独立的产品线：Elastic-job-lite和Elastic-job-cloud <1>Elastic-job-lite：定位为轻量级无中心化的解决方案，使用jar包的形式提供分布式任务的协调服务，外部依赖仅依赖于zookeeper。

xxl-job分布式任务调度原理：

执行器：就是执行任务的机器
链接： ①分布式任务调度 ②xxl-job系列

Job与Tigger状态

简介：

jobkey相当于一把钥匙连接所有从 schedule 中获取信息的钥匙，你会获得当前钥匙下的初始化信息

JobKey jobkey = new JobKey(name,group)
scheduler.getJobDetail(jobKey).getJobDataMap().get("当时创建的名称")

获取该条记录下次着火事件的时间

Date date = scheduler.getTriggersOfJob(jobKey).get(0).getNextFireTime();

获得该job 的调度状态，也可以使用 jobkey

 TriggerKey triggerKey = TriggerKey.triggerKey(jobKey.getName(), jobKey.getGroup());
 scheduler.getTriggerState(triggerKey);

状态情况分为以下几类可以直接拿去用。

private static String getTriggerStatesCN(String key) {
    Map<String, String> map = new LinkedHashMap<String, String>();
    map.put("BLOCKED", "阻塞");
    map.put("COMPLETE", "完成");
    map.put("ERROR", "出错");
    map.put("NONE", "不存在");
    map.put("NORMAL", "正常");
    map.put("PAUSED", "暂停");

    map.put("4", "阻塞");
    map.put("2", "完成");
    map.put("3", "出错");
    map.put("-1", "不存在");
    map.put("0", "正常");
    map.put("1", "暂停");
    /*  **STATE_BLOCKED 4 阻塞
STATE_COMPLETE 2 完成
STATE_ERROR 3 错误
STATE_NONE -1 不存在
STATE_NORMAL 0 正常
STATE_PAUSED 1 暂停***/
    return map.get(key);
}

在这里插入图片描述

quartz 监听器

quartz 监听器主要分三大类：

SchedulerListener：任务调度监听器
TriggerListener：任务触发监听器
JobListener：任务执行监听器

SchedulerListener：

SchedulerListener监听器，主要对任务调度Scheduler生命周期中关键节点进行监听，它只能全局进行监听，简单示例如下：

public class SimpleSchedulerListener implements SchedulerListener {

    @Override
    public void jobScheduled(Trigger trigger) {
        System.out.println("任务被部署时被执行");
    }

    @Override
    public void jobUnscheduled(TriggerKey triggerKey) {
        System.out.println("任务被卸载时被执行");
    }

    @Override
    public void triggerFinalized(Trigger trigger) {
        System.out.println("任务完成了它的使命，光荣退休时被执行");
    }

    @Override
    public void triggerPaused(TriggerKey triggerKey) {
        System.out.println(triggerKey + "（一个触发器）被暂停时被执行");
    }

    @Override
    public void triggersPaused(String triggerGroup) {
        System.out.println(triggerGroup + "所在组的全部触发器被停止时被执行");
    }

    @Override
    public void triggerResumed(TriggerKey triggerKey) {
        System.out.println(triggerKey + "（一个触发器）被恢复时被执行");
    }

    @Override
    public void triggersResumed(String triggerGroup) {
        System.out.println(triggerGroup + "所在组的全部触发器被回复时被执行");
    }

    @Override
    public void jobAdded(JobDetail jobDetail) {
        System.out.println("一个JobDetail被动态添加进来");
    }

    @Override
    public void jobDeleted(JobKey jobKey) {
        System.out.println(jobKey + "被删除时被执行");
    }

    @Override
    public void jobPaused(JobKey jobKey) {
        System.out.println(jobKey + "被暂停时被执行");
    }

    @Override
    public void jobsPaused(String jobGroup) {
        System.out.println(jobGroup + "(一组任务）被暂停时被执行");
    }

    @Override
    public void jobResumed(JobKey jobKey) {
        System.out.println(jobKey + "被恢复时被执行");
    }

    @Override
    public void jobsResumed(String jobGroup) {
        System.out.println(jobGroup + "(一组任务）被恢复时被执行");
    }

    @Override
    public void schedulerError(String msg, SchedulerException cause) {
        System.out.println("出现异常" + msg + "时被执行");
        cause.printStackTrace();
    }

    @Override
    public void schedulerInStandbyMode() {
        System.out.println("scheduler被设为standBy等候模式时被执行");
    }

    @Override
    public void schedulerStarted() {
        System.out.println("scheduler启动时被执行");
    }

    @Override
    public void schedulerStarting() {
        System.out.println("scheduler正在启动时被执行");
    }

    @Override
    public void schedulerShutdown() {
        System.out.println("scheduler关闭时被执行");
    }

    @Override
    public void schedulerShuttingdown() {
        System.out.println("scheduler正在关闭时被执行");
    }

    @Override
    public void schedulingDataCleared() {
        System.out.println("scheduler中所有数据包括jobs, triggers和calendars都被清空时被执行");
    }
}

需要在任务调度器启动前，将SimpleSchedulerListener注册到Scheduler容器中：

// 创建一个Scheduler
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
//添加SchedulerListener监听器
scheduler.getListenerManager().addSchedulerListener(new SimpleSchedulerListener());
// 启动Scheduler
scheduler.start();

TriggerListener：

TriggerListener，与触发器Trigger相关的事件都会被监听，它既可以全局监听，也可以实现局部监听。所谓局部监听，就是对某个Trigger的名称或者组进行监听，简单示例如下：

public class SimpleTriggerListener implements TriggerListener {

    /**
     * Trigger监听器的名称
     * @return
     */
    @Override
    public String getName() {
        return "mySimpleTriggerListener";
    }

    /**
     * Trigger被激发 它关联的job即将被运行
     * @param trigger
     * @param context
     */
    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        System.out.println("myTriggerListener.triggerFired()");
    }

    /**
     * Trigger被激发 它关联的job即将被运行, TriggerListener 给了一个选择去否决 Job 的执行,如果返回TRUE 那么任务job会被终止
     * @param trigger
     * @param context
     * @return
     */
    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        System.out.println("myTriggerListener.vetoJobExecution()");
        return false;
    }

    /**
     * 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作，
     * 那么有的触发器就有可能超时，错过这一轮的触发。
     * @param trigger
     */
    @Override
    public void triggerMisfired(Trigger trigger) {
        System.out.println("myTriggerListener.triggerMisfired()");
    }

    /**
     * 任务完成时触发
     * @param trigger
     * @param context
     * @param triggerInstructionCode
     */
    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
        System.out.println("myTriggerListener.triggerComplete()");
    }
}

与之类似，需要将SimpleTriggerListener注册到Scheduler容器中！

// 创建一个Scheduler
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
// 创建并注册一个全局的Trigger Listener
scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener(), EverythingMatcher.allTriggers());
        
// 创建并注册一个局部的Trigger Listener
//scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener(), KeyMatcher.keyEquals(TriggerKey.triggerKey("myTrigger", "myJobTrigger")));
        
// 创建并注册一个特定组的Trigger Listener
//scheduler.getListenerManager().addTriggerListener(new SimpleTriggerListener(), GroupMatcher.groupEquals("myTrigger"));
// 启动Scheduler
scheduler.start();

JobListener：

JobListener，与任务执行Job相关的事件都会被监听，和Trigger一样，既可以全局监听，也可以实现局部监听。

public class SimpleJobListener implements JobListener {

    /**
     * job监听器名称
     * @return
     */
    @Override
    public String getName() {
        return "mySimpleJobListener";
    }

    /**
     * 任务被调度前
     * @param context
     */
    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        System.out.println("simpleJobListener监听器，准备执行："+context.getJobDetail().getKey());
    }

    /**
     * 任务调度被拒了
     * @param context
     */
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        System.out.println("simpleJobListener监听器，取消执行："+context.getJobDetail().getKey());
    }

    /**
     * 任务被调度后
     * @param context
     * @param jobException
     */
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        System.out.println("simpleJobListener监听器，执行结束："+context.getJobDetail().getKey());
    }
}

同样的，将SimpleJobListener注册到Scheduler容器中，即可实现监听！

// 创建一个Scheduler
Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
// 创建并注册一个全局的Job Listener
scheduler.getListenerManager().addJobListener(new SimpleJobListener(), EverythingMatcher.allJobs());

// 创建并注册一个指定任务的Job Listener
//scheduler.getListenerManager().addJobListener(new SimpleJobListener(), KeyMatcher.keyEquals(JobKey.jobKey("myJob", "myJobGroup")));

// 将同一任务组的任务注册到监听器中
//scheduler.getListenerManager().addJobListener(new SimpleJobListener(), GroupMatcher.jobGroupEquals("myJobGroup"));

// 启动Scheduler
scheduler.start();

Quartz总结

Quartz总结：

quartz 已经有对应的任务表，不需要手动创建，只需要配置quartz.properties文件即可！quartz官方提供了对应任务表，主要用于分布式架构下的任务处理！如果只是单体应用，可以创建一张单表来存储任务，实现简单！
如果只在单体环境中应用，Quartz 未必是最好的选择，例如Spring Scheduled一样也可以实现任务调度，并且与SpringBoot无缝集成，支持注解配置，非常简单，但是它有个缺点就是在集群环境下，会导致任务被重复调度！
quartz分布式架构和集群架构其实是一样的，都是部署多台定时任务机器而已。(不同于应用服务器的集群和分布式)
链接： ①Quartz 架构和单体应用介绍 ②SpringBoot 整合 Quartz 实现分布式调度 ③Quartz详解

Quartz注意：

Quartz 当 Job 执行时间超过触发间隔时间时所发生的情况： ①默认情况下，当Job执行时间超过间隔时间时，调度框架为了能让任务按照我们预定的时间间隔执行，会马上启用新的线程执行任务。 ②若我们希望当前任务执行完之后再执行下一轮任务，也就是不要并发执行任务，该如何解决呢？ <1>设置 quartz.threadPool.threadCount 最大线程数为 1。这样到了第二次执行任务时，若当前还没执行完，调度器想新开一个线程执行任务，但我们却设置了最大线程数为 1 个（即：没有足够的线程提供给调度器），则调度器会等待当前任务执行完之后，再立即调度执行下一次任务。（注意：此方法仅适用于Quartz中仅有一个Job，如果有多个Job，会影响其他Job的执行） <2>在 Job 类的头部加上 [DisallowConcurrentExecution]，表示禁用并发执行。（推荐使用此方法）