【JavaWeb】Quartz—任务调度（一）从入门到了解Quartz的所有概念

冷不防 2022-11-14 11:57 611阅读 0赞

### 文章目录 ###

*  一.前言
 *  二.任务调度场景
 *  三.定时任务实现方式
 *   *  1.Thread实现
     *  2.Timer
     *  3.线程池ScheduledExecutorService
     *  4.Spring-scheduling
     *  5.Spring-异步调用
     *  6.Quartz
 *  四.Quartz 入门
 *   *  1.特点
     *  2.依赖
     *  3.三大核心概念
     *   *  3.1.做什么工作—任务(Job)
         *  3.2.什么时候工作—触发器(Trigger)
         *   *  3.2.1.描述
             *  3.2.2.触发器类型
         *  3.3.搭配 Trigger和Job—调度器(scheduler）
     *  4.任务存储方式
     *  5.常用类
     *   *  5.1.任务
         *   *  5.1.1.Job
             *  5.1.2.JobBuilder
             *  5.1.3.JobDetail
             *  5.1.4.JobDataMap
             *  5.1.5.JobExecutionContext
         *  5.2.触发器
         *   *  5.2.1.Trigger
             *  5.2.2.TriggerBuilder
             *  5.2.3.SimpleTrigger
             *  5.2.4.CalendarIntervalTrigger
             *  5.2.5.DailyTimeIntervalTrigger
             *  5.2.6.CronTrigger
         *  5.3.调度器
         *   *  5.3.1.Scheduler
             *  5.3.2.SchedulerFactory
             *  5.3.3.ScheduleBuilder
         *  5.4.监听器
         *   *  5.4.1.JobListener
             *  5.4.2.TriggerListener
             *  5.4.3.SchedulerListener
             *  5.4.4.监听器注册
         *  5.5.trigger状态
     *  6.定时任务实现步骤
     *   *  6.1.步骤描述
         *  6.2.实例代码
         *  6.3.设置分组的作用
         *  6.4.异常处理
         *  6.5. Job 并发-@DisallowConcurrentExecution、@PersistJobDataAfterExecution
         *  6.6.中断 Job
         *  6.6.Calendar
     *  7.具体对象和方法
     *   *  7.1.ScheduleBuilder的具体对象和常用方法：
         *   *  7.1.1.CronScheduleBuilder(常用)
             *  7.1.2.SimpleScheduleBuilder(常用)
             *  7.1.3.CalendarIntervalScheduleBuilder
             *  7.1.4.DailyTimeIntervalScheduleBuilder
         *  7.2.TriggerBuilder
         *  7.3.Scheduler
         *  7.4.StdSchedulerFactory
         *  7.5.JobDetail
         *  7.6.JobBuilder
     *  8.配置文件-quartz.properties
     *  9.总结
     *  10.Job工具类
 *  五.Cron学习
 *   *  1.表达式
     *  2.特殊字符含义
     *  3.Cron表达式详解

# 一.前言 #

**定时任务，是指定一个时间点定时执行任务的功能**。不同的语言，不同的操作系统， 都有其自己的任务调度解决方案，**windows系统**把它叫做`任务计划`，**linux系统**中`cron服务`都提供了这个功能

# 二.任务调度场景 #

**（1）驱动处理工作流程**  
作为一个新的预支付订单被初始化放置，如果该订单在指定时间内未进行支付，则将被认为超时订单进行关闭处理；电商系统中应用较多，用户购买商品产生订单，但未进行支付，订单产生30分钟内未支付将关闭订单（且满足该场景数量庞大），不可能采用人工干预。

**（2）系统维护**  
调度任务获取系统异常日志，及某些关键点数据存储到数据库中，每个工作日（节假日除外平日）在11:30 PM转储到数据库，且生成一个XML文件发送至某位员工邮箱。

**（3）在应用程序内提供提醒服务。**  
系统定时提醒登录用户某时间点执行相关工作。

**（4）定时对账任务**  
公司与三方公司（运营商，银行等）业务，每天零点后进行当天业务的对账，将对账信息结果数据发送至相关负责人邮箱，第二天工作时间进行处理不匹配数据。

**（5）数据统计**  
数据量庞时实时从数据库读取查询进行数据统计，不仅耗费时间，并且影响客户体验，为客户体验及性能需要，因此通过定时任务每周（天，小时）将数据进行汇总，从而在展示数据时能够快速的呈现数据。

等等等等。。。。。

# 三.定时任务实现方式 #

## 1.Thread实现 ##

通过给`线程设置休眠时间`的方式可以实现简单的定时任务逻辑。

public static void main(String[] args){ 
            //定时任务间隔时间
            int sleepTime=2*1000;
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                    while (true){ 
                        try { 
                            System.out.println("Thread方式执行一次定时任务");
                            //线程休眠规定时间
                            Thread.sleep(sleepTime);
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                }
            }).start();
        }

## 2.Timer ##

**JDK自带的定时工具，可以基于给定的时间点、给定的时间间隔、给定的执行次数自动执行的任务。一般用的较少。**

*  使用 Timer 实现任务调度的核心类是 `Timer` 和 `TimerTask`。其中 Timer 负责`设置 TimerTask 的起始与间隔执行时间`。 使用者只需要`创建一个 TimerTask 的继承类`，`实现自己的 run 方法，然后将其丢给 Timer 去执行即可`。
 *  Timer 的设计核心是一个`TaskList`和一个`TaskThread`。
    
     *  Timer 将接收到的任务丢到自己的 `TaskList 中`，TaskList `按照 Task 的最初执行时间进行排序`。
     *  `TimerThread`在创建 Timer 时会启动成为一个`守护线程`。这个线程会`轮询`所有任务，找到一个最近要执行的任务，然后`休眠`，当到达最近要执行任务的`开始时间点`，TimerThread 被`唤醒`并执行该任务。之后 TimerThread 更新最近一个要执行的任务，继续休眠。
 *  Timer 的优点在于`简单易用`，但由于所有任务都是由`同一个线程`来调度，因此所有任务都是`串行执行`的，**同一时间只能有一个任务在执行，前一个任务的延迟或异常都将会影响到之后的任务**（这点需要注意）。

schedule的4种用法和scheduleAtFixedRate的2种用法

schedule(TimerTask task, Date time)：安排在指定的时间执行指定的任务。
    schedule(TimerTask task, Date firstTime, long period) ：安排指定的任务在指定的时间开始进行重复的固定延迟执行。
    schedule(TimerTask task, long delay) ：安排在指定延迟后执行指定的任务。
    schedule(TimerTask task, long delay, long period) ：安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
    scheduleAtFixedRate(TimerTask task, Date firstTime, long period)：安排指定的任务在指定的时间开始进行重复的固定速率执行。
    scheduleAtFixedRate(TimerTask task, long delay, long period)：安排指定的任务在指定的延迟后开始进行重复的固定速率执行。

**参数说明：**

*  task：所要执行的任务，需要extends TimeTask override run()
 *  time/firstTime：首次执行任务的时间
 *  period：周期性执行Task的时间间隔，单位是毫秒
 *  delay：执行task任务前的延时时间，单位是毫秒

通过上面的参数我们可以实现：

*  延迟多久后执行一次任务
 *  指定时间执行一次任务
 *  延迟一段时间，并周期性执行任务
 *  指定时间，并周期性执行任务；

**代码**

public class TimerTest extends TimerTask { 
    
        private String jobName = "";
    
        public TimerTest(String jobName) { 
            super();
            this.jobName = jobName;
        }
    
        public static void main(String[] args) { 
            Timer timer = new Timer();
            long delay1 = 1 * 1000;
            long period1 = 1000;
            // 从现在开始 1 秒钟之后，每隔 1 秒钟执行一次 job1
            timer.schedule(new TimerTest("job1"), delay1, period1);
    
            long delay2 = 2 * 1000;
            long period2 = 2000;
            // 从现在开始 2 秒钟之后，每隔 2 秒钟执行一次 job2
            timer.schedule(new TimerTest("job2"), delay2, period2);
        }
    
        @Override
        public void run() { 
            System.out.println("execute " + jobName);
        }
    }

执行结果

execute job1
    execute job1
    execute job2
    execute job1
    execute job1
    execute job2

> 注：
> 
>  *  cancel()：终止Timer计时器，丢弃所有当前已安排的任务（TimeTask也存在cancel()方法，不过终止的是TimeTask）
>  *  purge()：从计时器的任务队列中移除已取消的任务，并返回个数

--------------------

**注意事项**

1.  在`当前时间`大于等于`time/firstTime`的时候，会执行task！也就是说，如果time/firstTime指定的时间在当前时间之前，就会立即得到执行。
2.  **schedule**：每次执行时间为`上一次任务结束`后推一个`period间隔`，也就是说下次执行时间相对于上一次任务结束的时间点，因此执行时间会不断延后。
3.  **scheduleAtFixedRate**：每次执行时间为`上一次任务开始`起向后推一个`period间隔`，也就是说下次执行时间相对于上一次任务开始的时间点，因此执行时间不会延后，但是存在任务并发执行的问题。
4.  如果TimeTask抛出`RuntimeException`，那么Timer会`停止所有任务的运行`！
5.  Timer是`单线程`实现的，因此Timer存在管理并发任务的缺陷：所有任务都是由同一个线程来调度，所有任务都是`串行执行`，意味**着同一时间只能有一个任务得到执行，而前一个任务的延迟或者异常会影响到之后的任务。**
6.  Timer调度方式比较简单，无法处理复杂的任务调度

## 3.线程池ScheduledExecutorService ##

基于Timer 的上述缺陷，`Java 5`推出了基于线程池设计的定时任务类**ScheduledExecutor,**

*  其设计思想是，`每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰`。只有当任务的执行时间到来时，ScheduledExecutor 才会`真正启动`一个线程，其余时间 ScheduledExecutor 都是在`轮询任务`的状态。
    
     *  **scheduleWithFixedDelay**：每次执行时间为`上一次任务结束起向后推一个时间间隔`，即每次执行时间为：`initialDelay, initialDelay+executeTime+delay, initialDelay+2*executeTime+2*delay, …`
     *  **scheduleAtFixedRate** : 每次执行时间为`上一次任务开始起向后推一个时间间隔`，即每次执行时间为 :`initialDelay, initialDelay+period, initialDelay+2*period, …`
 *  由此可见，**scheduleAtFixedRate** 是`基于固定时间间隔`进行任务调度，**scheduleWithFixedDelay** 取决于`每次任务执行的时间长短`，是`基于不固定时间间隔`进行任务调度。

public class ScheduledExecutorTest implements Runnable { 
     private String jobName = "";
     
     public ScheduledExecutorTest(String jobName) { 
      super();
      this.jobName = jobName;
     }
     
     @Override
     public void run() { 
      System.out.println("execute " + jobName);
     }
     
     public static void main(String[] args) { 
      	ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
     
      	long initialDelay1 = 1;
      	long period1 = 1;
      	// 从现在开始1秒钟之后，每隔1秒钟执行一次job1
      	service.scheduleAtFixedRate(
        	new ScheduledExecutorTest("job1"), initialDelay1,
        	period1, TimeUnit.SECONDS);
     
      	long initialDelay2 = 1;
      	long delay2 = 1;
      	// 从现在开始2秒钟之后，每隔2秒钟执行一次job2
      	service.scheduleWithFixedDelay(
        	new ScheduledExecutorTest("job2"), initialDelay2,
        	delay2, TimeUnit.SECONDS);
     }
    }

execute job1
    execute job1
    execute job2
    execute job1
    execute job1
    execute job2

由此可见

*  `Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度`，不能胜任更加复杂的调度需求。
    
     *  比如，设置每星期二的 16:38:10 执行任务。该功能使用 Timer 和 ScheduledExecutor 都不能直接实现，但我们可以借助`Calendar 间接实现该功能。`

## 4.Spring-scheduling ##

**Spring scheduling** ：`Spring3.0`以后`自带任务调度框架`，是`单机服务常用的调度任务策略`。可以将它看成一个`轻量级的Quartz`，使用起来比Quartz简单。使用注解 `@EnableScheduling + @Scheduled`注解就可以实现一个简单的定时任务

> SprngTask没有专门的包，其核心类位于`spring-context包`中。所以引入spring的核心包此功能即可使用。  
> 　　在实际的项目中，我们经常将job作为action层，在job中注入service去操作底层的dao，或者`定时的向其他系统拉取数据,再或者向其他系统推送数据`。
> 
>  *  同一定时任务，第二次触发时间到了，第一次还没有执行完成时会执行吗？
>     
>      *  不会，会等前一次执行完成才执行下一次
>  *  不同的定时任务，相互之间是否有影响？
>     
>      *  取决于可用的定时任务线程数，如果线程数足够则不会影响；如果可用定时任务线程数少于要执行定时任务数量，未能获取到线程的自然要等到有空闲线程时才能执行。

**注解@Scheduled属性有**

cron : cron的表达式
    zone : 解析cron表达式的时区
    fixedDelay : 方法之间以毫秒为单位执行带注释的方法,返回延迟，以毫秒为单位
    fixedDelayString : 方法之间以毫秒为单位执行带注释的方法,返回延迟，以毫秒为单位
    fixedRate : 周期(以毫秒为单位)
    fixedRateString : 周期(以毫秒为单位)
    initialDelay : 在第一次执行a之前要延迟的毫秒数,初始延迟(以毫秒为单位)
    initialDelayString : 在第一次执行a之前要延迟的毫秒数,初始延迟(以毫秒为单位)

@Component
    public class SpringScheduled { 
        // 10秒后开始执行，每隔3秒执行一次
        @Scheduled(initialDelay = 10 * 1000, fixedRate = 3 * 1000)
        public void execute() { 
            System.out.println("------------" + System.currentTimeMillis());
        }
    }

--------------------

**Spring-scheduling非注解实现任务调度**  
[SpringBoot-基于接口SchedulingConfigurer的动态定时任务][SpringBoot-_SchedulingConfigurer]  
[SpringBoot-基于接口SchedulingConfigurer实现多线程并发动态执行计划任务][SpringBoot-_SchedulingConfigurer 1]  
[springboot -ThreadPoolTaskScheduler介绍][springboot -ThreadPoolTaskScheduler]  
[Springboot -ThreadPoolTaskScheduler实现定时任务动态增、删、改、启动、暂停][Springboot -ThreadPoolTaskScheduler]  
[springboot -ThreadPoolTaskSchedulere完成添加修改删除定时任务][springboot -ThreadPoolTaskSchedulere]

