彻底理解spring的定制任务（scheduling）

   相信做软件的朋友都有这样的经历，我的软件是不是少了点什么东西呢？比如定时任务啊，

   就拿新闻发布系统来说，如果新闻的数据更新太快，势必涉及一个问题，这些新闻不能由人工的去发布，应该让系统自己发布，这就需要用到定时定制任务了，以前定制任务无非就是设计一个Thread，并且设置运行时间片，让它到了那个时间执行一次，就ok了，让系统启动的时候启动它，想来也够简单的。不过有了spring，我想这事情就更简单了。

看看spring的配置文件，想来就只有这个配置文件了

xml 代码

1. <bean id="infoCenterAutoBuildTask"  
2.     class="com.teesoo.teanet.scheduling.InfoCenterAutoBuildTask">  
3.     <property name="baseService" ref="baseService" />  
4.     <property name="htmlCreator" ref="htmlCreator" />  
5. </bean>  
6.   
7. <bean id="scheduledTask"  
8.     class="org.springframework.scheduling.timer.ScheduledTimerTask">  
9.     <!-- wait 10 seconds before starting repeated execution -->  
10.     <property name="delay" value="10000" />  
11.     <!-- run every 50 seconds -->  
12.     <property name="period" value="1000000" />  
13.     <property name="timerTask" ref="infoCenterAutoBuildTask" />  
14. </bean>  
15.   
16.   
17. <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">  
18.    <property name="scheduledTimerTasks">  
19.        <list>  
20.            <!-- see the example above -->  
21.            <ref bean="scheduledTask" />  
22.        </list>  
23.    </property>  
24. </bean>  

上面三个配置文件中只有一个配置文件是涉及到您自己的class的，其他的都是spring的类。很简单吧

我们只需要涉及一个class让他继承java.util.TimerTask;

java 代码

1. BaseTask extends java.util.TimerTask {   
2. //用户只需要实现这个方面，把自己的任务放到这里   
3. public void run(){   
4. }   
5. }  

 

下面让我们来看看 spring的源代码

java 代码

