SpringBoot 整合定时任务 Quartz、SpringBoot 内置定时任务 Task 代码详解

概念介绍

• 什么是定时任务：
  定时任务是每个业务常见的需求，比如每分钟扫描超时支付的订单，每小时清理一次数据库历史数据，每天统计前一天的数据并生成报表，年度报表、统计报告等都可以用定时任务来实现。

• 流行的定时任务技术：
  1、quartz
  2、Spring Task

• 相关概念介绍：
  1、工作（Job）：用于定义具体执行的工作。
  2、工作明细（JobDetail）：用于描述定时工作相关的信息。
  3、触发器（Trigger）：用于描述触发工作的规则，通常使用 cron 表达式定义调度规则。
  4、调度器（Scheduler）：描述了工作明细与触发器的对应关系，简单说是执行频度。

- 通过 Java 来实现定时任务：

import java.util.Timer;
import java.util.TimerTask;

public class TestTimerTask {

    // 通过java的方式实现定时任务
    public static void main(String[] args) {
        Timer timer = new Timer();
        TimerTask timerTask = new TimerTask() {
            @Override
            public void run() {
                System.out.println("--------：定时任务执行了");
            }
        };
        // 2000ms执行一次run(), 延迟为0
        timer.schedule(timerTask, 0, 2000);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

SpringBoot 整合 Quartz

- 引入相关依赖：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
dependency>
<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <optional>trueoptional>
dependency>
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-testartifactId>
    <scope>testscope>
dependency>
<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-quartzartifactId>
dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

- 定义Job：MyQuartz.java

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class MyQuartz extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("SpringBoot 整合 Quartz 的任务执行了...");
    }
}
1
2
3
4
5
6
7
8
9
10

- 通过配置类的形式将工作明细和触发器注册为Bean：

import com.example.springboot.quartz.MyQuartz;
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {

    @Bean
    // 定义工作明细
    public JobDetail myJobDetail(){

        return JobBuilder
                .newJob(MyQuartz.class)
                .storeDurably()
                .build();
    }

    @Bean
    // 定义触发器
    public Trigger myJobTrigger(){
    	// 定义调度器 schedBuilder
        // cronSchedule()参数依次为：秒、分钟、小时、日、月、星期
        // 如下表示，任意月份的任意天的每小时每分钟的每20秒执行一次
        ScheduleBuilder schedBuilder = CronScheduleBuilder.cronSchedule("0/20 * * * * ?");
        
        return TriggerBuilder
                .newTrigger().
                forJob(myJobDetail())
                .withSchedule(schedBuilder)
                .build();
    }

}
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

- 执行效果：

SpringBoot 内置定时任务 Task

- 主启动类开启定时任务开关：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
// SpringBoot Task 开启定时任务开关
@EnableScheduling
public class SpringBootTaskApplication {

    public static void main(String[] args) {

        SpringApplication.run(SpringBootTaskApplication.class, args);

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

- 配置 yml：

spring:
  task:
    scheduling:
      # 任务调度线程池大小，默认为1
      pool:
        size: 1
      thread-name-prefix: test_
      shutdown:
        # 线程池关闭时等待所有任务完成
        await-termination: false
        # 调度线程关闭前最大等待时间，确保最后一定关闭
        await-termination-period: 10s
1
2
3
4
5
6
7
8
9
10
11
12

- 定义任务类：MyTask.java

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyTask {

	// 每月每日每小时每分钟每20秒执行一次
	// @Scheduled 用于设定具体的任务执行的频度
    @Scheduled(cron = "0/20 * * * * ?")
    public void testMyTask(){
        System.out.println("SpringBoot Task 定时任务执行了...");
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

- 执行结果：