配置見前面兩篇部落格

首先我需要的quartz相關的資訊包括任務名稱、任務組名稱、作業開始時間、作業結束時間等，定義一個類UniQuartzBean用於儲存這些屬性：

import java.util.Date;

public class UniQuartzBean {
	private String jobName; // 作業名稱
	private String jobGroupName; // 作業組名稱
	private String oldJobName; // 作業名稱
	private String oldJobGroupName; // 作業組名稱
	
	private String schedulerInstanceId;	// 排程器ID
	private String schedulerName;		// 排程器名稱
	private String triggerName;		// 觸發器名稱
	private String triggerGroupName;		// 觸發器組名稱
	private String jobClass;		// 處理類名稱
	private String description;		// 任務描述
	
	private Date startTime;		// 作業開始啟動時間
	private Date previousTime;		// 上一次啟動時間
	private Date nextTime;		// 下一次啟動時間
	private Date endTime;		// 結束時間
	
	private int repeatCount;	// 作業需要執行的次數（計數任務）
	private long repeatInterval; // 執行時間間隔
	private int timesTriggered;	// 已經執行的次數
	private String cronExpression; // 執行的時間表達式（定時任務）
	private String triggerState; // 作業狀態
	
	private String jobId;		// FireInstanceId 獨一無二的標識，在獲取正在執行的任務時用到
	private Long jobRunTime;	// 作業的執行時間，只有當作業完成時才會獲取到值，沒有完成時返回-1
	/**
	 * 
    None：Trigger已經完成，且不會在執行，或者找不到該觸發器，或者Trigger已經被刪除<br />
    NORMAL:正常狀態<br />
    PAUSED：暫停狀態<br />
    COMPLETE：觸發器完成，但是任務可能還正在執行中<br />
    BLOCKED：執行緒阻塞狀態<br />
    ERROR：出現錯誤<br />
	 */
	private String triggerType; // 觸發器型別
	private String timeZone;	// timeZone
	
	private boolean isConcurrent;	// 是否支援併發執行
	
	public UniQuartzBean() {
		super();
	}
	
	// 暫停、恢復時可以使用
	public UniQuartzBean(String jobName, String jobGroupName) {
		super();
		this.jobName = jobName;
		this.jobGroupName = jobGroupName;
	}
	
	// 修改作業排程時間可以用到
	public UniQuartzBean(String jobName, String jobGroupName, String oldJobName, String oldJobGroupName) {
		super();
		this.jobName = jobName;
		this.jobGroupName = jobGroupName;
		this.oldJobName = oldJobName;
		this.oldJobGroupName = oldJobGroupName;
	}
    ...Set、Get函式
}
 

此外修改配置任務需要配置其任務時間間隔、任務次數、何時結束等，定義一個類來儲存這些屬性

public class UniQuartzConfig {
	/**
	 * 是否是定時任務?	<br/>
	 * 如果是定時任務,設定true;預設為true<br/>
	 * 如果是即時任務或計數執行,則設定為false;
	 * @return
	 */
	private boolean isTimedTask = true;
	
	/**
	 * 定時任務執行時,設定一個時間的正則表示式;<br />
	 * 如:'0/5 * * * * ?'
	 * @return
	 */
	private String cron = "";
	
	/**
	 * 即時任務或計數執行需要設定,表示在當前時間之後間隔delayTime後執行;<br />
	 * 時間間隔型別見delayTimeType;<br />
	 * 預設延時啟動時間為0,表示立即開始執行;
	 * @return
	 */
	private int delayTime = 0;
	
	/**
	 * 設定延時啟動時間間隔的時間是什麼型別的，預設為'秒';<br />
	 * IntervalUnit.MILLISECOND 毫秒<br />
	 * IntervalUnit.SECOND	秒<br />
	 * IntervalUnit.MINUTE	分<br />
	 * IntervalUnit.HOUR	小時<br />
	 * IntervalUnit.DAY		天<br />
	 * IntervalUnit.WEEK	周<br />
	 * IntervalUnit.MONTH	月<br />
	 * IntervalUnit.YEAR	年
	 * @return
	 */
	private IntervalUnit delayTimeType = IntervalUnit.SECOND;
	
	/**
	 * 計數執行每次執行任務之間的“間隔時間”設定，預設為1<br/>
	 * “間隔時間”型別,見“intervalTimeType”
	 * @return
	 */
	private int intervalTime = 1;
	
