SpringBoot集成Quartz(解决@Autowired空指针Null问题即依赖注入的属性为null)
使用spring-boot作为基础框架，其理念为零配置文件，所有的配置都是基于注解和暴露bean的方式。
Quartz的4个核心概念：
1、Job
表示一个工作，要执行的具体内容。此接口中只有一个方法
void execute(JobExecutionContext context)
2、JobDetail
JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。
3、Trigger代表一个调度参数的配置，什么时候去调。
4、Scheduler代表一个调度容器，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。
集成Quartz的步骤如下：
1、POM中引入依赖
<!-- quartz --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>${quartz.version}</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>${quartz.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${spring-context-support.version}</version> </dependency>
注意版本号
<spring-context-support.version>4.1.6.RELEASE</spring-context-support.version> <quartz.version>2.2.3</quartz.version>
2、修改quartz.properties文件（可以存放在resources下，也可以存放未固定路径）
我们这里将使用基于DB的作业存储
# Default Properties file for use by StdSchedulerFactory # to create a Quartz Scheduler Instance, if a different # properties file is not explicitly specified. # # StdSchedulerFactory使用quartz.properties 创建一个Quartz Scheduler实例 # 参数请参考：http://www.quartz-scheduler.org/documentation/quartz-2.x/configuration/ # # Quartz提供两种基本作业存储类型 # --->第一种类型叫做RAMJobStore: # 最佳的性能，因为内存中数据访问最快 # 不足之处是缺乏数据的持久性，当程序路途停止或系统崩溃时，所有运行的信息都会丢失 # --->第二种类型叫做JDBC作业存储: # 通过调整其quartz.properties属性文件，持久化任务调度信息 # 使用数据库保存任务调度信息后，即使系统崩溃后重新启动，任务的调度信息将得到恢复 # #============================================================================ # 基础配置 #============================================================================ # 设置调度器的实例名(instanceName) 和实例ID (instanceId) org.quartz.scheduler.instanceName: DefaultQuartzScheduler #如果使用集群，instanceId必须唯一，设置成AUTO org.quartz.scheduler.instanceId = AUTO org.quartz.scheduler.rmi.export: false org.quartz.scheduler.rmi.proxy: false org.quartz.scheduler.wrapJobExecutionInUserTransaction: false #============================================================================ # 调度器线程池配置 #============================================================================ org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool # 指定多少个工作者线程被创建用来处理 Job org.quartz.threadPool.threadCount: 10 # 设置工作者线程的优先级（最大值10，最小值1，常用值5） org.quartz.threadPool.threadPriority: 5 # 加载任务代码的ClassLoader是否从外部继承 org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true org.quartz.jobStore.misfireThreshold: 60000 #============================================================================ # Configure JobStore 作业存储配置 #============================================================================ # 默认配置，数据保存到内存(调度程序信息是存储在被分配给JVM的内存里面，运行速度快) #org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore # 持久化配置（存储方式使用JobStoreTX，也就是数据库） org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate #使用自己的配置文件 org.quartz.jobStore.useProperties:true #数据库中quartz表的表名前缀 org.quartz.jobStore.tablePrefix:qrtz_ org.quartz.jobStore.dataSource:qzDS #是否使用集群（如果项目只部署到 一台服务器，就不用了） org.quartz.jobStore.isClustered = true #============================================================================ # Configure Datasources 配置数据源 #============================================================================ org.quartz.dataSource.qzDS.driver:oracle.jdbc.OracleDriver org.quartz.dataSource.qzDS.URL:jdbc:oracle:thin:@10.132.81.134:1521:dsdb1 org.quartz.dataSource.qzDS.user:masmf org.quartz.dataSource.qzDS.password:masmf org.quartz.dataSource.qzDS.maxConnections:10
注意：如果项目中同时运行了基于内存的任务调度(RAMJobStore)和基于数据库的任务调度(JobStoreTX)且属性文件中配置org.quartz.scheduler.instanceName=DefaultQuartzScheduler时，任务永远不会被写入到数据库，因为数据库的schedualer已被内存的schedualer覆盖
原因参考：
QUARTZ任务不写入数据库分析
3、自定义JobFactory
首先解释一个常见的困境：Spring容器可以管理Bean，但是Quartz的job是自己管理的，如果在Job中注入Spring管理的Bean，需要先把Quartz的Job也让Spring管理起来，因此，我们需要重写JobFactory，详细的源码分析，请参考：
Quartz与Spring集成 Job如何自动注入Spring容器托管的对象
Quartz入门实例14-让Quartz的Job使用Spring注入的Bean
import org.quartz.spi.TriggerFiredBundle; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.AutowireCapableBeanFactory; import org.springframework.scheduling.quartz.AdaptableJobFactory; import org.springframework.stereotype.Component; /** * Description: 自定义JobFactory,使用Spring容器管理的Quartz的Bean(Job) * <p/> * AdaptableJobFactory是Spring提供的SchedulerFactoryBean的默认实例化工厂，将由直接实例化Job，没有被Spring管理 * User: lishaohua * Date: 2017/11/15 13:54 */ @Component public class MyJobFactory extends AdaptableJobFactory { /** * AutowireCapableBeanFactory接口是BeanFactory的子类 * 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例 * 具体请参考：http://blog.csdn.net/iycynna_123/article/details/52993542 */ @Autowired private AutowireCapableBeanFactory capableBeanFactory; /** * 创建Job实例 * * @param bundle * @return * @throws Exception */ @Override protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception { // 实例化对象 Object jobInstance = super.createJobInstance(bundle); // 进行注入（Spring管理该Bean） capableBeanFactory.autowireBean(jobInstance); //返回对象 return jobInstance; } }
4、配置schedulerFactoryBean
Spring为了能集成Quartz，特意提供了管理Quartz的schedulerFactoryBean，必须配置，具体代码如下：
import org.quartz.ee.servlet.QuartzInitializerListener; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.config.PropertiesFactoryBean; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.FileSystemResource; import org.springframework.scheduling.quartz.SchedulerFactoryBean; import javax.sql.DataSource; import java.io.IOException; import java.util.Properties; /** * Description: Quartz调度配置 * <p/> * User: lishaohua * Date: 2017/11/14 10:27 */ @Configuration //类似xml中的<beans>标签,一般和@bean注解一起使用来配置一个Bean,让Spring来管理它的生命周期 @ConfigurationProperties(prefix = "quartz.config")//把配置文件的信息自动装配到Bean上(以quartz.config前缀的) public class SchedulerConfig { /** * 配置文件路径 */ private String propertiesPath;//quartz.config.propertiesPath @Autowired private MyJobFactory myJobFactory; /** * 配置SchedulerFactoryBean * * @param dataSource 数据源 * @return * @throws IOException */ @Bean //将一个方法产生为Bean并交给Spring容器管理(@Bean只能用在方法上) public SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) throws IOException { //Spring提供SchedulerFactoryBean为Scheduler提供配置信息,并被Spring容器管理其生命周期 SchedulerFactoryBean factory = new SchedulerFactoryBean(); //启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了 factory.setOverwriteExistingJobs(true); // 延时启动(秒) factory.setStartupDelay(20); //设置quartz的配置文件 factory.setQuartzProperties(quartzProperties()); //设置自定义Job Factory，用于Spring管理Job bean factory.setJobFactory(myJobFactory); return factory; } /** * 加载Quartz配置 * * @return * @throws IOException */ @Bean public Properties quartzProperties() throws IOException { //使用Spring的PropertiesFactoryBean对属性配置文件进行管理 PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean(); //注意：quartz的配置文件从指定系统目录中获取，而不是从classpath中获取 //propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties")); propertiesFactoryBean.setLocation(new FileSystemResource(propertiesPath));
//重要：保证其初始化 propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject(); } /** * 初始化Quartz监听器,让Spring boot启动时初始化Quartz * --web工程中，一般在web.xml中设置如下： * <listener> * <listener-class>org.quartz.ee.servlet.QuartzInitializerListener</listener-class> * </listener> * Quartz就会随着web容器启动，加载调度任务 * * @return */ @Bean public QuartzInitializerListener executorListener() { return new QuartzInitializerListener(); } //========get/set method============================ public String getPropertiesPath() { return propertiesPath; } public void setPropertiesPath(String propertiesPath) { this.propertiesPath = propertiesPath; } }
注意两点：
a、加载quartz.properties使用的是Spring的PropertiesFactoryBean，我将该文件存放在固定磁盘目录，因此使用了
new FileSystemResource(propertiesPath)
如果你的文件存放在resources下，请从classpath下加载：new ClassPathResource("/quartz.properties")
b、我将quartz.properties路径配置在SpringBoot的yml中，因此使用了@ConfigurationProperties，不需要请移除，如果使用请注意get/set方法不能少
c、注意，一定要先执行propertiesFactoryBean.afterPropertiesSet();然后propertiesFactoryBean.getObject();
5、初始化DB
不解释，直接从quartz官网下载并初始化到你的DB中
6、编写定时任务
直接上代码：
@Component public class UpdateCEBKeyJob extends QuartzJobBean { //日志记录 private static Logger logger = LoggerFactory.getLogger(UpdateCEBKeyJob.class); //ECB密钥更新 @Autowired private KeyOperationService keyOperationService; /** * 执行Job * * @param jobExecutionContext * @throws JobExecutionException */ @Override protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException { boolean updateFlag = false; logger.info("-------------------update ECB key job begin:{} ----------------", DateTimeUtil.getCurrentDateTime()); //===============01.正常执行任务====================== try { /* KeyOperationService keyOperationService = ContextWrapper .getBean("keyOperationService", KeyOperationService.class);*/ updateFlag = keyOperationService.updateCEBKey(); } catch (Exception e) { logger.error("更新光大密钥失败！", e); } //===============02.执行结果判定====================== if (!updateFlag) {//如果更新失败，创建一次性任务再次执行（Job仍然是当前class） createJob(2); } logger.info("-------------------update ECB key job end:{} ----------------", DateTimeUtil.getCurrentDateTime()); }
7、单元测试 或 手工添加任务的Controller
单元测试不解释，如果使用了界面，编写的Controller如下
import com.shengpay.mf.constant.ServerErrorEnum; import com.shengpay.mf.exception.ServerException; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperation; import org.quartz.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.quartz.SchedulerFactoryBean; import org.springframework.stereotype.Controller; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestMethod; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.ResponseBody; import javax.servlet.http.HttpServletRequest; import java.util.HashMap; import java.util.Map; /** * Description: 定时任务 管理 * <p/> * User: lishaohua * Date: 2017/11/14 13:22 */ @Controller @Api("定时任务管理")//描述类的作用(Swagger注解) public class JobController { private static Logger logger = LoggerFactory.getLogger(JobController.class); /*@Autowired private SchedulerFactoryBean schedulerFactoryBean;*/ @Autowired private Scheduler scheduler; /** * 添加定时任务 * * @param request * @param jobClassName * @param jobGroupName * @param cronExpression * @return */ @ApiOperation("添加定时任务")//描述方法的作用(Swagger注解) @RequestMapping(value = "/addJob", method = {RequestMethod.POST}) @ResponseBody public Map<String, String> addJob(HttpServletRequest request, @RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName, @RequestParam(value = "cronExpression") String cronExpression) { Map<String, String> returnData = new HashMap<String, String>(); try { /** * 构建JobDetail(表示一个具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容) */ JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass())//工作项1：Job类 .withIdentity(jobClassName, jobGroupName)//工作项2：job名以及所属组 .build();//构建 /** * 构建触发器Trigger(调度参数的配置，代表何时触发该任务) */ //通过cron表达式构建CronScheduleBuilder CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression); //构建CronTrigger触发器 CronTrigger trigger = TriggerBuilder.newTrigger() .withIdentity(jobClassName, jobGroupName) //工作项1：job名以及所属组 .withSchedule(scheduleBuilder) //工作项2：指定调度参数 .build();//构建 /** *构建调度容器(当Trigger与JobDetail组合，就可以被Scheduler容器调度了) * 一个调度容器中可以注册多个JobDetail和Trigger。 */ //获得调度容器 //Scheduler scheduler = getCurrentScheduler(); //注册调度任务 scheduler.scheduleJob(jobDetail, trigger); //启动任务 scheduler.start(); returnData.put("msg", "添加调度任务成功"); } catch (SchedulerException e) { logger.error("构建调度任务异常", e); returnData.put("msg", "添加调度任务异常：" + e.getMessage()); } catch (ServerException e) { logger.error("内部异常", e); returnData.put("msg", "添加调度任务异常：" + e.getMessage()); } catch (Exception e) { logger.error("添加调度任务异常", e); returnData.put("msg", "添加调度任务异常：" + e.getMessage()); } return returnData; } @ApiOperation("暂停定时任务")//描述方法的作用(Swagger注解) @RequestMapping(value = "/pauseJob", method = {RequestMethod.POST}) @ResponseBody public Map<String, String> pauseJob(HttpServletRequest request, @RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName) { Map<String, String> returnData = new HashMap<String, String>(); try { //获得调度容器 //Scheduler scheduler = getCurrentScheduler(); //JobKey定义了job的名称和组别 JobKey jobKey = JobKey.jobKey(jobClassName, jobGroupName); //暂停任务 scheduler.pauseJob(jobKey); returnData.put("msg", "暂停调度任务成功"); } catch (SchedulerException e) { logger.error("暂停调度任务异常", e); returnData.put("msg", "暂停调度任务异常：" + e.getMessage()); } catch (Exception e) { logger.error("暂停调度任务异常", e); returnData.put("msg", "暂停调度任务异常：" + e.getMessage()); } return returnData; } @ApiOperation("继续定时任务")//描述方法的作用(Swagger注解) @RequestMapping(value = "/resumeJob", method = {RequestMethod.POST}) @ResponseBody public Map<String, String> resumeJob(HttpServletRequest request, @RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName) { Map<String, String> returnData = new HashMap<String, String>(); try { //获得调度容器 //Scheduler scheduler = getCurrentScheduler(); //JobKey定义了job的名称和组别 JobKey jobKey = JobKey.jobKey(jobClassName, jobGroupName); //继续任务 scheduler.resumeJob(jobKey); returnData.put("msg", "继续调度任务成功"); } catch (SchedulerException e) { logger.error("继续调度任务异常", e); returnData.put("msg", "继续调度任务异常：" + e.getMessage()); } catch (Exception e) { logger.error("继续调度任务异常", e); returnData.put("msg", "继续调度任务异常：" + e.getMessage()); } return returnData; } /** * 更新定时任务： * --传入的triggerKey有与之匹配的 * --旧触发器的触发时间没有完成 * * @param request * @param jobClassName * @param jobGroupName * @param cronExpression * @return */ @ApiOperation("更新定时任务")//描述方法的作用(Swagger注解) @RequestMapping(value = "/rescheduleJob", method = {RequestMethod.POST}) @ResponseBody public Map<String, String> rescheduleJob(HttpServletRequest request, @RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName, @RequestParam(value = "cronExpression") String cronExpression) { Map<String, String> returnData = new HashMap<String, String>(); try { //获得调度容器 //Scheduler scheduler = getCurrentScheduler(); //构建旧的TriggerKey TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName); //通过cron表达式构建CronScheduleBuilder CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression); //从调度容器中获取旧的CronTrigger CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey); //更新CronTrigger trigger = trigger.getTriggerBuilder() .withIdentity(triggerKey) //工作项1：job名以及所属组 .withSchedule(scheduleBuilder) //工作项2：指定调度参数 .build();//构建 //更新调度任务 scheduler.rescheduleJob(triggerKey, trigger); returnData.put("msg", "更新调度任务成功"); } catch (SchedulerException e) { logger.error("更新调度任务异常", e); returnData.put("msg", "更新调度任务异常：" + e.getMessage()); } catch (ServerException e) { logger.error("内部异常", e); returnData.put("msg", "更新调度任务异常：" + e.getMessage()); } catch (Exception e) { logger.error("更新调度任务异常", e); returnData.put("msg", "更新调度任务异常：" + e.getMessage()); } return returnData; } @ApiOperation("删除定时任务")//描述方法的作用(Swagger注解) @RequestMapping(value = "/removeJob", method = {RequestMethod.POST}) @ResponseBody public Map<String, String> removeJob(HttpServletRequest request, @RequestParam(value = "jobClassName") String jobClassName, @RequestParam(value = "jobGroupName") String jobGroupName) { Map<String, String> returnData = new HashMap<String, String>(); try { //获得调度容器 //Scheduler scheduler = getCurrentScheduler(); //TriggerKey定义了trigger的名称和组别 TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName); //暂停触发器 scheduler.resumeTrigger(triggerKey); //暂停触发器 scheduler.unscheduleJob(triggerKey); //移除任务 scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName)); returnData.put("msg", "删除调度任务成功"); } catch (SchedulerException e) { logger.error("删除调度任务异常", e); returnData.put("msg", "删除调度任务异常：" + e.getMessage()); } catch (Exception e) { logger.error("删除调度任务异常", e); returnData.put("msg", "删除调度任务异常：" + e.getMessage()); } return returnData; } /** * 获得调度容器Scheduler * * @return * @throws SchedulerException */ /*private Scheduler getCurrentScheduler() throws SchedulerException { // 实例化Quartz默认的调度器工厂SchedulerFactory //SchedulerFactory sf = new StdSchedulerFactory(); // 获得调度容器 //Scheduler sched = sf.getScheduler(); //return sched; //Scheduler sched = schedulerFactoryBean.getScheduler(); //return sched; }*/ /** * 获得指定的类实例 * * @param classname * @return * @throws ServerException */ private Job getClass(String classname) throws ServerException { Job baseJob = null; try { //加载参数指定的类 Class<?> classTmp = Class.forName(classname); //实例化 baseJob = (Job) classTmp.newInstance(); } catch (ClassNotFoundException e) { logger.error("找不到指定的类", e); throw new ServerException(ServerErrorEnum.INTERNAL_ERROR); } catch (InstantiationException e) { logger.error("实例化类失败", e); throw new ServerException(ServerErrorEnum.INTERNAL_ERROR); } catch (IllegalAccessException e) { logger.error("实例化类失败", e); throw new ServerException(ServerErrorEnum.INTERNAL_ERROR); } return baseJob; } }
注意：
在controller层直接注入Scheduler即可，如下：
@Autowired private Scheduler scheduler;
然后方法中直接调用
//注册调度任务 scheduler.scheduleJob(jobDetail, trigger); //启动任务 scheduler.start();
或者注入声明的
@Autowired private SchedulerFactoryBean schedulerFactoryBean;
然后方法中先执行schedulerFactoryBean.getScheduler()获得scheduler
//获得调度容器 Scheduler scheduler = schedulerFactoryBean.getScheduler(); //注册调度任务 scheduler.scheduleJob(jobDetail, trigger); //启动任务 scheduler.start();
但是，一定要注意，千万不要自己直接去new StdSchedulerFactory()，默认的schedulerFactoryBean或注入的scheduler都是被StdScheduler，
new StdSchedulerFactory()获得的Scheduler将无法被Spring管理，如下代码：
// 实例化Quartz默认的调度器工厂SchedulerFactory SchedulerFactory sf = new StdSchedulerFactory(); // 获得调度容器 Scheduler sched = sf.getScheduler();
创建的任务区别如下：
===================================华丽的分割线======================================
如果不需要让Spring管理quartz生成的job，则每个job作为普通的Bean对象，可以直接通过applicationContext对象直接getBean
代码如下
import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.stereotype.Component; /** * Description: applicationContext工具类 * <p/> * User: lishaohua * Date: 2017/11/16 13:48 */ @Component public class ApplicationContextUtil implements ApplicationContextAware { /** * 上下文对象实例 */ private static ApplicationContext appContext; /** * Spring自动注入applicationContext对象 * -- 因此该Bean必须@Component被Spring scan发现 * * @param applicationContext * @throws BeansException */ @Override public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { appContext = applicationContext; } /** * 获得applicationContext * @return */ public static ApplicationContext getAppContext() { return appContext; } /** * 根据name获取Bean * * @param name * @return */ public static Object getBean(String name) { return getAppContext().getBean(name); } /** * 根据class获取Bean * * @param clazz * @param <T> * @return */ public static <T> T getBean(Class<T> clazz) { return getAppContext().getBean(clazz); } /** * 根据name、class获得Bean * * @param name * @param clazz * @param <T> * @return */ public static <T> T getBean(String name, Class<T> clazz) { return getAppContext().getBean(name, clazz); } }
通过DB查询已添加的任务，查询SQL如下：
select TO_CHAR(t.next_fire_time / (1000 * 60 * 60 * 24) + TO_DATE('1970-01-01 08:00:00', 'YYYY-MM-DD HH24:MI:SS'), 'YYYY-MM-DD HH24:MI:SS') next_fire_datetime, t.* from qrtz_triggers t;
查询效果如图
参考：
如何获取SpringBoot项目的applicationContext对象
参考文章：
https://www.cnblogs.com/javanoob/p/springboot_schedule.html
https://www.cnblogs.com/softidea/p/6073495.html
http://blog.csdn.net/magic_best/article/details/50158125
http://blog.csdn.net/iycynna_123/article/details/52993542
http://www.jianshu.com/p/b460171c57ea
