Quartz实现JAVA定时任务的动态配置(Spring boot)

实现步骤

①启动项目，启动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，这里仅介绍一些常用的，想要了解更多可以稍后看下彩蛋部分。

1、start()方法：只有调用start()方法后，Scheduler线程才开始启动触发器trigger，运行job

2、pauseJob(JobKey jobKey) ：根据指定的JobDetail key暂停job。

3、resumeJob(JobKey jobKey) ：根据指定的key恢复一个job。

4、deleteJob(JobKey jobKey) ：删除一个job

5、triggerJob(JobKey jobKey) ：触发一个JobDetail(现在执行)。

6、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())); } }

 

暂停一个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); }