首先非常感谢原作者恒宇少年 ，写了一遍好文章。找了很多文章终于找到比较有用有价值的高质量博文。
原贴地址：https://www.jianshu.com/p/056281e057b3
以下引用原文章。
在新版本的SpringBoot2.0发布后，急迫尝鲜的我将相关的项目已经更换为最新版本，在SpringBoot源码GitHub看到更新日志，表明了针对Quartz新版本进行了 AutoConfiguration自动化配置，省去了很多繁琐的配置。
官网更新日志
Auto-configuration support is now include for the Quartz Scheduler. We’ve also added a new
spring-boot-starter-quartzstarter POM.
You can use in-memoryJobStores, or a full JDBC-based store. AllJobDetail,CalendarandTriggerbeans from your Spring application context will be automatically registered with theScheduler.
For more details read the new "Quartz Scheduler" section of the reference documentation.
SpringBoot2.0版本集成了Quartz2.3.0官网最新版本。
本章目标
使用SpringBoot2.0新特性完成Quartz自动化配置。
SpringBoot 企业级核心技术学习专题
| 专题 | 专题名称 | 专题描述 |
|---|---|---|
| 001 | Spring Boot 核心技术 | 讲解SpringBoot一些企业级层面的核心组件 |
| 002 | Spring Boot 核心技术章节源码 | Spring Boot 核心技术简书每一篇文章码云对应源码 |
| 003 | Spring Cloud 核心技术 | 对Spring Cloud核心技术全面讲解 |
| 004 | Spring Cloud 核心技术章节源码 | Spring Cloud 核心技术简书每一篇文章对应源码 |
| 005 | QueryDSL 核心技术 | 全面讲解QueryDSL核心技术以及基于SpringBoot整合SpringDataJPA |
| 006 | SpringDataJPA 核心技术 | 全面讲解SpringDataJPA核心技术 |
| 007 | SpringBoot核心技术学习目录 | SpringBoot系统的学习目录，敬请关注点赞！！! |
构建项目
在前面章节第四十章：基于SpringBoot & Quartz完成定时任务分布式多节点负载持久化内我们已经通过添加配置的方式完成集成，为了本章的方便直接复制之前的项目，在基础上进行修改。
打开pom.xml配置文件，SpringBoot为我们提供了对应的依赖，我们将之前的quartz相关依赖删除，替换为spring-boot-starter-quartz，如下所示：
<!--quartz相关依赖-->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>${quartz.version}</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>${quartz.version}</version>
</dependency>
>>>>替换为：>>>>
<!--quartz依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
......
删除QuartzConfiguration配置类
在之前章节我们使用QuartzConfiguration配置类来完成了Quartz需要的一系列配置，如：JobFactory、SchedulerFactoryBean等，在我们添加spring-boot-starter-quartz依赖后就不需要主动声明工厂类，因为spring-boot-starter-quartz已经为我们自动化配置好了。
自动化配置源码
我们找到Idea的External Libraries并且展开spring-boot-autoconfigure-2.0.0.RELEASE.jar，找到org.springframework.boot.autoconfigure.quartz，该目录就是SpringBoot为我们提供的Quartz自动化配置源码实现，在该目录下有如下所示几个类：
AutowireCapableBeanJobFactory
该类替代了我们之前在QuartzConfiguration配置类的AutowiringSpringBeanJobFactory内部类实现，主要作用是我们自定义的QuartzJobBean子类被Spring IOC进行托管，可以在定时任务类内使用注入任意被Spring IOC托管的类。JobStoreType
该类是一个枚举类型，定义了对应application.yml、application.properties文件内spring.quartz.job-store-type配置，其目的是配置quartz任务的数据存储方式，分别为：MEMORY（内存方式：默认）、JDBC（数据库方式）。QuartzAutoConfiguration
该类是自动配置的主类，内部配置了SchedulerFactoryBean以及JdbcStoreTypeConfiguration，使用QuartzProperties作为属性自动化配置条件。QuartzDataSourceInitializer
该类主要用于数据源初始化后的一些操作，根据不同平台类型的数据库进行选择不同的数据库脚本。QuartzProperties
该类对应了spring.quartz在application.yml、application.properties文件内开头的相关配置。SchedulerFactoryBeanCustomizer
这是一个接口，我们实现该接口后并且将实现类使用Spring IOC托管，可以完成SchedulerFactoryBean的个性化设置，这里的设置完全可以对SchedulerFactoryBean做出全部的设置变更。
spring.quartz配置
看到QuartzAutoConfiguration类源码，我们知道了，想要使用自动化配置，需要满足QuartzProperties属性配置类的初始化，所以我们需要再application.yml、application.properties配置文件内添加对应的配置信息，如下所示：
spring:
quartz:
#相关属性配置
properties:
org:
quartz:
scheduler:
instanceName: clusteredScheduler
instanceId: AUTO
jobStore:
class: org.quartz.impl.jdbcjobstore.JobStoreTX
driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
tablePrefix: QRTZ_
isClustered: true
clusterCheckinInterval: 10000
useProperties: false
threadPool:
class: org.quartz.simpl.SimpleThreadPool
threadCount: 10
threadPriority: 5
threadsInheritContextClassLoaderOfInitializingThread: true
#数据库方式
job-store-type: jdbc
#初始化表结构
#jdbc:
#initialize-schema: never
spring.quartz.properties
该配置其实代替了之前的quartz.properties，我们把之前quartz.properties配置文件内的所有配置转换成YUML风格，对应的添加在该配置下即可，在QuartzAutoConfiguration类内，会自动调用SchedulerFactoryBean的setQuartzProperties方法，把spring.quartz.properties内的所有配置进行设置。
@Bean
@ConditionalOnMissingBean
public SchedulerFactoryBean quartzScheduler() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setJobFactory(new AutowireCapableBeanJobFactory(this.applicationContext.getAutowireCapableBeanFactory()));
// 如果配置了spring.quartz.properties
if (!this.properties.getProperties().isEmpty()) {
// 将所有properties设置到QuartzProperties
schedulerFactoryBean.setQuartzProperties(this.asProperties(this.properties.getProperties()));
}
......省略部分代码
spring.quartz.job-store-type
设置quartz任务的数据持久化方式，默认是内存方式，我们这里沿用之前的方式，配置JDBC以使用数据库方式持久化任务。spring.quartz.jdbc.initialize-schema
该配置目前版本没有生效，根据官网文档查看，其目的是自动将
quartz需要的数据表通过配置方式进行初始化。
测试
- 启动项目
- 打开浏览器访问
http://localhost:8083/good/save?name=abcd&unit=斤&price=12.5进行添加定时任务 - 查看控制台输出
22:55:18.812 INFO 17161 --- [ main] c.hengyu.chapter39.Chapter47Application : 【【【【【【定时任务分布式节点 - quartz-cluster-node-second 已启动】】】】】】
2018-03-06 22:55:20.772 INFO 17161 --- [uartzScheduler]] o.s.s.quartz.SchedulerFactoryBean : Starting Quartz Scheduler now, after delay of 2 seconds
2018-03-06 22:55:20.793 INFO 17161 --- [uartzScheduler]] org.quartz.core.QuartzScheduler : Scheduler quartzScheduler_$_yuqiyudeMacBook-Pro.local1520348117910 started.
2018-03-06 22:56:20.103 INFO 17161 --- [nio-8083-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring FrameworkServlet 'dispatcherServlet'
2018-03-06 22:56:20.103 INFO 17161 --- [nio-8083-exec-1] o.s.web.servlet.DispatcherServlet : FrameworkServlet 'dispatcherServlet': initialization started
2018-03-06 22:56:20.121 INFO 17161 --- [nio-8083-exec-1] o.s.web.servlet.DispatcherServlet : FrameworkServlet 'dispatcherServlet': initialization completed in 18 ms
Hibernate: select next_val as id_val from hibernate_sequence for update
Hibernate: update hibernate_sequence set next_val= ? where next_val=?
Hibernate: insert into basic_good_info (bgi_name, bgi_price, bgi_unit, bgi_id) values (?, ?, ?, ?)
2018-03-06 22:56:20.268 TRACE 17161 --- [nio-8083-exec-1] o.h.type.descriptor.sql.BasicBinder : binding parameter [1] as [VARCHAR] - [abcd]
2018-03-06 22:56:20.269 TRACE 17161 --- [nio-8083-exec-1] o.h.type.descriptor.sql.BasicBinder : binding parameter [2] as [NUMERIC] - [12.5]
2018-03-06 22:56:20.269 TRACE 17161 --- [nio-8083-exec-1] o.h.type.descriptor.sql.BasicBinder : binding parameter [3] as [VARCHAR] - [斤]
2018-03-06 22:56:20.269 TRACE 17161 --- [nio-8083-exec-1] o.h.type.descriptor.sql.BasicBinder : binding parameter [4] as [BIGINT] - [1]
2018-03-06 22:56:47.253 INFO 17161 --- [eduler_Worker-1] c.h.c.timers.GoodStockCheckTimer : 分布式节点quartz-cluster-node-second，执行库存检查定时任务，执行时间：Tue Mar 06 22:56:47 CST 2018
2018-03-06 22:57:00.012 INFO 17161 --- [eduler_Worker-2] c.h.c.timers.GoodStockCheckTimer : 分布式节点quartz-cluster-node-second，执行库存检查定时任务，执行时间：Tue Mar 06 22:57:00 CST 2018
2018-03-06 22:57:20.207 INFO 17161 --- [eduler_Worker-3] c.hengyu.chapter39.timers.GoodAddTimer : 分布式节点quartz-cluster-node-second，商品添加完成后执行任务，任务时间：Tue Mar 06 22:57:20 CST 2018
2018-03-06 22:57:30.013 INFO 17161 --- [eduler_Worker-4] c.h.c.timers.GoodStockCheckTimer : 分布式节点quartz-cluster-node-second，执行库存检查定时任务，执行时间：Tue Mar 06 22:57:30 CST 2018
2018-03-06 22:58:00.014 INFO 17161 --- [eduler_Worker-5] c.h.c.timers.GoodStockCheckTimer : 分布式节点quartz-cluster-node-second，执行库存检查定时任务，执行时间：Tue Mar 06 22:58:00 CST 2018
根据控制台内容，可以看到我们的定时任务已经正常的开始执行，当然我们如果打开多个节点同样可以实现任务自动漂移的效果。
总结
综上所述我们已经完成了SpringBoot2.0集成Quartz，我们只需要添加依赖、添加配置即可，别的不需要做任何代码编写。
作者：恒宇少年
链接：https://www.jianshu.com/p/056281e057b3
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。
我来说说我自己的背景
springboot 2.1.0版本
同样也是集成了quartz的2.3.0版本
我的yml配置
这里我已经是通过了持久化的测试，在2.0往后的quartz的集成中，是不需要让你去再配datasourse的。之前看了几篇文章，各种在properties中配自定义的datasourse，然后配置驱动什么的。按照那种方式的配置应该也是在spring boot1.5中的做法。
我这里把jobStore和job-store-type注释掉的原因是因为，我在开发环境下我是希望我每次重新启动项目的时候job都可以在执行的时候重新的执行第一次，因为我是要每两个小时获取微信的AccessToken的场景下面，如果是持久化到数据库的话
比如定时7200秒执行一次，现在时间是中午12点，他就会在你这个启动的时间去执行一次，然后下次的执行时间是下午2点。在12-2点的时间内不管你项目怎么启动 他都不会重复的去执行，他只认2点钟这个时间点执行。
再比如你是在开发中1点50分的时候关闭了程序，没有启动，而你在2点零1分的时候启动了项目，那么你启动这个项目的时候也是不会帮你去执行任务的，因为他只认2点钟的时候，2点的时候你程序没有启动，所以他不会帮你重新的回过头，对于任务来说那么下次的执行时间就是下午4点钟。你要想任务式执行的那么你就要保持服务是开启的。
所以我在开发环境下面把持久化到数据库的配置先注销掉，保存在内存中，这样每次项目启动的时候都能保证任务执行一次。适合项目在初始化的时候就需要执行任务的场景。
因为原作者对配置的东西讲的已经比较详细了，我就不过多说了，我最后会贴上sql语句，只要是配置好了你的datasourse不需要再quartz中再次配置了，就可以自动成功持久化数据库了。
我就在贴出一下 需要用到和我一样需求的在项目初始化的时候就开始执行的一种方式。
- 方式一：使用cron表达式来创建任务。（不建议在开发环境中使用）
package com.atao.zowei.job;
import com.atao.zowei.util.QuartzManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class InitializationJobManage {
// @Autowired
// QuartzManager quartzManager;
/**
* 持久化在数据库的时候用cron表达式的话，jobName是不能重复的，在正式服务器环境下可以使用这种方式，在开发环境下建议使用simpleSchedule
*/
// @Bean
// public void Initialization(){
// quartzManager.addJob(WeiXinAccessTokenJob.class.getName(),WeiXinAccessTokenJob.class,"0 0 0/2 * * ? ");
// }
}
下面贴上我修改过的封装好的适合springboot使用的 quartz的工具类
在工具类中使用作者的方法自动注入了Scheduler调度器。可以实现任务的增加，修改，停止，移除。
package com.atao.zowei.util;
import java.util.Map;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
/**
* 定时任务管理类
*
* @author ataopro
* @editdate 2018-11-30
*/
@Component
public class QuartzManager {
/**
* 注入任务调度器
*/
@Autowired
private Scheduler sched;
private static String JOB_GROUP_NAME = "ATAO_JOBGROUP"; //任务组
private static String TRIGGER_GROUP_NAME = "ATAO_TRIGGERGROUP"; //触发器组
/**
* 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
*
* @param jobName 任务名
* @param cls 任务
* @param time 时间设置，参考quartz说明文档
*/
public void addJob(String jobName, Class<? extends Job> cls, String time) {
try {
JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build(); //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
CronTrigger trigger = TriggerBuilder
.newTrigger() //创建一个新的TriggerBuilder来规范一个触发器
.withIdentity(jobName, TRIGGER_GROUP_NAME) //给触发器起一个名字和组名
.withSchedule(CronScheduleBuilder.cronSchedule(time))
.build();
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start(); // 启动
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名 （带参数）
*
* @param jobName 任务名
* @param cls 任务
* @param time 时间设置，参考quartz说明文档
*/
public void addJob(String jobName, Class<? extends Job> cls, String time, Map<String, Object> parameter) {
try {
JobDetail jobDetail = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build(); //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
jobDetail.getJobDataMap().put("parameterList", parameter); //传参数
CronTrigger trigger = TriggerBuilder
.newTrigger() //创建一个新的TriggerBuilder来规范一个触发器
.withIdentity(jobName, TRIGGER_GROUP_NAME) //给触发器起一个名字和组名
.withSchedule(CronScheduleBuilder.cronSchedule(time))
.build();
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start(); // 启动
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 添加一个定时任务
*
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param jobClass 任务
* @param time 时间设置，参考quartz说明文档
*/
public void addJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName, Class<? extends Job> jobClass,
String time) {
try {
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();// 任务名，任务组，任务执行类
CronTrigger trigger = TriggerBuilder // 触发器
.newTrigger()
.withIdentity(triggerName, triggerGroupName)
.withSchedule(CronScheduleBuilder.cronSchedule(time))
.build();
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start(); // 启动
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 添加一个定时任务 （带参数）
*
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param jobClass 任务
* @param time 时间设置，参考quartz说明文档
*/
public void addJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName, Class<? extends Job> jobClass,
String time, Map<String, Object> parameter) {
try {
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();// 任务名，任务组，任务执行类
jobDetail.getJobDataMap().put("parameterList", parameter); //传参数
CronTrigger trigger = TriggerBuilder // 触发器
.newTrigger()
.withIdentity(triggerName, triggerGroupName)
.withSchedule(CronScheduleBuilder.cronSchedule(time))
.build();
sched.scheduleJob(jobDetail, trigger);
if (!sched.isShutdown()) {
sched.start(); // 启动
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
*
* @param jobName 任务名
* @param time 新的时间设置
*/
public void modifyJobTime(String jobName, String time) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME); //通过触发器名和组名获取TriggerKey
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey); //通过TriggerKey获取CronTrigger
if (trigger == null) {
return;
}
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(time)) {
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME); //通过任务名和组名获取JobKey
JobDetail jobDetail = sched.getJobDetail(jobKey);
Class<? extends Job> objJobClass = jobDetail.getJobClass();
removeJob(jobName);
addJob(jobName, objJobClass, time);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 修改一个任务的触发时间
*
* @param triggerName 任务名称
* @param triggerGroupName 传过来的任务名称
* @param time 更新后的时间规则
*/
public void modifyJobTime(String triggerName, String triggerGroupName, String time) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName); //通过触发器名和组名获取TriggerKey
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey); //通过TriggerKey获取CronTrigger
if (trigger == null) return;
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(time)) {
trigger = (CronTrigger) trigger.getTriggerBuilder() //重新构建trigger
.withIdentity(triggerKey)
.withSchedule(scheduleBuilder)
.withSchedule(CronScheduleBuilder.cronSchedule(time))
.build();
sched.rescheduleJob(triggerKey, trigger); //按新的trigger重新设置job执行
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
*
* @param jobName 任务名称
*/
public void removeJob(String jobName) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME); //通过触发器名和组名获取TriggerKey
JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME); //通过任务名和组名获取JobKey
sched.pauseTrigger(triggerKey); // 停止触发器
sched.unscheduleJob(triggerKey);// 移除触发器
sched.deleteJob(jobKey); // 删除任务
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 移除一个任务
*
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
*/
public void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName); //通过触发器名和组名获取TriggerKey
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName); //通过任务名和组名获取JobKey
sched.pauseTrigger(triggerKey); // 停止触发器
sched.unscheduleJob(triggerKey);// 移除触发器
sched.deleteJob(jobKey); // 删除任务
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 启动所有定时任务
*/
public void startJobs() {
try {
sched.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 关闭所有定时任务
*/
public void shutdownJobs() {
try {
if (!sched.isShutdown()) {
sched.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
} http://cron.qqe2.com/ 这个是自动生成cron表达式的工具网址。
- 方式二
使用simpleSchedule来添加任务。
package com.atao.zowei.job;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class QuartzConfig {
/**
* 定时获取AccessToken保存到redis中
* @return
*/
@Bean
public JobDetail getWeiXinAccessTokenQuartzDetail(){
return JobBuilder.newJob(WeiXinAccessTokenJob.class).withIdentity("getWeiXinAccessTokenQuartz").storeDurably().build();
}
@Bean
public Trigger getWeiXinAccessTokenTrigger(){
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(7200) //设置时间周期单位秒
.repeatForever();
return TriggerBuilder.newTrigger().forJob(getWeiXinAccessTokenQuartzDetail())
.withIdentity("getWeiXinAccessTokenQuartz")
.withSchedule(scheduleBuilder)
.build();
}
}
下面说下使用simpleSchedule创建job和Scheduler创建job的区别
其实我研究也不是很深入，我只能讲到我遇到的问题。
- 在使用持久化到数据库的时候使用simpleSchedule创建的任务式可以重复创建的就是说你在开发环境下的话难免会重启服务，使用simpleSchedule的方式的话会覆盖持久化在数据库中的job记录。
- 而使用Scheduler配合cron表达式的方式创建的，他需要你又任务组名和任务名，然后你的任务名是不能重复的创建的，就是说如果在开发环境下使用了这种方式，你重启了服务或者你重复的添加了这个任务，任务名重复的话，系统则会报错，你不会像每次启动服务的时候都去换一个任务名的，当然也有直接用UUID当任务名的，但是我个人建议的话还是使用class的name比较好。或者你去把数据库的表重新构建一遍清空数据表。
我就在这上面踩了雷，我就一直重复的去启动项目，然后第一次是成功的，第二次就不行了。所以这边点的话注意一下。
贴上建表的sql语句
/*
Navicat MySQL Data Transfer
Source Server : local
Source Server Version : 50505
Source Host : localhost:3306
Source Database : quartz
Target Server Type : MYSQL
Target Server Version : 50505
File Encoding : 65001
Date: 2017-11-05 18:01:51
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for qrtz_blob_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
CREATE TABLE `qrtz_blob_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`BLOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_calendars
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
CREATE TABLE `qrtz_calendars` (
`SCHED_NAME` varchar(120) NOT NULL,
`CALENDAR_NAME` varchar(200) NOT NULL,
`CALENDAR` blob NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_cron_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
CREATE TABLE `qrtz_cron_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`CRON_EXPRESSION` varchar(120) NOT NULL,
`TIME_ZONE_ID` varchar(80) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_fired_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
CREATE TABLE `qrtz_fired_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`ENTRY_ID` varchar(95) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`INSTANCE_NAME` varchar(200) NOT NULL,
`FIRED_TIME` bigint(13) NOT NULL,
`SCHED_TIME` bigint(13) NOT NULL,
`PRIORITY` int(11) NOT NULL,
`STATE` varchar(16) NOT NULL,
`JOB_NAME` varchar(200) DEFAULT NULL,
`JOB_GROUP` varchar(200) DEFAULT NULL,
`IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
`REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_job_details
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
CREATE TABLE `qrtz_job_details` (
`SCHED_NAME` varchar(120) NOT NULL,
`JOB_NAME` varchar(200) NOT NULL,
`JOB_GROUP` varchar(200) NOT NULL,
`DESCRIPTION` varchar(250) DEFAULT NULL,
`JOB_CLASS_NAME` varchar(250) NOT NULL,
`IS_DURABLE` varchar(1) NOT NULL,
`IS_NONCONCURRENT` varchar(1) NOT NULL,
`IS_UPDATE_DATA` varchar(1) NOT NULL,
`REQUESTS_RECOVERY` varchar(1) NOT NULL,
`JOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_locks
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks` (
`SCHED_NAME` varchar(120) NOT NULL,
`LOCK_NAME` varchar(40) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_paused_trigger_grps
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_scheduler_state
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
CREATE TABLE `qrtz_scheduler_state` (
`SCHED_NAME` varchar(120) NOT NULL,
`INSTANCE_NAME` varchar(200) NOT NULL,
`LAST_CHECKIN_TIME` bigint(13) NOT NULL,
`CHECKIN_INTERVAL` bigint(13) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_simple_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
CREATE TABLE `qrtz_simple_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`REPEAT_COUNT` bigint(7) NOT NULL,
`REPEAT_INTERVAL` bigint(12) NOT NULL,
`TIMES_TRIGGERED` bigint(10) NOT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_simprop_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
CREATE TABLE `qrtz_simprop_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`STR_PROP_1` varchar(512) DEFAULT NULL,
`STR_PROP_2` varchar(512) DEFAULT NULL,
`STR_PROP_3` varchar(512) DEFAULT NULL,
`INT_PROP_1` int(11) DEFAULT NULL,
`INT_PROP_2` int(11) DEFAULT NULL,
`LONG_PROP_1` bigint(20) DEFAULT NULL,
`LONG_PROP_2` bigint(20) DEFAULT NULL,
`DEC_PROP_1` decimal(13,4) DEFAULT NULL,
`DEC_PROP_2` decimal(13,4) DEFAULT NULL,
`BOOL_PROP_1` varchar(1) DEFAULT NULL,
`BOOL_PROP_2` varchar(1) DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- ----------------------------
-- Table structure for qrtz_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
CREATE TABLE `qrtz_triggers` (
`SCHED_NAME` varchar(120) NOT NULL,
`TRIGGER_NAME` varchar(200) NOT NULL,
`TRIGGER_GROUP` varchar(200) NOT NULL,
`JOB_NAME` varchar(200) NOT NULL,
`JOB_GROUP` varchar(200) NOT NULL,
`DESCRIPTION` varchar(250) DEFAULT NULL,
`NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
`PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
`PRIORITY` int(11) DEFAULT NULL,
`TRIGGER_STATE` varchar(16) NOT NULL,
`TRIGGER_TYPE` varchar(8) NOT NULL,
`START_TIME` bigint(13) NOT NULL,
`END_TIME` bigint(13) DEFAULT NULL,
`CALENDAR_NAME` varchar(200) DEFAULT NULL,
`MISFIRE_INSTR` smallint(2) DEFAULT NULL,
`JOB_DATA` blob DEFAULT NULL,
PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;最后还是在提一下cron表达式吧
上面的话你选完条件了，看下面的。就只要记得cron表达式 下面的运行时间就是马上任务执行的时间节点。
他只认绝对的时间，就是在下面的那个时间点的时候会去执行，别的时间不会去执行
至于是到底怎么写还是别去深究了，就看下面给你的运行时间，就是那个时间节点就行了，抛开以前那些什么相对时间，从现在开始多久执行一次，他就是固定的时间点，都是如此。好了，现在就想到这么多。对于查询sql数据库什么的到时候研究出来的再来补充。