定时任务-Quartz(热部署、冷部署)

一、配置Quartz.xml

 1 <beans xmlns="http://www.springframework.org/schema/beans"
 2  xmlns:context="http://www.springframework.org/schema/context"
 3  xmlns:p="http://www.springframework.org/schema/p"
 4  xmlns:mvc="http://www.springframework.org/schema/mvc"
 5  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 6  xsi:schemaLocation="http://www.springframework.org/schema/beans
 7       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8       http://www.springframework.org/schema/context
 9       http://www.springframework.org/schema/context/spring-context.xsd
10       http://www.springframework.org/schema/mvc
11       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">
12 
13      <!-- 要调用的工作类 -->
14     <bean id="jobclass" class="com.sh.test.dingshi"></bean>
15 
16      <!-- 配置方法调用 -->
17     <bean id="conJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
18         <property name="targetObject" ref="jobclass"></property>
19         <property name="targetMethod" value="say"></property>
20         <!-- 是否允许同时运行 -->
21         <property name="concurrent" value="false"></property>
22     </bean>
23     
24     <!-- 定时重复执行 -->
25      <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
26         <property name="jobDetail" ref="conJob"></property>
27         <property name="cronExpression" >
28             <value>0/5 * * ? * * </value><!-- 配置5秒执行一次 -->
29         </property>
30     </bean>
31     
32     <!-- 定时任务配置,定时工厂,用于管理配置的所有定时器，保证其在单独的线程上运行 -->
33     <bean id="quartzfactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
34         <property name="triggers">
35             <list>
36                 <ref local="cronTrigger"/><!-- 注册开关，local为上面配置的-->
37             </list>
38         </property>
39     </bean>
40      
41 </beans>
spring-dingshi.xml

二、导入jar

quartz-1.8.5.jar

三、创建冷部署的定时任务类，dingshi.java

 1 package com.sh.test;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 
 6 import org.springframework.stereotype.Service;
 7 
 8 @Service("dingshi")
 9 public class dingshi {
10     public void say(){
11         String format = "yyyy-MM-dd HH:mm:ss";
12         SimpleDateFormat sdf = new SimpleDateFormat(format);
13         System.out.println("定时循环执行:"+sdf.format(new Date()));
14     }
15 }
View Code

这配置有两种方式

注解方式：

1.通过在任务类(dingshi.java)中配置注解@Service("dingshi")

2.在配置文件(spring-dingshi.xml)中第18行配置ref="dingshi"，无需第14行

非注解方式：

1.在配置文件(spring-dingshi.xml)中配置第14行内容，在第18行ref=“id”配置18行的id