1. /*  
2.  * Copyright 2002-2005 the original author or authors.  
3.  *   
4.  * Licensed under the Apache License, Version 2.0 (the "License");  
5.  * you may not use this file except in compliance with the License.  
6.  * You may obtain a copy of the License at  
7.  *   
8.  *      http://www.apache.org/licenses/LICENSE-2.0  
9.  *   
10.  * Unless required by applicable law or agreed to in writing, software  
11.  * distributed under the License is distributed on an "AS IS" BASIS,  
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
13.  * See the License for the specific language governing permissions and  
14.  * limitations under the License.  
15.  */  
16.   
17. package org.springframework.scheduling.timer;   
18.   
19. import java.util.TimerTask;   
20.   
21. /**  
22.  * JavaBean that describes a scheduled TimerTask, consisting of  
23.  * the TimerTask itself (or a Runnable to create a TimerTask for)  
24.  * and a delay plus period. Period needs to be specified;  
25.  * there is no point in a default for it.  
26.  *  
27.  * <p>The JDK Timer does not offer more sophisticated scheduling  
28.  * options such as  cron expressions. Consider using Quartz for  
29.  * such advanced needs.  
30.  *  
31.  * <p>Note that Timer uses a TimerTask instance that is shared  
32.  * between repeated executions, in contrast to Quartz which  
33.  * instantiates a new Job for each execution.  
34.  *  
35.  * @author Juergen Hoeller  
36.  * @since 19.02.2004  
37.  * @see java.util.TimerTask  
38.  * @see java.util.Timer#schedule(TimerTask, long, long)  
39.  * @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long)  
40.  */  
41. public class ScheduledTimerTask {   
42.   
43.     private TimerTask timerTask;   
44.   
45.     private long delay = 0;   
46.   
47.     private long period = 0;   
48.   
49.     private boolean fixedRate = false;   
50.   
51.   
52.     /**  
53.      * Create a new ScheduledTimerTask,  
54.      * to be populated via bean properties.  
55.      * @see #setTimerTask  
56.      * @see #setDelay  
57.      * @see #setPeriod  
58.      * @see #setFixedRate  
59.      */  
60.     public ScheduledTimerTask() {   
61.     }   
62.   
63.     /**  
64.      * Create a new ScheduledTimerTask, with default  
65.      * one-time execution without delay.  
66.      * @param timerTask the TimerTask to schedule  
67.      */  
68.     public ScheduledTimerTask(TimerTask timerTask) {   
69.         this.timerTask = timerTask;   
70.     }   
71.   
72.     /**  
73.      * Create a new ScheduledTimerTask, with default  
74.      * one-time execution with the given delay.  
75.      * @param timerTask the TimerTask to schedule  
76.      * @param delay the delay before starting the task for the first time (ms)  
77.      */  
78.     public ScheduledTimerTask(TimerTask timerTask, long delay) {   
79.         this.timerTask = timerTask;   
80.         this.delay = delay;   
81.     }   
82.   
83.     /**  
84.      * Create a new ScheduledTimerTask.  
85.      * @param timerTask the TimerTask to schedule  
86.      * @param delay the delay before starting the task for the first time (ms)  
87.      * @param period the period between repeated task executions (ms)  
88.      * @param fixedRate whether to schedule as fixed-rate execution  
89.      */  
90.     public ScheduledTimerTask(TimerTask timerTask, long delay, long period, boolean fixedRate) {   
91.         this.timerTask = timerTask;   
92.         this.delay = delay;   
93.         this.period = period;   
94.         this.fixedRate = fixedRate;   
95.     }   
96.   
97.     /**  
98.      * Create a new ScheduledTimerTask, with default  
99.      * one-time execution without delay.  
100.      * @param timerTask the Runnable to schedule as TimerTask  
101.      */  
102.     public ScheduledTimerTask(Runnable timerTask) {   
103.         setRunnable(timerTask);   
104.     }   
105.   
106.     /**  
107.      * Create a new ScheduledTimerTask, with default  
108.      * one-time execution with the given delay.  
109.      * @param timerTask the Runnable to schedule as TimerTask  
110.      * @param delay the delay before starting the task for the first time (ms)  
111.      */  
112.     public ScheduledTimerTask(Runnable timerTask, long delay) {   
113.         setRunnable(timerTask);   
114.         this.delay = delay;   
115.     }   
116.   
117.     /**  
118.      * Create a new ScheduledTimerTask.  
119.      * @param timerTask the Runnable to schedule as TimerTask  
120.      * @param delay the delay before starting the task for the first time (ms)  
121.      * @param period the period between repeated task executions (ms)  
122.      * @param fixedRate whether to schedule as fixed-rate execution  
123.      */  
124.     public ScheduledTimerTask(Runnable timerTask, long delay, long period, boolean fixedRate) {   
125.         setRunnable(timerTask);   
126.         this.delay = delay;   
127.         this.period = period;   
128.         this.fixedRate = fixedRate;   
129.     }   
130.   
131.   
132.     /**  
133.      * Set the Runnable to schedule as TimerTask.  
134.      * @see DelegatingTimerTask  
135.      */  
136.     public void setRunnable(Runnable timerTask) {   
137.         this.timerTask = new DelegatingTimerTask(timerTask);   
138.     }   
139.   
140.     /**  
141.      * Set the TimerTask to schedule.  
142.      */  
143.     public void setTimerTask(TimerTask timerTask) {   
144.         this.timerTask = timerTask;   
145.     }   
146.   
147.     /**  
148.      * Return the TimerTask to schedule.  
149.      */  
150.     public TimerTask getTimerTask() {   
151.         return timerTask;   
152.     }   
153.   
154.     /**  
155.      * Set the delay before starting the task for the first time,  
156.      * in milliseconds. Default is 0, immediately starting the  
157.      * task after successful scheduling.  
158.      */  
159.     public void setDelay(long delay) {   
160.         this.delay = delay;   
161.     }   
162.   
163.     /**  
164.      * Return the delay before starting the job for the first time.  
165.      */  
166.     public long getDelay() {   
167.         return delay;   
168.     }   
169.   
170.     /**  
171.      * Set the period between repeated task executions, in milliseconds.  
172.      * Default is 0, leading to one-time execution. In case of a positive  
173.      * value, the task will be executed repeatedly, with the given interval  
174.      * inbetween executions.  
175.      * <p>Note that the semantics of the period vary between fixed-rate  
176.      * and fixed-delay execution.  
177.      * @see #setFixedRate  
178.      */  
179.     public void setPeriod(long period) {   
180.         this.period = period;   
181.     }   
182.   
183.     /**  
184.      * Return the period between repeated task executions.  
185.      */  
186.     public long getPeriod() {   
187.         return period;   
188.     }   
189.   
190.     /**  
191.      * Set whether to schedule as fixed-rate execution, rather than  
192.      * fixed-delay execution. Default is "false", i.e. fixed delay.  
193.      * <p>See Timer javadoc for details on those execution modes.  
194.      * @see java.util.Timer#schedule(TimerTask, long, long)  
195.      * @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long)  
196.      */  
197.     public void setFixedRate(boolean fixedRate) {   
198.         this.fixedRate = fixedRate;   
199.     }   
200.   
201.     /**  
202.      * Return whether to schedule as fixed-rate execution.  
203.      */  
204.     public boolean isFixedRate() {   
205.         return fixedRate;   
206.     }   
207.   
208. }   

