java如何用Quartz框架來實現動態定時任務
初探
Quartz是OpenSymphony開源組織在Job scheduling領域又一個開源項目，它能夠與J2EE與J2SE應用程序相結合也能夠單獨使用。Quartz能夠用來建立簡單或爲運行十個，百個，甚至是好幾萬個Jobs這樣複雜的程序。而咱們在寫Java程序中常常會寫一些定時執行的任務，好比某月的幾號去執行一件事，天天的凌晨作些什麼，或者天天執行一次什麼方法，接下來我把簡單的Quartz入門實例放進來，是能夠直接運行，是對Quartz的增刪改查系列，能夠對於初學者，有個大概的瞭解。java
這裏直接放代碼，看效果(quartz version: 1.8.4)：web
QuartzManager（增刪改查方法）：spring
package com.sai.quartz;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
public class QuartzManager {
private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";
private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";
/**
* 添加一個定時任務，使用默認的任務組名，觸發器名，觸發器組名
* @param jobName 任務名
* @param cls 任務
* @param time 時間設置
*/
@SuppressWarnings("rawtypes")
public static void addJob(String jobName, Class cls, String time) {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
// 任務名，任務組，任務執行類
JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);
//能夠傳遞參數
jobDetail.getJobDataMap().put("param", "railsboy");
// 觸發器
CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);
// 觸發器名,觸發器組
trigger.setCronExpression(time);
// 觸發器時間設定
sched.scheduleJob(jobDetail, trigger);
// 啓動
if (!sched.isShutdown()) {
sched.start();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 修改一個任務的觸發時間(使用默認的任務組名，觸發器名，觸發器組名)
* @param jobName
* @param time
*/
@SuppressWarnings("rawtypes")
public static void modifyJobTime(String jobName, String time) {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME);
if (trigger == null) {
return;
}
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(time)) {
JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME);
Class objJobClass = jobDetail.getJobClass();
removeJob(jobName);
addJob(jobName, objJobClass, time);
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 移除一個任務(使用默認的任務組名，觸發器名，觸發器組名)
* @param jobName
*/
public static void removeJob(String jobName) {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 中止觸發器
sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除觸發器
sched.deleteJob(jobName, JOB_GROUP_NAME);// 刪除任務
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 啓動全部定時任務
*/
public static void startJobs() {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
sched.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* 關閉全部定時任務
*/
public static void shutdownJobs() {
try {
Scheduler sched = gSchedulerFactory.getScheduler();
if (!sched.isShutdown()) {
sched.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
QuartzJob（任務執行類）：數據庫
package com.sai.quartz;
import java.text.SimpleDateFormat;
import java.util.Date;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
* 任務執行類
*/
public class QuartzJob implements Job {
@Override
public void execute(JobExecutionContext content) throws JobExecutionException {
System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "★★★★★★★★★★★");
String jobName = content.getJobDetail().getName();
JobDataMap dataMap = content.getJobDetail().getJobDataMap();
String param = dataMap.getString("param");
System.out.println("傳遞的參數是="+param +"任務名字是="+jobName);
}
}
QuartzTest（定時任務測試類）：express
package com.sai.quartz.main;
import java.text.SimpleDateFormat;
import java.util.Date;
import com.sai.quartz.QuartzJob;
import com.sai.quartz.QuartzManager;
public class QuartzTest {
public static void main(String[] args) {
try {
String job_name = "動態任務調度";
System.out.println("【任務啓動】開始(每10秒輸出一次)...");
QuartzManager.addJob(job_name, QuartzJob.class, "0/10 * * * * ?");
Thread.sleep(5000);
System.out.println("【修改時間】開始(每2秒輸出一次)...");
QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");
Thread.sleep(6000);
System.out.println("【移除定時】開始...");
QuartzManager.removeJob(job_name);
System.out.println("【移除定時】成功");
System.out.println("【再次添加定時任務】開始(每10秒輸出一次)...");
QuartzManager.addJob(job_name, QuartzJob.class, "*/10 * * * * ?");
Thread.sleep(60000);
System.out.println("【移除定時】開始...");
QuartzManager.removeJob(job_name);
System.out.println("【移除定時】成功");
} catch (Exception e) {
e.printStackTrace();
}
}
public static String formatDateByPattern(Date date,String dateFormat){
SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
String formatTimeStr = null;
if (date != null) {
formatTimeStr = sdf.format(date);
}
return formatTimeStr;
}
public static String getCron(java.util.Date date){
String dateFormat="ss mm HH dd MM ? yyyy";
return formatDateByPattern(date, dateFormat);
}
}
console執行效果：xcode
經常使用的時間配置：app
格式: [秒] [分] [小時] [日] [月] [周] [年]0 0 12 * * ? 天天12點觸發 0 15 10 ? * * 天天10點15分觸發 0 15 10 * * ? 天天10點15分觸發 0 15 10 * * ? * 天天10點15分觸發 0 15 10 * * ? 2005 2005年天天10點15分觸發 0 * 14 * * ? 天天下午的 2點到2點59分每分觸發 0 0/5 14 * * ? 天天下午的 2點到2點59分(整點開始，每隔5分觸發) 0 0/5 14,18 * * ? 天天下午的 18點到18點59分(整點開始，每隔5分觸發)0 0-5 14 * * ? 天天下午的 2點到2點05分每分觸發 0 10,44 14 ? 3 WED 3月分每週三下午的 2點10分和2點44分觸發 0 15 10 ? * MON-FRI 從週一到週五天天上午的10點15分觸發 0 15 10 15 * ? 每個月15號上午10點15分觸發 0 15 10 L * ? 每個月最後一天的10點15分觸發 0 15 10 ? * 6L 每個月最後一週的星期五的10點15分觸發 0 15 10 ? * 6L 2002-2005 從2002年到2005年每個月最後一週的星期五的10點15分觸發0 15 10 ? * 6#3每個月的第三週的星期五開始觸發 0 0 12 1/5 * ? 每個月的第一個中午開始每隔5天觸發一次 0 11 11 11 11 ? 每一年的11月11號 11點11分觸發(光棍節)
細化
以前作的項目中有五個平臺，分別是出版平臺、圖書館平臺、發行平臺、零售平臺、中心平臺。框架
- 出版平臺：主要是錄入圖書信息和圖書的相關圖片和附件信息
- 圖書館平臺：將出版發送過來的圖書進行借閱和副本的錄入
- 發佈平臺和零售平臺：給圖書錄入訂購、銷售、庫存的數量的信息
- 中心平臺：跟前臺頁面進行交互（管理前臺頁面）
需求一： 在中心平臺中，信息發佈管理模塊有4個管理，分別是：首頁大圖管理、行業信息管理、友情連接管理、文件發佈管理，除了在原有的手動發佈（後臺點擊發布，前臺會展現後臺所發佈的信息）的基礎上，實現定時發佈效果（本身設置任意時間，系統會根據你設置的時間來進行發佈）。異步
需求一頁面效果：ide
需求二：出版、圖書館、發行、零售這四個平臺的信息是能夠相互傳遞的，如出版能夠發送給圖書館、發行和零售，其餘幾個也能夠發送給任何一個平臺(點對點發送)，用的是消息隊列(activemq)來實現了，也是這個項目的核心功能，這個也是，在原來手動發送的基礎上，實現定時發送，這個要複雜一些，實現單獨的模塊，數據交換的策略管理，根據設置的要求和相應的時間，定時進行發送。
需求二頁面效果：
說明：這裏能夠根據通告類型、出版狀態、接收對象(是發送給哪一個平臺，能夠任意選擇)、發送日期和時間進行定時發送
說明：這裏我單獨定義一個包，來寫定時任務的代碼 ScheduleJobController：（這裏控制層沒有在這寫，由於，我要在具體的發送的controller來寫，這裏定義了出來，可是沒有用到）：
package com.jetsen.quartz.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
/**
* @author LY
* @date 2016-07-25
*/
//暫時用不到,定時分佈在各個須要的模塊中
@RequestMapping("schedule")
@Controller
public class ScheduleJobController {
}<strong>
</strong>
ScheduleJob：
package com.jetsen.quartz.entity;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import com.jetsen.model.book.Strategy;
/**
* @author LY
* @date 2016-07-25
*/
@Entity
@Table(name = "task_scheduleJob")
public class ScheduleJob{
/** 任務id */
private Long scheduleJobId;
/** 任務名稱 */
private String jobName;
/** 任務別名 */
private String aliasName;
/** 任務分組 */
private String jobGroup;
/** 觸發器 */
private String jobTrigger;
/** 任務狀態 */
private String status;
/** 任務運行時間表達式 */
private String cronExpression;
/** 是否異步 */
private boolean isSync;
/** 任務描述 */
private Long description;
/** 建立時間 */
private Date gmtCreate;
/** 修改時間 */
private Date gmtModify;
//定時發送的方式
private String sendStyle;
//這裏方便展現
private String taskTime;
private String descInfo;
private String org_codes;
private String org_names;
private String publishState;
private String notificationType;
private Strategy strategy;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name = "scheduleJobId", nullable = false)
public Long getScheduleJobId() {
return scheduleJobId;
}
public void setScheduleJobId(Long scheduleJobId) {
this.scheduleJobId = scheduleJobId;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getAliasName() {
return aliasName;
}
public void setAliasName(String aliasName) {
this.aliasName = aliasName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getJobTrigger() {
return jobTrigger;
}
public void setJobTrigger(String jobTrigger) {
this.jobTrigger = jobTrigger;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public Long getDescription() {
return description;
}
public void setDescription(Long description) {
this.description = description;
}
public Date getGmtCreate() {
return gmtCreate;
}
public void setGmtCreate(Date gmtCreate) {
this.gmtCreate = gmtCreate;
}
public Date getGmtModify() {
return gmtModify;
}
public void setGmtModify(Date gmtModify) {
this.gmtModify = gmtModify;
}
public Boolean getIsSync() {
return isSync;
}
public void setIsSync(Boolean isSync) {
this.isSync = isSync;
}
public String getTaskTime() {
return taskTime;
}
public void setTaskTime(String taskTime) {
this.taskTime = taskTime;
}
public void setSync(boolean isSync) {
this.isSync = isSync;
}
public String getSendStyle() {
return sendStyle;
}
public void setSendStyle(String sendStyle) {
this.sendStyle = sendStyle;
}
public String getDescInfo() {
return descInfo;
}
public void setDescInfo(String descInfo) {
this.descInfo = descInfo;
}
public String getOrg_codes() {
return org_codes;
}
public void setOrg_codes(String org_codes) {
this.org_codes = org_codes;
}
public String getPublishState() {
return publishState;
}
public void setPublishState(String publishState) {
this.publishState = publishState;
}
@ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH }, optional = true)
@JoinColumn(name="stratelyId")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public Strategy getStrategy() {
return strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public String getNotificationType() {
return notificationType;
}
public void setNotificationType(String notificationType) {
this.notificationType = notificationType;
}
public String getOrg_names() {
return org_names;
}
public void setOrg_names(String org_names) {
this.org_names = org_names;
}
}
ScheduleJobInit：
package com.jetsen.quartz.event;
import javax.annotation.PostConstruct;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.jetsen.quartz.service.ScheduleJobService;
/**
* 定時任務初始化
* @author LY
* @date 2016-07-25
*/
@Component
public class ScheduleJobInit {
/** 日誌對象 */
private static final Logger LOG = LoggerFactory.getLogger(ScheduleJobInit.class);
/** 定時任務service */
@Autowired
private ScheduleJobService scheduleJobService;
/**
* 項目啓動時初始化
*/
@PostConstruct
public void init() {
if (LOG.isInfoEnabled()) {
LOG.info("init");
}
scheduleJobService.initScheduleJob();
if (LOG.isInfoEnabled()) {
LOG.info("end");
}
}
}
ScheduleException：
package com.jetsen.quartz.exceptions;
import com.dexcoder.commons.exceptions.DexcoderException;
/**
* 自定義異常
* @author LY
* @date 2016-07-25
*/
public class ScheduleException extends DexcoderException {
/** serialVersionUID */
private static final long serialVersionUID = -1921648378954132894L;
/**
* Instantiates a new ScheduleException.
*
* @param e the e
*/
public ScheduleException(Throwable e) {
super(e);
}
/**
* Constructor
*
* @param message the message
*/
public ScheduleException(String message) {
super(message);
}
/**
* Constructor
*
* @param code the code
* @param message the message
*/
public ScheduleException(String code, String message) {
super(code, message);
}
}
JobFactory：
package com.jetsen.quartz.factory;
import java.util.Date;
import java.util.List;
import javax.servlet.http.HttpServletRequest;
import org.quartz.DisallowConcurrentExecution;
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.stereotype.Service;
import com.jetsen.common.bean.SpringBeanUtil;
import com.jetsen.common.util.StringUtil;
import com.jetsen.controller.LibraryController;
import com.jetsen.model.book.Book;
import com.jetsen.model.cms.Manuscript;
import com.jetsen.quartz.entity.ScheduleJob;
import com.jetsen.quartz.service.ScheduleJobService;
import com.jetsen.quartz.vo.ScheduleJobVo;
import com.jetsen.service.BookService;
import com.jetsen.service.ManuscriptService;
/**
* 任務工廠類,非同步
* @author LY
* @date 2016-07-25
*/
@DisallowConcurrentExecution
public class JobFactory implements Job {
/* 日誌對象 */
private static final Logger LOG = LoggerFactory.getLogger(JobFactory.class);
public void execute(JobExecutionContext context) throws JobExecutionException {
LOG.info("JobFactory execute");
/*ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get(
ScheduleJobVo.JOB_PARAM_KEY);*/
ManuscriptService manuscriptService = (ManuscriptService) SpringBeanUtil.getBean("jcManuscriptService");
BookService companybookService = (BookService) SpringBeanUtil.getBean("bookService");
ScheduleJobService scheduleJobService = (ScheduleJobService) SpringBeanUtil.getBean("scheduleJobService");
JobDataMap dataMap = context.getJobDetail().getJobDataMap();
Long ids = dataMap.getLong("jobParam");
//Manuscript content = manuscriptService.getManuScriptByTask(ids);
String library = dataMap.getString("library");
String issue = dataMap.getString("issue");
String books = dataMap.getString("book");
if(library!=null){
String publishStatus = dataMap.getString("publishStatus");
if(library.equals("library") || "liarary".equals(library)){
List<Book> bookList = companybookService.getBookList(1,publishStatus);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
//companybookService.updateIsSend(2, bookIds);
}
//scheduleJobService.updateStatus("0");
companybookService.send(null, null, null, null, null,bookIds);
}
}
}
if(issue!=null){
String publishStatus = dataMap.getString("publishStatus");
if(issue.equals("issue") || "issue".equals(issue)){
List<Book> bookList = companybookService.getBookList(1,publishStatus);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
//companybookService.updateIsSend(2, bookIds);
}
//scheduleJobService.updateStatus("0");
companybookService.send(null, null, null, null, null,bookIds);
}
}
}
if(books!=null){
String org_codes = dataMap.getString("org_codes");
String publishStatus = dataMap.getString("publishStatus");
String notificationType = dataMap.getString("notificationType");
if(books.equals("book") || "book".equals(books)){
List<Book> bookList = companybookService.getBookList(0,publishStatus);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
// companybookService.updateIsSend(1, bookIds);
}
companybookService.bookSend(notificationType,org_codes,bookIds);
//scheduleJobService.updateStatus("0");
}
}
}
if(ids!=0L){
manuscriptService.publishSingleState(1, new Date(), ids);
scheduleJobService.updateInfoStatus("0", ids);
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
JobSyncFactory：
package com.jetsen.quartz.factory;
import java.util.Date;
import java.util.List;
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 com.jetsen.common.bean.SpringBeanUtil;
import com.jetsen.model.book.Book;
import com.jetsen.quartz.service.ScheduleJobService;
import com.jetsen.service.BookService;
import com.jetsen.service.ManuscriptService;
/**
* 同步的任務工廠類
* @author LY
* @date 2016-07-25
*/
public class JobSyncFactory implements Job {
private static final Logger LOG = LoggerFactory.getLogger(JobSyncFactory.class);
public void execute(JobExecutionContext context) throws JobExecutionException {
LOG.info("JobSyncFactory execute");
/* JobDataMap mergedJobDataMap = jobExecutionContext.getMergedJobDataMap();
ScheduleJob scheduleJob = (ScheduleJob) mergedJobDataMap.get(ScheduleJobVo.JOB_PARAM_KEY);
System.out.println("jobName:" + scheduleJob.getJobName() + " " + scheduleJob);*/
ManuscriptService manuscriptService = (ManuscriptService) SpringBeanUtil.getBean("jcManuscriptService");
BookService companybookService = (BookService) SpringBeanUtil.getBean("bookService");
ScheduleJobService scheduleJobService = (ScheduleJobService) SpringBeanUtil.getBean("scheduleJobService");
JobDataMap dataMap = context.getJobDetail().getJobDataMap();
Long ids = dataMap.getLong("jobParam");
//Manuscript content = manuscriptService.getManuScriptByTask(ids);
String library = dataMap.getString("library");
String issue = dataMap.getString("issue");
String books = dataMap.getString("book");
if(library!=null){
//String publishStatus = dataMap.getString("publishStatus");
if(library.equals("library") || "liarary".equals(library)){
List<Book> bookList = companybookService.getBookList(1);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
//companybookService.updateIsSend(2, bookIds);
}
//scheduleJobService.updateStatus("0");
companybookService.send(null, null, null, null, null,bookIds);
}
}
}
if(issue!=null){
//String publishStatus = dataMap.getString("publishStatus");
if(issue.equals("issue") || "issue".equals(issue)){
List<Book> bookList = companybookService.getBookList(1);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
//companybookService.updateIsSend(2, bookIds);
}
//scheduleJobService.updateStatus("0");
companybookService.send(null, null, null, null, null,bookIds);
}
}
}
if(books!=null){
String org_codes = dataMap.getString("org_codes");
String publishStatus = dataMap.getString("publishStatus");
String notificationType = dataMap.getString("notificationType");
if(books.equals("book") || "book".equals(books)){
List<Book> bookList = companybookService.getBookList(0,publishStatus);
if(bookList!=null && bookList.size()>0){
String bookIds = "";
for (Book book : bookList) {
bookIds += book.getBookid()+",";
// companybookService.updateIsSend(1, bookIds);
}
companybookService.bookSend(notificationType,org_codes,bookIds);
//scheduleJobService.updateStatus("0");
}
}
}
if(ids!=null && ids!=0){
manuscriptService.publishSingleState(1, new Date(), ids);
scheduleJobService.updateInfoStatus("0", ids);
}
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
說明：同步方法：好比說我定時了固定的時候，設置了好幾個，都是在這個時間執行，那就要走同步方法才能夠；非同步方法，是設置一個時間點，跟其餘不衝突，這個沒有問題，這裏是要注意的地方，而後這倆方法能夠加入本身想要執行的業務邏輯，這裏只需知道怎麼傳遞參數過來就好了，好比我判斷了，或者傳過來id啦，這裏均可以的。
JobDataMap dataMap = context.getJobDetail().getJobDataMap();
Long ids = dataMap.getLong("jobParam");
String library = dataMap.getString("library");
這裏能夠接收不一樣的類型，好比我這裏獲取id用long來接收，而根據不一樣平臺進行判斷是string來接收參數。
ScheduleJobService：
package com.jetsen.quartz.service;
import java.util.List;
import com.jetsen.quartz.entity.ScheduleJob;
import com.jetsen.quartz.vo.ScheduleJobVo;
/**
* 定時任務service
* @author LY
* @date 2016-07-25
*/
public interface ScheduleJobService {
/**
* 初始化定時任務
*/
public void initScheduleJob();
/**
* 新增(這裏參加增長是Mq的機構碼)
* @param scheduleJobVo
* @return
*/
public void insert(ScheduleJobVo scheduleJobVo);
/**
* 直接修改 只能修改運行的時間，參數、同異步等沒法修改
*
* @param scheduleJobVo
*/
public void update(ScheduleJobVo scheduleJobVos);
/**
* 刪除從新建立方式
*
* @param scheduleJobVo
*/
public void delUpdate(ScheduleJobVo scheduleJobVo);
/**
* 刪除
*
* @param scheduleJobId
*/
public void delete(Long scheduleJobId);
/**
* 運行一次任務
*
* @param scheduleJobId the schedule job id
* @return
*/
public void runOnce(Long scheduleJobId);
/**
* 暫停任務
*
* @param scheduleJobId the schedule job id
* @return
*/
public void pauseJob(Long scheduleJobId);
/**
* 恢復任務
*
* @param scheduleJobId the schedule job id
* @return
*/
public void resumeJob(Long scheduleJobId);
/**
* 獲取任務對象
*
* @param scheduleJobId
* @return
*/
public ScheduleJobVo get(Long scheduleJobId);
/**
* 查詢任務列表
*
* @param scheduleJobVo
* @return
*/
public List<ScheduleJobVo> queryList(ScheduleJobVo scheduleJobVo);
/**
* 獲取運行中的任務列表
*
* @return
*/
public List<ScheduleJobVo> queryExecutingJobList();
/**
* 修改狀態
* @param status
*/
public void updateStatus(String status,Long scheduleJobId);
/**
* 修改狀態
* @param status
*/
public void updateInfoStatus(String status,Long scheduleJobId);
/**
* 根據發送狀態查重
* @param sendStyle
* @return
*/
public List<ScheduleJobVo> findByStyle(String sendStyle);
/**
* 根據id查詢定時任務
* @param id
* @return
*/
public List<ScheduleJobVo> findById(Long id);
/**
* 更新按鈕參數
* @param desc
* @param sid
*/
public void updateDesc(Long desc,Long sid);
/**
* 根據策略id刪除定時任務
* @param sid
*/
public void deleteBySid(Long sid);
}
ScheduleJobServiceImpl：
package com.jetsen.quartz.service.impl;
import java.util.ArrayList;
import java.util.List;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.dexcoder.commons.bean.BeanConverter;
import com.jetsen.quartz.entity.ScheduleJob;
import com.jetsen.quartz.service.ScheduleJobService;
import com.jetsen.quartz.util.ScheduleUtils;
import com.jetsen.quartz.vo.ScheduleJobVo;
import com.jetsen.repository.SchedulejobRepository;
/**
* 定時任務
* @author LY
* @date 2016-07-25
*/
@Service("scheduleJobService")
public class ScheduleJobServiceImpl implements ScheduleJobService {
/** 調度工廠Bean */
@Autowired
private Scheduler scheduler;
@Autowired
private SchedulejobRepository schedulejobRepository;
public void initScheduleJob() {
List<ScheduleJob> scheduleJobList = schedulejobRepository.findAll();
if (scheduleJobList==null) {
return;
}
for (ScheduleJob scheduleJob : scheduleJobList) {
CronTrigger cronTrigger = ScheduleUtils.getCronTrigger(scheduler, scheduleJob.getJobName(),
scheduleJob.getJobGroup());
if(scheduleJob.getStatus().equals("1")){
//不存在，建立一個
if (cronTrigger == null) {
ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
} else {
//已存在，那麼更新相應的定時設置
ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
}
}
}
}
public void insert(ScheduleJobVo scheduleJobVo) {
ScheduleJob scheduleJob = scheduleJobVo.getTargetObject(ScheduleJob.class);
ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
if(scheduleJob.getSendStyle()!=null){
if(scheduleJobVo.getSendStyle().equals("job-library") || scheduleJobVo.getSendStyle().equals("job-library")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-issue") || scheduleJobVo.getSendStyle().equals("job-issue")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-book") || scheduleJobVo.getSendStyle().equals("job-book")){
schedulejobRepository.save(scheduleJob);
}
}
}
@Override
public void update(ScheduleJobVo scheduleJobVo) {
ScheduleJob scheduleJob = scheduleJobVo.getTargetObject(ScheduleJob.class);
ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
if(scheduleJob.getSendStyle()!=null){
if(scheduleJobVo.getSendStyle().equals("job-library") || scheduleJobVo.getSendStyle().equals("job-library")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-issue") || scheduleJobVo.getSendStyle().equals("job-issue")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("other") || scheduleJobVo.getSendStyle().equals("other")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-book") || scheduleJobVo.getSendStyle().equals("job-book")){
schedulejobRepository.save(scheduleJob);
}
}
}
public void delUpdate(ScheduleJobVo scheduleJobVo) {
ScheduleJob scheduleJob = scheduleJobVo.getTargetObject(ScheduleJob.class);
//先刪除
ScheduleUtils.deleteScheduleJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup());
//再建立
ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
if(scheduleJob.getSendStyle()!=null){
if(scheduleJobVo.getSendStyle().equals("job-library") || scheduleJobVo.getSendStyle().equals("job-library")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-issue") || scheduleJobVo.getSendStyle().equals("job-issue")){
schedulejobRepository.save(scheduleJob);
}
if(scheduleJobVo.getSendStyle().equals("job-book") || scheduleJobVo.getSendStyle().equals("job-book")){
schedulejobRepository.save(scheduleJob);
}
}
}
public void delete(Long scheduleJobId) {
ScheduleJob scheduleJob = schedulejobRepository.findOne(scheduleJobId);
//刪除運行的任務
ScheduleUtils.deleteScheduleJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup());
//刪除數據
//schedulejobRepository.delete(scheduleJobId);
}
public void runOnce(Long scheduleJobId) {
ScheduleJob scheduleJob = schedulejobRepository.findOne(scheduleJobId);
ScheduleUtils.runOnce(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup());
}
public void pauseJob(Long scheduleJobId) {
ScheduleJob scheduleJob = schedulejobRepository.findOne(scheduleJobId);
ScheduleUtils.pauseJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup());
//演示數據庫就不更新了
}
public void resumeJob(Long scheduleJobId) {
ScheduleJob scheduleJob = schedulejobRepository.findOne(scheduleJobId);
ScheduleUtils.resumeJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup());
//演示數據庫就不更新了
}
//這裏是vo不知道爲何
/*public ScheduleJobVo get(Long scheduleJobId) {
ScheduleJobVo scheduleJob = schedulejobRepository.findOne(scheduleJobId);
return scheduleJob;
}*/
public List<ScheduleJobVo> queryList(ScheduleJobVo scheduleJobVo) {
List<ScheduleJob> scheduleJobs = schedulejobRepository.findAll();
List<ScheduleJobVo> scheduleJobVoList = BeanConverter.convert(ScheduleJobVo.class, scheduleJobs);
try {
for (ScheduleJobVo vo : scheduleJobVoList) {
JobKey jobKey = ScheduleUtils.getJobKey(vo.getJobName(), vo.getJobGroup());
List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
if (triggers.size()==0) {
continue;
}
//這裏一個任務能夠有多個觸發器， 可是咱們一個任務對應一個觸發器，因此只取第一個便可，清晰明瞭
Trigger trigger = triggers.iterator().next();
scheduleJobVo.setJobTrigger(trigger.getKey().getName());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
vo.setStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
vo.setCronExpression(cronExpression);
}
}
} catch (SchedulerException e) {
//演示用，就不處理了
}
return scheduleJobVoList;
}
public List<ScheduleJobVo> queryExecutingJobList() {
try {
List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
List<ScheduleJobVo> jobList = new ArrayList<ScheduleJobVo>(executingJobs.size());
for (JobExecutionContext executingJob : executingJobs) {
ScheduleJobVo job = new ScheduleJobVo();
JobDetail jobDetail = executingJob.getJobDetail();
JobKey jobKey = jobDetail.getKey();
Trigger trigger = executingJob.getTrigger();
job.setJobName(jobKey.getName());
job.setJobGroup(jobKey.getGroup());
job.setJobTrigger(trigger.getKey().getName());
Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
job.setStatus(triggerState.name());
if (trigger instanceof CronTrigger) {
CronTrigger cronTrigger = (CronTrigger) trigger;
String cronExpression = cronTrigger.getCronExpression();
job.setCronExpression(cronExpression);
}
jobList.add(job);
}
return jobList;
} catch (SchedulerException e) {
//演示用，就不處理了
return null;
}
}
@Override
public ScheduleJobVo get(Long scheduleJobId) {
return schedulejobRepository.findById(scheduleJobId);
}
@Override
public void updateStatus(String status,Long scheduleJobId) {
schedulejobRepository.updateStatus(status,scheduleJobId);
}
@Override
public List<ScheduleJobVo> findByStyle(String sendStyle) {
return schedulejobRepository.findByStyle(sendStyle);
}
@Override
public void updateDesc(Long desc, Long sid) {
schedulejobRepository.updateStatus(desc, sid);
}
@Override
public List<ScheduleJobVo> findById(Long id) {
return schedulejobRepository.findBySId(id);
}
@Override
public void deleteBySid(Long sid) {
schedulejobRepository.delete_strategy(sid);
}
@Override
public void updateInfoStatus(String status, Long scheduleJobId) {
schedulejobRepository.updateInfoStatus(status, scheduleJobId);
}
}
ScheduleUtils：
package com.jetsen.quartz.util;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jetsen.quartz.entity.ScheduleJob;
import com.jetsen.quartz.exceptions.ScheduleException;
import com.jetsen.quartz.factory.JobFactory;
import com.jetsen.quartz.factory.JobSyncFactory;
import com.jetsen.quartz.vo.ScheduleJobVo;
/**
* 定時任務輔助類
* @author LY
* @date 2016-07-25
*/
public class ScheduleUtils {
/** 日誌對象 */
private static final Logger LOG = LoggerFactory.getLogger(ScheduleUtils.class);
/**
* 獲取觸發器key
*
* @param jobName
* @param jobGroup
* @return
*/
public static TriggerKey getTriggerKey(String jobName, String jobGroup) {
return TriggerKey.triggerKey(jobName, jobGroup);
}
/**
* 獲取表達式觸發器
*
* @param scheduler the scheduler
* @param jobName the job name
* @param jobGroup the job group
* @return cron trigger
*/
public static CronTrigger getCronTrigger(Scheduler scheduler, String jobName, String jobGroup) {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
return (CronTrigger) scheduler.getTrigger(triggerKey);
} catch (SchedulerException e) {
LOG.info("獲取定時任務CronTrigger出現異常", e);
throw new ScheduleException("獲取定時任務CronTrigger出現異常");
}
}
/**
* 建立任務
*
* @param scheduler the scheduler
* @param scheduleJob the schedule job
*/
public static void createScheduleJob(Scheduler scheduler, ScheduleJob scheduleJob) {
createScheduleJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup(),
scheduleJob.getCronExpression(), scheduleJob.getIsSync(), scheduleJob.getDescription(),scheduleJob.getStatus(),scheduleJob.getSendStyle(),scheduleJob.getOrg_codes(),scheduleJob.getPublishState(),scheduleJob.getNotificationType());
}
/**
* 建立定時任務
*
* @param scheduler the scheduler
* @param jobName the job name
* @param jobGroup the job group
* @param cronExpression the cron expression
* @param isSync the is sync
* @param param the param
*/
public static void createScheduleJob(Scheduler scheduler, String jobName, String jobGroup,
String cronExpression, boolean isSync, Long param,String status,String sendStyle,String org_codes,String publishStatus,String notificationType) {
//同步或異步
Class<? extends Job> jobClass = isSync ? JobSyncFactory.class : JobFactory.class;
//構建job信息
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();
if(param!=null){
//放入參數，運行時的方法能夠獲取
jobDetail.getJobDataMap().put(ScheduleJobVo.JOB_PARAM_KEY, param);
}else{
Long paramValue = 0L;
jobDetail.getJobDataMap().put(ScheduleJobVo.JOB_PARAM_KEY, paramValue);
}
if(sendStyle!=null){
if(sendStyle.equals("job-library") || "job-library".equals(sendStyle)){
jobDetail.getJobDataMap().put("library", "library");
}
if(sendStyle.equals("job-issue") || "job-issue".equals(sendStyle)){
jobDetail.getJobDataMap().put("issue", "issue");
}
if(sendStyle.equals("job-book") || "job-book".equals(sendStyle)){
jobDetail.getJobDataMap().put("book", "book");
}
}
if(org_codes!=null){
jobDetail.getJobDataMap().put("org_codes", org_codes);
}
if(publishStatus!=null){
jobDetail.getJobDataMap().put("publishStatus", publishStatus);
}
if(notificationType!=null){
jobDetail.getJobDataMap().put("notificationType", notificationType);
}
//表達式調度構建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
//按新的cronExpression表達式構建一個新的trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup)
.withSchedule(scheduleBuilder).build();
try {
if(status.equals("1")){
scheduler.scheduleJob(jobDetail, trigger);
}
} catch (SchedulerException e) {
LOG.info("建立定時任務失敗", e);
throw new ScheduleException("建立定時任務失敗");
}
}
/**
* 運行一次任務
*
* @param scheduler
* @param jobName
* @param jobGroup
*/
public static void runOnce(Scheduler scheduler, String jobName, String jobGroup) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
try {
scheduler.triggerJob(jobKey);
} catch (SchedulerException e) {
LOG.info("運行一次定時任務失敗", e);
throw new ScheduleException("運行一次定時任務失敗");
}
}
/**
* 暫停任務
*
* @param scheduler
* @param jobName
* @param jobGroup
*/
public static void pauseJob(Scheduler scheduler, String jobName, String jobGroup) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
try {
scheduler.pauseJob(jobKey);
} catch (SchedulerException e) {
LOG.info("暫停定時任務失敗", e);
throw new ScheduleException("暫停定時任務失敗");
}
}
/**
* 恢復任務
*
* @param scheduler
* @param jobName
* @param jobGroup
*/
public static void resumeJob(Scheduler scheduler, String jobName, String jobGroup) {
JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
try {
scheduler.resumeJob(jobKey);
} catch (SchedulerException e) {
LOG.info("暫停定時任務失敗", e);
throw new ScheduleException("暫停定時任務失敗");
}
}
/**
* 獲取jobKey
*
* @param jobName the job name
* @param jobGroup the job group
* @return the job key
*/
public static JobKey getJobKey(String jobName, String jobGroup) {
return JobKey.jobKey(jobName, jobGroup);
}
/**
* 更新定時任務
*
* @param scheduler the scheduler
* @param scheduleJob the schedule job
*/
public static void updateScheduleJob(Scheduler scheduler, ScheduleJob scheduleJob) {
updateScheduleJob(scheduler, scheduleJob.getJobName(), scheduleJob.getJobGroup(),
scheduleJob.getCronExpression(), scheduleJob.getIsSync(), scheduleJob);
}
/**
* 更新定時任務
*
* @param scheduler the scheduler
* @param jobName the job name
* @param jobGroup the job group
* @param cronExpression the cron expression
* @param isSync the is sync
* @param param the param
*/
public static void updateScheduleJob(Scheduler scheduler, String jobName, String jobGroup,
String cronExpression, boolean isSync, Object param) {
//同步或異步
// Class<? extends Job> jobClass = isSync ? JobSyncFactory.class : JobFactory.class;
try {
// JobDetail jobDetail = scheduler.getJobDetail(getJobKey(jobName, jobGroup));
// jobDetail = jobDetail.getJobBuilder().ofType(jobClass).build();
//更新參數 實際測試中發現沒法更新
// JobDataMap jobDataMap = jobDetail.getJobDataMap();
// jobDataMap.put(ScheduleJobVo.JOB_PARAM_KEY, param);
// jobDetail.getJobBuilder().usingJobData(jobDataMap);
TriggerKey triggerKey = ScheduleUtils.getTriggerKey(jobName, jobGroup);
//表達式調度構建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//按新的cronExpression表達式從新構建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder)
.build();
//按新的trigger從新設置job執行
scheduler.rescheduleJob(triggerKey, trigger);
} catch (SchedulerException e) {
LOG.info("更新定時任務失敗", e);
throw new ScheduleException("更新定時任務失敗");
}
}
/**
* 刪除定時任務
*
* @param scheduler
* @param jobName
* @param jobGroup
*/
public static void deleteScheduleJob(Scheduler scheduler, String jobName, String jobGroup) {
try {
scheduler.deleteJob(getJobKey(jobName, jobGroup));
} catch (SchedulerException e) {
LOG.info("刪除定時任務失敗", e);
throw new ScheduleException("刪除定時任務失敗");
}
}
}
說明：看，這裏的**jobDetail.getJobDataMap().put("library", "library");**就是將你想傳遞的參數進行put壓值
ScheduleJobVo：
package com.jetsen.quartz.vo;
import java.util.Date;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
import com.dexcoder.commons.pager.Pageable;
import com.jetsen.model.book.Strategy;
/**
* @author LY
* @date 2016-07-25
*/
@Entity
@Table(name = "task_scheduleJob")
public class ScheduleJobVo extends Pageable {
private static final long serialVersionUID = -4216107640768329946L;
/** 任務調度的參數key */
public static final String JOB_PARAM_KEY = "jobParam";
/** 任務id */
private Long scheduleJobId;
/** 任務名稱 */
private String jobName;
/** 任務別名 */
private String aliasName;
/** 任務分組 */
private String jobGroup;
/** 觸發器 */
private String jobTrigger;
/** 任務狀態 */
private String status;
/** 任務運行時間表達式 */
private String cronExpression;
/** 是否異步 */
private boolean isSync;
/** 任務描述 */
private Long description;
/** 建立時間 */
private Date gmtCreate;
/** 修改時間 */
private Date gmtModify;
//發送方式
private String sendStyle;
//這裏方便展現
private String taskTime;
private String descInfo;
/** 定時的機構編碼封裝在表中方便傳遞*/
private String org_codes;
private String org_names;
private String publishState;//出版狀態
private String notificationType;
private Strategy strategy;
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name = "scheduleJobId", nullable = false)
public Long getScheduleJobId() {
return scheduleJobId;
}
public void setScheduleJobId(Long scheduleJobId) {
this.scheduleJobId = scheduleJobId;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getAliasName() {
return aliasName;
}
public void setAliasName(String aliasName) {
this.aliasName = aliasName;
}
public String getJobGroup() {
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public String getJobTrigger() {
return jobTrigger;
}
public void setJobTrigger(String jobTrigger) {
this.jobTrigger = jobTrigger;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public Long getDescription() {
return description;
}
public void setDescription(Long description) {
this.description = description;
}
public void setSync(boolean isSync) {
this.isSync = isSync;
}
public Date getGmtCreate() {
return gmtCreate;
}
public void setGmtCreate(Date gmtCreate) {
this.gmtCreate = gmtCreate;
}
public Date getGmtModify() {
return gmtModify;
}
public void setGmtModify(Date gmtModify) {
this.gmtModify = gmtModify;
}
public Boolean getIsSync() {
return isSync;
}
public void setIsSync(Boolean isSync) {
this.isSync = isSync;
}
public String getTaskTime() {
return taskTime;
}
public void setTaskTime(String taskTime) {
this.taskTime = taskTime;
}
public String getSendStyle() {
return sendStyle;
}
public void setSendStyle(String sendStyle) {
this.sendStyle = sendStyle;
}
public String getDescInfo() {
return descInfo;
}
public void setDescInfo(String descInfo) {
this.descInfo = descInfo;
}
public String getOrg_codes() {
return org_codes;
}
public void setOrg_codes(String org_codes) {
this.org_codes = org_codes;
}
public String getPublishState() {
return publishState;
}
public void setPublishState(String publishState) {
this.publishState = publishState;
}
@ManyToOne(cascade = {CascadeType.MERGE,CascadeType.REFRESH }, optional = true)
@JoinColumn(name="stratelyId")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public Strategy getStrategy() {
return strategy;
}
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public String getNotificationType() {
return notificationType;
}
public void setNotificationType(String notificationType) {
this.notificationType = notificationType;
}
public String getOrg_names() {
return org_names;
}
public void setOrg_names(String org_names) {
this.org_names = org_names;
}
}
StrategyController（實現的controller）：
@RequestMapping("/saveScheduleSend")
public String saveScheduleSend(String times,String org_codes,String strategyName,String org_name,RedirectAttributes redirectAttributes,String[] englishName,
String publish_status,String notification_type,String taskSwitch,Long sid,String type,String style) throws Exception{
String task = "";
/*if(times.indexOf(",")>0){
task = times.substring(0,times.length() - 1);
}else{
task = times;
}*/
/*if(org_name.indexOf(",")>0){
org_name = org_name.substring(1, org_name.length());
}*/
if(style.equals("edit") && "edit".equals(style)){
if (times.lastIndexOf(",")>0) {
task = times.substring(0,times.length() - 1);
}else if(times.startsWith(",")){
task = times.substring(1, times.length());
}else{
task = times;
}
}else{
task = times.substring(0,times.length() - 1);
}
//SimpleDateFormat sdf = new SimpleDateFormat("HH:mm");
List<ScheduleJobVo> jobList = scheduleJobService.findById(sid);
ScheduleJobVo job = new ScheduleJobVo();
//if(task!=null && !"".equals(task)){
//String[] time = task.split(",");
//for (int i = 0; i < time.length; i++) {
String express = "";
String[] time = task.split(",");
String hour = "";
String minute = "";
for (int i = 0; i < time.length; i++) {
String one[] = time[i].split(":");
hour+=one[0]+",";
minute+=one[1]+",";
}
hour = hour.substring(0,hour.length()-1);
minute = minute.substring(0,minute.length()-1);
express = minute+" "+hour;
/*if(task!=null && !"".equals(task)){
String[] time = task.split(",");
for (int i = 0; i < time.length; i++) {
String[] minutes = task.split(":");
Date date = sdf.parse(time[i]);
minut
}
}*/
//express = express.substring(0, express.length()-1);
String cron = "";
String desc = "";
String descInfo = "";
if(englishName!=null){
List<Columns> cList = columnsService.getColumnsByEnglish(englishName);
for (Columns columns : cList) {
desc += columns.getColumnName()+",";
}
desc = desc.substring(0, desc.length()-1);
String newName = "";
for (int j = 0; j < englishName.length; j++) {
newName += englishName[j]+",";
}
newName = newName.substring(0, newName.length()-1);
cron = "0 "+express+" ? *"+" "+newName;
descInfo = desc;
}else{
cron = "0 "+express+" * * ?";
descInfo = "星期一,星期二,星期三,星期四,星期五,星期六,星期日";
}
String uuid = UUID.getUUID();
job.setJobName(uuid);
job.setJobGroup("group"+1);
job.setAliasName("alias"+1);
job.setStatus("0");
if(taskSwitch!=null && !"".equals(taskSwitch)){
if(taskSwitch.equals("開") || "開".equals(taskSwitch)){
job.setDescription(1L);
}else{
job.setDescription(0L);
}
}
if(jobList!=null && jobList.size()>0){
for (ScheduleJobVo scheduleJobVo : jobList) {
scheduleJobVo.setJobName(uuid);
scheduleJobVo.setJobGroup("group"+1);
scheduleJobVo.setAliasName("alias"+1);
scheduleJobVo.setStatus("0");
scheduleJobVo.setDescInfo(descInfo);
scheduleJobVo.setCronExpression(cron);
scheduleJobVo.setIsSync(true);
if(taskSwitch!=null && !"".equals(taskSwitch)){
scheduleJobVo.setDescription(1L);
}else{
scheduleJobVo.setDescription(0L);
}
Strategy strategy = strategyService.findById(sid);
if(strategy!=null){
strategy.setPublishStatus(publish_status);
strategy.setNotificationType(notification_type);
strategy.setSwitchStatus("0");
strategy.setStrategyStyle(strategyName);
scheduleJobVo.setStrategy(strategy);
}
scheduleJobVo.setPublishState(publish_status);
scheduleJobVo.setNotificationType(notification_type);
scheduleJobVo.setTaskTime(task);
scheduleJobVo.setSendStyle(type);
scheduleJobVo.setOrg_codes(org_codes);
scheduleJobVo.setOrg_names(org_name);
scheduleJobService.delUpdate(scheduleJobVo);
}
}else{
job.setDescInfo(descInfo);
//String cron=getCron(date);
job.setPublishState(publish_status);
job.setNotificationType(notification_type);
job.setCronExpression(cron);
job.setIsSync(true);
job.setSendStyle(type);
job.setOrg_codes(org_codes);
job.setOrg_names(org_name);
Strategy strategy = new Strategy();
strategy.setSwitchStatus("0");
strategy.setPublishStatus(publish_status);
strategy.setNotificationType(notification_type);
strategy.setStrategyStyle(strategyName);
strategyService.doAdd(strategy);
job.setStrategy(strategy);
if(org_name!=null && !"".equals(org_name)){
String[] orgName = org_name.split(",");
for (int k = 0; k < orgName.length; k++) {
String[] orgCode = org_codes.split(",");
ConfigOrganization organization = new ConfigOrganization();
organization.setOrgName(orgName[k]);
organization.setOrgCode(orgCode[k]);
organization.setStrategy(strategy);
configOrganizationService.addOrganization(organization);
}
}
job.setTaskTime(task);
scheduleJobService.insert(job);
}
//}
//job.setTaskTime(time);
//}
//String[] names = descInfo.split(",");
/*columnsService.updateStatus(0);
columnsService.updateStatus(1, names);*/
//configOrganizationService.delete();
return "redirect:/strategy/schedule?type="+type;
}
接下來，在這個controller裏寫了時間格式的轉換的方法：
public static String getCron(java.util.Date date){
//String dateFormat="ss mm HH dd MM ? yyyy";
String = "0 mm HH * * ?";
return formatDateByPattern(date, dateFormat);
}
public static String getDayCron(java.util.Date date){
//String dateFormat="ss mm HH dd MM ? yyyy";
//String dateFormat = "0 mm HH ? *";
String dateFormat = "mm HH";
return formatDateByPattern(date, dateFormat);
}
public static String getMinuteCron(java.util.Date date){
//String dateFormat="ss mm HH dd MM ? yyyy";
//String dateFormat = "0 mm HH ? *";
String dateFormat = "mm";
return formatDateByPattern(date, dateFormat);
}
public static String getHourCron(java.util.Date date){
//String dateFormat="ss mm HH dd MM ? yyyy";
//String dateFormat = "0 mm HH ? *";
String dateFormat = "HH";
return formatDateByPattern(date, dateFormat);
}
spring-quartz.xml（這裏須要添加配置文件）：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>
</beans>
這裏列出了我在項目中實現代碼，若是需求類似，能夠按照這個路線來，中心思想是跟我寫的任務(一)是一個道理，這裏主要仍是依賴於Quartz框架。
更加細化
有時候，咱們用quartz有這樣的需求，在保存定時任務的表中增長一列，是一個定時任務，一個觸發的時間，而後根據你設置的時間會執行定時任務。可是，當我設置多個時間的話，我不可能每次一個一個設置，一個一個保存到數據庫（這裏針對於頁面交互型的，而不是配置文件設置的形式），這樣的話太繁瑣，那怎麼解決呢？
個人設置界面以下：
數據庫保存以後的形式
這裏能夠根據設置的時間能夠看出設置形式，頁面交互的話轉換成這種形式便可。
代碼：
String[] time = task.split(",");//前臺傳遞過來的多條時間
String hour = "";
String minute = "";
for (int i = 0; i < time.length; i++) {
String one[] = time[i].split(":");
hour+=one[0]+",";
minute+=one[1]+",";
}
hour = hour.substring(0,hour.length()-1);
minute = minute.substring(0,minute.length()-1);
express = minute+" "+hour;
cron = "0 "+express+" ? *"+" "+newName;
scheduleJobVo.setCronExpression(cron);//把設置好的expression保存到數據庫
相關文章
- 1. Quartz框架來實現定時任務
- 2. Quartz實現動態定時任務
- 3. Quartz定時任務框架
- 4. 定時任務框架Quartz
- 5. 定時任務框架quartz
- 6. Java 實現定時任務（Quartz 框架）定時執行某個任務（Maven版）
- 7. 【quartz】springboot 集成 quartz 實現動態管理定時任務
- 8. quartz實現定時任務
- 9. SpringBoot 整合 Quartz 實現 JAVA 定時任務的動態配置
- 10. Quartz實現JAVA定時任務的動態配置
- 更多相關文章...
- • XSD 如何使用? - XML Schema 教程
- • Eclipse 任務管理 - Eclipse 教程
- • Spring Cloud 微服務實戰(三) - 服務註冊與發現
- • ☆基於Java Instrument的Agent實現
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
