SpingBoot Quartz配置及數據庫持久化配置

本文是基於SpringBoot java代碼配置完成的 Quartz持久化是基於Mysql數據庫持久化的原因是防止服務器宕機丟掉所在執行的任務

一：SpringBoot代碼配置

import java.io.IOException;
import java.util.Properties;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
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;

/**
* @ClassName: QuartzConifg
* @Description: TODO(Quartz定時任務配置)
* @author: mengxr
* @date 2017年5月10日 下午2:08:16
*/
@Configuration
public class QuartzConifgue {
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource,
    		@Qualifier("JobFactory")  QuartzSpringJobFactory jobFactory) throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        // this allows to update triggers in DB when updating settings in config file:
        factory.setOverwriteExistingJobs(true);
        factory.setJobFactory(jobFactory);
        factory.setDataSource(dataSource);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }
    
    @Bean("JobFactory")
    public QuartzSpringJobFactory JobFactory(){
    	QuartzSpringJobFactory jobFactory = new QuartzSpringJobFactory();
    	return jobFactory;
    }
}

二：把Quartz放入Spring管理容器（不配置的話在定義的Job任務中不能注入）

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;

/**
 * 由於job是在quartz中實例化出來的 ，把Quartz放入Spring管理
* @ClassName: QuartzSpringJobFactory
* @Description: TODO()
* @author: mengxr
* @date 2017年5月11日 下午2:08:48
*/
public class QuartzSpringJobFactory extends AdaptableJobFactory {

    //這個對象Spring會幫我們自動注入進來,也屬於Spring技術範疇.
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //調用父類的方法
        Object jobInstance = super.createJobInstance(bundle);
        //進行注入,這屬於Spring的技術,不清楚的可以查看Spring的API.
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

三：Quartz配置文件配置

org.quartz.scheduler.instanceName:meipro-notice
org.quartz.scheduler.instanceId: AUTO
org.quartz.scheduler.skipUpdateCheck: true
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 5
org.quartz.threadPool.threadPriority: 5
org.quartz.jobStore.misfireThreshold: 60000
# 內存配置 org.quartz.simpl.RAMJobStore
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX  
org.quartz.jobStore.driverDelegateClass= org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties=false
org.quartz.jobStore.dataSource=myDS
org.quartz.jobStore.tablePrefix=QRTZ_
org.quartz.jobStore.isClustered=true

四：Quartz工具類

import java.util.Date;
import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


/**
 * @ClassName: QuartzTools
 * @Description: TODO(任務調度工具類)
 * @author: mengxr
 * @date 2017年5月10日 下午5:23:36
 */
@Service
public class QuartzTools {
	@Autowired
	private Scheduler scheduler;
	// 日誌處理
	private Logger logger = LoggerFactory.getLogger(this.getClass());

	/**
	 * @throws NoticeExeception 
	 * @Title: addJob
	 * @Description: TODO(添加一個Job)
	 * @param @param name
	 * @param @param group
	 * @param @param job
	 * @param @param date
	 * @param @return 設定文件
	 * @return boolean 返回類型
	 * @author: mengxr
	 * @date 2017年5月10日 下午5:46:06
	 * @throws
	 */
	public boolean addJob(String name, String group,
			Class<? extends Job> jobclazz, Date date,JobDataMap newJobDataMap) throws NoticeExeception {
		boolean flag = false;
		try {
			JobDetail jobDetail = JobBuilder.newJob(jobclazz).setJobData(newJobDataMap)
					.withIdentity(name, group).build(); // 1、創建一個JobDetail實例，指定Quartz
			// 創建任務觸發器
			Trigger trigger = TriggerBuilder
					.newTrigger()
					.withIdentity(name, group)
					.withSchedule(
							CronScheduleBuilder.cronSchedule(CronDateUtils
									.getCron(date))).build();
			scheduler.scheduleJob(jobDetail, trigger);
			flag = true;
			logger.info("創建定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 成功，定時執行時間：[{}]", date);
		} catch (SchedulerException e) {
			flag = false;
			logger.info("創建定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，定時執行時間：[{}]", date, e);
			throw new NoticeExeception("notice.addJob");
		}
		return flag;
	}

