比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

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

springboot整合Quartz实现动态配置定时任务http://www.bieryun.com/1478.html

前言

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

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

[html] view plain copy

  1. <dependency>
  2.             <groupId>org.springframework.boot</groupId>
  3.             <artifactId>spring-boot-starter-data-jpa</artifactId>
  4.         </dependency>
  5.         <dependency><!– 为了方便测试,此处使用了内存数据库 –>
  6.             <groupId>com.h2database</groupId>
  7.             <artifactId>h2</artifactId>
  8.             <scope>runtime</scope>
  9.         </dependency>
  10.         <dependency>
  11.             <groupId>org.springframework.boot</groupId>
  12.             <artifactId>spring-boot-starter-test</artifactId>
  13.             <scope>test</scope>
  14.         </dependency>
  15.         <dependency>
  16.             <groupId>org.quartz-scheduler</groupId>
  17.             <artifactId>quartz</artifactId>
  18.             <version>2.2.1</version>
  19.             <exclusions>
  20.                 <exclusion>
  21.                     <artifactId>slf4j-api</artifactId>
  22.                     <groupId>org.slf4j</groupId>
  23.                 </exclusion>
  24.             </exclusions>
  25.         </dependency>
  26.         <dependency><!– 该依赖必加,里面有sping对schedule的支持 –>
  27.                        <groupId>org.springframework</groupId>
  28.                        <artifactId>spring-context-support</artifactId>
  29.         </dependency>

二、配置文件application.properties

[java] view plain copy

  1. # 服务器端口号
  2. server.port=7902
  3. # 是否生成ddl语句
  4. spring.jpa.generate-ddl=false
  5. # 是否打印sql语句
  6. spring.jpa.show-sql=true
  7. # 自动生成ddl,由于指定了具体的ddl,此处设置为none
  8. spring.jpa.hibernate.ddl-auto=none
  9. # 使用H2数据库
  10. spring.datasource.platform=h2
  11. # 指定生成数据库的schema文件位置
  12. spring.datasource.schema=classpath:schema.sql
  13. # 指定插入数据库语句的脚本位置
  14. spring.datasource.data=classpath:data.sql
  15. # 配置日志打印信息
  16. logging.level.root=INFO
  17. logging.level.org.hibernate=INFO
  18. logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE
  19. logging.level.org.hibernate.type.descriptor.sql.BasicExtractor=TRACE
  20. logging.level.com.itmuch=DEBUG

三、Entity类

[java] view plain copy

  1. package com.chhliu.springboot.quartz.entity;
  2. import javax.persistence.Column;
  3. import javax.persistence.Entity;
  4. import javax.persistence.GeneratedValue;
  5. import javax.persistence.GenerationType;
  6. import javax.persistence.Id;
  7. @Entity
  8. public class Config {
  9.     @Id
  10.       @GeneratedValue(strategy = GenerationType.AUTO)
  11.       private Long id;
  12.       @Column
  13.       private String cron;
  14.     /**
  15.      * @return the id
  16.      */
  17.     public Long getId() {
  18.         return id;
  19.     }
  20.         ……此处省略getter和setter方法……
  21. }

四、任务类

[java] view plain copy

  1. package com.chhliu.springboot.quartz.entity;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.scheduling.annotation.EnableScheduling;
  6. import org.springframework.stereotype.Component;
  7. @Configuration
  8. @Component // 此注解必加
  9. @EnableScheduling // 此注解必加
  10. public class ScheduleTask {
  11.     private static final Logger LOGGER =  LoggerFactory.getLogger(ScheduleTask.class);
  12.     public void sayHello(){
  13.         LOGGER.info(“Hello world, i’m the king of the world!!!”);
  14.     }
  15. }

五、Quartz配置类

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