说实话这个类也没什么，只是简单的包装了我们的timertask，里面也就只有几个属性，一个是时间片，一个是任务等。

真正运行我们的任务的类是：

java 代码

1. /*  
2.  * Copyright 2002-2006 the original author or authors.  
3.  *  
4.  * Licensed under the Apache License, Version 2.0 (the "License");  
5.  * you may not use this file except in compliance with the License.  
6.  * You may obtain a copy of the License at  
7.  *  
8.  *      http://www.apache.org/licenses/LICENSE-2.0  
9.  *  
10.  * Unless required by applicable law or agreed to in writing, software  
11.  * distributed under the License is distributed on an "AS IS" BASIS,  
12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
13.  * See the License for the specific language governing permissions and  
14.  * limitations under the License.  
15.  */  
16.   
17. package org.springframework.scheduling.timer;   
18.   
19. import java.util.Timer;   
20.   
21. import org.apache.commons.logging.Log;   
22. import org.apache.commons.logging.LogFactory;   
23.   
24. import org.springframework.beans.factory.DisposableBean;   
25. import org.springframework.beans.factory.FactoryBean;   
26. import org.springframework.beans.factory.InitializingBean;   
27.   
28. /**  
29.  * FactoryBean that sets up a JDK 1.3+ Timer and exposes it for bean references.  
30.  *  
31.  * <p>Allows for registration of ScheduledTimerTasks, automatically starting  
32.  * the Timer on initialization and cancelling it on destruction of the context.  
33.  * In scenarios that just require static registration of tasks at startup,  
34.  * there is no need to access the Timer instance itself in application code.  
35.  *  
36.  * <p>Note that Timer uses a TimerTask instance that is shared between  
37.  * repeated executions, in contrast to Quartz which instantiates a new  
38.  * Job for each execution.  
39.  *  
40.  * @author Juergen Hoeller  
41.  * @since 19.02.2004  
42.  * @see ScheduledTimerTask  
43.  * @see java.util.Timer  
44.  * @see java.util.TimerTask  
45.  */  
46. public class TimerFactoryBean implements FactoryBean, InitializingBean, DisposableBean {   
47.   
48.     protected final Log logger = LogFactory.getLog(getClass());   
49.   
50.     private ScheduledTimerTask[] scheduledTimerTasks;   
51.   
52.     private boolean daemon = false;   
53.   
54.     private Timer timer;   
55.   
56.   
57.     /**  
58.      * Register a list of ScheduledTimerTask objects with the Timer that  
59.      * this FactoryBean creates. Depending on each SchedulerTimerTask's  
60.      * settings, it will be registered via one of Timer's schedule methods.  
61.      * @see java.util.Timer#schedule(java.util.TimerTask, long)  
62.      * @see java.util.Timer#schedule(java.util.TimerTask, long, long)  
63.      * @see java.util.Timer#scheduleAtFixedRate(java.util.TimerTask, long, long)  
64.      */  
65.     public void setScheduledTimerTasks(ScheduledTimerTask[] scheduledTimerTasks) {   
66.         this.scheduledTimerTasks = scheduledTimerTasks;   
67.     }   
68.   
69.     /**  
70.      * Set whether the timer should use a daemon thread,  
71.      * just executing as long as the application itself is running.  
72.      * <p>Default is "false": The timer will automatically get cancelled on  
73.      * destruction of this FactoryBean. Hence, if the application shuts down,  
74.      * tasks will by default finish their execution. Specify "true" for eager  
75.      * shutdown of threads that execute tasks.  
76.      * @see java.util.Timer#Timer(boolean)  
77.      */  
78.     public void setDaemon(boolean daemon) {   
79.         this.daemon = daemon;   
80.     }   
81.   
82.   
83.     public void afterPropertiesSet() {   
84.         logger.info("Initializing Timer");   
85.         this.timer = createTimer(this.daemon);   
86.   
87.         // Register all ScheduledTimerTasks.   
88.         if (this.scheduledTimerTasks != null) {   
89.             for (int i = 0; i < this.scheduledTimerTasks.length; i++) {   
90.                 ScheduledTimerTask scheduledTask = this.scheduledTimerTasks[i];   
91.                 if (scheduledTask.getPeriod() > 0) {   
92.                     // repeated task execution   
93.                     if (scheduledTask.isFixedRate()) {   
94.                         this.timer.scheduleAtFixedRate(   
95.                                 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());   
96.                     }   
97.                     else {   
98.                         this.timer.schedule(   
99.                                 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());   
100.                     }   
101.                 }   
102.                 else {   
103.                     // One-time task execution.   
104.                     this.timer.schedule(scheduledTask.getTimerTask(), scheduledTask.getDelay());   
105.                 }   
106.             }   
107.         }   
108.     }   
109.   
110.     /**  
111.      * Create a new Timer instance. Called by <code>afterPropertiesSet</code>.  
112.      * Can be overridden in subclasses to provide custom Timer subclasses.  
113.      * @param daemon whether to create a Timer that runs as daemon thread  
114.      * @return a new Timer instance  
115.      * @see #afterPropertiesSet()  
116.      * @see java.util.Timer#Timer(boolean)  
117.      */  
118.     protected Timer createTimer(boolean daemon) {   
119.         return new Timer(daemon);   
120.     }   
121.   
122.   
123.     public Object getObject() {   
124.         return this.timer;   
125.     }   
126.   
127.     public Class getObjectType() {   
128.         return Timer.class;   
129.     }   
130.   
131.     public boolean isSingleton() {   
132.         return true;   
133.     }   
134.   
135.   
136.     /**  
137.      * Cancel the Timer on bean factory shutdown, stopping all scheduled tasks.  
138.      * @see java.util.Timer#cancel()  
139.      */  
140.     public void destroy() {   
141.         logger.info("Cancelling Timer");   
142.         this.timer.cancel();   
143.     }   
144.   
145. }   

 

这个类就是运行我们任务的类了，我们可以定制N个任务，只需要塞到这里就ok了。