在實際專案應用中經常會用到定時任務，可以通過quartz和spring的簡單配置即可完成，但如果要改變任務的執行時間、頻率，廢棄任務等就需要改變配置甚至程式碼需要重啟伺服器，這裡介紹一下如何通過quartz與spring的組合實現動態的改變定時任務的狀態的一個實現。

本文章適合對quartz和spring有一定了解的讀者。
spring版本為3.2  quartz版本為2.2.1  如果使用了quartz2.2.1 則spring版本需3.1以上

1.
spring中引入註冊bean

1. <bean id="schedulerFactoryBean"  
2.         class
   ="org.springframework.scheduling.quartz.SchedulerFactoryBean" />  

為什麼要與spring結合？
與spring結合可以使用spring統一管理quartz中任務的生命週期，使得web容器關閉時所有的任務一同關閉。如果不用spring管理可能會出現web容器關閉而任務仍在繼續執行的情況，不與spring結合的話要自己控制任務在容器關閉時一起關閉。

2.建立儲存計劃任務資訊的實體類

1. /** 
2.  *  
3. * @Description: 計劃任務資訊 
4. * @author snailxr 
5. * @date 2014年4月24日 下午10:49:43
    
6.  */  
7. public class ScheduleJob {  
8.     public static final String STATUS_RUNNING = "1";  
9.     public static final String STATUS_NOT_RUNNING = "0";  
10.     public static final String CONCURRENT_IS = "1";  
11.     public static final String CONCURRENT_NOT = "0";  
12.     private Long jobId;  
13.     private Date createTime;  
14.     private Date updateTime;  
15.     /** 
16.      * 任務名稱 
17.      */  
18.     private String jobName;  
19.     /** 
20.      * 任務分組 
21.      */  
22.     private String jobGroup;  
23.     /** 
24.      * 任務狀態 是否啟動任務 
25.      */  
26.     private String jobStatus;  
27.     /** 
28.      * cron表示式 
29.      */  
30.     private String cronExpression;  
31.     /** 
32.      * 描述 
33.      */  
34.     private String description;  
35.     /** 
36.      * 任務執行時呼叫哪個類的方法 包名+類名 
37.      */  
38.     private String beanClass;  
39.     /** 
40.      * 任務是否有狀態 
41.      */  
42.     private String isConcurrent;  
43.     /** 
44.      * spring bean 
45.      */  
46.     private String springId;  
47.     /** 
48.      * 任務呼叫的方法名 
49.      */  
50.     private String methodName;  
51.     //get  set.......  
52. }  

 該實體類與資料庫中的表對應，在資料庫中儲存多個計劃任務。

  注意：jobName 跟 groupName的組合應該是唯一的,beanClass springId至少有一個

在專案啟動時執行以下程式碼：

1. public void init() throws Exception {  
2.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
3.         // 這裡從資料庫中獲取任務資訊資料  
4.         List<ScheduleJob> jobList = scheduleJobMapper.getAll();  
5.         for (ScheduleJob job : jobList) {  
6.             addJob(job);  
7.         }  
8.     }  

1. /** 
2.      * 新增任務 
3.      *  
4.      * @param scheduleJob 
5.      * @throws SchedulerException 
6.      */  
7.     public void addJob(ScheduleJob job) throws SchedulerException {  
8.         if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {  
9.             return;  
10.         }  
11.         Scheduler scheduler = schedulerFactoryBean.getScheduler();  
12.         log.debug(scheduler + ".......................................................................................add");  
13.         TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());  
14.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);  
15.         // 不存在，建立一個  
16.         if (null == trigger) {  
17.             Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;  
18.             JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();  
19.             jobDetail.getJobDataMap().put("scheduleJob", job);  
20.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());  
21.             trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();  
22.             scheduler.scheduleJob(jobDetail, trigger);  
23.         } else {  
24.             // Trigger已存在，那麼更新相應的定時設定  
25.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());  
26.             // 按新的cronExpression表示式重新構建trigger  
27.             trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();  
28.             // 按新的trigger重新設定job執行  
29.             scheduler.rescheduleJob(triggerKey, trigger);  
30.         }  
31.     }  

 看到程式碼第20行根據scheduleJob類中CONCURRENT_IS來判斷任務是否有狀態。來給出不同的Job實現類

1. /** 
2.  *  
3.  * @Description: 若一個方法一次執行不完下次輪轉時則等待改方法執行完後才執行下一次操作 
4.  * @author snailxr 
5.  * @date 2014年4月24日 下午5:05:47 
6.  */  
7. @DisallowConcurrentExecution  
8. public class QuartzJobFactoryDisallowConcurrentExecution implements Job {  
9.     public final Logger log = Logger.getLogger(this.getClass());  
10.     @Override  
11.     public void execute(JobExecutionContext context) throws JobExecutionException {  
12.         ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");  
13.         TaskUtils.invokMethod(scheduleJob);  
14.     }  
15. }  

