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

最新推荐文章于 2021-02-22 01:07:46 发布

quinn_hn

最新推荐文章于 2021-02-22 01:07:46 发布

阅读量349

点赞数

文章标签： spring delay timer permissions quartz

相信做软件的朋友都有这样的经历，我的软件是不是少了点什么东西呢？比如定时任务啊，

就拿新闻发布系统来说，如果新闻的数据更新太快，势必涉及一个问题，这些新闻不能由人工的去发布，应该让系统自己发布，这就需要用到定时定制任务了，以前定制任务无非就是设计一个Thread，并且设置运行时间片，让它到了那个时间执行一次，就ok了，让系统启动的时候启动它，想来也够简单的。不过有了spring，我想这事情就更简单了。

看看spring的配置文件，想来就只有这个配置文件了

[xhtml] view plain copy print ?

<beanid="infoCenterAutoBuildTask"
class="com.teesoo.teanet.scheduling.InfoCenterAutoBuildTask">
<propertyname="baseService"ref="baseService"/>
<propertyname="htmlCreator"ref="htmlCreator"/>
</bean>
<beanid="scheduledTask"
class="org.springframework.scheduling.timer.ScheduledTimerTask">
<propertyname="delay"value="10000"/>
<propertyname="period"value="1000000"/>
<propertyname="timerTask"ref="infoCenterAutoBuildTask"/>
</bean>
<beanid="timerFactory"class="org.springframework.scheduling.timer.TimerFactoryBean">
<propertyname="scheduledTimerTasks">
<list>
<refbean="scheduledTask"/>
</list>
</property>
</bean>

上面三个配置文件中只有一个配置文件是涉及到您自己的class的，其他的都是spring的类。很简单吧

我们只需要涉及一个class让他继承java.util.TimerTask;

[java] view plain copy print ?

BaseTask extends java.util.TimerTask {
//用户只需要实现这个方面，把自己的任务放到这里
public void run(){
}
}

下面让我们来看看 spring的源代码

[java] view plain copy print ?

