SpringBoot中实现定时任务(Quartz)

一、使用Spring Task

Spring 3.0以后自带了 task 调度工具，使用比 Quartz简单方便，使用 @Scheduled 注解。

1、创建一个 SpringBoot项目，引入spring-boot-starter-web依赖。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

1. 在启动类上添加 @EnableScheduling 注解，表示开启定时任务。

@SpringBootApplication
@EnableScheduling
public class QuartzApplication {

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

}

2. 了解 @Scheduled 注解

在方法上使用 @Scheduled 注解表示开启一个定时任务：下面参数单位都是毫秒

• fixedRate：表示按一定频率来执行定时任务，具体是指两次任务的开始时间间隔，即第二次任务开始时，第一次任务可能还没结束。
• fixedDelay：表示按一定时间间隔来执行定时任务，具体是指本次任务结束到下次任务开始之间的时间间隔。该属性还可以配合initialDelay使用， 定义该任务延迟执行时间。
• initialDelay：表示首次任务启动的延迟时间。与fixedDelay配合使用。
• cron：通过 cron 表达式来配置任务执行时间，cron 表达式格式为：[秒] [分] [小时] [日] [月] [周] [年]

2、单线程执行任务

使用同一个线程中串行执行，如果只有一个定时任务，这样做肯定没问题，当定时任务增多，如果一个任务卡死，会导致其他任务也无法执行。

1. 创建一个类，配置定时任务

@Component
public class Task1 {

