SpringBoot定时任务全解析：@Scheduled与Quartz集群方案

fanxbl957

1014人浏览 · 2025-04-10 13:38:23

fanxbl957 · 2025-04-10 13:38:23 发布

🎓博主介绍：Java、Python、js全栈开发 “多面手”，精通多种编程语言和技术，痴迷于人工智能领域。秉持着对技术的热爱与执着，持续探索创新，愿在此分享交流和学习，与大家共进步。
📖DeepSeek-行业融合之万象视界(附实战案例详解100+)
📖全栈开发环境搭建运行攻略：多语言一站式指南(环境搭建+运行+调试+发布+保姆级详解)
👉感兴趣的可以先收藏起来，希望帮助更多的人

SpringBoot定时任务全解析：@Scheduled与Quartz集群方案

一、引言

在现代的软件开发中，定时任务是一个非常常见的需求。例如，定时生成报表、定时清理缓存、定时同步数据等。Spring Boot 为开发者提供了便捷的定时任务实现方式，其中最常用的是 @Scheduled 注解和 Quartz 框架。本文将深入解析这两种方案，包括它们的基本使用、高级特性以及在集群环境下的应用。

二、@Scheduled 注解基础

2.1 开启定时任务支持

在 Spring Boot 项目中，要使用 @Scheduled 注解，首先需要在主应用类上添加 @EnableScheduling 注解来开启定时任务支持。示例代码如下：

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

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

2.2 基本使用

@Scheduled 注解可以用于方法上，让该方法按照指定的时间规则执行。常见的时间规则配置方式有以下几种：

2.2.1 fixedRate

fixedRate 表示任务执行的固定间隔时间，单位为毫秒。示例代码如下：

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

@Component
public class ScheduledTasks {
    @Scheduled(fixedRate = 5000) // 每 5 秒执行一次
    public void reportCurrentTime() {
        System.out.println("The time is now " + System.currentTimeMillis());
    }
}

2.2.2 fixedDelay

fixedDelay 表示任务执行完成后，下一次任务开始的延迟时间，单位为毫秒。示例代码如下：

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

@Component
public class ScheduledTasks {
    @Scheduled(fixedDelay = 3000) // 任务执行完成后，延迟 3 秒再执行下一次
    public void doSomething() {
        System.out.println("Doing something...");
    }
}

2.2.3 cron 表达式

cron 表达式是一种更灵活的时间规则配置方式，可以精确到秒。示例代码如下：

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

@Component
public class ScheduledTasks {
    @Scheduled(cron = "0 0 2 * * ?") // 每天凌晨 2 点执行
    public void runDailyTask() {
        System.out.println("Running daily task...");
    }
}

三、@Scheduled 注解高级特性

3.1 异步执行

默认情况下，@Scheduled 注解的任务是同步执行的，如果一个任务执行时间过长，会影响其他任务的执行。可以通过配置异步执行来解决这个问题。

3.1.1 开启异步支持

在主应用类上添加 @EnableAsync 注解来开启异步支持。示例代码如下：

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

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

3.1.2 配置异步执行

在需要异步执行的方法上添加 @Async 注解。示例代码如下：

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

@Component
public class ScheduledTasks {
    @Async
    @Scheduled(fixedRate = 5000)
    public void asyncTask() {
        System.out.println("Running async task...");
    }
}

3.2 动态配置

有时候，我们需要根据不同的环境或配置文件来动态调整定时任务的执行时间。可以通过读取配置文件的方式来实现动态配置。示例代码如下：

import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class ScheduledTasks {
    @Value("${task.fixedRate:5000}") // 默认每 5 秒执行一次
    private long fixedRate;

    @Scheduled(fixedRateString = "#{${task.fixedRate:5000}}")
    public void dynamicTask() {
        System.out.println("Running dynamic task with fixed rate: " + fixedRate);
    }
}

四、Quartz 框架基础

4.1 引入依赖

在 Spring Boot 项目中使用 Quartz 框架，需要在 pom.xml 中添加相应的依赖。示例代码如下：

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

4.2 基本使用

Quartz 框架的核心概念包括 Job、Trigger 和 Scheduler。Job 表示要执行的任务，Trigger 表示任务的触发条件，Scheduler 负责管理和调度任务。

4.2.1 定义 Job

创建一个实现 Job 接口的类，实现 execute 方法。示例代码如下：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Executing Quartz job...");
    }
}

4.2.2 配置 Job 和 Trigger

使用 JobDetail 和 Trigger 来配置任务和触发条件。示例代码如下：

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(MyJob.class)
                .withIdentity("myJob", "group1")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger myJobTrigger() {
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(5)
                .repeatForever();

        return TriggerBuilder.newTrigger()
                .forJob(myJobDetail())
                .withIdentity("myTrigger", "group1")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

五、Quartz 集群方案

5.1 集群原理

Quartz 集群是通过数据库来实现任务的分布式调度。多个节点共享同一个数据库，每个节点都可以从数据库中获取任务信息并执行。当一个节点执行任务时，会在数据库中标记该任务为已执行，其他节点就不会再执行该任务。

5.2 配置步骤

5.2.1 配置数据库

首先，需要创建一个数据库来存储 Quartz 的任务信息。Quartz 提供了不同数据库的建表脚本，可以在官方文档中找到。以 MySQL 为例，创建数据库和表的 SQL 脚本如下：

CREATE DATABASE quartz;

USE quartz;

-- 创建 Quartz 表
-- ... 这里省略具体的建表 SQL 语句，可以从官方文档中获取

5.2.2 配置 Spring Boot 项目

在 application.properties 中配置数据库连接信息和 Quartz 集群相关信息。示例代码如下：

spring.datasource.url=jdbc:mysql://localhost:3306/quartz
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=20000

5.2.3 配置 SchedulerFactoryBean

在配置类中配置 SchedulerFactoryBean，并设置数据源和集群相关属性。示例代码如下：

import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;

@Configuration
public class QuartzClusterConfig {
    @Autowired
    private DataSource dataSource;

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setDataSource(dataSource);
        schedulerFactoryBean.setQuartzProperties(quartzProperties());
        return schedulerFactoryBean;
    }

    @Bean
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }

    private Properties quartzProperties() {
        Properties properties = new Properties();
        properties.setProperty("org.quartz.jobStore.isClustered", "true");
        properties.setProperty("org.quartz.jobStore.clusterCheckinInterval", "20000");
        return properties;
    }
}