谈谈spring定时调度的几种实现方式

来源：互联网发布：淘宝信鸽出售编辑：程序博客网时间：2024/06/06 09:36

近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，或对一些过期图片的定时清理或者库存不足发出预警提示，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合spring框架来介绍。

 

 
<h1>一、分类</h1>
 
<h2>从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：</h2>
1、Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行一次或者反复执行多次，但不能在指定时间运行。一般用的较少，本文将不做详细介绍。

2、使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。

3、（推荐）Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

 
<h2>从作业类的继承方式来讲，可以分为两类：</h2>
1、作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean（java.util.Timer中需要继承自java.util.TimerTask）。

2、作业类即普通的java类，不需要继承自任何基类。

 
<h2>从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：</h2>
1、每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerFactoryBean

2、每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerFactoryBean

（注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。）

 
<h1>二、具体实现</h1>
<img class="size-full wp-image-417 aligncenter" src="http://59.110.158.250/wp-content/uploads/2017/08/20170805001.png" alt="" width="1323" height="541" />

 

详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。

 

首先要么导入相应的jar包，要么使用maven加载。
<pre class="lang:default decode:true "><properties>
<springframework.version>4.3.10.RELEASE</springframework.version>
</properties>

<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${springframework.version}</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>

<version>2.2.1</version>
</dependency>
</dependencies></pre>
 

 
<h2>2.1、Quartz</h2>
<h3>2.1.1、作业类继承自特定的基类org.springframework.scheduling.quartz.QuartzJobBean</h3>
第一步：定义作业类

MyJob.java
<pre class="lang:default decode:true">import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.Date;

/**
* Created by Xjh on 2017/8/5.
*/
public class MyJob extends QuartzJobBean {
private int timeout;
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout = timeout;
}

/**
* 要调度的具体任务
*/
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
System.out.println("myJob-->定时任务执行中…" + new Date());
}
}</pre>
 

 

 

第二步：spring配置文件中配置作业类JobDetailBean
<pre class="lang:default decode:true">

<bean name="myJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
<property name="name" value="exampleJob" />
<property name="jobClass" value="com.xjh.quartz.MyJob" />
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="0" />
</map>
</property>
</bean></pre>
说明：org.springframework.scheduling.quartz.JobDetailFactoryBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。

 

 

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerFactoryBean

org.springframework.scheduling.quartz.CronTriggerFactoryBean
<pre class="lang:default decode:true">
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
<property name="jobDetail" ref="myJob" />
<property name="startDelay" value="0" />
<property name="repeatInterval" value="2000" />
</bean></pre>
<pre class="lang:default decode:true">



 
</pre>
 

第四步：配置调度工厂
<pre class="lang:default decode:true ">
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTrigger" />

</list>
</property>
</bean></pre>
 

说明：该参数指定的就是之前配置的触发器的名字。

 

别忘了还有一个web.xml要加载spring的配置文件。
<pre class="lang:default decode:true "><context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-*.xml</param-value>
</context-param>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener></pre>
 

然后就可以部署运行tomcat了。

 
<h2>2.1.2、作业类不继承特定基类。</h2>
Spring能够支持这种方式，归功于两个类：

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。

 

第一步：编写任务类
<pre class="lang:default decode:true ">import java.util.Date;

/**
* Created by Xjh on 2017/8/5.
*/
public class MyJob2 {
protected void execute(){
System.out.println("myjob2-->\t\t" + new Date());
}
}</pre>
 

可以看出，这就是一个普通的类，并且有一个方法。

 

第二步：配置作业类
<pre class="lang:default decode:true "><bean id="myJob2" class="com.xjh.quartz.MyJob2"/>
<bean id="springQtzJobMethod" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject">
<ref bean="myJob2"></ref>
</property>
<property name="targetMethod">
<value>execute</value>
</property>
</bean></pre>
 

说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。

 

第三步：配置作业调度的触发方式（触发器）
<pre class="lang:default decode:true">
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
<property name="jobDetail" ref="myJob" />
<property name="startDelay" value="0" />
<property name="repeatInterval" value="2000" />
</bean></pre>
<pre class="lang:default decode:true ">



 
</pre>
 

以上两种调度方式根据实际情况，任选一种即可。

 

第四步：配置调度工厂 
<pre class="lang:default decode:true ">
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="simpleTrigger" />

</list>
</property>
</bean></pre>
 

到此，spring中Quartz的基本配置就介绍完了，其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具？

有！请看我第下文Spring task的介绍（推荐第三种方式）。

 
<h2>2.2、Spring-Task</h2>
上文介绍了在Spring 中使用Quartz，这里介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。

 
<h4>2.2.1配置文件开发</h4>
 

第一步：编写作业类
<pre class="lang:default decode:true ">/**
* Created by Xjh on 2017/8/5.
*/
import org.springframework.stereotype.Service;
import java.util.Date;

@Service
public class TaskJob {
public void task() {
System.out.println("task->任务进行中。。。" + new Date());
}
}</pre>
 

 

第二步：在spring配置文件头中添加命名空间及描述
<pre class="lang:default decode:true "><beans xmlns="http://www.springframework.org/schema/beans"
xmlns:task="http://www.springframework.org/schema/task"
......
xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"></pre>
 

 

 第三步：spring配置文件中设置具体的任务