/*
* Copyright 2002-2005 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.scheduling.timer;
import java.util.TimerTask;
/**
* JavaBean that describes a scheduled TimerTask, consisting of
* the TimerTask itself (or a Runnable to create a TimerTask for)
* and a delay plus period. Period needs to be specified;
* there is no point in a default for it.
*
* The JDK Timer does not offer more sophisticated scheduling
* options such as cron expressions. Consider using Quartz for
* such advanced needs.
*
* Note that Timer uses a TimerTask instance that is shared
* between repeated executions, in contrast to Quartz which
* instantiates a new Job for each execution.
*
* @author Juergen Hoeller
* @since 19.02.2004
* @see java.util.TimerTask
* @see java.util.Timer#schedule(TimerTask, long, long)
* @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long)
*/
public class ScheduledTimerTask {
private TimerTask timerTask;
private long delay =0;
private long period =0;
private boolean fixedRate =false;
/**
* Create a new ScheduledTimerTask,
* to be populated via bean properties.
* @see #setTimerTask
* @see #setDelay
* @see #setPeriod
* @see #setFixedRate
*/
public ScheduledTimerTask() {
}
/**
* Create a new ScheduledTimerTask, with default
* one-time execution without delay.
* @param timerTask the TimerTask to schedule
*/
public ScheduledTimerTask(TimerTask timerTask) {
this.timerTask = timerTask;
}
/**
* Create a new ScheduledTimerTask, with default
* one-time execution with the given delay.
* @param timerTask the TimerTask to schedule
* @param delay the delay before starting the task for the first time (ms)
*/
public ScheduledTimerTask(TimerTask timerTask,long delay) {
this.timerTask = timerTask;
this.delay = delay;
}
/**
* Create a new ScheduledTimerTask.
* @param timerTask the TimerTask to schedule
* @param delay the delay before starting the task for the first time (ms)
* @param period the period between repeated task executions (ms)
* @param fixedRate whether to schedule as fixed-rate execution
*/
public ScheduledTimerTask(TimerTask timerTask,long delay,long period,boolean fixedRate) {
this.timerTask = timerTask;
this.delay = delay;
this.period = period;
this.fixedRate = fixedRate;
}
/**
* Create a new ScheduledTimerTask, with default
* one-time execution without delay.
* @param timerTask the Runnable to schedule as TimerTask
*/
public ScheduledTimerTask(Runnable timerTask) {
setRunnable(timerTask);
}
/**
* Create a new ScheduledTimerTask, with default
* one-time execution with the given delay.
* @param timerTask the Runnable to schedule as TimerTask
* @param delay the delay before starting the task for the first time (ms)
*/
public ScheduledTimerTask(Runnable timerTask,long delay) {
setRunnable(timerTask);
this.delay = delay;
}
/**
* Create a new ScheduledTimerTask.
* @param timerTask the Runnable to schedule as TimerTask
* @param delay the delay before starting the task for the first time (ms)
* @param period the period between repeated task executions (ms)
* @param fixedRate whether to schedule as fixed-rate execution
*/
public ScheduledTimerTask(Runnable timerTask,long delay,long period,boolean fixedRate) {
setRunnable(timerTask);
this.delay = delay;
this.period = period;
this.fixedRate = fixedRate;
}
/**
* Set the Runnable to schedule as TimerTask.
* @see DelegatingTimerTask
*/
public void setRunnable(Runnable timerTask) {
this.timerTask =new DelegatingTimerTask(timerTask);
}
/**
* Set the TimerTask to schedule.
*/
public void setTimerTask(TimerTask timerTask) {
this.timerTask = timerTask;
}
/**
* Return the TimerTask to schedule.
*/
public TimerTask getTimerTask() {
return timerTask;
}
/**
* Set the delay before starting the task for the first time,
* in milliseconds. Default is 0, immediately starting the
* task after successful scheduling.
*/
public void setDelay(long delay) {
this.delay = delay;
}
/**
* Return the delay before starting the job for the first time.
*/
public long getDelay() {
return delay;
}
/**
* Set the period between repeated task executions, in milliseconds.
* Default is 0, leading to one-time execution. In case of a positive
* value, the task will be executed repeatedly, with the given interval
* inbetween executions.
* Note that the semantics of the period vary between fixed-rate
* and fixed-delay execution.
* @see #setFixedRate
*/
public void setPeriod(long period) {
this.period = period;
}
/**
* Return the period between repeated task executions.
*/
public long getPeriod() {
return period;
}
/**
* Set whether to schedule as fixed-rate execution, rather than
* fixed-delay execution. Default is "false", i.e. fixed delay.
* See Timer javadoc for details on those execution modes.
* @see java.util.Timer#schedule(TimerTask, long, long)
* @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long)
*/
public void setFixedRate(boolean fixedRate) {
this.fixedRate = fixedRate;
}
/**
* Return whether to schedule as fixed-rate execution.
*/
public boolean isFixedRate() {
return fixedRate;
}
}

/* 
 * Copyright 2002-2005 the original author or authors. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 
package org.springframework.scheduling.timer; 
 
import java.util.TimerTask; 
 
/** 
 * JavaBean that describes a scheduled TimerTask, consisting of 
 * the TimerTask itself (or a Runnable to create a TimerTask for) 
 * and a delay plus period. Period needs to be specified; 
 * there is no point in a default for it. 
 * 
 * The JDK Timer does not offer more sophisticated scheduling 
 * options such as cron expressions. Consider using Quartz for 
 * such advanced needs. 
 * 
 * Note that Timer uses a TimerTask instance that is shared 
 * between repeated executions, in contrast to Quartz which 
 * instantiates a new Job for each execution. 
 * 
 * @author Juergen Hoeller 
 * @since 19.02.2004 
 * @see java.util.TimerTask 
 * @see java.util.Timer#schedule(TimerTask, long, long) 
 * @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long) 
 */ 
public class ScheduledTimerTask { 
 
 private TimerTask timerTask; 
 
 private long delay = 0; 
 
 private long period = 0; 
 
 private boolean fixedRate = false; 
 
 
 /** 
 * Create a new ScheduledTimerTask, 
 * to be populated via bean properties. 
 * @see #setTimerTask 
 * @see #setDelay 
 * @see #setPeriod 
 * @see #setFixedRate 
 */ 
 public ScheduledTimerTask() { 
 } 
 
 /** 
 * Create a new ScheduledTimerTask, with default 
 * one-time execution without delay. 
 * @param timerTask the TimerTask to schedule 
 */ 
 public ScheduledTimerTask(TimerTask timerTask) { 
 this.timerTask = timerTask; 
 } 
 
 /** 
 * Create a new ScheduledTimerTask, with default 
 * one-time execution with the given delay. 
 * @param timerTask the TimerTask to schedule 
 * @param delay the delay before starting the task for the first time (ms) 
 */ 
 public ScheduledTimerTask(TimerTask timerTask, long delay) { 
 this.timerTask = timerTask; 
 this.delay = delay; 
 } 
 
