当前位置导航:炫浪网>>网络学院>>编程开发>>JAVA教程>>Java进阶

彻底理解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.  * 

    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.  * 

    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.      * 

    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.      * 

  194. See Timer javadoc for details on those execution modes.

     
  195.      * @see java.util.Timer#schedule(TimerTask, long, long)  
  196.      * @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long)  
  197.      */   
  198.      public   void  setFixedRate( boolean  fixedRate) {   
  199.          this .fixedRate = fixedRate;   
  200.     }   
  201.   
  202.      /**  
  203.      * Return whether to schedule as fixed-rate execution.  
  204.      */   
  205.      public   boolean  isFixedRate() {   
  206.          return  fixedRate;   
  207.     }   
  208.   
  209. }   

说实话这个类也没什么,只是简单的包装了我们的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.  * 

    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.  * 

    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.      * 
  73.  

  74. Default is "false": The timer will automatically get cancelled on

     
  75.      * destruction of this FactoryBean. Hence, if the application shuts down,  
  76.      * tasks will by default finish their execution. Specify "true" for eager  
  77.      * shutdown of threads that execute tasks.  
  78.      * @see java.util.Timer#Timer(boolean)  
  79.      */   
  80.      public   void  setDaemon( boolean  daemon) {   
  81.          this .daemon = daemon;   
  82.     }   
  83.   
  84.   
  85.      public   void  afterPropertiesSet() {   
  86.         logger.info( "Initializing Timer" );   
  87.          this .timer = createTimer( this .daemon);   
  88.   
  89.          // Register all ScheduledTimerTasks.   
  90.          if  ( this .scheduledTimerTasks !=  null ) {   
  91.              for  ( int  i =  0 ; i <  this .scheduledTimerTasks.length; i++) {   
  92.                 ScheduledTimerTask scheduledTask =  this .scheduledTimerTasks[i];   
  93.                  if  (scheduledTask.getPeriod() >  0 ) {   
  94.                      // repeated task execution   
  95.                      if  (scheduledTask.isFixedRate()) {   
  96.                          this .timer.scheduleAtFixedRate(   
  97.                                 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());   
  98.                     }   
  99.                      else  {   
  100.                          this .timer.schedule(   
  101.                                 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());   
  102.                     }   
  103.                 }   
  104.                  else  {   
  105.                      // One-time task execution.   
  106.                      this .timer.schedule(scheduledTask.getTimerTask(), scheduledTask.getDelay());   
  107.                 }   
  108.             }   
  109.         }   
  110.     }   
  111.   
  112.      /**  
  113.      * Create a new Timer instance. Called by afterPropertiesSet.  
  114.      * Can be overridden in subclasses to provide custom Timer subclasses.  
  115.      * @param daemon whether to create a Timer that runs as daemon thread  
  116.      * @return a new Timer instance  
  117.      * @see #afterPropertiesSet()  
  118.      * @see java.util.Timer#Timer(boolean)  
  119.      */   
  120.      protected  Timer createTimer( boolean  daemon) {   
  121.          return   new  Timer(daemon);   
  122.     }   
  123.   
  124.   
  125.      public  Object getObject() {   
  126.          return   this .timer;   
  127.     }   
  128.   
  129.      public  Class getObjectType() {   
  130.          return  Timer. class ;   
  131.     }   
  132.   
  133.      public   boolean  isSingleton() {   
  134.          return   true ;   
  135.     }   
  136.   
  137.   
  138.      /**  
  139.      * Cancel the Timer on bean factory shutdown, stopping all scheduled tasks.  
  140.      * @see java.util.Timer#cancel()  
  141.      */   
  142.      public   void  destroy() {   
  143.         logger.info( "Cancelling Timer" );   
  144.          this .timer.cancel();   
  145.     }   
  146.   
  147. }   

 

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

相关内容
赞助商链接