springboot整合Quartz實現動態配置定時任務

前言

在我們日常的開發中，很多時候，定時任務都不是寫死的，而是寫到數據庫中，從而實現定時任務的動態配置，下面就通過一個簡單的示例，來實現這個功能。

一、新建一個springboot工程，並添加依賴

 

1.  
   <dependency>
2.  
   <groupId>org.springframework.boot</groupId>
3.  
   <artifactId>spring-boot-starter-data-jpa</artifactId>
4.  
   </dependency>
5.  
    
6.  
   <dependency><!-- 為了方便測試，此處使用了內存數據庫 -->
7.  
   <groupId>com.h2database</groupId>
8.  
   <artifactId>h2</artifactId>
9.  
   <scope>runtime</scope>
10.  
    </dependency>
11.  
    <dependency>
12.  
    <groupId>org.springframework.boot</groupId>
13.  
    <artifactId>spring-boot-starter-test</artifactId>
14.  
    <scope>test</scope>
15.  
    </dependency>
16.  
     
17.  
    <dependency>
18.  
    <groupId>org.quartz-scheduler</groupId>
19.  
    <artifactId>quartz</artifactId>
20.  
    <version>2.2.1</version>
21.  
    <exclusions>
22.  
    <exclusion>
23.  
    <artifactId>slf4j-api</artifactId>
24.  
    <groupId>org.slf4j</groupId>
25.  
    </exclusion>
26.  
    </exclusions>
27.  
    </dependency>
28.  
    <dependency><!-- 該依賴必加，里面有sping對schedule的支持 -->
29.  
    <groupId>org.springframework</groupId>
30.  
    <artifactId>spring-context-support</artifactId>
31.  
    </dependency>

二、配置文件application.properties

 

 

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類

 

 

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

四、任務類

 

 

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

五、Quartz配置類

 

由於springboot追求零xml配置，所以下面會以配置Bean的方式來實現

 

1.  
   package com.chhliu.springboot.quartz.entity;
2.  
    
3.  
   import org.quartz.Trigger;
4.  
   import org.springframework.context.annotation.Bean;
5.  
   import org.springframework.context.annotation.Configuration;
6.  
   import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
7.  
   import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
8.  
   import org.springframework.scheduling.quartz.SchedulerFactoryBean;
9.  
    
10.  
    @Configuration
11.  
    public class QuartzConfigration {
12.  
         /**
13.  
         * attention:
14.  
         * Details：配置定時任務
15.  
         */
16.  
         @Bean(name = "jobDetail")
17.  
         public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduleTask task) {// ScheduleTask為需要執行的任務
18.  
            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
19.  
             /*
20.  
             *  是否並發執行
21.  
             *  例如每5s執行一次任務，但是當前任務還沒有執行完，就已經過了5s了，
22.  
             *  如果此處為true，則下一個任務會執行，如果此處為false，則下一個任務會等待上一個任務執行完后，再開始執行
23.  
             */
24.  
            jobDetail.setConcurrent( false);
25.  
            
26.  
            jobDetail.setName( "srd-chhliu");// 設置任務的名字
27.  
            jobDetail.setGroup( "srd");// 設置任務的分組，這些屬性都可以存儲在數據庫中，在多任務的時候使用
28.  
            
29.  
             /*
30.  
             * 為需要執行的實體類對應的對象
31.  
             */
32.  
            jobDetail.setTargetObject(task);
33.  
            
34.  
             /*
35.  
             * sayHello為需要執行的方法
36.  
             * 通過這幾個配置，告訴JobDetailFactoryBean我們需要執行定時執行ScheduleTask類中的sayHello方法
37.  
             */
38.  
            jobDetail.setTargetMethod( "sayHello");
39.  
             return jobDetail;
40.  
        }
41.  
        
42.  
         /**
43.  
         * attention:
44.  
         * Details：配置定時任務的觸發器，也就是什么時候觸發執行定時任務
45.  
         */
46.  
         @Bean(name = "jobTrigger")
47.  
         public CronTriggerFactoryBean cronJobTrigger(MethodInvokingJobDetailFactoryBean jobDetail) {
48.  
            CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
49.  
            tigger.setJobDetail(jobDetail.getObject());
50.  
            tigger.setCronExpression( "0 30 20 * * ?");// 初始時的cron表達式
51.  
            tigger.setName( "srd-chhliu");// trigger的name
52.  
             return tigger;
53.  
     
54.  
        }