 /** 
 * Create a new ScheduledTimerTask. 
 * @param timerTask the TimerTask to schedule 
 * @param delay the delay before starting the task for the first time (ms) 
 * @param period the period between repeated task executions (ms) 
 * @param fixedRate whether to schedule as fixed-rate execution 
 */ 
 public ScheduledTimerTask(TimerTask timerTask, long delay, long period, boolean fixedRate) { 
 this.timerTask = timerTask; 
 this.delay = delay; 
 this.period = period; 
 this.fixedRate = fixedRate; 
 } 
 
 /** 
 * Create a new ScheduledTimerTask, with default 
 * one-time execution without delay. 
 * @param timerTask the Runnable to schedule as TimerTask 
 */ 
 public ScheduledTimerTask(Runnable timerTask) { 
 setRunnable(timerTask); 
 } 
 
 /** 
 * Create a new ScheduledTimerTask, with default 
 * one-time execution with the given delay. 
 * @param timerTask the Runnable to schedule as TimerTask 
 * @param delay the delay before starting the task for the first time (ms) 
 */ 
 public ScheduledTimerTask(Runnable timerTask, long delay) { 
 setRunnable(timerTask); 
 this.delay = delay; 
 } 
 
 /** 
 * Create a new ScheduledTimerTask. 
 * @param timerTask the Runnable to schedule as TimerTask 
 * @param delay the delay before starting the task for the first time (ms) 
 * @param period the period between repeated task executions (ms) 
 * @param fixedRate whether to schedule as fixed-rate execution 
 */ 
 public ScheduledTimerTask(Runnable timerTask, long delay, long period, boolean fixedRate) { 
 setRunnable(timerTask); 
 this.delay = delay; 
 this.period = period; 
 this.fixedRate = fixedRate; 
 } 
 
 
 /** 
 * Set the Runnable to schedule as TimerTask. 
 * @see DelegatingTimerTask 
 */ 
 public void setRunnable(Runnable timerTask) { 
 this.timerTask = new DelegatingTimerTask(timerTask); 
 } 
 
 /** 
 * Set the TimerTask to schedule. 
 */ 
 public void setTimerTask(TimerTask timerTask) { 
 this.timerTask = timerTask; 
 } 
 
 /** 
 * Return the TimerTask to schedule. 
 */ 
 public TimerTask getTimerTask() { 
 return timerTask; 
 } 
 
 /** 
 * Set the delay before starting the task for the first time, 
 * in milliseconds. Default is 0, immediately starting the 
 * task after successful scheduling. 
 */ 
 public void setDelay(long delay) { 
 this.delay = delay; 
 } 
 
 /** 
 * Return the delay before starting the job for the first time. 
 */ 
 public long getDelay() { 
 return delay; 
 } 
 
 /** 
 * Set the period between repeated task executions, in milliseconds. 
 * Default is 0, leading to one-time execution. In case of a positive 
 * value, the task will be executed repeatedly, with the given interval 
 * inbetween executions. 
 * Note that the semantics of the period vary between fixed-rate 
 * and fixed-delay execution. 
 * @see #setFixedRate 
 */ 
 public void setPeriod(long period) { 
 this.period = period; 
 } 
 
 /** 
 * Return the period between repeated task executions. 
 */ 
 public long getPeriod() { 
 return period; 
 } 
 
 /** 
 * Set whether to schedule as fixed-rate execution, rather than 
 * fixed-delay execution. Default is "false", i.e. fixed delay. 
 * See Timer javadoc for details on those execution modes. 
 * @see java.util.Timer#schedule(TimerTask, long, long) 
 * @see java.util.Timer#scheduleAtFixedRate(TimerTask, long, long) 
 */ 
 public void setFixedRate(boolean fixedRate) { 
 this.fixedRate = fixedRate; 
 } 
 
 /** 
 * Return whether to schedule as fixed-rate execution. 
 */ 
 public boolean isFixedRate() { 
 return fixedRate; 
 } 
 
}

说实话这个类也没什么，只是简单的包装了我们的timertask，里面也就只有几个属性，一个是时间片，一个是任务等。

真正运行我们的任务的类是：

[java] view plain copy print ?

/*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.scheduling.timer;
import java.util.Timer;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.InitializingBean;
/**
* FactoryBean that sets up a JDK 1.3+ Timer and exposes it for bean references.
*
* Allows for registration of ScheduledTimerTasks, automatically starting
* the Timer on initialization and cancelling it on destruction of the context.
* In scenarios that just require static registration of tasks at startup,
* there is no need to access the Timer instance itself in application code.
*
* Note that Timer uses a TimerTask instance that is shared between
* repeated executions, in contrast to Quartz which instantiates a new
* Job for each execution.
*
* @author Juergen Hoeller
* @since 19.02.2004
* @see ScheduledTimerTask
* @see java.util.Timer
* @see java.util.TimerTask
*/
public class TimerFactoryBeanimplements FactoryBean, InitializingBean, DisposableBean {
protected final Log logger = LogFactory.getLog(getClass());
private ScheduledTimerTask[] scheduledTimerTasks;
private boolean daemon =false;
private Timer timer;
/**
* Register a list of ScheduledTimerTask objects with the Timer that
* this FactoryBean creates. Depending on each SchedulerTimerTask's
* settings, it will be registered via one of Timer's schedule methods.
* @see java.util.Timer#schedule(java.util.TimerTask, long)
* @see java.util.Timer#schedule(java.util.TimerTask, long, long)
* @see java.util.Timer#scheduleAtFixedRate(java.util.TimerTask, long, long)
*/
public void setScheduledTimerTasks(ScheduledTimerTask[] scheduledTimerTasks) {
this.scheduledTimerTasks = scheduledTimerTasks;
}
/**
* Set whether the timer should use a daemon thread,
* just executing as long as the application itself is running.
* Default is "false": The timer will automatically get cancelled on
* destruction of this FactoryBean. Hence, if the application shuts down,
* tasks will by default finish their execution. Specify "true" for eager
* shutdown of threads that execute tasks.
* @see java.util.Timer#Timer(boolean)
*/
public void setDaemon(boolean daemon) {
this.daemon = daemon;
}
public void afterPropertiesSet() {
logger.info("Initializing Timer");
this.timer = createTimer(this.daemon);
// Register all ScheduledTimerTasks.
if (this.scheduledTimerTasks !=null) {
for (int i =0; i <this.scheduledTimerTasks.length; i++) {
ScheduledTimerTask scheduledTask = this.scheduledTimerTasks[i];
if (scheduledTask.getPeriod() >0) {
// repeated task execution
if (scheduledTask.isFixedRate()) {
this.timer.scheduleAtFixedRate(
scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());
}
else {
this.timer.schedule(
scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod());
}
}
else {
// One-time task execution.
this.timer.schedule(scheduledTask.getTimerTask(), scheduledTask.getDelay());
}
}
}
}
/**
* Create a new Timer instance. Called by <code>afterPropertiesSet</code>.
* Can be overridden in subclasses to provide custom Timer subclasses.
* @param daemon whether to create a Timer that runs as daemon thread
* @return a new Timer instance
* @see #afterPropertiesSet()
* @see java.util.Timer#Timer(boolean)
*/
protected Timer createTimer(boolean daemon) {
return new Timer(daemon);
}
public Object getObject() {
return this.timer;
}
public Class getObjectType() {
return Timer.class;
}
public boolean isSingleton() {
return true;
}
/**
* Cancel the Timer on bean factory shutdown, stopping all scheduled tasks.
* @see java.util.Timer#cancel()
*/
public void destroy() {
logger.info("Cancelling Timer");
this.timer.cancel();
}
}

/* 
 * Copyright 2002-2006 the original author or authors. 
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); 
 * you may not use this file except in compliance with the License. 
 * You may obtain a copy of the License at 
 * 
 * http://www.apache.org/licenses/LICENSE-2.0 
 * 
 * Unless required by applicable law or agreed to in writing, software 
 * distributed under the License is distributed on an "AS IS" BASIS, 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
 * See the License for the specific language governing permissions and 
 * limitations under the License. 
 */ 
 
package org.springframework.scheduling.timer; 
 
import java.util.Timer; 
 
import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
 
import org.springframework.beans.factory.DisposableBean; 
import org.springframework.beans.factory.FactoryBean; 
import org.springframework.beans.factory.InitializingBean; 
 