    @Scheduled(fixedRate = 2000)
    public void fixedRateTask() {
        System.out.println("fixedRateTask定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }

    @Scheduled(fixedDelay = 2000)
    public void fixedDelayTask1() {
        System.out.println("fixedDelayTask1111定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }

    @Scheduled(initialDelay = 2000,fixedDelay = 2000)
    public void initialDelayTask2() throws InterruptedException {
        System.out.println("initialDelayTask2222定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        TimeUnit.SECONDS.sleep(15);
    }

    @Scheduled(cron = "0/5 * * * * ?")
    public void cron() {
        System.out.println("cron定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }
}

2. 启动项目，定时任务就开始工作了

• 可以看到使用的是同一个线程，并出现了任务阻塞的情况。

3、多线程执行任务

Spring Task 默认是单线程的，想要改成多线程，

给Spring Task提供一个多线程的TaskScheduler，Spring已经有默认实现。

1. 方式一

创建配置类，@EnableAsync注解：表示开启异步事件的支持

@Configuration
@EnableAsync // 开启异步事件的支持
public class AsyncTaskConfig {

    private int corePoolSize = 10;
    private int maxPoolSize = 200;
    private int queueCapacity = 10;
    @Bean
    public Executor taskExecutor() {
        // 线程池
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(corePoolSize);
        executor.setMaxPoolSize(maxPoolSize);
        executor.setQueueCapacity(queueCapacity);
        executor.initialize();
        return executor;
    }
}

在定时任务的类或者方法上添加 @Async 注解。最后重启项目，每一个任务都是在不同的线程中

2. 方式二

创建配置类

@Configuration
@EnableAsync // 开启异步事件的支持
public class ScheduleConfig {
    @Bean("taskScheduler1")
    public TaskScheduler taskScheduler1(){
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10);
        scheduler.setThreadNamePrefix("spring-task1-thread");
        return scheduler;
    }

    @Bean
    public TaskScheduler taskScheduler2(){
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10);
        scheduler.setThreadNamePrefix("spring-task2-thread");
        return scheduler;
    }
}

在定时任务的类或者方法上添加 @Async 注解。最后重启项目。

@Component
public class TestTask2 {

    @Async("taskScheduler1")
    @Scheduled(cron = "0/1 * * * * ?")
    public void execute1() {
        System.out.println("execute1定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }

    @Async("taskScheduler2")
    @Scheduled(cron = "0/1 * * * * ?")
    public void execute2() throws InterruptedException {
        System.out.println("execute2定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }
    @Async("taskScheduler2")
    @Scheduled(cron = "0/1 * * * * ?")
    public void execute3() throws InterruptedException {
        System.out.println("execute3定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }

    @Scheduled(cron = "0/2 * * * * ?")
    public void execute4() throws InterruptedException {
        System.out.println("execute4定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());

    }

    @Scheduled(cron = "0/3 * * * * ?")
    public void execute5() throws InterruptedException {
        System.out.println("execute5定时任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
        TimeUnit.SECONDS.sleep(15);
    }
}

任务使用同上，线程池有区别。

二、使用第三方框架 Quartz

使用 @Scheduled 注解来解决简单的定时任务，大部分项目中可能都是使用 Quartz 来做定时任务。

Quartz是一个开源项目，专注于任务调度器，功能强大，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。

• 持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。
• 集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端（节点）时，

采用Quartz的集群和分布式处理时，简单了解几点 

• 1）一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
• 2）Quartz调度是通过触发器的类别来识别不同的任务，在不同的节点定义相同的触发器的类别，这样在集群下能稳定的运行，一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。
• 3）分布式 体现在 当相同的任务定时在一个时间点，在那个时间点，不会被两个节点同时执行。

1、添加 Quartz 依赖

在 上面的 SpringBoot项目（把@Scheduled相关的注释掉）中使用 Quartz ，添加 Quartz 依赖。

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

在启动类上添加 @EnableScheduling 注解，表示开启定时任务。

@SpringBootApplication
@EnableScheduling
public class QuartzApplication {

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

}

2、Quartz的使用

Quartz 在使用过程中，有两个关键概念，

• 一个是 JobDetail（要做的事情），要定义 JobDetail，需要先自定义Job
• 一个是 Trigger触发器（什么时候做）

1. 定义 Job

@Service
public class UserService {

    public String get(Long id){
        return "UserService get data:" + id;
    }
}

Job 的定义有两种方式：

• 直接定义一个Bean，不支持传参。
• 定义一个Bean继承 QuartzJobBean类，并实现默认的方法，支持传参，任务启动时，executeInternal 方法将会被执行。
   

@Component
public class MyJob1 {

    public void myTask1() {
        System.out.println("MyJob1 myTask1任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }
}

@Component
public class MyJob2 extends QuartzJobBean {
//    @Autowired  这里注入方式是不行的，报NPE
    private UserService userService;

    private Long id;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        // 处理相应的注入service业务
        String data = userService.get(id);
        System.out.println(data);
        System.out.println("MyJob2 任务开始 : " + LocalDateTime.now().toLocalTime() + "，线程：" + Thread.currentThread().getName());
    }

    public UserService getUserService() {
        return userService;
    }

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }
}

2. 创建配置类，配置 JobDetail， Trigger 触发器

配置简单说明一下：

JobDetail 的配置有两种方式：

• MethodInvokingJobDetailFactoryBean：可以配置目标 Bean 的名字和目标方法的名字，这种方式不支持传参。
• JobDetailFactoryBean：任务类继承自 QuartzJobBean ，这种方式支持传参，将参数封装在 JobDataMap 中进行传递。

Quartz 中定义了多个 Trigger触发器，，这里使用下 SimpleTrigger 和 CronTrigger 。

• SimpleTrigger触发器： 有点类似于上面的 @Scheduled 的基本用法。
• CronTrigger触发器：支持 cron 表达式来配置任务执行时间

@Configuration
public class QuartzConfig {
    // MyJob2 需要 userService， 这两个都可以注入
//    @Bean
//    UserService userService() {
//        return new UserService();
//    }
    @Autowired
    private UserService userService;

    // MyJob1任务配置
    @Bean
    MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean() {
        MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean();
        bean.setTargetBeanName("myJob1"); // 首字母小写
        bean.setTargetMethod("myTask1");
        return bean;
    }

    @Bean
    SimpleTriggerFactoryBean simpleTriggerFactoryBean() {
        SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
        bean.setStartTime(new Date());
        bean.setRepeatCount(5);
        bean.setRepeatInterval(2000);
        bean.setJobDetail(methodInvokingJobDetailFactoryBean().getObject());
        return bean;
    }

    // MyJob2任务配置
    // 传参
    @Bean
    JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean bean = new JobDetailFactoryBean();
        bean.setJobClass(MyJob2.class);
        JobDataMap map = new JobDataMap();
        map.put("userService", userService);
        map.put("id", 101);
        bean.setJobDataMap(map);
        return bean;
    }

    @Bean
    CronTriggerFactoryBean cronTriggerFactoryBean() {
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        bean.setCronExpression("0/5 * * * * ?");
        bean.setJobDetail(jobDetailFactoryBean().getObject());
        return bean;
    }

    // 添加 MyJob1和MyJob2的触发器
    @Bean
    SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        bean.setTriggers(cronTriggerFactoryBean().getObject(), simpleTriggerFactoryBean().getObject());
        return bean;
    }

}

3. 启动项目，每一个任务都是在不同的线程中执行了。

   

三、cron表达式

cron 表达式格式为：[秒] [分] [小时] [日] [月] [周] [年]

一个cron表达式有至少6个（也可能7个）有空格分隔的时间元素。顺序和具体取值依次为：

序号	说明	是否必填	允许填写的值	允许的通配符
1	秒	是	0-59	- * /
2	分	是	0-59	- * /
3	时	是	0-23	- * /
4	日	是	1-31	- * ? / L W
5	月	是	1-12 or JAN-DEC	- * /
6	周	是	1-7 or SUN-SAT	- * ? / L #
7	年	否	1970-2099	- * /

注意：由于”月份中的日期”和”星期中的日期”这两个元素互斥的，必须要对其中一个设置，因此在配置时这两个得有一个是 ?。

其中每个元素可以是一个值（5），一个连续区间（14-18），一个间隔时间（8-18/4）(/表示每隔4小时)，一个列表（1,3,5），通配符（*）。

通配符含义：

? 表示不指定值，即不关心某个字段的取值时使用。需要注意的是，月份中的日期和星期可能会起冲突，因此在配置时这两个得有一个是 ?

* 表示所有值，例如:在秒的字段上设置 *,表示每一秒都会触发

, 用来分开多个值，例如在周字段上设置 “MON,WED,FRI” 表示周一，周三和周五触发

- 表示区间，例如在秒上设置 “10-12”,表示 10,11,12秒都会触发

/ 用于递增触发，如在秒上面设置”5/15” 表示从5秒开始，每增15秒触发(5,20,35,50)

# 序号(表示每月的第几个周几)，例如在周字段上设置”6#3”表示在每月的第三个周六，(用 在母亲节和父亲节再合适不过了)

周字段的设置，若使用英文字母是不区分大小写的 ，即 MON 与mon相同

L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会自动判断是否是润年), 在周字段上表示星期六，相当于”7”或”SAT”（注意周日算是第一天）。如果在”L”前加上数字，则表示该数据的最后一个。例如在周字段上设置”6L”这样的格式,则表示”本月最后一个星期五”

W 表示离指定日期的最近工作日(周一至周五)，例如在日字段上设置”15W”，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发，如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，”W”前只能设置具体的数字,不允许区间”-“)

L 和 W 可以一组合使用。如果在日字段上设置”LW”,则表示在本月的最后一个工作日触发(一般指发工资 )

这里列举几个：

    "0/10 * * * * ?" 每10秒触发 

    "0 0/3 * * * ?" 每隔1分钟执行一次 

    "0 0 08 * * ?" 每天上午8点触发
 
    "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 2009-2019" 2009年至2019年的每月的最后一个星期五上午10:15触发
 
    "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 

XXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。

分布式任务调度平台XXL-JOB，在项目中也有使用。网址：https://www.xuxueli.com/xxl-job/ ，参考：XXL-JOB快速入门

具体时间设定可以参考文章：

• Cron定时器表达式生成工具：http://www.jsons.cn/quartzcron/
• cron表达式：https://blog.csdn.net/k_scott/article/details/8508290

—— Stay Hungry. Stay Foolish. 求知若饥，虚心若愚。