Quartz

Quartz

　　Quartz是一个完全由Java编写的开源作业调度框架。不仅可以用来创建简单的定时程序，还可以创建成百上千甚至上万个Job的复杂定时程序。

　　Quartz框架的核心对象：

　　　　1、Job：表示一个工作，要执行的具体内容。此接口中只有一个方法，如下：void execute(JobExecutionContext context) 

　　　　2、JobDetail：表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。 

　　　　3、Trigger触发器： 定义执行给定作业的计划的组件，即执行任务的规则， 代表一个调度参数的配置，什么时候去调。

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

　　　　5、JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。

　　　　6、TriggerBuilder ：用于定义/构建触发器实例。

　　核心对象之间的关系：

　　一句话总结其关系：

　　　　Job表示一种类型的任务（执行逻辑相同，比如HTTP请求的，RPC接口请求的），Job下每个具体的任务详情存在JobDetail中，JobDetail中包含该任务的属性集和JobDataMap。Trigger与JobDetail绑定，是多对一的关系。所有的JobDetail和Trigger实例都会加载到scheduler中。

 　　　　当一个trigger被触发时，与之关联的JobDetail实例会被加载，JobDetail引用的job类通过配置在Scheduler上的JobFactory进行初始化。默认的JobFactory实现，仅仅是调用job类的newInstance()方法，然后尝试调用JobDataMap中的key的setter方法。

 　　主要线程：

　　在Quartz中有两类线程，也即执行线程和调度线程，其中执行任务的线程通常用一个线程池维护。池中的线程越多，并发运行的jobs数越多。但是线程要根据系统和服务器配置适当的数量。一般评估一下在同一时间同时运行的jobs数量，与之相同即可。如果triggers的触发时间到达，并且没有可用的线程，Quartz将暂停直到线程可用，然后执行job，这甚至可能导致线程misfire - 如果在调度程序配置的“misfire阈值（默认60000毫秒，1分钟）”的持续时间内没有可用的线程。

　　调度线程主要有两个：

regular Scheduler Thread（执行常规调度）和Misfire Scheduler Thread（执行错失的任务）。其中Regular Thread轮询Trigger，如果有将要触发的Trigger，则从任务线程池中获取一个

空闲线程，然后执行与该Trigger关联的Job。Misfire Thread则是扫描所有的Trigger，查看是否有错失的，如果有的话，根据一定的策略进行处理。

　　数据存储：

　　Quartz中的trigger和job需要存储下来才能被使用。Quartz中有两种存储方式：RAMJobStore,JobStoreSupport，其中RAMJobStore是将trigger和job存储在内存中，而JobStoreSupport是基于jdbc将trigger和job存储到数据库中。RAMJobStore的存取速度非常快，但是由于其在系统被停止后所有的数据都会丢失，所以在集群应用中，必须使用JobStoreSupport。

　　表结构说明：

表名	用途
BS_JOB_DETAILS	存储Job名称所属组等信息
BS_TRIGGERS	存储Job触发类型（simple，cron），触发器名称（组+任务名），开始、结束时间，上次、下次触发时间；任务组件和任务参数等信息
BS_SIMPLE_TRIGGERS	存储触发器名称，执行频率，重复策略，已触发次数等
BS_CRON_TRIGGERS	存储触发器名称，cron表达式
BS_TASK_HISTORY	存储任务执行历史，包括任务执行时间，执行日志，触发方式，完成时间等

　　

　　Quartz集群：

　　Quartz集群中的每个节点都是一个独立的Quartz应用，并不与其他节点通信，而是通过相同的数据库表来感知其他节点的存在。

 　　

应用：

　　quartz安装包根目录的lib/目录下有很多的jar包。其中，quartz-xxx.jar（其中xxx是版本号）是最主要的。为了使用quartz，必须将该jar包放在应用的classpath下

　　属性文件：quartz使用名为quartz.properties的配置文件。刚开始时该配置文件不是必须的，但是为了使用最基本的配置，该文件必须位于classpath下。

　　主要的配置：

