SpringBoot依赖之Quartz Scheduler定时调度器使用MySQL存储Job_org.quartz.scheduler在springboot中使用,怎么设置存储到mysql数据库

接上一篇SpringBoot依赖之Quartz Scheduler定时调度器
。

本篇将在 Spring Boot 项目中，使用 Quartz Scheduler 结合 MySQL 数据库来存储 Job。

1. 创建 Spring Boot 项目

使用 IntelliJ IDEA 创建项目 这一步可以参考前一篇

SpringBoot依赖之Quartz Scheduler定时调度器

在 Dependencies 中选择以下内容：

• Spring Web
• Spring Data JPA
• MySQL Driver
• Quartz

配置 MySQL 数据库

在 application.properties 中配置你的 MySQL 数据库连接信息。

application.properties

spring.application.name=quartz-scheduler-mysql

spring.datasource.url=jdbc:mysql://localhost:3306/springboot-quartz?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
1
2
3
4
5
6
7
8
9

3. 配置 Quartz Scheduler

创建一个配置类来配置 Quartz，并指定使用数据库作为 Job 存储。

package com.dependencies.quartzschedulermysql.config;

import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
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 org.springframework.scheduling.quartz.SpringBeanJobFactory;

import javax.sql.DataSource;

/**
 * @author zhizhou   2024/8/7 23:20
 */
@Configuration
public class QuartzConfig {
    
    @Autowired
    private DataSource dataSource;
    
    @Bean
    public JobFactory jobFactory() {
        SpringBeanJobFactory jobFactory = new SpringBeanJobFactory() {
            @Override
            protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
                return super.createJobInstance(bundle);
            }
        };
        return jobFactory;
    }
    
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setDataSource(dataSource);
        schedulerFactoryBean.setJobFactory(jobFactory);
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        schedulerFactoryBean.setAutoStartup(true);
        return schedulerFactoryBean;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

4. 创建一个 Job 类

创建一个 Job 类来定义你的任务逻辑。

package com.dependencies.quartzschedulermysql.jobs;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @author zhizhou   2024/8/7 23:21
 */
@Component
public class SampleJob implements Job {
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Executing Job at " + LocalDateTime.now());
    }
    
  
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

5. 创建一个 Job Scheduler 类

创建一个类来调度你的 Job。

package com.dependencies.quartzschedulermysql.scheduler;

import com.dependencies.quartzschedulermysql.jobs.SampleJob;
import jakarta.annotation.PostConstruct;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author zhizhou   2024/8/7 23:23
 */
@Configuration
public class JobScheduler {
    
    @Autowired
    private Scheduler scheduler;
    
    @PostConstruct
    public void scheduleJob() throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(SampleJob.class)
                                      .withIdentity("sampleJob")
                                      .storeDurably()
                                      .build();
        
        Trigger trigger = TriggerBuilder.newTrigger()
                                  .withIdentity("sampleTrigger")
                                  .forJob(jobDetail)
                                  .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                                        .withIntervalInSeconds(10)
                                                        .repeatForever())
                                  .build();
        
        scheduler.scheduleJob(jobDetail, trigger);
    }
    
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

6. 初始化 Quartz 数据库表

Quartz Scheduler 需要一些表来存储 Job 和 Trigger 的信息。需要在 MySQL 数据库中创建这些表。Quartz 提供了 SQL 脚本来创建这些表。

7. 启动应用程序

现在，启动你的 Spring Boot 应用程序。Quartz Scheduler 将使用 MySQL 数据库存储 Job，并按照调度器的配置执行任务。

项目学习代码地址

通过这些步骤，我们就可以在 Spring Boot 项目中使用 Quartz Scheduler 和 MySQL 数据库来存储和调度 Job。核心目的是为了定时调度任务的可观测性，已操作性。后期再加上可视化操作界面，就可以很优雅的解决任务模糊、不好统计的痛点。

加油，程序员们！