SpringCloud 整合 Quartz 支持集群黄绩，支持動(dòng)態(tài)修改 Quartz 執(zhí)行時(shí)間

一、添加 maven 引用包

<dependencies>
    <!-- 訪問數(shù)據(jù)庫模塊 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>

    <!-- web模塊 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- MYSQL -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

    <!-- Jdbc 模塊 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
    </dependency>

    <!-- log4j 日志模塊 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-log4j</artifactId>
    </dependency>

    <!-- quartz 模塊 -->
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
        <version>2.3.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency>

    <!-- druid 線程池模塊 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.3</version>
    </dependency>

二魄缚、添加 3 個(gè)配置文件

   1宝与、src\main\resources\application.yml 文件：

   server:
        port: 8395
   spring:
        application:
            name: microservice-simple-quartz-cluster
        datasource:
            driver-class-name: com.mysql.jdbc.Driver
            url: jdbc:mysql://ip:port/hmilyylimh?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true
            username: username
            password: username
        jpa:
            hibernate:
                ddl-auto: update #ddl-auto:設(shè)為update表示每次都不會(huì)重新建表
                show-sql: true

    2焚廊、src\main\resources\quartz.properties 文件冶匹，配置quartz：

    org.quartz.scheduler.instanceName = quartzScheduler  
    org.quartz.scheduler.instanceId = AUTO  


    org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
    org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    org.quartz.jobStore.tablePrefix = QRTZ_  
    org.quartz.jobStore.isClustered = true  
    org.quartz.jobStore.useProperties = false
    org.quartz.jobStore.clusterCheckinInterval = 20000    


    org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool  
    org.quartz.threadPool.threadCount = 10  
    org.quartz.threadPool.threadPriority = 5  
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

    3、src\main\resources\quartz.xml 文件咆瘟，配置定時(shí)任務(wù)：

    <?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   
           xmlns:p="http://www.springframework.org/schema/p"
           xmlns:aop="http://www.springframework.org/schema/aop" 
           xmlns:context="http://www.springframework.org/schema/context"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
                    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
                    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">


<bean id="testJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <!-- durability 表示任務(wù)完成之后是否依然保留到數(shù)據(jù)庫嚼隘，默認(rèn)false -->
    <property name="durability" value="true" />
    <property name="requestsRecovery" value="true" />
    <property name="jobClass">
        <value>
            com.itmuch.cloud.job.DetailQuartzJobBean
        </value>
    </property>
    <property name="jobDataAsMap">
        <map>
            <entry key="targetObject" value="testScheduleTask" />
            <entry key="targetMethod" value="sayHello" />
            <!-- 是否允許任務(wù)并發(fā)執(zhí)行。當(dāng)值為false時(shí)袒餐，表示必須等到前一個(gè)線程處理完畢后才再啟一個(gè)新的線程 -->
            <entry key="concurrent" value="false" />
        </map>
    </property>
</bean>

<bean id="testJobTrigger"
      class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="jobDetail">
        <ref bean="testJobDetail" />
    </property>
    <property name="cronExpression">
        <value>0/10 * * * * ?</value><!--每10秒鐘執(zhí)行一次 -->
    </property>
</bean>

<bean id="startQuertz" lazy-init="false" autowire="no"
      class="org.springframework.scheduling.quartz.SchedulerFactoryBean"
      destroy-method="destroy">
    <!--QuartzScheduler 啟動(dòng)時(shí)更新己存在的Job飞蛹，這樣就不用每次修改targetObject后刪除qrtz_job_details表對(duì)應(yīng)記錄了 -->
    <property name="overwriteExistingJobs" value="true" />
    <property name="startupDelay" value="2" />
    <property name="autoStartup" value="true" />
    <property name="triggers">
        <list>
            <ref bean="testJobTrigger" />
        </list>
    </property>
    <property name="dataSource" ref="dataSource" />
    <property name="applicationContextSchedulerContextKey" value="applicationContext" />
    <property name="configLocation" value="classpath:quartz.properties" />