四、配置热部署管理类

  1 package com.sh.test;
  2 
  3 import org.quartz.CronTrigger;
  4 import org.quartz.JobDetail;
  5 import org.quartz.Scheduler;
  6 import org.quartz.SchedulerFactory;
  7 import org.quartz.impl.StdSchedulerFactory;
  8 
  9 /**
 10  * @Description: 定时任务管理类
 11  * 
 12  * @ClassName: QuartzManager
 13  * @Copyright: Copyright (c) 2015
 14  * 
 15  * @author SH
 16  * @version V2.0
 17  */
 18 public class QuartzManager {
 19     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
 20     private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME";
 21     private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME";
 22 
 23     /**
 24      * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
 25      * 
 26      * @param jobName
 27      *            任务名
 28      * @param cls
 29      *            任务
 30      * @param time
 31      *            时间设置，参考quartz说明文档
 32      * 
 33      * @Title: QuartzManager.java
 34      * @Copyright: Copyright (c) 2015
 35      * 
 36      * @author SH
 37      * @version V2.0
 38      */
 39     @SuppressWarnings("unchecked")
 40     public static void addJob(String jobName, Class cls, String time) {
 41         try {
 42             Scheduler sched = gSchedulerFactory.getScheduler();
 43             JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类
 44             // 触发器
 45             CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组
 46             trigger.setCronExpression(time);// 触发器时间设定
 47             sched.scheduleJob(jobDetail, trigger);
 48             // 启动
 49             if (!sched.isShutdown()) {
 50                 sched.start();
 51             }
 52         } catch (Exception e) {
 53             throw new RuntimeException(e);
 54         }
 55     }
 56 
 57     /**
 58      * @Description: 添加一个定时任务
 59      * 
 60      * @param jobName
 61      *            任务名
 62      * @param jobGroupName
 63      *            任务组名
 64      * @param triggerName
 65      *            触发器名
 66      * @param triggerGroupName
 67      *            触发器组名
 68      * @param jobClass
 69      *            任务
 70      * @param time
 71      *            时间设置，参考quartz说明文档
 72      * 
 73      * @Title: QuartzManager.java
 74      * @Copyright: Copyright (c) 2015
 75      * 
 76      * @author SH
 77      * @version V2.0
 78      */
 79     @SuppressWarnings("unchecked")
 80     public static void addJob(String jobName, String jobGroupName,
 81             String triggerName, String triggerGroupName, Class jobClass,
 82             String time) {
 83         try {
 84             Scheduler sched = gSchedulerFactory.getScheduler();
 85             JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类
 86             // 触发器
 87             CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
 88             trigger.setCronExpression(time);// 触发器时间设定
 89             sched.scheduleJob(jobDetail, trigger);
 90         } catch (Exception e) {
 91             throw new RuntimeException(e);
 92         }
 93     }
 94 
 95     /**
 96      * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
 97      * 
 98      * @param jobName
 99      * @param time
100      * 
101      * @Title: QuartzManager.java
102      * @Copyright: Copyright (c) 2015
103      * 
104      * @author SH
105      * @version V2.0
106      */
107     @SuppressWarnings("unchecked")
108     public static void modifyJobTime(String jobName, String time) {
109         try {
110             Scheduler sched = gSchedulerFactory.getScheduler();
111             CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME);
112             if (trigger == null) {
113                 return;
114             }
115             String oldTime = trigger.getCronExpression();
116             if (!oldTime.equalsIgnoreCase(time)) {
117                 JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME);
118                 Class objJobClass = jobDetail.getJobClass();
119                 removeJob(jobName);
120                 addJob(jobName, objJobClass, time);
121             }
122         } catch (Exception e) {
123             throw new RuntimeException(e);
124         }
125     }
126 
127     /**
128      * @Description: 修改一个任务的触发时间
129      * 
130      * @param triggerName
131      * @param triggerGroupName
132      * @param time
133      * 
134      * @Title: QuartzManager.java
135      * @Copyright: Copyright (c) 2015
136      * 
137      * @author SH
138      * @version V2.0
139      */
140     public static void modifyJobTime(String triggerName,
141             String triggerGroupName, String time) {
142         try {
143             Scheduler sched = gSchedulerFactory.getScheduler();
144             CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName);
145             if (trigger == null) {
146                 return;
147             }
148             String oldTime = trigger.getCronExpression();
149             if (!oldTime.equalsIgnoreCase(time)) {
150                 CronTrigger ct = (CronTrigger) trigger;
151                 // 修改时间
152                 ct.setCronExpression(time);
153                 // 重启触发器
154                 sched.resumeTrigger(triggerName, triggerGroupName);
155             }
156         } catch (Exception e) {
157             throw new RuntimeException(e);
158         }
159     }
160 
161     /**
162      * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
163      * 
164      * @param jobName
165      * 
166      * @Title: QuartzManager.java
167      * @Copyright: Copyright (c) 2015
168      * 
169      * @author SH
170      * @version V2.0
171      */
172     public static void removeJob(String jobName) {
173         try {
174             Scheduler sched = gSchedulerFactory.getScheduler();
175             sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
176             sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
177             sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
178         } catch (Exception e) {
179             throw new RuntimeException(e);
180         }
181     }
182 
183     /**
184      * @Description: 移除一个任务
185      * 
186      * @param jobName
187      * @param jobGroupName
188      * @param triggerName
189      * @param triggerGroupName
190      * 
191      * @Title: QuartzManager.java
192      * @Copyright: Copyright (c) 2015
193      * 
194      * @author SH
195      * @version V2.0
196      */
197     public static void removeJob(String jobName, String jobGroupName,
198             String triggerName, String triggerGroupName) {
199         try {
200             Scheduler sched = gSchedulerFactory.getScheduler();
201             sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
202             sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
203             sched.deleteJob(jobName, jobGroupName);// 删除任务
204         } catch (Exception e) {
205             throw new RuntimeException(e);
206         }
207     }
208 
209     /**
210      * @Description:启动所有定时任务
211      * 
212      * 
213      * @Title: QuartzManager.java
214      * @Copyright: Copyright (c) 2015
215      * 
216      * @author SH
217      * @version V2.0
218      */
219     public static void startJobs() {
220         try {
221             Scheduler sched = gSchedulerFactory.getScheduler();
222             sched.start();
223         } catch (Exception e) {
224             throw new RuntimeException(e);
225         }
226     }
227 
228     /**
229      * @Description:关闭所有定时任务
230      * 
231      * 
232      * @Title: QuartzManager.java
233      * @Copyright: Copyright (c) 2015
234      * 
235      * @author SH
236      * @version V2.0
237      */
238     public static void shutdownJobs() {
239         try {
240             Scheduler sched = gSchedulerFactory.getScheduler();
241             if (!sched.isShutdown()) {
242                 sched.shutdown();
243             }
244         } catch (Exception e) {
245             throw new RuntimeException(e);
246         }
247     }
248 }
QuartzManager.java