[java] view plain copy

  1. package com.chhliu.springboot.quartz.entity;
  2. import org.quartz.Trigger;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
  6. import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
  7. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
  8. @Configuration
  9. public class QuartzConfigration {
  10.     /**
  11.      * attention:
  12.      * Details:配置定时任务
  13.      */
  14.     @Bean(name = “jobDetail”)
  15.     public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask为需要执行的任务
  16.         MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
  17.         /*
  18.          *  是否并发执行
  19.          *  例如每5s执行一次任务,但是当前任务还没有执行完,就已经过了5s了,
  20.          *  如果此处为true,则下一个任务会执行,如果此处为false,则下一个任务会等待上一个任务执行完后,再开始执行
  21.          */
  22.         jobDetail.setConcurrent(false);
  23.         jobDetail.setName(“srd-chhliu”);// 设置任务的名字
  24.         jobDetail.setGroup(“srd”);// 设置任务的分组,这些属性都可以存储在数据库中,在多任务的时候使用
  25.         /*
  26.          * 为需要执行的实体类对应的对象
  27.          */
  28.         jobDetail.setTargetObject(task);
  29.         /*
  30.          * sayHello为需要执行的方法
  31.          * 通过这几个配置,告诉JobDetailFactoryBean我们需要执行定时执行ScheduleTask类中的sayHello方法
  32.          */
  33.         jobDetail.setTargetMethod(“sayHello”);
  34.         return jobDetail;
  35.     }
  36.     /**
  37.      * attention:
  38.      * Details:配置定时任务的触发器,也就是什么时候触发执行定时任务
  39.      */
  40.     @Bean(name = “jobTrigger”)
  41.     public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) {
  42.         CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
  43.         tigger.setJobDetail(jobDetail.getObject());
  44.         tigger.setCronExpression(“0 30 20 * * ?”);// 初始时的cron表达式
  45.         tigger.setName(“srd-chhliu”);// trigger的name
  46.         return tigger;
  47.     }
  48.     /**
  49.      * attention:
  50.      * Details:定义quartz调度工厂
  51.      */
  52.     @Bean(name = “scheduler”)
  53.     public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {
  54.         SchedulerFactoryBean bean = new SchedulerFactoryBean();
  55.         // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
  56.         bean.setOverwriteExistingJobs(true);
  57.         // 延时启动,应用启动1秒后
  58.         bean.setStartupDelay(1);
  59.         // 注册触发器
  60.         bean.setTriggers(cronJobTrigger);
  61.         return bean;
  62.     }
  63. }

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

[java] view plain copy

  1. package com.chhliu.springboot.quartz.entity;
  2. import javax.annotation.Resource;
  3. import org.quartz.CronScheduleBuilder;
  4. import org.quartz.CronTrigger;
  5. import org.quartz.JobDetail;
  6. import org.quartz.Scheduler;
  7. import org.quartz.SchedulerException;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.context.annotation.Configuration;
  10. import org.springframework.scheduling.annotation.EnableScheduling;
  11. import org.springframework.scheduling.annotation.Scheduled;
  12. import org.springframework.stereotype.Component;
  13. import com.chhliu.springboot.quartz.repository.ConfigRepository;
  14. @Configuration
  15. @EnableScheduling
  16. @Component
  17. public class ScheduleRefreshDatabase {
  18.     @Autowired
  19.     private ConfigRepository repository;
  20.     @Resource(name = “jobDetail”)
  21.     private JobDetail jobDetail;
  22.     @Resource(name = “jobTrigger”)
  23.     private CronTrigger cronTrigger;
  24.     @Resource(name = “scheduler”)
  25.     private Scheduler scheduler;
  26.     @Scheduled(fixedRate = 5000// 每隔5s查库,并根据查询结果决定是否重新设置定时任务
  27.     public void scheduleUpdateCronTrigger() throws SchedulerException {
  28.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
  29.         String currentCron = trigger.getCronExpression();// 当前Trigger使用的
  30.         String searchCron = repository.findOne(1L).getCron();// 从数据库查询出来的
  31.         System.out.println(currentCron);
  32.         System.out.println(searchCron);
  33.         if (currentCron.equals(searchCron)) {
  34.             // 如果当前使用的cron表达式和从数据库中查询出来的cron表达式一致,则不刷新任务
  35.         } else {
  36.             // 表达式调度构建器
  37.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
  38.             // 按新的cronExpression表达式重新构建trigger
  39.             trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
  40.             trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())
  41.                     .withSchedule(scheduleBuilder).build();
  42.             // 按新的trigger重新设置job执行
  43.             scheduler.rescheduleJob(cronTrigger.getKey(), trigger);
  44.             currentCron = searchCron;
  45.         }
  46.     }
  47. }

六、相关脚本

1、data.sql

[sql] view plain copy

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

2、schema.sql

[sql] view plain copy

  1. drop table config if exists;
  2. create table config(
  3.     id bigint generated by default as identity,
  4.     cron varchar(40),
  5.     primary key(id)
  6. );

六、运行测试

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

[java] view plain copy

  1. 0 30 20 * * ?
  2. 0 0/2 * * * ?
  3. 20170308 18:02:00.025  INFO 5328 — [eduler_Worker-1] c.c.s.quartz.entity.ScheduleTask         : Hello world, i’m the king of the world!!!
  4. 20170308 18:04:00.003  INFO 5328 — [eduler_Worker-2] c.c.s.quartz.entity.ScheduleTask         : Hello world, i’m the king of the world!!!
  5. 20170308 18:06:00.002  INFO 5328 — [eduler_Worker-3] c.c.s.quartz.entity.ScheduleTask         : Hello world, i’m the king of the world!!!
  6. 20170308 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推荐的方式完美,但基本上可以满足我们的需求,当然也可以采用触发事件的方式来实现,例如当前端修改定时任务的触发时间时,异步的向后台发送通知,后台收到通知后,然后再更新程序,也可以实现动态的定时任务刷新

未经允许不得转载:比尔云 » springboot整合Quartz实现动态配置定时任务
分享到: 更多 (0)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS