一、什么是Quartz

Quartz是OpenSymphony开源组织在Job
scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer，
Quartz增加了很多功能：
持久性作业 - 就是保持调度定时的状态;
作业管理 - 对调度作业进行有效的管理;

在我们实际的项目中，当Job过多的时候，肯定不能人工去操作，这时候就需要一个任务调度框架，帮我们自动去执行这些程序。那么该如何实现这个功能呢？

（1）首先我们需要定义实现一个定时功能的接口，我们可以称之为Task（或Job），如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下：

（2）有了任务之后，还需要一个能够实现触发任务去执行的触发器，触发器Trigger最基本的功能是指定Job的执行时间，执行间隔，运行次数等。

（3）有了Job和Trigger后，怎么样将两者结合起来呢？即怎样指定Trigger去执行指定的Job呢？这时需要一个Schedule，来负责这个功能的实现。

上面三个部分就是Quartz的基本组成部分：

	调度器：Scheduler任务：JobDetail触发器：Trigger，包括SimpleTrigger和CronTrigger

二、集成依赖

<!-- 定时任务 --><dependency><groupId>org.quartz-scheduler</groupId><artifactId>quartz</artifactId><exclusions><exclusion><groupId>com.mchange</groupId><artifactId>c3p0</artifactId></exclusion></exclusions></dependency>

