关键词：
目录
-
初识Quartz
-
Quartz基础使用
-
基于时间间隔的定时任务
-
基于Cron表达式的定时任务
-
-
Quartz解读
-
Job
-
Trigger
-
Scheduler
-
-
Quartz进阶使用
-
多触发器的定时任务
-
Job中注入Bean
-
Quartz的持久化
-
最近在工作遇到了定时任务场景，因此特地对定时任务相关知识进行了调研，记录在此，后文中使用的代码已经上传到Github：https://github.com/ThinkMugz/springboot-demo-major，需要的伙伴儿自取。
本文主要有以下内容：
-
Quartz的基本认知和源码初探
-
Quartz的基本使用
-
Quartz的进阶使用，包括Job中注入Mapper层、Quartz的持久化
在Java领域，有很多定时任务框架，这里简单对比一下目前比较流行的三款：
网络资源：
-
Quartz文档：
https://www.w3cschool.cn/quartz_doc/ -
xxl-job博客：
https://www.cnblogs.com/xuxueli/p/5021979.html
1 初识Quartz
如果你的定时任务没有分布式需求，但需要对任务有一定的动态管理，例如任务的启动、暂停、恢复、停止和触发时间修改，那么Quartz非常适合你。
Quartz是Java定时任务领域一个非常优秀的框架，由OpenSymphony（一个开源组织）开发，这个框架进行了优良地解耦设计，整个模块可以分为三大部分：
-
Job：顾名思义，指待定时执行的具体工作内容；
-
Trigger：触发器，指定运行参数，包括运行次数、运行开始时间和技术时间、运行时长等；
-
Scheduler：调度器，将Job和Trigger组装起来，使定时任务被真正执行；
下面这个图简略地描述了三者之间的关系：
-
一个
JobDetail（Job的实现类）可以绑定多个Trigger，但一个Trigger只能绑定一个JobDetail； -
每个
JobDetail和Trigger通过group和name来标识唯一性； -
一个
Scheduler可以调度多组JobDetail和Trigger。
为了便于理解和记忆，可以把这套设计机制与工厂车间相关联：
-
Job：把Job比作车间要生产的一类产品，例如汽车、电脑等。
-
Trigger：trigger可以理解为一条生产线，一条生产线只能生产一类产品，但一类产品可以由多条生产线生产。
-
Scheduler：
Scheduler则可以理解为车间主任，指挥调度着车间内的生产任务（Scheduler内置线程池，线程池内的工作线程即为车间工人，每个工人承担着一组任务的真正执行）。
2 Quartz基础使用
Quartz提供了丰富的API，下面我们在Springboot中使用Quartz完成一些简单的demo。
2.1 基于时间间隔的定时任务
基于时间间隔和时间长度实现定时任务，借助SimpleTrigger，例如这个场景——每隔2s在控制台输出线程名和当前时间，持续30s。
1.导入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
2.新建Job，实现我们想要定时执行的任务：
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class SimpleJob implements Job
@Override
public void execute(JobExecutionContext jobExecutionContext)
// 创建一个事件，下面仅创建一个输出语句作演示
System.out.println(Thread.currentThread().getName() + "--"
+ DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()));
3.创建Scheduler和Trigger，执行定时任务：
import com.quartz.demo.schedule.SimpleJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.Date;
import java.util.concurrent.TimeUnit;
public class SimpleQuartzTest
/*
* 基于时间间隔的定时任务
*/
@Test
public void simpleTest() throws SchedulerException, InterruptedException
// 1、创建Scheduler（调度器）
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
// 2、创建JobDetail实例，并与SimpleJob类绑定(Job执行内容)
JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
.withIdentity("job1", "group1")
.build();
// 3、构建Trigger（触发器），定义执行频率和时长
Trigger trigger = TriggerBuilder.newTrigger()
// 指定group和name，这是唯一身份标识
.withIdentity("trigger-1", "trigger-group")
.startNow() //立即生效
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(2) //每隔2s执行一次
.repeatForever()) // 永久执行
.build();
//4、将Job和Trigger交给Scheduler调度
scheduler.scheduleJob(jobDetail, trigger);
// 5、启动Scheduler
scheduler.start();
// 休眠，决定调度器运行时间，这里设置30s
TimeUnit.SECONDS.sleep(30);
// 关闭Scheduler
scheduler.shutdown();
启动测试方法后，控制台观察现象即可。注意到这么一句日志：Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.，这说明Scheduler确实是内置了10个线程的线程池，通过打印线程名也印证了这一点。
另外要尤其注意的是，我们之所以通过TimeUnit.SECONDS.sleep(30);设置休眠，是因为定时任务是交由线程池异步执行的，而测试方法运行结束，主线程随之结束导致定时任务也不再执行了，所以需要设置休眠hold住主线程。在真实项目中，项目的进程是一直存活的，因此不需要设置休眠时间。扩展：最全的java面试题库
这其中的区别可以参考
https://github.com/ThinkMugz/springboot-demo-major。
2.2 基于Cron表达式的定时任务
基于Cron表达式的定时任务demo如下：
import com.quartz.demo.schedule.SimpleJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.concurrent.TimeUnit;
public class SimpleQuartzTest
/*
* 基于cron表达式的定时任务
*/
@Test
public void cronTest() throws SchedulerException, InterruptedException
// 1、创建Scheduler（调度器）
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
// 2、创建JobDetail实例，并与SimpleJob类绑定
JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
.withIdentity("job-1", "job-group").build();
// 3、构建Trigger（触发器），定义执行频率和时长
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
.withIdentity("trigger-1", "trigger-group")
.startNow() //立即生效
.withSchedule(CronScheduleBuilder.cronSchedule("* 30 10 ? * 1/5 *"))
.build();
//4、执行
scheduler.scheduleJob(jobDetail, cronTrigger);
scheduler.start();
// 休眠，决定调度器运行时间，这里设置30s
TimeUnit.SECONDS.sleep(30);
// 关闭Scheduler
scheduler.shutdown();
3 Quartz解读
整个Quartz体系涉及的类及之间的关系如下图所示：
-
JobDetail：Job接口的实现类，由
JobBuilder将具体定义任务的类包装而成。 -
Trigger：触发器，定义定时任务的触发规则，包括执行间隔、时长等，使用
TriggerBuilder创建，JobDetail和Trigger可以一对多，反之不可。触发器可以拥有多种状态。 -
Scheduler：调度器，将Job和Trigger组装起来，使定时任务被真正执行；是Quartz的核心，提供了大量API。
-
JobDataMap：集成Map，通过键值对为
JobDetail存储一些额外信息。 -
JobStore：用来存储任务和触发器相关的信息，例如任务名称、数量、状态等等。Quartz 中有两种存储任务的方式，一种在在内存（
RAMJobStore），一种是在数据库（JDBCJobStore）。
3.1 Job
Job是一个接口，只有一个方法execute()，我们创建具体的任务类时要继承Job并重写execute()方法，使用JobBuilder将具体任务类包装成一个JobDetail（使用了建造者模式）交给Scheduler管理。每个JobDetail由name和group作为其唯一身份标识。
-
JobDataMap中可以包含不限量的（序列化的）数据对象，在job实例执行的时候，可以使用其中的数据。
-
JobDataMap继承Map，可通过键值对为JobDetail存储一些额外信息。
3.2 Trigger
Trigger有四类实现，分别如下：
-
SimpleTrigger：简单触发器，支持定义任务执行的间隔时间，执行次数的规则有两种，一是定义重复次数，二是定义开始时间和结束时间。如果同时设置了结束时间与重复次数，先结束的会覆盖后结束的，以先结束的为准。
-
CronTrigger：基于Cron表达式的触发器。
-
CalendarIntervalTrigger：基于日历的触发器，比简单触发器更多时间单位，且能智能区分大小月和平闰年。
-
DailyTimeIntervalTrigger：基于日期的触发器，如每天的某个时间段。
Trigger是有状态的：NONE, NORMAL, PAUSED, COMPLETE, ERROR, BLOCKED，状态之间转换关系：
COMPLETE状态比较特殊，我在实际操作中发现，当Trigger长时间暂停后（具体时长不太确定）再恢复，状态就会变为COMPLETE，这种状态下无法再次启动该触发器。
3.3 Scheduler
调度器，是 Quartz 的指挥官，由 StdSchedulerFactory 产生，它是单例的。Scheduler中提供了 Quartz 中最重要的 API，默认是实现类是 StdScheduler。
Scheduler中主要的API大概分为三种：
-
操作Scheduler本身：例如
start、shutdown等； -
操作Job：例如：
addJob、pauseJob、pauseJobs、resumeJob、resumeJobs、getJobKeys、getJobDetail等 -
操作Trigger：例如
pauseTrigger、resumeTrigger等
这些API使用非常简单，源码中也有完善的注释，这里不再赘述。
4 Quartz进阶使用
除了基本使用外，Quartz还有一些较为复杂的应用场景。
4.1 多触发器的定时任务
前文提过，一个JobDetail可以绑定多个触发器，这种场景还是有一些注意点的：
-
首先，要通过
storeDurably()方法将JobDetail设置为孤立后保存存储（没有触发器指向该作业的情况）； -
Scheduler通过addJob()将给定的作业添加到计划程序中-没有关联的触发器。作业将处于“休眠”状态，直到使用触发器或调度程序对其进行调度； -
触发器通过
forJob(JobDetail jobDetail)指定要绑定的JobDetail，scheduleJob()方法只传入触发器，触发后将自动执行addJob过的绑定JobDetail。
import com.quartz.demo.schedule.SimpleJob;
import org.junit.jupiter.api.Test;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.concurrent.TimeUnit;
public class MultiQuartzTest
@Test
public void multiJobTest() throws SchedulerException, InterruptedException
// 1、创建Scheduler（调度器）
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
// 2、创建JobDetail实例，与执行内容类SimpleJob绑定，注意要设置 .storeDurably()，否则报错
JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
.withIdentity("job1", "job-group")
.storeDurably()
.build();
// 3、分别构建Trigger实例
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "trigger-group")
.startNow()//立即生效
.forJob(jobDetail)
.withSchedule(SimpleScheduleBuilder
.simpleSchedule()
.withIntervalInSeconds(2) //每隔3s执行一次
.repeatForever()) // 永久循环
.build();
Trigger trigger2 = TriggerBuilder.newTrigger().withIdentity("trigger2", "trigger-group")
.startNow()//立即生效
.forJob(jobDetail)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
.withIntervalInSeconds(3) //每隔5s执行一次
.repeatForever()).build(); // 永久循环
//4、调度器中添加job
scheduler.addJob(jobDetail, false);
scheduler.scheduleJob(trigger);
scheduler.scheduleJob(trigger2);
// 启动调度器
scheduler.start();
// 休眠任务执行时长
TimeUnit.SECONDS.sleep(20);
scheduler.shutdown();
4.2 Job中注入Bean
有时候，我们要在定时任务中操作数据库，但Job中无法直接注入数据层，解决这种问题，有两种解决方案。扩展：最全的java面试题库
方案一：借助JobDataMap
在构建JobDetail时，可以将数据放入JobDataMap，基本类型的数据通过usingJobData方法直接放入，mapper这种类型数据手动put进去：
@Autowired
private PersonMapper personMapper;
// 构建定时任务
JobDetail jobDetail = JobBuilder.newJob(MajorJob.class)
.withIdentity(jobName, jobGroupName)
.usingJobData("jobName", "QuartzDemo")
.build();
// 将mapper放入jobDetail的jobDataMap中
jobDetail.getJobDataMap().put("personMapper", personMapper);
在job的执行过程中，可以从JobDataMap中取出数据，如下示例：
import com.quartz.demo.entity.Person;
import com.quartz.demo.mapper.PersonMapper;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
public class MajorJob implements Job
@Override
public void execute(JobExecutionContext jobExecutionContext)
JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
String jobName = dataMap.getString("jobName");
PersonMapper personMapper = (PersonMapper) dataMap.get("personMapper");
// 这样就可以执行mapper层方法了
List<Person> personList = personMapper.queryList();
System.out.println(Thread.currentThread().getName() + "--"
+ DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()) + "--"
+ jobName + "--" + personList);
这个方案相对简单，但在持久化中会遇到mapper的序列化问题：
java.io.NotSerializableException: Unable to serialize JobDataMap for insertion into database because the value of property 'personMapper' is not serializable: org.mybatis.spring.SqlSessionTemplate
方案二：静态工具类
创建工具类SpringContextJobUtil，实现ApplicationContextAware接口
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
import java.util.Locale;
@Component
public class SpringContextJobUtil implements ApplicationContextAware
private static ApplicationContext context;
@Override
@SuppressWarnings("static-access")
public void setApplicationContext(ApplicationContext contex) throws BeansException
this.context = contex;
/**
* 根据name获取bean
*
* @param beanName name
* @return bean对象
*/
public static Object getBean(String beanName)
return context.getBean(beanName);
public static String getMessage(String key)
return context.getMessage(key, null, Locale.getDefault());
mapper类上打上@Service注解，并赋予其name：
@Service("personMapper")
public interface PersonMapper
@Select("select id,name,age,sex,address,sect,skill,power,create_time createTime,modify_time modifyTime from mytest.persons")
List<Person> queryList();
Job中通过SpringContextJobUtil的getBean获取mapper的bean：
public class MajorJob implements Job
@Override
public void execute(JobExecutionContext jobExecutionContext)
JobDataMap dataMap = jobExecutionContext.getJobDetail().getJobDataMap();
String jobName = dataMap.getString("jobName");
PersonMapper personMapper = (PersonMapper) SpringContextJobUtil.getBean("personMapper");
List<Person> personList = personMapper.queryList();
System.out.println(Thread.currentThread().getName() + "--"
+ DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").format(LocalDateTime.now()) + "--"
+ jobName + "--" + personList);
推荐使用这个方法。
4.3 Quartz的持久化
定时任务的诸多要素，如任务名称、数量、状态、运行频率、运行时间等，是要存储起来的。JobStore，就是用来存储任务和触发器相关的信息的。
Quartz 中有两种存储任务的方式，一种在在内存（RAMJobStore），一种是在数据库（JDBCJobStore）。
Quartz 默认的 JobStore 是 RAMJobstore，也就是把任务和触发器信息运行的信息存储在内存中，用到了 HashMap、TreeSet、HashSet 等等数据结构，如果程序崩溃或重启，所有存储在内存中的数据都会丢失。所以我们需要把这些数据持久化到磁盘。扩展：最全的java面试题库
实现Quartz的持久化并不困难，按下列步骤操作即可：
1.添加相关依赖：
<!--Quartz 使用的连接池 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>
2.编写配置：
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
/**
* @author muguozheng
* @version 1.0.0
* @createTime 2022/4/19 18:46
* @description Quartz配置
*/
@Configuration
public class SchedulerConfig
/**
* 读取quartz.properties,将值初始化
*
* @return Properties
* @throws IOException io
*/
@Bean
public Properties quartzProperties() throws IOException
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
/**
* 将配置文件的数据加载到SchedulerFactoryBean中
*
* @return SchedulerFactoryBean
* @throws IOException io
*/
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setQuartzProperties(quartzProperties());
return schedulerFactoryBean;
/**
* 初始化监听器
*
* @return QuartzInitializerListener
*/
@Bean
public QuartzInitializerListener executorListener()
return new QuartzInitializerListener();
/**
* 获得Scheduler对象
*
* @return Scheduler
* @throws IOException io
*/
@Bean
public Scheduler scheduler() throws IOException
return schedulerFactoryBean().getScheduler();
3.创建quartz.properties配置文件
# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
# 并发个数
org.quartz.threadPool.threadCount=10
# 优先级
org.quartz.threadPool.threadPriority=3
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
org.quartz.jobStore.misfireThreshold=5000
# 持久化使用的类
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
# 数据库中表的前缀
org.quartz.jobStore.tablePrefix=QRTZ_
# 数据源命名
org.quartz.jobStore.dataSource=qzDS
# qzDS 数据源
org.quartz.dataSource.qzDS.driver=com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL=jdbc:mysql://localhost:3306/mytest?useUnicode=true&characterEncoding=UTF-8
org.quartz.dataSource.qzDS.user=root
org.quartz.dataSource.qzDS.password=root
org.quartz.dataSource.qzDS.maxConnections=10
4.创建Quartz持久化数据的表
数据表初始化sql放置在External Libraries的org/quartz/impl/jdbcjobstore中，直接用其初始化相关表即可。要注意的是，用来放置这些表的库要与quartz.properties的库一致。
#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
#
# By: Ron Cordell - roncordell
# I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.
DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;
CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) 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 NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
JOB_NAME VARCHAR(190) NOT NULL,
JOB_GROUP VARCHAR(190) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(190) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) 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),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SIMPROP_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
STR_PROP_1 VARCHAR(512) NULL,
STR_PROP_2 VARCHAR(512) NULL,
STR_PROP_3 VARCHAR(512) NULL,
INT_PROP_1 INT NULL,
INT_PROP_2 INT NULL,
LONG_PROP_1 BIGINT NULL,
LONG_PROP_2 BIGINT NULL,
DEC_PROP_1 NUMERIC(13,4) NULL,
DEC_PROP_2 NUMERIC(13,4) NULL,
BOOL_PROP_1 VARCHAR(1) NULL,
BOOL_PROP_2 VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(190) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;
CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;
CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(190) NOT NULL,
TRIGGER_GROUP VARCHAR(190) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(190) NULL,
JOB_GROUP VARCHAR(190) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;
CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(190) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;
CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;
CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
commit;
重学springboot系列之异步任务与定时任务(代码片段)
...入对应的maven依赖创建一个任务类Job创建Quartz定时配置类深入解析核心概念SimpleTriggerandCronTriggerquartz动态定时任务(数据库持久化)前言原理配置动态配置代码实现分布式任务调度框架---xxl-job实现Async异步任务环境准备在SpringBoot入... 查看详情
以代码的方式管理quartz定时任务的暂停重启删除添加等
【前言】在项目的管理功能中，对定时任务的管理有时会很常见。因为我们不能指望只在配置文件中配置好定时任务就行了，因为如果要控制定时任务的“暂停”呢？暂停之后又要在某个时间点“重启”该定时任务呢？或者说直... 查看详情
hostedservices+quartz实现定时任务调度(代码片段)
背景之前.netcore使用quartz.net时，总感觉非常变扭，百度和谷歌了N久都没解决以下问题，造成代码丑陋，非常不优雅：1.项目启动时，要立刻恢复执行quartz.net中的任务2.quartz.net中的Job任务无法使用ioc注入，要额外写一套直到最近... 查看详情
任务调度管理器quartz漫谈(代码片段)
quartz中主要有Job、JobDetail、Scheduler构成在你需要执行的任务中只要实现Job类，然后在execute中执行具体的任务即可。你定义了一个实现Job接口的类，这个类仅仅表明该job需要完成什么类型的任务.首先，我们可以实现一... 查看详情
springboot结合xxl-job实现定时任务(代码片段)
...变更管理定时任务框架Java定时任务技术分析SpringBoot结合Quartz实现定时任务SpringBoot结合XXL-JOB实现定时任务缓存SpringSecurity结合Redis实现缓存功能安全框架Java应用程序安全框架SpringSecurity系列文章SpringSecurity结合JWT实现认证与授权... 查看详情
quartz定时任务调度管理器(代码片段)
本项目使用的是spring-quartz以下配置可以开启多个已知定时任务1<?xmlversion="1.0"encoding="UTF-8"?>2<beansxmlns="http://www.springframework.org/schema/beans"3xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"4xmlns:task="http://www.springframework.org/schema/task"5xsi... 查看详情
从timer到quartz实现动态管理定时任务(代码片段)
...定时任务线程池底层的数据结构都是基于小顶堆，而quartz是基于时间轮算法。1.1：小顶堆小顶堆实际上是一个完全二叉树，并且满足：Key[i]<=key[2i+1]&&Key[i]<= 查看详情
定时任务框架选型quartz/xxl
...定时任务框架进行简单说明。github地址：https://github.com/quartz-scheduler/quartz可以查看jar包的依赖情况如下：最终编译后的位置：WEB-INF/classes/quartz.properties下面是一个最基本的配置项内容：其中此配置创建的调度器有以下特点:任务... 查看详情
quartz+springboot实现动态管理定时任务
项目实践过程中碰到一个动态管理定时任务的需求：针对每个人员进行信息的定时更新，具体更新时间可随时调整、启动、暂定等。思路将每个人员信息的定时配置保存到数据库中，这样实现了任务的动态展示和管理。任务的每... 查看详情
关于quartz对定时任务的管理
请问有谁知道Quartz有没有Web页面的管理应用，可以灵活控制定时任务的起停和执行周期，官方的最好，多谢！我曾经在其他网站上看到那些管理定时任务的页面，而且好像不是个人用的页面，简直和企业应用差不多……我已经找... 查看详情
springboot集成quartz动态定时任务
...job()System.out.println("每五秒执行一次");为什么要使用Quartz多任务情况下，quartz更容易管理，可以实现动态配置执行时间表达式：表达式示例：集成Quartz如何搭建springboot就不再细说，官网和网上的教程很多... 查看详情
quartz深入浅出
什么是QuartzQuartz是一个开源的作业调度框架,由java编写,在.NET平台为Quartz.Net,通过Quart可以快速完成任务调度的工作.Quartz能干什么/应用场景如网页游戏中挂机自动修炼如8个小时,人物相关数值进行成长,当使用某道具后,时间减少到4... 查看详情
任务调度框架quartz一文读懂(代码片段)
1、Quartz简介Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer，Quartz增加了很多功能：持久性作业-就是保持调度定时的... 查看详情
任务调度框架quartz一文读懂(代码片段)
1、Quartz简介Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer，Quartz增加了很多功能：持久性作业-就是保持调度定时的... 查看详情
springboot整合quartz定时任务管理springboot系列18(代码片段)
...者学习SpringBooot项目开发与SpringCloud微服务系列项目开发Quartz是由Java语言编写，是OpenSymphony开源组织在Jobscheduling领域的项目。1项目信息首先是在项目的pom.xml文件中添加依赖如下<!--定时任务--><!--https://mvnrepository.com/arti... 查看详情
quartz3.0定时任务学习之异步调度器
前言Quartz3与Quartz2的主要区别有两点：1，Quartz3将它的资源类库拆的更细了，比如，想使用Quartz3开发，最少要引用Quartz，Quartz.Jobs，Quartz.Plugins这三个类库。2，Quartz3整体上使用的是异步创建实例，所以我们使用时就必须要async，aw... 查看详情
定时调度框架quartz可以定义单个触发器多个任务吗
...个触发器只能单个任务，单个任务可以多个触发器触发。Quartz是一个用Java编写的任务调度框架，任务调度是什么，举例说明：比如需要在每个星期四下午三点时候发周报，我们需要一个系统在两点半的时候给一个发周报的提醒... 查看详情
使用quartz框架集成spring，动态配置定时任务（个人思考）(代码片段)
前言最近遇到这样一个需求，需要开发一个类似若依的任务管理控制面板。核心内容是让用户可以动态的去进行对任务的增、删、改、查操作。实现方式有很多种下面先来简单列举一下可实现这个需求的技术。使用Spring为我... 查看详情