## 5.Spring-异步调用 ##

在传统的Spring项目中，我们可以在xml配置文件添加task的配置，而在SpringBoot项目中一般使用`@Configuration配置类`的方式添加配置，所以新建一个AsyncConfig类

@Configuration
    @EnableAsync
    public class AsyncConfig { 
         /* 此处成员变量应该使用@Value从配置中读取 */
        private int corePoolSize = 10;
        private int maxPoolSize = 200;
        private int queueCapacity = 10;
        @Bean
        public Executor taskExecutor() { 
            ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
            executor.setCorePoolSize(corePoolSize);
            executor.setMaxPoolSize(maxPoolSize);
            executor.setQueueCapacity(queueCapacity);
            executor.initialize();
            return executor;
        }
    }

*  `@Configuration`：标识该类是一个配置类
 *  `@EnableAsync`：开启异步调用的支持

**然后在`定时任务`的`类`或者`方法`上添加`@Async` 。最后重启项目，`每一个异步任务都会开启一个线程执行`**

## 6.Quartz ##

虽然`线程池ScheduledExecutorService`对*Timer进行了改进*，但依然无法满足复杂的定时任务调度场景。

*  因此**OpenSymphony**提供了开源任务调度框架：**Quartz**。`Quartz是纯Java实现`，而且作为`Spring的默认调度框架`，由于Quartz的强大的调度功能、灵活的使用方式、还具有`分布式集群能力`，可以说Quartz出马，可以搞定一切定时任务调度！

**核心概念：**

*  **Job表示实现业务逻辑的任务接口**，接口只有一个`execute方法`，在里面编写`业务逻辑`。`定时任务必须实现Job(org.quartz.Job)接口。`
 *  **Trigger 触发器**，表示触发Job执行的规则。
 *  **Scheduler: 表示一个调度容器**，一个调度容器中可以`注册多个 JobDetail 和Trigger`。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。

# 四.Quartz 入门 #

## 1.特点 ##

1.  具有强大的调度功能，与Spring容易集成，形成灵活的调度功能。
2.  调度环境的持久化机制：可以保存并恢复调度现场，即使系统因为故障关闭，任务调度现场的数据并不会丢失。
3.  灵活的应用方式：可以灵活的定义触发器调度时间表，并可对触发器与任务进行关联映射(通过Name和Group形式为一个的JobKey)。
4.  `分布式与集群能力(通过数据库锁机制来实现分布式定时任务的执行)`

**Quartz的设计模式**

*  Builder模式
 *  Factory模式
 *  组件模式
 *  链式写法

## 2.依赖 ##

如果SpringBoot`2.x`版本以后的，使用依赖：

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

如果是SpringBoot`1.5x`版本的使用依赖：

<dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz</artifactId>
      <version>2.3.0</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
    </dependency>

我使用的是SpringBoot2.x 的，该版本开始集成了Quartz，所以实现起来很方便。

## 3.三大核心概念 ##

**三大核心概念为：`调度器(Scheduler)、任务(Job)、触发器Trigger（SimpleTrigger和CronTrigger）`**

![在这里插入图片描述][20210329180136976.png]

Job、JobDetail
    trigger
        SimpleTrigger
        CronTrigger
    scheduler
        start
        stop
        pause
        resume

### 3.1.做什么工作—任务(Job) ###

*  Job表示`实现业务逻辑的任务接口`，只有一个`execute方法`，在里面编写定时任务的业务逻辑。比如：发送短信、发送邮件、访问数据库、同步数据等。`定时任务必须实现Job(org.quartz.Job)接口。`
    
        public interface Job { 
        	void execute(JobExecutionContext var1) throws JobExecutionException;
        }
 *  **`Job的生命周期`**: 每次调度器Sheduler执行Job时，都会根据`JobDetail创建一个新的Job实例`，再去执行Job中的execute()的内容。`任务执行结束后，关联的Job对象实例会被释放`，且会被JVM GC清除。这样可以`规避并发访问的问题`。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]

**JobDetail**： 当Quartz执行Job时，它会接收JobDetail这个实现类，通过`newInstance()`的反射调用机制来实例化一个Job，也就是说，在实例化Job时，需要有一个`返回值`来`接收实例化的Job`和一些`静态信息`。

public interface JobDetail extends Serializable, Cloneable { 
    	// 封装了name和group，作为JobDetail的唯一标识
        // 用空间来换取时间和可读性的策略
        JobKey getKey();
    	//返回Job的描述
        String getDescription();
    	//执行Job业务逻辑的实现类的Class引用
        Class<? extends Job> getJobClass();
    	//保存关于Job的信息，根据业务逻辑自己放进去
        JobDataMap getJobDataMap();
    
        boolean isDurable();
    
        boolean isPersistJobDataAfterExecution();
    
        boolean isConcurrentExectionDisallowed();
    
        boolean requestsRecovery();
    
        Object clone();
    
        JobBuilder getJobBuilder();
    }

### 3.2.什么时候工作—触发器(Trigger) ###

#### 3.2.1.描述 ####

**用于编写调度器scheduler执行定时任务Job触发规则。比如触发条件、触发时间，触发间隔，终止时间等。**

*  主要有`SimpleTrigger和CronTrigger`两个子类。
    
     *  **SimpleTrigger**是Quartz中最简单Trigger.它是为那种需要在指定的日期/时间启动，且以一个固定时间间隔重复执行 n 次的 Job 所设计的。如每5秒钟执行一次,一共执行4次的任务.
     *  **CronTrigger** 通过`cron表达式`不仅可以设定简单的触发时间表,更可以设定非常复杂的触发时间表。

触发器主要是指定**Job的开始时间、结束时间、重复次数以及重复的间隔等**。[Quartz触发器处理策略详解][Quartz]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]

#### 3.2.2.触发器类型 ####

**触发器的五种类型：**

*  SimpleTrigger
 *  CronTirgger
 *  DateIntervalTrigger
 *  NthIncludedDayTrigger
 *  Calendar 类(org.quartz.Calendar)

**其中做常用的是：**

*  **SimpleTrigger ： 用来触发一次或者多次的定时任务。**
 *  **CronTirgger：按照设置的cron表达式触发任务**

### 3.3.搭配 Trigger和Job—调度器(scheduler） ###

*  代表一个Quartz的独立运行调度容器，`一个调度容器中可以注册多个 JobDetail 和 Trigger`。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。两者在Scheduler中拥有`各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据`，**Trigger的组及名称必须唯一**，**JobDetail的组和名称也必须唯一**（`但可以和Trigger的组和名称相同，因为它们是不同类型的`）。
 *  Scheduler定义了多个接口方法，**允许外部 `通过组及名称`访问和控制容器中Trigger和JobDetail**。Scheduler可以将Trigger绑定到某一JobDetail中，这样当Trigger触发时，对应的Job就被执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job。`可以通过SchedulerFactory创建一个Scheduler实例。`  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]

**调度器(Schedule)的作用是将Job和Trigger结合起来。将对应的Trigger和Job绑定到调度器内，使得Trigger能够指定对应的Job在正确的时间执行。**

// 将触发器和任务绑定到调度器内
    scheduler.scheduleJob(backupHistoryJob, backupHistoryTrigger);

> **一个Job可以对应多个Trigger，一个Trigger只能对应一个Job**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]

## 4.任务存储方式 ##

**RAMJobStore**

*  `默认情况`，Quartz的触发器，调度，任务等信息都是放在`内存`中的，叫做 **RAMJobStore**。 好处是快速，坏处是z占用内存，而且一旦系统重启，那么信息就丢失了，就得全部从头来过。

**JDBCJobStore**

*  触发器，调度，任务等信息都是放在存放在`数据库`，叫做**JobStoreTX**。 好处是就算系统重启了，目前运行到第几次了这些信息都是存放在数据库中的，那么就可以继续原来的步伐把计划任务无缝地继续做下去。 坏处就是性能上比内存慢一些，毕竟数据库读取总是要慢一些的。

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>RAMJobStore</td> 
   <td>运行速度快，配置简单</td> 
   <td>因为存储在内存中，所以当程序停止运行，调度信息会丢失，并且内存的大小直接限制调度器的个数</td> 
  </tr> 
  <tr> 
   <td>JDBCJobStore</td> 
   <td>因为存储在数据库中，所以程序停止或重启，不会造成数据丢失，并且可以支持集群</td> 
   <td>存储在数据库中，运行速度相对较慢，并且有一些配置</td> 
  </tr> 
 </tbody> 
</table>

## 5.常用类 ##

### 5.1.任务 ###

#### 5.1.1.Job ####

*  该接口用于`编写具体的任务业务逻辑`。当调度器需要执行 job 时创建实例，调用完成后释放 job 实例。
 *  实现后需要重写`void execute(JobExecutionContext context)`方法。
 *  Job运行时的信息保存在`JobDataMap`实例中。

#### 5.1.2.JobBuilder ####

*  **Job构建器**：用来创建JobDetail的实例；

#### 5.1.3.JobDetail ####

*  JobDetail 定义的是`任务的明细数据`，而`真正的执行逻辑是在Job中`。
    
     *  常用属性：
    
    > name：Job名称、group：Job组。默认值为default、JobClass：job接口实现类的class。
    
     *  **JobDetail是任务的明细数据，而Job是任务的执行逻辑。在JobDetail里会引用一个Job Class定义**

为什么设计成 `JobDetail绑定指定的Job`，不直接使用Job

> 这是因为`任务是有可能并发执行`，如果Scheduler直接使用Job，就会存在`对同一个Job实例并发访问的问题`。而 JobDetail + Job 的方式，Sheduler每次执行，都会根据JobDetail创建一个新的Job实例，再去执行Job中的execute()的内容。任务执行结束后，关联的Job对象实例会被释放，且会被JVM GC清除。这样就可以规避并发访问的问题。

JobDetail是任务的明细数据，而Job是任务的执行逻辑。在JobDetail里会引用一个Job Class定义。

一个最简单的例子：

public class JobTest { 
        public static void main(String[] args) throws SchedulerException, IOException { 
            JobDetail job = JobBuilder.newJob()
                    .ofType(DoNothingJob.class) //引用Job Class
                    .withIdentity("job1", "group1") //设置name/group
                    .withDescription("this is a test job") //设置描述
                    .usingJobData("age", 18) //加入属性到ageJobDataMap
                    .build();
    
            job.getJobDataMap().put("name", "quertz"); //加入属性name到JobDataMap
    
            //定义一个每秒执行一次的SimpleTrigger
            Trigger trigger = TriggerBuilder.newTrigger()
                    .startNow()
                    .withIdentity("trigger1")
                    .withSchedule(SimpleScheduleBuilder
                    .simpleSchedule()
                    .withIntervalInSeconds(1)
                    .repeatForever())
                    .build();
                    
    		//直接读取classpath下的quartz.properties（不存在就都使用默认值）配置来实例化Schduler
            Scheduler sche = StdSchedulerFactory.getDefaultScheduler();
            sche.scheduleJob(job, trigger);
            sche.start();
            System.in.read();
            sche.shutdown();
        }
    }
    
    public class DoNothingJob implements Job { 
        public void execute(JobExecutionContext context) throws JobExecutionException { 
            System.out.println("do nothing");
        }
    }

#### 5.1.4.JobDataMap ####

*  JobDataMap实现了`Map接口`，以`Key-Value的存储数据`。用于`存储Job实例的状态信息`，调度器会使用这些信息实例Job 实例。
 *  JobDetail、Trigger都可以使用JobDataMap来设置一些参数或信息，Job执行execute()方法的时候，`JobExecutionContext`可以获取到`JobDataMap`中的信息。*`外部可以通过JobDataMap将数据传递给在运行的 Job 实例`*。  
      
    **外部传值到JobDataMap的两种方式**
    
        JobBuilder.newJob().usingJobData("age", 18) //加入属性到ageJobDataMap
        Job实例.getJobDataMap().put("name", "quertz"); //加入属性name到JobDataMap
    
    **Job内获取JobDataMap2种方式**
    
        public class HelloQuartz implements Job { 
        	private String name;
        
        	@Override
        	public void execute(JobExecutionContext context) throws JobExecutionException { 
            	JobDetail detail = context.getJobDetail();
            	//方法一：通过JobExecutionContext 获得JobDataMap
            	JobDataMap map = detail.getJobDataMap(); 
            	System.out.println("say hello to " + name + "[" + map.getInt("age") + "]" + " at "
                    + new Date());
         	}
        
        	//方法二：属性的setter方法，会将JobDataMap的属性自动注入
        	public void setName(String name) { 
            	this.name = name;
        	}
        }
    
    >  *  `同一个JobDetail实例，执行的多个Job实例共享同一个JobDataMap`，也就是说，如果你在任务里修改了里面的值，会对其他Job实例（并发的或者后续的）造成影响。
    >  *  除了JobDetail，`Trigger同样有一个JobDataMap，共享范围是所有使用这个Trigger的Job实例。`

#### 5.1.5.JobExecutionContext ####

*  Job能通过`JobExecutionContext`访问 `Quartz 运行环境`以及`Job本身的详细数据信息`。当Schedule调度执行一个Job的时候，就会将JobExecutionContext传递给该Job的`execute()方法`中，Job就可以通过JobExecutionContext对象获取信息。

> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]

### 5.2.触发器 ###

#### 5.2.1.Trigger ####

*  Trigger ：触发器的基本接口，主要有`SimpleTrigger和CronTrigger这2个子类`。**用于编写调度器执行定时任务触发规则**。
 *  主要是指定Job的开始时间、结束时间、重复次数以及重复的间隔等。
 *  多个 Trigger 可以指向同一 Job，但单个Trigger只能指向一个 Job。`可使用TriggerBuilder实例化触发器。`

![在这里插入图片描述][20210330163731100.png]

**触发器通用属性**

*  JobKey：表示job实例的标识，触发器被触发时，该指定的job实例会执行
 *  StartTime：表示触发器的时间表首次被触发的时间，它的值的类型是`Java.util.Date`
 *  EndTime：指定触发器的不再被触发的时间，它的值的类型是`Java.util.Date`

#### 5.2.2.TriggerBuilder ####

*  触发器构建器，用来定义或创建触发器的实例

#### 5.2.3.SimpleTrigger ####

