Spring + Quartz 实现简单的定时任务

目录

 

1. 背景说明

2. 引入 maven 依赖

3. 调度器配置

4. Bean 配置

5. 任务监听器

6. 任务管理器

7. 自定义任务

8. 测试执行

---

1. 背景说明

目前实现定时任务的方式有很多种，每一种又都有各自的特点。

Spring + Quartz 的实现，是其中实现不算复杂，但是功能非常强大的一种。

本文简要记录所实现的一个简单框架，包含开始定时任务、删除定时任务、暂停/恢复定时任务、重设定时任务执行的Cron表达式等

一些基本的概念：

• SchedulerFactory：任务调度工厂

• Scheduler: 负责调度任务，如：开始/结束一个调度

• Job: 被执行的任务

• Trigger: 负责执行任务的触发器（这里我用的是CronTrigger可以用cron表达式去执行任务的触发器）如："0/5 * * * * ?" //每五秒执行一次，具体使用方法可以查阅一下官网。

• JobDetail: 封装Job，Scheduler真正调度的对象，包括Job名称，组等信息。

• JobListener: 任务执行的监听器，可以监听到任务执行前、后以及未能成功执行抛出异常。

2. 引入 maven 依赖

引入依赖如下：

        <!-- scheduler -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>4.1.6.RELEASE</version>
        </dependency>
        <!-- 该依赖里面有spring对schedule的支持 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

3. 调度器配置

配置文件名：quartz.properties，该文件位于 resources 下

#配置调度器的线程池类
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
#线程个数
org.quartz.threadPool.threadCount=10
#配置任务调度现场数据保存机制，默认保存在内存
org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore

4. Bean 配置

SpringBoot集成Quartz使用了工厂Bean生成Bean的方式。Bean 的配置主要是为了得到：schedulerFactoryBean

类名：SchedulerConfig

package com.amwalle.walle.scheduler;

import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

@Configuration
public class SchedulerConfig {
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setQuartzProperties(quartzProperties());

        return schedulerFactoryBean;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();

        return propertiesFactoryBean.getObject();
    }
}

5. 任务监听器

任务监听器能够监听任务执行的状态（执行前、执行后等）

类名：SchedulerListener

package com.amwalle.walle.scheduler;

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

public class SchedulerListener implements JobListener {
    private static final Logger logger = LoggerFactory.getLogger(SchedulerListener.class);

    private static final String LISTENER_NAME = "QuartSchedulerListener";

    @Override
    public String getName() {
        return LISTENER_NAME;
    }

    /**
     * 任务调度之前
     *
     * @param jobExecutionContext Job Execution Context
     */
    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
        String jobName = jobExecutionContext.getJobDetail().getKey().toString();
        logger.info("Job [" + jobName + "] is going to be executed >>>>>>>>>>");
    }

    /**
     * 任务调度被拒绝
     *
     * @param jobExecutionContext Job Execution Context
     */
    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
        String jobName = jobExecutionContext.getJobDetail().getKey().toString();
        logger.info("Job [" + jobName + "] execution is vetoed!");
    }

    /**
     * 任务调度之后
     *
     * @param jobExecutionContext Job Execution Context
     */
    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException exception) {
        String jobName = jobExecutionContext.getJobDetail().getKey().toString();
        logger.info("Job [" + jobName + "] execute finished! <<<<<<<<<<<<");
        if (null != exception) {
            logger.info("Exception thrown by [" + jobName + "]");
            logger.info("Exception message: " + (exception.getMessage().equals("") ? "" : exception.getMessage()));
        }
    }
}

6. 任务管理器

任务管理器用于管理任务的开始、结束、暂停/恢复和重设执行Cron表达式等

类名：WalleJobManager

package com.amwalle.walle.scheduler;

import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

@Component
public class WalleJobManager {
    private static final Logger logger = LoggerFactory.getLogger(WalleJobManager.class);

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    private JobListener scheduleListener;

    /**
     * 新建并开始一个定时任务
     *
     * @param cron     定时任务执行的时间表达式
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @param jobClass 任务定义的类
     * @throws SchedulerException  任务异常
     */
    public void startJob(String cron, String jobName, String jobGroup, Class<? extends Job> jobClass) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();

        if (null == scheduleListener) {
            scheduleListener = new SchedulerListener();
            scheduler.getListenerManager().addJobListener(scheduleListener);
        }

        JobKey jobKey = new JobKey(jobName, jobGroup);

