相信做軟件的朋友都有這樣的經歷，我的軟件是不是少了點什麼東西呢？比如定時任務啊!就拿新聞發布系統來說，如果新聞的數據更新太快，勢必涉及一個問題，這些新聞不能由人工的去發布，應該讓系統自己發布，這就需要用到定時定制任務了，以前定制任務無非就是設計一個Thread，並且設置運行時間片，讓它到了那個時間執行一次，就ok了，讓系統啟動的時候啟動它，想來也夠簡單的。不過有了spring，我想這事情就更簡單了。
看看spring的配置文件，想來就只有這個配置文件了。
XML代碼：
< bean id = "infoCenterAutoBuildTask"
class = "com.teesoo.teanet.scheduling.InfoCenterAutoBuildTask" >
< property name = "baseService" ref = "baseService" />
< property name = "htmlCreator" ref = "htmlCreator" />
< bean id = "scheduledTask"
class = "org.springframework.scheduling.timer.ScheduledTimerTask" >
< property name = "delay" value = "10000" />
< property name = "period" value = "1000000" />
< property name = "timerTask" ref = "infoCenterAutoBuildTask" />
< bean id = "timerFactory"
class = "org.springframework.scheduling.timer.TimerFactoryBean" >
< property name = "scheduledTimerTasks" >
< list >
< ref bean = "scheduledTask" />
上面三個配置文件中只有一個配置文件是涉及到您自己的class的，其他的都是spring的類。很簡單吧!
我們只需要涉及一個class讓他繼承java.util.TimerTask;
Java代碼：
BaseTask extends java.util.TimerTask {
//用戶只需要實現這個方面，把自己的任務放到這裡
public void run(){
}
}
下面讓我們來看看spring的源代碼：
Java代碼：
/*
* Copyright 2002-2005 the original author or authors.
*
* Licensed under the Apache License,Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.scheduling.timer;
import java.util.TimerTask;
/**
* JavaBean that describes a scheduled TimerTask,consisting of
* the TimerTask itself (or a Runnable to create a TimerTask for)
* and a delay plus period. Period needs to be specified;
* there is no point in a default for it.
*
*
The JDK Timer does not offer more sophisticated scheduling
* options such as cron expressions. Consider using Quartz for
* such advanced needs.
*
*
Note that Timer uses a TimerTask instance that is shared
* between repeated executions,in contrast to Quartz which
* instantiates a new Job for each execution.
*
* @author Juergen Hoeller
* @since 19.02.2004
* @see java.util.TimerTask
* @see java.util.Timer#schedule(TimerTask,long,long)
* @see java.util.Timer#scheduleAtFixedRate(TimerTask,long,long)
*/
public class ScheduledTimerTask {
private TimerTask timerTask;
private long delay = 0 ;
private long period = 0 ;
private boolean fixedRate = false ;
/**
* Create a new ScheduledTimerTask,
* to be populated via bean properties.
* @see #setTimerTask
* @see #setDelay
* @see #setPeriod
* @see #setFixedRate
*/
public ScheduledTimerTask() {
}
/**
* Create a new ScheduledTimerTask,with default
* one-time execution without delay.
* @param timerTask the TimerTask to schedule
*/
public ScheduledTimerTask(TimerTask timerTask) {
this .timerTask = timerTask;
}
/**
* Create a new ScheduledTimerTask,with default
* one-time execution with the given delay.
* @param timerTask the TimerTask to schedule
* @param delay the delay before starting the task for the first time (ms)
*/
public ScheduledTimerTask(TimerTask timerTask,long delay) {
this .timerTask = timerTask;
this .delay = delay;
}
/**
* Create a new ScheduledTimerTask.
* @param timerTask the TimerTask to schedule
* @param delay the delay before starting the task for the first time (ms)
* @param period the period between repeated task executions (ms)
* @param fixedRate whether to schedule as fixed-rate execution
*/
public ScheduledTimerTask(TimerTask timerTask,long delay,long period,
boolean fixedRate) {
this .timerTask = timerTask;
this .delay = delay;
this .period = period;
this .fixedRate = fixedRate;
}
/**
* Create a new ScheduledTimerTask,with default
* one-time execution without delay.
* @param timerTask the Runnable to schedule as TimerTask
*/
public ScheduledTimerTask(Runnable timerTask) {
setRunnable(timerTask);
}
/**
* Create a new ScheduledTimerTask,with default
* one-time execution with the given delay.
* @param timerTask the Runnable to schedule as TimerTask
* @param delay the delay before starting the task for the first time (ms)
*/
public ScheduledTimerTask(Runnable timerTask,long delay) {
setRunnable(timerTask);
this .delay = delay;
}
/**
* Create a new ScheduledTimerTask.
* @param timerTask the Runnable to schedule as TimerTask
* @param delay the delay before starting the task for the first time (ms)
* @param period the period between repeated task executions (ms)
* @param fixedRate whether to schedule as fixed-rate execution
*/
public ScheduledTimerTask(Runnable timerTask,long delay,long period,
boolean fixedRate) {
setRunnable(timerTask);
this .delay = delay;
this .period = period;
this .fixedRate = fixedRate;
}
/**
* Set the Runnable to schedule as TimerTask.
* @see DelegatingTimerTask
*/
public void setRunnable(Runnable timerTask) {
this .timerTask = new DelegatingTimerTask(timerTask);
}
/**
* Set the TimerTask to schedule.
*/
public void setTimerTask(TimerTask timerTask) {
this .timerTask = timerTask;
}
/**
* Return the TimerTask to schedule.
*/
public TimerTask getTimerTask() {
return timerTask;
}
/**
* Set the delay before starting the task for the first time,
* in milliseconds. Default is 0,immediately starting the
* task after successful scheduling.
*/
public void setDelay( long delay) {
this .delay = delay;
}
/**
* Return the delay before starting the job for the first time.
*/
public long getDelay() {
return delay;
}
/**
* Set the period between repeated task executions,in milliseconds.
* Default is 0,leading to one-time execution. In case of a positive
* value,the task will be executed repeatedly,with the given interval
* inbetween executions.
*
Note that the semantics of the period vary between fixed-rate .
* and fixed-delay execution.
* @see #setFixedRate
*/
public void setPeriod( long period) {
this .period = period;
}
/**
* Return the period between repeated task executions.
*/
public long getPeriod() {
return period;
}
/**
* Set whether to schedule as fixed-rate execution,rather than
* fixed-delay execution. Default is "false",i.e. fixed delay.
*
See Timer javadoc for details on those execution modes.
* @see java.util.Timer#schedule(TimerTask,long,long)
* @see java.util.Timer#scheduleAtFixedRate(TimerTask,long,long)
*/
public void setFixedRate( boolean fixedRate) {
this .fixedRate = fixedRate;
}
/**
* Return whether to schedule as fixed-rate execution.
*/
public boolean isFixedRate() {
return fixedRate;
}
}
說實話這個類也沒什麼，只是簡單的包裝了我們的timertask，裡面也就只有幾個屬性，一個是時間片，一個是任務等。
真正運行我們的任務的類是：
Java代碼：
/*
* Copyright 2002-2006 the original author or authors.
*
* Licensed under the Apache License,Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.scheduling.timer;
import java.util.Timer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
/**
* FactoryBean that sets up a JDK 1.3+ Timer and exposes it for bean references.
*
*
Allows for registration of ScheduledTimerTasks,automatically starting
* the Timer on initialization and cancelling it on destruction of the context.
* In scenarios that just require static registration of tasks at startup,
* there is no need to access the Timer instance itself in application code.
*
*
Note that Timer uses a TimerTask instance that is shared between
* repeated executions,in contrast to Quartz which instantiates a new
* Job for each execution.
*
* @author Juergen Hoeller
* @since 19.02.2004
* @see ScheduledTimerTask
* @see java.util.Timer
* @see java.util.TimerTask
*/
public class TimerFactoryBean implements FactoryBean,InitializingBean,DisposableBean {
protected final Log logger = LogFactory.getLog(getClass());
private ScheduledTimerTask[] scheduledTimerTasks;
private boolean daemon = false ;
private Timer timer;
/**
* Register a list of ScheduledTimerTask objects with the Timer that
* this FactoryBean creates. Depending on each SchedulerTimerTask's
* settings,it will be registered via one of Timer's schedule methods.
* @see java.util.Timer#schedule(java.util.TimerTask,long)
* @see java.util.Timer#schedule(java.util.TimerTask,long,long)
* @see java.util.Timer#scheduleAtFixedRate(java.util.TimerTask,long,long)
*/
public void setScheduledTimerTasks(ScheduledTimerTask[] scheduledTimerTasks) {
this .scheduledTimerTasks = scheduledTimerTasks;
}
/**
* Set whether the timer should use a daemon thread,
* just executing as long as the application itself is running.
*
Default is "false": The timer will automatically get cancelled on
* destruction of this FactoryBean. Hence,if the application shuts down,
* tasks will by default finish their execution. Specify "true" for eager
* shutdown of threads that execute tasks.
* @see java.util.Timer#Timer(boolean)
*/
public void setDaemon( boolean daemon) {
this .daemon = daemon;
}
public void afterPropertiesSet() {
logger.info( "Initializing Timer" );
this .timer = createTimer( this .daemon);
// Register all ScheduledTimerTasks.
if ( this .scheduledTimerTasks != null ) {
for ( int i = 0 ; i < this .scheduledTimerTasks.length; i++) {
ScheduledTimerTask scheduledTask = this .scheduledTimerTasks[i];
if (scheduledTask.getPeriod() > 0 ) {
// repeated task execution
if (scheduledTask.isFixedRate()) {
this .timer.scheduleAtFixedRate(
scheduledTask.getTimerTask(),scheduledTask.getDelay(),
scheduledTask.getPeriod());
}
else {
this .timer.schedule(
scheduledTask.getTimerTask(),scheduledTask.getDelay(),
scheduledTask.getPeriod());
}
}
else {
// One-time task execution.
this .timer.schedule(scheduledTask.getTimerTask(),
scheduledTask.getDelay());
}
}
}
}
/**
* Create a new Timer instance. Called by afterPropertiesSet.
* Can be overridden in subclasses to provide custom Timer subclasses.
* @param daemon whether to create a Timer that runs as daemon thread
* @return a new Timer instance
* @see #afterPropertiesSet()
* @see java.util.Timer#Timer(boolean)
*/
protected Timer createTimer( boolean daemon) {
return new Timer(daemon);
}
public Object getObject() {
return this .timer;
}
public Class getObjectType() {
return Timer. class ;
}
public boolean isSingleton() {
return true ;
}
/**
* Cancel the Timer on bean factory shutdown,stopping all scheduled tasks.
* @see java.util.Timer#cancel()
*/
public void destroy() {
logger.info( "Cancelling Timer" );
this .timer.cancel();
}
}
這個類就是運行我們任務的類了，我們可以定制N個任務，只需要塞到這裡就ok了。