**指定`从某一个时间开始，以一定的时间间隔（单位是毫秒）执行的任务`。它适合的任务类似于：9:00 开始，每隔1小时，执行一次。**

**常用属性：**

*  repeatInterval 重复间隔
 *  repeatCount 重复次数。实际执行次数是 repeatCount+1。因为在startTime的时候一定会执行一次。
 *  repeatForever: 无限重复

**伪代码:**  
如: 每隔1s执行一次执行定时任务触发器

Date startDate = new Date();
    startDate.setTime(startDate.getTime() + 5000);
    
    Date endDate = new Date();
    endDate.setTime(startDate.getTime() + 5000);
    
            Trigger trigger = TriggerBuilder.newTrigger()
            		.withIdentity("trigger1", "triggerGroup1")
                    .usingJobData("trigger1", "这是jobDetail1的trigger")
                    .startNow()//立即生效
                    .startAt(startDate)//几点开始执行
                    .endAt(endDate)//几点结束执行
                    .withSchedule(
                    	SimpleScheduleBuilder.simpleSchedule()
                    	.withIntervalInSeconds(1)//每隔1s执行一次
                    	.repeatForever()
                     )
    				.build();//一直执行

#### 5.2.4.CalendarIntervalTrigger ####

**类似于SimpleTrigger，`指定从某一个时间开始，以一定的时间间隔执行的任务`。**

*  但是不同的是`SimpleTrigger指定的时间间隔单位为毫秒`，没办法指定每隔一个月执行一次（每月的时间间隔不是固定值），而`CalendarIntervalTrigger支持的间隔单位有秒，分钟，小时，天，月，年，星期。`
 *  相较于SimpleTrigger有两个优势：
    
     *  1.更方便，比如每隔1小时执行，你不用自己去计算1小时等于多少毫秒。
     *  2.支持不是固定长度的间隔，比如间隔为月和年。但`劣势是精度只能到秒`。它适合的任务类似于：9:00 开始执行，并且以后每周 9:00 执行一次。

**常用属性:**

*  interval 执行间隔
 *  intervalUnit 执行间隔的单位（秒，分钟，小时，天，月，年，星期）

伪代码:

.withSchedule(
                    	CalendarIntervalScheduleBuilder.calendarIntervalSchedule()
                        .withIntervalInSeconds(1)
                    )//每秒执行一次
                    .build();
                    
                    .withSchedule(
                    	CalendarIntervalScheduleBuilder.calendarIntervalSchedule()
                        .withIntervalInDays(1)
                     )//每天执行一次
                    .build();
                    
                    .withSchedule(
                    	CalendarIntervalScheduleBuilder.calendarIntervalSchedule()
                        .withIntervalInWeeks(1)
                     )//每周执行一次
                    .build();

#### 5.2.5.DailyTimeIntervalTrigger ####

**指定`每天的某个时间段内，以一定的时间间隔执行任务。` 并且它可以`支持指定星期`。它适合的任务类似于：指定每天9:00 至 18:00 ，每隔70秒执行一次，并且只要周一至周五执行。**

常用属性

*  startTimeOfDay 每天开始时间
 *  endTimeOfDay 每天结束时间
 *  daysOfWeek 需要执行的星期
 *  interval 执行间隔
 *  intervalUnit 执行间隔的单位（秒，分钟，小时，天，月，年，星期）
 *  repeatCount 重复次数

伪代码

.withSchedule(
                    		DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()
                            .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //每天9：00开始
                            .endingDailyAt(TimeOfDay.hourAndMinuteOfDay(16, 0)) //16：00 结束
                            .onDaysOfTheWeek(1,2,3,4,5) //周一至周五执行
                            .withIntervalInHours(1) //每间隔1小时执行一次
                            .withRepeatCount(100)
                    ) //最多重复100次（实际执行100+1次）
                    .build();
    
                    .withSchedule(
                    		DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()
                            .startingDailyAt(TimeOfDay.hourAndMinuteOfDay(9, 0)) //每天9：00开始
                            .endingDailyAfterCount(10) //每天执行10次，这个方法实际上根据 startTimeOfDay+interval*count 算出 endTimeOfDay
                            .onDaysOfTheWeek(1, 2, 3, 4, 5) //周一至周五执行
                            .withIntervalInHours(1)
                     ) //每间隔1小时执行一次
                    .build();

#### 5.2.6.CronTrigger ####

**CroTrigger是`基于Cron表达式动态调度任务`，适用于更复杂的任务**

*  编写每周一到周五上午10:30执行定时任务触发器

**伪代码**

// 3、构建Trigger实例,每隔1s执行一次
                    .withSchedule(
                    	CronScheduleBuilder.cronSchedule("* 30 10 ? * 1/5 2021")
                     )
                    .build();

### 5.3.调度器 ###

#### 5.3.1.Scheduler ####

*  触发器的主要接口,是一个独立运行容器，调度器将对应的Trigger和Job绑定到调度器内，一旦Job和触发器绑定，当Trigger满足时间条件时，调度程序负责执行对应的Job。
 *  **Scheduler作为Quartz的核心调度器，有将近50多个API接口，包括任务的`添加，暂停，恢复，删除`等一系列的API，这里仅介绍一些常用的方法**
    
    1.  **start()**：只有调用start()方法后，Scheduler线程才开始`启动`触发器trigger，运行job
    2.  **pauseJob(JobKey jobKey)** ：根据指定的JobDetail key`暂停`job。
    3.  **resumeJob(JobKey jobKey)** ：根据指定的key`恢复`一个job。
    4.  **deleteJob(JobKey jobKey)** ：`删除`一个job
    5.  **triggerJob(JobKey jobKey)** ：`触发`一个JobDetail(现在执行)。
    6.  **rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)**：`更新`job的触发器
 *  **Scheduler有2个重要组件: `JobStore和ThreadPool`**
    
     *  JobStore是会来 **`存储运行时任务信息`** 的，包括`Trigger,Schduler,JobDetail，业务锁`等。
        
         *  它有多种实现`RAMJob(内存实现)`，`JobStoreTX(JDBC，事务由Quartz管理）`，`JobStoreCMT(JDBC，使用容器事务)`，`ClusteredJobStore(集群实现)`、`TerracottaJobStore(保存在Terractta缓存服务器)`
     *  **RAMJobStore**
    
    > org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
    
     *  **JDBCJobStore**
    
    > 几乎适用于所有的数据库，广泛用于 Oracle, PostgreSQL, MySQL, MS SQLServer, HSQLDB, 和DB2。
    
     *  **JobStoreTX**
    
    > org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
    > org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate  
    > \#配置表的前缀  
    > org.quartz.jobStore.tablePrefix = QRTZ\_  
    > \#使用JNDI数据源的时候，数据源的名字  
    > org.quartz.jobStore.dataSource = myDS
    
     *  **TerracottaJobStore**
    
    > \#数据是存储在Terracotta服务器。它的性能比使用数据库访问JDBCJobStore好  
    > org.quartz.jobStore.class = org.terracotta.quartz.TerracottaJobStore  
    > org.quartz.jobStore.tcConfigUrl = localhost:9510
    
     *  ThreadPool： 线程池，Quartz有自己的线程池实现。所有任务的都会由线程池执行。任务通过共享线程池中的线程提高运行效率。

#### 5.3.2.SchedulerFactory ####

*  SchdulerFactory: 就是来用创建Schduler了，有两个实现：
    
     *  **DirectSchedulerFactory**
     *  **StdSchdulerFactory**。
 *  **`前者`可以用来在代码里配置参数,实例化Schduler**。**`后者`是直接读取classpath下的quartz.properties（不存在就都使用默认值）配置来实例化Schduler。** `一般使用StdSchdulerFactory就足够`。

#### 5.3.3.ScheduleBuilder ####

*  构建调度器实例，设置`触发规则`，如多久执行一次，是否重复执行，延迟多久执行等。

### 5.4.监听器 ###

Quartz 的监听器`有Job监听器，Trigger监听器， Scheduler监听器` 。  
三者的使用方法类似。

*  在开始介绍三种监听器之前，需要明确两个概念：**全局监听器与非全局监听器**，二者的区别在于：**全局监听器能够接收到`所有的Job/Trigger的事件通知`，而非全局监听器`只能接收到在其上注册的Job或Trigger的事`**
    
     *  实际业务用的较多的是`Job监听器`，用于监听器Job是否执行了，其他的用的相对较少。

#### 5.4.1.JobListener ####

**跟任务相关的事件包括：`job开始要执行的通知; job执行完成的通知`**

源码

public interface JobListener { 
     	//用于获取该JobListener的名称。
        public String getName();
        
     	//Scheduler在JobDetail将要被执行时调用这个方法。
        public void jobToBeExecuted(JobExecutionContext context);
        
     	//Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
        public void jobExecutionVetoed(JobExecutionContext context);
        
     	//Scheduler在JobDetail被执行之后调用这个方法
        public void jobWasExecuted(JobExecutionContext context,  JobExecutionException jobException);
    }

**任务**

public class TimerJob implements Job { 
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException { 
    		System.out.println("坚持 坚持 在坚持，永不放弃"+ new Date());
    	}
    }

**Job监听器**

public class TimerJobListener implements JobListener { 
    	//获取该JobListener的名称
    	@Override
    	public String getName() { 
    		 String name = getClass().getSimpleName();
    		return name;
    	}
    	
    	//Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
    	@Override
    	public void jobExecutionVetoed(JobExecutionContext arg0) { 
    		System.out.println("Scheduler在JobDetail即将被执行，但又被TriggerListerner否决");
    	}
    	
    	//Scheduler在JobDetail将要被执行时调用这个方法。
    	@Override
    	public void jobToBeExecuted(JobExecutionContext arg0) { 
    		System.out.println("Scheduler在JobDetail将要被执行");
    	}
    	
    	//Scheduler在JobDetail被执行之后调用这个方法
    	@Override
    	public void jobWasExecuted(JobExecutionContext arg0, JobExecutionException arg1) { 
    		System.out.println("Scheduler在JobDetail被执行之后");
    	}
    }

**任务调度与运行，及JobListener的创建与注册。**

public class TimerExample { 
    	// 创建 schedulerFactory 工厂
    	private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
    
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		String[] data= { "s","t","r","i","n","g"};
    		addJob("HelloJob1","HelloJobGroup","HelloTrigger1","HelloTriggerGroup",TimerJob.class,"0/1 * * * * ?",data);
    	}
    	/**添加一个定时任务 * @param jobName 任务名 * @param jobGroupName 任务组名 * @param triggerName 触发器名 * @param triggerGroupName 触发器组名 * @param jobClass 任务类名 * @param cron 时间 */
    	public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
    			,Class<? extends Job> jobClass,String cron,String[] data) { 
    		try { 
    			//通过scheduleFactory创建任务调度器
    			Scheduler scheduler = scheduleFactory.getScheduler();
    			
    			//创建 jobDetail 实例，绑定 Job 实现类
    			// 指明 job 的名称，所在组的名称，以及绑定 job 类
    			JobDetail job = (JobDetail) JobBuilder.newJob(jobClass)
    					.withIdentity(jobName,jobGroupName)
    					//.requestRecovery() // 执行中应用发生故障，需要重新执行
    					.build();
    					// 初始化参数传递到 job
    					job.getJobDataMap().put("data",data);
    					
    			// 定义调度触发规则CronTrigger
    			//指明 CronTrigger 的名称，所在组的名称，触发时间
    			Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
    					.withIdentity(triggerName,triggerGroupName)
    					.startNow()
    					.withSchedule(CronScheduleBuilder.cronSchedule(cron))
    					.build();
    			
    			// 把作业和触发器注册到任务调度中
    			scheduler.scheduleJob(job,trigger);
    	
    			
    			// 创建并注册一个全局的Job Listener
    	        scheduler.getListenerManager().addJobListener(new TimerJobListener(), EverythingMatcher.allJobs());
    	        // 创建并注册一个指定任务的Job Listener
    // scheduler.getListenerManager().addJobListener(new TimerJobListener(), KeyMatcher.keyEquals(JobKey.jobKey(jobName,jobGroupName)));
    			
    			//启动
    			if(!scheduler.isShutdown()) { 
    				scheduler.start();
    				System.out.println("开始调度任务");
    			}
    		} catch (SchedulerException e) { 
    			e.printStackTrace();
    		}
    	}
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]

#### 5.4.2.TriggerListener ####

**跟触发器有关的事件包括：`触发器被触发`，`触发器触发失败`，以及`触发器触发完成`（触发器完成后作业任务开始运行）。**

接口源码

public interface ITriggerListener{ 
    	//用于获取触发器的名称
         string Name {  get; }
     	//当与监听器相关联的Trigger被触发，Job上的execute()方法将被执行时，Scheduler就调用该方法。
         void TriggerFired(ITrigger trigger, IJobExecutionContext context);
     	
     	//在 Trigger 触发后，Job 将要被执行时由 Scheduler 调用这个方法。TriggerListener 给了一个选择去否决 Job 的执行。假如这个方法返回 true，这个 Job 将不会为此次 Trigger 触发而得到执行。
         boolean VetoJobExecution(ITrigger trigger, IJobExecutionContext context);
     	
     	//Scheduler 调用这个方法是在 Trigger 错过触发时。你应该关注此方法中持续时间长的逻辑：在出现许多错过触发的 Trigger 时，长逻辑会导致骨牌效应。你应当保持这上方法尽量的小。
         void TriggerMisfired(ITrigger trigger);
     	
     	//Trigger 被触发并且完成了 Job 的执行时，Scheduler 调用这个方法。
         void TriggerComplete(ITrigger trigger, IJobExecutionContext context, int triggerInstructionCode);
    }

**使用：**

1.  创建一个监听器，实现org.quartz.TriggerListener或org.quartz.JobListener接口的对象即可。监听器会在运行期间注册到`调度器`中，并且`必须要给定监听器名`（更确切地说，监听器会调用getName方法获取自己的名字）。
2.  监听器注册到调度器中的监听器管理类时还携带着一个`匹配器`，这个匹配器描述了任务和触发器的监听器想接收的事件。
3.  监听器在运行期间注册到调度器中，但是不会把任务和触发器存储到JobStore中。那是因为监听器在你的应用中通常是一些点的集合。因此，每次应用运行时，监听器都需要重新在调度器中注册。

**任务**

**Trigger监听器**

public class TimerTriggerListener implements TriggerListener{ 
    	private String timerTriggerName="";
    	
