Spring boot整合SpringTask实现定时任务

发表于 | 分类于 |

SpringTask是Spring自主研发的一个定时任务工具，不需要引入其他依赖就可以使用。

SpringTask Cron语法

类似于shell中的crontab，只不过最前面多了一个Seconds秒级别。
Seconds Minutes Hours DayofMonth Month DayofWeek

时间元素 可出现的字符 数值范围
Seconds ,-*/ 0-59
Minutes ,-*/ 0-59
Hours ,-*/ 0-23
Day of Month ,-*/?LW 0-31
Month ,-*/ 1-12
Day of Week ,-*/?L# 1-7
  • “,” 列出枚举值
  • “-“ 触发范围
  • “*” 任意值
  • “/“ 每隔一段时间执行
  • “?” 任意值
  • “#” 确定第几个星期几
  • “L” 表示最后的有效值
  • “W” 表示有效工作日

    整合使用SpringTask

    因为SpringTask已经存在于Spring框架中，所有不需要引入任何依赖。
    只需要在配置类中添加一个@EnableScheduling注解就可以开启SpringTask的定时任务功能。
    然后可以通过在方法上增加@Scheduled注解配置定时任务。或者通过代码动态创建定时任务。

通过spring boot注解实现

在Spring boot的主类或者配置类中加入@EnableScheduling注解，启动定时任务的配置。

1
2
3
4
5
6
7
8
9
@SpringBootApplication
@EnableScheduling
public class SpringbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootApplication.class, args);
    }

}

创建定时任务实现类

1
2
3
4
5
6
7
8
@Component
public class SpringTaskDemo {

    @Scheduled(cron = "0/1 * * * * ?")
    public void printHello(){
        System.out.println("scheduled is running.........");
    }
}

动态创建定时任务

使用注解的方式，无法实现动态的修改、添加、关闭定时任务。这个时候就需要使用编程的方式进行任务的更新操作了。可以使用ThreadPoolTaskScheduler或SchedulingConfigurer接口来创建自定义定时任务。

SchedulingConfigurer
通过实现SchedulingConfigurer接口，重写configureTasks方法添加定时任务。

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
33
@Configuration
public class ScheduleConfig implements SchedulingConfigurer {
 
	@Override
	public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		taskRegistrar.setTaskScheduler(taskScheduler());
		
		taskRegistrar.getScheduler().schedule(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + "|SchedulingConfigurer cron task01");
			}
		}, new CronTrigger("0/3 * * * * ?"));
		
		taskRegistrar.addCronTask(new CronTask(new Runnable() {
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + "|SchedulingConfigurer cron task02");
			}
		}, new CronTrigger("0/2 * * * * ?")));
	}
 
	@Bean
	public TaskScheduler taskScheduler() {
		ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
		taskScheduler.setPoolSize(10);
		taskScheduler.setThreadNamePrefix("spring-task-scheduler-thread-");
		taskScheduler.setAwaitTerminationSeconds(60);
		taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
		taskScheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());
		return taskScheduler;
	}
 }

ThreadPoolTaskScheduler是Spring Task的核心实现类，该类提供了大量的重载方法进行任务调度。首先配置一个自定义任务调度线程池ThreadPoolTaskScheduler，然后调用schedule等方法对定时任务进行动态管理操作。

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
@RestController
@RequestMapping("/task")
public class SpringTaskDemo{

    @Resource
    private ThreadPoolTaskScheduler taskScheduler;

    private ScheduledFuture<?> scheduledFuture;

    @Value("${timing-task.cron1}")
    private String cronStr1;

    @Value("${timing-task.cron2}")
    private String cronStr2;

    @RequestMapping("/start")
    public String startTask() {
        scheduledFuture = taskScheduler.schedule(new RunTask01(), new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                return new CronTrigger(cronStr1).nextExecutionTime(triggerContext);
            }
        });
        log.info("start timed task success ..");
        return "start task suceess";
    }

    @RequestMapping("/stop")
    public String stopTask() {
        Boolean result = null;
        if (scheduledFuture != null) {
            result = scheduledFuture.cancel(true);
        }
        log.info("stop timed task result: " + result);
        return "stop task result: " + result;
    }

    @RequestMapping("/modify")
    public String modifyTask() {
        Boolean stopResult = null;
        // 停止定时任务
        if (scheduledFuture != null) {
            stopResult = scheduledFuture.cancel(true);
        } else {
            log.info("modify task error -> scheduledFuture is null");
            return "error";
        }
        // 更换cron重新开启定时任务
        if (stopResult) {
            scheduledFuture = taskScheduler.schedule(new RunTask01(), new Trigger() {
                @Override
                public Date nextExecutionTime(TriggerContext triggerContext) {
                    return new CronTrigger(cronStr2).nextExecutionTime(triggerContext);
                }
            });
            log.info("modify task success ..");
            return "success";
        }
        log.info("modify task failed ..");
        return "failed";
    }

    class RunTask01 implements Runnable {

        @Override
        public void run() {
            log.info(Thread.currentThread().getName() + "|schedule task01" + "|" + new Date().toLocaleString());
        }
    }

    class RunTask02 implements Runnable {
        @Override
        public void run() {
            log.info(Thread.currentThread().getName() + "|schedule task02" + "|" + new Date().toLocaleString());
        }
    }
}