spring task定时调度任务

素颜马尾好姑娘i 2022-06-11 06:13 361阅读 0赞

深入浅出spring task定时任务

在工作中有用到spring task作为定时任务的处理，spring通过接口TaskExecutor和TaskScheduler这两个接口的方式为异步定时任务提供了一种抽象。这就意味着spring容许你使用其他的定时任务框架，当然spring自身也提供了一种定时任务的实现：spring task。spring task支持线程池，可以高效处理许多不同的定时任务。同时，spring还支持使用Java自带的Timer定时器和Quartz定时框架。限于篇幅，这里将只介绍spring task的使用。

其实，官方文档已经介绍地足够详细，只不过都是英文版，所以为了更好地理解并使用spring task，首先会对spring task的实现原理做一个简单的介绍，然后通过实际代码演示spring task是如何使用的。这里会涉及到一个很重要的知识点：cron表达式。

TaskExecutor和TaskScheduler

TaskExecutor是spring task的第一个抽象，它很自然让人联想到jdk中concurrent包下的Executor，实际上TaskExecutor就是为区别于Executor才引入的，而引入TaskExecutor的目的就是为定时任务的执行提供线程池的支持，那么，问题来了，为什么spring不直接使用jdk自带的Executor呢？TaskExecutor源码如下？

  1. public interface TaskExecutor extends Executor { 
  2.     void execute(Runnable var1);
  3. }
  6.    1
  7.    2
  8.    3
  12.    1
  13.    2
  14.    3

那么，答案很显然，TaskExecutor提供的线程池支持也是基于jdk自带的Executor的。用法于Executor没有什么不同。

TaskScheduler是spring task的第二个抽象，那么从字面的意义看，TaskScheduler就是为了提供定时任务的支持咯。TaskScheduler需要传入一个Runnable的任务做为参数，并指定需要周期执行的时间或者触发器，这样Runnable任务就可以周期性执行了。传入时间很好理解，有意思的是传入一个触发器（Trigger）的情况，因为这里需要使用cron表达式去触发一个定时任务，所以有必要先了解下cron表达式的使用。

在spring 4.x中已经不支持7个参数的cronin表达式了，要求必须是6个参数（具体哪个参数后面会说）。cron表达式的格式如下：

  1. { 秒} { 分} { 时} { 日期（具体哪天）} { 月} { 星期}
  4.    1
  8.    1
  • 秒：必填项，允许的值范围是0-59，支持的特殊符号包括, - * /，,表示特定的某一秒才会触发任务，-表示一段时间内会触发任务，*表示每一秒都会触发，/表示从哪一个时刻开始，每隔多长时间触发一次任务。
  • 分：必填项，允许的值范围是0-59，支持的特殊符号和秒一样，含义类推
  • 时：必填项，允许的值范围是0-23，支持的特殊符号和秒一样，含义类推
  • 日期：必填项，允许的值范围是1-31，支持的特殊符号相比秒多了?，表示与{星期}互斥，即意味着若明确指定{星期}触发，则表示{日期}无意义，以免引起冲突和混乱。
  • 月：必填项，允许的值范围是1-12（JAN-DEC），支持的特殊符号与秒一样，含义类推
  • 星期：必填项，允许值范围是1~7 (SUN-SAT),1代表星期天（一星期的第一天），以此类推，7代表星期六，支持的符号相比秒多了?，表达的含义是与{日期}互斥，即意味着若明确指定{日期}触发，则表示{星期}无意义。

比如下面这个cron表达式：

  1. // 表达的含义是：每半分钟触发一次任务
  2. 30 * * * * ?
  5.    1
  6.    2
  10.    1
  11.    2

spring提供了一个CronTrigger，通过传入一个Runnable任务和CronTrigger，就可以使用cron表达式去指定定时任务了，是不是非常方面。实际上，在工程实践上，cron表达式也是使用很多的。实际上，是执行了下面的代码：

  1. scheduler.schedule(task, new CronTrigger("30 * * * * ?"));
  4.    1
  8.    1

TaskScheduler抽象的好处是让需要执行定时任务的代码不需要指定特定的定时框架（比如Timer和Quartz）。TaskScheduler的更简单的实现是ThreadPoolTaskScheduler,它实际上代理一个jdk中的SchedulingTaskExecutor，并且也实现了TaskExecutor接口，所以需要经常执行定时任务的场景可以使用这个实现（Spring推荐）。我们再来看一下TaskExecutor和TaskScheduler的类继承关系：

spring-task

通常而言，使用spring task实现定时任务有两种方式：注解和xml配置文件。这里使用xml配置文件的方式加以说明。

实战

