maven项目集成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;
     }
 }

 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;
     }

 }

第四步：建类（任务管理类）

 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<TaskInfo>    返回类型
      * @throws
      */
     public List<TaskInfo> queryJobList() {
         LOGGER.info("TaskService--data-s-->queryJobList()");
         List<TaskInfo> list = new ArrayList<>();
         try {
         for (String groupJob : scheduler.getJobGroupNames()) {
             for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.<JobKey> groupEquals(groupJob))) {
             List<? extends Trigger> 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<? extends Job> clazz = (Class<? extends Job>) 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<? extends Job> clazz = (Class<? extends Job>) 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<Trigger> 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);
     }

 }

第六步：执行sql脚本

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，将第七步编写的任务加入调度器，由线程调用执行。