1. /** 
2.  *  
3.  * @Description: 計劃任務執行處 無狀態 
4.  * @author snailxr 
5.  * @date 2014年4月24日 下午5:05:47 
6.  */  
7. public class QuartzJobFactory implements Job {  
8.     public final Logger log = Logger.getLogger(this.getClass());  
9.     @Override  
10.     public void execute(JobExecutionContext context) throws JobExecutionException {  
11.         ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");  
12.         TaskUtils.invokMethod(scheduleJob);  
13.     }  
14. }  

真正執行計劃任務的程式碼就在TaskUtils.invokMethod(scheduleJob)裡面

通過scheduleJob的beanClass或springId通過反射或spring來獲得需要執行的類,通過methodName來確定執行哪個方法

1. public class TaskUtils {  
2.     public final static Logger log = Logger.getLogger(TaskUtils.class);  
3.     /** 
4.      * 通過反射呼叫scheduleJob中定義的方法 
5.      *  
6.      * @param scheduleJob 
7.      */  
8.     public static void invokMethod(ScheduleJob scheduleJob) {  
9.         Object object = null;  
10.         Class clazz = null;  
11.                 //springId不為空先按springId查詢bean  
12.         if (StringUtils.isNotBlank(scheduleJob.getSpringId())) {  
13.             object = SpringUtils.getBean(scheduleJob.getSpringId());  
14.         } else if (StringUtils.isNotBlank(scheduleJob.getBeanClass())) {  
15.             try {  
16.                 clazz = Class.forName(scheduleJob.getBeanClass());  
17.                 object = clazz.newInstance();  
18.             } catch (Exception e) {  
19.                 // TODO Auto-generated catch block  
20.                 e.printStackTrace();  
21.             }  
22.         }  
23.         if (object == null) {  
24.             log.error("任務名稱 = [" + scheduleJob.getJobName() + "]---------------未啟動成功，請檢查是否配置正確！！！");  
25.             return;  
26.         }  
27.         clazz = object.getClass();  
28.         Method method = null;  
29.         try {  
30.             method = clazz.getDeclaredMethod(scheduleJob.getMethodName());  
31.         } catch (NoSuchMethodException e) {  
32.             log.error("任務名稱 = [" + scheduleJob.getJobName() + "]---------------未啟動成功，方法名設定錯誤！！！");  
33.         } catch (SecurityException e) {  
34.             // TODO Auto-generated catch block  
35.             e.printStackTrace();  
36.         }  
37.         if (method != null) {  
38.             try {  
39.                 method.invoke(object);  
40.             } catch (IllegalAccessException e) {  
41.                 // TODO Auto-generated catch block  
42.                 e.printStackTrace();  
43.             } catch (IllegalArgumentException e) {  
44.                 // TODO Auto-generated catch block  
45.                 e.printStackTrace();  
46.             } catch (InvocationTargetException e) {  
47.                 // TODO Auto-generated catch block  
48.                 e.printStackTrace();  
49.             }  
50.         }  
51.     }  
52. }  

 對任務的暫停，刪除，修改等操作

