springboot整合Quartz实现动态配置定时任务

　　前言

　　在我们日常的开发中，很多时候，定时任务都不是写死的，而是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。

　　一、新建一个springboot工程，并添加依赖

　　

　　org.springframework.boot

　　spring-boot-starter-data-jpa

　　

　　

　　com.h2database

　　h2

　　runtime

　　

　　

　　org.springframework.boot

　　spring-boot-starter-test

　　test

　　

　　

　　org.quartz-scheduler

　　quartz

　　2.2.1

　　

　　

　　slf4j-api

　　org.slf4j

　　

　　

　　

　　

　　org.springframework

　　spring-context-support

　　

　　二、配置文件application.properties

　　# 服务器端口号

　　server.port=7902

　　# 是否生成ddl语句

　　spring.jpa.generate-ddl=false

　　# 是否打印sql语句

　　spring.jpa.show-sql=true

　　# 自动生成ddl，由于指定了具体的ddl，此处设置为none

　　spring.jpa.hibernate.ddl-auto=none

　　# 使用H2数据库

　　spring.datasource.platform=h2

　　# 指定生成数据库的schema文件位置

　　spring.datasource.schema=classpath:schema.sql

　　# 指定插入数据库语句的脚本位置

　　spring.datasource.data=classpath:data.sql

　　# 配置日志打印信息

　　logging.level.root=INFO

　　logging.level.org.hibernate=INFO

　　logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

　　logging.level.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE

　　logging.level.com.itmuch=DEBUG

　　三、Entity类

　　package com.chhliu.springboot.quartz.entity;

　　import javax.persistence.Column;

　　import javax.persistence.Entity;

　　import javax.persistence.GeneratedValue;

　　import javax.persistence.GenerationType;

　　import javax.persistence.Id;

　　@Entity

　　public class Config {

　　@Id

　　@GeneratedValue(strategy=GenerationType.AUTO)

　　private Long id;

　　@Column

　　private String cron;

　　/**

　　* @return the id

　　*/

　　public Long getId() {

　　return id;

　　}

　　……此处省略getter和setter方法……

　　}

　　四、任务类

　　package com.chhliu.springboot.quartz.entity;

　　import org.slf4j.Logger;

　　import org.slf4j.LoggerFactory;

　　import org.springframework.context.annotation.Configuration;

　　import org.springframework.scheduling.annotation.EnableScheduling;

　　import org.springframework.stereotype.Component;

　　@Configuration

　　@Component // 此注解必加

　　@EnableScheduling // 此注解必加

　　public class ScheduleTask {

　　private static final Logger LOGGER=LoggerFactory.getLogger(ScheduleTask.class);

　　public void sayHello(){

　　LOGGER.info("Hello world, i'm the king of the world!!!");

　　}

　　}

　　五、Quartz配置类

　　由于springboot追求零xml配置，所以下面会以配置Bean的方式来实现

　　package com.chhliu.springboot.quartz.entity;

　　import org.quartz.Trigger;

　　import org.springframework.context.annotation.Bean;

　　import org.springframework.context.annotation.Configuration;

　　import org.springframework.scheduling.quartz.CronTriggerFactoryBean;

　　import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

　　import org.springframework.scheduling.quartz.SchedulerFactoryBean;

　　@Configuration

　　public class QuartzConfigration {

　　/**

　　* attention:

　　* Details：配置定时任务

　　*/

　　@Bean(name="jobDetail")

　　public

　　MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask为需要执行的任务

　　MethodInvokingJobDetailFactoryBean jobDetail=new MethodInvokingJobDetailFactoryBean();

　　/*

　　* 是否并发执行

　　* 例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了，

　　* 如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行

　　*/

　　jobDetail.setConcurrent(false);

　　jobDetail.setName("srd-chhliu");// 设置任务的名字

　　jobDetail.setGroup("srd");// 设置任务的分组，这些属性都可以存储在数据库中，在多任务的时候使用

　　/*

　　* 为需要执行的实体类对应的对象

　　*/

　　jobDetail.setTargetObject(task);

　　/*

　　* sayHello为需要执行的方法

　　* 通过这几个配置，告诉JobDetailFactoryBean我们需要执行定时执行ScheduleTask类中的sayHello方法

　　*/

　　jobDetail.setTargetMethod("https://www.ershouyi.com/");

　　return jobDetail;

　　}

　　/**

　　* attention:

　　* Details：配置定时任务的触发器，也就是什么时候触发执行定时任务

　　*/

　　@Bean(name="jobTrigger")

