饶荣庆 -- 您今天UCWEB了吗？--http://www.ucweb.com

3G 手机开发网
   :: 首页 :: 联系 :: 聚合  :: 管理
  99 Posts :: 1 Stories :: 219 Comments :: 0 Trackbacks
彻底理解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.      * 

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

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

    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 afterPropertiesSet.  
  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了。



爬虫工作室 -- 专业的手机软件开发工作室
3G视线 -- 专注手机软件开发
posted on 2007-04-01 15:04 3G工作室 阅读(2835) 评论(0)  编辑  收藏 所属分类: j2ee

只有注册用户登录后才能发表评论。
网站导航: