SpringBoot整合Quartz實現定時任務

本文轉載自查看原文 2019-05-13 15:51 1205 通用實踐/ 高並發/ 調度/ 開發經驗/ java經驗集錦/ 多線程/ quartz/ 工作總結/ 線程池

簡介

Quartz是一個很牛的任務調度框架，通過它我們可以實現諸如:定時活動、延時活動、訂單狀態延時檢測、服務器狀態定時檢測等，時間調度任務功能。

下面我們介紹一下它在SpringBoot中的使用：

1.配置Quartz
2.靜態任務調度
3.動態任務調度
4.任務調度監聽器

快速集成

快速集成體驗一下Quartz的功能吧。

1.首先引入maven依賴

<!--Quartz-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

2.配置Quartz

SpringBoot集成Quartz依然沿用了Spring的典型方式，使用工廠Bean生成Bean的方式。在Quartz中，需要被調度的任務叫做Job，而負責調度任務則是Scheduler。
我們首先需要配置工廠Bean：JobFactory接口，自定義一個AutowiringSpringBeanJobFactory類繼承SpringBeanJobFactory(實現了JobFactory接口)

AutowiringSpringBeanJobFactory工廠類將負責生成實現了Job接口的類的實例對象Bean。

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
/**

   
   
   
           
    
    
    
              自動注入的jobBean工廠
 */
 public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory
 implements ApplicationContextAware {
 private transient AutowireCapableBeanFactory beanFactory;
 @Override
 public void setApplicationContext(final ApplicationContext context) {
  beanFactory = context.getAutowireCapableBeanFactory();
 }
 @Override
 protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
 final Object job = super.createJobInstance(bundle);
  beanFactory.autowireBean(job);

 <span class="hljs-keyword">return</span> job;
 }
 }

下面創建一個Quartz的config配置類：SchedulerConfig
SchedulerConfig類通過 @Configuration 自動裝載配置。這里它配置了兩種Bean工廠，一個是JobFactory ，另一個是SchedulerFactoryBean。JobFactory就是上面我們所說的AutowiringSpringBeanJobFactory，而SchedulerFactoryBean是Quartz為我們提供的一個生成Scheduler實例Bean的工廠類。

而在這個SchedulerConfig類中還提供了simpleJobTrigger()【表達式任務觸發器工廠】和quartzProperties()【Properties屬性基本配置參數】

CronTriggerFactoryBean為我們提供了執行任務的觸發器，這里是通過靜態方式配置了一個調度任務。
quartzProperties配置參數可以自由配置Quartz的一些基本參數屬性，比如配置調度線程數，調度線程池類型等，這里只配置了一個基本使用參數，如果需要更多請查閱官網。

import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
 import java.util.Properties;
/**

    
    
    
             
              定時配置（可以配置靜態定時任務）
 */
 @Configuration
 public class SchedulerConfig {
 @Bean
 public JobFactory jobFactory(ApplicationContext applicationContext) {
 AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
  jobFactory.setApplicationContext(applicationContext);

 <span class="hljs-keyword">return</span> jobFactory;
 }
 //SchedulerFactoryBean
 @Bean
 public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, Trigger simpleJobTrigger)
 throws IOException{
 SchedulerFactoryBean factory = new SchedulerFactoryBean();
  factory.setJobFactory(jobFactory);
 factory.setQuartzProperties(quartzProperties());
 factory.setTriggers(simpleJobTrigger);

 <span class="hljs-keyword">return</span> factory;
 }
 /** 
               
                靜態方式配置定時任務
  
                @param jobDetail
  
                @return
 */
 @Bean
 public CronTriggerFactoryBean simpleJobTrigger(@Qualifier("simpleJobDetail") JobDetail jobDetail) {
 CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean ();
 factoryBean.setJobDetail(jobDetail);
 factoryBean.setStartDelay(1000L);
 factoryBean.setName("trigger1");
 factoryBean.setGroup("group1");
 //周1至周5，每天上午8點至下午18點，每分鍾執行一次
 factoryBean.setCronExpression("0 0/1 8-18 ? * 2-6");
 return factoryBean;
 }
  
              
 @Bean
 public JobDetailFactoryBean simpleJobDetail() {
 JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
  factoryBean.setJobClass(ScheduledJob.class);
 factoryBean.setGroup(<span class="hljs-string">"group1"</span>);
 factoryBean.setName(<span class="hljs-string">"job1"</span>);

 <span class="hljs-keyword">return</span> factoryBean;
 }
 @Bean
 public Properties quartzProperties() throws IOException {
 PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
  propertiesFactoryBean.setLocation(<span class="hljs-keyword">new</span> ClassPathResource(<span class="hljs-string">"/quartz.properties"</span>));

 propertiesFactoryBean.afterPropertiesSet();

 <span class="hljs-keyword">return</span> propertiesFactoryBean.getObject();
 }
  
            
}

quartz.properties內容:

#------配置調度器的線程池
#線程池類
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
#線程個數
org.quartz.threadPool.threadCount = 3
#------配置任務調度現場數據保存機制，默認保存在內存
 org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore

3.自定義一個任務Job

創建 ScheduledJob.java 並實現Job接口，它是我們之后任務被調度后執行業務邏輯的主要類，通過execute()方法執行：

import org.jboss.logging.Logger;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**

   
   
   
           
    
    
    
              自定義定時任務
 */
 public class ScheduledJob implements Job {
 private static final Logger logger= Logger.getLogger(ScheduledJob.class);
 @Override
 public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
  <span class="hljs-comment">//執行任務邏輯....</span>
 logger.info(<span class="hljs-string">"執行自定義定時任務"</span>);
 }
 }

4.自定義開啟關閉任務的管理器類
為了之后項目中使用方便我們抽象出一個任務調度管理類 SchedulerManager.java，我們開啟、暫停、恢復、停止、移除所有任務額功能都是通過它去執行。

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
/*

    
    
    
             
              此處可以注入數據庫操作，查詢出所有的任務配置
 */
 @Component
 public class SchedulerManager {
 @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
 @Autowired
 private SchedulerFactoryBean schedulerFactoryBean;
 private JobListener scheduleListener;
 /** 
               
               開始定時任務 
               @param jobName 
               @param jobGroup 
               @throws SchedulerException
 */
 public void startJob(String cron,String jobName,String jobGroup,Class<? extends Job> jobClass) throws SchedulerException
 {
 Scheduler scheduler = schedulerFactoryBean.getScheduler();
 if(scheduleListener==null){
 scheduleListener=new SchedulerListener();
 scheduler.getListenerManager().addJobListener(scheduleListener);
 }
 JobKey jobKey=new JobKey(jobName,jobGroup);
 if(!scheduler.checkExists(jobKey))
 {
 scheduleJob(cron,scheduler,jobName,jobGroup,jobClass);
 }
 } 
              
 /** 
               
               移除定時任務 
               @param jobName 
               @param jobGroup 
               @throws SchedulerException
 /
 public void deleteJob(String jobName,String jobGroup) throws SchedulerException
 {
 Scheduler scheduler = schedulerFactoryBean.getScheduler();
 JobKey jobKey=new JobKey(jobName,jobGroup);
 scheduler.deleteJob(jobKey);
 }
 /* 
               暫停定時任務 
               @param jobName 
               @param jobGroup 
               @throws SchedulerException
 /
 public void pauseJob(String jobName,String jobGroup) throws SchedulerException
 {
 Scheduler scheduler = schedulerFactoryBean.getScheduler();
 JobKey jobKey=new JobKey(jobName,jobGroup);
 scheduler.pauseJob(jobKey);
 }
 /* 
               恢復定時任務 
               @param jobName 
               @param jobGroup 
               @throws SchedulerException
 /
 public void resumeJob(String jobName,String jobGroup) throws SchedulerException
 {
 Scheduler scheduler = schedulerFactoryBean.getScheduler();
 JobKey triggerKey=new JobKey(jobName,jobGroup);
 scheduler.resumeJob(triggerKey);
 }
 /* 
               清空所有當前scheduler對象下的定時任務【目前只有全局一個scheduler對象】 
               @throws SchedulerException
 */
 public void clearAll() throws SchedulerException {
 Scheduler scheduler = schedulerFactoryBean.getScheduler();
 scheduler.clear();
 } 
              
 /** 
               
                動態創建Job
  
                此處的任務可以配置可以放到properties或者是放到數據庫中
  
                Trigger:name和group 目前和job的name、group一致，之后可以擴展歸類
  
                @param scheduler
  
                @throws SchedulerException
 /
 private void scheduleJob(String cron,Scheduler scheduler,String jobName,String jobGroup,Class<? extends Job> jobClass) throws SchedulerException{
 / 
                 
                 此處可以先通過任務名查詢數據庫，如果數據庫中存在該任務，更新任務的配置以及觸發器 
                 如果此時數據庫中沒有查詢到該任務，則按照下面的步驟新建一個任務，並配置初始化的參數，並將配置存到數據庫中
 */
 JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();
 // 每5s執行一次
 CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
 CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(scheduleBuilder).build(); 
                
 scheduler.scheduleJob(jobDetail,cronTrigger);
 }
  
              
  
            
}

任務監聽器SchedulerListener.java：

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
public class SchedulerListener implements JobListener {
 public static final String LISTENER_NAME = "QuartSchedulerListener";
<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">getName</span><span class="hljs-params">()</span> </span>{
    <span class="hljs-keyword">return</span> LISTENER_NAME; <span class="hljs-comment">//must return a name</span>
}

