目录
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";
}
}
感谢下面这位同学的总结: