SpringBoot + Quartz定时任务示例

程序文件结构，如下图，后面详细列出各文件的代码：

1. maven的pom.xml文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>syb</groupId>
    <artifactId>quartzTest</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>quartzTest</name>
    <url>http://maven.apache.org</url>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.1.RELEASE</version>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. 启动类，注意添加了一个Listener，用于在Spring初始化完成后，执行一段我们自定义的逻辑。代码如下：

package syb.quartzTest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class App {
    public static void main(String[] args) {
        SpringApplication springApplication = new SpringApplication(App.class);
        // 添加了一个listener，用于在spring初始化完成后，执行一段我们自定义的逻辑
        springApplication.addListeners(new StartupListener());
        springApplication.run(args);
    }
}

3. StartupListener.java，在Spring初始化完成后，添加了一个定时任务：

package syb.quartzTest;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

public class StartupListener implements ApplicationListener<ContextRefreshedEvent> {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 初始化方法，添加了一个定时任务
     */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
            ApplicationContext ctx = event.getApplicationContext();

            // 添加一个定时任务
            QuartzUtil qu = ctx.getBean(QuartzUtil.class);
            JobKey jobKey = new JobKey("testJob");
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).build();
            Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")).build();
            qu.addJob(jobDetail, trigger);
        } catch (Exception e) {
            logger.error("", e);
        }
    }
}

4. QuartzUtil.java，定义了添加、删除定时任务的公用方法。

package syb.quartzTest;

import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Quartz定时任务工具类，包含添加定时任务、删除定时任务的操作。
 */
@Service
public class QuartzUtil {
    private Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 注入springboot自动配置的调度器
     */
    @Autowired
    private Scheduler scheduler;

    /**
     * 添加定时任务
     * @param job
     * @param trigger
     */
    public void addJob(JobDetail job, Trigger trigger) {
        try {
            if (scheduler.checkExists(job.getKey())) {
                scheduler.deleteJob(job.getKey());
            }
            scheduler.scheduleJob(job, trigger);
            logger.info("add job: " + job.getKey());
        } catch (Exception e) {
            logger.error("", e);
        }
    }

    /**
     * 删除定时任务
     * @param jobName
     */
    public void deleteJob(String jobName) {
        try {
            JobKey jobKey = new JobKey(jobName);
            if (scheduler.checkExists(jobKey)) {
                scheduler.deleteJob(jobKey);
            }
        } catch (Exception e) {
            logger.error("", e);
        }
    }
}

5. TestJob.java，一个供测试用的任务类。代码如下：

package syb.quartzTest;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 定时任务类，这里定义了一个定时任务
 */
public class TestJob implements Job {
    private Logger logger = LoggerFactory.getLogger(getClass());

    @Override
    public void execute(JobExecutionContext ctx) throws JobExecutionException {
        logger.info("*********************executing TestJob*********************");
    }

}

6. 配置文件application.properties，定义了一个数据源，并指定quartz存储任务的方式为使用数据库。如果不希望将定时任务的信息保存到数据库，则去掉spring.quartz.job-store-type=jdbc即可。

spring.datasource.type=com.zaxxer.hikari.HikariDataSource
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test_database
spring.datasource.username=root
spring.datasource.password=password
spring.datasource.hikari.minimum-idle=2
spring.datasource.hikari.maximum-pool-size=10

spring.quartz.job-store-type=jdbc

注意，如果要将quartz定时任务存储到数据库，需要在数据库中建表，具体建表语句，自己找，哇哈哈哈。。。