Spring Boot定时任务-SpringBoot整合Quartz

如何通过SpringBoot整合Quartz框架,我们首先去创建一个项目,接下来我们需要在pom文件里添加坐标,

我们在使用SpringBoot整合Quartz的时候,需要添加哪些坐标呢,我们来看一下,在这里我们需要添加三个坐标,

第一个是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>

我们在SpringBoot整合Quartz的时候,把日志记录的jar包去掉,一个exclusions就可以了,因为这个已经在WEB启动器里面包含了,

第二个我们还得去导入spring-context-support 的jar包

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
</dependency>

这个jar包我们之前用过,就是用Spring自带的Schedule,用它去做定时任务的时候,其实我们现在使用SpirngBoot去整合

Quartz的时候,SpringBoot对于Quartz的支持,仍然需要spring-context-support这个jar包,Spring-tx,事务的jar包

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
</dependency>

我们在Quartz当中呢,把这个jar包拿过来,在这里把这三个添加进来,修改pom文件,添加坐标,第一个我们修改完毕以后呢,

接下来我们就可以去做我们的定时任务了,我们还是先去创建一个Job的任务类,我把它放到一个叫Quartz的包下,

/**
 * Job类
 */
public class QuartzDemo2 implements Job {

	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		System.out.println("Execute2...."+new Date());
	}

}

需要让他去实现一个Job接口,这个是我们的任务类,我们任务调用会触发的一个方法,我们这里打印一句话,

有了任务类以后呢,有了任务类以后呢,接下来我们就来编写一个在SPRINGBoot当中,Quartz的配置类,那么在这个配置

类当中呢,我们就要去完成SpringBoot对于Quartz的一些配置信息,既然是配置类,还有一个@Configuration的注解,

在这里我要提供三个方法,这三个方法分别是干嘛的呢,其实就是使用Quartz基本的实现,第一个是创建Job对象,第二步

就是创建Trigger对象,然后第三步就是创建我们的Scheduler对象,我们接下来看,这每一个步骤该怎么去做,我们先来看

第一步,创建Job对象,要用到一个@Bean标签,然后在这里要提供一个方法,这个方法要返回一个JobDetailFactoryBean

对象,然后我们起个名,这个名叫什么都行,然后在这个方法当中呢,我们要去创建JobDetailFactoryBean对象,最后我们的

方法肯定是返回这个factory对象,既然我们来看一下,在这个对象当中,怎么去关联我们已定义的Job,现在Job是类,我怎么把它

实例化出来,怎么关联他呢,在我们的方法当中,关联我们自己的Job类,factory下面有一个方法叫setJobClass,在这里把我们的

Job类的模板给他,然后将我们的factory返回,这样就完成了一个Job实例化的工作,

/**
 * 1.创建Job对象
 */
@Bean
public JobDetailFactoryBean jobDetailFactoryBean(){
	JobDetailFactoryBean factory = new JobDetailFactoryBean();
	//关联我们自己的Job类
	factory.setJobClass(QuartzDemo2.class);
	return factory;
}

第二步我们来创建Trigger,这种Trigger也是分为两种,一种是简单的Trigger,还有一个是cron的Trigger,先来创建一个简单的

Trigger,我们用的是SimpleTriggerFactoryBean,我们需要这个方法返回一个SimpleTriggerFactoryBean的返回值,

然后这个方法名叫什么都可以,在这个对象当中呢,就完成一个Trigger的实例,Trigger的创建,首先我肯定要先去new这个对象,

最后也是返回这个factory,然后我们在这个对象下,怎么去关联我们的JobDetailFactoryBean,我们不是已经把Job类

和JobDetail类关联了吗,那我们的Trigger也就是什么时间做,做什么做关联,所以我这个方法需要一个入参,

这个入参的类型就是我们返回返回的类型,然后在这里,我们通过SimpleTriggerFactoryBean对象,调他的一个方法,

