java 个人笔记-quartz动态添加多个定时任务

﹏ヽ暗。殇╰゛Y 2022-01-06 03:15 1700阅读 0赞

## 一、简单定时任务 ##

1、启动类添加 @EnableScheduling

@SpringBootApplication
    @EnableScheduling
    public class DemoApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DemoApplication.class, args);
        }
    }

2、设置定时任务（这个是开启服务器直接自动执行）

@Component
    public class TimerTask {
        private long time = new Date().getTime();
    
        @Scheduled(fixedRate = 4000) //上次任务开始后4秒执行
    //    @Scheduled(fixedDelay = 4000) //上次任务结束后4秒执行
    //    @Scheduled(initialDelay = 1000,fixedDelay = 4000) //第一次延迟1秒后执行，之后每隔4秒执行
    //    @Scheduled(cron = "*/5 * * * * *") //corn表达式定义
        public void showCurrentTime(){
            System.out.println("执行时间：" +  (new Date().getTime() - time));
        }
    }

# #

## 二、简介： ##

Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能， 但就其简易形式看，你会发现它易用得简直让人受不了！。简单地创建一个实现org.quartz.Job接口的java类。

在你的Job接口实现类里面，添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表，Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候，Quartz框架将调用你Job实现类（作业类）上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用，Quartz框架将在恰当的时间再次调用它。

1、导入依赖

<dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.3.0</version>
            </dependency>

2、开启定时器

