quartz学习笔记之界面配置（二）

quartz学习笔记之界面配置（二）

本文内容

通过xml配置一个调度器Scheduler，所有的任务通过该调度器来进行调度，结合官方提供的数据结构以及调度实现来达到前端控制定时器的目的。

调度器Scheduler的作用

调度器是Quartz的核心组成部分，其作用是调度Job能够被Trigger触发，是Quartz的驱动。
下图是列出来的定时器的核心概念、组成部分以及

调度器的创建

Scheduler的实现类有以下几个：

• RemoteScheduler: 远程调度器；
• StdScheduler：默认标准调度器（最为常用的）；
• RemoteMBeanScheduler：抽象类，
  • JBoss4RMIRemoteMBeanScheduler：是抽象类RemoteMBeanScheduler 的实现类
    调度器的创建主要是通过其工厂模式创建的，创建方式有：
• StdSchedulerFactory；
  • 使用一组参数（java.util.Properties）来创建和初始化Quartz调度器；
  • 配置参数一般在quartz.properties中
  • 调用getScheduler方法就能创建和初始化调度器对象；
  • 通过new StdSchedulerFactory().getScheduler(); 来获取调度器。
• DirectSchedulerFactory；

定时器创建以后，可以进行增加、删除以及显示Job和Trigger，对Job进行暂停/恢复等操作，调用了.start()方法后，Scheduler才正式开始执行Job和Trigger；

StdSchedulerFactory

StdSchedulerFactory依赖于一系列属性决定如何产生Scheduler，提供配置信息的方式如下：

• 通过java.util.Properties属性实例；
• 通过外部属性文件提供；
• 通过含有属性文件内容的java.io.InputStream提供；

// 1. 无参方法，会优先加载当前工作目录的quartz.properties，如果未找到，则试图从系统的classpath中加载该配置文件。
        factory.initialize();
// 2.通过外部属性文件提供
//        factory.initialize("lx-quartz-scheduler.properties");
// 3. 通过含有属性文件内容的java.io.InputStream提供
//        factory.initialize(new FileInputStream(new File("lx-quartz-scheduler.properties")));
scheduler = factory.getScheduler("quartzScheduler");

前端控制定时器暂停、恢复等核心方法

原理：配置定时器项目默认调度器名字，并结合quartz官方提供的表结构以及自动从数据库加载定时器配置的机制，使用调度器Scheduler的几个核心方法结合数据库配置达到使用前端界面控制定时器恢复、执行等操作。

• void start(); // 启动
• void standby();// 挂起
• void shutdown();// 关闭
• void shutdown(true); // 等待所有正在执行的job执行完毕之后，再关闭scheduler；

暂停定时器核心方法

修改数据库的执行器状态

    @Override
    public Message updateJobStatus(QuartzJobInfo job) {
        QuartzTriggers triggers = new QuartzTriggers();
        triggers.setSchedName(job.getSchedName());
        triggers.setTriggerGroup(job.getTriggerGroup());
        triggers.setTriggerName(job.getTriggerName());
        triggers.setTriggerState(job.getTriggerState());
        quartzTriggersDao.updateByPrimaryKeySelective(triggers);
        if (QRTZ_TRIGGER_STATUS_WAITING.equals(job.getTriggerState())) {
            quartzManager.resumeJob(job.getJobName(), job.getJobGroup());
        } else {
            quartzManager.pauseJob(job.getJobName(), job.getJobGroup());
        }
        return Message.success();
    }

    /**
    * 调度器暂停Job
    *
    * @param jobName      job名字
    * @param jobGroupName job组名
    */
public void pauseJob(String jobName, String jobGroupName) {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
    try {
        scheduler.pauseJob(jobKey);
    } catch (SchedulerException e) {
        throw new BusinessException("暂停任务[" + jobGroupName + SPLIT_DOT + jobName + "]中出现异常!", e);
    } catch (IllegalArgumentException e) {
        throw new BusinessException("暂停任务[" + jobGroupName + SPLIT_DOT + jobName + "]中出现异常!", e);
    }
}