创建Maven工程，pom.xml:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.     <modelVersion>4.0.0</modelVersion>
  5.     <groupId>com.rhwayfun</groupId>
  6.     <artifactId>sring-task-demo</artifactId>
  7.     <version>1.0-SNAPSHOT</version>
  9.     <dependencies>
  10.         <dependency>
  11.             <groupId>org.springframework</groupId>
  12.             <artifactId>spring-context</artifactId>
  13.             <version>4.2.4.RELEASE</version>
  14.         </dependency>
  15.     </dependencies>
  17.     <build>
  18.         <plugins>
  19.             <plugin>
  20.                 <groupId>org.apache.maven.plugins</groupId>
  21.                 <artifactId>maven-compiler-plugin</artifactId>
  22.                 <version>3.5.1</version>
  23.                 <configuration>
  24.                     <source>1.8</source>
  25.                     <target>1.8</target>
  26.                 </configuration>
  27.             </plugin>
  28.         </plugins>
  29.     </build>
  30. </project>
  33.    1
  34.    2
  35.    3
  36.    4
  37.    5
  38.    6
  39.    7
  40.    8
  41.    9
  42.    10
  43.    11
  44.    12
  45.    13
  46.    14
  47.    15
  48.    16
  49.    17
  50.    18
  51.    19
  52.    20
  53.    21
  54.    22
  55.    23
  56.    24
  57.    25
  58.    26
  59.    27
  60.    28
  61.    29
  62.    30
  63.    31
  64.    32
  68.    1
  69.    2
  70.    3
  71.    4
  72.    5
  73.    6
  74.    7
  75.    8
  76.    9
  77.    10
  78.    11
  79.    12
  80.    13
  81.    14
  82.    15
  83.    16
  84.    17
  85.    18
  86.    19
  87.    20
  88.    21
  89.    22
  90.    23
  91.    24
  92.    25
  93.    26
  94.    27
  95.    28
  96.    29
  97.    30
  98.    31
  99.    32

开发需要执行定时任务的方法：

  1. package com.rhwayfun.task;
  3. import org.springframework.stereotype.Component;
  5. import java.time.LocalDateTime;
  7. /** * @author ZhongCB * @date 2016年09月10日 14:30 * @description */
  8. @Component
  9. public class App { 
  11.     public void execute1(){
  12.         System.out.printf("Task: %s, Current time: %s\n", 1, LocalDateTime.now());
  13.     }
  15.     public void execute2(){
  16.         System.out.printf("Task: %s, Current time: %s\n", 2, LocalDateTime.now());
  17.     }
  19.     public void execute3(){
  20.         System.out.printf("Task: %s, Current time: %s\n", 3, LocalDateTime.now());
  21.     }
  23.     public void execute4(){
  24.         System.out.printf("Task: %s, Current time: %s\n", 4, LocalDateTime.now());
  25.     }
  27.     public void execute5(){
  28.         System.out.printf("Task: %s, Current time: %s\n", 5, LocalDateTime.now());
  29.     }
  31.     public void execute6(){
  32.         System.out.printf("Task: %s, Current time: %s\n", 6, LocalDateTime.now());
  33.     }
  35.     public void execute7(){
  36.         System.out.printf("Task: %s, Current time: %s\n", 7, LocalDateTime.now());
  37.     }
  39.     public void execute8(){
  40.         System.out.printf("Task: %s, Current time: %s\n", 8, LocalDateTime.now());
  41.     }
  43.     public void execute9(){
  44.         System.out.printf("Task: %s, Current time: %s\n", 9, LocalDateTime.now());
  45.     }
  47.     public void execute10(){
  48.         System.out.printf("Task: %s, Current time: %s\n", 10, LocalDateTime.now());
  49.     }
  51.     public void execute11(){
  52.         System.out.printf("Task: %s, Current time: %s\n", 11, LocalDateTime.now());
  53.     }
  55. }
  59.    1
  60.    2
  61.    3
  62.    4
  63.    5
  64.    6
  65.    7
  66.    8
  67.    9
  68.    10
  69.    11
  70.    12
  71.    13
  72.    14
  73.    15
  74.    16
  75.    17
  76.    18
  77.    19
  78.    20
  79.    21
  80.    22
  81.    23
  82.    24
  83.    25
  84.    26
  85.    27
  86.    28
  87.    29
  88.    30
  89.    31
  90.    32
  91.    33
  92.    34
  93.    35
  94.    36
  95.    37
  96.    38
  97.    39
  98.    40
  99.    41
  100.    42
  101.    43
  102.    44
  103.    45
  104.    46
  105.    47
  106.    48
  107.    49
  108.    50
  109.    51
  110.    52
  111.    53
  112.    54
  113.    55
  114.    56
  115.    57
  116.    58
  117.    59
  118.    60
  122.    1
  123.    2
  124.    3
  125.    4
  126.    5
  127.    6
  128.    7
  129.    8
  130.    9
  131.    10
  132.    11
  133.    12
  134.    13
  135.    14
  136.    15
  137.    16
  138.    17
  139.    18
  140.    19
  141.    20
  142.    21
  143.    22
  144.    23
  145.    24
  146.    25
  147.    26
  148.    27
  149.    28
  150.    29
  151.    30
  152.    31
  153.    32
  154.    33
  155.    34
  156.    35
  157.    36
  158.    37
  159.    38
  160.    39
  161.    40
  162.    41
  163.    42
  164.    43
  165.    44
  166.    45
  167.    46
  168.    47
  169.    48
  170.    49
  171.    50
  172.    51
  173.    52
  174.    53
  175.    54
  176.    55
  177.    56
  178.    57
  179.    58
  180.    59
  181.    60