三、配置代码

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import javax.sql.DataSource;
import java.util.Properties;/*** 定时任务配置**/
@Configuration
public class ScheduleConfig {@Beanpublic SchedulerFactoryBean schedulerFactoryBean(DataSource dataSource) {SchedulerFactoryBean factory = new SchedulerFactoryBean();factory.setDataSource(dataSource);// quartz参数Properties prop = new Properties();prop.put("org.quartz.scheduler.instanceName", "RuoyiScheduler");prop.put("org.quartz.scheduler.instanceId", "AUTO");// 线程池配置prop.put("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");prop.put("org.quartz.threadPool.threadCount", "20");prop.put("org.quartz.threadPool.threadPriority", "5");// JobStore配置prop.put("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");// 集群配置prop.put("org.quartz.jobStore.isClustered", "true");prop.put("org.quartz.jobStore.clusterCheckinInterval", "15000");prop.put("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");prop.put("org.quartz.jobStore.txIsolationLevelSerializable", "true");// sqlserver 启用// prop.put("org.quartz.jobStore.selectWithLockSQL", "SELECT * FROM {0}LOCKS UPDLOCK WHERE LOCK_NAME = ?");prop.put("org.quartz.jobStore.misfireThreshold", "12000");prop.put("org.quartz.jobStore.tablePrefix", "QRTZ_");factory.setQuartzProperties(prop);factory.setSchedulerName("Scheduler");// 延时启动factory.setStartupDelay(1);factory.setApplicationContextSchedulerContextKey("applicationContextKey");// 可选，QuartzScheduler// 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了factory.setOverwriteExistingJobs(true);// 设置自动启动，默认为truefactory.setAutoStartup(true);return factory;}
}

注意：也可以将此配置代码放在配置文件中进行加载

四、抽象Quartz调用

(1) 定时任务调度表

/*** 定时任务调度表 sys_job* */
@Data
@TableName("sys_job")
@ApiModel(value="SysJobDTO", description="定时任务记录")
public class SysJobDTO extends BaseDTO implements Serializable {private static final long serialVersionUID = 1L;/** 任务ID */@ApiModelProperty(value = "主键ID")@TableId(value = "job_id", type = IdType.ASSIGN_ID)private String jobId;/** 任务名称 */private String jobName;/** 任务组名 */private String jobGroup;/** 调用目标字符串 */private String invokeTarget;/** cron执行表达式 */private String cronExpression;/** cron计划策略 */private String misfirePolicy = ScheduleConstants.MISFIRE_DEFAULT;/** 是否并发执行（0允许 1禁止） */private String concurrent;/** 任务状态（0正常 1暂停） */private String status;}

(2) 定时任务调度日志表

/*** 定时任务调度日志表 sys_job_log* */
@Data
@TableName("sys_job_log")
@ApiModel(value="SysJobLogDTO", description="定时任务日志记录")
public class SysJobLogDTO extends BaseDTO {private static final long serialVersionUID = 1L;/** ID */@ApiModelProperty(value = "主键ID")@TableId(value = "job_log_id", type = IdType.ASSIGN_ID)private String jobLogId;/** 任务名称 */private String jobName;/** 任务组名 */private String jobGroup;/** 调用目标字符串 */private String invokeTarget;/** 日志信息 */private String jobMessage;/** 执行状态（0正常 1失败） */private String status;/** 异常信息 */private String exceptionInfo;/** 开始时间 */private Date startTime;/** 结束时间 */private Date endTime;}

(3) 抽象quartz调用

```java
/*** 抽象quartz调用**/
public abstract class AbstractQuartzJob implements Job {private static final Logger log = LoggerFactory.getLogger(AbstractQuartzJob.class);/*** 线程本地变量*/private static ThreadLocal<Date> threadLocal = new ThreadLocal<>();@Overridepublic void execute(JobExecutionContext context) throws JobExecutionException {SysJobDTO sysJob = new SysJobDTO();BeanUtils.copyBeanProp(sysJob, context.getMergedJobDataMap().get(ScheduleConstants.TASK_PROPERTIES));try {before(context, sysJob);if (sysJob != null) {doExecute(context, sysJob);}after(context, sysJob, null);} catch (Exception e) {log.error("任务执行异常  - ：", e);after(context, sysJob, e);}}/*** 执行前** @param context 工作执行上下文对象* @param sysJob 系统计划任务*/protected void before(JobExecutionContext context, SysJobDTO sysJob) {threadLocal.set(new Date());}/*** 执行后** @param context 工作执行上下文对象*/protected void after(JobExecutionContext context, SysJobDTO sysJob, Exception e) {Date startTime = threadLocal.get();threadLocal.remove();final SysJobLogDTO sysJobLog = new SysJobLogDTO();sysJobLog.setJobName(sysJob.getJobName());sysJobLog.setJobGroup(sysJob.getJobGroup());sysJobLog.setInvokeTarget(sysJob.getInvokeTarget());sysJobLog.setStartTime(startTime);sysJobLog.setEndTime(new Date());long runMs = sysJobLog.getEndTime().getTime() - sysJobLog.getStartTime().getTime();sysJobLog.setJobMessage(sysJobLog.getJobName() + " 总共耗时：" + runMs + "毫秒");if (e != null) {sysJobLog.setStatus(ConstantData.FAIL);String errorMsg = StringUtils.substring(ExceptionUtil.getExceptionMessage(e), 0, 2000);sysJobLog.setExceptionInfo(errorMsg);} else {sysJobLog.setStatus(ConstantData.SUCCESS);}// 写入数据库当中SpringUtils.getBean(ISysJobLogService.class).addJobLog(sysJobLog);}/*** 执行方法，由子类重载** @param context 工作执行上下文对象* @param sysJob 系统计划任务* @throws Exception 执行过程中的异常*/protected abstract void doExecute(JobExecutionContext context, SysJobDTO sysJob) throws Exception;
}

(4) cron表达式工具类

/*** cron表达式工具类* **/
public class CronUtils {/*** 返回一个布尔值代表一个给定的Cron表达式的有效性** @param cronExpression Cron表达式* @return boolean 表达式是否有效*/public static boolean isValid(String cronExpression){return CronExpression.isValidExpression(cronExpression);}/*** 返回一个字符串值,表示该消息无效Cron表达式给出有效性** @param cronExpression Cron表达式* @return String 无效时返回表达式错误描述,如果有效返回null*/public static String getInvalidMessage(String cronExpression) {try {new CronExpression(cronExpression);return null;} catch (ParseException pe) {return pe.getMessage();}}/*** 返回下一个执行时间根据给定的Cron表达式** @param cronExpression Cron表达式* @return Date 下次Cron表达式执行时间*/public static Date getNextExecution(String cronExpression) {try {CronExpression cron = new CronExpression(cronExpression);return cron.getNextValidTimeAfter(new Date(System.currentTimeMillis()));} catch (ParseException e) {throw new IllegalArgumentException(e.getMessage());}}
}

(5) 任务执行工具

```java
/*** 任务执行工具**/
public class JobInvokeUtil {/*** 执行方法** @param sysJob 系统任务*/public static void invokeMethod(SysJobDTO sysJob) throws Exception {String invokeTarget = sysJob.getInvokeTarget();String beanName = getBeanName(invokeTarget);String methodName = getMethodName(invokeTarget);List<Object[]> methodParams = getMethodParams(invokeTarget);if (!isValidClassName(beanName)) {Object bean = SpringUtils.getBean(beanName);invokeMethod(bean, methodName, methodParams);} else {Object bean = Class.forName(beanName).newInstance();invokeMethod(bean, methodName, methodParams);}}/*** 调用任务方法** @param bean 目标对象* @param methodName 方法名称* @param methodParams 方法参数*/private static void invokeMethod(Object bean, String methodName, List<Object[]> methodParams)throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException,InvocationTargetException {if (StringUtils.isNotNull(methodParams) && methodParams.size() > 0) {Method method = bean.getClass().getDeclaredMethod(methodName, getMethodParamsType(methodParams));method.invoke(bean, getMethodParamsValue(methodParams));} else {Method method = bean.getClass().getDeclaredMethod(methodName);method.invoke(bean);}}/*** 校验是否为为class包名* * @return true是 false否*/public static boolean isValidClassName(String invokeTarget) {return StringUtils.countMatches(invokeTarget, ".") > 1;}/*** 获取bean名称* * @param invokeTarget 目标字符串* @return bean名称*/public static String getBeanName(String invokeTarget) {String beanName = StringUtils.substringBefore(invokeTarget, "(");return StringUtils.substringBeforeLast(beanName, ".");}/*** 获取bean方法* * @param invokeTarget 目标字符串* @return method方法*/public static String getMethodName(String invokeTarget) {String methodName = StringUtils.substringBefore(invokeTarget, "(");return StringUtils.substringAfterLast(methodName, ".");}/*** 获取method方法参数相关列表* * @param invokeTarget 目标字符串* @return method方法相关参数列表*/public static List<Object[]> getMethodParams(String invokeTarget) {String methodStr = StringUtils.substringBetween(invokeTarget, "(", ")");if (StringUtils.isEmpty(methodStr)) {return null;}String[] methodParams = methodStr.split(",");List<Object[]> classs = new LinkedList<>();for (int i = 0; i < methodParams.length; i++) {String str = StringUtils.trimToEmpty(methodParams[i]);// String字符串类型，包含'if (StringUtils.contains(str, "'")) {classs.add(new Object[] { StringUtils.replace(str, "'", ""), String.class });}// boolean布尔类型，等于true或者falseelse if (StringUtils.equals(str, "true") || StringUtils.equalsIgnoreCase(str, "false")) {classs.add(new Object[] { Boolean.valueOf(str), Boolean.class });}// long长整形，包含Lelse if (StringUtils.containsIgnoreCase(str, "L")) {classs.add(new Object[] { Long.valueOf(StringUtils.replaceIgnoreCase(str, "L", "")), Long.class });}// double浮点类型，包含Delse if (StringUtils.containsIgnoreCase(str, "D")) {classs.add(new Object[] { Double.valueOf(StringUtils.replaceIgnoreCase(str, "D", "")), Double.class });}// 其他类型归类为整形else {classs.add(new Object[] { Integer.valueOf(str), Integer.class });}}return classs;}/*** 获取参数类型* * @param methodParams 参数相关列表* @return 参数类型列表*/public static Class<?>[] getMethodParamsType(List<Object[]> methodParams) {Class<?>[] classs = new Class<?>[methodParams.size()];int index = 0;for (Object[] os : methodParams) {classs[index] = (Class<?>) os[1];index++;}return classs;}/*** 获取参数值* * @param methodParams 参数相关列表* @return 参数值列表*/public static Object[] getMethodParamsValue(List<Object[]> methodParams) {Object[] classs = new Object[methodParams.size()];int index = 0;for (Object[] os : methodParams) {classs[index] = (Object) os[0];index++;}return classs;}
}

(6) 定时任务处理(禁止并发执行)

/*** 定时任务处理（禁止并发执行）**/
@DisallowConcurrentExecution
public class QuartzDisallowConcurrentExecution extends AbstractQuartzJob {@Overrideprotected void doExecute(JobExecutionContext context, SysJobDTO sysJob) throws Exception {JobInvokeUtil.invokeMethod(sysJob);}
}

(7) 定时任务处理(允许并发执行)

/*** 定时任务处理（允许并发执行）**/
public class QuartzJobExecution extends AbstractQuartzJob {@Overrideprotected void doExecute(JobExecutionContext context, SysJobDTO sysJob) throws Exception {JobInvokeUtil.invokeMethod(sysJob);}
}

(8) 定时任务工具类

/*** 定时任务工具类***/
public class ScheduleUtils {/*** 得到quartz任务类** @param sysJob 执行计划* @return 具体执行任务类*/private static Class<? extends Job> getQuartzJobClass(SysJobDTO sysJob) {boolean isConcurrent = "0".equals(sysJob.getConcurrent());return isConcurrent ? QuartzJobExecution.class : QuartzDisallowConcurrentExecution.class;}/*** 构建任务触发对象*/public static TriggerKey getTriggerKey(String jobId, String jobGroup) {return TriggerKey.triggerKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);}/*** 构建任务键对象*/public static JobKey getJobKey(String jobId, String jobGroup) {return JobKey.jobKey(ScheduleConstants.TASK_CLASS_NAME + jobId, jobGroup);}/*** 创建定时任务*/public static void createScheduleJob(Scheduler scheduler, SysJobDTO job) throws SchedulerException, TaskException {Class<? extends Job> jobClass = getQuartzJobClass(job);// 构建job信息String jobId = job.getJobId();String jobGroup = job.getJobGroup();JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(getJobKey(jobId, jobGroup)).build();// 表达式调度构建器CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());cronScheduleBuilder = handleCronScheduleMisfirePolicy(job, cronScheduleBuilder);// 按新的cronExpression表达式构建一个新的triggerCronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(getTriggerKey(jobId, jobGroup)).withSchedule(cronScheduleBuilder).build();// 放入参数，运行时的方法可以获取jobDetail.getJobDataMap().put(ScheduleConstants.TASK_PROPERTIES, job);// 判断是否存在if (scheduler.checkExists(getJobKey(jobId, jobGroup))) {// 防止创建时存在数据问题 先移除，然后在执行创建操作scheduler.deleteJob(getJobKey(jobId, jobGroup));}scheduler.scheduleJob(jobDetail, trigger);// 暂停任务if (job.getStatus().equals(ScheduleConstants.Status.PAUSE.getValue())) {scheduler.pauseJob(ScheduleUtils.getJobKey(jobId, jobGroup));}}/*** 设置定时任务策略*/public static CronScheduleBuilder handleCronScheduleMisfirePolicy(SysJobDTO job, CronScheduleBuilder cb)throws TaskException {switch (job.getMisfirePolicy()) {case ScheduleConstants.MISFIRE_DEFAULT:return cb;case ScheduleConstants.MISFIRE_IGNORE_MISFIRES:return cb.withMisfireHandlingInstructionIgnoreMisfires();case ScheduleConstants.MISFIRE_FIRE_AND_PROCEED:return cb.withMisfireHandlingInstructionFireAndProceed();case ScheduleConstants.MISFIRE_DO_NOTHING:return cb.withMisfireHandlingInstructionDoNothing();default:throw new TaskException("The task misfire policy '" + job.getMisfirePolicy()+ "' cannot be used in cron schedule tasks", TaskException.Code.CONFIG_ERROR);}}
}

(9) Spring工具类

/*** spring工具类 方便在非spring管理环境中获取bean* */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor {/** Spring应用上下文环境 */private static ConfigurableListableBeanFactory beanFactory;@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {SpringUtils.beanFactory = beanFactory;}/*** 获取对象** @param name* @return Object 一个以所给名字注册的bean的实例* @throws BeansException**/@SuppressWarnings("unchecked")public static <T> T getBean(String name) throws BeansException {return (T) beanFactory.getBean(name);}/*** 获取类型为requiredType的对象** @param clz* @return* @throws BeansException**/public static <T> T getBean(Class<T> clz) throws BeansException {T result = (T) beanFactory.getBean(clz);return result;}/*** 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true** @param name* @return boolean*/public static boolean containsBean(String name) {return beanFactory.containsBean(name);}/*** 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）** @param name* @return boolean* @throws NoSuchBeanDefinitionException**/public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {return beanFactory.isSingleton(name);}/*** @param name* @return Class 注册对象的类型* @throws NoSuchBeanDefinitionException**/public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {return beanFactory.getType(name);}/*** 如果给定的bean名字在bean定义中有别名，则返回这些别名** @param name* @return* @throws NoSuchBeanDefinitionException**/public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {return beanFactory.getAliases(name);}/*** 获取aop代理对象* * @param invoker* @return*/@SuppressWarnings("unchecked")public static <T> T getAopProxy(T invoker) {return (T) AopContext.currentProxy();}
}

五、测试方法

@Component("ryTask ")
public class RyTask {public void ryNoParams() {System.out.println("测试定时规则");}
}