谈谈spring定时调度任务的几种实现
近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，或对一些过期图片的定时清理或者库存不足发出预警提示，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合spring框架来介绍。
一、分类
从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：
1、Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行一次或者反复执行多次，但不能在指定时间运行。一般用的较少，本文将不做详细介绍。
2、使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
3、（推荐）Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。
从作业类的继承方式来讲，可以分为两类：
1、作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean（java.util.Timer中需要继承自java.util.TimerTask）。
2、作业类即普通的java类，不需要继承自任何基类。
从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：
1、每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerFactoryBean
2、每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerFactoryBean
（注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。）
二、具体实现
详细介绍每种任务调度工具的使用方式，包括Quartz和spring task两种。
首先要么导入相应的jar包，要么使用maven加载。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
<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>1.8.5</version>--> <version>2.2.1</version> </dependency> </dependencies> |
2.1、Quartz
2.1.1、作业类继承自特定的基类org.springframework.scheduling.quartz.QuartzJobBean
第一步：定义作业类
MyJob.java
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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()); } } |
第二步：spring配置文件中配置作业类JobDetailBean
|
1 2 3 4 5 6 7 8 9 10 11 |
<!--第一种方法 作业类继承自特定的基类。--> <!--JobDetailFactoryBean--> <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> |
说明：org.springframework.scheduling.quartz.JobDetailFactoryBean有两个属性，jobClass属性即我们在java代码中定义的任务类，jobDataAsMap属性即该任务类中需要注入的属性值。
第三步：配置作业调度的触发方式（触发器）
Quartz的作业触发器有两种，分别是
org.springframework.scheduling.quartz.SimpleTriggerFactoryBean
org.springframework.scheduling.quartz.CronTriggerFactoryBean
|
1 2 3 4 5 6 |
<!--调度触发器simpleTrigger（每隔一段时间执行）--> <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"> <property name="jobDetail" ref="myJob" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> |
|
1 2 3 4 5 6 |
<!--调度触发器cronTrigger（每到一个时间点执行）--> <!--<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">--> <!--<property name="jobDetail" ref="myJob" />--> <!--<!–每天12:00运行一次 –>--> <!--<property name="cronExpression" value="0 0 12 * * ?" />--> <!-- 具体参照spring的cron规则，稍后在后文详细介绍 --> <!--</bean>--> |
第四步：配置调度工厂
|
1 2 3 4 5 6 7 8 9 |
<!--配置调度工厂--> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="simpleTrigger" /> <!--<ref bean="cronTrigger" />--> </list> </property> </bean> |
说明：该参数指定的就是之前配置的触发器的名字。
别忘了还有一个web.xml要加载spring的配置文件。
|
1 2 3 4 5 6 7 8 |
<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> |
然后就可以部署运行tomcat了。
2.1.2、作业类不继承特定基类。
Spring能够支持这种方式，归功于两个类：
org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean
org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean
这两个类分别对应spring支持的两种实现任务调度的方式，即前文提到到java自带的timer task方式和Quartz方式。这里我只写MethodInvokingJobDetailFactoryBean的用法，使用该类的好处是,我们的任务类不再需要继承自任何类，而是普通的pojo。
第一步：编写任务类
|
1 2 3 4 5 6 7 8 9 10 |
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()); } } |
可以看出，这就是一个普通的类，并且有一个方法。
第二步：配置作业类
|
1 2 3 4 5 6 7 8 9 |
<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> |
说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。
第三步：配置作业调度的触发方式（触发器）
|
1 2 3 4 5 6 |
<!--调度触发器simpleTrigger（每隔一段时间执行）--> <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"> <property name="jobDetail" ref="myJob" /> <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 --> <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 --> </bean> |
|
1 2 3 4 5 6 |
<!--调度触发器cronTrigger（每到一个时间点执行）--> <!--<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">--> <!--<property name="jobDetail" ref="myJob" />--> <!--<!–每天12:00运行一次 –>--> <!--<property name="cronExpression" value="0 0 12 * * ?" />--> <!-- 具体参照spring的cron规则，稍后在后文详细介绍 --> <!--</bean>--> |
以上两种调度方式根据实际情况，任选一种即可。
第四步：配置调度工厂
|
1 2 3 4 5 6 7 8 9 |
<!--配置调度工厂--> <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> <property name="triggers"> <list> <ref bean="simpleTrigger" /> <!--<ref bean="cronTrigger" />--> </list> </property> </bean> |
到此，spring中Quartz的基本配置就介绍完了，其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具？
有！请看我第下文Spring task的介绍（推荐第三种方式）。
2.2、Spring-Task
上文介绍了在Spring 中使用Quartz，这里介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种
形式，下面将分别介绍这两种方式。
2.2.1配置文件开发
第一步：编写作业类
|
1 2 3 4 5 6 7 8 9 10 11 12 |
/** * 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()); } } |
第二步：在spring配置文件头中添加命名空间及描述
|
1 2 3 4 |
<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"> |
第三步：spring配置文件中设置具体的任务
|
1 2 3 4 5 6 7 |
<!--扫描包--> <context:component-scan base-package="com.xjh.task" /> <!--非注解--> <task:scheduled-tasks> <task:scheduled ref="taskJob" method="task" cron="0 * * * * ?"/> </task:scheduled-tasks> |
说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法稍后详解。
spring-task到这里就配置完成了，是不是很简单？下面再来谈谈注解开发的spring-task吧。
2.2.2注解开发
也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：
|
1 2 3 4 5 6 7 8 9 |
@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(); } |
可以看出该注解有三个方法或者叫参数，分别表示的意思是：
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
/** * 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()); } } |
第二步：添加task相关的配置：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
<?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" /> <!--注解--> <!--开启这个配置，spring才能识别@Scheduled注解 --> <task:annotation-driven scheduler="qbScheduler" mode="proxy"/> <task:scheduler id="qbScheduler" pool-size="10"/> <!--非注解--> <!--<task:scheduled-tasks>--> <!--<task:scheduled ref="taskJob" method="task" cron="0 * * * * ?"/>--> <!--</task:scheduled-tasks>--> </beans> |
网上的说法需要开启上面红色的配置信息才能识别@Scheduled注解，但是经过我的实测，只需要加载注解驱动<context:annotation-config />即可，并不需要加载task的两条配置信息。
Ok配置完毕
当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档。
附录：
一个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表达式了吧，再回去看看上面的源码，知道是何含义了吧？
| 字段 | 允许值 | 允许的特殊字符 |
| 秒 | 0-59 | , - * / |
| 分 | 0-59 | , - * / |
| 小时 | 0-23 | , - * / |
| 日期 | 1-31 | , - * ? / L W C |
| 月份 | 1-12 或者 JAN-DEC | , - * / |
| 星期 | 1-7 或者 SUN-SAT | , - * ? / L C # |
| 年（可选） | 留空, 1970-2099 | , - * / |
有句MMP一定要讲，遇见过很多人，看到过很多事，才知道自己那点哀伤多么微不足道，每个人的生活都有过千疮百孔，从千疮百孔到平凡努力的精彩，这就是最好的了不起。改变世界不用大刀阔斧，一个个小碎步依然可以万丈光芒。
发表评论