Quartz持久化和RAM兩種使用方式，Job實現注入service，execute方法傳入執行參數

A、項目中引入相關依賴

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

　　

我使用的項目是Springboot，因此這里我可以使用插件，如果你使用的單獨的項目你可以這么配置：

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

　　

查詢依賴的maven倉庫地址為：http://mvnrepository.com/

 

B、進行相關配置操作

 

配置文件 ：quartz.properties

# 固定前綴org.quartz
# 主要分為scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName=DefaultQuartzScheduler
org.quartz.scheduler.rmi.export=false
org.quartz.scheduler.rmi.proxy=false
org.quartz.scheduler.wrapJobExecutionInUserTransaction=false

# 實例化ThreadPool時，使用的線程類為SimpleThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority將以setter的形式注入ThreadPool實例
# 並發個數
org.quartz.threadPool.threadCount=5
# 優先級
org.quartz.threadPool.threadPriority=5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

org.quartz.jobStore.misfireThreshold=5000

# 默認存儲在內存中(不需要配置 可以在源碼中的properties中看到這個配置)
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

# ——————————————————————————————上面展示的是非持久的配置————————————————————————————————————————————————————

　　

使用配置：

package com.meimei.quartz_demo.config;

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 licunzhi
 * @desc quartz configuration(we can also use xml, but springboot recommend to use annotation @configuration to config)
 * @date 2018-09-05
 */
@Configuration
public class QuartzConfiguration {

    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的屬性被讀取並注入后再初始化對象
        propertiesFactoryBean.afterPropertiesSet();
        Properties properties = propertiesFactoryBean.getObject();
        factory.setQuartzProperties(properties);
        return factory;
    }

    /*
     * quartz初始化監聽器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /*
     * 通過SchedulerFactoryBean獲取Scheduler的實例
     */
    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

}

　　

編寫簡單的JOB類准備使用

package com.meimei.quartz_demo.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public class SampleJob implements Job {

    public SampleJob() {
    }

    public void execute(JobExecutionContext context) {
        System.out.println("執行方法。。。。。" + id);
    }
}

　　

啟動類配置（注意使用注解@EnableScheduling）

package com.meimei.quartz_demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableScheduling//開啟定時任務功能
public class QuartzDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(QuartzDemoApplication.class, args);
    }
}

　　

C、如何使用

package com.meimei.quartz_demo.api;

import com.meimei.quartz_demo.job.SampleJob;
import org.apache.juli.logging.Log;
import org.apache.juli.logging.LogFactory;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Set;

/**
 * @author licunzhi
 * @desc 方便調用這里全部操作為get操作
 * @date 2018-09-07
 */
@RestController
@RequestMapping("/job")
public class JobController {

    private static final Log LOGGER = LogFactory.getLog(JobController.class);

    @Autowired
    @Qualifier(value = "Scheduler")
    private Scheduler scheduler;

    //創建一個新的job任務
    @GetMapping("/add/{jobName}")
    public void addJob(@PathVariable(value = "jobName") String jobName) {
        String groupName = "group_one"; //定義job所在組名稱
        String cronExpression = "0 * * ? * * *";//執行時間表達式
        try {
            //啟動任務調度器，准備添加任務相關信息操作
            scheduler.start();

            //構建一個新的任務規范，執行特定任務，任務執行的時間
            JobDetail jobDetail = JobBuilder
                            .newJob(SampleJob.class).withIdentity(jobName, groupName).build();
            //創建corn表達式，創建執行任務的時間規范
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            //創建一個觸發器，加入上面創建的時間規范
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
                            .withSchedule(scheduleBuilder).build();

            //把執行的job任務和創建時間trigger綁定一起
            scheduler.scheduleJob(jobDetail, trigger);

        } catch (SchedulerException e) {
            LOGGER.info("scheduler start or shutdown error ...");
        }

    }

    //查詢所有的任務
    @GetMapping("/search")
    public String searchJob() throws SchedulerException {
        String groupName = "group_one"; //定義job所在組名稱
        Set<JobKey> jobKeys = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName));
        StringBuilder message = new StringBuilder();
        for (JobKey jobKey : jobKeys) {
            message.append(jobKey.getName() + "----------------" + jobKey.getGroup() + "\n");
        }
        return message.toString();
    }

    @GetMapping("/pause/{jobName}")
    public String pauseJob(@PathVariable(value = "jobName") String jobName) throws SchedulerException {
        String groupName = "group_one"; //定義job所在組名稱
        scheduler.pauseJob(JobKey.jobKey(jobName, groupName));
        return "success";
    }

    @GetMapping("/recover/{jobName}")
    public String recoverJob(@PathVariable(value = "jobName") String jobName) throws SchedulerException {
        String groupName = "group_one"; //定義job所在組名稱
        scheduler.resumeJob(JobKey.jobKey(jobName, groupName));
        return "success";
    }

    @GetMapping("/delete/{jobName}")
    public String deleteJob(@PathVariable(value = "jobName") String jobName) throws SchedulerException {
        String groupName = "group_one"; //定義job所在組名稱
        scheduler.deleteJob(JobKey.jobKey(jobName, groupName));
        return "success";
    }

    @GetMapping("/update/{jobName}")
    public String updateJob(@PathVariable(value = "jobName") String jobName) throws SchedulerException {
        String groupName = "group_one"; //定義job所在組名稱
        String cronExpression = "* * * ? * * *";//執行時間表達式
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, groupName);

            //創建corn表達式，創建執行任務的時間規范
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            //獲取trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            //把執行的job任務和創建時間trigger綁定一起
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            LOGGER.info("scheduler start or shutdown error ...");
        }

        return "success";

    }
}

　　

備注：上面的方法中更沒有在job方法中的默認執行操作傳入參數，如果你需要傳入指定的參數可以使用下面的代碼

//創建一個新的job任務
    @GetMapping("/add/{jobName}")
    public void addJob(@PathVariable(value = "jobName") String jobName) {
        String groupName = "group_one"; //定義job所在組名稱
        String cronExpression = "0 * * ? * * *";//執行時間表達式
        try {
            //啟動任務調度器，准備添加任務相關信息操作
            scheduler.start();

            //構建一個新的任務規范，執行特定任務，任務執行的時間
            JobDetail jobDetail = JobBuilder
                            .newJob(SampleJob.class).withIdentity(jobName, groupName).build();
            //執行的任務中傳入參數------------------------------
            jobDetail.getJobDataMap().put("sakura", "sakura");
            //------------------------------------------------
            //創建corn表達式，創建執行任務的時間規范
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            //創建一個觸發器，加入上面創建的時間規范
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, groupName)
                            .withSchedule(scheduleBuilder).build();

            //把執行的job任務和創建時間trigger綁定一起
            scheduler.scheduleJob(jobDetail, trigger);

        } catch (SchedulerException e) {
            LOGGER.info("scheduler start or shutdown error ...");
        }

    }

　　

在job獲取設置的參數

package com.meimei.quartz_demo.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public class SampleJob implements Job {

    public SampleJob() {
    }

    public void execute(JobExecutionContext context) {
        String id = context.getJobDetail().getJobDataMap().get("sakura").toString();
        System.out.println("執行方法。。。。。" + id);
    }
}

　　

 

D、如果想在job中注入指定的service，從而實現執行指定的service方法如何做

a 自定義個factory

package com.meimei.quartz_demo.factory;

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;

/**
 * @author licunzhi
 * @desc 自定義工廠類
 * @date 2018-09-09
 */
@Component
public class SchedulerFactory extends AdaptableJobFactory {

    //spring bean 對象管理工廠
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //調用父類的方法
        Object jobInstance = super.createJobInstance(bundle);
        //自動注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

　　

b 設置自定義工廠類為quartz的factorybean（有關自定義的factorybean后面會單獨較為淺的源碼層分析一篇博客）

package com.meimei.quartz_demo.config;

import com.meimei.quartz_demo.factory.SchedulerFactory;
import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
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 licunzhi
 * @desc quartz configuration(we can also use xml, but springboot recommend to use annotation @configuration to config)
 * @date 2018-09-05
 */
@Configuration
public class QuartzConfiguration {

    // 注入service需要配置工廠類
    @Autowired
    private SchedulerFactory schedulerFactory;

    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        // 注入service需要配置工廠類
        factory.setJobFactory(schedulerFactory);
        // 注入service需要配置工廠類

        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的屬性被讀取並注入后再初始化對象
        propertiesFactoryBean.afterPropertiesSet();
        Properties properties = propertiesFactoryBean.getObject();
        factory.setQuartzProperties(properties);
        return factory;
    }

    /*
     * quartz初始化監聽器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /*
     * 通過SchedulerFactoryBean獲取Scheduler的實例
     */
    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

}

　　

c 自定義的job類作為容器初始話的組件對象

package com.meimei.quartz_demo.job;

import com.meimei.quartz_demo.service.ServiceDemo;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class JobOne implements Job {

    @Autowired
    private ServiceDemo serviceDemo;

    public void execute(JobExecutionContext context) {
        System.out.println("執行方法servicedemo中的方法");
        serviceDemo.sakura();
        System.out.println("執行方法servicedemo中的方法");
    }
}

　　

E、持久化的操作怎么做

a 增加下面的配置文件，數據庫鏈接的信息是自己創建的數據庫環境

# —————————————————————下面是持久化的配置，使用時修改配置參數即可(運行腳本放在項目下的scripts，選擇合的數據庫即可)———————————————————————————————————————————

#持久化(需要配置持久化的類型----jdbc和兵馬俑兩種)
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
# 數據庫表名稱前綴
org.quartz.jobStore.tablePrefix=QRTZ_
# 持久化的數據庫名稱
org.quartz.jobStore.dataSource=quartz
# 數據庫驅動類型
org.quartz.dataSource.quartz.driver=com.mysql.jdbc.Driver
# 數據庫鏈接地址
org.quartz.dataSource.quartz.URL=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8
# 用戶名
org.quartz.dataSource.quartz.user=root
# 密碼
org.quartz.dataSource.quartz.password=123
# 最大連接數
org.quartz.dataSource.quartz.maxConnections=10
# 使用持久化配置
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate

　　

b 執行初始化數據庫腳本（這里使用的是tables_mysql_innodb.sql）

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

　　

sql腳本一般都在jar包文件中的doc/TBtablse文件下，如果要是找不到你可以去下載我的項目，里面有各種版本的sql

我的項目腳本所在位置在scripts目錄下

c 操作完成之后，其余的操作和其他的一樣，運行項目即可

 

項目結構說明

​

 

歡迎訪問交流群：589780530 
博主交流：2718272293
郵箱：[e-mail]  [e-mail]
github: https://github.com/licunzhi