SpringBoot中使用spring-boot-starter-quartz实现定时任务

目录

• 前言
• 添加依赖
• 配置数据库
• 数据库操作
• Quartz 相关配置
• 总结

在实际开发中，我们经常需要实现定时任务。Spring Boot 提供了 spring-boot-starter-quartz 组件，可以方便地集成 Quartz 调度框架。本文将介绍如何在 Spring Boot 项目中使用 spring-boot-starter-quartz，并将 cron 表达式存储在数据库中，以便动态调整任务执行频率。

首先，在项目的 pom.xml 文件中添加以下依赖：

    org.springframework.boot
    spring-boot-starter-quartz


    org.mybatis.spring.boot
    mybatis-spring-boot-starter
    1.3.2


    mysql
    mysql-connector-java
    8.0.13
    runtime

在 application.properties 文件中配置数据库连接信息：

spring.datasource.url: jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&serverTimezOne=Asia/Shanghai&useSSL=false
spring.datasource.username: root
spring.datasource.password: root

1. 创建数据库 test 和表 cron

创建一个名为 test 的数据库，并在其中创建一个名为 cron 的表，用于存储 cron 表达式：

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- 创建表 cron
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron` (
  `id` int NOT NULL AUTO_INCREMENT,
  `cron` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB CHARACTER SET=utf8 COLLATE=utf8_general_ci ROW_FORMAT=Dynamic;

-- 插入初始数据
INSERT INTO `cron` VALUES (1, '0/5 * * * * ? *');

cron 表结构如下图所示：

2. 创建 cron 表对应的实体类

创建一个 Java 类 CronModel，对应 cron 表：

public class CronModel {
    private String cron;
    
    public String getCron() {
        return cron;
    }
    
    public void setCron(String cron) {
        this.cron = cron;
    }
}

3. 创建 Mapper

创建一个 MyBatis 的 Mapper 接口 CronModelMapper，用于查询 cron 表中的数据：

@Mapper
public interface CronModelMapper {
    @Select("select cron from cron where id = 1")
    String getCron();
}

4. 创建 Service

创建一个 Service 类 CronModelService，用于调用 Mapper 查询 cron 表中的数据：

@Service
public class CronModelService {
    @Autowired
    private CronModelMapper cronModelMapper;
    
    public String getCron() {
        return cronModelMapper.getCron();
    }
}

1. 创建 JobConfig 类

创建一个配置类 JobConfig，用于配置 Quartz 的 Job 和 Trigger：

@Configuration
public class JobConfig {
    @Autowired
    private CronModelService cronModelService;
    
    @Bean
    public JobDetail jobDetail() {
        return JobBuilder.newJob(Job.class)
                .withIdentity("jobDetail", "jobDetail")
                .storeDurably()
                .build();
    }
    
    @Bean
    public Trigger trigger() {
        return TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withIdentity("trigger", "trigger")
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(cronModelService.getCron()))
                .build();
    }
}

2. 创建 Job 类

创建一个 Job 类，实现 Quartz 的 QuartzJobBean 接口，用于执行具体的定时任务：

@Component
public class Job extends QuartzJobBean {
    private static final Logger logger = LoggerFactory.getLogger(Job.class);
    
    @Autowired
    private CronModelService cronModelService;
    
    @Autowired
    private Scheduler scheduler;
    
    @Override
    protected void executeInternal(JobExecutionContext context) {
        logger.info("执行定时任务");
        
        Trigger trigger = context.getTrigger();
        String cron = cronModelService.getCron();
        
        try {
            CronTrigger crOnTrigger= (CronTrigger) scheduler.getTrigger(trigger.getKey());
            String crOnExpression= cronTrigger.getCronExpression();
            
            if (!cron.equals(cronExpression)) {
                CronScheduleBuilder crOnSchedule= CronScheduleBuilder.cronSchedule(cron);
                crOnTrigger= cronTrigger.getTriggerBuilder()
                        .withIdentity(trigger.getKey())
                        .withSchedule(cronSchedule)
                        .build();
                scheduler.rescheduleJob(trigger.getKey(), cronTrigger);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

通过本文的介绍，我们可以看到，使用 spring-boot-starter-quartz 可以非常方便地在 Spring Boot 项目中实现定时任务。与传统的 Quartz 集成方式相比，spring-boot-starter-quartz 简化了配置过程，无需手动绑定 Job 和 Trigger，只需进行简单的配置即可实现定时任务的动态管理。