恢复定时器核心方法

    /**
     * 调度器恢复Job
     *
     * @param jobName      job名字
     * @param jobGroupName job组名
     */
    public void resumeJob(String jobName, String jobGroupName) {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
        try {
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            throw new BusinessException("恢复任务[" + jobGroupName + SPLIT_DOT + jobName + "]中出现异常!", e);
        }
    }

效果

回顾

定时器配置：SimpleTrigger和CronTrigger

spring-servlet.xml 中添加配置，用于托付给spring来管理；

• 配置JobDetail；
• 配置Trigger；
• 配置Scheduler；
  首先配置JobDetail，前面的概念中也了解到定义的方式，方式如下：
• MethodInvokingJobDetailFactoryBean
• JobDetailFactoryBean：可以传入参数jobDataMap；比较灵活；
• extends QuartzJobBean

<description>Quartz定时器配置</description>

<!-- JobDetail 定义方式一： MethodInvokingJobDetailFactoryBean-->
<bean id="lxJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <!-- 指定类 -->
    <property name="targetObject" ref="lxJobDetailBean"/>
    <!-- 指定方法 -->
    <property name="targetMethod" value="init"/>
</bean>

<!-- JobDetail 定义方式二：JobDetailFactoryBean -->
<bean id="lxJobDetailBean1" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <property name="jobClass" value="com.weyoung.platform.quartz.schedule.LxQuartzJobBean"/>
    <!-- 传入自定义参数 -->
    <property name="jobDataMap">
        <map>
            <entry key="anotherBean" value-ref="anotherBean"/>
        </map>
    </property>
    <property name="durability" value="true"/>
</bean>

<!-- Trigger方式一：SimpleTriggerFactoryBean 距离当前时间1秒之后执行，之后每隔两秒钟执行一次 -->
<bean id="lxSimpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
    <property name="jobDetail" ref="lxJobDetail"/>
    <property name="startDelay" value="1000"/>
    <property name="repeatInterval" value="2000"/>
</bean>

<!-- Trigger方式二：CronTriggerFactoryBean 每隔五秒钟执行一次 -->
<bean id="lxCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="jobDetail" ref="lxJobDetailBean1"/>
    <property name="cronExpression" value="0/5 * * ? * *"/>
</bean>

<bean id="lxQuartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="jobDetails">
        <list>
            <ref bean="lxJobDetail"/>
            <ref bean="lxJobDetailBean1"/>
        </list>
    </property>
    <property name="triggers">
        <list>
            <ref bean="lxSimpleTrigger"/>
            <ref bean="lxCronTrigger"/>
        </list>
    </property>
</bean>

其中，定义的类lxJobDetailBean、lxJobDetailBean1、anotherBean代码如下：
LxJobDetailBean.java

package com.weyoung.platform.quartz.schedule;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @功能描述:
 * @时间: 2019/6/29 11:26
 * @author: Mr.wang
 */
@Component("lxJobDetailBean")
public class LxJobDetailBean {

    private static final Logger LOGGER = LoggerFactory.getLogger(LxJobDetailBean.class);

    public void init() {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        LOGGER.info("-----------lxJobDetailBean.init-----------" + sdf.format(date));
    }
}

LxQuartzJobBean.java

package com.weyoung.platform.quartz.schedule;

import com.weyoung.platform.quartz.entity.AnotherBean;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @功能描述:
 * @时间: 2019/6/29 11:33
 * @author: Mr.wang
 */
public class LxQuartzJobBean extends QuartzJobBean {

    // 定义一个需要传入的参数，并给一个setter方法