	/**
	 * 計數執行“間隔時間”是什麼型別的，預設為'秒';<br />
	 * IntervalUnit.MILLISECOND 毫秒<br />
	 * IntervalUnit.SECOND	秒<br />
	 * IntervalUnit.MINUTE	分<br />
	 * IntervalUnit.HOUR	小時<br />
	 * @return
	 */
	private IntervalUnit intervalTimeType = IntervalUnit.SECOND;
	
	/**
	 * “計數執行”的重複次數,預設為1; <br />
	 * 當設定為“0”時,表示一直重複; <br />
	 * 當這是為“-1”時,表示在某一刻時間結束,需要設定結束的時間endTime,endTimeType;
	 * @return
	 */
	private int repeatCount = 1;
	
	/**
	 * 多少時間之後，該任務停止; <br />
	 * 時間型別見“endTimeType”
	 * @return
	 */
	private int endTime = 0;
	
	/**
	 * 結束時間間隔型別 ,預設設定為秒;其他時間設定如下 <br />
	 * IntervalUnit.MILLISECOND 毫秒<br />
	 * IntervalUnit.SECOND	秒<br />
	 * IntervalUnit.MINUTE	分<br />
	 * IntervalUnit.HOUR	小時<br />
	 * IntervalUnit.DAY		天<br />
	 * IntervalUnit.WEEK	周<br />
	 * IntervalUnit.MONTH	月<br />
	 * IntervalUnit.YEAR	年
	 * @return
	 */
	private IntervalUnit endTimeType = IntervalUnit.SECOND;

	public static UniQuartzConfig newInstance() {
		return new UniQuartzConfig();
	}
	
	private UniQuartzConfig() {
		super();
	}

	...Set、Get函式
	
}
 

接下來就是service類，實現對任務的增刪改查：

@Component
public class UniQuartzService implements UniQuartz {
	@Autowired
	private Scheduler quartzScheduler;