/** 
 * FactoryBean that sets up a JDK 1.3+ Timer and exposes it for bean references. 
 * 
 * Allows for registration of ScheduledTimerTasks, automatically starting 
 * the Timer on initialization and cancelling it on destruction of the context. 
 * In scenarios that just require static registration of tasks at startup, 
 * there is no need to access the Timer instance itself in application code. 
 * 
 * Note that Timer uses a TimerTask instance that is shared between 
 * repeated executions, in contrast to Quartz which instantiates a new 
 * Job for each execution. 
 * 
 * @author Juergen Hoeller 
 * @since 19.02.2004 
 * @see ScheduledTimerTask 
 * @see java.util.Timer 
 * @see java.util.TimerTask 
 */ 
public class TimerFactoryBean implements FactoryBean, InitializingBean, DisposableBean { 
 
 protected final Log logger = LogFactory.getLog(getClass()); 
 
 private ScheduledTimerTask[] scheduledTimerTasks; 
 
 private boolean daemon = false; 
 
 private Timer timer; 
 
 
 /** 
 * Register a list of ScheduledTimerTask objects with the Timer that 
 * this FactoryBean creates. Depending on each SchedulerTimerTask's 
 * settings, it will be registered via one of Timer's schedule methods. 
 * @see java.util.Timer#schedule(java.util.TimerTask, long) 
 * @see java.util.Timer#schedule(java.util.TimerTask, long, long) 
 * @see java.util.Timer#scheduleAtFixedRate(java.util.TimerTask, long, long) 
 */ 
 public void setScheduledTimerTasks(ScheduledTimerTask[] scheduledTimerTasks) { 
 this.scheduledTimerTasks = scheduledTimerTasks; 
 } 
 
 /** 
 * Set whether the timer should use a daemon thread, 
 * just executing as long as the application itself is running. 
 * Default is "false": The timer will automatically get cancelled on 
 * destruction of this FactoryBean. Hence, if the application shuts down, 
 * tasks will by default finish their execution. Specify "true" for eager 
 * shutdown of threads that execute tasks. 
 * @see java.util.Timer#Timer(boolean) 
 */ 
 public void setDaemon(boolean daemon) { 
 this.daemon = daemon; 
 } 
 
 
 public void afterPropertiesSet() { 
 logger.info("Initializing Timer"); 
 this.timer = createTimer(this.daemon); 
 
 // Register all ScheduledTimerTasks. 
 if (this.scheduledTimerTasks != null) { 
 for (int i = 0; i < this.scheduledTimerTasks.length; i++) { 
 ScheduledTimerTask scheduledTask = this.scheduledTimerTasks[i]; 
 if (scheduledTask.getPeriod() > 0) { 
 // repeated task execution 
 if (scheduledTask.isFixedRate()) { 
 this.timer.scheduleAtFixedRate( 
 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod()); 
 } 
 else { 
 this.timer.schedule( 
 scheduledTask.getTimerTask(), scheduledTask.getDelay(), scheduledTask.getPeriod()); 
 } 
 } 
 else { 
 // One-time task execution. 
 this.timer.schedule(scheduledTask.getTimerTask(), scheduledTask.getDelay()); 
 } 
 } 
 } 
 } 
 
 /** 
 * Create a new Timer instance. Called by <code>afterPropertiesSet</code>. 
 * Can be overridden in subclasses to provide custom Timer subclasses. 
 * @param daemon whether to create a Timer that runs as daemon thread 
 * @return a new Timer instance 
 * @see #afterPropertiesSet() 
 * @see java.util.Timer#Timer(boolean) 
 */ 
 protected Timer createTimer(boolean daemon) { 
 return new Timer(daemon); 
 } 
 
 
 public Object getObject() { 
 return this.timer; 
 } 
 
 public Class getObjectType() { 
 return Timer.class; 
 } 
 
 public boolean isSingleton() { 
 return true; 
 } 
 
 
 /** 
 * Cancel the Timer on bean factory shutdown, stopping all scheduled tasks. 
 * @see java.util.Timer#cancel() 
 */ 
 public void destroy() { 
 logger.info("Cancelling Timer"); 
 this.timer.cancel(); 
 } 
 
}

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

转自：http://www.javaeye.com/topic/67095

quinn_hn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
彻底理解spring的定制任务（scheduling）

相信做软件的朋友都有这样的经历，我的软件是不是少了点什么东西呢？比如定时任务啊，就拿新闻发布系统来说，如果新闻的数据更新太快，势必涉及一个问题，这些新闻不能由人工的去发布，应该让系统自己发布，这就需要用到定时定制任务了，以前定制任务无非就是设计一个Thread，并且设置运行时间片，让它到了那个时间执行一次，就ok了，让系统启动的时候启动它，想来也够简单的。不过有了spring，我想这事情
复制链接

扫一扫