        if (!scheduler.checkExists(jobKey)) {
            scheduleJob(cron, scheduler, jobName, jobGroup, jobClass);
        }
    }

    /**
     * 动态创建一个定时任务
     *
     * @param cron     定时任务执行的时间表达式
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @param jobClass 任务定义的类
     * @throws SchedulerException 任务执行异常
     */
    private void scheduleJob(String cron, Scheduler scheduler, String jobName, String jobGroup, Class<? extends Job> jobClass) throws SchedulerException {
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(scheduleBuilder).build();

        scheduler.scheduleJob(jobDetail, cronTrigger);
    }

    /**
     * 删除一个定时任务
     *
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @throws SchedulerException 任务异常
     */
    public void deleteJob(String jobName, String jobGroup) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = new JobKey(jobName, jobGroup);
        scheduler.deleteJob(jobKey);
        logger.info("Job [" + jobGroup + "." + jobName + "] was deleted!");
    }

    /**
     * 暂停一个定时任务
     *
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @throws SchedulerException 任务异常
     */
    public void pauseJob(String jobName, String jobGroup) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = new JobKey(jobName, jobGroup);
        scheduler.pauseJob(jobKey);
        logger.info("Job [" + jobGroup + "." + jobName + "] was paused!");
    }

    /**
     * 恢复一个定时任务
     *
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @throws SchedulerException 任务异常
     */
    public void resumeJob(String jobName, String jobGroup) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = new JobKey(jobName, jobGroup);
        scheduler.resumeJob(jobKey);
        logger.info("Job [" + jobGroup + "." + jobName + "] was resumed!");
    }

    /**
     * 手动出发一次定时任务
     *
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @throws SchedulerException 任务异常
     */
    public void triggerJob(String jobName, String jobGroup) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();
        JobKey jobKey = new JobKey(jobName, jobGroup);
        scheduler.triggerJob(jobKey);
        logger.info("Job [" + jobGroup + "." + jobName + "] was triggered!");
    }

    /**
     * 重新设定一个任务执行的时间表达式
     *
     * @param jobName  任务名
     * @param jobGroup 任务组
     * @throws SchedulerException 任务异常
     */
    public void resetJobCron(String jobName, String jobGroup, String cron) throws SchedulerException {
        Scheduler scheduler = schedulerFactoryBean.getScheduler();

        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(scheduleBuilder).build();
        scheduler.rescheduleJob(TriggerKey.triggerKey(jobName, jobGroup), cronTrigger);
        logger.info("Job [" + jobGroup + "." + jobName + "] was reset cron to: " + cron);
    }
}

7. 自定义任务

自定义任务要实现 Job 接口，Scheduler 可以调度自定义任务，执行自定义任务的 execute 方法

所以定时执行的逻辑就放在自定义任务中

类名：WalleJob

package com.amwalle.walle.scheduler;

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

public class WalleJob implements Job {

    private static final Logger logger = LoggerFactory.getLogger(WalleJob.class);

    @Override
    public void execute(JobExecutionContext context) {
        String jobGroup = context.getJobDetail().getKey().getGroup();
        String jobName = context.getJobDetail().getKey().getName();

        logger.info("Job [" + jobGroup + "." + jobName + "] execute started...");

        // TODO 这里是定时任务具体要做的事

        logger.info("Job [" + jobGroup + "." + jobName + "] execute End...");
    }
}

8. 测试执行

自定义一个 Controller，并在其中开始一个新的任务，然后启动项目，再访问 http://127.0.0.1:8080/walle

类名：HelloWorldController

package com.amwalle.walle.controller;

import com.amwalle.walle.scheduler.WalleJobManager;
import com.amwalle.walle.scheduler.WalleJob;
import org.quartz.SchedulerException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
@EnableAutoConfiguration
public class HelloWorldController {
    private static final Logger logger = LoggerFactory.getLogger(HelloWorldController.class);

    @Autowired
    private WalleJobManager jobManager;

    @RequestMapping(value = "/walle", method = RequestMethod.GET)
    public String helloWorld() {
        try {
            jobManager.startJob("0 0/1 * * * ?", "TestJob1", "TestJobGroup1", WalleJob.class);
            jobManager.resetJobCron("TestJob1","TestJobGroup1","0 0/2 * * * ?");
            jobManager.triggerJob("TestJob1","TestJobGroup1");
        } catch (SchedulerException e) {
            logger.error(e.getMessage());
        }

        return "hello world";
    }
}

 

感谢下面这位同学的总结：

https://www.jianshu.com/p/a99b80021be6