新闻正文

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

 来源:JAVA天堂  JAVA学习者  2007-4-25 04:13:18 网友评论 0 条 字体:[大 中 小] ~我要投稿!

 

下面让我们来看看 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.     }   

  83.   
  84.      /**  
  85.      * Create a new ScheduledTimerTask.  
  86.      * @param timerTask the TimerTask to schedule  
  87.      * @param delay the delay before starting the task for the first time (ms)  
  88.      * @param period the period between repeated task executions (ms)  
  89.      * @param fixedRate whether to schedule as fixed-rate execution  
  90.      */   
  91.      public  ScheduledTimerTask(TimerTask timerTask,  long  delay,  long  period,  boolean  fixedRate) {   
  92.          this .timerTask = timerTask;   
  93.          this .delay = delay;   
  94.          this .period = period;   
  95.          this .fixedRate = fixedRate;   
  96.     }   
  97.   
  98.      /**  
  99.      * Create a new ScheduledTimerTask, with default  
  100.      * one-time execution without delay.  
  101.      * @param timerTask the Runnable to schedule as TimerTask  
  102.      */   
  103.      public  ScheduledTimerTask(Runnable timerTask) {   
  104.         setRunnable(timerTask);   
  105.     }   
  106.   
  107.      /**  
  108.      * Create a new ScheduledTimerTask, with default  
  109.      * one-time execution with the given delay.  
  110.      * @param timerTask the Runnable to schedule as TimerTask  
  111.      * @param delay the delay before starting the task for the first time (ms)  
  112.      */   
  113.      public  ScheduledTimerTask(Runnable timerTask,  long  delay) {   
  114.         setRunnable(timerTask);   
  115.          this .delay = delay;   
  116.     }   
  117.   
  118.      /**  
  119.      * Create a new ScheduledTimerTask.  
  120.      * @param timerTask the Runnable to schedule as TimerTask  
  121.      * @param delay the delay before starting the task for the first time (ms)  
  122.      * @param period the period between repeated task executions (ms)  
  123.      * @param fixedRate whether to schedule as fixed-rate execution  
  124.      */   
  125.      public  ScheduledTimerTask(Runnable timerTask,  long  delay,  long  period,  boolean  fixedRate) {   
  126.         setRunnable(timerTask);   
  127.          this .delay = delay;   
  128.          this .period = period;   
  129.          this .fixedRate = fixedRate;   
  130.     }   
  131.   
  132.   
  133.      /**  
  134.      * Set the Runnable to schedule as TimerTask.  
  135.      * @see DelegatingTimerTask  
  136.      */   
  137.      public   void  setRunnable(Runnable timerTask) {   
  138.          this .timerTask =  new  DelegatingTimerTask(timerTask);   
  139.     }   
  140.   
  141.      /**  
  142.      * Set the TimerTask to schedule.  
  143.      */   
  144.      public   void  setTimerTask(TimerTask timerTask) {   
  145.          this .timerTask = timerTask;   
  146.     }   
  147.   
  148.      /**  
  149.      * Return the TimerTask to schedule.  
  150.      */   
  151.      public  TimerTask getTimerTask() {   
  152.          return  timerTask;   
  153.     }   
  154.   
  155.      /**  
  156.      * Set the delay before starting the task for the first time,  
  157.      * in milliseconds. Default is 0, immediately starting the  
  158.      * task after successful scheduling.  
  159.      */   
  160.      public   void  setDelay( long  delay) {   
  161.          this .delay = delay;   
  162.     }   
  163.   
  164.      /**  
  165.      * Return the delay before starting the job for the first time.  
  166.      */   
  167.      public   long  getDelay() {   
  168.          return  delay;   
  169.     }   
  170.   
  171.      /**  
  172.      * Set the period between repeated task executions, in milliseconds.  
  173.      * Default is 0, leading to one-time execution. In case of a positive  
  174.      * value, the task will be executed repeatedly, with the given interval  
  175.      * inbetween executions.  
  176.      * 

    Note that the semantics of the period vary between fixed-rate

     
  177.      * and fixed-delay execution.  
  178.      * @see #setFixedRate  
  179.      */   
  180.      public   void  setPeriod( long  period) {   
  181.          this .period = period;   
  182.     }   
  183.   
  184.      /**  
  185.      * Return the period between repeated task executions.  
  186.      */   
  187.      public   long  getPeriod() {   
  188.          return  period;   
  189.     }   
  190.   
  191.      /**  
  192.      * Set whether to schedule as fixed-rate execution, rather than  
  193.      * fixed-delay execution. Default is "false", i.e. fixed delay.  
  194.      * 

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

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

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



收藏到ViVi   收藏此页到365Key
上一篇：Spring中的Template和Callback模式
下一篇：SPRING数据访问对象(DAO)框架入门
用户名： （新注册） 密码： 匿名评论 [所有评论]
评论内容：不能超过250字，需审核后才会公布，请自觉遵守互联网相关政策法规。
Copyright 2003-2008 www.javah.net All Rights Reserved
2008 如果你喜欢本站 请收藏本站 并推荐给你的朋友一起分享