</bean>

    </beans> 

三、DetailQuartzJobBean 加載類和方法

package com.itmuch.cloud.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DetailQuartzJobBean extends QuartzJobBean {

private String targetObject;
private String targetMethod;
private ApplicationContext ctx;

// 配置中設(shè)定了
// ① targetMethod: 指定需要定時(shí)執(zhí)行scheduleInfoAction中的simpleJobTest()方法
// ② concurrent：對(duì)于相同的JobDetail灸眼，當(dāng)指定多個(gè)Trigger時(shí), 很可能第一個(gè)job完成之前卧檐，
// 第二個(gè)job就開始了。指定concurrent設(shè)為false焰宣，多個(gè)job不會(huì)并發(fā)運(yùn)行霉囚，第二個(gè)job將不會(huì)在第一個(gè)job完成之前開始。
// ③ cronExpression：0/10 * * * * ?表示每10秒執(zhí)行一次匕积，具體可參考附表盈罐。
// ④ triggers：通過再添加其他的ref元素可在list中放置多個(gè)觸發(fā)器。 scheduleInfoAction中的simpleJobTest()方法
@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
    try {
        Object otargetObject = ctx.getBean(targetObject);
        Method m = null;

        System.out.println(targetObject + " - " + targetMethod + " - " + ((new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS")).format(new Date())));
        try {
            m = otargetObject.getClass().getMethod(targetMethod, new Class[] { JobExecutionContext.class });
            m.invoke(otargetObject, new Object[] { context });
        } catch (SecurityException e) {
            // Logger.error(e);
            System.out.println(e.getMessage());
        } catch (NoSuchMethodException e) {
            // Logger.error(e);
            System.out.println(e.getMessage());
        }
    } catch (Exception e) {
        System.out.println(e.getMessage());
        throw new JobExecutionException(e);
    }
}

public void setApplicationContext(ApplicationContext applicationContext) {
    this.ctx = applicationContext;
}

public void setTargetObject(String targetObject) {
    this.targetObject = targetObject;
}

public void setTargetMethod(String targetMethod) {
    this.targetMethod = targetMethod;
}

}

四闪唆、調(diào)度服務(wù)接口

package com.itmuch.cloud.service;

import java.util.Date;

import org.quartz.CronExpression;

/**
* 調(diào)度服務(wù)接口盅粪。
*
* @date 2017/9/16
*
*/
public interface ISchedulerService {

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param cronExpression 
 *            Quartz Cron 表達(dá)式，如 "0/10 * * ? * * *"等 
 */  
void schedule(String cronExpression);  

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param name 
 *            Quartz CronTrigger名稱 
 * @param cronExpression 
 *            Quartz Cron 表達(dá)式悄蕾，如 "0/10 * * ? * * *"等 
 */  
void schedule(String name, String cronExpression);  

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param name 
 *            Quartz CronTrigger名稱 
 * @param group 
 *            Quartz CronTrigger組 
 * @param cronExpression 
 *            Quartz Cron 表達(dá)式票顾，如 "0/10 * * ? * * *"等 
 */  
void schedule(String name, String group, String cronExpression);  

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param cronExpression 
 *            Quartz CronExpression 
 */  
void schedule(CronExpression cronExpression);  

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param name 
 *            Quartz CronTrigger名稱 
 * @param cronExpression 
 *            Quartz CronExpression 
 */  
void schedule(String name, CronExpression cronExpression);  

/** 
 * 根據(jù) Quartz Cron Expression 調(diào)試任務(wù) 
 *  
 * @param name 
 *            Quartz CronTrigger名稱 
 * @param group 
 *            Quartz CronTrigger組 
 * @param cronExpression 
 *            Quartz CronExpression 
 */  
void schedule(String name, String group, CronExpression cronExpression);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試一次 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 */  
void schedule(Date startTime);  

void schedule(Date startTime, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試一次 
 *  
 * @param name 
 *            Quartz SimpleTrigger 名稱 
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 */  
void schedule(String name, Date startTime);  

void schedule(String name, Date startTime, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試，endTime結(jié)束執(zhí)行調(diào)度 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 */  
void schedule(Date startTime, Date endTime);  

void schedule(Date startTime, Date endTime, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試，endTime結(jié)束執(zhí)行調(diào)度 
 *  
 * @param name 
 *            Quartz SimpleTrigger 名稱 
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 */  
void schedule(String name, Date startTime, Date endTime);  

void schedule(String name, Date startTime, Date endTime, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試奠骄，endTime結(jié)束執(zhí)行調(diào)度霸旗，重復(fù)執(zhí)行repeatCount次 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 */  
void schedule(Date startTime, int repeatCount);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試，endTime結(jié)束執(zhí)行調(diào)度戚揭，重復(fù)執(zhí)行repeatCount次 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 */  
void schedule(Date startTime, Date endTime, int repeatCount);  

void schedule(Date startTime, Date endTime, int repeatCount, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試诱告，endTime結(jié)束執(zhí)行調(diào)度，重復(fù)執(zhí)行repeatCount次 
 *  
 * @param name 
 *            Quartz SimpleTrigger 名稱 
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 */  
void schedule(String name, Date startTime, Date endTime, int repeatCount);  

void schedule(String name, Date startTime, Date endTime, int repeatCount, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試民晒，endTime結(jié)束執(zhí)行調(diào)度精居，重復(fù)執(zhí)行repeatCount次，每隔repeatInterval秒執(zhí)行一次 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 *  
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 * @param repeatInterval 
 *            執(zhí)行時(shí)間隔間 
 */  
void schedule(Date startTime, int repeatCount, long repeatInterval);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試潜必，endTime結(jié)束執(zhí)行調(diào)度靴姿，重復(fù)執(zhí)行repeatCount次，每隔repeatInterval秒執(zhí)行一次 
 *  
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 * @param repeatInterval 
 *            執(zhí)行時(shí)間隔間 
 */  
void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval);  

void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval, String group);  

/** 
 * 在startTime時(shí)執(zhí)行調(diào)試磁滚，endTime結(jié)束執(zhí)行調(diào)度佛吓，重復(fù)執(zhí)行repeatCount次，每隔repeatInterval秒執(zhí)行一次 
 *  
 * @param name 
 *            Quartz SimpleTrigger 名稱 
 * @param startTime 
 *            調(diào)度開始時(shí)間 
 * @param endTime 
 *            調(diào)度結(jié)束時(shí)間 
 * @param repeatCount 
 *            重復(fù)執(zhí)行次數(shù) 
 * @param repeatInterval 
 *            執(zhí)行時(shí)間隔間 
 */  
void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval);  

void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval, String group);  

/** 
 * 暫停觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 */  
void pauseTrigger(String triggerName);  

/** 
 * 暫停觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 * @param group 
 *            觸發(fā)器組 
 */  
void pauseTrigger(String triggerName, String group);  

/** 
 * 恢復(fù)觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 */  
void resumeTrigger(String triggerName);  

/** 
 * 恢復(fù)觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 * @param group 
 *            觸發(fā)器組 
 */  
void resumeTrigger(String triggerName, String group);  

/** 
 * 刪除觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 * @return 
 */  
boolean removeTrigdger(String triggerName);  

/** 
 * 刪除觸發(fā)器 
 *  
 * @param triggerName 
 *            觸發(fā)器名稱 
 * @param group 
 *            觸發(fā)器組 
 * @return 
 */  
boolean removeTrigdger(String triggerName, String group);  

}

五垂攘、調(diào)度服務(wù)接口實(shí)現(xiàn)類

package com.itmuch.cloud.service.impl;

import java.text.ParseException;
import java.util.Date;
import java.util.UUID;

import com.itmuch.cloud.service.ISchedulerService;
import org.quartz.CronExpression;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerKey;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.quartz.impl.triggers.SimpleTriggerImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
* 調(diào)度服務(wù)實(shí)現(xiàn)類维雇。
*
* @date 2017/9/16
*
*/
@Service(“schedulerService”)
public class SchedulerServiceImpl implements ISchedulerService {

private static final String NULLSTRING = null;  
private static final Date NULLDATE = null;  

@Autowired  
private Scheduler scheduler;  
@Autowired  
private JobDetail jobDetail;  

@Override  
public void schedule(String cronExpression) {  
    schedule(NULLSTRING, cronExpression);  
}  

@Override  
public void schedule(String name, String cronExpression) {  
    schedule(name, NULLSTRING, cronExpression);  
}  

@Override  
public void schedule(String name, String group, String cronExpression) {  
    try {  
        schedule(name, group, new CronExpression(cronExpression));  
    } catch (ParseException e) {  
        throw new IllegalArgumentException(e);  
    }  
}  

@Override  
public void schedule(CronExpression cronExpression) {  
    schedule(NULLSTRING, cronExpression);  
}  

@Override  
public void schedule(String name, CronExpression cronExpression) {  
    schedule(name, NULLSTRING, cronExpression);  
}  

@Override  
public void schedule(String name, String group, CronExpression cronExpression) {  

    if (isValidExpression(cronExpression)) {  

        if (name == null || name.trim().equals("")) {  
            name = UUID.randomUUID().toString();  
        }  

        CronTriggerImpl trigger = new CronTriggerImpl();  
        trigger.setCronExpression(cronExpression);  

        TriggerKey triggerKey = new TriggerKey(name, group);  

        trigger.setJobName(jobDetail.getKey().getName());  
        trigger.setKey(triggerKey);  

        try {  
            scheduler.addJob(jobDetail, true);  
            if (scheduler.checkExists(triggerKey)) {  
                scheduler.rescheduleJob(triggerKey, trigger);  
            } else {  
                scheduler.scheduleJob(trigger);  
            }  
        } catch (SchedulerException e) {  
            throw new IllegalArgumentException(e);  
        }  
    }  
}  

@Override  
public void schedule(Date startTime) {  
    schedule(startTime, NULLDATE);  
}  

@Override  
public void schedule(Date startTime, String group) {  
    schedule(startTime, NULLDATE, group);  
}  

@Override  
public void schedule(String name, Date startTime) {  
    schedule(name, startTime, NULLDATE);  
}  

@Override  
public void schedule(String name, Date startTime, String group) {  
    schedule(name, startTime, NULLDATE, group);  
}  

@Override  
public void schedule(Date startTime, Date endTime) {  
    schedule(startTime, endTime, 0);  
}  

@Override  
public void schedule(Date startTime, Date endTime, String group) {  
    schedule(startTime, endTime, 0, group);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime) {  
    schedule(name, startTime, endTime, 0);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime, String group) {  
    schedule(name, startTime, endTime, 0, group);  
}  

@Override  
public void schedule(Date startTime, int repeatCount) {  
    schedule(null, startTime, NULLDATE, 0);  
}  

@Override  
public void schedule(Date startTime, Date endTime, int repeatCount) {  
    schedule(null, startTime, endTime, 0);  
}  

@Override  
public void schedule(Date startTime, Date endTime, int repeatCount, String group) {  
    schedule(null, startTime, endTime, 0, group);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime, int repeatCount) {  
    schedule(name, startTime, endTime, 0, 0L);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime, int repeatCount, String group) {  
    schedule(name, startTime, endTime, 0, 0L, group);  
}  

@Override  
public void schedule(Date startTime, int repeatCount, long repeatInterval) {  
    schedule(null, startTime, NULLDATE, repeatCount, repeatInterval);  
}  

@Override  
public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval) {  
    schedule(null, startTime, endTime, repeatCount, repeatInterval);  
}  

@Override  
public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval, String group) {  
    schedule(null, startTime, endTime, repeatCount, repeatInterval, group);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval) {  
    schedule(name, startTime, endTime, repeatCount, repeatInterval, NULLSTRING);  
}  

@Override  
public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval, String group) {  

    if (this.isValidExpression(startTime)) {  

        if (name == null || name.trim().equals("")) {  
            name = UUID.randomUUID().toString();  
        }  

        TriggerKey triggerKey = new TriggerKey(name, group);  

        SimpleTriggerImpl trigger = new SimpleTriggerImpl();  
        trigger.setKey(triggerKey);  
        trigger.setJobName(jobDetail.getKey().getName());  

        trigger.setStartTime(startTime);  
        trigger.setEndTime(endTime);  
        trigger.setRepeatCount(repeatCount);  
        trigger.setRepeatInterval(repeatInterval);  

        try {  
            scheduler.addJob(jobDetail, true);  
            if (scheduler.checkExists(triggerKey)) {  
                scheduler.rescheduleJob(triggerKey, trigger);  
            } else {  
                scheduler.scheduleJob(trigger);  
            }  
        } catch (SchedulerException e) {  
            throw new IllegalArgumentException(e);  
        }  
    }  
}  

@Override  
public void pauseTrigger(String triggerName) {  
    pauseTrigger(triggerName, NULLSTRING);  
}  

@Override  
public void pauseTrigger(String triggerName, String group) {  
    try {  
        scheduler.pauseTrigger(new TriggerKey(triggerName, group));// 停止觸發(fā)器  
    } catch (SchedulerException e) {  
        throw new RuntimeException(e);  
    }  
}  

@Override  
public void resumeTrigger(String triggerName) {  
    resumeTrigger(triggerName, NULLSTRING);  
}  

@Override  
public void resumeTrigger(String triggerName, String group) {  
    try {  
        scheduler.resumeTrigger(new TriggerKey(triggerName, group));// 重啟觸發(fā)器  
    } catch (SchedulerException e) {  
        throw new RuntimeException(e);  
    }  
}  

@Override  
public boolean removeTrigdger(String triggerName) {  
    return removeTrigdger(triggerName, NULLSTRING);  
}  

@Override  
public boolean removeTrigdger(String triggerName, String group) {  
    TriggerKey triggerKey = new TriggerKey(triggerName, group);  
    try {  
        scheduler.pauseTrigger(triggerKey);// 停止觸發(fā)器  
        return scheduler.unscheduleJob(triggerKey);// 移除觸發(fā)器  
    } catch (SchedulerException e) {  
        throw new RuntimeException(e);  
    }  
}  

private boolean isValidExpression(final CronExpression cronExpression) {  

    CronTriggerImpl trigger = new CronTriggerImpl();  
    trigger.setCronExpression(cronExpression);  

    Date date = trigger.computeFirstFireTime(null);  

    return date != null && date.after(new Date());  
}  

private boolean isValidExpression(final Date startTime) {  

    SimpleTriggerImpl trigger = new SimpleTriggerImpl();  
    trigger.setStartTime(startTime);  

    Date date = trigger.computeFirstFireTime(null);  

    return date != null && date.after(new Date());  
}  

}

六、調(diào)度的任務(wù)類

package com.itmuch.cloud.task;

import org.quartz.JobExecutionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

/**
* 調(diào)度的任務(wù)晒他。
*
* testScheduleTask 字符串名稱在 quartz.xml 中配置為屬性 targetObject 的 value 值吱型。
* sayHello 方法名稱在 quartz.xml 中配置為屬性 targetMethod 的 value 值。
*
* @date 2017/9/16
*
*/
@Configuration
@Component(“testScheduleTask”)
@EnableScheduling
public class ScheduleTask {

private static final Logger Logger = LoggerFactory.getLogger(ScheduleTask.class);

public void sayHello(JobExecutionContext context){
    Logger.info("====    sayHello 123456789    ====");
    System.out.println("====    sayHello 123456789    ====");
}    

}

七陨仅、執(zhí)行 Quartz 的 11 張表入數(shù)據(jù)庫

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;

八津滞、簡單Quartz-Cluster微服務(wù)啟動(dòng)類

package com.itmuch.cloud;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

/**
* 簡單Quartz-Cluster微服務(wù)。
*
* @date 2017/9/16
*
*/
@SpringBootApplication
@ImportResource(“quartz.xml”)
public class SimpleQuartzClusterApplication {

private static final Logger Logger = LoggerFactory.getLogger(SimpleQuartzClusterApplication.class);

public static void main(String[] args) {
    Logger.info("簡單Quartz-Cluster微服務(wù)入口函數(shù)編碼-" + System.getProperty("file.encoding"));

    SpringApplication.run(SimpleQuartzClusterApplication.class, args);

    System.out.println("【【【【【【 簡單Quartz-Cluster微服務(wù) 】】】】】】已啟動(dòng).");
}

}

九灼伤、如何測試分布式触徐？

/******************************************************************************
一、簡單Quartz-Cluster微服務(wù)：

1狐赡、添加 Quartz 相關(guān)配置文件撞鹉；
2、啟動(dòng) microservice-simple-quartz-cluster 模塊服務(wù)猾警，啟動(dòng)1個(gè)端口（8395）孔祸；
3、然后查看日志发皿， ScheduleTask 類的 sayHello 方法被有規(guī)律的調(diào)用崔慧，并打印日志出來；

4穴墅、啟動(dòng) microservice-simple-quartz-cluster 模塊服務(wù)惶室，再啟動(dòng)2個(gè)端口（8396温自、8397）；
5皇钞、然后看到 3 臺(tái)服務(wù)器只有 1 臺(tái)服務(wù)器調(diào)用了 sayHello 方法悼泌，因此 Quartz 的集群分布式也算是部署成功了；
******************************************************************************/

/******************************************************************************
二夹界、簡單Quartz-Cluster微服務(wù)（動(dòng)態(tài)修改定時(shí)任務(wù)的 cronExpression 時(shí)間表達(dá)式）：

1馆里、添加 Quartz 相關(guān)配置文件；
2可柿、啟動(dòng) microservice-simple-quartz-cluster 模塊服務(wù)鸠踪，啟動(dòng)3個(gè)端口（8395、8396复斥、8397）营密；
3、然后看到 3 臺(tái)服務(wù)器只有 1 臺(tái)服務(wù)器調(diào)用了 sayHello 方法打印了日志目锭，因此 Quartz 的集群分布式也算是部署成功了评汰；
4、然后新起網(wǎng)頁輸入 http://localhost:8395/modify/5 修改定時(shí)任務(wù)的觸發(fā)時(shí)間痢虹；
5被去、再等一會(huì)兒就看到 3 臺(tái)服務(wù)器只有 1 臺(tái)服務(wù)器每隔 5 秒調(diào)用一次 sayHello 方法，因此修改定時(shí)任務(wù)的克隆表達(dá)式也算是成功了世分；
******************************************************************************/

/******************************************************************************
三编振、簡單Quartz-Cluster微服務(wù)（動(dòng)態(tài)刪除其中 1 臺(tái)活躍 Quartz 服務(wù)器，然后剩下的其中 1 臺(tái)自動(dòng)接替）：

1臭埋、添加 Quartz 相關(guān)配置文件；
2臀玄、啟動(dòng) microservice-simple-quartz-cluster 模塊服務(wù)瓢阴，啟動(dòng)3個(gè)端口（8395、8396健无、8397）荣恐；
3、然后看到 3 臺(tái)服務(wù)器只有 1 臺(tái)服務(wù)器調(diào)用了 sayHello 方法打印了日志累贤，因此 Quartz 的集群分布式也算是部署成功了叠穆；
4、然后關(guān)閉 1 臺(tái)活躍 Quartz 服務(wù)器臼膏；
5硼被、再等一會(huì)兒就看到 2 臺(tái)服務(wù)器中的 1 臺(tái)服務(wù)器每隔一定的時(shí)間調(diào)用一次 sayHello 方法；
******************************************************************************/