簡介
Quartz是一個很牛的任務調度框架,通過它我們可以實現諸如:定時活動、延時活動、訂單狀態延時檢測、服務器狀態定時檢測等,時間調度任務功能。
下面我們介紹一下它在SpringBoot中的使用:
1.配置Quartz
2.靜態任務調度
3.動態任務調度
4.任務調度監聽器
快速集成
快速集成體驗一下Quartz的功能吧。
1.首先引入maven依賴
<!--Quartz-->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.3.0</version>
</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;
/**
- 想要job中注入service等類,必須配置自定義的jobFactory,不然注入進去的service爲null
- 配置jobFactory,配置之後job可以以bean的形式注入spring
- 我們需要自定義一個類將創建的job添加到applicationContext中,該類需要繼承SpringBeanJobFactory並
- 實現ApplicationContextAware接口
- ApplicationContextAware接口的作用:spring容器會檢測容器中的所有bean,如果發現某個bean實現了applicationContextAware
- 接口,spring容器會在創建該bean之後,自動調用該bean的setApplicationContextAware()方法,該方法調用時,會將容器
- 本身作爲參數傳給該方法,該方法中的實現部分將spring傳入的參數(容器本身)賦給該類對象的applicationContext實例變量
- 因此接下來可以通過該applicationContext實例變量來訪問容器本身
- 重寫springBeanJobFactory類中的createJobInstance方法,將創建的job實例添加到applicationContext中,交給spring管理
- 爲了保證scheduler能夠感知spring容器的生命週期,完成自動啓動和關閉的操作,必須讓scheduler
- 和spring容器的生命週期相關聯,以便在spring容器啓動後,scheduler自動開始工作,而在spring容器關閉之前,
- 自動關閉scheduler
*/
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);
return 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);
return jobFactory;
}
//SchedulerFactoryBean
@Bean
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, Trigger simpleJobTrigger)
throws IOException{
SchedulerFactoryBean factory = new SchedulerFactoryBean();
// schedulerFactoryBean在初始化後是否馬上啓動scheduler,默認未true,如果設置未false,
// 則需要手動啓動scheduler
factoryBean.setAutoStartup(true);
factory.setJobFactory(jobFactory);
factory.setQuartzProperties(quartzProperties());
// triggers屬性未Trigger[]類型,可以通過該屬性註冊多個Trigger
factory.setTriggers(simpleJobTrigger);
return 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("group1");
factoryBean.setName("job1");
return factoryBean;
}
@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return 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 {
//執行任務邏輯....
logger.info("執行自定義定時任務");
}
}
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";
@Override
public String getName() {
return LISTENER_NAME; //must return a name
}
//任務被調度前
@Override
public void jobToBeExecuted(JobExecutionContext context) {
String jobName = context.getJobDetail().getKey().toString();
System.out.println("jobToBeExecuted");
System.out.println("Job : " + jobName + " is going to start...");
}
//任務調度被拒了
@Override
public void jobExecutionVetoed(JobExecutionContext context) {
System.out.println("jobExecutionVetoed");
//可以做一些日誌記錄原因
}
//任務被調度後
@Override
public void jobWasExecuted(JobExecutionContext context,
JobExecutionException jobException) {
System.out.println("jobWasExecuted");
String jobName = context.getJobDetail().getKey().toString();
System.out.println("Job : " + jobName + " is finished...");
if (jobException!=null&&!jobException.getMessage().equals("")) {
System.out.println("Exception thrown by: " + jobName
+ " Exception: " + 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{
@Autowired
public SchedulerManager myScheduler;
@RequestMapping(value = "/job2",method = RequestMethod.GET)
public String scheduleJob2()
{
try {
myScheduler.startJob("0/5 * * * * ?","job2","group2", ScheduledJob.class);//每五秒執行一次
//0 0/5 14 * * ?在每天下午2點到下午2:55期間的每5分鐘觸發
//0 50 14 * * ?在每天下午2點50分5秒執行一次
// 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定時任務調度的使用,就介紹到這裏。