免费视频淫片aa毛片_日韩高清在线亚洲专区vr_日韩大片免费观看视频播放_亚洲欧美国产精品完整版

打開APP
userphoto
未登錄

開通VIP，暢享免費(fèi)電子書等14項(xiàng)超值服

開通VIP

首頁

好書

留言交流

下載APP

聯(lián)系客服
徹底理解spring的定制任務(wù)（scheduling）
關(guān)鍵字: 企業(yè)應(yīng)用       

   相信做軟件的朋友都有這樣的經(jīng)歷，我的軟件是不是少了點(diǎn)什么東西呢？比如定時(shí)任務(wù)啊，

   就拿新聞發(fā)布系統(tǒng)來說，如果新聞的數(shù)據(jù)更新太快，勢必涉及一個(gè)問題，這些新聞不能由人工的去發(fā)布，應(yīng)該讓系統(tǒng)自己發(fā)布，這就需要用到定時(shí)定制任務(wù)了，以前定制任務(wù)無非就是設(shè)計(jì)一個(gè)Thread，并且設(shè)置運(yùn)行時(shí)間片，讓它到了那個(gè)時(shí)間執(zhí)行一次，就ok了，讓系統(tǒng)啟動的時(shí)候啟動它，想來也夠簡單的。不過有了 spring，我想這事情就更簡單了。

看看spring的配置文件，想來就只有這個(gè)配置文件了

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 >   

上面三個(gè)配置文件中只有一個(gè)配置文件是涉及到您自己的class的，其他的都是spring的類。很簡單吧

我們只需要涉及一個(gè)class讓他繼承java.util.TimerTask;

java 代碼
  1. BaseTask  extends  java.util.TimerTask {   
  2. //用戶只需要實(shí)現(xiàn)這個(gè)方面，把自己的任務(wù)放到這里   
  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. }   

說實(shí)話這個(gè)類也沒什么，只是簡單的包裝了我們的timertask，里面也就只有幾個(gè)屬性，一個(gè)是時(shí)間片，一個(gè)是任務(wù)等。

真正運(yùn)行我們的任務(wù)的類是：

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

 

本站僅提供存儲服務(wù)，所有內(nèi)容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點(diǎn)擊舉報(bào)。
打開APP，閱讀全文并永久保存 查看更多類似文章
猜你喜歡
類似文章
spring中集成TimerTask執(zhí)行定時(shí)任務(wù)
Spring中使用注解 @Scheduled執(zhí)行定時(shí)任務(wù)
SpringFramework(6)
springboot(九)：定時(shí)任務(wù)
Spring Boot 如何快速實(shí)現(xiàn)定時(shí)任務(wù)
并發(fā)編程：使用任務(wù)執(zhí)行器和調(diào)度器，任務(wù)執(zhí)行器和調(diào)度器實(shí)戰(zhàn)經(jīng)驗(yàn)
更多類似文章 >>
生活服務(wù)
分享 收藏 導(dǎo)長圖 關(guān)注 下載文章
綁定賬號成功
后續(xù)可登錄賬號暢享VIP特權(quán)！
如果VIP功能使用有故障，
可點(diǎn)擊這里聯(lián)系客服！

聯(lián)系客服