属性名称	说明	是否必填	值类型	默认值
org.quartz.scheduler.instanceName	应用实例名称	否	String	'QuartzScheduler'
org.quartz.scheduler.instanceId	应用实例编号，需唯一	否	String	'NON_CLUSTERED'
org.quartz.scheduler.threadName	调度器线程名称	否	String	instanceName
org.quartz.threadPool.threadCount	线程池数量，决定可以同时运行多少Job	是	int	-1
org.quartz.jobStore.driverDelegateClass	数据库驱动策略（MySQL或其他）	是	String	null
org.quartz.jobStore.dataSource	数据源	是	String	null
org.quartz.jobStore.tablePrefix	数据库表名的前缀	否	String	"QRTZ_"
org.quartz.jobStore.useProperties	JobDataMap中的值以键值对存储还是二进制	否	boolean	false
org.quartz.jobStore.misfireThreshold	被错失执行的Job下一次触发的间隔	否	int	60000
org.quartz.jobStore.isClustered	是否集群	否	boolean	false

 　　API：

　　Scheduler：与调度程序交互的主要API

　　Job：由希望由调度程序执行的组件实现的接口，一个job就是一个实现了Job接口的类

　　JobDetail：用于自定义作业的实例

　　Trigger：触发器，定义执行作业的计划的组件

　　JobBuilder：用于定义/构建JobDetail实例，即用于定义作业的实例

　　TriggerBuilder：用于定义/构建触发器实例

　　

　　 Scheduler的生命期，从SchedulerFactory创建它时开始，到Scheduler调用shutdown()方法时结束；Scheduler被创建后，可以增加、删除和列举Job和Trigger，以及执行其它与调度相关的操作（如暂停Trigger）。但是，Scheduler只有在调用start()方法后，才会真正地触发trigger（即执行job）。

 　　当Job的一个trigger被触发时，execute()方法由调度程度的一个工作线程调用。传递给execute()方法的JobExecutionContext对象中保存着该job运行时的一些信息，执行job的schedule的引用，触发job的trigger引用，JobDetail对象引用，以及一些其他信息。

 　　JobDetail对象是在将job加入scheduler时，由客户端程序（你的程序）创建的。它包含job的各种属性设置，以及用于存储job实例状态信息的JobDataMap

 　　Trigger用于触发Job的执行。当你准备调度一个job时，你创建一个Trigger的实例，然后设置调度相关的属性。Trigger也有一个相关联的JobDataMap，用于给Job传递一些触发相关的参数。Quartz自带了各种不同类型的Trigger，最常用的主要是SimpleTrigger和CronTrigger。SimpleTrigger主要用于一次性执行的Job（只在某个特定的时间点执行一次），或者Job在特定的时间点执行，重复执行N次，每次执行间隔T个时间单位。CronTrigger在基于日历的调度上非常有用，如“每个星期五的正午”，或者“每月的第十天的上午10:15”等。cron（秒分时日月周年）

 　　Job被创建后，可以保存在Scheduler中，与Trigger是独立的，同一个Job可以有多个Trigger；这种松耦合的另一个好处是，当与Scheduler中的Job关联的trigger都过期时，可以配置Job稍后被重新调度，而不用重新定义Job；还有，可以修改或者替换Trigger，而不用重新定义与之关联的Job

　　Scheduler：

　　Scheduler实例化后，可以启动(start)、暂停(stand-by)、停止(shutdown)。注意：scheduler被停止后，除非重新实例化，否则不能重新启动；只有当scheduler启动后，即使处于暂停状态也不行，trigger才会被触发（job才会被执行）

　　Key：
　　将Job和Trigger注册到Scheduler时，可以为它们设置key，配置其身份属性。Job和Trigger的key（JobKey和TriggerKey）可以用于将Job和Trigger放到不同的分组（group）里，然后基于分组进行操作。同一个分组下的Job或Trigger的名称必须唯一，即一个Job或Trigger的key由名称（name）和分组（group）组成。

　　Job：

　　定义了一个实现Job接口的类，仅仅表明了该job需要完成什么类型的任务（如HTTP调用类型的任务），除此之外，Quartz还需要知道该Job实例所包含的属性，这都是JobDetail来完成。我们传给scheduler一个JobDetail实例，因为我们在创建JobDetail时，将要执行的job的类名传给了JobDetail，所以scheduler就知道了要执行何种类型的job；每次当scheduler执行job时，在调用execute()方法之前会创建该类的一个新的实例；执行完毕，对该实例的引用就被丢弃了，实例会被垃圾回收，这种执行策略要求在job类中不应该定义有状态的数据属性，因为在job的多次执行中，这些属性的值不会保留。因此在job的多次执行中，其状态就存放在JobDataMap中，JobDetail对象的一部分。

　　JobDataMap：

　　JobDataMap中可以包含不限量的（序列化的）数据对象，在job实例执行的时候，可以使用其中的数据；JobDataMap是Java Map接口的一个实现，额外增加了一些便于存取基本类型的数据的方法。将job加入到scheduler之前，在构建JobDetail时，可以将数据放入JobDataMap。在job的执行过程中，可以从JobDataMap中取出数据。

在Job执行时，JobExecutionContext是JobDetail中的JobDataMap和Trigger中的JobDataMap的并集，但是如果存在相同的数据，则后者会覆盖前者的值。从JobExecutionContext中获取JobDataMap：JobDataMap dataMap = context.getMergedJobDataMap();  

　　Trigger：

　　其属性有：jobKey，startTime，endTime，优先级，错过触发，日历等。

　　jobKey：当trigger被触发时执行的job的身份，

　　startTime：trigger第一次触发的时间，默认当前时间，endTime：trigger失效的时间，默认为null，表示永不失效。

　　优先级(priority)：当trigger比quartz线程池中的线程多时，通过配置优先级可以控制让优先级高的trigger先被触发，只有同时触发的trigger之间会比较优先级，默认值为5。

　　错过触发(misfire Instructions)：如果scheduler关闭了，或者Quartz线程池中没有可用的线程来执行job，此时持久性的trigger就会错过（miss）其触发时间，即错过触发（misfire）。不同类型的trigger，有不同的misfire机制。它们默认都使用“智能机制(smart policy)”，即根据trigger的类型和配置动态调整行为（SimpleTrigger会根据实例的配置及状态，在所有MISFIRE策略中动态选择一种Misfire策略；CronTrigger 的智能策略为MISFIRE_INSTRUCTION_FIRE_NOW）。当scheduler启动的时候，查询所有错过触发(misfire)的持久性trigger。然后根据它们各自的misfire机制更新trigger的信息。

　　　　cronTrigger misfire策略：

　　　　   SmartPolicy：默认策略。对应的是FireAndProceed策略

   　　　　IgnoreMisfires：以错过的第一个频率时间立刻开始执行，重做错过的所有频率周期后，当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行

   　　　　FireAndProceed：以当前时间为触发频率立刻触发一次执行，然后按照Cron频率依次执行

   　　　　DoNothing：不触发立即执行，等待下次Cron触发频率到达时刻开始按照Cron频率依次执行

　　监听器：

　　Listeners是我们创建的用来根据调度程序中发生的事件执行操作。通过实现TriggerListener接口或者JobListener，然后在运行时向调度程度scheduler注册，并且给出一个名称（重写getName方法）。如：scheduler.getListenerManager().addJobListener

　　TriggerListeners：接收与触发器相关的事件，包括触发器触发，触发失灵，触发完成。

　　JobListeners：接收与job相关的事件，包括job即将执行的通知，以及job完成执行时的通知

　　SchedulerListeners：接收添加job/触发器，删除job/触发器，调度程序中的严重错误，关闭调度程序的通知等。实现SchedulerListener 接口，scheduler.getListenerManager().addSchedulerListener。

SpringBoot Quartz

1、jar包依赖

　　　　 <!--quartz-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
        </dependency>

2、配置 Quartz Scheduler

 　　(1)：spring-boot-autoconfigure 提供了quartz的自动配置类

/**
 * {@link EnableAutoConfiguration Auto-configuration} for Quartz Scheduler.
 *
 * @author Vedran Pavic
 * @author Stephane Nicoll
 * @since 2.0.0
 */
@Configuration
@ConditionalOnClass({ Scheduler.class, SchedulerFactoryBean.class,PlatformTransactionManager.class })
@EnableConfigurationProperties(QuartzProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class,HibernateJpaAutoConfiguration.class })
public class QuartzAutoConfiguration {

    private final QuartzProperties properties;

    private final ObjectProvider<SchedulerFactoryBeanCustomizer> customizers;

    private final JobDetail[] jobDetails;

    private final Map<String, Calendar> calendars;

    private final Trigger[] triggers;

    private final ApplicationContext applicationContext;

    public QuartzAutoConfiguration(QuartzProperties properties,
            ObjectProvider<SchedulerFactoryBeanCustomizer> customizers,
            ObjectProvider<JobDetail[]> jobDetails,
            ObjectProvider<Map<String, Calendar>> calendars,
            ObjectProvider<Trigger[]> triggers, ApplicationContext applicationContext) {
        this.properties = properties;
        this.customizers = customizers;
        this.jobDetails = jobDetails.getIfAvailable();
        this.calendars = calendars.getIfAvailable();
        this.triggers = triggers.getIfAvailable();
        this.applicationContext = applicationContext;
    }

    @Bean
    @ConditionalOnMissingBean
    public SchedulerFactoryBean quartzScheduler() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        SpringBeanJobFactory jobFactory = new SpringBeanJobFactory();
        jobFactory.setApplicationContext(this.applicationContext);
        schedulerFactoryBean.setJobFactory(jobFactory);
        if (this.properties.getSchedulerName() != null) {
            schedulerFactoryBean.setSchedulerName(this.properties.getSchedulerName());
        }
        schedulerFactoryBean.setAutoStartup(this.properties.isAutoStartup());
        schedulerFactoryBean.setStartupDelay((int) this.properties.getStartupDelay().getSeconds());
        schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(
                this.properties.isWaitForJobsToCompleteOnShutdown());
        schedulerFactoryBean.setOverwriteExistingJobs(this.properties.isOverwriteExistingJobs());
        if (!this.properties.getProperties().isEmpty()) {
            schedulerFactoryBean.setQuartzProperties(asProperties(this.properties.getProperties()));
        }
        if (this.jobDetails != null && this.jobDetails.length > 0) {
            schedulerFactoryBean.setJobDetails(this.jobDetails);
        }
        if (this.calendars != null && !this.calendars.isEmpty()) {
            schedulerFactoryBean.setCalendars(this.calendars);
        }
        if (this.triggers != null && this.triggers.length > 0) {
            schedulerFactoryBean.setTriggers(this.triggers);
        }
        customize(schedulerFactoryBean);
        return schedulerFactoryBean;
    }

    private Properties asProperties(Map<String, String> source) {
        Properties properties = new Properties();
        properties.putAll(source);
        return properties;
    }

    private void customize(SchedulerFactoryBean schedulerFactoryBean) {
        this.customizers.orderedStream().forEach((customizer) -> customizer.customize(schedulerFactoryBean));
    }

    @Configuration
    @ConditionalOnSingleCandidate(DataSource.class)
    protected static class JdbcStoreTypeConfiguration {

        @Bean
        @Order(0)
        public SchedulerFactoryBeanCustomizer dataSourceCustomizer(
                QuartzProperties properties, DataSource dataSource,
                @QuartzDataSource ObjectProvider<DataSource> quartzDataSource,
                ObjectProvider<PlatformTransactionManager> transactionManager) {
            return (schedulerFactoryBean) -> {
                if (properties.getJobStoreType() == JobStoreType.JDBC) {
                    DataSource dataSourceToUse = getDataSource(dataSource,quartzDataSource);
                    schedulerFactoryBean.setDataSource(dataSourceToUse);
                    PlatformTransactionManager txManager = transactionManager.getIfUnique();
                    if (txManager != null) {
                        schedulerFactoryBean.setTransactionManager(txManager);
                    }
                }
            };
        }

        private DataSource getDataSource(DataSource dataSource,ObjectProvider<DataSource> quartzDataSource) {
            DataSource dataSourceIfAvailable = quartzDataSource.getIfAvailable();
            return (dataSourceIfAvailable != null) ? dataSourceIfAvailable : dataSource;
        }

        @Bean
        @ConditionalOnMissingBean
        public QuartzDataSourceInitializer quartzDataSourceInitializer(
                DataSource dataSource,
                @QuartzDataSource ObjectProvider<DataSource> quartzDataSource,
                ResourceLoader resourceLoader, QuartzProperties properties) {
            DataSource dataSourceToUse = getDataSource(dataSource, quartzDataSource);
            return new QuartzDataSourceInitializer(dataSourceToUse, resourceLoader,
                    properties);
        }

        @Bean
        public static DataSourceInitializerSchedulerDependencyPostProcessor dataSourceInitializerSchedulerDependencyPostProcessor() {
            return new DataSourceInitializerSchedulerDependencyPostProcessor();
        }

        private static class DataSourceInitializerSchedulerDependencyPostProcessor
                extends AbstractDependsOnBeanFactoryPostProcessor {

            DataSourceInitializerSchedulerDependencyPostProcessor() {
                super(Scheduler.class, SchedulerFactoryBean.class,
                        "quartzDataSourceInitializer");
            }

        }

    }

}