QuartzManager分组版
package net.fjyl.market.quartz;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
/**
* @author caizw
* @date 2018-08-13
* @description: 定时任务
*/
public class QuartzManager {
private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();
/**
* @Description: 添加一个定时任务
*
* @param jobName 任务名
* @param jobGroupName 任务组名
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param jobClass 任务
* @param cron 时间设置，参考quartz说明文档
*/
@SuppressWarnings({ "unchecked", "rawtypes" })
public static void addJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName, Class jobClass, String cron) {
try {
Scheduler sched = schedulerFactory.getScheduler();
// 任务名，任务组，任务执行类
JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
// 创建Trigger对象
CronTrigger trigger = (CronTrigger) triggerBuilder.build();
// 调度容器设置JobDetail和Trigger
sched.scheduleJob(jobDetail, trigger);
// 启动
if (!sched.isShutdown()) {
sched.start();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 修改一个任务的触发时间
*
* @param jobName
* @param jobGroupName
* @param triggerName 触发器名
* @param triggerGroupName 触发器组名
* @param cron 时间设置，参考quartz说明文档
*/
public static void modifyJobTime(String jobName,
String jobGroupName, String triggerName, String triggerGroupName, String cron) {
try {
Scheduler sched = schedulerFactory.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
if (trigger == null) {
return;
}
String oldTime = trigger.getCronExpression();
if (!oldTime.equalsIgnoreCase(cron)) {
/** 方式一 ：调用 rescheduleJob 开始 */
// 触发器
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
// 触发器名,触发器组
triggerBuilder.withIdentity(triggerName, triggerGroupName);
triggerBuilder.startNow();
// 触发器时间设定
triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron));
// 创建Trigger对象
trigger = (CronTrigger) triggerBuilder.build();
// 方式一 ：修改一个任务的触发时间
sched.rescheduleJob(triggerKey, trigger);
/** 方式一 ：调用 rescheduleJob 结束 */
/** 方式二：先删除，然后在创建一个新的Job */
//JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
//Class<? extends Job> jobClass = jobDetail.getJobClass();
//removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
//addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
/** 方式二 ：先删除，然后在创建一个新的Job */
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description: 移除一个任务
*
* @param jobName
* @param jobGroupName
* @param triggerName
* @param triggerGroupName
*/
public static void removeJob(String jobName, String jobGroupName,
String triggerName, String triggerGroupName) {
try {
Scheduler sched = schedulerFactory.getScheduler();
TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
sched.pauseTrigger(triggerKey);// 停止触发器
sched.unscheduleJob(triggerKey);// 移除触发器
sched.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description:启动所有定时任务
*/
public static void startJobs() {
try {
Scheduler sched = schedulerFactory.getScheduler();
sched.start();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @Description:关闭所有定时任务
*/
public static void shutdownJobs() {
try {
Scheduler sched = schedulerFactory.getScheduler();
if (!sched.isShutdown()) {
sched.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
QuartzManager精简版
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Date;
/**
* @author caizw
* @date 2018-08-13
* @description: 定时任务
*/
public class QuartzManager {
private static Logger logger = LoggerFactory.getLogger(QuartzManager.class);
private static Scheduler scheduler;
static {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
try {
scheduler = schedulerFactory.getScheduler();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
private static void addJob(String jobKey, Class jobClass, String cron, Date date) throws SchedulerException {
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey).build();
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
Trigger trigger = null;
if (cron != null) {
trigger = TriggerBuilder.newTrigger().withIdentity(jobKey).withSchedule(scheduleBuilder).build();
} else if (date != null) {
trigger = TriggerBuilder.newTrigger().startAt(date).withIdentity(jobKey).build();
} else {
throw new RuntimeException("未指定定时任务何时启动");
}
scheduler.scheduleJob(jobDetail, trigger);
if (!scheduler.isShutdown()) {
scheduler.start();
}
}
/**
* @param jobKey 定时任务 key
* @param jobClass 定时执行的实例对象
* @param date 定时启动任务，传入时间实例对象
* @throws SchedulerException
*/
public static void addJobByDate(String jobKey, Class jobClass, Date date) throws SchedulerException {
logger.info("date启动定时任务");
addJob(jobKey, jobClass, null, date);
}
/**
* @param jobKey 定时任务 key
* @param jobClass 定时执行的实例对象
* @param cron quartz cron表达式
* @throws SchedulerException
*/
public static void addJobByCron(String jobKey, Class jobClass, String cron) throws SchedulerException {
logger.info("cron启动定时任务");
addJob(jobKey, jobClass, cron, null);
}
/**
* 删除定时任务
*
* @param jobKey
*/
public static void deleteJob(String jobKey) {
try {
scheduler.pauseTrigger(TriggerKey.triggerKey(jobKey));
scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey));
scheduler.deleteJob(JobKey.jobKey(jobKey));
} catch (Exception e) {
logger.info("删除定时任务失败");
}
}
/**
* @Description:关闭所有定时任务
*/
public static void shutdownJobs() {
logger.info("关闭所有定时任务");
try {
if (!scheduler.isShutdown()) {
scheduler.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
实践版本
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
/**
* @author caizw
* @date 2018-08-13
* @description: 定时任务
*/
@Slf4j
public class QuartzManager {
private static Scheduler scheduler;
public static void setScheduler(Scheduler schedule) {
QuartzManager.scheduler = schedule;
}
private static void addJob(String jobKey, Class jobClass, String cron, Date date, Integer interval, boolean nowStart) throws SchedulerException {
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey).build();
Trigger trigger;
if (StringUtils.isNotBlank(cron)) {
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
trigger = TriggerBuilder.newTrigger().withIdentity(jobKey).withSchedule(scheduleBuilder).build();
} else if (date != null) {
if (interval == null || interval == 0) {
// 只执行一次
Date nowTime = new Date();
if (date.getTime() <= nowTime.getTime()) {
trigger = TriggerBuilder.newTrigger().startNow().withIdentity(jobKey).build();
} else {
trigger = TriggerBuilder.newTrigger().startAt(date).withIdentity(jobKey).build();
}
} else {
Date nowTime = new Date();
if (date.getTime() <= nowTime.getTime() && nowStart) {
trigger = TriggerBuilder.newTrigger()
// 立即生效
.startNow()
.withIdentity(jobKey)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
// 间隔 interval 秒执行一次
.withIntervalInSeconds(interval)
.repeatForever()//永远重复执行
).build();
} else {
trigger = TriggerBuilder.newTrigger()
// 在指定日期生效
.startAt(date)
.withIdentity(jobKey)
.withSchedule(SimpleScheduleBuilder.simpleSchedule()
// 间隔 interval 秒执行一次
.withIntervalInSeconds(interval)
.repeatForever()//永远重复执行
).build();
}
}
} else {
throw new RuntimeException("未指定定时任务何时启动");
}
if (!scheduler.isShutdown()) {
scheduler.start();
}
scheduler.scheduleJob(jobDetail, trigger);
}
/**
* @param jobKey 定时任务 key
* @param jobClass 定时执行的实例对象，此对象需继承Job接口
* @param date 定时启动任务，传入时间实例对象
* @param nowStart 当前启动(条件满足后是否立即执行任务)
* @throws SchedulerException
*/
public static void addJobByDate(String jobKey, Class jobClass, Date date, boolean nowStart) throws SchedulerException {
log.info("date启动定时任务");
addJob(jobKey, jobClass, null, date, null, nowStart);
}
/**
* @param jobKey 定时任务 key
* @param jobClass 定时执行的实例对象，此对象需继承Job接口
* @param date 定时启动任务，传入时间实例对象
* @param interval 每间隔多少秒执行， 单位秒
* @param nowStart 当前启动(条件满足后是否立即执行任务)
* @throws SchedulerException
*/
public static void addJobByDate(String jobKey, Class jobClass, Date date, Integer interval, boolean nowStart) throws SchedulerException {
log.info("date启动间隔定时任务");
addJob(jobKey, jobClass, null, date, interval, nowStart);
}
/**
* @param jobKey 定时任务 key
* @param jobClass 定时执行的实例对象，此对象需继承Job接口
* @param cron quartz cron表达式
* @param nowStart 当前启动(条件满足后是否立即执行任务)
* @throws SchedulerException
*/
public static void addJobByCron(String jobKey, Class jobClass, String cron, boolean nowStart) throws SchedulerException {
log.info("cron启动定时任务");
addJob(jobKey, jobClass, cron, null, null, nowStart);
}
/**
* 获取所有任务key
*/
public static Set<JobKey> getJobKeySet() {
try {
return scheduler.getJobKeys(GroupMatcher.anyGroup());
} catch (Exception e) {
log.error("获取所有任务key失败：" + e.getMessage(), e);
}
return new HashSet<>();
}
/**
* 删除定时任务
*
* @param jobKey
*/
public static void deleteJob(String jobKey) {
log.info("删除定时任务, keyName ===>【{}】", jobKey);
if (StringUtils.isBlank(jobKey)) {
return;
}
try {
scheduler.pauseTrigger(TriggerKey.triggerKey(jobKey));
scheduler.unscheduleJob(TriggerKey.triggerKey(jobKey));
scheduler.interrupt(JobKey.jobKey(jobKey, null));
scheduler.deleteJob(JobKey.jobKey(jobKey));
} catch (Exception e) {
log.error("删除定时任务失败：" + e.getMessage(), e);
throw new RuntimeException(e);
}
}
/**
* 关闭所有定时任务
*/
public static void shutdownJobs() {
log.info("关闭所有定时任务");
try {
if (!scheduler.isShutdown()) {
scheduler.shutdown();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
定时器中注入Spring Bean问题
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;
/**
* @author caizw
* @date 2018-08-13
* @description: 定时器工厂
*/
@Component
public class MyJobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory capableBeanFactory;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
Object jobInstance = super.createJobInstance(bundle);
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
import org.quartz.Scheduler;
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;
/**
* @author caizw
* @date 2018-08-13
* @description: 配置定时器
*/
@Configuration
public class QuartzConfig {
@Autowired
private MyJobFactory myJobFactory;
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setJobFactory(myJobFactory);
return schedulerFactoryBean;
}
@Bean
public Scheduler scheduler() {
return schedulerFactoryBean().getScheduler();
}
}
使用 注入 Scheduler 代替 new
@Autowired
private Scheduler scheduler;
static {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
try {
scheduler = schedulerFactory.getScheduler();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
常用方法
获取全部真正执行的任务
public Set<JobKey> getJob() throws SchedulerException {
Set<JobKey> jobKeySet = scheduler.getJobKeys(GroupMatcher.anyGroup());
return jobKeySet;
}
浙公网安备 33010602011771号