    private AnotherBean anotherBean;
    private static final Logger LOGGER = LoggerFactory.getLogger(LxQuartzJobBean.class);
    /**
     * 业务逻辑
     *
     * @param jobExecutionContext
     * @throws JobExecutionException
     */
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        LOGGER.info("---------LxQuartzJobBean.executeInternal---------" + sdf.format(date));
    }

    public void setAnotherBean(AnotherBean anotherBean) {
        this.anotherBean = anotherBean;
    }
}

AnotherBean.java

package com.weyoung.platform.quartz.entity;

import org.springframework.stereotype.Component;

/**
 * @功能描述:
 * @时间: 2019/6/29 11:36
 * @author: Mr.wang
 */
@Component("anotherBean")
public class AnotherBean {
    public void someMessage () {

    }
}

Quartz中作业存储方式

• RAMJobStore：作业、触发器、调度信息存储在内存中，这种方式存取速度比较快，但是如果定时器项目重启或者崩溃的话，存储的信息都会丢失；
• JDBC作业存储：作业、触发器、调度信息存储在数据库中，支持事务，支持集群；

前面的笔记里面记录了Quartz官方提供的表结构及创建脚本等，使用该脚本创建数据库；

修改调度器信息及使用quartz.propertie文件配置

我的项目暂时是把定时器放在项目主程序中，也是使用同一个数据库，当然也可以分开。如果需要自己配置数据库的话，在quartz.properties中配置就行。
因此，修改spring-quartz.xml配置如下：

<!-- 调度器，调度器的id不要改，数据库中记录调度器名称 -->
<bean id="lxQuartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <!-- 使用spring中配置的数据源，需要在这儿配置 -->
    <property name="dataSource" ref="masterDataSource"/>
    <property name="overwriteExistingJobs" value="true"/><!--覆盖JOB：true、以数据库中已经存在的为准： -->
    <property name="autoStartup" value="true"/><!--自启动-->
    <property name="startupDelay" value="20"/> <!-- 定时任务延时启动，程序启动后20秒再启动定时任务 -->
    <!-- 调度器配置文件 -->
    <property name="configLocation" value="classpath:config/quartz.properties"/>
</bean>

quartz.properties文件的配置

#===========================================================================
# Configure Main Scheduler Properties 调度器属性
# ===========================================================================
org.quartz.scheduler.instanceName=lxQuartzScheduler
org.quartz.scheduler.instanceid=AUTO
org.quartz.scheduler.rmi.export=false
org.quartz.scheduler.rmi.proxy=false
org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
# ===========================================================================
# Configure ThreadPool 线程池属性
# ===========================================================================
#线程池的实现类（一般使用SimpleThreadPool即可满足几乎所有用户的需求）
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
#指定线程数，至少为1（无默认值）(一般设置为1-100直接的整数合适)
org.quartz.threadPool.threadCount=10
#设置线程的优先级（最大为java.lang.Thread.MAX_PRIORITY 10，最小为Thread.MIN_PRIORITY 1，默认为5）
org.quartz.threadPool.threadPriority=5
===========================================================================
# Configure JobStore 存储调度信息（工作，触发器和日历等）
# ===========================================================================
# 信息保存时间 默认值60秒
org.quartz.jobStore.misfireThreshold=60000
#保存job和Trigger的状态信息到内存中的类
#org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
# Mysql需要使用下面的链接
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#org.quartz.jobStore.useProperties = false
## 我们采用程序中的数据源，因此这块不配置，在spring-quartz.xml中配置
#org.quartz.jobStore.dataSource = masterDataSource
org.quartz.jobStore.tablePrefix = QRTZ_
#org.quartz.jobStore.isClustered = false
#============================================================================
# Configure Datasources
#============================================================================
#org.quartz.dataSource.myDS.driver=com.mysql.jdbc.Driver
#org.quartz.dataSource.myDS.URL=jdbc:mysql://localhost:3306/SSM_NOTE
#org.quartz.dataSource.myDS.user=root
#org.quartz.dataSource.myDS.password=lucifer
#org.quartz.dataSource.myDS.maxConnections=5