    	public TimerTriggerListener(String timerTriggerName) { 
    		this.timerTriggerName = timerTriggerName;
    	}
     
    	@Override
    	public String getName() { 
    		System.out.println(timerTriggerName);
    		return timerTriggerName;
    	}
    	
    	//触发器触发完成
    	//(4) 任务完成时触发
    	@Override
    	public void triggerComplete(Trigger arg0, JobExecutionContext arg1, CompletedExecutionInstruction arg2) { 
    		System.out.println("触发器触发完成");
    	}
    	//触发器被触发
    	//(1)Trigger被激发 它关联的job即将被运行
    	@Override
    	public void triggerFired(Trigger arg0, JobExecutionContext arg1) { 
    		System.out.println("Trigger被激发 它关联的job即将被运行");
    	}
    	//触发器触发失败
    	//(3) 当Trigger错过被激发时执行,比如当前时间有很多触发器都需要执行，但是线程池中的有效线程都在工作，
    	//那么有的触发器就有可能超时，错过这一轮的触发。
    	@Override
    	public void triggerMisfired(Trigger arg0) { 
    		System.out.println("触发器触发失败");
    	}
    	//(2)Trigger被激发 它关联的job即将被运行,先执行(1)，在执行(2) 如果返回TRUE 那么任务job会被终止
    	@Override
    	public boolean vetoJobExecution(Trigger arg0, JobExecutionContext arg1) { 
    		return false;
    	}
     
    }

**任务调度与运行，及TriggerListener的创建与注册。**

public class TimerExample { 
    	// 创建 schedulerFactory 工厂
    	private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
    	
    	
    	public static void main(String[] args) { 
    		// TODO Auto-generated method stub
    		String[] data= { "s","t","r","i","n","g"};
    		addJob("HelloJob","HelloJobGroup","HelloTrigger","HelloTriggerGroup",TimerJob.class,"0/1 * * * * ?",data);
    	}
    	/**添加一个定时任务 * @param jobName 任务名 * @param jobGroupName 任务组名 * @param triggerName 触发器名 * @param triggerGroupName 触发器组名 * @param jobClass 任务类名 * @param cron 时间 */
    	public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
    			,Class<? extends Job> jobClass,String cron,String[] data) { 
    		try { 
    			//通过scheduleFactory创建任务调度器
    			Scheduler scheduler = scheduleFactory.getScheduler();
    			
    			//创建 jobDetail 实例，绑定 Job 实现类
    			// 指明 job 的名称，所在组的名称，以及绑定 job 类
    			JobDetail job = (JobDetail) JobBuilder.newJob(jobClass)
    					.withIdentity(jobName,jobGroupName)
    					//.requestRecovery() // 执行中应用发生故障，需要重新执行
    					.build();
    					// 初始化参数传递到 job
    					job.getJobDataMap().put("data",data);
    					
    			// 定义调度触发规则CronTrigger
    			//指明 CronTrigger 的名称，所在组的名称，触发时间
    			Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
    					.withIdentity(triggerName,triggerGroupName)
    					.startNow()
    					.withSchedule(CronScheduleBuilder.cronSchedule(cron))
    					.build();
    			
    			// 把作业和触发器注册到任务调度中
    			scheduler.scheduleJob(job,trigger);
    			// 创建并注册一个全局的TriggerListener
    	        scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), EverythingMatcher.allTriggers());
    	        // 创建并注册一个局部的TriggerListener
    // scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), KeyMatcher.keyEquals(TriggerKey.triggerKey(triggerName, triggerGroupName)));
    	        // 创建并注册一个特定组的TriggerListener
    // scheduler.getListenerManager().addTriggerListener(new TimerTriggerListener("TimerTrigger"), GroupMatcher.groupEquals(triggerGroupName));
    			
    			//启动
    			if(!scheduler.isShutdown()) { 
    				scheduler.start();
    				System.out.println("开始调度任务");
    			}
    		} catch (SchedulerException e) { 
    			e.printStackTrace();
    		}
    	}
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]

#### 5.4.3.SchedulerListener ####

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

接口源码

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

**任务**

**Scheduler监听器**

public class TimerSchedulerListener implements SchedulerListener { 
    	 @Override
    	    public void jobScheduled(Trigger trigger) { 
    	        String jobName = trigger.getJobKey().getName();
    	        System.out.println(jobName + "部署s");
    	    }
     
    	    @Override
    	    public void jobUnscheduled(TriggerKey triggerKey) { 
    	        System.out.println(triggerKey + "卸载");
    	    }
     
    	    @Override
    	    public void triggerFinalized(Trigger trigger) { 
    	        System.out.println("触发完成" + trigger.getJobKey().getName());
    	    }
     
    	    @Override
    	    public void triggerPaused(TriggerKey triggerKey) { 
    	        System.out.println(triggerKey + "暂停");
    	    }
     
    	    @Override
    	    public void triggersPaused(String triggerGroup) { 
    	        System.out.println("trigger group "+triggerGroup + "暂停");
    	    }
     
    	    @Override
    	    public void triggerResumed(TriggerKey triggerKey) { 
    	        System.out.println(triggerKey + "从暂停中恢复");
    	    }
     
    	    @Override
    	    public void triggersResumed(String triggerGroup) { 
    	        System.out.println("trigger group "+triggerGroup + "从暂停中恢复");
    	    }
     
    	    @Override
    	    public void jobAdded(JobDetail jobDetail) { 
    	        System.out.println(jobDetail.getKey()+"增加");
    	    }
     
    	    @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("job group "+jobGroup+"暂停");
    	    }
     
    	    @Override
    	    public void jobResumed(JobKey jobKey) { 
    	        System.out.println(jobKey+"从暂停上恢复");
    	    }
     
    	    @Override
    	    public void jobsResumed(String jobGroup) { 
    	        System.out.println("job group "+jobGroup+"从暂停上恢复");
    	    }
     
    	    @Override
    	    public void schedulerError(String msg, SchedulerException cause) { 
    	        System.out.println("正常运行期间产生一个严重错误");
    	    }
     
    	    @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中的数据被清除");
    	    }
    }

**任务调度与运行，及SchedulerListener的创建与注册。**

public class TimerExample { 
    	// 创建 schedulerFactory 工厂
    	private static SchedulerFactory scheduleFactory= new StdSchedulerFactory();
    	
    	public static void main(String[] args) { 
    		String[] data= { "s","t","r","i","n","g"};
    		try { 
    			addJob("HelloJob2","HelloJobGroup","HelloTrigger2","HelloTriggerGroup",TimerJob.class,"0/1 * * * * ?",data);
    		} catch (InterruptedException e) { 
    			e.printStackTrace();
    		}
    	}
    	/**添加一个定时任务 * @param jobName 任务名 * @param jobGroupName 任务组名 * @param triggerName 触发器名 * @param triggerGroupName 触发器组名 * @param jobClass 任务类名 * @param cron 时间 * @throws InterruptedException */
    	public static void addJob(String jobName,String jobGroupName,String triggerName,String triggerGroupName
    			,Class<? extends Job> jobClass,String cron,String[] data) throws InterruptedException { 
    		try { 
    			//通过scheduleFactory创建任务调度器
    			Scheduler scheduler = scheduleFactory.getScheduler();
    			
    			//创建 jobDetail 实例，绑定 Job 实现类
    			// 指明 job 的名称，所在组的名称，以及绑定 job 类
    			JobDetail job = (JobDetail) JobBuilder.newJob(jobClass)
    					.withIdentity(jobName,jobGroupName)
    					//.requestRecovery() // 执行中应用发生故障，需要重新执行
    					.build();
    					// 初始化参数传递到 job
    					job.getJobDataMap().put("data",data);
    					
    			// 定义调度触发规则CronTrigger
    			//指明 CronTrigger 的名称，所在组的名称，触发时间
    			Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
    					.withIdentity(triggerName,triggerGroupName)
    					.startNow()
    					.withSchedule(CronScheduleBuilder.cronSchedule(cron))
    					.build();
    			
    			// 把作业和触发器注册到任务调度中
    			scheduler.scheduleJob(job,trigger);
    			
    	        
    	        // 创建SchedulerListener
    	        scheduler.getListenerManager().addSchedulerListener(new TimerSchedulerListener());
    	        
    	        // 移除对应的SchedulerListener
    			//scheduler.getListenerManager().removeSchedulerListener(new TimerSchedulerListener());
    			//启动
    			if(!scheduler.isShutdown()) { 
    				scheduler.start();
    				System.out.println("开始调度任务");
    			}
    			
    			Thread.sleep(5000);
    	        scheduler.shutdown();
    	        
    		} catch (SchedulerException e) { 
    			e.printStackTrace();
    		}
    	}
    }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]

#### 5.4.4.监听器注册 ####

上面采用`KeyMatcher`和`ListerManager`来对我们的任务进行监听，其实在Quartz框架中，可以通过组合来实现不同的方式对job进行监听 。如：

**如上面添加Job监听器的代码**  
![在这里插入图片描述][20210504173452417.png]

通过`ListenerManager`向`scheduler中添加监听器`。针对JobDtail方法有

//添加全局监听器
    public void addJobListener(JobListener jobListener);
    
    // 添加带条件匹配监听器
    public void addJobListener(JobListener jobListener, Matcher<JobKey> matcher);
    
    
     //添加不定参数带条件匹配监听器
    public void addJobListener(JobListener jobListener, Matcher<JobKey> ... matchers);
    
     //添加不定参数带条件匹配监听器
    public void addJobListener(JobListener jobListener, List<Matcher<JobKey>> matchers);
    
     // 添加匹配名字的监听器
    public boolean addJobListenerMatcher(String listenerName, Matcher<JobKey> matcher);
    
     //删除匹配名字的监听器
    public boolean removeJobListenerMatcher(String listenerName, Matcher<JobKey> matcher);
    
     //设置匹配名字的监听器
    public boolean setJobListenerMatchers(String listenerName, List<Matcher<JobKey>> matchers);
    
     //根据监听名字获取匹配监听器
    public List<Matcher<JobKey>> getJobListenerMatchers(String listenerName);
    
     //根据名字删除监听器
    public boolean removeJobListener(String name);
    
     // 获取所有的监听器
    public List<JobListener> getJobListeners();
    
    //根据名字获取监听器
    public JobListener getJobListener(String name);

**Matcher:通过Matcher监听不同的任务，具体实现类如下：**

*  KeyMatcher:根据JobKey进行匹配
 *  GroupMatcher:跟组名信息进行匹配
 *  AndMatcher:对两个匹配器做交际
 *  OrMatcher:对两个匹配器做并集
 *  EveryThingMatcher:局部全局匹配

### 5.5.trigger状态 ###

`org.quartz.impl.jdbcjobstore.Constants`中存放了一些列的常量

*  里面有`quartz的表名`、各个`表包含的列名`、`trigger状态`、`trigger类型`等

**状态包括**

*  **WAITING**：等待中
 *  **ACQUIRED**：将触发，`此时还未到trigger真正的触发时刻`
 *  **EXECUTING**：触发，亦可理解成执行中，`trigger真正的触发时刻`
 *  **COMPLETE**：完成，不再触发
 *  BLOCKED：受阻，`不允许并发执行job时会出现（@DisallowConcurrentExecution）`
 *  ERROR：出错
 *  **PAUSED**：暂停中
 *  PAUSED\_BLOCKED：暂停受阻，`不允许并发执行job时会出现（@DisallowConcurrentExecution）`
 *  **DELETED**：已删除
 *  MISFIRED：触发失败，已弃用，有另外的替代方式  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]
 *  trigger的`初始状态是WAITING`，处于WAITING状态的trigger`等待被触发`。调度线程会不停地扫t`riggers表`，根据`NEXT_FIRE_TIME`提前拉取即将触发的trigger，如果这个trigger被该调度线程拉取到，它的状态就会变为`ACQUIRED（将触发）`。
 *  因为是*提前拉取trigger，并未到达trigger真正的触发时刻*，所以调度线程会等到真正触发的时刻，再将trigger状态由`ACQUIRED改为EXECUTING`。如果这个trigger不再执行，就将状态改为·COMPLETE·,否则为·WAITING，开始新的周期。`如果这个周期中的任何环节抛出异常`，trigger的状态会变成`ERROR`。如果`手动暂停`这个trigger，状态会变成`PAUSED`。

## 6.定时任务实现步骤 ##

### 6.1.步骤描述 ###

（1）首先要`实现一个定时功能的接口Task（或Job）,编写定时任务的具体逻辑`。如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]

（2）实现任务Job后，需要一个`能够触发什么时候执行任务的触发器`，触发器Trigger最基本的功能是指定Job的执行时间，执行间隔，运行次数等。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]

（3）有了任务Job和触发器Trigger后，怎么样将两者结合起来呢？即怎样指定Trigger去执行指定的Job呢？这时需要一个调度器Schedule，来负责这个功能的实现。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 11]

具体代码如下:

1.**新建一个能够打印当前时间的Job**

public class PrintWordsJob implements Job{ 
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { 
            String printTime = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss").format(new Date());
            System.out.println("PrintWordsJob start at:" + printTime + ", prints: Hello Job-" + new Random().nextInt(100));
    
        }
    }

2.**创建Schedule，执行任务**

public class MyScheduler { 
    
        public static void main(String[] args) throws SchedulerException, InterruptedException { 
            // 1、创建调度器Scheduler
            //直接读取classpath下的quartz.properties（不存在就都使用默认值）配置来实例化Schduler
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            
            // 2、创建任务JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
            JobDetail jobDetail = JobBuilder.newJob(PrintWordsJob.class)//指定干活的类MailJob
                                            .withIdentity("job1", "group1")//设置任务名、任务组名
                                            .usingJobData("jobDetailData1", "data1") //自定义属性1
                                            .usingJobData("jobDetailData2", "data2") //自定义属性2
                                            .build();
                                            
            // 3、构建触发器Trigger实例,每隔1s执行一次
            Trigger trigger = TriggerBuilder.newTrigger()
            		.withIdentity("trigger1", "triggerGroup1")//设置触发器名、触发器组名
            		.usingJobData("triggerData1", "data3") //自定义属性1
                    .usingJobData("triggerData2", "data4") //自定义属性2
                    .startNow()//立即生效
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                    .withIntervalInSeconds(1)//每隔1s执行一次
                    .repeatForever()).build();//一直执行
    
            //4、执行
            scheduler.scheduleJob(jobDetail, trigger);
            System.out.println("--------scheduler start ! ------------");
            scheduler.start();
    