<span class="hljs-comment">//任務被調度前</span>
<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">jobToBeExecuted</span><span class="hljs-params">(JobExecutionContext context)</span> </span>{

    String jobName = context.getJobDetail().getKey().toString();
    System.out.println(<span class="hljs-string">"jobToBeExecuted"</span>);
    System.out.println(<span class="hljs-string">"Job : "</span> + jobName + <span class="hljs-string">" is going to start..."</span>);

}

<span class="hljs-comment">//任務調度被拒了</span>
<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">jobExecutionVetoed</span><span class="hljs-params">(JobExecutionContext context)</span> </span>{
    System.out.println(<span class="hljs-string">"jobExecutionVetoed"</span>);
    <span class="hljs-comment">//可以做一些日志記錄原因</span>

}

<span class="hljs-comment">//任務被調度后</span>
<span class="hljs-meta">@Override</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">jobWasExecuted</span><span class="hljs-params">(JobExecutionContext context,
                           JobExecutionException jobException)</span> </span>{
    System.out.println(<span class="hljs-string">"jobWasExecuted"</span>);

    String jobName = context.getJobDetail().getKey().toString();
    System.out.println(<span class="hljs-string">"Job : "</span> + jobName + <span class="hljs-string">" is finished..."</span>);

    <span class="hljs-keyword">if</span> (jobException!=<span class="hljs-keyword">null</span>&amp;&amp;!jobException.getMessage().equals(<span class="hljs-string">""</span>)) {
        System.out.println(<span class="hljs-string">"Exception thrown by: "</span> + jobName
                + <span class="hljs-string">" Exception: "</span> + jobException.getMessage());
    }

}

}

這里涉及到Quartz的一些概念，有必要在這里簡單說明一下：

Job: 被執行的任務
Scheduler: 負責調度任務，如：開始/結束一個調度
Trigger: 負責執行任務的觸發器（這里我用的是CronTrigger可以用cron表達式去執行任務的觸發器）如："0/5 * * * * ?" //每五秒執行一次，具體使用方法可以查閱一下官網。
JobDetail: 封裝Job，Scheduler真正調度的對象，包括Job名稱，組等信息。
JobListener: 任務執行的監聽器，可以監聽到任務執行前、后以及未能成功執行拋出異常。
5.使用示例：
這里我寫了一個簡單的Controller去開啟/停止任務調度：

import com.yu.scloud.baseframe.frame.utils.quartz.ScheduledJob;
import com.yu.scloud.baseframe.frame.utils.quartz.SchedulerManager;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
@RestController
 @RequestMapping("/quartz")
 public class QuartzController{
<span class="hljs-meta">@Autowired</span>
<span class="hljs-keyword">public</span> SchedulerManager myScheduler;

<span class="hljs-meta">@RequestMapping</span>(value = <span class="hljs-string">"/job2"</span>,method = RequestMethod.GET)
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">scheduleJob2</span><span class="hljs-params">()</span>
</span>{
    <span class="hljs-keyword">try</span> {
        myScheduler.startJob(<span class="hljs-string">"0/5 * * * * ?"</span>,<span class="hljs-string">"job2"</span>,<span class="hljs-string">"group2"</span>, ScheduledJob.class);<span class="hljs-comment">//每五秒執行一次</span>
        <span class="hljs-comment">//0 0/5 14 * * ?在每天下午2點到下午2:55期間的每5分鍾觸發</span>
        <span class="hljs-comment">//0 50 14 * * ?在每天下午2點50分5秒執行一次</span>

// myScheduler.startJob("5 50 14 * * ?","job2","group2", ScheduledJob.class);
 return "啟動定時器成功";
 } catch (SchedulerException e) {
 e.printStackTrace();
 }
 return "啟動定時器失敗";
 }
 @RequestMapping(value = "/del_job2",method = RequestMethod.GET)
 public String deleteScheduleJob2()
 {
 try {
 myScheduler.deleteJob("job2","group2");
 return "刪除定時器成功";
 } catch (SchedulerException e) {
 e.printStackTrace();
 }
 return "刪除定時器失敗";
 }
}

啟動服務，訪問就會開啟一個定時任務，可以打開控制台查看打印信息。OK!關於在SpringBoot中Quartz定時任務調度的使用，就介紹到這里。

      </div>
    </div>

原文地址：https://www.jianshu.com/p/a99b80021be6

posted @ 2019-05-13 15:51 星朝閱讀( 1204) 評論( 0) 編輯收藏

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 springboot整合Quartz實現動態配置定時任務 springboot整合Quartz實現動態配置定時任務 Springboot整合Quartz實現動態定時任務 springboot整合Quartz定時任務 SpringBoot整合Quartz定時任務 springboot整合Quartz實現動態配置定時任務 SpringBoot 簡單整合 quartz 實現定時任務 springboot整合quartz定時器實現定時任務詳解 SpringBoot整合Quartz定時任務的簡單實例 2 SpringBoot整合Quartz定時任務管理