private Scheduler scheduler;
    
        private void setScheduler(){
            try {
                //方法1
                SchedulerFactory sfact = new StdSchedulerFactory();
                scheduler = sfact.getScheduler();
    
                //方法2
    //          DirectSchedulerFactory factory = DirectSchedulerFactory.getInstance();
    //          return (Scheduled) factory.getScheduler();
                scheduler.start();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }

3、添加定时任务

scheduler.scheduleJob(jobDetail, trigger);

*  jobDetail  （1、newJob 需要实现Job 是定时器执行逻辑。2、usingJobData指传入定时任务信息。3、withIdentity任务分组）

JobDetail jobDetail = JobBuilder.newJob(info.getJobClass())
                    .usingJobData(info.getJobMap())
                    .withIdentity(info.getName(), info.getGroup()).build();

4、一个普通定时任务工具类，自己写的

任务类

public class SimpleJob implements Job {
    
        private Runnable runnable;
    
        public Runnable getRunnable() {
            return runnable;
        }
    
        public void setRunnable(Runnable runnable) {
            this.runnable = runnable;
        }
    
        @Override
        public void execute(JobExecutionContext context) throws JobExecutionException {
            runnable.run();
        }
    }

定时信息

public class TaskInfo {
    
        private String name;
    
        private String group;
        /*开始时间*/
        private Date startAT;
        /*结束时间*/
        private Date endAT;
        /*执行次数*/
        private int count;
        /*间隔时间*/
        private long intervalTime;
        /*时间单位*/
        private TimeUnit intervalUnit;
        /*一直循环执行*/
        private boolean forever;
        /*复杂定时器的corn表达式，没有代表普通定时器*/
        private String corn;
        /*定时任务执行类*/
        private Class<? extends Job> jobClass;
        /*定时器内传递的消息*/
        private JobDataMap jobMap;
        /*修改任务*/
        private boolean modify = false;
    
       ....get set
    }

工具类

@Component
    public class SimpleQuartz {
    
        /*调度器*/
        private Scheduler scheduler;
        /*避免名称重复计算器*/
        private AtomicInteger counter = new AtomicInteger();
        /*默认执行任务类，这里没有则必须在调用的时候传入*/
        private Class<? extends Job> jobClass;
        /*默认时间单位（秒）*/
        private TimeUnit defaultTimeUnit = TimeUnit.SECONDS;
        /*定时任务信息*/
        private JobDataMap jobMap = new JobDataMap();
        /*可自定义任务信息*/
        private TaskInfo taskInfo = null;
    
        private final String RUN_MGR = "runnable";
    
        private static final String SIMPLE_NAME = "SimpleQuartz";
        private static final String CORN_NAME = "CornQuartz";
    
        public Scheduler getScheduler() {
            return scheduler;
        }
    
        public SimpleQuartz() {
            setScheduler();
            jobClass = SimpleJob.class;
        }
    
        public SimpleQuartz setTaskInfo(TaskInfo taskInfo){
            this.taskInfo = taskInfo;
            return this;
        }
    
        private void setScheduler() {
            try {
                //方法1
                SchedulerFactory sfact = new StdSchedulerFactory();
                scheduler = sfact.getScheduler();
                scheduler.start();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
    
        /**
         * 关闭
         */
        public boolean shutdown(JobKey key) throws SchedulerException {
            //true表示等待定时任务执行完才关闭
            return scheduler.deleteJob(key);
        }
    
        /**
         * 获取任务状态
         * @param key
         * @return
         * @throws SchedulerException
         */
        public String getJobState(JobKey key) throws SchedulerException {
            TriggerKey triggerKey = new TriggerKey(key.getName(), key.getGroup());
            return scheduler.getTriggerState(triggerKey).name();
        }
    
        /**
         * 暂停所有任务
         */
        public void pauseAllJob() throws SchedulerException {
            scheduler.pauseAll();
        }
    
        /**
         * 恢复所有任务
         * @throws SchedulerException
         */
        public void resumeAllJob() throws SchedulerException {
            scheduler.resumeAll();
        }
    
        /**
         * 暂停任务
         * @throws SchedulerException
         */
        public boolean pauseJob(JobKey jobKey) throws SchedulerException {
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return false;
            }else {
                scheduler.pauseJob(jobKey);
                return true;
            }
        }
    
        /**
         * 恢复某个任务
         * @param jobKey
         * @return
         * @throws SchedulerException
         */
        public boolean resumeJob(JobKey jobKey) throws SchedulerException {
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                return false;
            }else {
                scheduler.resumeJob(jobKey);
                return true;
            }
        }
    
        /**
         * 添加通用定时器
         */
        public JobKey commonTimmer(TaskInfo info) throws SchedulerException {
            if(info.isModify()){
                JobKey jobKey = new JobKey(info.getName(),info.getGroup());
                TriggerKey triggerKey = TriggerKey.triggerKey(info.getName(),info.getGroup());
                if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
                    shutdown(jobKey);
                }
            }
    
            //设置默认参数
            setBaseInfo(info);
            //绑定具体定时任务：执行任务的类、传递信息、名称、组
            JobDetail jobDetail = JobBuilder.newJob(info.getJobClass())
                    .usingJobData(info.getJobMap())
                    .withIdentity(info.getName(), info.getGroup()).build();
    
            Trigger trigger = null;
            if (info.getCorn() == null) {
                //简单定时器
                trigger = TriggerBuilder.newTrigger()
                        .withIdentity(info.getName(), info.getGroup())
                        //定时器开始时间
                        .startAt(info.getStartAT())
                        //定时器结束时间
                        .endAt(info.getEndAT())
                        .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                //任务执行间隔时间
                                .withIntervalInMilliseconds(info.getIntervalTime())
                                //执行次数
                                .withRepeatCount(info.getCount()))
                        .build();
            } else {
                //复杂定时器
                trigger = TriggerBuilder.newTrigger()
                        .withIdentity(info.getName(), info.getGroup())
                        .startAt(info.getStartAT())
                        .endAt(info.getEndAT())
                        .withSchedule(CronScheduleBuilder.cronSchedule(info.getCorn()))
                        .build();
            }
            if (trigger != null) {
                scheduler.scheduleJob(jobDetail, trigger);
            }
            taskInfo = null;
            return jobDetail.getKey();
        }
    
        /**
         * 设置默认参数
         *
         * @param info
         */
        private void setBaseInfo(TaskInfo info) {
            counter.set(counter.get() + 1);
            if (info.isForever()) {
                info.setCount(SimpleTrigger.REPEAT_INDEFINITELY);
            }
            if (info.getStartAT() == null) {
                info.setStartAT(new Date());
            }
            if (info.getIntervalTime() <= 0) {
                info.setIntervalTime(1000);
            }
            if (info.getName() == null) {
                if (info.getCorn() == null) {
                    info.setName(SIMPLE_NAME);
                }else {
                    info.setName(CORN_NAME);
                }
            }
            if (info.getGroup() == null) {
                info.setGroup(String.valueOf(counter));
            }
            if (info.getJobMap() == null) {
                info.setJobMap(new JobDataMap());
            }
    
            TimeUnit timeUnit = info.getIntervalUnit();
            if (timeUnit != null) {
                long intervalTime = info.getIntervalTime();
                info.setIntervalTime(getRealTime(intervalTime, timeUnit));
            }
        }
    
        private long getRealTime(long time, TimeUnit timeUnit) {
            if (timeUnit == TimeUnit.SECONDS) {
                time *= 1000L;
            } else if (timeUnit == TimeUnit.MINUTES) {
                time *= 60000L;
            } else if (timeUnit == TimeUnit.HOURS) {
                time *= 3600000L;
            } else if (timeUnit == TimeUnit.DAYS) {
                time *= 86400000L;
            }
            return time;
        }
    
        /**
         * 倒计时单次任务
         * 延迟5秒执行一次
         */
        public JobKey delayTimmer(long time, TimeUnit timeUnit, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            Date date = new Date();
            date.setTime(date.getTime() + getRealTime(time, timeUnit));
            jobMap.put(RUN_MGR, runnable);
            info.setStartAT(date);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey delayTimmer(long time, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            Date date = new Date();
            date.setTime(date.getTime() + getRealTime(time, defaultTimeUnit));
            jobMap.put(RUN_MGR, runnable);
            info.setStartAT(date);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        /**
         * 倒计时单次任务
         * 延迟到指定时间，执行一次
         */
        public JobKey delayTimmer(Date startDate, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setStartAT(startDate);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(long time, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(time, defaultTimeUnit));
            info.setForever(true);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(long time, TimeUnit timeUnit, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(time, timeUnit));
            info.setForever(true);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(Date startDate, Date endDate, long interval, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(interval, defaultTimeUnit));
            info.setStartAT(startDate);
            info.setEndAT(endDate);
            info.setForever(true);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(Date startDate, Date endDate, long interval, TimeUnit timeUnit, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(interval, timeUnit));
            info.setStartAT(startDate);
            info.setEndAT(endDate);
            info.setForever(true);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(Date startDate, int count, long interval, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(interval, defaultTimeUnit));
            info.setStartAT(startDate);
            info.setCount(count - 1);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        public JobKey intervalTimmer(Date startDate, int count, long interval, TimeUnit timeUnit, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setIntervalTime(getRealTime(interval, timeUnit));
            info.setStartAT(startDate);
            info.setCount(count - 1);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    
        /**
         * 添加复杂定时任务
         * cron可以在线生成
         */
        public JobKey cornTimmer(String corn, Runnable runnable) throws SchedulerException {
            TaskInfo info = new TaskInfo();
            if(taskInfo != null){
                info = taskInfo;
            }
            jobMap.put(RUN_MGR, runnable);
            info.setCorn(corn);
            info.setJobClass(jobClass);
            info.setJobMap(jobMap);
            return commonTimmer(info);
        }
    }

调用实例

@Component
    public class Test {
    
        @Autowired
        private SimpleQuartz simpleQuartz;
    
        /**
         * 延迟执行
         * @throws SchedulerException
         */
        public void test01() throws SchedulerException {
            simpleQuartz.delayTimmer(10,() -> {
                System.out.println("10秒后执行");
            });
            simpleQuartz.delayTimmer(10, TimeUnit.HOURS,() -> {
                System.out.println("10小时后执行");
            });
    
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.HOUR_OF_DAY,2);
            simpleQuartz.delayTimmer(calendar.getTime(),() -> {
                System.out.println("2小时后执行");
            });
        }
    
        /**
         * 循环执行
         * @throws SchedulerException
         */
        public void test02() throws SchedulerException {
            simpleQuartz.intervalTimmer(10,() -> {
                System.out.println("每隔10秒执行");
            });
            simpleQuartz.intervalTimmer(10, TimeUnit.HOURS,() -> {
                System.out.println("每隔10小时执行");
            });
    
            Calendar calendar = Calendar.getInstance();
            calendar.add(Calendar.HOUR_OF_DAY,2);
            Date startTime = calendar.getTime();
            calendar.add(Calendar.HOUR_OF_DAY,2);
            Date endTime = calendar.getTime();
            simpleQuartz.intervalTimmer(startTime,endTime,50,() -> {
                System.out.println("2小时后开始，每隔50秒执行一次，4小时后关闭");
            });
        }
    
        /**
         * corn 定时任务
         * @throws SchedulerException
         */
        public void test03() throws SchedulerException {
            simpleQuartz.cornTimmer("0 0 0/2 * * ? ",() -> {
                System.out.println("每隔2小时执行一次");
            });
        }
    
        /**
         * 详细设置 定时任务
         * @throws SchedulerException
         */
        public void test04() throws SchedulerException {
            TaskInfo taskInfo = new TaskInfo();
            taskInfo.setName("任务1");
            taskInfo.setGroup("组1");
            //这个参数为true  代表修改之前的定时器。。需要name和group 与之前的需要修改的定时器对应。
            //默认false 新增
            taskInfo.setModify(true);
            simpleQuartz.setTaskInfo(taskInfo).cornTimmer("0 0 0/2 * * ? ",() -> {
                System.out.println("每隔2小时执行一次");
            });
        }
    }

以下是配置信息，，同步到数据库（暂时我还未验证，，网上找的，，作为自己临时记录）

默认 springBoot 环境下

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

# 实例化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

package cn.cooplan.quartz;
    
    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;
    
    /**
     * Qartz配置, 搭配quartz.properties文件自定义配置, 该处目的使定时任务持久化
     */
    @Configuration
    public class SchedulerConfig {
    
        /**
         * 读取quartz.properties 文件
         * 将值初始化
         * @return
         */
        @Bean
        public Properties quartzProperties() throws IOException {
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
            propertiesFactoryBean.afterPropertiesSet();
            return propertiesFactoryBean.getObject();
        }
    
        /**
         * 将配置文件的数据加载到SchedulerFactoryBean中
         * @return
         * @throws IOException
         */
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
            SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
            schedulerFactoryBean.setQuartzProperties(quartzProperties());
            return schedulerFactoryBean;
        }
    
        /**
         * 初始化监听器
         * @return
         */
        @Bean
        public QuartzInitializerListener executorListener(){
            return new QuartzInitializerListener();
        }
    
        /**
         * 获得Scheduler 对象
         * @return
         * @throws IOException
         */
        @Bean
        public Scheduler scheduler() throws IOException {
            return schedulerFactoryBean().getScheduler();
        }
    }

1.同步到mysql

<dependency>
                <groupId>com.mchange</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.5.2</version>
            </dependency>

#持久化使用的类
    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/quartz?useUnicode=true&characterEncoding=UTF-8
    org.quartz.dataSource.qzDS.user = root
    org.quartz.dataSource.qzDS.password = root
    org.quartz.dataSource.qzDS.maxConnections = 10

sql信息

1.qrtz_blob_triggers : 以Blob 类型存储的触发器。
    2.qrtz_calendars：存放日历信息， quartz可配置一个日历来指定一个时间范围。
    3.qrtz_cron_triggers：存放cron类型的触发器。
    4.qrtz_fired_triggers：存放已触发的触发器。
    5.qrtz_job_details：存放一个jobDetail信息。
    6.qrtz_job_listeners：job监听器。
    7.qrtz_locks： 存储程序的悲观锁的信息(假如使用了悲观锁)。
    8.qrtz_paused_trigger_graps：存放暂停掉的触发器。
    9.qrtz_scheduler_state：调度器状态。
    10.qrtz_simple_triggers：简单触发器的信息。
    11.qrtz_trigger_listeners：触发器监听器。
    12.qrtz_triggers：触发器的基本信息

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;

2.同步到mongo

<dependency>
                <groupId>com.novemberain</groupId>
                <artifactId>quartz-mongodb</artifactId>
                <version>2.0.0-rc2</version>
            </dependency>

mongo有密码时配置文件如下：
    
    org.quartz.jobStore.class=com.novemberain.quartz.mongodb.MongoDBJobStore
    org.quartz.jobStore.mongoUri=mongodb://用户名:密码@10.10.17.8:27017,10.10.17.9:27017,10.10.17.10:27017/数据库
    org.quartz.jobStore.dbName=数据库
    org.quartz.scheduler.instanceName = MyScheduler
    org.quartz.threadPool.threadCount=3
    org.quartz.jobStore.collectionPrefix=qrtz
    org.quartz.jobStore.misfireThreshold = 1800000
    
    mongo无密码时配置文件如下：
    org.quartz.jobStore.class=com.novemberain.quartz.mongodb.MongoDBJobStore
    org.quartz.jobStore.mongoUri= mongodb://localhost:27020
    org.quartz.jobStore.dbName=quartz
    org.quartz.jobStore.collectionPrefix=qrtz
    org.quartz.threadPool.threadCount=100