<pre class="lang:default decode:true ">
<context:component-scan base-package="com.xjh.task" />


<task:scheduled-tasks>
<task:scheduled ref="taskJob" method="task" cron="0 * * * * ?"/>
</task:scheduled-tasks></pre>
 

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法稍后详解。

 

spring-task到这里就配置完成了，是不是很简单？下面再来谈谈注解开发的spring-task吧。

 
<h4>2.2.2注解开发</h4>
也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：
<pre class="lang:default decode:true ">@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheduled
{
public abstract String cron();
public abstract long fixedDelay();
public abstract long fixedRate();
}</pre>
 

可以看出该注解有三个方法或者叫参数，分别表示的意思是：

cron：指定cron表达式

fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。

fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。

 

第一步：写Pojo
<pre class="lang:default decode:true ">/**
* Created by Xjh on 2017/8/5.
*/
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import java.util.Date;

@Service
public class TaskJob {
@Scheduled(cron = "0 * * * * ?")
public void task() {
System.out.println("task->任务进行中。。。" + new Date());
}
}</pre>
 

 

第二步：添加task相关的配置：
<pre class="lang:default decode:true "><?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:task="http://www.springframework.org/schema/task"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/task
http://www.springframework.org/schema/task/spring-task-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">


<context:annotation-config />


<context:component-scan base-package="com.xjh.task" />



<task:annotation-driven scheduler="qbScheduler" mode="proxy"/>
<task:scheduler id="qbScheduler" pool-size="10"/>





</beans></pre>
 

网上的说法需要开启上面红色的配置信息才能识别@Scheduled注解，但是经过我的实测，只需要加载注解驱动<context:annotation-config />即可，并不需要加载task的两条配置信息。

 

Ok配置完毕

当然spring task还有很多参数，我就不一一解释了，具体参考<a href="http://www.springframework.org/schema/task/spring-task-3.0.xsd">xsd文档</a>。

 
<h1>附录：</h1>
一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。

按顺序依次为

1、秒（0~59）

2、分钟（0~59）

3、小时（0~23）

4、天（月）（0~31，但是你需要考虑你月的天数）

5、月（0~11）

6、天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）

7、年份（1970－2099）

其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.

0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
 0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
 0 0 12 ? * WED 表示每个星期三中午12点 
 0 0 12 * * ? 每天中午12点触发 
 0 15 10 ? * * 每天上午10:15触发 
 0 15 10 * * ? 每天上午10:15触发 
 0 15 10 * * ? * 每天上午10:15触发 
 0 15 10 * * ? 2005 2005年的每天上午10:15触发 
 0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发 
 0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发 
 0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
 0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发 
 0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发 
 0 15 10 ? * MON-FRI 周一至周五的上午10:15触发 
 0 15 10 15 * ? 每月15日上午10:15触发 
 0 15 10 L * ? 每月最后一日的上午10:15触发 
 0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发 
 0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发 
 0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

有些子表达式能包含一些范围或列表

例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”

“*”字符代表所有可能的值

因此，“*”在子表达式（月）里表示每个月的含义，“*”在子表达式（天（星期））表示星期的每一天

“/”字符用来指定数值的增量

例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟

在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

 

“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值

当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写

但是它在两个子表达式里的含义是不同的。

在天（月）子表达式中，“L”表示一个月的最后一天

在天（星期）自表达式中，“L”表示一个星期的最后一天，也就是SAT

如果在“L”前有具体的内容，它就具有其他的含义了

例如：“6L”表示这个月的倒数第６天，“ＦＲＩＬ”表示这个月的最一个星期五

注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

 

看完了这个应该知道spring的cron表达式了吧，再回去看看上面的源码，知道是何含义了吧？

 
<table style="border-color: #4431b0;">
<tbody>
<tr>
<td>字段</td>
<td>允许值</td>
<td>允许的特殊字符</td>
</tr>
<tr>
<td>秒</td>
<td>0-59</td>
<td>, - * /</td>
</tr>
<tr>
<td>分</td>
<td>0-59</td>
<td>, - * /</td>
</tr>
<tr>
<td>小时</td>
<td>0-23</td>
<td>, - * /</td>
</tr>
<tr>
<td>日期</td>
<td>1-31</td>
<td>, - * ? / L W C</td>
</tr>
<tr>
<td>月份</td>
<td>1-12 或者 JAN-DEC</td>
<td>, - * /</td>
</tr>
<tr>
<td>星期</td>
<td>1-7 或者 SUN-SAT</td>
<td>, - * ? / L C #</td>
</tr>
<tr>
<td>年（可选）</td>
<td>留空, 1970-2099</td>
<td>, - * /</td>
</tr>
</tbody>
</table>
 

 

 

有句MMP一定要讲，遇见过很多人，看到过很多事，才知道自己那点哀伤多么微不足道，每个人的生活都有过千疮百孔，从千疮百孔到平凡努力的精彩，这就是最好的了不起。改变世界不用大刀阔斧，一个个小碎步依然可以万丈光芒。

阅读全文

0 0