# ===========================================================================
# Configure SchedulerPlugins 插件属性 配置
# ===========================================================================
# 自定义插件
org.quartz.plugin.triggHistory.class=org.quartz.plugins.history.LoggingTriggerHistoryPlugin  
org.quartz.plugin.triggHistory.triggerFiredMessage=Trigger {1}.{0} fired job {6}.{5} at: {4, date, HH:mm:ss MM/dd/yyyy}  
org.quartz.plugin.triggHistory.triggerCompleteMessage=Trigger {1}.{0} completed firing job {6}.{5} at {4, date, HH:mm:ss MM/dd/yyyy} with resulting trigger instruction code: {9}  

qrtz_triggers表中的字段特别解析：

MISFIRE_INSTR：Misfire处理规则:

SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule();
// 1
scheduleBuilder.withMisfireHandlingInstructionFireNow();
// -1
scheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
// 5
scheduleBuilder.withMisfireHandlingInstructionNextWithExistingCount();
// 4
scheduleBuilder.withMisfireHandlingInstructionNextWithRemainingCount();
// 2
scheduleBuilder.withMisfireHandlingInstructionNowWithExistingCount();
// 3
scheduleBuilder.withMisfireHandlingInstructionNowWithRemainingCount();

/*
1：withMisfireHandlingInstructionFireNow
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率，FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值
-1：withMisfireHandlingInstructionIgnoreMisfires
——以错过的第一个频率时间立刻开始执行
——重做错过的所有频率周期
——当下一次触发频率发生时间大于当前时间以后，按照Interval的依次执行剩下的频率
——共执行RepeatCount+1次
2：withMisfireHandlingInstructionNowWithExistingCount
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率，FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值
3：withMisfireHandlingInstructionNowWithRemainingCount
——以当前时间为触发频率立即触发执行
——执行至FinalTIme的剩余周期次数
——以调度或恢复调度的时刻为基准的周期频率，FinalTime根据剩余次数和当前时间计算得到
——调整后的FinalTime会略大于根据starttime计算的到的FinalTime值
4：withMisfireHandlingInstructionNextWithRemainingCount
——不触发立即执行
——等待下次触发频率周期时刻，执行至FinalTime的剩余周期次数
——以startTime为基准计算周期频率，并得到FinalTime
——即使中间出现pause，resume以后保持FinalTime时间不变
5：withMisfireHandlingInstructionNextWithExistingCount
——不触发立即执行
——等待下次触发频率周期时刻，执行至FinalTime的剩余周期次数
——以startTime为基准计算周期频率，并得到FinalTime
——即使中间出现pause，resume以后保持FinalTime时间不变
*/

// Cron的MisFire策略；使用最多的

CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("");
// -1: 以错过的第一个频率时间立刻开始执行,重做错过的所有频率周期后当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行；
cronScheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
// 2: 不触发立即执行，等待下次Cron触发频率到达时刻开始按照Cron频率依次执行；
cronScheduleBuilder.withMisfireHandlingInstructionDoNothing();
// 1:以当前时间为触发频率立刻触发一次执行，然后按照Cron频率依次执行
cronScheduleBuilder.withMisfireHandlingInstructionFireAndProceed();

错误

org.springframework.web.context.ContextLoader - Context initialization failed
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'quartzJobServiceImpl': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'quartzManager': Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'lxQuartzScheduler' defined in class path resource [spring/spring-quartz.xml]: Invocation of init method failed; nested exception is java.lang.NoClassDefFoundError: javax/transaction/UserTransaction

是因为缺少jar包，添加如下依赖,即可

<dependency>
    <groupId>javax.transaction</groupId>
    <artifactId>jta</artifactId>
    <version>1.1</version>
</dependency>

分享

欢迎扫描下方二维码，关注weyoung公众号，一起交流学习~~

最后

以上就是细腻蜡烛为你收集整理的quartz学习笔记之界面配置（二）的全部内容，希望文章能够帮你解决quartz学习笔记之界面配置（二）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。