Spring Boot定时任务

定时任务是企业级开发中最常见的功能之一，如定时统计订单数、数据库备份、定时发送短信和邮件、定时统计博客访客等，简单的定时任务可以直接通过Spring中的@Scheduled注解来实现，复杂的定时任务则可以通过集成Quartz来实现，下面分别予以介绍。

1. @Scheduled

@Scheduled是由Spring提供的定时任务注解，使用方便，配置简单，可以解决工作中大部分的定时任务需求，使用方式如下:

1.1 创建工程

首先创建一个普通的Spring Boot Web工程，添加Web依赖即可，代码如下:

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

1.2 开启定时任务

在项目启动类上添加@EnableScheduling注解开启定时任务，代码如下:

@SpringBootApplication
@EnableScheduling
public class TestforeverApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestforeverApplication.class, args);
    }
}

1.3 配置定时任务

定时任务主要通过@Scheduled注解进行配置，代码如下:

@Component
public class MySchedule {
    // 当前任务执行结束1秒后开启另一个任务
    @Scheduled(fixedDelay = 1000)
    public void fixedDelay() {
        System.out.println("fixedDelay："+new Date());
    }

    // 当前任务开始执行2秒后开启另一个定时任务
    @Scheduled(fixedRate = 2000)
    public void fixedRate() {
        System.out.println("fixedRate："+new Date());
    }

    // 当前任务开始执行2秒后开启另一个定时任务，并且首次延迟1秒执行
    @Scheduled(initialDelay = 1000, fixedRate = 2000)
    public void initialDelay() {
        System.out.println("initialDelay："+new Date());
    }

    // 使用crom 表达式，下面表示定时任务每分钟执行一次
    @Scheduled(cron = "0 * * * * ?")
    public void cron() {
        System.out.println("cron："+new Date());
    }
}

代码解释:

• 通过@Scheduled注解来标注一个定时任务,其中fixedDelay= 1000表示在当前任务执行结束1秒后开启另一个任务，fixedRate= 2000表示在当前任务开始执行2秒后开启另一个定时任务，initialDelay= 1000则表示首次执行的延迟时间。
• 在@Scheduled注解中也可以使用cron表达式，cron=”0 * * * * ?”表示该定时任务每分钟执行一次

配置完成后，接下来启动Spring Boot项目即可，定时任务部分打印日志如图所示。

2. Quartz

2.1 Quartz简介

Quartz是一个功能丰富的开源作业调度库，它由Java写成，可以集成在任何Java应用程序中，包括Java SE和Java EE等。使用Quartz可以创建简单或者复杂的执行计划，它支持数据库、集群、插件以及邮件，并且支持cron表达式，具有极高的灵活性。Spring Boot中集成Quartz和Spring 中集成Quartz比较类似，主要提供三个Bean: JobDetail、 Trigger 以及SchedulerFactory。

2.2 整合Spring Boot

首先创建Spring Boot项目，添加Quartz依赖，代码如下:

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

2.3 创建Job

接着我们使用不同的方式创建两个 Job。

2.3.1 Bean方式

Job 可以是一个普通的 JavaBean。如果是普通的 JavaBean，那么可以先添加 @Component 注解将之注册到 Spring 容器中。

@Component
public class MyFirstJob {
    public void sayHello() {
        System.out.println("MyFirstJob:sayHello:" + new Date());
    }
}

2.3.1 抽象类 QuartzJobBean

Job 也可以继承抽象类 QuartzJobBean。若继承自 QuartzJobBean，则要实现该类中的 executeInternal 方法，该方法在任务被调用时使用。

public class MySecondJob extends QuartzJobBean {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) {
        System.out.println("hello:" + name + ":" + new Date());
    }
}

2.4 提供 Quartz 相关配置 Bean

接下来创建 QuartzConfig 对 JobDetail 和 Trigger 进行配置，并创建 SchedulerFactory。

JobDetail 的配置有两种方式：

• 第一种方式通过 MethodInvokingJobDetailFactoryBean 类配置 JobDetail，只需要指定 Job 的实例名和要调用的方法即可，注册这用方式无法在创建 JobDetail 时传递参数。
• 第二种方式通过 JobDetailFactoryBean 来实现，这种方式只需要指定 JobClass 即可，然后可以通过 JobDataMap 传递参数到 Job 中，Job 中只需要提供属性名，并且提供一个相应的 set 方法即可接收到参数。

Trigger 有多种不同的实现，这里展示两种常用的 Trigger：SimpleTrigger 和 CronTrigger。

• SimpleTrigger 使用 SimpleTriggerFactoryBean 进行创建。在 SimpleTriggerFactoryBean 对象中，首先设置 JobDetail，接着配置任务循环次数、任务启动延迟时间、任务的时间间隔。
• CronTrigger 使用 CronTriggerFactoryBean 进行创建。在 SimpleTriggerFactoryBean 对象中，则主要配置 JobDetail 和 Cron 表达式。

@Configuration
public class QuartzConfig {
    /********** 配置两个 JobDetail **********/
    // 通过 MethodInvokingJobDetailFactoryBean 类配置 JobDetail
    @Bean
    MethodInvokingJobDetailFactoryBean jobDetail1() {
        MethodInvokingJobDetailFactoryBean bean =
                new MethodInvokingJobDetailFactoryBean();
        bean.setTargetBeanName("myFirstJob");
        bean.setTargetMethod("sayHello");
        return bean;
    }

    // 通过 JobDetailFactoryBean 来实现 JobDetail
    @Bean
    JobDetailFactoryBean jobDetail2() {
        JobDetailFactoryBean bean = new JobDetailFactoryBean();
        bean.setJobClass(MySecondJob.class);
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("name","sang");
        bean.setJobDataMap(jobDataMap);
        bean.setDurability(true);
        return bean;
    }

    /********** 创建两个 Trigger **********/
    // 创建一个 SimpleTrigger
    @Bean
    SimpleTriggerFactoryBean simpleTrigger() {
        SimpleTriggerFactoryBean bean = new SimpleTriggerFactoryBean();
        bean.setJobDetail(jobDetail1().getObject()); // 设置 jobDetail
        bean.setRepeatCount(3); // 任务循环次数为3（总共会执行4次）
        bean.setStartDelay(2000); // 任务启动延迟2秒执行
        bean.setRepeatInterval(2000);  // 任务的时间间隔为2秒
        return bean;
    }

    // 创建一个 CronTrigger
    @Bean
    CronTriggerFactoryBean cronTrigger() {
        CronTriggerFactoryBean bean = new CronTriggerFactoryBean();
        bean.setJobDetail(jobDetail2().getObject()); // 设置 jobDetail
        bean.setCronExpression("* * * * * ?"); // 设置 Cron 表达式
        return bean;
    }

    /********** 创建 SchedulerFactory **********/
    @Bean
    SchedulerFactoryBean schedulerFactory() {
        // 通过 SchedulerFactoryBean 创建 SchedulerFactor
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        // 配置两个 Trigger
        SimpleTrigger simpleTrigger = simpleTrigger().getObject();
        CronTrigger cronTrigger = cronTrigger().getObject();
        bean.setTriggers(simpleTrigger,cronTrigger);
        return bean;
    }
}

经过这几步的配置，定时任务就配置成功了。接下来启动Spring Boot项目，控制台打印日志如图所示。

可以看到 MyFirstJob 在重复 3 次之后便不再执行（一共执行 4 次）,而 MySecondJob 则每秒执行 1 次，一直执行下去。