SpringBoot整合Quartz定时

时间 2020-03-01

原文原文链接

背景
最近在作项目，项目中有个需求：须要使用定时任务，这个定时任务须要即时生效。
查看Quartz官网以后发现：Quartz提供两种基本做业存储类型：html

RAMJobStore ：RAM也就是内存，默认状况下Quartz会将任务调度存在内存中，这种方式性能是最好的，由于内存的速度是最快的。很差的地方就是数据缺少持久性，但程序崩溃或者从新发布的时候，全部运行信息都会丢失
JDBC做业存储：存到数据库以后，能够作单点也能够作集群，当任务多了以后，能够统一进行管理。关闭或者重启服务器，运行的信息都不会丢失。缺点就是运行速度快慢取决于链接数据库的快慢。
因此决定采用 JDBC做业存储的方式。java

为何须要持久化？
之后能够作集群。
任务能够进行管理，随时中止、暂停、修改任务。
你应该了解的概念
由于以前接触过quartz这个任务调度框架，因此对quartz有必定的了解，quartz三要素：Scheduler、Trigger、JobDetai&Job。
忽然想起来，以前写过介绍-。- 本身都忘了，贴上地址，须要的童鞋能够先去了解下：
https://blog.csdn.net/bicheng4769/article/details/81097305mysql

SpringBoot集成Quartz
咱们也能够本身去将quartz和springBoot整合在一块儿，其实说是springBoot还不如说是sping，由于咱们没有用到spirngboot的相关的快捷方式。
若是童鞋们想快速集成Quartz，马上看到效果的话，能够直接往下翻，直接看SpirngBoot自带的Quartz插件。但我建议你们仍是从spring整合Quartz开始，懂的原理，方有收获。web

Quartz初始化表
若是须要作持久化的话，数据确定是要存在数据库的，那么到底存在哪些表呢？其实官网文档也跟咱们讲过了，地址以下：
http://www.quartz-scheduler.org/documentation/quartz-2.2.x/tutorials/tutorial-lesson-09.html
其中有句话：spring

JDBCJobStore works with nearly any database, it has been used widely with Oracle, PostgreSQL, MySQL, MS SQLServer, HSQLDB, and DB2. To use JDBCJobStore, you must first create a set of database tables for Quartz to use. You can find table-creation SQL scripts in the “docs/dbTables” directory of the Quartz distribution.sql

荣老夫这个四级的水平给大家翻译下：
大概就是支持这么多的数据库类型。若是你要使用JDBCJoBStore的话，你先要建立一些表，这些表在 “doc/dbTables”里面。“doc/dbTables” 在哪儿呢？其实都在源码里面，直接到官网下下来就好了。数据库

Spring整合Quartz
pom文件加入相关jar
相关配置文件（不论是properties 仍是yml。采用JDBC存储）
业务逻辑层中使用。
pom文件
以下所示：api

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>

<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>

</dependency>

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.1</version>
</dependency>
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.2</version>
</dependency>

<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.10</version>
</dependency>
</dependencies>
对应的properties 文件
#使用本身的配置文件
org.quartz.jobStore.useProperties:true浏览器

#默认或是本身更名字都行
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
#若是使用集群，instanceId必须惟一，设置成AUTO
org.quartz.scheduler.instanceId = AUTOspringboot

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#是否使用集群（若是项目只部署到一台服务器，就不用了）
org.quartz.jobStore.isClustered = false
org.quartz.jobStore.clusterCheckinInterval=20000
org.quartz.jobStore.tablePrefix = qrtz_
org.quartz.jobStore.dataSource = myDS

#配置数据源
#数据库中quartz表的表名前缀
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/aipyun?serverTimezone=GMT&characterEncoding=utf-8
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = root123
org.quartz.dataSource.myDS.maxConnections = 5
核心QuartzConfiguration类：
ackage com.cj.config;

import org.quartz.Scheduler;
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**
* 描述： quartz 配置信息
*
* @author caojing
* @create 2018-12-24-16:47
*/
@Configuration
public class QuartzConfiguration {
@Autowired
private JobFactory jobFactory;

@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setJobFactory(jobFactory);
// 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
schedulerFactoryBean.setOverwriteExistingJobs(true);
//延长启动
schedulerFactoryBean.setStartupDelay(1);
//设置加载的配置文件
schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
return schedulerFactoryBean;
}

