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

关键字: 企业应用       

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

   就拿新闻发布系统来说，如果新闻的数据更新太快，势必涉及一个问题，这些新闻不能由人工的去发布，应该让系统自己发布，这就需要用到定时定制任务了，以前定制任务无非就是设计一个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 >

< bean   id = "scheduledTask"
     class = "org.springframework.scheduling.timer.ScheduledTimerTask" >
     <!-- wait 10 seconds before starting repeated execution -->
     < property   name = "delay"   value = "10000"   />
     <!-- run every 50 seconds -->
     < property   name = "period"   value = "1000000"   />
     < property   name = "timerTask"   ref = "infoCenterAutoBuildTask"   />
</ bean >


< bean   id = "timerFactory"   class = "org.springframework.scheduling.timer.TimerFactoryBean" >
    < property   name = "scheduledTimerTasks" >
        < list >
            <!-- see the example above -->
            < ref   bean = "scheduledTask"   />
        </ list >
    </ property >
</ bean >

上面三个配置文件中只有一个配置文件是涉及到您自己的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./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./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();
    }

}