	/**
	 * @throws NoticeExeception 
	 * @Title: modifyJobTime
	 * @Description: TODO(執行時間)
	 * @param @param name
	 * @param @param group
	 * @param @param date
	 * @param @return 設定文件
	 * @return boolean 返回類型
	 * @author: mengxr
	 * @date 2017年5月10日 下午6:05:23
	 * @throws
	 */
	public boolean modifyJobTime(String name, String group, Date date) throws NoticeExeception  {
		boolean flag = false;
		try {
			TriggerKey tk = TriggerKey.triggerKey(name, group);
			// 構造任務觸發器
			Trigger trg = TriggerBuilder
					.newTrigger()
					.withIdentity(name, group)
					.withSchedule(
							CronScheduleBuilder.cronSchedule(CronDateUtils
									.getCron(date))).build();
			scheduler.rescheduleJob(tk, trg);
			flag = true;
			logger.info("修改定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 成功，修改執行時間：[{}]", date);
		} catch (SchedulerException e) {
			flag = false;
			logger.info("修改定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，修改執行時間：[{}]", date, e);
			throw new NoticeExeception("notice.modifyJobTime");
		}
		return flag;
	}

	/**
	 * @throws NoticeExeception 
	 * @Title: parseJob
	 * @Description: TODO(暫停任務)
	 * @param @param name
	 * @param @param group
	 * @param @return 設定文件
	 * @return boolean 返回類型
	 * @author: mengxr
	 * @date 2017年5月10日 下午6:14:47
	 * @throws
	 */
	public boolean parseJob(String name, String group) throws NoticeExeception {
		boolean flag = false;
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			scheduler.pauseJob(jobKey);
			flag = true;
			logger.info("暫停定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 成功，暫停執行時間：[{}]", new Date());
		} catch (SchedulerException e) {
			flag = false;
			logger.info("暫停定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，暫停執行時間：[{}]", new Date(),e);
			throw new NoticeExeception("notice.parseJob");
		}
		return flag;
	}
	/**
	 * @throws NoticeExeception 
	* @Title: deleteJob
	* @Description: TODO(刪除任務)
	* @param @param name
	* @param @param group
	* @param @return    設定文件
	* @return boolean    返回類型
	* @author: mengxr
	* @date 2017年5月11日 下午2:03:46
	* @throws
	*/
	public boolean deleteJob(String name, String group) throws NoticeExeception {
		boolean flag = false;
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			scheduler.deleteJob(jobKey);
			flag = true;
			logger.info("刪除定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 成功，暫停執行時間：[{}]", new Date());
		} catch (SchedulerException e) {
			flag = false;
			logger.info("刪除定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，暫停執行時間：[{}]", new Date(),e);
			throw new NoticeExeception("notice.deleteJob");
		}
		return flag;
	}
	/**
	 * @throws NoticeExeception 
	 * @Title: resumeJob
	 * @Description: TODO(恢復任務執行)
	 * @param @param name
	 * @param @param group
	 * @param @return 設定文件
	 * @return boolean 返回類型
	 * @author: mengxr
	 * @date 2017年5月10日 下午6:17:01
	 * @throws
	 */
	public boolean resumeJob(String name, String group) throws NoticeExeception {
		boolean flag = false;
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			scheduler.resumeJob(jobKey);
			flag = true;
			logger.info("恢復定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 成功，恢復執行時間：[{}]", new Date());
		} catch (SchedulerException e) {
			flag = false;
			logger.info("恢復定時任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，恢復執行時間：[{}]", new Date(),e);
			throw new NoticeExeception("notice.resumeJob");
		}
		return flag;
	}
	/**
	 * @throws NoticeExeception 
	* @Title: isExistJob
	* @Description: TODO(檢測任務是否存在)
	* @param @param name
	* @param @param group
	* @param @return    設定文件
	* @return boolean    返回類型
	* @author: mengxr
	* @date 2017年5月11日 上午10:44:09
	* @throws
	*/
	public boolean isExistJob(String name, String group) throws NoticeExeception{
		boolean flag = false;
		try {
			JobKey jobKey = JobKey.jobKey(name, group);
			flag = scheduler.checkExists(jobKey);
		} catch (SchedulerException e) {
			logger.info("檢測任務=> [任務名稱：" + name + " 任務組：" + group
					+ "] 失敗，檢測執行時間：[{}]", new Date(),e);
			throw new NoticeExeception("notice.isExistJob");
		}
		return flag;
	}
}