@Bean
public Scheduler scheduler() {
return schedulerFactoryBean().getScheduler();
}
}
这其中咱们把2个类的初始化移到了IOC中，由于以前Quartz的实例化是本身去控制的，为何要这么作后面会有讲到。
一个是SchedulerFactoryBean类，这个类其实就是以前xml配置中的SchedulerFactoryBean。附上以前xml配置以下（这里不须要配置，springboot建议咱们少用xml配置）

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="oceanStatusCronTrigger"/>
</list>
</property>
</bean>
这个类我相信只要用过xml配置的人必定很熟悉，这是Quartz入口。同时也是spring 和Scheduler 关系的桥梁。以便在Spring容器启动后，Scheduler自动开始工做，而在Spring容器关闭前，自动关闭Scheduler。

JobFactory类
package com.cj.config;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
* 描述：
*
* @author caojing
* @create 2018-12-26-14:03
*/
@Component
public class JobFactory extends AdaptableJobFactory {

@Autowired
private AutowireCapableBeanFactory capableBeanFactory;

@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
// 调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
// 进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
这个类的做用就是讲Job的实例化交给IOC去进行。
其实问题在于：
Job对象的实例化过程是在Quartz中进行的，注入的实体类是在Spring容器当中的因此在job中没法注入Srping容器的实体类。
解决方案：将Job Bean也归入到Spring容器的管理之中，Spring容器天然可以为Job Bean自动装配好所需的依赖。
如何归入：Job的建立都是经过JobFactory建立的。官网解释为证：
https://www.quartz-scheduler.org/api/2.2.1/org/quartz/spi/JobFactory.html

A JobFactory is responsible for producing instances of Job classes.

翻译：JobFactory负责生成Job类的实例。
JobFactory 有2个实现类：AdaptableJobFactory 和 SimpleJobFactory。

自定义的工厂类 JobFactory 继承 AdaptableJobFactory 。
经过调用父类 AdaptableJobFactory 的方法createJobInstance来实现对Job的实例化。
在Job实例化完之后，再调用自身方法为建立好的Job实例进行属性自动装配并将其归入到Spring容器的管理之中。(经过AutowireCapableBeanFactory归入)。截胡~~~~
UploadTask 类：
package com.cj.quartzdemo;
import com.cj.controller.IndexController;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import java.util.Date;

/**
* 描述：
*
* @author caojing
* @create 2018-12-25-11:38
*/
@Component
@DisallowConcurrentExecution
public class UploadTask extends QuartzJobBean {
@Autowired
private IndexController indexController;
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println(new Date() + "任务开始------------------------------------");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(new Date() + "任务结束------------------------------------");
}
}

继承QuartzJobBean类，重写executeInternal方法。
附：DisallowConcurrentExecution 好比job执行10秒，任务是每隔5秒执行，加上这个注解，程序就会等10秒结束后再执行下一个任务。

indexController类：
package com.cj.controller;

import com.cj.quartzdemo.UploadTask;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;

/**
* 描述：
*
* @author caojing
* @create 2018-12-26-14:11
*/
@Controller
public class IndexController {
@Autowired
private Scheduler scheduler;

@RequestMapping(value = "/index", method = RequestMethod.GET)
public void index() throws SchedulerException {
//cron表达式
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/8 * * * * ?");
//根据name 和group获取当前trgger 的身份
TriggerKey triggerKey = TriggerKey.triggerKey("cj", "123");
CronTrigger triggerOld = null;
try {
//获取触发器的信息
triggerOld = (CronTrigger) scheduler.getTrigger(triggerKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
if (triggerOld == null) {
//将job加入到jobDetail中
JobDetail jobDetail = JobBuilder.newJob(UploadTask.class).withIdentity("cj", "123").build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("cj","123").withSchedule(cronScheduleBuilder).build();
//执行任务
scheduler.scheduleJob(jobDetail, trigger);
} else {
System.out.println("当前job已存在--------------------------------------------");
}
}
}

浏览器输入 http://localhost:8080/index 就能够看到数据库已经存储了咱们写的cron表达式和相应的类。
查看数据库表（qrtz_cron_triggers）附上截图：

至此，job 已经被咱们成功持久化到数据库。咱们来回顾下总体的一个流程。

pom文件添加对应的依赖。mysql数据库对应表的初始化。配置对应的properties将原来quartz控制的类的实例化交给spirng IOC控制。（对应的是核心QuartzConfiguration类和JobFactory类）业务逻辑层对job进行控制。总结其实思路整理一下，咱们发现过程其实仍是挺简单的，惟一可能有些困难的是对QuartzConfiguration类和JobFactory类的理解。这两个类也是整合的核心类。可是在springboot2.0以后，我发现了一个很神奇的starter。