setJobDetail,那么这个job在哪儿呢,是不是在jobDetailFactoryBean里面放的呢,我们用入参来getObject,

这样就关联了我们的JobDetail对象,除了关联这个对象以外,Trigger是要设置一个触发的时间

的,那我们来看怎么来设置它的触发时间,在这里我们就用他的一个方法,叫setRepeatInterval,这个方法里需要一个Long型的参数,

这个Long型的参数是什么呢,其实就是一个毫秒数,这里我们加一个说明,该参数表示一个执行的毫秒数,他的单位是毫秒,比如我们还是

让他以两秒的间隔执行我们的任务,我们这里给一个2000,这里只是表示他不停的重复,除此之外我们还可以设置他的重复次数,比如我们

之前再讲简单案例的时候,在这里我们也可以设置重复的次数,这个叫setRepeatCount,执行5次,重复4次,这个是设置重复次数,

/**
 * 2.创建Trigger对象
 * 简单的Trigger
 */
@Bean
public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
	SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
	//关联JobDetail对象
	factory.setJobDetail(jobDetailFactoryBean.getObject());
	//该参数表示一个执行的毫秒数
	factory.setRepeatInterval(2000);
	//重复次数
	factory.setRepeatCount(5);
	return factory;
}

创建的是一个简单的Trigger,其实第三步就是创建Scheduler对象的,还是用一个@Bean,然后这里会提供一个方法,这个方法会返回一个

SchedulerFactoryBean,所以他们都会返回一个什么factoryBean,这里我们给他起一个名字,这个方法叫什么都行,我们之前讲过

Scheduler的作用,会帮我们的Job,还有Trigger整合到一起,那我们现在已经完成了Job到Trigger的一个整合,我们已经做了一个关联,

我们就把Trigger关联到Scheduler的对象当中,所以我们这个方法仍然需要一个入参,这个入参类型就是cronTriggerFactoryBean,

在这里我们仍然是创建SchedulerFactoryBean的对象,最后我肯定也是返回这个factory,然后=我们在这里如何去关联呢,

第一个我们先关联Trigger,关联Trigger我们就是用方法setTriggers,是不是在SimpleTriggerFactoryBean这里放着呢,

通过入参调用getObject,这样就把工厂的TriggerBean对象取出来,放到Scheduler的对象当中,

然后接下来我们需不需要在这里去启动呢,我们原来在写这个案例的时候知道,我设置完Scheduler的时候,

要用到Scheduler的对象去启动,这里很显然不用了,这样我们一个整合的过程就完成了,

那怎么启动呢,这里还要回到我们的启动类里面去说

@Bean
public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	//关联trigger
	factory.setTriggers(simpleTriggerFactoryBean.getObject());
	
	return factory;
}

这里是编写Quartz的配置类,然后我们怎么去启动呢,在启动类当中,SpringBoot整合Quartz的案例,我们仍然要

用@EnableScheduling的注解,这样才能去启动我们的Quartz

@SpringBootApplication
@EnableScheduling
public class QuartzApp {

	public static void main(String[] args) {
		SpringApplication.run(QuartzApp.class, args);
	}
}

修改启动类,那么其实我们使用SpringBoot去整合Quartz,已经整合完毕了,我们来测试一下,从启动类开始启动,然后我们观察

控制台,以两秒的间隔去重复,然后我们定的是5次,我们给的是重复五次

factory.setRepeatCount(5);

重复五次,然后再加上1次就是6次,没有问题的,以上就是使用SpringBoot整合Quartz的一个案例,但是这里注意一下,

现在我们用的Trigger呢,简单的Trigger,如果还想用cron,来定义这个Trigger,我们可以在这里去实现一下,

/**
 * Cron Trigger
 */
@Bean
public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
	CronTriggerFactoryBean factory = new CronTriggerFactoryBean();
	factory.setJobDetail(jobDetailFactoryBean.getObject());
	//设置触发时间
	factory.setCronExpression("0/2 * * * * ?");
	return factory;
}