五：Quartz Mysql數據庫表初始化(基於innodb)

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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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))
ENGINE=InnoDB;

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(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(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))
ENGINE=InnoDB;

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),
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(200) 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(200) 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(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))
ENGINE=InnoDB;

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

六：創建一個Job任務

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
/**
 * @ClassName: NoticeJob
 * @Description: TODO(公告JOB任務 ,添加定時任務)
 * @author: mengxr
 * @date 2017年5月10日 下午6:58:13
 */
public class NoticeJob implements Job {
	private Logger logger = LoggerFactory.getLogger(this.getClass());
	@Autowired
	private INoticeService iNoticeService;
	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		Long noticeId = null;
		Short noticeState = null;
		try {
			//獲取JobDataMap
			JobDataMap dataMap = context.getJobDetail().
					getJobDataMap();
		    noticeId = (Long) dataMap.get("noticeId"); //獲取公告ID
		    noticeState = (Short) dataMap.get("noticeState"); //獲取公告類型
			iNoticeService.updateNoticeTargetState(new NoticeVo(noticeId, noticeState)); //修改公告目標
			logger.info("定時任務執行成功公告主鍵[{}]，公告類型[{}]修改公告目標",noticeId,noticeState);
		} catch (Exception e) {
			logger.error("定時任務公告主鍵[{}]，公告類型[{}]修改公告目標失敗",noticeId,noticeState,e);
		}
	}
}

七：調用Job任務（一小段代碼）

private void startNoticeJob(NoticeVo notice) throws MeiproException {
		Long noticeId = notice.getId();
		Short noticeState = notice.getState();
		if (State.timeinterval.equals(noticeState)) { // 如果狀態爲定時發佈開啓定時任務
			Date sendtime = notice.getSendtime();
			boolean flag = quartzTools.isExistJob(String.valueOf(noticeId),
					NoticeConstant.quartzGroup); 
			JobDataMap jobData = new JobDataMap();
			jobData.put("noticeId", noticeId);
			jobData.put("noticeState", State.publish);
			if(flag){
				if(null != sendtime){
					quartzTools.deleteJob(String.valueOf(noticeId),
							NoticeConstant.quartzGroup);
					quartzTools.addJob(String.valueOf(noticeId),
							NoticeConstant.quartzGroup, NoticeJob.class,
							sendtime, jobData);
				}else{
					//恢復任務
					quartzTools.resumeJob(String.valueOf(noticeId), NoticeConstant.quartzGroup);
				}
			}else{
				quartzTools.addJob(String.valueOf(noticeId),
						NoticeConstant.quartzGroup, NoticeJob.class,
						sendtime, jobData);
			}
		} else if (State.publish.equals(noticeState)) {// 如果狀態爲 發佈公告
			boolean flag = quartzTools.isExistJob(String.valueOf(noticeId),
					NoticeConstant.quartzGroup);
			if(flag){
				quartzTools.deleteJob(String.valueOf(noticeId),
					NoticeConstant.quartzGroup);
			}
		} else if (State.draft.equals(noticeState) || 
				State.recall.equals(noticeState) ||
				State.delete.equals(noticeState)) { 
			boolean flag = quartzTools.isExistJob(String.valueOf(noticeId),
					NoticeConstant.quartzGroup);
			if(flag){
				quartzTools.deleteJob(String.valueOf(noticeId),
					NoticeConstant.quartzGroup);
			}
		}
	}

SpingBoot Quartz配置及數據庫持久化配置

使用c#強大的表達式樹實現對象的深克隆之解決循環引用的問題

GPT-4o 引領人機交互新風向，向量數據庫賽道沸騰了

free AI online tools All In One

痞子衡嵌入式：恩智浦i.MX RT1xxx系列MCU啓動那些事（12.A）- uSDHC eMMC啓動時間(RT1170)

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（二）使用kube-vip實現集羣VIP訪問

企業大模型如何成爲自己數據的“百科全書”？

本地SSL證書過期輸入命令在IIS自動生成

.NET週刊【5月第2期 2024-05-12】

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（一）部署K8s

基於Ubuntu-22.04安裝K8s-v1.28.2實驗（三）數據卷掛載NFS（網絡文件系統）

Spring cloud config server Could not fetch remote for master remote: 解決

怎樣使得Tomcat服務器啓動更快使用隨機數與熵池策略

Spring Boot actuator框架的一些安全考慮

Mybatis# $ 及SQL 踩坑

Python面向對象編程

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結