SpringBoot集成Quartz(解决@Autowired空指针Null问题即依赖注入的属性为null)

importorg.quartz.spi.TriggerFiredBundle;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.config.AutowireCapableBeanFactory;
importorg.springframework.scheduling.quartz.AdaptableJobFactory;
importorg.springframework.stereotype.Component;

/**
*Description:自定义JobFactory,使用Spring容器管理的Quartz的Bean(Job)
*<p/>
*AdaptableJobFactory是Spring提供的SchedulerFactoryBean的默认实例化工厂，将由直接实例化Job，没有被Spring管理
*User:lishaohua
*Date:2017/11/1513:54
*/
@Component
publicclassMyJobFactoryextendsAdaptableJobFactory{

/**
*AutowireCapableBeanFactory接口是BeanFactory的子类
*可以连接和填充那些生命周期不被Spring管理的已存在的bean实例
*具体请参考：http://blog.csdn.net/iycynna_123/article/details/52993542
*/
@Autowired
privateAutowireCapableBeanFactorycapableBeanFactory;

/**
*创建Job实例
*
*@parambundle
*@return
*@throwsException
*/
@Override
protectedObjectcreateJobInstance(TriggerFiredBundlebundle)throwsException{
//实例化对象
ObjectjobInstance=super.createJobInstance(bundle);
//进行注入（Spring管理该Bean）
capableBeanFactory.autowireBean(jobInstance);
//返回对象
returnjobInstance;
}
}

importorg.quartz.ee.servlet.QuartzInitializerListener;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.config.PropertiesFactoryBean;
importorg.springframework.boot.context.properties.ConfigurationProperties;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
importorg.springframework.core.io.FileSystemResource;
importorg.springframework.scheduling.quartz.SchedulerFactoryBean;

importjavax.sql.DataSource;
importjava.io.IOException;
importjava.util.Properties;

/**
*Description:Quartz调度配置
*<p/>
*User:lishaohua
*Date:2017/11/1410:27
*/
@Configuration//类似xml中的<beans>标签,一般和@bean注解一起使用来配置一个Bean,让Spring来管理它的生命周期
@ConfigurationProperties(prefix="quartz.config")//把配置文件的信息自动装配到Bean上(以quartz.config前缀的)
publicclassSchedulerConfig{
/**
*配置文件路径
*/
privateStringpropertiesPath;//quartz.config.propertiesPath

@Autowired
privateMyJobFactorymyJobFactory;

/**
*配置SchedulerFactoryBean
*
*@paramdataSource数据源
*@return
*@throwsIOException
*/
@Bean//将一个方法产生为Bean并交给Spring容器管理(@Bean只能用在方法上)
publicSchedulerFactoryBeanschedulerFactoryBean(DataSourcedataSource)throwsIOException{
//Spring提供SchedulerFactoryBean为Scheduler提供配置信息,并被Spring容器管理其生命周期
SchedulerFactoryBeanfactory=newSchedulerFactoryBean();
//启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了
factory.setOverwriteExistingJobs(true);
//延时启动(秒)
factory.setStartupDelay(20);
//设置quartz的配置文件
factory.setQuartzProperties(quartzProperties());
//设置自定义JobFactory，用于Spring管理Jobbean
factory.setJobFactory(myJobFactory);
returnfactory;
}

/**
*加载Quartz配置
*
*@return
*@throwsIOException
*/
@Bean
publicPropertiesquartzProperties()throwsIOException{
//使用Spring的PropertiesFactoryBean对属性配置文件进行管理
PropertiesFactoryBeanpropertiesFactoryBean=newPropertiesFactoryBean();
//注意：quartz的配置文件从指定系统目录中获取，而不是从classpath中获取
//propertiesFactoryBean.setLocation(newClassPathResource("/quartz.properties"));
propertiesFactoryBean.setLocation(newFileSystemResource(propertiesPath));

//重要：保证其初始化
propertiesFactoryBean.afterPropertiesSet();

returnpropertiesFactoryBean.getObject();
}

/**
*初始化Quartz监听器,让Springboot启动时初始化Quartz
*--web工程中，一般在web.xml中设置如下：
*<listener>
*<listener-class>org.quartz.ee.servlet.QuartzInitializerListener</listener-class>
*</listener>
*Quartz就会随着web容器启动，加载调度任务
*
*@return
*/
@Bean
publicQuartzInitializerListenerexecutorListener(){
returnnewQuartzInitializerListener();
}

//========get/setmethod============================
publicStringgetPropertiesPath(){
returnpropertiesPath;
}

publicvoidsetPropertiesPath(StringpropertiesPath){
this.propertiesPath=propertiesPath;
}
}

