SpringBoot集成quartz实现定时任务详解

SpringBoot集成Quartz实现定时任务详解

1. 什么是Quartz

Quartz是一个开源的作业调度框架，其主要用于定时调度任务。它能够完成复杂的调度需求，如在指定时间执行任务、每天执行任务、周末执行任务等。

2. SpringBoot集成Quartz

2.1 引入依赖

我们首先需要在pom.xml文件中引入quartz和spring-boot-starter-quartz依赖。

<!-- quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

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

2.2 编写定时任务类

我们需要自定义一个定时任务类，这个类需要实现org.quartz.Job接口，同时需要重写execute方法。

例如，我们自定义一个定时任务类MyTask，代码如下：

public class MyTask implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("执行定时任务：" + new Date());
    }
}

2.3 配置任务触发器

在使用Quartz实现定时任务时，我们通常需要配置任务触发器，才能实现定时执行任务的效果。

我们可以在配置文件中配置一个默认的触发器，也可以在代码中自定义触发器。

例如，我们在代码中自定义一个触发器，执行一次任务后间隔5秒钟再继续执行下一次任务：

@Bean
public JobDetail myTaskDetails() {
    return JobBuilder.newJob(MyTask.class).withIdentity("myTask").storeDurably().build();
}

@Bean
public Trigger myTaskTrigger() {
    SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
            .withIntervalInSeconds(5)
            .repeatForever();
    return TriggerBuilder.newTrigger().forJob(myTaskDetails())
            .withIdentity("myTaskTrigger")
            .withSchedule(scheduleBuilder)
            .build();
}

2.4 启动调度器

最后，我们需要在SpringBoot启动类中添加一个启动Quartz调度器的方法。

例如：

@SpringBootApplication
public class DemoApplication {

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

    @Bean
    public SchedulerFactoryBean quartzScheduler() {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        factoryBean.setJobDetails(myTaskDetails());
        factoryBean.setTriggers(myTaskTrigger());
        return factoryBean;
    }
}

3. 示例

下面我们来演示两个使用SpringBoot集成Quartz实现定时任务的例子。

3.1 示例1：每分钟执行一次任务

我们定义一个MyTask类，每次执行任务后让线程休眠10秒钟。

public class MyTask implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("执行定时任务：" + new Date());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

我们将每分钟执行一次任务，并让任务在执行前先延迟5秒钟。

@Bean
public JobDetail myTaskDetails() {
    return JobBuilder.newJob(MyTask.class).withIdentity("myTask").storeDurably().build();
}

@Bean
public Trigger myTaskTrigger() {
    SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
            .withIntervalInMinutes(1)
            .repeatForever()
            .withMisfireHandlingInstructionNextWithRemainingCount();
    return TriggerBuilder.newTrigger().forJob(myTaskDetails())
            .withIdentity("myTaskTrigger")
            .startAt(DateBuilder.futureDate(5, DateBuilder.IntervalUnit.SECOND))
            .withSchedule(scheduleBuilder)
            .build();
}

3.2 示例2：每天凌晨执行一次任务

我们定义一个MyTask类，每次执行任务后打印当前日期。

public class MyTask implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("执行定时任务：" + new Date());
    }
}

我们将每天凌晨执行一次任务，并让任务在执行前先延迟10秒钟。

@Bean
public JobDetail myTaskDetails() {
    return JobBuilder.newJob(MyTask.class).withIdentity("myTask").storeDurably().build();
}

@Bean
public Trigger myTaskTrigger() {
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0 0 0 * * ?");
    return TriggerBuilder.newTrigger().forJob(myTaskDetails())
            .withIdentity("myTaskTrigger")
            .startAt(DateBuilder.futureDate(10, DateBuilder.IntervalUnit.SECOND))
            .withSchedule(scheduleBuilder)
            .build();
}