	/**
	 * 
	 * @param uqb
	 *            任務名稱、任務組名稱
	 * @param uqc
	 *            任務的配置資訊
	 * @param quartzClass
	 *            任務執行的類
	 * @param parameter
	 *            給任務傳遞的引數上下文
	 * @return
	 */
	@Override
	public boolean addJob(UniQuartzBean uqb, UniQuartzConfig uqc, Class<? extends Job> quartzClass, Object parameter) {
		try {
			// 判斷觸發器是否存在
			boolean exist = isTriggerExist(uqb);

			// 獲取觸發器，不存在觸發器時建立一個
			Trigger trigger = getTrigger(uqb, uqc);
			if (exist) {
				if (!ObjectUtils.isEmpty(parameter)) {
					trigger.getJobDataMap().put("context", parameter); // 傳遞上下文資料給定時任務
				}
				TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
				quartzScheduler.rescheduleJob(triggerKey, trigger);
			} else {
				// 建立JobDetail,並傳遞引數
				JobDetail jobDetail = getNewJob(uqb, quartzClass);
				if (!ObjectUtils.isEmpty(parameter)) {
					jobDetail.getJobDataMap().put("context", parameter);
				}
				// 排程任務
				quartzScheduler.scheduleJob(jobDetail, trigger);
				//quartzScheduler.start();
			}
			System.out.println(JSON.toJSONString(uqc));
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return true;
	}

	/**
	 * 修改任務的時間
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 */
	@Override
	public boolean modifyJobTime(UniQuartzBean uqb, UniQuartzConfig uqc) {
		try {
			if (isTriggerExist(uqb) == false) {
				System.err.println("不存在[JobName=" + uqb.getJobName() + ",JobGroupName=" + uqb.getJobGroupName());
				return false;
			} else {
				addJob(uqb, uqc, null, null);
				return true;
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 修改任務的時間
	 * 
	 * @param jobName
	 * @param jobGroupName
	 * @param uqc
	 * @return
	 */
	@Override
	public boolean modifyJobTime(String jobName, String jobGroupName, UniQuartzConfig uqc) {
		UniQuartzBean uqb = new UniQuartzBean(jobName, jobGroupName);
		return modifyJobTime(uqb, uqc);
	}

	/**
	 * 暫停任務
	 */
	@Override
	public boolean pauseJob(UniQuartzBean uqb) {
		return pauseJob(uqb.getJobName(), uqb.getJobGroupName());
	}

	/**
	 * 暫停任務
	 */
	@Override
	public boolean pauseJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			// 暫停觸發器
			quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
			quartzScheduler.pauseJob(jobKey);
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 暫停所有任務
	 */
	@Override
	public boolean pauseAllJob() {
		try {
			quartzScheduler.pauseAll();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return true;
	}

	/**
	 * 恢復任務
	 */
	@Override
	public boolean resumeJob(UniQuartzBean uqb) {
		return resumeJob(uqb.getJobName(), uqb.getJobGroupName());
	}

	/**
	 * 恢復任務
	 */
	@Override
	public boolean resumeJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			// 恢復觸發器
			quartzScheduler.resumeTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
			quartzScheduler.resumeJob(jobKey);
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 恢復任務
	 */
	@Override
	public void resumeAllJob() {
		try {
			quartzScheduler.resumeAll();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 刪除任務
	 */
	@Override
	public boolean deleteJob(UniQuartzBean uqb) {
		return deleteJob(uqb.getJobName(), uqb.getJobGroupName());
	}

	/**
	 * 刪除任務
	 */
	@Override
	public boolean deleteJob(String jobName, String jobGroupName) {
		JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
		try {
			// 停止觸發器
			quartzScheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
			// 移除觸發器
			quartzScheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
			// 刪除任務
			quartzScheduler.deleteJob(jobKey);
			return true;
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return false;
	}

	/**
	 * 停止排程器觸發觸發器，清理與排程器相關的所有資源。相當於關閉(false)。無法重新啟動排程程式。
	 */
	@Override
	public void shutdown() {
		try {
			quartzScheduler.shutdown();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 判斷觸發器是否存在
	 * 
	 * @param uqb
	 * @param trigName
	 * @param trigGroupName
	 * @return
	 * @throws SchedulerException
	 */
	private boolean isTriggerExist(UniQuartzBean uqb) throws SchedulerException {
		boolean bExist = false;
		TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
		Trigger trigger = quartzScheduler.getTrigger(triggerKey);
		if (!ObjectUtils.isEmpty(trigger)) {
			bExist = true;
		}
		return bExist;
	}

	/**
	 * 獲取觸發器，觸發器之前存在則返回；不存在，則建立之後返回；
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger getTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		return uqc.isTimedTask() ? configCronTrigger(uqb, uqc) : configSimpleTrigger(uqb, uqc);
	}

	/**
	 * 定時任務-配置觸發器
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger configCronTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		Trigger trigger = null;
		ScheduleBuilder<?> scheduleBuilder = getScheduleBuilder(uqc);
		if (isTriggerExist(uqb)) { // 存在
			System.out.println("定時任務-配置觸發器---存在");
			TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
			trigger = quartzScheduler.getTrigger(triggerKey);
			trigger = ((CronTrigger) trigger).getTriggerBuilder().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
					.withSchedule((CronScheduleBuilder) scheduleBuilder).withDescription(uqb.getDescription()).build();
		} else { // 不存在
			System.out.println("定時任務-配置觸發器---不存在");
			trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
					.withSchedule(scheduleBuilder).withDescription(uqb.getDescription()).build();
		}
		return trigger;
	}

	/**
	 * 建立排程器
	 * 
	 * @param uqa
	 * @return
	 */
	private ScheduleBuilder<?> getScheduleBuilder(UniQuartzConfig uqc) {
		ScheduleBuilder<?> scheduleBuilder = null;
		if (uqc.isTimedTask()) { // 定時任務
			scheduleBuilder = CronScheduleBuilder.cronSchedule(uqc.getCron());
		} else { // 即時任務、計數任務
			scheduleBuilder = SimpleScheduleBuilder.simpleSchedule();
		}
		return scheduleBuilder;
	}

	/**
	 * 配置即時任務、定時任務的延時、延時種類、執行間隔、執行間隔種類、重複次數、結束時間、結束時間種類
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger configSimpleTrigger(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		System.out.println("配置Simple觸發器.迴圈次數" + uqc.getRepeatCount());
		if (uqc.getRepeatCount() == -1) { // 表示在某一時刻結束，需要設定結束時間
			System.out.println("在某一刻結束-觸發器");
			return configSimpleTriggerEnd(uqb, uqc);
		} else if (uqc.getRepeatCount() == 0) { // 表示一直重複
			System.out.println("一直重複執行-觸發器....");
			return configSimpleTriggerForever(uqb, uqc);
		} else { // 計數執行
			System.out.println("計數執行-觸發器...");
			return configSimpleTriggerCount(uqb, uqc);
		}
	}

	/**
	 * 在某一時刻結束
	 * 
	 * @param trigName
	 * @param trigGroupName
	 * @param uqa
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger configSimpleTriggerEnd(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		Trigger trigger = null;
		TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
		SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
		// 延時啟動時間
		Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
		// 結束時間
		Date endDate = DateBuilder.futureDate(uqc.getEndTime(), uqc.getEndTimeType());
		// 配置時間間隔
		scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
		scheduleBuilder = scheduleBuilder.repeatForever();
		if (isTriggerExist(uqb)) {
			trigger = quartzScheduler.getTrigger(triggerKey);

			trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
					.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
					.withDescription(uqb.getDescription()).startAt(startDate).endAt(endDate).build();
			System.out.println("即時任務-某時間結束-配置觸發器---存在");
		} else {
			System.out.println("即時任務-某時間結束-配置觸發器---不存在");
			// 構建排程器
			trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
					.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate)
					.endAt(endDate).build();
		}
		return trigger;
	}

	/**
	 * 配置觸發器啟動時間間隔、間隔型別
	 * 
	 * @param scheduleBuilder
	 * @param uqa
	 */
	private SimpleScheduleBuilder configSimpleTriggerInterval(SimpleScheduleBuilder scheduleBuilder,
			UniQuartzConfig uqc) {
		SimpleScheduleBuilder res = scheduleBuilder;
		if (uqc.getIntervalTime() > 0) { // 間隔時間大於0時設定
			System.out.println("設定的間隔時間大於0");
			switch (uqc.getIntervalTimeType()) {
			case MILLISECOND:
				System.out.println("時間間隔為毫秒:" + uqc.getIntervalTime());
				res = scheduleBuilder.withIntervalInMilliseconds(uqc.getIntervalTime());
				break;
			case SECOND:
				System.out.println("時間間隔為秒:" + uqc.getIntervalTime());
				res = scheduleBuilder.withIntervalInSeconds(uqc.getIntervalTime());
				break;
			case MINUTE:
				System.out.println("時間間隔為分:" + uqc.getIntervalTime());
				res = scheduleBuilder.withIntervalInMinutes(uqc.getIntervalTime());
				break;
			case HOUR:
				System.out.println("時間間隔為小時:" + uqc.getIntervalTime());
				res = scheduleBuilder.withIntervalInHours(uqc.getIntervalTime());
				break;
			default:
				System.err.println("這是不支援的排程間隔時間：" + uqc.getIntervalTimeType());
				break;
			}
		} else {
			System.err.println("設定的時間間隔必須大於0.");
		}
		return res;
	}

	/**
	 * 一直重複執行
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger configSimpleTriggerForever(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		Trigger trigger = null;
		TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
		SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
		// 延時啟動時間
		Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
		// 配置時間間隔
		scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
		scheduleBuilder = scheduleBuilder.repeatForever();// 一直重複
		if (isTriggerExist(uqb)) {
			trigger = quartzScheduler.getTrigger(triggerKey);

			trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
					.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
					.withDescription(uqb.getDescription()).startAt(startDate).build();
			System.out.println("即時任務-重複執行-配置觸發器---存在");
		} else {
			System.out.println("即時任務-重複執行-配置觸發器---不存在");
			// 構建排程器
			trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
					.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate).build();
		}
		return trigger;
	}

	/**
	 * 執行一定的次數
	 * 
	 * @param uqb
	 * @param uqc
	 * @return
	 * @throws SchedulerException
	 */
	private Trigger configSimpleTriggerCount(UniQuartzBean uqb, UniQuartzConfig uqc) throws SchedulerException {
		Trigger trigger = null;
		TriggerKey triggerKey = TriggerKey.triggerKey(uqb.getJobName(), uqb.getJobGroupName());
		SimpleScheduleBuilder scheduleBuilder = (SimpleScheduleBuilder) getScheduleBuilder(uqc);
		// 延時啟動時間
		Date startDate = DateBuilder.futureDate(uqc.getDelayTime(), uqc.getDelayTimeType());
		// 配置時間間隔
		scheduleBuilder = configSimpleTriggerInterval(scheduleBuilder, uqc);
		scheduleBuilder = scheduleBuilder.withRepeatCount(uqc.getRepeatCount() - 1); // 設定重複次數
		if (isTriggerExist(uqb)) {
			System.out.println("是否存在---------------------2:" + "存在");
			trigger = quartzScheduler.getTrigger(triggerKey);

			trigger = ((SimpleTrigger) trigger).getTriggerBuilder()
					.withIdentity(uqb.getJobName(), uqb.getJobGroupName()).withSchedule(scheduleBuilder)
					.withDescription(uqb.getDescription()).startAt(startDate).build();
		} else {
			System.out.println("是否存在---------------------2:" + "不存在");
			// 構建排程器
			trigger = TriggerBuilder.newTrigger().withIdentity(uqb.getJobName(), uqb.getJobGroupName())
					.withDescription(uqb.getDescription()).withSchedule(scheduleBuilder).startAt(startDate).build();
		}
		return trigger;
	}

	/**
	 * 建立一個新的作業
	 * 
	 * @param uniSchTrig
	 * @param quartzClass
	 * @return
	 */
	private JobDetail getNewJob(UniQuartzBean uqb, Class<? extends Job> quartzClass) {
		JobDetail jobDetail = JobBuilder.newJob(quartzClass).withIdentity(uqb.getJobName(), uqb.getJobGroupName())
				.build();
		return jobDetail;
	}

	private UniQuartzBean getJob(JobKey jobKey, Trigger trigger) {
		UniQuartzBean uniQuartzBean = null;
		try {
			String jobName = jobKey.getName();
			String jobGroupName = jobKey.getGroup();
			// Trigger trigger = quartzScheduler.getTrigger(triggerKey);
			if (!ObjectUtils.isEmpty(trigger)) {
				uniQuartzBean = new UniQuartzBean();
				// 獲取任務基本資訊，作業名稱、作業組名稱、觸發器名稱、觸發器組名稱
				uniQuartzBean.setJobName(jobName).setJobGroupName(jobGroupName).setTriggerName(jobName)
						.setTriggerGroupName(jobGroupName);
				// 獲取排程器基本資訊，排程器ID、排程器名稱、處理類名稱、任務描述、作業狀態
				uniQuartzBean.setSchedulerInstanceId(quartzScheduler.getSchedulerInstanceId())
						.setSchedulerName(quartzScheduler.getSchedulerName());
				JobDetail jobDetail = quartzScheduler.getJobDetail(jobKey);
				uniQuartzBean.setJobClass("" + jobDetail.getJobClass()).setDescription(trigger.getDescription())
						.setTriggerState(quartzScheduler.getTriggerState(trigger.getKey()).name());
				// 獲取作業的啟動時間資訊
				uniQuartzBean.setStartTime(trigger.getStartTime()).setPreviousTime(trigger.getPreviousFireTime())
						.setNextTime(trigger.getNextFireTime()).setEndTime(trigger.getEndTime());
				// 是否支援併發
				uniQuartzBean.setConcurrent(jobDetail.isConcurrentExectionDisallowed());
				// 獲取需要執行的次數、執行間隔、已經執行的次數、時間表達式
				if (trigger instanceof CronTrigger) {
					CronTrigger cronTrigger = (CronTrigger) trigger;
					uniQuartzBean.setTriggerType("CronTrigger");
					uniQuartzBean.setCronExpression(cronTrigger.getCronExpression())
							.setTimeZone(cronTrigger.getTimeZone().getID());
				} else if (trigger instanceof SimpleTrigger) {
					SimpleTrigger simpleTrigger = (SimpleTrigger) trigger;
					uniQuartzBean.setTriggerType("SimpleTrigger");
					uniQuartzBean.setRepeatCount(simpleTrigger.getRepeatCount() + 1)
							.setRepeatInterval(simpleTrigger.getRepeatInterval())
							.setTimesTriggered(simpleTrigger.getTimesTriggered());
				}
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return uniQuartzBean;
	}

	/**
	 * 獲取任務資訊
	 * @param uqb
	 * @return
	 */
	@Override
	public UniQuartzBean getJob(UniQuartzBean uqb) {
		return getJob(uqb.getJobName(), uqb.getJobGroupName());
	}

	/**
	 * 獲取任務資訊
	 * @param jobName
	 * @param jobGroupName
	 * @return
	 */
	@Override
	public UniQuartzBean getJob(String jobName, String jobGroupName) {
		UniQuartzBean uniQuartzBean = null;
		try {
			TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
			Trigger trigger = quartzScheduler.getTrigger(triggerKey);
			if (!ObjectUtils.isEmpty(trigger)) {
				JobKey jobKey = trigger.getJobKey();
				uniQuartzBean = getJob(jobKey, trigger);
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return uniQuartzBean;
	}

	/**
	 * 獲取所有的任務,指那些新增到quartz排程器中的任務
	 * @return
	 */
	@Override
	public List<UniQuartzBean> getAllJob() {
		List<UniQuartzBean> listUniQuartzBean = new ArrayList<>();
		try {
			GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
			Set<JobKey> jobKeys = quartzScheduler.getJobKeys(matcher);
			if (!CollectionUtils.isEmpty(jobKeys)) {
				jobKeys.forEach(jobKey -> {
					try {
						List<? extends Trigger> listTrigger = quartzScheduler.getTriggersOfJob(jobKey);
						if (!CollectionUtils.isEmpty(listTrigger)) {
							listTrigger.forEach(trigger->{
								UniQuartzBean uniQuartzBean = getJob(jobKey, trigger);
								if (!ObjectUtils.isEmpty(uniQuartzBean)) {
									listUniQuartzBean.add(uniQuartzBean);
								}
							});
						}
					} catch (SchedulerException e) {
						e.printStackTrace();
					}
				});
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return listUniQuartzBean;
	}
	
	/**
	 * 獲取所有任務中-正在執行的例項
	 * 
	 * @return
	 */
	@Override
	public List<UniQuartzBean> getAllJobInstance() {
		List<UniQuartzBean> listUniQuartzBean = new ArrayList<>();
		try {
			List<JobExecutionContext> listExecJob = quartzScheduler.getCurrentlyExecutingJobs();
			if (!CollectionUtils.isEmpty(listExecJob)) {
				listExecJob.forEach(execJob->{
					JobKey jobKey = execJob.getJobDetail().getKey();
					try {
						List<? extends Trigger> listTrigger = quartzScheduler.getTriggersOfJob(jobKey);
						if (!CollectionUtils.isEmpty(listTrigger)) {
							listTrigger.forEach(trigger->{
								//UniQuartzBean uniQuartzBean = getJob(jobKey, trigger);
								UniQuartzBean uniQuartzBean = getRuningJob(execJob, trigger);
								if (!ObjectUtils.isEmpty(uniQuartzBean)) {
									listUniQuartzBean.add(uniQuartzBean);									
								}
							});
						}
					} catch (SchedulerException e) {
						e.printStackTrace();
					}
				});
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return listUniQuartzBean;
	}
	
	/**
	 * 獲取正在執行的任務資訊
	 * @param execJob
	 * @param trigger
	 * @return
	 */
	private UniQuartzBean getRuningJob(JobExecutionContext execJob, Trigger trigger) {
		UniQuartzBean uniQuartzBean = null;
		try {
			JobKey jobKey = trigger.getJobKey();
			String jobName = jobKey.getName();
			String jobGroupName = jobKey.getGroup();
			if (!ObjectUtils.isEmpty(trigger)) {
				uniQuartzBean = new UniQuartzBean();
				// 獲取任務基本資訊，作業名稱、作業組名稱、觸發器名稱、觸發器組名稱
				uniQuartzBean.setJobName(jobName).setJobGroupName(jobGroupName).setTriggerName(jobName)
						.setTriggerGroupName(jobGroupName);
				JobDetail jobDetail = quartzScheduler.getJobDetail(jobKey);
				// 獲取作業“實際”開始的時間、上次執行的時間、下次執行的時間
				uniQuartzBean.setStartTime(execJob.getFireTime()).setPreviousTime(execJob.getPreviousFireTime())
						.setNextTime(execJob.getNextFireTime());
				// 獲取作業狀態
				uniQuartzBean.setJobClass("" + jobDetail.getJobClass()).setDescription(trigger.getDescription());
				// 獲取執行時間、例項ID
				uniQuartzBean.setJobRunTime(execJob.getJobRunTime()).setJobId(execJob.getFireInstanceId());
			}
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
		return uniQuartzBean;
	}
}
 

測試：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({ "classpath*:/spring-context*.xml", "classpath*:/quartz_jobs.xml" })
public class UniQuartz2Test {
	@Autowired
	UniQuartz uniQuartz2;
	
	@Test
	public void testAddJob_TimedTask() throws InterruptedException {
		System.out.println("--------新增定時器------start---------");
		UniQuartzConfig uqc =UniQuartzConfig.newInstance().setCron("0/3 * * * * ?");
		UniQuartzBean uqb = new UniQuartzBean("jobName2", "jobGroupName1");
		uniQuartz2.addJob(uqb, uqc, TimedTaskJob.class, "每隔3秒執行一次.");
		uqb.setDescription("定時器");
		System.out.println("--------新增定時器------stop---------");
		int i= 0;
		while (true) {
			i++;
			Thread.sleep(1000);
			if (i >= 16)
				break;
		}
	}
}

參考部落格：