五、热部署执行类

 1 package com.sh.test;
 2 
 3 import java.text.SimpleDateFormat;
 4 import java.util.Date;
 5 
 6 import org.quartz.Job;
 7 import org.quartz.JobExecutionContext;
 8 import org.quartz.JobExecutionException;
 9 
10 /**
11  * @Description: 任务执行类
12  *
13  * @ClassName: QuartzJob
14  * @Copyright: Copyright (c) 2015
15  *
16  * @author SH
17  * @version V2.0
18  */
19 public class QuartzJob implements Job {
20 
21     public void execute(JobExecutionContext arg0) throws JobExecutionException {
22         String name = arg0.getTrigger().getName();//获得当前执行任务名
23         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));  
24     }
25 }
QuartzJob.java

六、热部署测试类

 1 package com.sh.test;
 2 
 3 import javax.servlet.http.HttpServletRequest;
 4 import javax.servlet.http.HttpServletResponse;
 5 
 6 import org.springframework.stereotype.Controller;
 7 import org.springframework.web.bind.annotation.RequestMapping;
 8 import org.springframework.web.bind.annotation.RequestMethod;
 9 
10 
11 /**
12  * @Description: 测试类
13  *
14  * @ClassName: QuartzTest
15  * @Copyright: Copyright (c) 2014
16  *
17  * @author SH
18  * @version V2.0
19  */
20 @Controller
21 public class QuartzTest {
22     public static void main(String[] args) {
23         try {
24             String job_name = "动态任务调度";
25             System.out.println("【系统启动】开始(每1秒输出一次)...");  
26             QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");  
27             
28             Thread.sleep(5000);  
29             System.out.println("【修改时间】开始(每2秒输出一次)...");  
30             QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");  
31             Thread.sleep(6000);  
32             System.out.println("【移除定时】开始...");  
33             QuartzManager.removeJob(job_name);  
34             System.out.println("【移除定时】成功");  
35             
36             System.out.println("【再次添加定时任务】开始(每10秒输出一次)...");  
37             QuartzManager.addJob(job_name, QuartzJob.class, "*/10 * * * * ?");  
38             Thread.sleep(60000);  
39             System.out.println("【移除定时】开始...");  
40             QuartzManager.removeJob(job_name);  
41             System.out.println("【移除定时】成功");
42         } catch (Exception e) {
43             e.printStackTrace();
44         }
45     }
46     String job_name = "动态任务调度";
47     @RequestMapping(value="/add",method=RequestMethod.GET)
48     public void timmertest(HttpServletRequest request,HttpServletResponse response){
49         System.out.println("【系统启动】开始(每1秒输出一次)...");  
50         QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");  
51     }
52     @RequestMapping(value="/update",method=RequestMethod.GET)
53     public void timmertest1(HttpServletRequest request,HttpServletResponse response){
54         System.out.println("【修改时间】开始(每2秒输出一次)...");  
55         QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");  
56     }
57     @RequestMapping(value="/del",method=RequestMethod.GET)
58     public void timmertest2(HttpServletRequest request,HttpServletResponse response){
59         QuartzManager.removeJob(job_name);  
60         System.out.println("【移除定时】成功");  
61     }
62 }
QuartzTest.java
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/rb2010/p/8301364.html