@Component
publicclassUpdateCEBKeyJobextendsQuartzJobBean{
//日志记录
privatestaticLoggerlogger=LoggerFactory.getLogger(UpdateCEBKeyJob.class);

//ECB密钥更新
@Autowired
privateKeyOperationServicekeyOperationService;

/**
*执行Job
*
*@paramjobExecutionContext
*@throwsJobExecutionException
*/
@Override
protectedvoidexecuteInternal(JobExecutionContextjobExecutionContext)throwsJobExecutionException{
booleanupdateFlag=false;
logger.info("-------------------updateECBkeyjobbegin:{}----------------",
DateTimeUtil.getCurrentDateTime());
//===============01.正常执行任务======================
try{
/*KeyOperationServicekeyOperationService=ContextWrapper
.getBean("keyOperationService",KeyOperationService.class);*/
updateFlag=keyOperationService.updateCEBKey();
}catch(Exceptione){
logger.error("更新光大密钥失败！",e);
}

//===============02.执行结果判定======================
if(!updateFlag){//如果更新失败，创建一次性任务再次执行（Job仍然是当前class）
createJob(2);
}
logger.info("-------------------updateECBkeyjobend:{}----------------",
DateTimeUtil.getCurrentDateTime());
}

importcom.shengpay.mf.constant.ServerErrorEnum;
importcom.shengpay.mf.exception.ServerException;
importio.swagger.annotations.Api;
importio.swagger.annotations.ApiOperation;
importorg.quartz.*;
importorg.slf4j.Logger;
importorg.slf4j.LoggerFactory;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.scheduling.quartz.SchedulerFactoryBean;
importorg.springframework.stereotype.Controller;
importorg.springframework.web.bind.annotation.RequestMapping;
importorg.springframework.web.bind.annotation.RequestMethod;
importorg.springframework.web.bind.annotation.RequestParam;
importorg.springframework.web.bind.annotation.ResponseBody;

importjavax.servlet.http.HttpServletRequest;
importjava.util.HashMap;
importjava.util.Map;

/**
*Description:定时任务管理
*<p/>
*User:lishaohua
*Date:2017/11/1413:22
*/
@Controller
@Api("定时任务管理")//描述类的作用(Swagger注解)
publicclassJobController{
privatestaticLoggerlogger=LoggerFactory.getLogger(JobController.class);

/*@Autowired
privateSchedulerFactoryBeanschedulerFactoryBean;*/

@Autowired
privateSchedulerscheduler;

/**
*添加定时任务
*
*@paramrequest
*@paramjobClassName
*@paramjobGroupName
*@paramcronExpression
*@return
*/
@ApiOperation("添加定时任务")//描述方法的作用(Swagger注解)
@RequestMapping(value="/addJob",method={RequestMethod.POST})
@ResponseBody
publicMap<String,String>addJob(HttpServletRequestrequest,
@RequestParam(value="jobClassName")StringjobClassName,
@RequestParam(value="jobGroupName")StringjobGroupName,
@RequestParam(value="cronExpression")StringcronExpression){
Map<String,String>returnData=newHashMap<String,String>();
try{
/**
*构建JobDetail(表示一个具体的可执行的调度程序,Job是这个可执行程调度程序所要执行的内容)
*/
JobDetailjobDetail=JobBuilder.newJob(getClass(jobClassName).getClass())//工作项1：Job类
.withIdentity(jobClassName,jobGroupName)//工作项2：job名以及所属组
.build();//构建

/**
*构建触发器Trigger(调度参数的配置，代表何时触发该任务)
*/
//通过cron表达式构建CronScheduleBuilder
CronScheduleBuilderscheduleBuilder=CronScheduleBuilder.cronSchedule(cronExpression);
//构建CronTrigger触发器
CronTriggertrigger=TriggerBuilder.newTrigger()
.withIdentity(jobClassName,jobGroupName)//工作项1：job名以及所属组
.withSchedule(scheduleBuilder)//工作项2：指定调度参数
.build();//构建

/**
*构建调度容器(当Trigger与JobDetail组合，就可以被Scheduler容器调度了)
*一个调度容器中可以注册多个JobDetail和Trigger。
*/
//获得调度容器
//Schedulerscheduler=getCurrentScheduler();
//注册调度任务
scheduler.scheduleJob(jobDetail,trigger);
//启动任务
scheduler.start();

returnData.put("msg","添加调度任务成功");
}catch(SchedulerExceptione){
logger.error("构建调度任务异常",e);
returnData.put("msg","添加调度任务异常："+e.getMessage());
}catch(ServerExceptione){
logger.error("内部异常",e);
returnData.put("msg","添加调度任务异常："+e.getMessage());
}catch(Exceptione){
logger.error("添加调度任务异常",e);
returnData.put("msg","添加调度任务异常："+e.getMessage());
}

returnreturnData;
}

@ApiOperation("暂停定时任务")//描述方法的作用(Swagger注解)
@RequestMapping(value="/pauseJob",method={RequestMethod.POST})
@ResponseBody
publicMap<String,String>pauseJob(HttpServletRequestrequest,
@RequestParam(value="jobClassName")StringjobClassName,
@RequestParam(value="jobGroupName")StringjobGroupName){
Map<String,String>returnData=newHashMap<String,String>();
try{
//获得调度容器
//Schedulerscheduler=getCurrentScheduler();
//JobKey定义了job的名称和组别
JobKeyjobKey=JobKey.jobKey(jobClassName,jobGroupName);
//暂停任务
scheduler.pauseJob(jobKey);

returnData.put("msg","暂停调度任务成功");
}catch(SchedulerExceptione){
logger.error("暂停调度任务异常",e);
returnData.put("msg","暂停调度任务异常："+e.getMessage());
}catch(Exceptione){
logger.error("暂停调度任务异常",e);
returnData.put("msg","暂停调度任务异常："+e.getMessage());
}

returnreturnData;
}

@ApiOperation("继续定时任务")//描述方法的作用(Swagger注解)
@RequestMapping(value="/resumeJob",method={RequestMethod.POST})
@ResponseBody
publicMap<String,String>resumeJob(HttpServletRequestrequest,
@RequestParam(value="jobClassName")StringjobClassName,
@RequestParam(value="jobGroupName")StringjobGroupName){
Map<String,String>returnData=newHashMap<String,String>();
try{
//获得调度容器
//Schedulerscheduler=getCurrentScheduler();
//JobKey定义了job的名称和组别
JobKeyjobKey=JobKey.jobKey(jobClassName,jobGroupName);
//继续任务
scheduler.resumeJob(jobKey);

returnData.put("msg","继续调度任务成功");
}catch(SchedulerExceptione){
logger.error("继续调度任务异常",e);
returnData.put("msg","继续调度任务异常："+e.getMessage());
}catch(Exceptione){
logger.error("继续调度任务异常",e);
returnData.put("msg","继续调度任务异常："+e.getMessage());
}

returnreturnData;
}

/**
*更新定时任务：
*--传入的triggerKey有与之匹配的
*--旧触发器的触发时间没有完成
*
*@paramrequest
*@paramjobClassName
*@paramjobGroupName
*@paramcronExpression
*@return
*/
@ApiOperation("更新定时任务")//描述方法的作用(Swagger注解)
@RequestMapping(value="/rescheduleJob",method={RequestMethod.POST})
@ResponseBody
publicMap<String,String>rescheduleJob(HttpServletRequestrequest,
@RequestParam(value="jobClassName")StringjobClassName,
@RequestParam(value="jobGroupName")StringjobGroupName,
@RequestParam(value="cronExpression")StringcronExpression){
Map<String,String>returnData=newHashMap<String,String>();
try{
//获得调度容器
//Schedulerscheduler=getCurrentScheduler();

//构建旧的TriggerKey
TriggerKeytriggerKey=TriggerKey.triggerKey(jobClassName,jobGroupName);
//通过cron表达式构建CronScheduleBuilder
CronScheduleBuilderscheduleBuilder=CronScheduleBuilder.cronSchedule(cronExpression);
//从调度容器中获取旧的CronTrigger
CronTriggertrigger=(CronTrigger)scheduler.getTrigger(triggerKey);
//更新CronTrigger
trigger=trigger.getTriggerBuilder()
.withIdentity(triggerKey)//工作项1：job名以及所属组
.withSchedule(scheduleBuilder)//工作项2：指定调度参数
.build();//构建

//更新调度任务
scheduler.rescheduleJob(triggerKey,trigger);

returnData.put("msg","更新调度任务成功");
}catch(SchedulerExceptione){
logger.error("更新调度任务异常",e);
returnData.put("msg","更新调度任务异常："+e.getMessage());
}catch(ServerExceptione){
logger.error("内部异常",e);
returnData.put("msg","更新调度任务异常："+e.getMessage());
}catch(Exceptione){
logger.error("更新调度任务异常",e);
returnData.put("msg","更新调度任务异常："+e.getMessage());
}

returnreturnData;
}

@ApiOperation("删除定时任务")//描述方法的作用(Swagger注解)
@RequestMapping(value="/removeJob",method={RequestMethod.POST})
@ResponseBody
publicMap<String,String>removeJob(HttpServletRequestrequest,
@RequestParam(value="jobClassName")StringjobClassName,
@RequestParam(value="jobGroupName")StringjobGroupName){
Map<String,String>returnData=newHashMap<String,String>();
try{
//获得调度容器
//Schedulerscheduler=getCurrentScheduler();
//TriggerKey定义了trigger的名称和组别
TriggerKeytriggerKey=TriggerKey.triggerKey(jobClassName,jobGroupName);

//暂停触发器
scheduler.resumeTrigger(triggerKey);
//暂停触发器
scheduler.unscheduleJob(triggerKey);
//移除任务
scheduler.deleteJob(JobKey.jobKey(jobClassName,jobGroupName));

returnData.put("msg","删除调度任务成功");
}catch(SchedulerExceptione){
logger.error("删除调度任务异常",e);
returnData.put("msg","删除调度任务异常："+e.getMessage());
}catch(Exceptione){
logger.error("删除调度任务异常",e);
returnData.put("msg","删除调度任务异常："+e.getMessage());
}

returnreturnData;
}

/**
*获得调度容器Scheduler
*
*@return
*@throwsSchedulerException
*/
/*privateSchedulergetCurrentScheduler()throwsSchedulerException{
//实例化Quartz默认的调度器工厂SchedulerFactory
//SchedulerFactorysf=newStdSchedulerFactory();
//获得调度容器
//Schedulersched=sf.getScheduler();
//returnsched;
//Schedulersched=schedulerFactoryBean.getScheduler();
//returnsched;
}*/

/**
*获得指定的类实例
*
*@paramclassname
*@return
*@throwsServerException
*/
privateJobgetClass(Stringclassname)throwsServerException{
JobbaseJob=null;
try{
//加载参数指定的类
Class<?>classTmp=Class.forName(classname);
//实例化
baseJob=(Job)classTmp.newInstance();
}catch(ClassNotFoundExceptione){
logger.error("找不到指定的类",e);
thrownewServerException(ServerErrorEnum.INTERNAL_ERROR);
}catch(InstantiationExceptione){
logger.error("实例化类失败",e);
thrownewServerException(ServerErrorEnum.INTERNAL_ERROR);
}catch(IllegalAccessExceptione){
logger.error("实例化类失败",e);
thrownewServerException(ServerErrorEnum.INTERNAL_ERROR);
}

returnbaseJob;
}
}

@Autowired
privateSchedulerscheduler;

//注册调度任务
scheduler.scheduleJob(jobDetail,trigger);
//启动任务
scheduler.start();

@Autowired
privateSchedulerFactoryBeanschedulerFactoryBean;

//获得调度容器
Schedulerscheduler=schedulerFactoryBean.getScheduler();
//注册调度任务
scheduler.scheduleJob(jobDetail,trigger);
//启动任务
scheduler.start();

newStdSchedulerFactory()获得的Scheduler将无法被Spring管理，如下代码：

//实例化Quartz默认的调度器工厂SchedulerFactory
SchedulerFactorysf=newStdSchedulerFactory();
//获得调度容器
Schedulersched=sf.getScheduler();

importorg.springframework.beans.BeansException;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.ApplicationContextAware;
importorg.springframework.stereotype.Component;

/**
*Description:applicationContext工具类
*<p/>
*User:lishaohua
*Date:2017/11/1613:48
*/
@Component
publicclassApplicationContextUtilimplementsApplicationContextAware{
/**
*上下文对象实例
*/
privatestaticApplicationContextappContext;

/**
*Spring自动注入applicationContext对象
*--因此该Bean必须@Component被Springscan发现
*
*@paramapplicationContext
*@throwsBeansException
*/
@Override
publicvoidsetApplicationContext(ApplicationContextapplicationContext)throwsBeansException{
appContext=applicationContext;
}

/**
*获得applicationContext
*@return
*/
publicstaticApplicationContextgetAppContext(){
returnappContext;
}

/**
*根据name获取Bean
*
*@paramname
*@return
*/
publicstaticObjectgetBean(Stringname){
returngetAppContext().getBean(name);
}

/**
*根据class获取Bean
*
*@paramclazz
*@param<T>
*@return
*/
publicstatic<T>TgetBean(Class<T>clazz){
returngetAppContext().getBean(clazz);
}

/**
*根据name、class获得Bean
*
*@paramname
*@paramclazz
*@param<T>
*@return
*/
publicstatic<T>TgetBean(Stringname,Class<T>clazz){
returngetAppContext().getBean(name,clazz);
}
}

selectTO_CHAR(t.next_fire_time/(1000*60*60*24)+
TO_DATE('1970-01-0108:00:00','YYYY-MM-DDHH24:MI:SS'),'YYYY-MM-DDHH24:MI:SS')next_fire_datetime,
t.*
fromqrtz_triggerst;