            //等待1分钟，让前面的任务都执行完了之后，再关闭调度器
            TimeUnit.MINUTES.sleep(1);
            scheduler.shutdown();
            System.out.println("--------scheduler shutdown ! ------------");
        }
    }

**执行结果:**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]

**所以可以得出结论:**

1.  `实现Job接口，重写execute方法，编写任务逻辑`。
2.  生成一个调度器工厂SchedulerFactory
3.  通过`SchedulerFactory#getScheduler()`方法从调度器工厂里得到调度器实例，首先查找有没有这样的调度器，没有的话，就生成一个，有的话直接返回。所以得到的一般是单例，即`默认的调度器`；
4.  `创建JobDetail实例，并与Job实现类绑定`，`设置任务的名字，分组`。
5.  `创建触发器Trigger实例，设置触发器的名字，分组`，编写定时任务触发规则。
6.  **将任务Job与触发器Trigger，交由调度器Scheduler 管理**
7.  开启任务调度（ `scheduler实例.start()`）

### 6.2.实例代码 ###

创建一个 Job 实现类，用于编写具体业务逻辑

import org.quartz.*;
    
    import java.time.LocalDateTime;
    import java.time.format.DateTimeFormatter;
    
    public class TestJob implements Job { 
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException { 
            LocalDateTime nowTime = LocalDateTime.now();
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
            System.out.println("---------" + formatter.format(nowTime));
            // 获取Scheduler
            Scheduler scheduler = context.getScheduler();
            // 获取Trigger
            Trigger trigger = context.getTrigger();
            // 通过Trigger获取JobDataMap参数
            JobDataMap triggerJobData = trigger.getJobDataMap();
            // 获取JobDetail
            JobDetail jobDetail = context.getJobDetail();
            // 通过JobDetail获取JobDetail参数
            JobDataMap jobDetailData = jobDetail.getJobDataMap();
            // 合并获取JobDataMap，存在键值相同的，取Trigger JobDataMap的值
            JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
        }
    }

具体调度实现代码

import org.quartz.*;
    import org.quartz.impl.StdSchedulerFactory;
    
    public class TestScheduled { 
        public static void main(String[] args) throws SchedulerException { 
            // 创建一个Trigger实例
            JobDataMap triggerData = new JobDataMap();
            triggerData.put("trigger1", "我是trigger1");
            triggerData.put("trigger2", "我是trigger2");
            
            // 创建一个Schedule实例(每个10秒执行一次)
            ScheduleBuilder scheduleBuilder =  CronScheduleBuilder.cronSchedule("0/10 * * * * ?");
            /*ScheduleBuilder scheduleBuilder = SimpleScheduleBuilder .repeatSecondlyForever(10) //每个10秒执行一次 .repeatForever(); //重复执行*/
                    
            Trigger trigger = TriggerBuilder.newTrigger()   // 获取trigger类
                    .withIdentity("triggerName", "triggerGroup")    // 任务唯一标识和组别
                    .withDescription("triggerDescription")  // 描述
                    .usingJobData(triggerData)   // 自定义参数
                    .startNow() // 立即执行,startAt(Date triggerStartTime) -> 某个特定时间开始执行
                                // endAt(Date triggerEndTime) -> 某个特定时间结束执行
                    .withSchedule(scheduleBuilder)  // 设置执行计划
                    .build();
                    
            // 创建一个jobDetil实例，该实例与 Job Class绑定
            JobDataMap jobData = new JobDataMap();
            jobData.put("job1", "我是job1");
            jobData.put("job2", "我是job2");
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class)
                    .withIdentity("jobName", "jobGroup")
                    .withDescription("jobDescription")
                    .usingJobData(jobData)
                    .build();
                    
            // 创建Scheduler实例：javaWeb项目可以通过注入方式创建Scheduler实例，如(@Autowired private Scheduler scheduler;)
            //直接读取classpath下的quartz.properties（不存在就都使用默认值）配置来实例化Schduler
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();  // 执行
    
            //等待20秒，让前面的任务都执行完了之后，再关闭调度器
            Thread.sleep(20000);
            scheduler.shutdown(true);
        }
    }

### 6.3.设置分组的作用 ###

.withIdentity("mailjob1", "mailgroup1")

比如一个系统有3个job 是备份数据库的，有4个job 是发邮件的，那么对他们进行分组，可以方便管理，可以实现似于一次性停止所有发邮件job 的这样的操作.

### 6.4.异常处理 ###

任务里发生异常是很常见的。 异常处理办法通常是两种：

1.  当异常发生，那么就通知所有管理这个 Job 的调度器Scheduler，`停止运行异常Job`
2.  当异常发生，修改参数，`重新运行异常Job`

**方式1：取消Job 对应的所有调度**

public class ExceptionJob1 implements Job { 
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException { 
            int i = 0;
            try { 
                //故意发生异常
                System.out.println(100 / i);
    
            } catch (Exception e) { 
                System.out.println("发生了异常，取消这个Job 对应的所有调度");
                JobExecutionException je = new JobExecutionException(e);
                //设置所有调度器取消该任务调度
                je.setUnscheduleAllTriggers(true);
                throw je;
            }
        }
    }

调度代码按照上面步骤编写即可，执行结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 13]

**方式2：修改参数，重新执行Job**

import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    
    public class ExceptionJob2  implements Job { 
    	static int i = 0;
        public void execute(JobExecutionContext context) throws JobExecutionException { 
    
            try { 
            	//故意发生异常
            	System.out.println("运算结果"+100/i);
            	
    		} catch (Exception e) { 
    			System.out.println("发生了异常，修改一下参数，立即重新执行");
    			i = 1;
    			JobExecutionException je =new JobExecutionException(e);
    			//设置任务立即重新执行
    			je.setRefireImmediately(true);
    			throw je;
    		}
        }
    }

> 注意:
> 
>  *  Job.execute()方法是`不允许抛出除JobExecutionException之外的所有异常的`（包括`RuntimeException`)，所以`编码的时候，最好是try-catch所有的Throwable`，小心处理。

### 6.5. Job 并发-@DisallowConcurrentExecution、@PersistJobDataAfterExecution ###

`Quartz定时任务默认都是并发执行的`，**不会等待上一次任务执行完毕，只要间隔时间到就会执行**, 如果定时任执行太长，会长时间占用资源，导致其它任务堵塞。这时需要`@DisallowConcurrentExecution 禁止并发执行。`

*  `当任务的执行时长超过定时任务触发的间隔时`，就会`导致两个或多个任务并发在执行`，如果我们不希望定时任务并发执行可以通过 **@DisallowConcurrentExecution** 注解来禁止并发。
 *  `不能并发执行同一个由绑定在JobDetail的Job生成的实例 ，但是可以同时执行多个不同的JobDetail`

> 场景：有时候会做长时间的任务，比如数据库备份，这个时候就希望上一次备份成功结束之后，才开始下一次备份，即便是规定时间到了，也不能开始，因为这样很有可能造成 数据库被锁死 （几个线程同时备份数据库，引发无法预计的混乱）。那么在这种情况下，给数据库备份任务增加一个注解就好了：`@DisallowConcurrentExecution`

**举例说明：**

> 同一个Job实现类DemoJob的两个JobDetail实例：A和B
> 
> > A的每1分钟执行一次，A的实际运行耗时为3分钟(`Job使用@DisallowConcurrentExecution注解`)  
> > B的也是每1分钟执行一次，B的实际运行耗时为30秒
> 
> 假如在07:00分00秒时A和B同时第一次运行，则到07:00分30秒时B运行结束，此时A还在运行中，到07:01分00秒时A和B又该执行了，但是由于注解@DisallowConcurrentExecution的缘故，此时A不会再次运行，A只能在其上一次运行结束后才能再次被调用执行。但是B会正常运行（B不受A的影响，注解@DisallowConcurrentExecution是作用于JobDetail实例而不是Job实现类）

**@DisallowConcurrentExecution**

*  禁止并发执行多个相同定义的JobDetail, 这个注解是加在Job类上的, 但意思并不是不能同时执行多个Job, 而是不能并发执行同一个Job Definition(由JobDetail定义), 但是可以同时执行多个不同的JobDetail。

**@PersistJobDataAfterExecution**

*  告诉Quartz在成功执行了Job实现类的execute方法后（没有发生任何异常），更新JobDetail中JobDataMap的数据，使得该JobDetail实例在下一次执行的时候，JobDataMap中是更新后的数据，而不是更新前的旧数据。

@Slf4j
    @DisallowConcurrentExecution
    @PersistJobDataAfterExecution
    public class DemoJob implements Job { 
    	@Override
        public void execute(JobExecutionContext context) { 
            String database = detail.getJobDataMap().getString("database");
            System.out.printf("给数据库 %s 备份, 耗时10秒 %n", database);
            try { 
                Thread.sleep(10000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    	}
    }

两个JobDetail实例：

// 定义触发器Trigger和调度器Scheduler省略
    JobDetail A = JobBuilder.newJob(DemoJob.class)
                    		.withDescription("jobDescription")
                   			.withIdentity("name1", "group")
                   			.usingJobData("database", "mysql")
                    		.build();
                    				
    JobDetail B = JobBuilder.newJob(DemoJob.class)
                    		.withDescription("jobDescription")
                   			.withIdentity("name2", "group")
                   			.usingJobData("database", "db2")               
                    		.build();

调度代码按照上面步骤编写即可

**使用建议：**

*  如果你使用了`@PersistJobDataAfterExecution`注解，则强烈建议你`同时使用@DisallowConcurrentExecution`注解，因为当同一个job（JobDetail）的两个实例被并发执行时，由于竞争，JobDataMap中存储的数据很可能是不确定的。

### 6.6.中断 Job ###

在业务上，有时候需要中断任务，那么这个Job需要`实现 InterruptableJob 接口`，然后就方便中断了

import org.quartz.InterruptableJob;
    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    import org.quartz.UnableToInterruptJobException;
    
    //必须实现InterruptableJob 而非 Job才能够被中断
    public class StoppableJob implements InterruptableJob { 
    	private boolean stop = false;
    	
        public void execute(JobExecutionContext context) throws JobExecutionException { 
        	while(true){ 
        		if(stop)
        			break;
        		try { 
            		System.out.println("每隔1秒，进行一次检测，看看是否停止");
    				Thread.sleep(1000);
    			} catch (InterruptedException e) { 
    				e.printStackTrace();
    			}
        		System.out.println("持续工作中。。。");
        	}
        
        }
        public void interrupt() throws UnableToInterruptJobException { 
        	System.out.println("被调度叫停");
            stop = true;
        }
    }

public static void main(String [] args) { 
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
    
            Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
                    .startNow()
                    .build();
    
            //定义一个JobDetail
            JobDetail job = newJob(StoppableJob.class)
                    .withIdentity("exceptionJob1", "someJobGroup")
                    .build();
    
            //调度加入这个job
            scheduler.scheduleJob(job, trigger);
    
            //启动
            scheduler.start();
    
            Thread.sleep(5000);
            System.out.println("过5秒，调度停止 job");
    
            //key 就相当于这个Job的主键（关键代码！！）
            scheduler.interrupt(job.getKey());
    
            //等待20秒，让前面的任务都执行完了之后，再关闭调度器
            Thread.sleep(20000);
            scheduler.shutdown(true);
        }

执行结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 15]

### 6.6.Calendar ###

这里的Calendar不是jdk的java.util.Calendar，不是为了计算日期的。它的作用是在于`补充Trigger的时间`。`可以排除或加入某一些特定的时间点。`

*  以”每月15日零点自动还花呗“为例，我们想排除掉每年的2月25号零点这个时间点（因为有2.14，所以2月一定会破产）。这个时间，就可以用Calendar来实现。  
    伪代码

AnnualCalendar cal = new AnnualCalendar(); //定义一个每年执行Calendar，精度为天，即不能定义到2.15号下午2:00
    java.util.Calendar excludeDay = new GregorianCalendar();
    excludeDay.setTime(newDate().inMonthOnDay(2, 15).build());
    cal.setDayExcluded(excludeDay, true); //设置排除2.15这个日期
    scheduler.addCalendar("FebCal", cal, false, false); //scheduler加入这个Calendar
     
    //定义一个Trigger
    Trigger trigger = newTrigger().withIdentity("trigger1", "group1") 
     .startNow()//一旦加入scheduler，立即生效
     .modifiedByCalendar("FebCal") //使用Calendar !!
     .withSchedule( SimpleScheduleBuilder.simpleSchedule()
      .withIntervalInSeconds(1) 
      .repeatForever()) 
     .build();

所有的Calendar`既可以是排除，也可以是包含`。Quartz提供以下几种Calendar

*  HolidayCalendar。指定特定的日期，比如20140613。精度到天。
 *  DailyCalendar。指定每天的时间段（rangeStartingTime, rangeEndingTime)，格式是HH:MM\[:SS\[:mmm\]\]。也就是最大精度可以到毫秒。
 *  WeeklyCalendar。指定每星期的星期几，可选值比如为java.util.Calendar.SUNDAY。精度是天。
 *  MonthlyCalendar。指定每月的几号。可选值为1-31。精度是天
 *  AnnualCalendar。 指定每年的哪一天。使用方式如上例。精度是天。
 *  CronCalendar。指定Cron表达式。精度取决于Cron表达式，也就是最大精度可以到秒。

## 7.具体对象和方法 ##

### 7.1.ScheduleBuilder的具体对象和常用方法： ###

#### 7.1.1.CronScheduleBuilder(常用) ####

**为触发器设置`基于 cron表达式`的调度规则。`该对象 使用Cron表达式 来进行实例，底层代码基本都是将对应参数转换为 Cron表达式 后进行创建。`**

*  **cronSchedule(String cronExpression)**：通过指定 Cron表达式 创建对象

详见

#### 7.1.2.SimpleScheduleBuilder(常用) ####

**为触发器设置`从某一个时间开始，以一定的时间间隔（单位是毫秒）执行的任务`的调度规则，它适合的任务类似于：9:00 开始，每隔1小时，执行一次。**