1. **  
2.      * 獲取所有計劃中的任務列表  
3.      *   
4.      * @return  
   相關推薦

   quartz spring 實現動態定時任務

   在實際專案應用中經常會用到定時任務，可以通過quartz和spring的簡單配置即可完成，但如果要改變任務的執行時間、頻率，廢棄任務等就需要改變配置甚至程式碼需要重啟伺服器，這裡介紹一下如何通過quartz與spring的組合實現動態的改變定時任務的狀態的一個實現。

   Spring 3整合Quartz 2實現動態定時任務

   一、 說明      在做公司的一款產品過程中要實現定時任務功能，而且這款產品是面向不同客戶的，因此具體執行的任務不固定，定時週期也不固定，所以就用到了quartz來實現這個功能。     需要說明的是spring3.1以下的版本必須使用quartz1.

   springboot和quartz整合實現動態定時任務（持久化單節點）

   依賴 1.5 ostc read 自動 1.8 自動註入 etc string 　　Quartz是一個完全由java編寫的開源作業調度框架,為在Java應用程序中進行作業調度提供了簡單卻強大的機制，它支持定時任務持久化到數據庫，從而避免了重啟服務器時任務丟失，支持分布式多節

   spring 實現動態定時任務排程

   概述 使用spring框架實現動態定時任務排程，可以不重啟專案，只修改cron表示式，即可變更任務執行週期。 spring xml配置： <?xml version="1.0" encoding="UTF-8"?> <beans

   spring整合quartz實現動態定時任務的前臺網頁配置與管理

   在實際專案應用中經常會用到定時任務，可以通過quartz和spring的簡單配置即可完成，但如果要改變任務的執行時間、頻率，廢棄任務等就需要改變配置甚至程式碼需要重啟伺服器，這裡介紹一下如何通過quartz與spring的組合實現動態的改變定時任務的狀態的一個實

   spring-boot-route（二十一）quartz實現動態定時任務

   `Quartz`是一個定時任務的排程框架，涉及到的主要概念有以下幾個： `Scheduler`：排程器，所有的排程都由它控制，所有的任務都由它管理。 `Job`：任務，定義業務邏輯。 `JobDetail`：基於Job，進一步封裝。其中關聯一個Job，併為Job指定更詳細的資訊。 `Trigger`：

   Spring整合Quartz框架實現分散式定時任務

   1、叢集使用定時任務的問題：    目前大部分在叢集中處理定時任務的方式不是正真的分散式處理方式，而是一種偽分散式，這種方式存在一個明顯的缺陷就是當叢集中機器宕機， 那麼整個定時任務就會掛掉或者不能一次性跑完，會對業務產生嚴重的影響。   而且在叢集環境中，

   SpringBoot系列5-定時任務-springboot整合quartz實現動態定時任務

   springboot有自帶的定時任務為什麼還要使用quartz 使用springboot自帶的定時任務可以很簡單很方便的完成一些簡單的定時任務，但是我們想動態的執行我們的定時任務就比較困難了。然而使用quartz卻可以很容易的管理我們的定時任務，很容易動態的操作定時任務。下面我們就講解下

   spring定時任務實現動態定時任務（啟停，週期修改）

   使用方法：             複製下方程式碼，在業務需要處呼叫（定時任務狀態和執行週期被修改後），一定要在專案啟動時後立刻執行一次庫中全資料呼叫此方法，List<Cron> crons   Cron中一定要有業務類的包加類名（com.rails.trave

   Quartz在Spring中動態設定cronExpression （spring設定動態定時任務）

   "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

   Spring下的Quartz的新增動態定時任務

   一.首先明白Spring下Quartz的使用: 需要用到3個類:由上而下依次引用 第一個類 注入了triggers的排程工廠Bean類 org.springframework.scheduling.quartz.SchedulerFactoryBean

   quartz java實現的定時任務框架

   概述瞭解Quartz體系結構Quartz對任務排程的領域問題進行了高度的抽象，提出了排程器、任務和觸發器這3個核心的概念，並在org.quartz通過介面和類對重要的這些核心概念進行描述：●Job：是一個介面，只有一個方法void execute(JobExecution

   Spring+Quartz 從資料庫中獲取定時任務和定時時間，動態實現對定時任務的增刪改查

   本文轉載自部落格：http://blog.csdn.net/wwkms/article/details/48851005 ----------------------------------------------------------------------------------------

   Spring整合Quartz實現動態定時器

   一、版本說明  spring3.1以下的版本必須使用quartz1.x系列，3.1以上的版本才支援quartz 2.x，不然會出錯。  原因：spring對於quartz的支援實現，org.springframework.scheduling.quartz.CronTri

   Spring+quartz 實現動態管理任務

   在實際專案應用中經常會用到定時任務，可以通過quartz和spring的簡單配置即可完成，但如果要改變任務的執行時間、頻率，廢棄任務等就需要改變配置甚至程式碼需要重啟伺服器，這裡介紹一下如何通過quartz與spring的組合實現動態的改變定時任務的狀態的一個實現。 本文

   Spring整合Quartz動態定時任務，新增及刪除的一些操作

   我是是一個新手，最近公司要用定時任務，才研究了一下。有什麼錯誤的地方，希望多指正。 1、首先需要一個執行的QuartzJob（任務類）實現Job介面 然後重寫execute（），需要執行的具體方法就寫在這裡面。   2、編寫一個QuartzJob（任務類）的實體類Jo

   使用quartz+spring實現簡單的可配置化的定時任務（可和資料庫配套使用）

   需要的jar包： spring-context-support-4.0.1.RELEASE.jar quartz-2.2.1.jar 首先定義一個job要實現Job介面,以後各種各樣的任務都放在這個job中執行： import org.quartz.Job; import

   Spring和Quartz實現的定時任務排程

   Corn表示式 一、增加所依賴的JAR包 1. 增加Spring的Maven依賴 <dependency>  <groupId>org.springframework</groupId>  

   Spring boot + Quartz實現分散式定時任務

   在實際專案中經常會用到定時任務，且有些定時任務同時只能執行一個例項，下面介紹一下通過Spring boot + Quartz框架實現分散式定時任務。 1. 定時任務持久化到Mysql 2. 名稱為JobA的定時任務每10秒執行一次@ScheduledJo

   Quartz動態設定任務時間/spring動態定時任務

   原作者xlxxcc原文傳送門:  PS:專案需求用到了定時任務 ,但是任務的時間是在配置檔案寫好的 ,無法根據使用者的需求 自行更改 ,想到了動態定時任務 ,在網上搜索的好久,但是好多程式碼都是幾年前的老程式碼 1.8版本, 親測可用 ,貼個連結 ,方便大家在