spring配置文件如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.1.xsd">
  4.     <!-- 配置注解扫描 -->
  5.     <context:component-scan base-package="com.rhwayfun.task"/>
  7.     <task:scheduler id="taskScheduler" pool-size="100" />
  9.     <task:scheduled-tasks scheduler="taskScheduler">
  10.         <!-- 每半分钟触发任务 -->
  11.         <task:scheduled ref="app" method="execute1" cron="30 * * * * ?"/>
  12.         <!-- 每小时的10分30秒触发任务 -->
  13.         <task:scheduled ref="app" method="execute2" cron="30 10 * * * ?"/>
  14.         <!-- 每天1点10分30秒触发任务 -->
  15.         <task:scheduled ref="app" method="execute3" cron="30 10 1 * * ?"/>
  16.         <!-- 每月20号的1点10分30秒触发任务 -->
  17.         <task:scheduled ref="app" method="execute4" cron="30 10 1 20 * ?"/>
  18.         <!-- 每年10月20号的1点10分30秒触发任务 -->
  19.         <task:scheduled ref="app" method="execute5" cron="30 10 1 20 10 ?"/>
  20.         <!-- 每15秒、30秒、45秒时触发任务 -->
  21.         <task:scheduled ref="app" method="execute6" cron="15,30,45 * * * * ?"/>
  22.         <!-- 15秒到45秒每隔1秒触发任务 -->
  23.         <task:scheduled ref="app" method="execute7" cron="15-45 * * * * ?"/>
  24.         <!-- 每分钟的每15秒时任务任务，每隔5秒触发一次 -->
  25.         <task:scheduled ref="app" method="execute8" cron="15/5 * * * * ?"/>
  26.         <!-- 每分钟的15到30秒之间开始触发，每隔5秒触发一次 -->
  27.         <task:scheduled ref="app" method="execute9" cron="15-30/5 * * * * ?"/>
  28.         <!-- 每小时的0分0秒开始触发，每隔3分钟触发一次 -->
  29.         <task:scheduled ref="app" method="execute10" cron="0 0/3 * * * ?"/>
  30.         <!-- 星期一到星期五的10点15分0秒触发任务 -->
  31.         <task:scheduled ref="app" method="execute11" cron="0 15 10 ? * MON-FRI"/>
  32.     </task:scheduled-tasks>
  34. </beans>
  38.    1
  39.    2
  40.    3
  41.    4
  42.    5
  43.    6
  44.    7
  45.    8
  46.    9
  47.    10
  48.    11
  49.    12
  50.    13
  51.    14
  52.    15
  53.    16
  54.    17
  55.    18
  56.    19
  57.    20
  58.    21
  59.    22
  60.    23
  61.    24
  62.    25
  63.    26
  64.    27
  65.    28
  66.    29
  67.    30
  68.    31
  69.    32
  70.    33
  71.    34
  72.    35
  73.    36
  74.    37
  75.    38
  76.    39
  77.    40
  78.    41
  79.    42
  83.    1
  84.    2
  85.    3
  86.    4
  87.    5
  88.    6
  89.    7
  90.    8
  91.    9
  92.    10
  93.    11
  94.    12
  95.    13
  96.    14
  97.    15
  98.    16
  99.    17
  100.    18
  101.    19
  102.    20
  103.    21
  104.    22
  105.    23
  106.    24
  107.    25
  108.    26
  109.    27
  110.    28
  111.    29
  112.    30
  113.    31
  114.    32
  115.    33
  116.    34
  117.    35
  118.    36
  119.    37
  120.    38
  121.    39
  122.    40
  123.    41
  124.    42

编写测试代码：

  1. package com.rhwayfun.task;
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. /** * @author ZhongCB * @date 2016年09月10日 14:55 * @description */
  7. public class AppTest { 
  9.     public static void main(String[] args) {
  10.         ApplicationContext context = new ClassPathXmlApplicationContext("classpath:/app-context-task.xml");
  11.     }
  12. }
  15.    1
  16.    2
  17.    3
  18.    4
  19.    5
  20.    6
  21.    7
  22.    8
  23.    9
  24.    10
  25.    11
  26.    12
  27.    13
  28.    14
  29.    15
  30.    16
  34.    1
  35.    2
  36.    3
  37.    4
  38.    5
  39.    6
  40.    7
  41.    8
  42.    9
  43.    10
  44.    11
  45.    12
  46.    13
  47.    14
  48.    15
  49.    16

运行测试代码，控制台会定时输出每个定时任务的日志信息，说明测试通过。

发表评论

表情：
评论列表 （有 0 条评论，361人围观）

还没有评论，来说两句吧...

相关阅读