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覆盖

3、自定义JobFactory

首先解释一个常见的困境：Spring容器可以管理Bean，但是Quartz的job是自己管理的，如果在Job中注入Spring管理的Bean，需要先把Quartz的Job也让Spring管理起来，因此，我们需要重写JobFactory，否则会出现@Autowired空指针Null问题即依赖注入的属性为null，详细的源码分析，请参考：

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对象

阅读更多