55.  
     
56.  
         /**
57.  
         * attention:
58.  
         * Details：定義quartz調度工廠
59.  
         */
60.  
         @Bean(name = "scheduler")
61.  
         public SchedulerFactoryBean schedulerFactory(Trigger cronJobTrigger) {
62.  
            SchedulerFactoryBean bean = new SchedulerFactoryBean();
63.  
             // 用於quartz集群,QuartzScheduler 啟動時更新己存在的Job
64.  
            bean.setOverwriteExistingJobs( true);
65.  
             // 延時啟動，應用啟動1秒后
66.  
            bean.setStartupDelay( 1);
67.  
             // 注冊觸發器
68.  
            bean.setTriggers(cronJobTrigger);
69.  
             return bean;
70.  
        }
71.  
    }

六、定時查庫，並更新任務

 

 

1.  
   package com.chhliu.springboot.quartz.entity;
2.  
    
3.  
   import javax.annotation.Resource;
4.  
    
5.  
   import org.quartz.CronScheduleBuilder;
6.  
   import org.quartz.CronTrigger;
7.  
   import org.quartz.JobDetail;
8.  
   import org.quartz.Scheduler;
9.  
   import org.quartz.SchedulerException;
10.  
    import org.springframework.beans.factory.annotation.Autowired;
11.  
    import org.springframework.context.annotation.Configuration;
12.  
    import org.springframework.scheduling.annotation.EnableScheduling;
13.  
    import org.springframework.scheduling.annotation.Scheduled;
14.  
    import org.springframework.stereotype.Component;
15.  
     
16.  
    import com.chhliu.springboot.quartz.repository.ConfigRepository;
17.  
     
18.  
    @Configuration
19.  
    @EnableScheduling
20.  
    @Component
21.  
    public class ScheduleRefreshDatabase {
22.  
    @Autowired
23.  
    private ConfigRepository repository;
24.  
     
25.  
    @Resource(name = "jobDetail")
26.  
    private JobDetail jobDetail;
27.  
     
28.  
    @Resource(name = "jobTrigger")
29.  
    private CronTrigger cronTrigger;
30.  
     
31.  
    @Resource(name = "scheduler")
32.  
    private Scheduler scheduler;
33.  
     
34.  
    @Scheduled(fixedRate = 5000) // 每隔5s查庫，並根據查詢結果決定是否重新設置定時任務
35.  
    public void scheduleUpdateCronTrigger() throws SchedulerException {
36.  
    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
37.  
    String currentCron = trigger.getCronExpression(); // 當前Trigger使用的
38.  
    String searchCron = repository.findOne( 1L).getCron();// 從數據庫查詢出來的
39.  
    System.out.println(currentCron);
40.  
    System.out.println(searchCron);
41.  
    if (currentCron.equals(searchCron)) {
42.  
    // 如果當前使用的cron表達式和從數據庫中查詢出來的cron表達式一致，則不刷新任務
43.  
    } else {
44.  
    // 表達式調度構建器
45.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);
46.  
    // 按新的cronExpression表達式重新構建trigger
47.  
    trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
48.  
    trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())
49.  
    .withSchedule(scheduleBuilder).build();
50.  
    // 按新的trigger重新設置job執行
51.  
    scheduler.rescheduleJob(cronTrigger.getKey(), trigger);
52.  
    currentCron = searchCron;
53.  
    }
54.  
    }
55.  
    }

六、相關腳本

 

1、data.sql

 

insert into config(id,cron) values(1,'0 0/2 * * * ?'); # 每2分鍾執行一次定時任務

2、schema.sql

 

 

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)

 

1.  
   0 30 20 * * ?
2.  
   0 0/2 * * * ?
3.  
   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!!!
4.  
   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!!!
5.  
   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!!!
6.  
   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推薦的方式完美，但基本上可以滿足我們的需求，當然也可以采用觸發事件的方式來實現，例如當前端修改定時任務的觸發時間時，異步的向后台發送通知，后台收到通知后，然后再更新程序，也可以實現動態的定時任務刷新

版權聲明：本文為博主原創文章，轉載請注明出處。 https://blog.csdn.net/liuchuanhong1/article/details/60873295