【示例】Spring Quartz入门
JAVA 针对定时任务，有 Timer，Scheduler, Quartz 等几种实现方式，其中最常用的应该就是 Quartz 了。
一. Quartz的基本概念
在开始之前，我们必须了解以下的几个基本概念：Job、Trigger、Cron expression、JobStores
1.1 Job
对于任务内容的构建，我们需要创建 Job 的继承类，并实现 execute 方法。
1.2 Trigger
其作用是设置调度策略。Quartz 设计了多种类型的 Trigger，其中最常用的是 SimpleTrigger 和 CronTrigger。
- SimpleTrigger 适用于在某一特定的时间以某一特定时间间隔执行多次。
- CronTrigger 的用途更广，主要适用于基于日历的调度安排。例如：每星期二的 16:38:10 执行，每月一号执行，等等。本文使用的是CronTrigger。
1.3 Cron表达式
由七个字段组成：
Seconds Minutes Hours Day-of-Month Month Day-of-Week Year (Optional field)
例如：创建一个每三小时执行的 CronTrigger，且从每小时的整点开始执行：
/ * * ?
Cron在线生成工具：http://cron.qqe2.com
1.4 JobStores
负责对Quartz的持久化，即将任务调度的相关数据保存在数据库中。这样，在系统重启后，任务的调度状态依然存在系统中。当任务错过了触发时间时，还可以重新触发并执行（需要配置）。
二、新建 Quartz 工程
我们会新建一个 Maven 工程，并在启动Web应用之后运行定时任务。
2.1 新建工程
在 Eclipse 中，新建 Maven 项目并引入 Jar 包
2.2 版本信息
| Java | 1.8 |
| Tomcat | 8.5 |
| Spring | 4.3.3.RELEASE |
| Quartz | 2.2.1 |
2.3 工程结构
2.4 Spring Quartz 的配置
主要是定义了数据源，调度工厂以及定时任务的配置：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.3.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-4.3.xsd"
default-autowire="no" >
<!-- 读取属性文件 -->
<context:property-placeholder location="classpath*:properties/quartz.properties"
ignore-unresolvable="true" />
<!-- 扫描包 -->
<context:component-scan base-package="org.stevexie" />
<!-- 数据源 -->
<bean id="quartzDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>${jdbc.driverclass}</value>
</property>
<property name="url">
<value>${jdbc.url}</value>
</property>
<property name="username">
<value>${jdbc.username}</value>
</property>
<property name="password">
<value>${jdbc.password}</value>
</property>
</bean>
<!-- ======================== 调度工厂开始 ======================== -->
<bean id="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false" autowire="no">
<!-- 设置持久化的数据源 -->
<property name="dataSource">
<ref bean="quartzDataSource" />
</property>
<!-- 设置Quartz的属性 -->
<property name="quartzProperties">
<props>
<!-- 线程池配置 -->
<prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
<!-- 初始化线程数为20 -->
<prop key="org.quartz.threadPool.threadCount">20</prop>
<!-- 设置作业的优先级是5 -->
<prop key="org.quartz.threadPool.threadPriority">5</prop>
<!-- 初始化线程数为20 -->
<prop key="org.quartz.jobStore.misfireThreshold">60000</prop>
<!-- JobStore 配置，通过数据库存储最终调度程序的配置 -->
<prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>
<prop key="org.quartz.jobStore.driverDelegateClass">org.quartz.impl.jdbcjobstore.StdJDBCDelegate</prop>
<!-- 数据表名的前缀设置 -->
<prop key="org.quartz.jobStore.tablePrefix">QRTZ_</prop>
</props>
</property>
<!-- 设置应用初始化之后，延迟30秒再启动scheduler -->
<property name="startupDelay" value="30" />
<property name="applicationContextSchedulerContextKey" value="applicationContext" />
<!-- 设置定时任务随web启动 -->
<property name="autoStartup" value="true" />
<property name="triggers">
<list>
<ref bean="definedInXMLcronTrigger"/>
</list>
</property>
</bean>
<!-- ======================== 调度工厂结束 ======================== -->
<!-- ======================== 定时任务1 开始 ======================== -->
<bean id="definedInXMLJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<!-- 必填项：在此处定义job detail -->
<property name="jobClass" value="org.stevexie.jobdetail.DefinedInXMLJobDetail" />
<!-- 必填项：在此处定义job name -->
<property name="name" value="jobName1"></property>
<!-- 必填项：在此处定义job group name -->
<property name="group" value="jobGroupName1"></property>
<!-- 选填项：设置该job是持久性的 -->
<property name="durability" value="true" />
<!-- 选填项：设置该job是中断后可恢复的 -->
<property name="requestsRecovery" value="true" />
</bean>
<bean id="definedInXMLcronTrigger"
class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<!-- 必填项：在此处定义trigger name -->
<property name="name" value="triggerName1" />
<!-- 必填项：在此处定义trigger group name -->
<property name="group" value="triggerGroupName1" />
<property name="jobDetail" ref="definedInXMLJobDetail" />
<!-- 必填项：在此处定义定时任务时间 -->
<property name="cronExpression" value="0/10 * * * * ? " />
<!-- 选填项：在此处定义市区 -->
<property name="timeZone" ref="timeZone" />
<property name="misfireInstruction" value="1" />
</bean>
<!-- ======================== 定时任务1 结束 ======================== -->
<!-- 时区 -->
<bean id="timeZone" class="java.util.TimeZone" factory-method="getTimeZone">
<constructor-arg value="GMT+08:00" />
</bean>
</beans>
2.5 定时任务
实现两个定时任务：一个是在应用初始化的时候启动；另一个是通过运行代码中的main方法来实现对定时任务的增删改。
2.5.1 定时任务1
随着应用的启动而实例化，每10秒打印一条语句：
package org.stevexie.jobdetail;
import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.stevexie.util.DateUtil;
public class DefinedInXMLJobDetail extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) {
System.out.println("执行在XML中定义好的定时任务，当前时间是：" +
DateUtil.currentDatetime());
}
}
2.5.2 定时任务2
与定时任务1的内容基本一致，但主要是在 JAVA 代码中被实例化并实现定时任务的增删改。
package org.stevexie.jobdetail;
import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.stevexie.util.DateUtil;
public class DefinedInCodeJobDetail extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext context) {
System.out.println("执行在代码中添加的定时任务，当前时间是：" +
DateUtil.currentDatetime());
}
}
2.6 定时任务的增删改工具类
package org.stevexie.util;
import java.text.ParseException;
import javax.annotation.Resource;
import org.apache.commons.lang.StringUtils;
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.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.stevexie.jobdetail.DefinedInCodeJobDetail;
import org.stevexie.jobdetail.DefinedInXMLJobDetail;
@Component("quartzUtil")
public class QuartzUtil {
@Resource(name="quartzScheduler")
private Scheduler scheduler;
private static String JOB_GROUP_NAME = "ddlib";
private static String TRIGGER_GROUP_NAME = "ddlibTrigger";
/**
* 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
* @param job Job任务类实例
* @param jobName job名字(请保证唯一性)
* @param cronExpression cron时间表达式
* @throws SchedulerException
*/
public void addJob(String jobName, Job job, String cronExpression)
throws SchedulerException, ParseException{
addJob(job, jobName, null, jobName, null, cronExpression, 5);
}
/**
* 开始一个simpleSchedule()调度(创建一个新的定时任务)
* @param job Job任务类实例
* @param jobName job名字(请保证唯一性)
* @param jobGroupName job组名(请保证唯一性)
* @param cronExpression cron时间表达式
* @param triggerName trigger名字(请保证唯一性)
* @param triggerGroupName triggerjob组名(请保证唯一性)
* @throws SchedulerException
*/
public void addJob(Job job, String jobName, String jobGroupName,
String triggerName, String triggerGroupName,
String cronExpression, int triggerPriority)
throws SchedulerException {
if(StringUtils.isEmpty(jobGroupName)){
jobGroupName = JOB_GROUP_NAME;
}
if(StringUtils.isEmpty(triggerGroupName)){
triggerGroupName = TRIGGER_GROUP_NAME;
}
// 1、创建一个JobDetail实例，指定Quartz
JobDetail jobDetail = JobBuilder.newJob(job.getClass())
// 任务执行类
.withIdentity(jobName, jobGroupName)
// 任务名，任务组
.build();
// 2、创建Trigger
// 优先级默认是5，数字越高优先级越高
Trigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerName, triggerGroupName).startNow()
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.withPriority(triggerPriority)
.build();
// 3、移除job，避免因为job的重复添加导致错误
this.removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
// 4、调度执行
try {
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
// 4、启动
this.startSchedule();
}
/**
* 开始任务
* @throws SchedulerException
*/
public void startSchedule() throws SchedulerException {
try {
if(scheduler.isShutdown()){
scheduler.resumeAll();
} else {
scheduler.start();
}
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
/**
* 暂停Job
* @param name job名字
* @param group job组名
* @throws SchedulerException
*/
public void pauseJob(String jobName, String jobGroupName)
throws SchedulerException {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
scheduler.pauseJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
/**
* 恢复Job
* @param name job名字
* @param group job组名
* @throws SchedulerException
*/
public void resumeJob(String jobName, String jobGroupName)
throws SchedulerException {
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
try {
scheduler.resumeJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
/**
* 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
*/
public void modifyJobTime(String jobName, String cronExpression)
throws SchedulerException, ParseException {
rescheduleJob(jobName, null, cronExpression);
}
/**
* 更新任务表达式
* @param triggerName trigger名字
* @param triggerGroupName trigger组名
* @param newCronExpression cron时间表达式
* @throws SchedulerException
*/
public void rescheduleJob( String triggerName,
String triggerGroupName,
String newCronExpression)
throws SchedulerException {
if(StringUtils.isBlank(triggerGroupName)) {
triggerGroupName = TRIGGER_GROUP_NAME;
}
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
// 获取trigger
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
// 按新的cronExpression表达式重新构建trigger
trigger = trigger
.getTriggerBuilder()
.withIdentity(triggerKey)
.withSchedule(CronScheduleBuilder.cronSchedule(newCronExpression))
.build();
// 按新的trigger重新设置job执行
try {
scheduler.rescheduleJob(triggerKey, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
throw e;
}
}
/** 移除一个任务和触发器(使用默认的任务组名，触发器名，触发器组名) */
public void removeJob(String jobName,String triggerName)
throws SchedulerException{
removeJob(jobName, null, triggerName, null);
}
/** 移除一个任务和触发器 */
public void removeJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName)
throws SchedulerException {
if(StringUtils.isEmpty(jobGroupName)) {
jobGroupName = JOB_GROUP_NAME;
}
if(StringUtils.isEmpty(triggerGroupName)) {
triggerGroupName = TRIGGER_GROUP_NAME;
}
JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
scheduler.pauseTrigger(triggerKey); // 停止触发器
scheduler.unscheduleJob(triggerKey); // 移除触发器
scheduler.deleteJob(jobKey); // 删除任务
}
public static void main(String[] args) {
ApplicationContext context = null;
context = new ClassPathXmlApplicationContext("classpath:spring/spring-quartz.xml");
QuartzUtil quartzUtil = (QuartzUtil) context.getBean("quartzUtil");
// 删除定时器
try {
quartzUtil.removeJob( "jobName",
"jobGroupName",
"triggerName",
"triggerGroupName");
quartzUtil.removeJob( "jobName1",
"jobGroupName",
"triggerName",
"triggerGroupName");
quartzUtil.removeJob( "jobName2",
"jobGroupName",
"triggerName",
"triggerGroupName");
} catch (SchedulerException e1) {
e1.printStackTrace();
}
// 添加定时器
try {
quartzUtil.addJob(new DefinedInXMLJobDetail(),
"jobName1", "jobGroupName1",
"triggerName1", "triggerGroupName1",
"0/20 * * * * ? ", 5);
quartzUtil.addJob(new DefinedInCodeJobDetail(),
"jobName2", "jobGroupName2",
"triggerName2", "triggerGroupName2",
"0/10 * * * * ? ", 5);
} catch (SchedulerException e2) {
e2.printStackTrace();
}
// 修改定时器
try {
quartzUtil.rescheduleJob( "triggerName1", "triggerGroupName1", "0/30 * * * * ? ");
} catch (SchedulerException e1) {
e1.printStackTrace();
}
try {
Thread.sleep(100*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2.7. Quartz的执行脚本
需要在数据库中建一些Quartz的表。
#
# Quartz seems -bin.jar
#
# PLEASE consider using mysql with innodb tables to avoid locking issues
#
# In your Quartz properties file, you'll need to set
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
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(200) NOT NULL,
JOB_GROUP VARCHAR(200) 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)
);
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) 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(200) 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)
);
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),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
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(200) 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)
);
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) 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)
);
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 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)
);
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)
);
CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);
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 INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);
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)
);
CREATE TABLE QRTZ_LOCKS
(
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);
commit;
三、 运行效果
3.1 初次运行web项目
每十秒钟会执行一次定时任务。该任务是在XML中被定义的，随着Web应用的启动而实例化。
3.2 修改定时任务的属性
停止 Web 项目，运行 QuartzUtil.java。结果显示，目前有两个定时任务正在运行：
- 定时任务一，每隔30秒运行一次，并打印：执行在XML中定义好的定时任务...
- 定时任务二，每隔10秒运行一次，并打印：执行在代码中添加的定时任务...
3.3 再次运行 Web 项目，确认修改结果
执行结果与 3.2 一致，说明定时任务的触发时间已经成功被修改了：
3.4 在数据库中，查询定时器信息，确认该调度程序已被成功地持久化
【示例】Spring Quartz入门的更多相关文章
- Spring MVC 入门教程示例 （一）
今天和大家分享下 Spring MVC 入门教程 首先还是从 HelloWorld web 工程开始 -------------------------- 1.首先创建一个Maven Web工程 ...
- 【转】spring MVC入门示例(hello world demo)
部分内容来自网络:<第二章 Spring MVC入门 —— 跟开涛学SpringMVC > 1. Spring MVC介绍 Spring Web MVC是一种基于Java的实现了Web M ...
- Spring Boot 入门（九）：集成Quartz定时任务
本片文章续<Spring Boot 入门(八):集成RabbitMQ消息队列>,关于Quartz定时任务请参考<Quartz的基本使用之入门(2.3.0版本)> spring ...
- JAVAEE——BOS物流项目13：Quartz入门案例、核心概念、cron 表达式的格式（了解）
1.quartz入门案例 本入门案例基于spring和quartz整合完成. 第一步:创建maven工程,导入spring和quartz相关依赖 第二步:创建任务类 第三步:在spring配置文件中配 ...
- Spring快速入门
什么是Spring Spring是分层的JavaSE/EE full-stack(一站式) 轻量级开源框架 分层 SUN提供的EE的三层结构:web层.业务层.数据访问层(持久层/集成层) Strut ...
- Quartz 入门详解
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用.Quartz可以用来创建简单或为运行十个,百个, ...
- atititt.java定时任务框架选型Spring Quartz 注解总结
atititt.java定时任务框架选型Spring Quartz 总结 1. .Spring Quartz (ati recomm) 1 2. Spring Quartz具体配置 2 2.1. 增 ...
- 161103、Spring Boot 入门
Spring Boot 入门 spring Boot是Spring社区较新的一个项目.该项目的目的是帮助开发者更容易的创建基于Spring的应用程序和服务,让更多人的人更快的对Spring进行入门体验 ...
- Quartz入门指南
Quartz入门指南 看到官网的教程对于新手来说不够全面和连贯,因此结合自己的使用过程写下这个入门指南,用以解惑.本文基于Quartz2.2.2版本.请注意,本文为了易于上手,省略了许多重要的概念,建 ...
随机推荐
- SQLSetStmtAttr
SQLSetStmtAttr 函数定义: Stmt是用来执行SQL语句的句柄,这个函数是用来设置她的属性的 SQLRETURN SQLSetStmtAttr( SQLHSTMT , 这是由游标 ...
- python base64加密文本内容（2）
上面一篇简单进行了base64加密 但安全系数非常低,只需要用网上的在线base64解码就能破解 这里我们可以自己修改一下base64加密后的字符串,在解码的时候只需要先提前将修改的内容还原就可以了 ...
- Python全栈-day14-模块和包
一.模块 1.模块 1)定义 一系列功能的集合体,在Python中py文件就是一个模块 2)模块的类别 a.使用Python编写的py文件 b.已经被编译成共享库或者DLL的C 或者 C++ 扩展 c ...
- C# & ASP.NET Core 入门官方资料汇总
借助给公司实习生培训事宜,整理了一些微软官方的适合新同学入门的资料,这里分享一下: 工具: Visual Studio 2017 Community 版本下载地址:https://www.visual ...
- Tornado安装
Tornado 和现在的主流 Web 服务器框架(包括大多数 Python 的框架)有着明显的区别:它是非阻塞式服务器,而且速度相当快.得利于其 非阻塞的方式和对 epoll 的运用,Tornado ...
- PYQT5学习笔记之各模块介绍
Qtwidgets模块包含创造经典桌面风格的用户界面提供了一套UI元素的类 Qtwidegts下还有以下常用对象,所以一般使用Qtwidegts时会使用面向对象式编程 QApplication: ap ...
- Token：共识的下一个100年，区块链技术是无可阻挡的文明进程
Token:共识的下一个100年,区块链技术是无可阻挡的文明进程.很少有人意识到,区块链的应用——Token可能是近100年来最伟大的制度创新,超越股份制,并将是『债券』之后最重要最主流的交易品种,没 ...
- JS 测试网络速度与网络延迟
一.延迟与网速 通过js加载一张1x1的极小图片,测试出图片加载的所用的时长.如果换一个几百KB的图片,则可心用来计算下载网速 document.write('<input type=" ...
- ORM some
1 -- 增 models.表名(类).objects.create(字段1=值,字段2=值) 查 models.表名(类).objects.get(pk = 3) models.表名(类).obje ...
- GoldenGate 12.3 MA架构介绍系列(3) - 各功能模块介绍
在新版的ogg 12.3 microservice architect中,提供了4个不同的服务模块和命令行模块. Admin Server: 负责连接用户.trandata, checkpoint的添 ...