这个是Cron Trigger,我们还是提供一个bean注解,然后在里面加一个方法,现在返回的就是一个CronTriggerFactoryBean,

这个是比较简单的,方法名还是叫cronTriggerFactoryBean,然后在这个方法里仍然需要一个jobDetailFactoryBean,

那么在这个方法里肯定是需要一个CronTriggerFactoryBean的,然后这里肯定是返回factory,然后我们还是要设置

job的关联,关联Job对象,然后设置一个时间,怎么设置呢,factory.setJobDetail(jobDetailFactoryBean.getObject()),

然后还是设置触发时间,这里通过setCronExpression,cron的表达式,那么我还是让他每两秒去执行一次,

@Bean
public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	//关联trigger
	factory.setTriggers(cronTriggerFactoryBean.getObject());
	
	return factory;
}

我们看一下,每两秒,没有问题,第一次他隔了一秒,其实它第一次计时的时候,第一次时间和第二次时间多多少少有些

误差,但是问题不大,以上就是SpringBoot整合Quartz的一个实现,还是比较简单的

<project xmlns="http://maven.apache.org/POM/4.0.0" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
	http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.learn</groupId>
  <artifactId>spring-boot-quartz</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.12.RELEASE</version>
  </parent>
  
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
  
  <dependencies>
  	<!-- springBoot的启动器 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- 添加Scheduled坐标 -->
    <!-- <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context-support</artifactId>
    </dependency> -->
	<!-- Quartz坐标 -->
	<!-- <dependency>
		<groupId>org.quartz-scheduler</groupId>
		<artifactId>quartz</artifactId>
		<version>2.2.1</version>
	</dependency> -->
	<!-- 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>
	<!-- 添加Scheduled坐标 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-context-support</artifactId>
	</dependency>
	<!-- Sprng tx 坐标 -->
	<dependency>
		<groupId>org.springframework</groupId>
		<artifactId>spring-tx</artifactId>
	</dependency>
  </dependencies>
</project>

package com.learn.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import com.learn.quartz.QuartzDemo2;

/**
 * Quartz配置类
 * @author Leon.Sun
 *
 */
@Configuration
public class QuartzConfig {

	
	/**
	 * 1.创建Job对象
	 */
	@Bean
	public JobDetailFactoryBean jobDetailFactoryBean(){
		JobDetailFactoryBean factory = new JobDetailFactoryBean();
		//关联我们自己的Job类
		factory.setJobClass(QuartzDemo2.class);
		return factory;
	}
	
	/**
	 * 2.创建Trigger对象
	 * 简单的Trigger
	 */
//	@Bean
//	public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
//		SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
//		//关联JobDetail对象
//		factory.setJobDetail(jobDetailFactoryBean.getObject());
//		//该参数表示一个执行的毫秒数
//		factory.setRepeatInterval(2000);
//		//重复次数
//		factory.setRepeatCount(5);
//		return factory;
//	}
	
	/**
	 * Cron Trigger
	 */
	@Bean
	public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
		CronTriggerFactoryBean factory = new CronTriggerFactoryBean();
		factory.setJobDetail(jobDetailFactoryBean.getObject());
		//设置触发时间
		factory.setCronExpression("0/2 * * * * ?");
		return factory;
	}
	
//	@Bean
//	public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
//		SchedulerFactoryBean factory = new SchedulerFactoryBean();
//		//关联trigger
//		factory.setTriggers(simpleTriggerFactoryBean.getObject());
//		
//		return factory;
//	}
	
	/**
	 * 3.创建Scheduler对象
	 */
	@Bean
	public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		//关联trigger
		factory.setTriggers(cronTriggerFactoryBean.getObject());
		
		return factory;
	}
}

package com.learn;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

/**
 * 
 *spring Boot 整合Quartz案例
 *
 */
@SpringBootApplication
@EnableScheduling
public class QuartzApp {

	public static void main(String[] args) {
		SpringApplication.run(QuartzApp.class, args);
	}
}