SpringBoot 整合 Quartz 实现 JAVA 定时任务的动态配置
什么是动态配置定时任务？
首先说下此次主题，动态配置。没接触过定时任务的同窗能够先看下此篇：JAVA定时任务实现的几种方式spring
定时任务实现方式千人千种，不过基础的无外乎 一、JDK 的Timer类 二、Quartz 三、SpringTask 。生产上三种方式我都有使用过。可是使用过程当中用的最多的即是xml配置的方式，这种方式最简单，无代码侵入，也比较好理解。数据库
可是却有个致命的缺点，好比你要改某个任务的触发时间，亦或是你要新增一个任务，暂停一个任务。怎么作？express
停应用！改XML配置！从新启动！api
是否是很致命。最近从新研究了下Quartz的配置，实现了不停机添加、暂停、删除、当即触发任务的方法，在本篇分享出来，其实也不算是彻底的研究，在上家公司已经有大佬实现了，此次是也是基于大佬的理解从新实现下。springboot
国际惯例~先看效果图
管理界面：并发
效果图：实在不知道该跑什么了，每隔十秒打一段话吧。app
技术实现
maven依赖框架
使用springboot作框架支持。maven
<!-- quartz -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
数据表。ide
CREATE TABLE `sys_task` (
`id` bigint(20) NOT NULL AUTO_INCREMENT,
`job_name` varchar(255) DEFAULT NULL COMMENT '任务名',
`description` varchar(255) DEFAULT NULL COMMENT '任务描述',
`cron_expression` varchar(255) DEFAULT NULL COMMENT 'cron表达式',
`bean_class` varchar(255) DEFAULT NULL COMMENT '任务执行时调用哪一个类的方法 包名+类名',
`job_status` varchar(255) DEFAULT NULL COMMENT '任务状态',
`job_group` varchar(255) DEFAULT NULL COMMENT '任务分组',
`create_user` varchar(64) DEFAULT NULL COMMENT '建立者',
`create_time` datetime DEFAULT NULL COMMENT '建立时间',
`update_user` varchar(64) DEFAULT NULL COMMENT '更新者',
`update_time` datetime DEFAULT NULL COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=MyISAM AUTO_INCREMENT=32 DEFAULT CHARSET=utf8;
实现步骤。
- 启动项目，启动task监听
- 读取数据库，将开启的任务job和trigger加载到scheduler调度器
- 根据任务调度运行job类
- 每次运行利用AdaptableJobFactory实例化job类，以便注入要运行的service
听着是否是很简单，但却仍是一头雾水，且听我慢慢道来~~
代码逻辑。
第一步：启动项目，加载监听。
Quartz配置
Springboot的配置方法，常规Spring项目能够在xml中配置
@Configuration
public class QuartzConfigration {
@Autowired
private JobFactory jobFactory;
@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
try {
schedulerFactoryBean.setOverwriteExistingJobs(true);
schedulerFactoryBean.setQuartzProperties(quartzProperties());
schedulerFactoryBean.setJobFactory(jobFactory);
} catch (Exception e) {
e.printStackTrace();
}
return schedulerFactoryBean;
}
// 指定quartz.properties，可在配置文件中配置相关属性
@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/config/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
}
// 建立schedule
@Bean(name = "scheduler")
public Scheduler scheduler() {
return schedulerFactoryBean().getScheduler();
}
}
监听器。
@Component
@Order(value = 1)
public class ScheduleJobInitListener implements CommandLineRunner {
@Autowired
TaskService scheduleJobService;
@Override
public void run(String... arg0) throws Exception {
try {
scheduleJobService.initSchedule();
} catch (Exception e) {
e.printStackTrace();
}
}
}
CommandLineRunner相似Spring框架的ApplicationListener监听器。官方的解释是:
❝Interface used to indicate that a bean should run when it is contained within a SpringApplication. Multiple CommandLineRunner beans can be defined within the same application context and can be ordered using the Ordered interface or Order @Order annotation.接口被用做将其加入spring容器中时执行其run方法。多个CommandLineRunner能够被同时执行在同一个spring上下文中而且执行顺序是以order注解的参数顺序一致。
❞
第二步：读取数据库，加载scheduler调度器。
job方法。
@Override
public void initSchedule() throws SchedulerException {
// 这里获取任务信息数据
List<TaskDO> jobList = taskMapper.list();
for (TaskDO task : jobList) {
if (JobStatusEnum.RUNNING.getCode().equals(task.getJobStatus())) {
quartzManager.addJob(task);
}
}
}
添加任务到Quartz调度器。
/**
* 添加任务/
@SuppressWarnings("unchecked")
public void addJob(TaskDO task) {
try {
// 建立jobDetail实例，绑定Job实现类
// 指明job的名称，所在组的名称，以及绑定job类
Class<? extends Job> jobClass = (Class<? extends Job>) (Class.forName(task.getBeanClass()).newInstance()
.getClass());
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(task.getJobName(), task.getJobGroup())// 任务名称和组构成任务key
.build();
// 定义调度触发规则
// 使用cornTrigger规则
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(task.getJobName(), task.getJobGroup())// 触发器key
.startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
.withSchedule(CronScheduleBuilder.cronSchedule(task.getCronExpression())).startNow().build();
// 把做业和触发器注册到任务调度中
scheduler.scheduleJob(jobDetail, trigger);
// 启动
if (!scheduler.isShutdown()) {
scheduler.start();
}
} catch (Exception e) {
e.printStackTrace();
}
}
Scheduler做为Quartz的核心调度器，有将近50多个API接口，包括任务的添加，暂停，恢复，删除等一系列的API，这里仅介绍一些经常使用的，想要了解更多能够稍后看下彩蛋部分。
- start()方法：只有调用start()方法后，Scheduler线程才开始启动触发器trigger，运行job
- pauseJob(JobKey jobKey) ：根据指定的JobDetail key暂停job。
- resumeJob(JobKey jobKey) ：根据指定的key恢复一个job。
- deleteJob(JobKey jobKey) ：删除一个job
- triggerJob(JobKey jobKey) ：触发一个JobDetail(如今执行)。
- rescheduleJob(TriggerKey triggerKey, Trigger newTrigger)：
用给定的键删除触发器，并存储新的触发器，它必须与同一个做业相关联（新触发器必须具备指定的做业名和组）-然而，新触发器没必要具备与旧触发器相同的名称。
第三步：根据任务调度运行job类。
其实这一步是不须要咱们编写的，在咱们将正确的JobDetail 和 Trigger 表达式加载到任务调度后，调度器会自动触发任务的执行 。
第四步：实例化job类，注入要运行的service。
工厂类
@Component
public class JobFactory extends AdaptableJobFactory {
//这个对象Spring会帮咱们自动注入进来,也属于Spring技术范畴.
//为何须要这个类呢，在我写的这个demo中，你们能够将此类删掉，发现程序也能够正确运行，但是我为何仍是加上呢。
//你们能够看下咱们的任务类，你们能够看到Job对象的实例化过程是在Quartz中进行的，这时候咱们将spring的东西注入进来，确定是行不通的，因此须要这个类
@Autowired
private AutowireCapableBeanFactory capableBeanFactory;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
//调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
//进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
任务类。
@DisallowConcurrentExecution //做业不并发
@Component
public class HelloWorldJob implements Job{
@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println("欢迎使用yyblog,这是一个定时任务 --小卖铺的老爷爷!"+ DateUtils.fullTime(new Date()));
}
}
好了，大功告成，一个简单的动态配置的定时任务已经完成。是否是so easy，下面咱们再来简单实现下其余的几种经常使用的api吧。
暂停一个job。
public void pauseJob(TaskDO task) throws SchedulerException {
JobKey jobKey = JobKey.jobKey(task.getJobName(), task.getJobGroup());
scheduler.pauseJob(jobKey);
}
恢复一个job
public void resumeJob(TaskDO task) throws SchedulerException {
JobKey jobKey = JobKey.jobKey(task.getJobName(), task.getJobGroup());
scheduler.resumeJob(jobKey);
}
删除一个job
public void deleteJob(TaskDO task) throws SchedulerException {
JobKey jobKey = JobKey.jobKey(task.getJobName(), task.getJobGroup());
scheduler.deleteJob(jobKey);
}
当即触发job
public void runJobNow(TaskDO task) throws SchedulerException {
JobKey jobKey = JobKey.jobKey(task.getJobName(), task.getJobGroup());
scheduler.triggerJob(jobKey);
}
更新job表达式
public void updateJobCron(TaskDO task) throws SchedulerException {
TriggerKey triggerKey = TriggerKey.triggerKey(task.getJobName(), task.getJobGroup());
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(task.getCronExpression());
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
scheduler.rescheduleJob(triggerKey, trigger);
}
总结
正文部分基本上就这些，很少废话了，本文没有太多的讲解原理，只是简单的应用。