徹底理解spring的定製任務（scheduling）

raorq發表於2020-04-06
Spring

   相信做軟體的朋友都有這樣的經歷，我的軟體是不是少了點什麼東西呢？比如定時任務啊，

   就拿新聞釋出系統來說，如果新聞的資料更新太快，勢必涉及一個問題，這些新聞不能由人工的去釋出，應該讓系統自己釋出，這就需要用到定時定製任務了，以前定製任務無非就是設計一個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.  * <p>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.  * <p>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.      * <p>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.      * <p>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.  * <p>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.  * <p>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.      * <p>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 <code>afterPropertiesSet</code>.  
  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了。

 

相關文章