quartz之动态定时器实现
重点：
- 1、基础环境配置
- 2、动态定时任务实现
重点分析：
1、基础环境配置
注意：
a、quartz调度框架是有内置表的
进入quartz的官网http://www.quartz-scheduler.org/，点击Downloads，
下载后在目录\docs\dbTables下有常用数据库创建quartz表的脚本，例如：“tables_mysql.sql”
table_mysql.sql
table_mysql_innodb.sql
上述两者所有的数据库引擎不一样
b、导入pom依赖
org.quartz-scheduler
quartz-jobs
2.2.1
org.springframework.boot
spring-boot-starter-quartz
com.mchange
c3p0
0.9.5.2
更换成Druid连接池
A、 引入依赖
com.alibaba
druid-spring-boot-starter
1.1.10
B、 导入DruidConnectionProvider.java
C、修改quartz.properties配置
#配置数据库源
org.quartz.dataSource.qzDS.connectionProvider.class:
com.javaxl.项目名.util.DruidConnectionProvider
c、在项目中添加quartz.properties文件(这样就不会加载自带的properties文件)
此文件的内容主要分为：scheduler，ThreadPool，JobStore，plugin，Datasources等部分，
覆盖properties文件的目的是覆盖默认的数据源，更换为druid的数据配置
d、自定义MyJobFactory，解决spring不能在quartz中注入bean的问题
e、创建调度器schedule
f、创建自定义任务
g、更新quartz中的任务
h、自定义任务表与quartz内置表的区分
要搞清楚一个问题：从数据库读取任务信息动态生成定时任务，和把quartz持久化到数据库是没有关系的。前者是我们自己定义的业务表，而后者是quartz使用自己的表来存储信息。持久化到数据库后，就算服务器重启或是多个quartz节点也没关系，因为他们共享数据库中的任务信息。
2、动态定时任务实现
自定义业务表
-- 注意：job_name存放的任务类的全路径，在quartz中通过jobName和jobGroup来确定trigger的唯一性，所以这两列为联合唯一索引
create table t_schedule_trigger
(
id int primary key auto_increment, -- ID
cron varchar(200) not null, -- 时间表达式
status char(1) not null, -- 使用状态 0：禁用 1：启用
job_name varchar(200) not null, -- 任务名称
job_group varchar(200) not null, -- 任务分组
unique index(job_name,job_group)
);
-- 额外添加到任务中的参数
create table t_schedule_trigger_param
(
param_id int primary key auto_increment, -- ID
name varchar(200) not null, -- 参数名
value varchar(512), -- 参数值
schedule_trigger_id int not null, -- 外键：引用t_schedule_trigger(id)
foreign key(schedule_trigger_id) references t_schedule_trigger(id)
);
案例中需要观察表数据变化的表：
-- 自定义的业务表
SELECT * FROM t_schedule_trigger;
SELECT * FROM t_schedule_trigger_param;
-- quartz调度框架自带的表
SELECT * FROM qrtz_scheduler_state;
SELECT * FROM qrtz_cron_triggers;
SELECT * FROM qrtz_simple_triggers
SELECT * FROM qrtz_triggers;
SELECT * FROM qrtz_job_details;
创建springboot项目
导入pom.xml里其他的文件
org.quartz-scheduler
quartz-jobs
2.2.1
com.alibaba
druid-spring-boot-starter
1.1.10
src/main/java
**/*.xml
src/main/resources
*.properties
*.xml
*.yml
org.mybatis.generator
mybatis-generator-maven-plugin
1.3.2
mysql
mysql-connector-java
${mysql.version}
true
application.yml的分享
server:
servlet:
context-path: /quartz
spring:
datasource:
#1.JDBC
type: com.alibaba.druid.pool.DruidDataSource
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybatis_ssm?useUnicode=true&characterEncoding=utf8
username: mybatis_ssm
password: xiaoli
druid:
#2.连接池配置
#初始化连接池的连接数量 大小，最小，最大
initial-size: 5
min-idle: 5
max-active: 20
#配置获取连接等待超时的时间
max-wait: 60000
#配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
time-between-eviction-runs-millis: 60000
# 配置一个连接在池中最小生存的时间，单位是毫秒
min-evictable-idle-time-millis: 30000
validation-query: SELECT 1 FROM DUAL
test-while-idle: true
test-on-borrow: true
test-on-return: false
# 是否缓存preparedStatement，也就是PSCache 官方建议MySQL下建议关闭 个人建议如果想用SQL防火墙 建议打开
pool-prepared-statements: true
max-pool-prepared-statement-per-connection-size: 20
# 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
filter:
stat:
merge-sql: true
slow-sql-millis: 5000
#3.基础监控配置
web-stat-filter:
enabled: true
url-pattern: /*
#设置不统计哪些URL
exclusions: "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*"
session-stat-enable: true
session-stat-max-count: 100
stat-view-servlet:
enabled: true
url-pattern: /druid/*
reset-enable: true
#设置监控页面的登录名和密码
login-username: admin
login-password: admin
allow: 127.0.0.1
#deny: 192.168.1.100
#显示日志
logging:
level:
com.javaxl.quartz02.mapper: debug
generatorConfig.xml代码分享这是自动创建实体类和对应的增删改查的sql语句：
jdbc.properties的代码分享：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis_ssm?useUnicode=true&characterEncoding=UTF-8
jdbc.username=mybatis_ssm
jdbc.password=xiaoli
jdbc.initialSize=10
jdbc.maxTotal=100
jdbc.maxIdle=50
jdbc.minIdle=10
jdbc.maxWaitMillis=-1
quartz.properties代码分享：
#
#============================================================================
# Configure Main Scheduler Properties 调度器属性
#============================================================================
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount= 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================
#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用自己的配置文件
org.quartz.jobStore.useProperties:true
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true
#============================================================================
# Configure Datasources
#============================================================================
#配置数据库源（org.quartz.dataSource.qzDS.maxConnections: c3p0配置的是有s的，druid数据源没有s）
org.quartz.dataSource.qzDS.connectionProvider.class:com.zking.quartz02.util.DruidConnectionProvider
org.quartz.dataSource.qzDS.driver: com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL: jdbc:mysql://localhost:3306/t211?useUnicode=true&characterEncoding=utf-8
org.quartz.dataSource.qzDS.user: root
org.quartz.dataSource.qzDS.password: 123
org.quartz.dataSource.qzDS.maxConnection: 10
在前面有自动创建的实体类中的xml文件要添加的方法及sql语句
- ScheduleTriggerMapper.java
/**
* 查询触发器中包含的所有任务
* @return
*/
List queryScheduleTriggerLst();
- ScheduleTriggerParamMapper.java
/**
* 查询出当前任务类对应所需的参数
* @param triggerId
* @return
*/
List queryScheduleParamLst(Integer triggerId);
- ScheduleTriggerMapper.xml
- ScheduleTriggerParamMapper.xml
service层的代码分享：
- ScheduleTriggerParamService
public classScheduleTriggerParamService {
public List queryScheduleParamLst(Integer triggerId)；
}
-
ScheduleTriggerParamServiceImpl.java
@Service public class ScheduleTriggerParamServiceImpl implements ScheduleTriggerParamService { @Autowired private ScheduleTriggerParamMapper scheduleTriggerParamMapper; @Override public ListqueryScheduleParamLst(Integer triggerId) { return scheduleTriggerParamMapper.queryScheduleParamLst(triggerId); } }
spring自带定时任务作业类
- ScheduleTriggerServiceImpl.java
package com.javaxl.quartz02.service.impl;
import com.javaxl.quartz02.mapper.ScheduleTriggerMapper;
import com.javaxl.quartz02.mapper.ScheduleTriggerParamMapper;
import com.javaxl.quartz02.model.ScheduleTrigger;
import com.javaxl.quartz02.model.ScheduleTriggerParam;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ScheduleTriggerServiceImpl {
@Autowired
private ScheduleTriggerMapper scheduleTriggerMapper;
@Autowired
private ScheduleTriggerParamMapper scheduleTriggerParamMapper;
@Autowired
private Scheduler scheduler;
@Scheduled(cron = "0/10 * * * * ?")
public void refreshScheduler(){
try {
List scheduleTriggers =
scheduleTriggerMapper.queryScheduleTriggerLst();
if(null!=scheduleTriggers){
for (ScheduleTrigger scheduleTrigger : scheduleTriggers) {
String cron = scheduleTrigger.getCron(); //表达式
String jobName = scheduleTrigger.getJob_name(); //任务名称
String jobGroup = scheduleTrigger.getJob_group(); //任务分组
String status = scheduleTrigger.getStatus(); //任务状态
//JobName+JobGroup=Primary Key
//根据jobName和jobGroup生成TriggerKey
TriggerKey triggerKey =
TriggerKey.triggerKey(jobName, jobGroup);
//根据TriggerKey到Scheduler调度器中获取触发器
CronTrigger cronTrigger = (CronTrigger)
scheduler.getTrigger(triggerKey);
if(null==cronTrigger){
if(status.equals("0"))
continue;
System.out.println("创建调度器");
//创建任务详情
JobDetail jobDetail=
JobBuilder.newJob((Class) Class.forName(jobName))
.withIdentity(jobName,jobGroup)
.build();
//往Job任务中传递参数
JobDataMap jobDataMap = jobDetail.getJobDataMap();
List params =
scheduleTriggerParamMapper.queryScheduleParamLst(scheduleTrigger.getId());
for (ScheduleTriggerParam param : params) {
jobDataMap.put(param.getName(),param.getValue());
}
//创建表达式调度器
CronScheduleBuilder cronSchedule =
CronScheduleBuilder.cronSchedule(cron);
//创建Trigger
cronTrigger=TriggerBuilder.newTrigger()
.withIdentity(jobName,jobGroup)
.withSchedule(cronSchedule)
.build();
//将jobDetail和Trigger注入到scheduler调度器中
scheduler.scheduleJob(jobDetail,cronTrigger);
}else{
//System.out.println("Quartz 调度任务中已存在该任务");
if(status.equals("0")){
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
scheduler.deleteJob(jobKey);
continue;
}
//调度器中的表达式
String cronExpression =
cronTrigger.getCronExpression();
if(!cron.equals(cronExpression)){
//创建表达式调度器
CronScheduleBuilder cronSchedule =
CronScheduleBuilder.cronSchedule(cron);
//重构
cronTrigger=cronTrigger.getTriggerBuilder()
.withIdentity(triggerKey)
.withSchedule(cronSchedule)
.build();
//刷新调度器
scheduler.rescheduleJob(triggerKey,cronTrigger);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
ScheduleTriggerServiceImpl .java代码分享：
package com.javaxl.quartz02.service.impl;
import com.javaxl.quartz02.mapper.ScheduleTriggerMapper;
import com.javaxl.quartz02.mapper.ScheduleTriggerParamMapper;
import com.javaxl.quartz02.model.ScheduleTrigger;
import com.javaxl.quartz02.model.ScheduleTriggerParam;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class ScheduleTriggerServiceImpl {
@Autowired
private ScheduleTriggerMapper scheduleTriggerMapper;
@Autowired
private ScheduleTriggerParamMapper scheduleTriggerParamMapper;
@Autowired
private Scheduler scheduler;
@Scheduled(cron = "0/10 * * * * ?")
public void refreshScheduler(){
try {
List scheduleTriggers =
scheduleTriggerMapper.queryScheduleTriggerLst();
if(null!=scheduleTriggers){
for (ScheduleTrigger scheduleTrigger : scheduleTriggers) {
String cron = scheduleTrigger.getCron(); //表达式
String jobName = scheduleTrigger.getJob_name(); //任务名称
String jobGroup = scheduleTrigger.getJob_group(); //任务分组
String status = scheduleTrigger.getStatus(); //任务状态
//JobName+JobGroup=Primary Key
//根据jobName和jobGroup生成TriggerKey
TriggerKey triggerKey =
TriggerKey.triggerKey(jobName, jobGroup);
//根据TriggerKey到Scheduler调度器中获取触发器
CronTrigger cronTrigger = (CronTrigger)
scheduler.getTrigger(triggerKey);
if(null==cronTrigger){
if(status.equals("0"))
continue;
System.out.println("创建调度器");
//创建任务详情
JobDetail jobDetail=
JobBuilder.newJob((Class) Class.forName(jobName))
.withIdentity(jobName,jobGroup)
.build();
//往Job任务中传递参数
JobDataMap jobDataMap = jobDetail.getJobDataMap();
List params =
scheduleTriggerParamMapper.queryScheduleParamLst(scheduleTrigger.getId());
for (ScheduleTriggerParam param : params) {
jobDataMap.put(param.getName(),param.getValue());
}
//创建表达式调度器
CronScheduleBuilder cronSchedule =
CronScheduleBuilder.cronSchedule(cron);
//创建Trigger
cronTrigger=TriggerBuilder.newTrigger()
.withIdentity(jobName,jobGroup)
.withSchedule(cronSchedule)
.build();
//将jobDetail和Trigger注入到scheduler调度器中
scheduler.scheduleJob(jobDetail,cronTrigger);
}else{
//System.out.println("Quartz 调度任务中已存在该任务");
if(status.equals("0")){
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
scheduler.deleteJob(jobKey);
continue;
}
//调度器中的表达式
String cronExpression =
cronTrigger.getCronExpression();
if(!cron.equals(cronExpression)){
//创建表达式调度器
CronScheduleBuilder cronSchedule =
CronScheduleBuilder.cronSchedule(cron);
//重构
cronTrigger=cronTrigger.getTriggerBuilder()
.withIdentity(triggerKey)
.withSchedule(cronSchedule)
.build();
//刷新调度器
scheduler.rescheduleJob(triggerKey,cronTrigger);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
Application层
项目名Application.java
@MapperScan("com.javaxl.quartz02.mapper")
@EnableTransactionManagement
@EnableScheduling
@SpringBootApplication
public class Quartz02Application {
public static void main(String[] args) {
SpringApplication.run(Quartz02Application.class, args);
}
}
案例1：
数据库表t_schedule_trigger配置
- MyJob.java
package com.javaxl.quartz02.quartz;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;
import java.util.Date;
@Component
@Slf4j
public class MyJob implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("MyJob是一个空的任务计划,时间："+new Date().toLocaleString());
}
}
效果图 ，Spring自带定时任务每10s执行一次，查询自定义触发器表，获取到具体的作业类及任务表达式，quartz的任务为每5s执行一次，所以打印如下：
更改数据库调度器表t_schedule_trigger的state状态，
当禁用该触发器时，那么程序只会执行spring自带的定时任务，每10s执行一次查询，所以打印语句如下
案例3：
数据库表配置
t_schedule_trigger
t_schedule_trigger_param
- MyJob1.java
@Component
@Slf4j
public class MyJob1 implements Job {
@Autowired
private ScheduleTriggerParamService scheduleTriggerParamService;
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
JobDetail jobDetail =
jobExecutionContext.getJobDetail();
JobDataMap jobDataMap = jobDetail.getJobDataMap();
System.out.println(new Date().toLocaleString()+"-->携带参数个数:"+jobDataMap.size());
}
}
效果图 ，程序执行spring自带的定时任务，每10s执行一次查询，查询t_schedule_trigger表，调度器表中有两个调度器，都是每5s执行一次，其中一个调度器是需要携带参数的，携带的参数在t_schedule_trigger_param表中，所以一开始调度器启动的时候需要查询t_schedule_trigger_param表数据，最终打印语句如下：
案例4：
t_schedule_trigger
t_schedule_trigger_param
-
MyJob2.java
@Component @Slf4j public class MyJob2 implements Job{ @Override public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { JobDetail jobDetail = jobExecutionContext.getJobDetail(); JobDataMap jobDataMap = jobDetail.getJobDataMap(); System.out.println(new Date().toLocaleString()+"-->MyJob2参数传递name="+jobDataMap.get("name")+",score="+ jobDataMap.get("score")); } }
效果图，程序执行spring自带的定时任务，每10s执行一次查询，查询t_schedule_trigger表，将任务3的表达式由0/3 * * * * ?改成0/20 * * * * ?，最终结果如下
附录一：AutowireCapableBeanFactory
对于想要拥有自动装配能力，并且想把这种能力暴露给外部应用的BeanFactory类需要实现此接口。
正常情况下，不要使用此接口，应该更倾向于使用BeanFactory或者ListableBeanFactory接口。此接口主要是针对框架之外，没有向Spring托管Bean的应用。通过暴露此功能，Spring框架之外的程序，具有自动装配等Spring的功能。
需要注意的是，ApplicationContext接口并没有实现此接口，因为应用代码很少用到此功能，如果确实需要的话，可以调用ApplicationContext的getAutowireCapableBeanFactory方法，来获取此接口的实例。
如果一个类实现了此接口，那么很大程度上它还需要实现BeanFactoryAware接口。它可以在应用上下文中返回BeanFactory
附录二：@Configuration注解
从Spring3.0，@Configuration用于定义配置类，可替换xml配置文件，
被注解的类内部包含有一个或多个被@Bean注解的方法，这些方法将会被AnnotationConfigApplicationContext
或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。
注意：
-
@Configuration不可以是final类型；
-
@Configuration不可以是匿名类；
-
嵌套的configuration必须是静态类。
附录三：quartz表简介
QRTZ_CALENDARS 以 Blob 类型存储 Quartz 的 Calendar 信息
QRTZ_CRON_TRIGGERS 存储 Cron Trigger，包括Cron表达式和时区信息
QRTZ_FIRED_TRIGGERS 存储与已触发的 Trigger 相关的状态信息，以及相联 Job的执行信息QRTZ_PAUSED_TRIGGER_GRPS 存储已暂停的 Trigger组的信息
QRTZ_SCHEDULER_STATE 存储少量的有关 Scheduler 的状态信息，和别的Scheduler实例(假如是用于一个集群中)
QRTZ_LOCKS 存储程序的悲观锁的信息(假如使用了悲观锁)
QRTZ_JOB_DETAILS 存储每一个已配置的 Job 的详细信息
QRTZ_JOB_LISTENERS 存储有关已配置的 JobListener的信息
QRTZ_SIMPLE_TRIGGERS存储简单的Trigger，包括重复次数，间隔，以及已触的次数
QRTZ_BLOG_TRIGGERS Trigger 作为 Blob 类型存储(用于 Quartz 用户用JDBC创建他们自己定制的 Trigger 类型，JobStore并不知道如何存储实例的时候)
QRTZ_TRIGGER_LISTENERS 存储已配置的 TriggerListener的信息
QRTZ_TRIGGERS 存储已配置的 Trigger 的信息