Springcloud项目集成Quartz定时任务框架，实现批处理功能
一、Quartz简介
主要做定时任务，即：在指定时间点或时间段，执行某项任务，可设置执行次数、时间间隔等。
二、Springcloud简介
对比传统的、庞大的、复杂的、以ssm或ssh为框架的web项目而言，springcloud显得格外轻巧，不错乱，易管理，至少模块清晰，功能明确。
三、Springcloud集成quartz
就个人理解，quartz可集成到某个功能模块，也可以单独做一个服务（功能模块），本文介绍的就是单独作为一个服务进行集成的（未开启集群）。
第一步：在已有的父工程下新建一个子工程
第二步：依赖
第三步：配置
/**
* @Title: MyJobFactory.java
* @Package com.ewp.data.controller.quartz
* @Description: 解决不能spring注入bean的问题
* @author zxj
* @date 2018年2月26日
* @version V1.0
*/
package com.ewp.data.config;
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;
/**
* @ClassName: MyJobFactory
* @Description: 解决不能spring注入bean的问题
* @author zxj
* @date 2018年2月26日
*
*/
@Component
public class MyJobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory capableBeanFactory;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
Object jobInstance = super.createJobInstance(bundle);
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}package com.ewp.data.config;
import java.io.IOException;
import java.util.Properties;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
*
* @ClassName: QuartzConfig
* @Description: 配置任务调度中心（服务启动时启动）
* @author zxj
* @date 2018年2月26日
*
*/
@Configuration
public class QuartzConfig {
@Autowired
private MyJobFactory myFactory; //自定义的factory
@Value("${spring.datasource.url}")
private String url;// 数据源地址
@Value("${spring.datasource.username}")
private String userName;// 用户名
@Value("${spring.datasource.password}")
private String password;// 密码
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
try {
schedulerFactoryBean.setQuartzProperties(quartzProperties());
schedulerFactoryBean.setJobFactory(myFactory); //指向自建的调度工厂，用于解决方法类无法注入的问题
} catch (IOException e) {
e.printStackTrace();
}
return schedulerFactoryBean;
}
@Bean
public Scheduler scheduler() throws IOException, SchedulerException {
Scheduler scheduler = schedulerFactoryBean().getScheduler();
scheduler.start();// 服务启动shi
return scheduler;
}
/**
*
* @Title: quartzProperties
* @Description: 设置quartz属性
* @param @return
* @param @throws IOException 参数
* @return Properties 返回类型
* @throws
*/
public Properties quartzProperties() throws IOException {
Properties prop = new Properties();
prop.put("org.quartz.scheduler.instanceName", "quartzScheduler");// 调度器的实例名
prop.put("org.quartz.scheduler.instanceId", "AUTO");// 实例的标识
prop.put("org.quartz.scheduler.skipUpdateCheck", "true");// 检查quartz是否有版本更新（true 不检查）
prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
prop.put("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");// 表名前缀
prop.put("org.quartz.jobStore.isClustered", "false");// 集群开关
prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");// 线程池的名字
prop.put("org.quartz.threadPool.threadCount", "10");// 指定线程数量
prop.put("org.quartz.threadPool.threadPriority", "5");// 线程优先级（1-10）默认为5
prop.put("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", "true");
prop.put("org.quartz.jobStore.dataSource", "quartzDataSource");
prop.put("org.quartz.dataSource.quartzDataSource.driver", "com.mysql.jdbc.Driver");
prop.put("org.quartz.dataSource.quartzDataSource.URL", url);
prop.put("org.quartz.dataSource.quartzDataSource.user", userName);
prop.put("org.quartz.dataSource.quartzDataSource.password", password);
prop.put("org.quartz.dataSource.quartzDataSource.maxConnections", "50");
return prop;
}
}第四步：建类（任务管理类）
package com.ewp.data.quartz;
import java.io.Serializable;
/**
*
* @ClassName: TaskInfo
* @Description: 管理定时任务
* @author zxj
* @date 2018年2月26日
*
*/
public class TaskInfo implements Serializable{
private static final long serialVersionUID = -8054692082716173379L;
/**
* 增加或修改标识
*/
private int id;
/**
* 任务名称
*/
private String jobName;
/**
* 任务分组
*/
private String jobGroup;
/**
* 任务描述
*/
private String jobDescription;
/**
* 任务状态
*/
private String jobStatus;
/**
* 任务表达式
*/
private String cronExpression;
/**
* 创建时间
*/
private String createTime;
/**
* 间隔时间（毫秒）
*/
private String milliSeconds;
/**
* 重复次数
*/
private String repeatCount;
/**
* 起始时间
*/
private String startDate;
/**
* 终止时间
*/
private String endDate;
/**
* @return the milliSeconds
*/
public String getMilliSeconds() {
return milliSeconds;
}
/**
* @param milliSeconds the milliSeconds to set
*/
public void setMilliSeconds(String milliSeconds) {
this.milliSeconds = milliSeconds;
}
/**
* @return the repeatCount
*/
public String getRepeatCount() {
return repeatCount;
}
/**
* @param repeatCount the repeatCount to set
*/
public void setRepeatCount(String repeatCount) {
this.repeatCount = repeatCount;
}
/**
* @return the startDate
*/
public String getStartDate() {
return startDate;
}
/**
* @param startDate the startDate to set
*/
public void setStartDate(String startDate) {
this.startDate = startDate;
}
/**
* @return the endDate
*/
public String getEndDate() {
return endDate;
}
/**
* @param endDate the endDate to set
*/
public void setEndDate(String endDate) {
this.endDate = endDate;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getJobDescription() {
return jobDescription;
}
public void setJobDescription(String jobDescription) {
this.jobDescription = jobDescription;
}
public String getJobStatus() {
return jobStatus;
}
public void setJobStatus(String jobStatus) {
this.jobStatus = jobStatus;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public String getCreateTime() {
return createTime;
}
public void setCreateTime(String createTime) {
this.createTime = createTime;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}第五步：写方法（任务处理方法）
package com.ewp.data.service;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import org.apache.commons.lang3.time.DateFormatUtils;
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.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ewp.data.quartz.TaskInfo;
import com.ewp.data.quartz.exception.ServiceException;
import com.ewp.data.util.DateUtil;
/**
*
* @ClassName: TaskService
* @Description: 任务处理类
* @author zxj
* @date 2018年2月26日
*
*/
@Service
public class TaskService {
private static final Logger LOGGER = LoggerFactory.getLogger(TaskService.class);
@Autowired
private Scheduler scheduler;
/**
*
* @Title: list
* @Description: 任务列表
* @param @return 参数
* @return List 返回类型
* @throws
*/
public List queryJobList() {
LOGGER.info("TaskService--data-s-->queryJobList()");
List list = new ArrayList<>();
try {
for (String groupJob : scheduler.getJobGroupNames()) {
for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher. groupEquals(groupJob))) {
List triggers = scheduler.getTriggersOfJob(jobKey);
for (Trigger trigger : triggers) {
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
String cronExpression = "";
String createTime = "";
String milliSeconds = "";
String repeatCount = "";
String startDate = "";
String endDate = "";
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
cronExpression = cronTrigger.getCronExpression();
createTime = cronTrigger.getDescription();
} else if (trigger instanceof SimpleTrigger) {
SimpleTrigger simpleTrigger = (SimpleTrigger) trigger;
milliSeconds = simpleTrigger.getRepeatInterval()+ "";
repeatCount = simpleTrigger.getRepeatCount() + "";
startDate = DateUtil.getDateStr(
simpleTrigger.getStartTime(),
DateUtil.FORMAT_HOUR_DATE_TIME);
endDate = DateUtil.getDateStr(simpleTrigger.getEndTime(),DateUtil.FORMAT_HOUR_DATE_TIME);
}
TaskInfo info = new TaskInfo();
info.setJobName(jobKey.getName());
info.setJobGroup(jobKey.getGroup());
info.setJobDescription(jobDetail.getDescription());
info.setJobStatus(triggerState.name());
info.setCronExpression(cronExpression);
info.setCreateTime(createTime);
info.setRepeatCount(repeatCount);
info.setStartDate(startDate);
info.setMilliSeconds(milliSeconds);
info.setEndDate(endDate);
list.add(info);
}
}
}
LOGGER.info("任务的数量为：---------------->" + list.size());
} catch (SchedulerException e) {
LOGGER.info("查询任务失败，原因是：------------------>" + e.getMessage());
e.printStackTrace();
}
return list;
}
/**
*
* @Title: setSimpleTrigger
* @Description: 简单调度
* @param @param inputMap
* @param @return 参数
* @return Boolean 返回类型
* @throws
*/
@SuppressWarnings({ "unchecked" })
public void setSimpleTriggerJob(TaskInfo info) {
LOGGER.info("TaskService--data-s-->setSimpleTriggerJob()" + info);
String jobName = info.getJobName();
String jobGroup = info.getJobGroup();
String jobDescription = info.getJobDescription();
Long milliSeconds = Long.parseLong(info.getMilliSeconds());
Integer repeatCount = Integer.parseInt(info.getRepeatCount());
Date startDate = DateUtil.parseDate(info.getStartDate());
Date endDate = DateUtil.parseDate(info.getEndDate());
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);// 触发器的key值
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);// job的key值
if (checkExists(jobName, jobGroup)) {
LOGGER.info(
"===> AddJob fail, job already exist, jobGroup:{}, jobName:{}",
jobGroup, jobName);
throw new ServiceException(String.format(
"Job已经存在, jobName:{%s},jobGroup:{%s}", jobName,
jobGroup));
}
/* 简单调度 */
SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder
.newTrigger()
.withIdentity(triggerKey)
.startAt(startDate)
.withSchedule(
SimpleScheduleBuilder.simpleSchedule()
.withIntervalInMilliseconds(milliSeconds)
.withRepeatCount(repeatCount))
.endAt(endDate).build();
Class clazz = (Class) Class
.forName(jobName);
JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobKey)
.withDescription(jobDescription).build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException | ClassNotFoundException e) {
LOGGER.info("任务添加失败！--->简单调度" + e.getMessage());
throw new ServiceException("任务添加失败！--->简单调度");
}
}
/**
*
* @Title: addJob
* @Description: 保存定时任务
* @param @param info 参数
* @return void 返回类型
* @throws
*/
@SuppressWarnings("unchecked")
public void addJob(TaskInfo info) {
LOGGER.info("TaskService--data-s-->addJob()" + info);
String jobName = info.getJobName(), jobGroup = info.getJobGroup(), cronExpression = info
.getCronExpression(), jobDescription = info.getJobDescription(), createTime = DateFormatUtils
.format(new Date(), "yyyy-MM-dd HH:mm:ss");
try {
if (checkExists(jobName, jobGroup)) {
LOGGER.info(
"===> AddJob fail, job already exist, jobGroup:{}, jobName:{}",
jobGroup, jobName);
throw new ServiceException(String.format(
"Job已经存在, jobName:{%s},jobGroup:{%s}", jobName,
jobGroup));
}
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
CronScheduleBuilder schedBuilder = CronScheduleBuilder
.cronSchedule(cronExpression)
.withMisfireHandlingInstructionDoNothing();
CronTrigger trigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey).withDescription(createTime)
.withSchedule(schedBuilder).build();
Class clazz = (Class) Class
.forName(jobName);
JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobKey)
.withDescription(jobDescription).build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException | ClassNotFoundException e) {
LOGGER.info("保存定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
throw new ServiceException("类名不存在或执行表达式错误");
}
}
/**
*
* @Title: edit
* @Description: 修改定时任务
* @param @param info 参数
* @return void 返回类型
* @throws
*/
public void editJob(TaskInfo info) {
LOGGER.info("TaskService--data-s-->editJob()" + info);
String jobName = info.getJobName(), jobGroup = info.getJobGroup(), cronExpression = info
.getCronExpression(), jobDescription = info.getJobDescription(), createTime = DateFormatUtils
.format(new Date(), "yyyy-MM-dd HH:mm:ss");
try {
if (!checkExists(jobName, jobGroup)) {
throw new ServiceException(
String.format("Job不存在, jobName:{%s},jobGroup:{%s}",
jobName, jobGroup));
}
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
JobKey jobKey = new JobKey(jobName, jobGroup);
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
.cronSchedule(cronExpression)
.withMisfireHandlingInstructionDoNothing();
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
.withIdentity(triggerKey).withDescription(createTime)
.withSchedule(cronScheduleBuilder).build();
JobDetail jobDetail = scheduler.getJobDetail(jobKey);
jobDetail.getJobBuilder().withDescription(jobDescription);
HashSet triggerSet = new HashSet<>();
triggerSet.add(cronTrigger);
scheduler.scheduleJob(jobDetail, triggerSet, true);
} catch (SchedulerException e) {
LOGGER.info("修改定时任务-->类名不存在或执行表达式错误--->复杂调度" + e.getMessage());
throw new ServiceException("类名不存在或执行表达式错误");
}
}
/**
*
* @Title: delete
* @Description: 删除定时任务
* @param @param jobName
* @param @param jobGroup 参数
* @return void 返回类型
* @throws
*/
public void deleteJob(String jobName, String jobGroup) {
LOGGER.info("TaskService--data-s-->deleteJob()--jobName:" + jobName
+ "jobGroup:" + jobGroup);
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (checkExists(jobName, jobGroup)) {
scheduler.pauseTrigger(triggerKey);
scheduler.unscheduleJob(triggerKey);
LOGGER.info("===> delete, triggerKey:{}", triggerKey);
}
} catch (SchedulerException e) {
LOGGER.info("删除定时任务-->复杂调度" + e.getMessage());
throw new ServiceException(e.getMessage());
}
}
/**
*
* @Title: pause
* @Description: 暂停定时任务
* @param @param jobName
* @param @param jobGroup 参数
* @return void 返回类型
* @throws
*/
public void pauseJob(String jobName, String jobGroup) {
LOGGER.info("TaskService--data-s-->pauseJob()--jobName:" + jobName
+ "jobGroup:" + jobGroup);
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (checkExists(jobName, jobGroup)) {
scheduler.pauseTrigger(triggerKey);
LOGGER.info("===> Pause success, triggerKey:{}", triggerKey);
}
} catch (SchedulerException e) {
LOGGER.info("暂停定时任务-->复杂调度" + e.getMessage());
throw new ServiceException(e.getMessage());
}
}
/**
*
* @Title: resume
* @Description: 恢复暂停任务
* @param @param jobName
* @param @param jobGroup 参数
* @return void 返回类型
* @throws
*/
public void resumeJob(String jobName, String jobGroup) {
LOGGER.info("TaskService--data-s-->resumeJob()--jobName:" + jobName
+ "jobGroup:" + jobGroup);
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
try {
if (checkExists(jobName, jobGroup)) {
scheduler.resumeTrigger(triggerKey);
LOGGER.info("===> Resume success, triggerKey:{}", triggerKey);
}
} catch (SchedulerException e) {
LOGGER.info("重新开始任务-->复杂调度" + e.getMessage());
e.printStackTrace();
}
}
/**
*
* @Title: checkExists
* @Description: 验证任务是否存在
* @param @param jobName
* @param @param jobGroup
* @param @return
* @param @throws SchedulerException 参数
* @return boolean 返回类型
* @throws
*/
private boolean checkExists(String jobName, String jobGroup)
throws SchedulerException {
LOGGER.info("TaskService--data-s-->checkExists()--jobName:" + jobName
+ "jobGroup:" + jobGroup);
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
return scheduler.checkExists(triggerKey);
}
} 第六步：执行脚本
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)
);
第七步：编写自定义任务（需实现Job接口）
/**
* @Title: ReportMailBatch.java
* @Package com.ewp.data.batch
* @Description: 邮件汇报批
* @author zxj
* @date 2018年2月26日
* @version V1.0
*/
package com.ewp.data.batch;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.ewp.data.service.ReportMailService;
/**
* @ClassName: ReportMailBatch
* @Description: 邮件汇报批
* @author zxj
* @date 2018年2月26日
*
*/
@Component
public class ReportMailBatch implements Job{
private static final Logger log = LoggerFactory.getLogger(ReportMailBatch.class);
@Autowired
private ReportMailService service;
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
log.info("ReportMailBatch--data-c->execute()");
service.sendReportMail();// 可换成自己业务逻辑
log.info("--本次邮件汇报批处理结束--");
}
}第八步：创建任务处理controller注入TaskService，将第七步编写的任务加入调度器，由线程调用执行。