　　public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) {

　　CronTriggerFactoryBean tigger=new CronTriggerFactoryBean();

　　tigger.setJobDetail(jobDetail.getObject());

　　tigger.setCronExpression("0 30 20 * * ?");// 初始时的cron表达式

　　tigger.setName("srd-chhliu");// trigger的name

　　return tigger;

　　}

　　/**

　　* attention:

　　* Details：定义quartz调度工厂

　　*/

　　@Bean(name="scheduler")

　　public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {

　　SchedulerFactoryBean bean=new SchedulerFactoryBean();

　　// 用于quartz集群,QuartzScheduler 启动时更新己存在的Job

　　bean.setOverwriteExistingJobs(true);

　　// 延时启动，应用启动1秒后

　　bean.setStartupDelay(1);

　　// 注册触发器

　　bean.setTriggers(cronJobTrigger);

　　return bean;

　　}

　　}

　　六、定时查库，并更新任务

　　package com.chhliu.springboot.quartz.entity;

　　import javax.annotation.Resource;

　　import org.quartz.CronScheduleBuilder;

　　import org.quartz.CronTrigger;

　　import org.quartz.JobDetail;

　　import org.quartz.Scheduler;

　　import org.quartz.SchedulerException;

　　import org.springframework.beans.factory.annotation.Autowired;

　　import org.springframework.context.annotation.Configuration;

　　import org.springframework.scheduling.annotation.EnableScheduling;

　　import org.springframework.scheduling.annotation.Scheduled;

　　import org.springframework.stereotype.Component;

　　import com.chhliu.springboot.quartz.repository.ConfigRepository;

　　@Configuration

　　@EnableScheduling

　　@Component

　　public class ScheduleRefreshDatabase {

　　@Autowired

　　private ConfigRepository repository;

　　@Resource(name="jobDetail")

　　private JobDetail jobDetail;

　　@Resource(name="jobTrigger")

　　private CronTrigger cronTrigger;

　　@Resource(name="scheduler")

　　private Scheduler scheduler;

　　@Scheduled(fixedRate=5000) // 每隔5s查库，并根据查询结果决定是否重新设置定时任务

　　public void scheduleUpdateCronTrigger() throws SchedulerException {

　　CronTrigger trigger=(CronTrigger) scheduler.getTrigger(cronTrigger.getKey());

　　String currentCron=trigger.getCronExpression();// 当前Trigger使用的

　　String searchCron=repository.findOne(1L).getCron();// 从数据库查询出来的

　　System.out.println(currentCron);

　　System.out.println(searchCron);

　　if (currentCron.equals(searchCron)) {

　　// 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致，则不刷新任务

　　} else {

　　// 表达式调度构建器

　　CronScheduleBuilder scheduleBuilder=CronScheduleBuilder.cronSchedule(searchCron);

　　// 按新的cronExpression表达式重新构建trigger

　　trigger=(CronTrigger) scheduler.getTrigger(cronTrigger.getKey());

　　trigger=trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())

　　.withSchedule(scheduleBuilder).build();

　　// 按新的trigger重新设置job执行

　　scheduler.rescheduleJob(cronTrigger.getKey(), trigger);

　　currentCron=searchCron;

　　}

　　}

　　}

　　六、相关脚本

　　1、data.sql

　　insert into config(id,cron) values(1,'0 0/2 * * * ?'); # 每2分钟执行一次定时任务

　　2、schema.sql

　　drop table config if exists;

　　create table config(

　　id bigint generated by default as identity,

　　cron varchar(40),

　　primary key(id)

　　);

　　六、运行测试

　　测试结果如下：(Quartz默认的线程池大小为10)

　　0 30 20 * * ?

　　0 0/2 * * * ?

　　2017-03-08 18:02:00.025 INFO 5328 --- [eduler_Worker-1] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world!!!

　　2017-03-08 18:04:00.003 INFO 5328 --- [eduler_Worker-2] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world!!!

　　2017-03-08 18:06:00.002 INFO 5328 --- [eduler_Worker-3] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world!!!

　　2017-03-08 18:08:00.002 INFO 5328 --- [eduler_Worker-4] c.c.s.quartz.entity.ScheduleTask : Hello world, i'm the king of the world!!!

　　从上面的日志打印时间来看，我们实现了动态配置，最初的时候，任务是每天20:30执行，后面通过动态刷新变成了每隔2分钟执行一次。

　　虽然上面的解决方案没有使用Quartz推荐的方式完美，但基本上可以满足我们的需求，当然也可以采用触发事件的方式来实现，例如当前端修改定时任务的触发时间时，异步的向后台发送通知，后台收到通知后，然后再更新程序，也可以实现动态的定时任务刷新