*  **build()**：构建实际的触发器
 *  **simpleSchedule()**：static 方法，获取一个 SimpleScheduleBuilder 对象
 *  **repeatForever()**：指定触发器将`无限重复`。
 *  **withRepeatCount(int triggerRepeatCount)**：设置`重复执行次数`
 *  **repeat\_\_\_lyForever()**：设置`对应时间单位执行一次`，`无限重复`
 *  **repeat\_\_\_lyForever(int)**：设置`当前 对应时间单位 * int 执行一次`，`无限重复`
 *  **withIntervalIn\_\_\_\_s(int/long)**：根据`对应时间单位设置执行间隔`

详见

#### 7.1.3.CalendarIntervalScheduleBuilder ####

**为触发器设置类似于SimpleTrigger，它为触发器定义基于间隔的日历时间(天、周、月、年)任务调度规则。**

但是不同的是`SimpleTrigger指定的时间间隔单位为毫秒`，没办法指定每隔一个月执行一次（每月的时间间隔不是固定值），而`CalendarIntervalTrigger支持的间隔单位有秒，分钟，小时，天，月，年，星期。`

*  **build()**：构建实际的触发器
 *  **calendarIntervalSchedule()**：创建一个 CalendarIntervalScheduleBuilder。
 *  **preserveHourOfDayAcrossDaylightSavings(boolean preserveHourOfDay)**：如果间隔是一天或更长的时间，这个属性(设置为 true )将导致触发器的触发总是在一天的同一时间发生，( startTime 的时间)，而不考虑夏令时转换。
 *  **withInterval(int timeInterval, DateBuilder.IntervalUnit unit)**：指定要生成的触发器的时间单位和间隔。
 *  **withIntervalIn\_\_\_s(int intervalInDays)**：在 IntervalUnit 中指定一个 interval。所产生的触发器将重复对应时间单位。

详见

#### 7.1.4.DailyTimeIntervalScheduleBuilder ####

**为触发器设置设置`每天的某个时间段内，以一定的时间间隔执行任务。` 并且它可以`支持指定星期`**

*  **build()**：构建实际的触发器
 *  **dailyTimeIntervalSchedule()**：创建一个 DailyTimeIntervalScheduleBuilder。
 *  **endingDailyAfterCount(int count)**：使用 count、interval 和 starTimeOfDay 计算和设置 endTimeOfDay。
 *  **endingDailyAt(TimeOfDay timeOfDay)**：设置此触发器的每日开始时间，以在给定的时间结束每天的触发。
 *  **onDaysOfTheWeek(onDaysOfWeek)**：将触发器设置为在一周中的特定日期触发。
 *  **onEveryDay()**：触发时间为一周中的任何一天。
 *  **onMondayThroughFriday()**：把周一到周五的日子设为触发时间。
 *  **onSaturdayAndSunday()**：触发时间为星期六和星期天。
 *  **startingDailyAt(TimeOfDay timeOfDay)**：设置触发开始每天在给定的时间。
 *  **withInterval(int timeInterval, DateBuilder.IntervalUnit unit)**：指定要生成的触发器的时间单位和间隔。
 *  **withIntervalIn\_\_\_\_s(int)**：在 IntervalUnit 中指定一个 interval。所产生的触发器将重复的时间。
 *  **withRepeatCount(int repeatCount)**：设置间隔重复的次数。

详见

### 7.2.TriggerBuilder ###

**触发器生成器，用于实例化触发器。**

*  **newTrigger()**：创建一个新的 TriggerBuilder，用于定义触发器的规范。
 *  **build()**：构建触发器
 *  **endAt(Date triggerEndTime)**：设置触发器不再触发的时间——即使它的时间表还有剩余的重复。
 *  **startAt(Date triggerStartTime)**：根据为触发器配置的计划，设置触发器应该启动的时间——触发器可能启动，也可能不启动。
 *  **startNow()**：将触发器应该启动的时间设置为当前时刻—触发器可能启动，也可能不启动—这取决于为触发器配置的调度。
 *  **forJob(String jobName, String jobGroup)**：设置生成的触发器触发的任务的标识，有多个forJob方法供不同场景使用。
 *  **modifiedByCalendar(String calName)**：设置应该应用于此触发器的日程安排的日历的名称。
 *  **`usingJobData(String dataKey, String value)`**：设置触发器的 JobDataMap。
 *  **withDescription(String triggerDescription)**：设置给定的(有意义的)触发器描述。
 *  **`withIdentity(String name, String group)`**：使用具有给定名称和组的 TriggerKey 来标识触发器。
 *  **withPriority(int triggerPriority)**：设置触发器的优先级。
 *  **`withSchedule(ScheduleBuilder<SBT> schedBuilder)`**：设置 ScheduleBuilder，它将用于定义触发器的调度。

### 7.3.Scheduler ###

这是Quartz调度器的主接口。

*  调度器维护 JobDetails 和触发器的注册表。一旦注册，调度器就负责在相关的触发器触发时执行任务。
 *  Scheduler 实例由 SchedulerFactory 生成。已经创建/初始化的调度器可以通过生成它的工厂找到并使用。创建调度器之后，它处于“备用”模式，必须先调用其 start() 方法，然后才会触发任何任务。
 *  任务将由“客户端程序”创建，方法是定义一个实现任务接口的类。然后创建 JobDetail 对象(也由客户机创建)来定义任务的单个实例。然后，可以通过`scheduleJob(JobDetail，Trigger)`或`addJob(JobDetail, boolean)`方法向调度器注册JobDetail实例。
 *  任务和触发器具d的名称和组在单个调度器中应该具有唯一性的。“组”功能对于创建任务和 Triggerss 的逻辑分组或分类可能很有用。如果您不需要为给定的触发器任务分配组，那么您可以使用这个接口上定义的 DEFAULT\_GROUP 常量。
 *  存储的任务也可以通过`triggerJob(String jobName, String jobGroup)` 函数“手动”触发。

--------------------

*  **addCalendar(String calName, Calendar calendar, boolean replace, boolean updateTriggers)**：将给定的日历添加(注册)到调度程序。
 *  **`addJob(JobDetail jobDetail, boolean replace)`**：将给定的任务添加到调度器—没有关联的触发器。
 *  **checkExists(JobKey jobKey)**：确定调度程序中是否已经存在具有给定标识符的任务。
 *  **checkExists(TriggerKey triggerKey)**：确定调度程序中是否已经存在具有给定标识符的触发器。
 *  **clear()**：清除(删除!)所有调度数据-所有任务，触发日历。
 *  **`deleteCalendar(String calName)`**：从调度程序中删除已标识的日历
 *  **`deleteJob(JobKey jobKey)`**：从调度程序中删除已标识的任务—以及任何关联的触发器。
 *  **`deleteJobs(List<JobKey> jobKeys)`**：从调度程序中删除已标识的任务—以及任何关联的触发器。
 *  **getCalendar(String calName)**：获取具有给定名称的日历实例。
 *  **getCalendarNames()**：获取所有已注册日历的名称。
 *  **getContext()**：返回调度器的调度器上下文。
 *  **getCurrentlyExecutingJobs()**：返回 JobExecutionContext 对象的列表，这些对象表示当前在此调度器实例中执行的所有任务。
 *  **getJobDetail(JobKey jobKey)**：使用给定的键获取任务实例的 JobDetail。
 *  **getJobGroupNames()**：获取所有已知 JobDetail 组的名称。
 *  **getJobKeys(GroupMatcher matcher)**：获取匹配组中所有 JobDetails 的键。
 *  **getListenerManager()**：获取调度程序的 ListenerManager 的引用，可以通过该引用注册侦听器。
 *  **getMetaData()**：获取描述调度器实例的设置和功能的 SchedulerMetaData 对象。
 *  **getPausedTriggerGroups()**：获取所有暂停的触发组的名称。
 *  **getSchedulerInstanceId()**：返回调度程序的实例Id。
 *  **getSchedulerName()**：返回调度程序的名称。
 *  **getTrigger(TriggerKey triggerKey)**：使用给定的键获取触发器实例。
 *  **getTriggerGroupNames()**：获取所有已知触发器组的名称。
 *  **getTriggerKeys(GroupMatcher matcher)**：获取给定组中所有触发器的名称。
 *  **getTriggerKeys(GroupMatcher matcher)**：获取给定组中所有触发器的名称。
 *  **getTriggersOfJob(JobKey jobKey)**：获取与标识的 JobDetail 关联的所有触发器。
 *  **getTriggerState(TriggerKey triggerKey)**：获取标识的触发器的当前状态。
 *  **interrupt(JobKey jobKey)**：在这个调度器实例中，请求中断标识的任务的所有当前正在执行的实例，这些实例必须是 InterruptableJob 接口的实现者。
 *  **interrupt(String fireInstanceId)**：在这个调度器实例中请求标识的正在执行的任务实例的中断，该实例必须是 InterruptableJob 接口的实现者。
 *  **isInStandbyMode()**：报告调度程序是否处于备用模式。
 *  **isShutdown()**：报告调度程序是否已关闭。
 *  **isStarted()**：调度程序是否已启动。
 *  **`pauseAll()`**：暂停所有触发器——类似于在每个组上调用 pauseTriggerGroup(group)，但是，在使用此方法之后，必须调用 resumeAll() 来清除调度器的“记住”状态，即所有新触发器将在添加时暂停。
 *  **`pauseJob(JobKey jobKey)`**：使用给定的键暂停 JobDetail ——通过暂停它的所有当前触发器。
 *  **`pauseJobs(GroupMatcher<JobKey> matcher)`**：暂停匹配组中的所有 JobDetails—通过暂停它们的所有触发器。
 *  **`pauseTrigger(TriggerKey triggerKey)`**：使用给定的键暂停触发器。
 *  **`pauseTriggers(GroupMatcher<TriggerKey> matcher)`**：暂停匹配组中的所有触发器。
 *  **`rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)`**：使用给定的键删除触发器，并存储新的给定的触发器——它必须与相同的任务相关联(新的触发器必须指定任务名称和组)——但是，新的触发器不需要与旧的触发器具有相同的名称。
 *  **`resumeAll()`**：恢复(非暂停)所有触发器-类似于调用 resumeTriggerGroup(组) 对每个组。
 *  **`resumeJob(JobKey jobKey)`**：使用给定的键恢复(取消暂停) JobDetail。
 *  **`resumeJobs(GroupMatcher<JobKey> matcher)`**：恢复(非暂停)匹配组中的所有 JobDetails。
 *  **`resumeTrigger(TriggerKey triggerKey)`**：使用给定的键恢复(取消暂停)触发器。
 *  **`resumeTriggers(GroupMatcher<TriggerKey> matcher)`**：恢复(取消暂停)匹配组中的所有触发器。
 *  **`scheduleJob(JobDetail jobDetail, Trigger trigger)`**：将给定的 JobDetail 添加到调度器中，并将给定的触发器与之关联。
 *  **`scheduleJob(Trigger trigger)`**：使用由触发器的设置标识的任务调度给定的触发器。
 *  **`scheduleJobs(Map<JobDetail,List<Trigger>> triggersAndJobs, boolean replace)`**：使用相关的一组触发器调度所有给定的任务。
 *  **setJobFactory(JobFactory factory)**：设置负责生成任务类实例的 JobFactory。
 *  **`shutdown()`**：停止调度器的触发器触发，并清理与调度器关联的所有资源。
 *  **`shutdown(boolean waitForJobsToComplete)`**：停止调度器的触发器触发，并清理与调度器关联的所有资源。根据 waitForJobsToComplete 判断是否等全部任务执行完后再停止、清理
 *  **standby()**：暂时停止调度程序的触发器触发。
 *  **`start()`**：启动引发触发器的调度器线程。
 *  **startDelayed(int seconds)**：在指定的秒数之后调用 \{\#start()\}。
 *  **triggerJob(JobKey jobKey)**：触发标识的 JobDetail (现在执行它)。
 *  **triggerJob(JobKey jobKey, JobDataMap data)**：触发标识的 JobDetail (现在执行它)。并传递需要的 JobDataMap。
 *  **unscheduleJob(TriggerKey triggerKey)**：从调度程序中删除指定的触发器。
 *  **unscheduleJobs(List triggerKeys)**：从调度程序中删除所有指示的触发器。

### 7.4.StdSchedulerFactory ###

StdSchedulerFactory 用于读取`classpath`下的`quartz.properties`（不存在就都使用默认值）配置来实例化Schduler。

完整的配置文档可以在 [http://www.quartz-scheduler.org/docs/configuration/index.html][http_www.quartz-scheduler.org_docs_configuration_index.html]找到。

--------------------

*  **StdSchedulerFactory()**：创建一个未初始化的 StdSchedulerFactory。
 *  **StdSchedulerFactory(Properties props)**：创建通过 initialize(Properties) 初始化的 StdSchedulerFactory。
 *  **StdSchedulerFactory(String fileName)**：创建通过 initialize(fileName) 初始化的 StdSchedulerFactory。
 *  **getAllSchedulers()**：返回所有已知调度器(由任何 StdSchedulerFactory 实例生成)。
 *  **getDefaultScheduler()**：返回默认调度器，如果它还不存在，则创建它。
 *  **getScheduler()**：返回此工厂生成的调度器。
 *  **getScheduler(String schedName)**：返回具有给定名称的调度器(如果它存在(如果它已经被实例化))。
 *  **initialize()**：使用 Properties 文件的内容和覆盖系统属性初始化ScheduerFactory。
 *  **initialize(InputStream propertiesStream)**:使用用给定属性文件的 InputStream 初始化SchedulerFactory。
 *  **initialize(Properties props)**:使用给定 Properties 对象的内容初始化ScheduerFactory。
 *  **initialize(String filename)**:使用给定名称的 Properties 文件的内容初始化 SchedulerFactory。

### 7.5.JobDetail ###

**传递给定 Job 实例的详细属性。JobDetails使用`JobBuilder创建`**

*  Quartz 并不存储 Job 类的实际实例，而是通过 JobDetail 来创建 Job 类的实例。每个Job的名称和分组名在它所属的调度器中都应该是唯一的。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 16]

--------------------

*  **getDescription()**:返回由其创建者(如果有的话)提供给 Job 实例的描述。
 *  **getJobBuilder()**:获得一个配置为生成与此 JobDetail 相同的 JobBuilder。
 *  **`getJobClass()`**:获取将要执行的任务的实例。
 *  **`getJobDataMap()`**:获取与任务关联的 JobDataMap。
 *  **`getKey()`**:返回 JobKey。
 *  **isConcurrentExectionDisallowed()**：是否禁止同时执行。
 *  **isDurable()**：Job 孤立后是否应该继续存储(没有 Trigger 指向它)。
 *  **isPersistJobDataAfterExecution()**：执行后是否保存 Job 数据。
 *  **requestsRecovery()**：指示调度器(Scheduler)，如果遇到“recovery恢复”或“fail-over故障转移”情况，是否应重新执行 Job。

上面的方法，`JobDetail 接口实现类 JobDetailImpl 都有之对应的 setter 方法。`

### 7.6.JobBuilder ###

**JobBuilder 用于实例化 JobDetails。会设置默认值**

*  **newJob()**：创建用于定义 JobDetail 的 JobBuilder。
 *  **ofType(Class<? extends Job> jobClazz)**：设置将在触发器触发与此 JobDetail 关联时实例化并执行的类。
 *  **newJob(Class<? extends Job> jobClass)**：创建用于定义 JobDetail 的 JobBuilder，并设置要执行的任务的类名。是 newJob() 和 ofType() 方法的合成。
 *  **build()**：生成此 JobBuilder 定义的 JobDetail 实例。
 *  **requestRecovery()**：指示调度器，如果遇到“恢复”或“故障转移”情况，应重新执行 Job。
 *  **requestRecovery(boolean jobShouldRecover)**：指示调度器，如果遇到“恢复”或“故障转移”情况，是否应重新执行 Job。true -> 重新执行，false -> 不重新执行。
 *  **storeDurably()**：任务孤立后应该继续存储(没有触发器指向它)。
 *  **storeDurably(boolean jobDurability)**：任务孤立后应该继续存储(没有触发器指向它)。true -> 继续存储，false -> 不继续存储。
 *  **`usingJobData(String dataKey, String value)`**：设置JobDetails的 JobDataMap。
 *  **withDescription(String jobDescription)**：设置任务的给定(有意义的)描述。
 *  **`withIdentity(JobKey jobKey)`**：使用 JobKey 来标识 JobDetail。

## 8.配置文件-quartz.properties ##

**默认情况下，Quartz会`优先加载classpath目录下的 ”quartz.properties” 作为配置属性`，`如果找不到就会去加载quartz.jar的org.quartz包下的”quartz.properties”文件。`**

*  【配置文件】默认：\`优先顺序Classpath:quartz.properties–>org/quartz/quartz.properties
 *  【程序内指定】在StdSchedulerFactory.getScheduler()之前使用StdSchedulerFactory.initialize(Propertes)

**常用配置**

# 设置调度器的实例名，可以设置为任何字符串。默认名字一般都采用QuartzScheduler，如果需要自动生成，则设置为AUTO
    # 用在 JDBCJobStore 中来唯一标识实例，但是所有集群节点中必须相同。
    org.quartz.scheduler.instanceName = DefaultQuartzScheduler
    
    # 设置调度器的实例 ID，设置要求如上 设置为AUTO基于主机名和时间戳来产生实例 ID
    org.quartz.scheduler.instanceid = AUTO
    
    # 当通过RMI使用Quartz时，您需要启动Quartz实例，并将其配置为通过RMI“导出”其服务
    # 将“rmi.export”标志设置为true，则Quartz Scheduler可以通过RMI作为服务器导出本身，(非必填，默认值为false)。
    org.quartz.scheduler.rmi.export = false
    
    # 可以找到RMI注册表的主机（非必填，默认值为localhost）。
    org.quartz.scheduler.rmi.registryHost = localhost
    
    # 配置RMI注册表正在侦听的端口（非必填，默认值为1099）。
    org.quartz.scheduler.rmi.registryPort = 2666
    
    # 设置让Quartz如何创建RMI注册表（非必填，默认never）
    # 如果不希望Quartz创建注册表，则设置为“false”或“never”
    # 如果希望Quartz首先尝试使用现有的注册表，然后回到创建一个注册表，则设置为true”或“as_needed”
    # 如果希望Quartz尝试创建一个注册表，然后回到使用现有的注册表，则设置为“always”
    org.quartz.scheduler.rmi.createRegistry = never
    
    # 将“org.quartz.scheduler.rmi.proxy”标志设置为true,则可以使用远程服务的调度程序(非必填，默认值为false)。
    org.quartz.scheduler.rmi.proxy = false
    # 默认false，若是在执行Job之前Quartz开启UserTransaction，此属性应该为true。
    #Job执行完毕，JobDataMap更新完（如果是StatefulJob）事务就会提交。默认值是false，可以在job类上使用@ExecuteInJTATransaction 注解，以便在各自的job上决定是否开启JTA事务。
    org.quartz.scheduler.wrapJobExecutionInUserTransaction = false
    
    # =========================================================================== 
    # Configure ThreadPool 线程池属性 ,在 Quartz 中是运行在后台肩负重任的.
    # ===========================================================================
    
    # 线程池的实现类（一般使用SimpleThreadPool即可满足几乎所有用户的需求）
    org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
    
    #指定线程数，指定了多少个工作线程被创建用来处理 Job，至少为1（无默认值）(一般设置为1-100直接的整数合适)
    org.quartz.threadPool.threadCount = 50
    
    #设置线程的优先级（最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1，默认为5）
    org.quartz.threadPool.threadPriority = 6
    
    #设置SimpleThreadPool的一些属性
    # 可以设置为“true”，使池中的线程创建为守护进程线程。默认为“false”。
    #org.quartz.threadpool.makethreadsdaemons = false
    
    #加载任务代码的ClassLoader是否从外部继承 可以是“true”或“false”，默认为true。
    #org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
    
    #org.quartz.threadpool.threadsinheritgroupofinitializingthread = false
    
    # 设置线程前缀，默认值是：[Scheduler Name]_Worker
    #org.quartz.threadpool.threadnameprefix = swhJobThead;
    
    # 配置全局监听(TriggerListener,JobListener) 则应用程序可以接收和执行 预定的事件通知
    # ===========================================================================
    # Configuring a Global TriggerListener 配置全局的Trigger监听器
    # MyTriggerListenerClass 类必须有一个无参数的构造函数，和 属性的set方法，目前2.2.x只支持原始数据类型的值（包括字符串）
    # ===========================================================================
    #org.quartz.triggerListener.NAME.class = com.swh.MyTriggerListenerClass
    #org.quartz.triggerListener.NAME.propName = propValue
    #org.quartz.triggerListener.NAME.prop2Name = prop2Value
    
    # ===========================================================================
    # Configuring a Global JobListener 配置全局的Job监听器
    # MyJobListenerClass 类必须有一个无参数的构造函数，和 属性的set方法，目前2.2.x只支持原始数据类型的值（包括字符串）
    # ===========================================================================
    #org.quartz.jobListener.NAME.class = com.swh.MyJobListenerClass
    #org.quartz.jobListener.NAME.propName = propValue
    #org.quartz.jobListener.NAME.prop2Name = prop2Value
    
    # =========================================================================== 
    # Configure JobStore 存储调度信息（工作，触发器和日历等）
    # ===========================================================================
    # 选择JDBC的存储方式，RAMJobStore内存保存
    org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
    # 信息保存时间 默认值60秒(最大能忍受的触发超时时间，如果超时则认为“失误”)
    org.quartz.jobStore.misfireThreshold = 60000
    # 任务存储方法：设置job和Trigger的状态信息是保存到内存中去还是数据库
    org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
    ##类似于Hibernate的dialect，用于处理DB之间的差异，StdJDBCDelegate能满足大部分的DB（授权）
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #存储Job相关信息表的前缀
    org.quartz.jobStore.tablePrefix = QRTZ_
    #使用JNDI数据源的时候，数据源的名字 
    org.quartz.jobStore.dataSource = myDS
    #这是JobStore能处理的错过触发的Trigger的最大数量。处理太多（2打）很快就会导致数据库表被锁定够长的时间，
    #这样会妨碍别的（还未错过触发）trigger执行的性能。
    #即时的最大容灾数
    org.quartz.jobStore.maxMisfiresToHandleAtATime=10
    #是否是应用在集群中，当应用在集群中时必须设置为TRUE，否则会出错。
    #如果有多个Quartz实例在用同一套数据库时，必须设置为true。
    org.quartz.jobStore.isClustered = true 
    #只用于设置了isClustered为true的时候，设置一个频度（毫秒），用于实例报告给集群中的其他实例。
    #这会影响到侦测失败实例的敏捷度。
    #clusterChedkinInterval 越小，Scheduler 节点检查失败的 Scheduler 实例就越频繁。默认值是 15000 (即15 秒)。
    org.quartz.jobStore.clusterCheckinInterval = 20000
    
    # =========================================================================== 
    # Configure SchedulerPlugins 插件属性 配置
    # ===========================================================================
    # 自定义插件 
    #org.quartz.plugin.NAME.class = com.swh.MyPluginClass
    #org.quartz.plugin.NAME.propName = propValue
    #org.quartz.plugin.NAME.prop2Name = prop2Value
    
    #配置trigger执行历史日志（可以看到类的文档和参数列表）
    org.quartz.plugin.triggHistory.class = org.quartz.plugins.history.LoggingTriggerHistoryPlugin  
    org.quartz.plugin.triggHistory.triggerFiredMessage = Trigger { 1}.{ 0} fired job { 6}.{ 5} at\: { 4, date, HH\:mm\:ss MM/dd/yyyy}  
    org.quartz.plugin.triggHistory.triggerCompleteMessage = Trigger { 1}.{ 0} completed firing job { 6}.{ 5} at { 4, date, HH\:mm\:ss MM/dd/yyyy} with resulting trigger instruction code\: { 9}  
    
    #配置job调度插件 quartz_jobs(jobs and triggers内容)的XML文档 
    #加载 Job 和 Trigger 信息的类 （1.8之前用：org.quartz.plugins.xml.JobInitializationPlugin）
    org.quartz.plugin.jobInitializer.class = org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin
    
    #指定存放调度器(Job 和 Trigger)信息的xml文件，默认是classpath下quartz_jobs.xml
    org.quartz.plugin.jobInitializer.fileNames = my_quartz_job2.xml  
    #org.quartz.plugin.jobInitializer.overWriteExistingJobs = false 
    org.quartz.plugin.jobInitializer.failOnFileNotFound = true  
    
    #自动扫描任务单并发现改动的时间间隔,单位为秒
    org.quartz.plugin.jobInitializer.scanInterval = 10
    
    #覆盖任务调度器中同名的jobDetail,避免只修改了CronExpression所造成的不能重新生效情况
    org.quartz.plugin.jobInitializer.wrapInUserTransaction = false
    
    # =========================================================================== 
    # Sample configuration of ShutdownHookPlugin ShutdownHookPlugin插件的配置样例‹
    # ===========================================================================
    #org.quartz.plugin.shutdownhook.class = \org.quartz.plugins.management.ShutdownHookPlugin
    #org.quartz.plugin.shutdownhook.cleanShutdown = true
    
    #
    # Configure RMI Settings 远程服务调用配置
    #
    #如果你想quartz-scheduler出口本身通过RMI作为服务器，然后设置“出口”标志true(默认值为false)。
    #org.quartz.scheduler.rmi.export = false
    
    #主机上rmi注册表(默认值localhost)
    #org.quartz.scheduler.rmi.registryhost = localhost
    
    #注册监听端口号（默认值1099）
    #org.quartz.scheduler.rmi.registryport = 1099
    
    #创建rmi注册，false/never：如果你已经有一个在运行或不想进行创建注册
    # true/as_needed:第一次尝试使用现有的注册，然后再回来进行创建
    # always:先进行创建一个注册，然后再使用回来使用注册
    #org.quartz.scheduler.rmi.createregistry = never
    
    #Quartz Scheduler服务端端口，默认是随机分配RMI注册表
    #org.quartz.scheduler.rmi.serverport = 1098
    
    #true:链接远程服务调度(客户端),这个也要指定registryhost和registryport，默认为false
    # 如果export和proxy同时指定为true，则export的设置将被忽略
    #org.quartz.scheduler.rmi.proxy = false

## 9.总结 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 17]

说明：

1.  从代码上来看，有`XxxBuilder、XxxFactory`等类名，说明Quartz用到了`建造者、工厂模式`，还有非常易懂的`链式编程风格`。
2.  Quartz有3个核心概念：`调度器（Scheduler）、任务（Job&JobDetail）、触发器（Trigger）`。`（一个任务可以被多个触发器触发，一个触发器只能触发一个任务）`
3.  注意当Scheduler调度Job时，实际上会通过`反射newInstance一个新的Job实例（待调度完毕后销毁掉）`，同时会`把JobExecutionContext传递给Job的execute方法`，Job实例可以`通过JobExecutionContext`访问到**Quartz运行时的环境以及Job本身的明细数据**。
4.  JobDataMap设值取值方式
5.  Trigger用来告诉Quartz调度程序什么时候执行，常用的触发器有2种：`SimpleTrigger（类似于Timer）、CronTrigger（类似于Linux的Crontab）`。
6.  实际上，Quartz在进行调度器初始化的时候，会读取`quartz.properties`文件进行一些属性的设置，比如`Quartz后台线程池的属性（threadCount）`、`任务存储设置等`。它会先从`classpath:quartz.properties`中找，如果找不到默认使用依赖包`quartz.jar中的默认的quartz.properties文件。`
7.  **Quartz存在监听器的概念，比如任务执行前后、任务的添加等，可以方便实现任务的监控。**

## 10.Job工具类 ##

这里给大家分享一个工具类

import org.quartz.*;
    import java.util.Calendar;
    import java.util.Date;
    public class JobUtil { 
    
        /** * 添加一个定时任务 * * @param scheduler * @param triggerName * @param triggerGroupName * @param jobName * @param jobGroupName * @param jobClass * @param triggerStartTime * @param cronTime * @throws SchedulerException */
        public static void addSchedulerJob(Scheduler scheduler,
                                           String triggerName, String triggerGroupName,
                                           String jobName, String jobGroupName, Class<? extends Job> jobClass,
                                           Date triggerStartTime, String cronTime) throws SchedulerException { 
            // 获取配置好的触发器Trigger
            Trigger trigger = scheduler.getTrigger(TriggerKey.triggerKey(triggerName, triggerGroupName));
            // 创建任务
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
    
            // 如果trigger还没有配置
            if (null == trigger) { 
                // corn表达式绑定
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronTime)
                        .withMisfireHandlingInstructionDoNothing();
                /* * 创建触发器 * withIdentity： 以name和group定义触发器 * startNow() 立即生效 * startAt： 开始时间 * withIntervalInSeconds(1) 每隔1s执行一次 * repeatForever() 一直执行 * withSchedule： 设置corn表达式 * build： 新建一个触发器 */
    // trigger = TriggerBuilder.newTrigger()
    // .withIdentity(triggerName, triggerGroupName)
    // .startAt(triggerStartTime)
    // .withSchedule(scheduleBuilder)
    // .build();
    // 方式2
                trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
                        .startNow()//立即生效
                        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                .withIntervalInSeconds(1)//每隔1s执行一次
                                .repeatForever()).build();//一直执行
    
    // 方式3
    // SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.repeatHourlyForever(3)
    // .withMisfireHandlingInstructionNextWithExistingCount();
    // 创建触发器
    // trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
    // .startAt(triggerStartTime).withSchedule(scheduleBuilder).build();
    
                // 将触发器和任务绑定到调度器内
                scheduler.scheduleJob(jobDetail, trigger);
                System.out.println(jobDetail + "任务绑定成功");
            } else { 
                System.out.println(trigger.getKey() + "触发器已存在。");
            }
        }
    
        /** * 删除一个定时任务 * * @param scheduler * @param triggerGroupName * @param triggerName * @param jobGroupName * @param jobName * @throws SchedulerException */
        public static void deleteSchedulerJob(Scheduler scheduler, String triggerGroupName, String triggerName,
                                              String jobGroupName, String jobName) throws SchedulerException { 
            // 获取任务的key
            JobKey jobKey = new JobKey(jobName, jobGroupName);
            // 判断对应的job是否存在
            if (scheduler.checkExists(jobKey)) { 
                // 存在，删除
                if (scheduler.deleteJob(jobKey)) { 
                    System.out.println("定时任务删除成功");
                } else { 
                    System.out.println("指定的定时任务不存在");
                }
            }
        }
    
        /** * 根据执行时间和类型生成Cron * * @param startTime * @param type * @return */
        public static String getCronExpression(Date startTime, String type) { 
            String cronExpression = "";
            if (null != startTime) { 
                // 当前时间所属周几
                Calendar c = Calendar.getInstance();
                c.setTime(startTime);
                int day = c.get(Calendar.DAY_OF_MONTH);
                int week = c.get(Calendar.DAY_OF_WEEK);
                int hour = c.get(Calendar.HOUR_OF_DAY);
                int minute = c.get(Calendar.MINUTE);
                int second = c.get(Calendar.SECOND);
    
                if ("day".equals(type)) { 
                    cronExpression = second + " " + minute + " " + hour + " ? * *";
                }
                if ("week".equals(type)) { 
                    cronExpression = second + " " + minute + " " + hour + " ? * " + week;
                }
                if ("month".equals(type)) { 
                    cronExpression = second + " " + minute + " " + hour + " " + day + " * ?";
                }
                if (!CronExpression.isValidExpression(cronExpression)) { 
                    cronExpression = "";
                }
            }
            return cronExpression;
        }
    }

**Job任务实现类**

import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;
    public class BackupHistoryJob implements Job { 
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException { 
            // 集成Job后需要实现execute，业务代码就写在这里面
            System.out.println("执行一系列历史数据备份操作.......");
        }
    }

**测试类**

import org.quartz.Scheduler;
    import org.quartz.SchedulerException;
    import org.quartz.SchedulerFactory;
    import org.quartz.impl.StdSchedulerFactory;
    import java.util.Date;
    
    // 测试类
    public class SchedulerTest { 
        public static void main(String[] args) throws SchedulerException, InterruptedException { 
            // 1、创建调度器Scheduler
            //直接读取classpath下的quartz.properties（不存在就都使用默认值）配置来实例化Schduler
            SchedulerFactory schedulerFactory = new StdSchedulerFactory();
            Scheduler scheduler = schedulerFactory.getScheduler();
            String cronExpression = JobUtil.getCronExpression(new Date(), "month");
            String triggerName = "historyTrigger";
            String triggerGroupName = "backopTrigger";
            String jobName = "historyJob";
            String jobGroupName = "backopJob";
            if (cronExpression == null || cronExpression.trim() == "") { 
                throw new RuntimeException("定时任务Corn表达式出错！");
            }
    
            JobUtil.deleteSchedulerJob(scheduler, triggerGroupName, triggerName, jobGroupName, jobName);
            JobUtil.addSchedulerJob(scheduler, triggerName, triggerGroupName, jobName, jobGroupName, BackupHistoryJob.class, new Date(), cronExpression);
        }
    }

# 五.Cron学习 #

## 1.表达式 ##

Cron有如下两种语法格式：

*  一个cron表达式有`至少6个（也可能7个）`有空格分隔的时间元素。按顺序依次为：

//秒（0~59）
    //分钟（0~59）
    //小时（0~23）
    //天（0~31）
    //月（0~11）
    //星期（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）
    //年份（1970－2099）
    
    Seconds Minutes Hours Day-of-Month Month Day-of-Week Year
    Seconds Minutes Hours Day-of-Month Month Day-of-Week

<table> 
 <thead> 
  <tr> 
   <th>域</th> 
   <th>是否必需</th> 
   <th>取值范围</th> 
   <th>特殊字符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>秒</td> 
   <td>是</td> 
   <td>[0, 59]</td> 
   <td>, - * /</td> 
  </tr> 
  <tr> 
   <td>分钟</td> 
   <td>是</td> 
   <td>[0, 59]</td> 
   <td>, - * /</td> 
  </tr> 
  <tr> 
   <td>小时</td> 
   <td>是</td> 
   <td>[0, 23]</td> 
   <td>, - * /</td> 
  </tr> 
  <tr> 
   <td>日期</td> 
   <td>是</td> 
   <td>[1, 31] (个别是30，或者28,29)</td> 
   <td>* , - / ? L W</td> 
  </tr> 
  <tr> 
   <td>月份</td> 
   <td>是</td> 
   <td>[1, 12]或[JAN, DEC]</td> 
   <td>, - * /</td> 
  </tr> 
  <tr> 
   <td>星期</td> 
   <td>是</td> 
   <td>[1, 7]或[MON, SUN]。若您使用[1, 7]表达方式，1代表星期一，7代表星期日。</td> 
   <td>* , - / ? L #</td> 
  </tr> 
  <tr> 
   <td>年</td> 
   <td>否</td> 
   <td>1970~2099</td> 
   <td>, - * /</td> 
  </tr> 
 </tbody> 
</table>

## 2.特殊字符含义 ##

**Cron表达式中的每个域支持的特殊字符以及其特殊含义。**

<table> 
 <thead> 
  <tr> 
   <th>特殊字符</th> 
   <th>含义</th> 
   <th>示例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>星号(*)</strong></td> 
   <td>表示任意。</td> 
   <td>在分钟域中，*表示每一分钟；在小时域中，*表示每一个小时。</td> 
  </tr> 
  <tr> 
   <td><strong>逗号(,)</strong></td> 
   <td>表示一个列表</td> 
   <td>比如1,2,3。在小时域中代表1点和2点和3点</td> 
  </tr> 
  <tr> 
   <td><strong>减号(-)</strong></td> 
   <td>表示一个范围。</td> 
   <td>在分钟域中，5-10表示从5分钟到10分钟之间每隔一分钟触发一次。</td> 
  </tr> 
  <tr> 
   <td><strong>斜杠(/)</strong></td> 
   <td>指定数值的增量（后者为增量）。</td> 
   <td>语法: <code>x/y</code>，<code>x为起始值</code>，<code>y为增量</code>。如在分钟域中使用0/15，则表示从第3分钟开始，每5分钟执行一次，而5/15在分钟域中表示从第3分钟开始，每15分钟执行一次。也可以使用<code>*/y</code>，它等同于<code>0/y</code></td> 
  </tr> 
  <tr> 
   <td><strong>问号(?)</strong></td> 
   <td><code>不指定值</code>，<code>仅日期和星期域支持该字符</code>。</td> 
   <td>当日期或星期域其中之一被指定了值以后，需要将另一个域的值设为?，以避免冲突，</td> 
  </tr> 
  <tr> 
   <td><strong>L</strong></td> 
   <td>L是Last的意思，表示最后一天，<code>仅日期和星期域支持该字符</code>。<strong>注意：指定L字符时，避免指定列表或者范围，否则，可能会会导致逻辑问题</strong>。</td> 
   <td>在日期域中，L表示某个月的最后一天。在星期域中，L表示一个星期的最后一天，也就是星期日（SUN）。如果在L前有具体的内容，例如，在星期域中的6L表示这个月的最后一个星期六。</td> 
  </tr> 
  <tr> 
   <td><strong>W</strong></td> 
   <td>该字符只能出现在<code>日期域</code>里，是对前导日期的修饰，表示离该日期最近的工作日。</td> 
   <td>如: 15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天。W字符串只能指定单一日期，而不能指定日期范围；</td> 
  </tr> 
  <tr> 
   <td><strong>LW组合</strong></td> 
   <td>在日期字段可以组合使用LW，它的意思是当月的最后一个工作日</td> 
   <td>-----</td> 
  </tr> 
  <tr> 
   <td><strong>#</strong></td> 
   <td>该字符只能在<code>星期域</code>中使用，表示当月某个工作日。</td> 
   <td>如6#3表示当月的第三个星期五(6表示星期五，#3表示当前的第三个)，而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发；</td> 
  </tr> 
  <tr> 
   <td><strong>C</strong></td> 
   <td>该字符只在日期和星期字段中使用，代表“Calendar”的意思。</td> 
   <td>它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。</td> 
  </tr> 
 </tbody> 
</table>

## 3.Cron表达式详解 ##

**一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。按顺序依次为：**

*  Cron表达式`对特殊字符的大小写不敏感`，`对代表星期的缩写英文大小写也不敏感`。一些例子：

秒（0~59）
    分钟（0~59）
    3 小时（0~23）
    4 天（0~31）
    5 月（0~11）
    6 星期（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）
    年份（1970－2099）
    
    #其中每个元素可以是
    1. 一个值(如6),
    2. 一个连续区间(9-12),
    3. 一个间隔时间(8-18/4)(/表示每隔4小时),
    4. 一个列表(1,3,5),
    5. 通配符。
    # 注意: 由于”月份中的日期”和”星期中的日期”这两个元素互斥的,必须要对其中一个设置。
    
    # 配置实例：
    每隔5秒执行一次：/5 * * * ?
    每隔1分钟执行一次：0 /1 * * ?
    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分运行。
    0 15 10 15 * ?	每月15日10:15分运行。
    0 15 10 L * ?	每月最后一天10:15分运行。
    0 15 10 ? * 6L	每月最后一个星期五10:15分运行。
    0 15 10 ? * 6L 2007-2009	在2007,2008,2009年每个月的最后一个星期五的10:15分运行。
    0 15 10 ? * 6#3 每月第三个星期五的10:15分运行。
    0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
    0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
    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/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发
    0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
    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触发
    
    # 有些子表达式能包含一些范围或列表
    例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”
    
    #“*”字符代表所有可能的值
    # “/”字符用来指定数值的增量
    例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟
    在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样```
    
    #“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值
    当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”
    
    #“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写
    如果在“L”前有具体的内容，它就具有其他的含义了。

\--------------------------相关好文------------------------------  
[ Quartz官方文档 ][Quartz_]  
[Quartz框架集合-nice][Quartz_-nice]  
[任务调度框架Quartz集合-two-nice][Quartz_-two-nice]  
[项目重启quartz定时任务执行策略-misfire][quartz_-misfire]

[SpringBoot-_SchedulingConfigurer]: https://blog.csdn.net/u013998466/article/details/90373811
[SpringBoot-_SchedulingConfigurer 1]: https://blog.csdn.net/carolcoral/article/details/107180695
[springboot -ThreadPoolTaskScheduler]: https://www.cnblogs.com/toiletgg/p/10647436.html
[Springboot -ThreadPoolTaskScheduler]: https://blog.csdn.net/xcc_2269861428/article/details/100023788
[springboot -ThreadPoolTaskSchedulere]: https://blog.csdn.net/qq_37549757/article/details/93876875?utm_medium=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-BlogCommendFromMachineLearnPai2-1.channel_param
[20210329180136976.png]: /images/20221022/af765e4ea7ba486bbc06f15ad13ccf04.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: /images/20221022/fd237e8aa5bd4a29b6028bb6390fe894.png
[Quartz]: https://blog.csdn.net/weixin_42255281/article/details/112600151
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]: /images/20221022/52ade43b6edd44c7a91e4a06a34e3999.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]: /images/20221022/d78ef975902047349cb8829b09c2b259.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]: /images/20221022/aa574712e8764e81affe88de0bbf2ba0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]: /images/20221022/8c370a0d7aa64efe90ad0c1773b5f221.png
[20210330163731100.png]: /images/20221022/5251f0c9ac714d8da442a70f4e133457.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]: /images/20221022/cd8c1539c6a84ac68422d3a38a3ba678.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]: /images/20221022/c6415cd8c62c4f7c9c585c8fadaa37cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]: /images/20221022/c87558883f0144af9cc9edeb21fe1320.png
[20210504173452417.png]: /images/20221022/0ea6b38a573543c48b6edf115430f425.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]: /images/20221022/485221f5193448459d29ab6f181ebf85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]: /images/20221022/2a9ee38a3eb64e55a96273166185d5c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]: /images/20221022/47cbb89cb99646eaa9fb11eeb2aa094a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 11]: /images/20221022/f059b5334e02462fa019642c424419a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]: /images/20221022/77ab49c152144833ac7a2824767ab545.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 13]: /images/20221022/f29506b6a5b14300b83c52aca5213c17.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 14]: /images/20221022/17deef2d64554b4abc1cfb68ac01c718.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 15]: /images/20221022/a8fa8aa206ed4c4f887a2cc8dc60b554.png
[http_www.quartz-scheduler.org_docs_configuration_index.html]: http://www.quartz-scheduler.org/docs/configuration/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 16]: /images/20221022/9995e1d973f743f9b58639e43e2f8efd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 17]: /images/20221022/0c567201f96b4eae9f8e85e66c7170a7.png
[Quartz_]: https://www.w3cschool.cn/quartz_doc/
[Quartz_-nice]: https://www.jianshu.com/p/2a5d3b6336ba
[Quartz_-two-nice]: https://blog.csdn.net/zixiao217/category_6500906.html
[quartz_-misfire]: https://blog.csdn.net/like_java_/article/details/108128022