Quartz使用指南

最新推荐文章于 2024-11-05 08:15:00 发布
最新推荐文章于 2024-11-05 08:15:00 发布
阅读量383 收藏 1
点赞数
分类专栏： java 框架使用 文章标签： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zzxinwow123/article/details/88763418
版权

Quartz使用指南

Quartz 简介

Quartz是一个完全由java编写的开源作业调度框架。
简单来说，就是可以帮助我们设置一个有规律的或者在某个具体点干点想干的事的一个开源框架。

它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。

Quartz是一个任务日程管理系统，一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。

Quartz用一个小Java库发布文件（.jar文件），这个库文件包含了所有Quartz核心功能。这些功能的主要接口(API)是Scheduler接口。它提供了简单的操作，例如：将任务纳入日程或者从日程中取消，开始/停止/暂停日程进度。

1.1 quartz的特点

1.quartz能嵌入到任何独立的系统中运行

2.quartz能在应用服务器或者servlet容器中实例化，并且能够参与XA事物

3.quartz能够以独立的方式运行（在它自己的Java虚拟机中），可以通过RMI使用quartz

1.2 quartz的应用背景

凡是业务中有需要用到定时的功能，都可以考虑用到quartz

1.3 quartz和spring自带的定时器Timer Task的比较

精确度和功能 ：
    Quartz可以通过cron表达式精确到特定时间执行，而TimerTask不能。
    Quartz拥有TimerTask所有的功能，而TimerTask则没有。 

任务类的数量 ：
    Quartz每次执行都创建一个新的任务类对象。
    TimerTask则每次使用同一个任务类对象。

对异常的处理 ：
	Quartz的某次执行任务过程中抛出异常，不影响下一次任务的执行，当下一次执行时间到来时，定时器会再次执行任务。

quartz调度核心元素：

Scheduler:任务调度器，是实际执行任务调度的控制器。在spring中通过SchedulerFactoryBean封装起来。
Trigger：触发器，用于定义任务调度的时间规则，有SimpleTrigger,CronTrigger,DateIntervalTrigger和NthIncludedDayTrigger，其中CronTrigger用的比较多，本文主要介绍这种方式。CronTrigger在spring中封装在CronTriggerFactoryBean中。

Calendar:它是一些日历特定时间点的集合。一个trigger可以包含多个Calendar，以便排除或包含某些时间点。

JobDetail:用来描述Job实现类及其它相关的静态信息，如Job名字、关联监听器等信息。在spring中有JobDetailFactoryBean和 MethodInvokingJobDetailFactoryBean两种实现，如果任务调度只需要执行某个类的某个方法，就可以通过MethodInvokingJobDetailFactoryBean来调用。

Job：是一个接口，只有一个方法void execute(JobExecutionContext context),开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中。实现Job接口的任务，默认是无状态的，若要将Job设置成有状态的，在quartz中是给实现的Job添加@DisallowConcurrentExecution注解（以前是实现StatefulJob接口，现在已被Deprecated）,在与spring结合中可以在spring配置文件的job detail中配置concurrent参数。

用法

废话不多说，下面就是具体的使用方式。

第一步 引入jar包

首先我们要引入jar包
用quartz，我们仅仅需要在maven的pom文件中添加依赖即可。我使用的是现在最新的一个版本2.3.0，大家可以在maven的仓库获取到最新的版本依赖，地址：http://mvnrepository.com/artifact/org.quartz-scheduler/quartz

但然也可以使用这个2.3.0的依赖，下面的例子都是使用此依赖并实现了效果。

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

第二步 属性文件

quartz使用名为quartz.properties的配置文件。刚开始时该配置文件不是必须的，但是为了使用最基本的配置，该文件必须位于classpath下。

如果你准备构建一个使用quartz的web应用（以.war包的形式），你应该将quartz.properties文件放到WEB-INF/classes目录下。

当然，springboot项目放在resource目录下就好了

# 固定前缀org.quartz
# 主要分为scheduler、threadPool、jobStore、plugin等部分
#
#
org.quartz.scheduler.instanceName=DefaultQuartzScheduler
org.quartz.scheduler.instanceIdGenerator.class = org.quartz.simpl.SimpleInstanceIdGenerator
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export=false
org.quartz.scheduler.rmi.proxy=false
org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
# 实例化ThreadPool时，使用的线程类为SimpleThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool

# threadCount和threadPriority将以setter的形式注入ThreadPool实例
# 并发个数
org.quartz.threadPool.threadCount=5
# 优先级
org.quartz.threadPool.threadPriority=5

#数据保存方式 持久化到数据库
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
#数据库平台 mysql
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#表的前缀
org.quartz.jobStore.tablePrefix = QRTZ_
#数据库别名 spring配置数据源 则这里配置的数据源不起作用 在spring中指定quartz的数据源
org.quartz.jobStore.dataSource = clusterDS

# ------------------------使用常规数据源配置

# 数据库驱动

org.quartz.dataSource.clusterDS.driver = com.mysql.jdbc.Driver

# 数据库连接地址

org.quartz.dataSource.clusterDS.URL = jdbc:mysql:/host:port/db_table?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=false

# 数据库用户名

org.quartz.dataSource.clusterDS.user = root

# 数据库密码

org.quartz.dataSource.clusterDS.password = xxxxxx

org.quartz.dataSource.clusterDS.maxConnections = 4

## ------------------------使用JDBCJobStore配置
#
## 所有的quartz数据例如job和Trigger的细节信息被保存在内存或数据库中,有两种实现：JobStoreTX(自己管理事务)和JobStoreCMT（application server管理事务，即全局事务JTA）
#
#org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
## 最大能忍受的触发超时时间(触发器被认定为“misfired”之前)，如果超过则认为“失误”【默认60秒】
#
#org.quartz.jobStore.misfireThreshold = 5000
#
## 类似于Hibernate的dialect，用于处理DB之间的差异，StdJDBCDelegate能满足大部分的DB
#
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
## 配置数据源的名称，在后面配置数据源的时候要用到，例如org.quartz.dataSource.clusterDS.driver = com.mysql.jdbc.Driver
#
#org.quartz.jobStore.dataSource = clusterDS
#
## 数据表前缀
#
#org.quartz.jobStore.tablePrefix = QRTZ_
#
## 为了指示JDBCJobStore所有的JobDataMaps中的值都是字符串，并且能以“名字-值”对的方式存储而不是以复杂对象的序列化形式存储在BLOB字段中，应该设置为true(缺省方式)
#
org.quartz.jobStore.useProperties = true
#
## 是否集群、负载均衡、容错，如果应用在集群中设置为false会出错
#
org.quartz.jobStore.isClustered = true
#
## 检入到数据库中的频率(毫秒)。检查是否其他的实例到了应当检入的时候未检入这能指出一个失败的实例，且当前Scheduler会以此来接管执行失败并可恢复的Job通过检入操作，Scheduler也会更新自身的状态记录
org.quartz.jobStore.clusterCheckinInterval = 20000
#
## jobStore处理未按时触发的Job的数量
#
##org.quartz.jobStore.maxMisfiresToHandleAtATime = 20
#
## true/false,true则调用connection的setAutoCommit(false)方法
#
##org.quartz.jobStore.dontSetAutoCommitFalse = true
#
## 加锁的SQL语句，默认为SELECT * FROM {0}LOCKS WHERE LOCK_NAME = ? FOR UPDATE
#
## {0}=$@org.quartz.jobStore.tablePrefix
#
##org.quartz.jobStore.selectWithLockSQL = false
#
## true/false, true则调用connection的setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE) 方法
#
##org.quartz.jobStore.txIsolationLevelSerializable = false
#
## 触发job时是否需要拥有锁
#
org.quartz.jobStore.acquireTriggersWithinLock = true
#

下面是springboot的配置类


import java.io.IOException;
import java.util.Properties;


import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;

@Configuration
public class QuartzConfigure {

//    @Autowired
//    private DataSource dataSource;

    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
//        factory.setDataSource(dataSource);
        factory.setQuartzProperties(quartzProperties());
        factory.setStartupDelay(15);
        return factory;
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        //在quartz.properties中的属性被读取并注入后再初始化对象
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }

    /*
     * quartz初始化监听器
     */
    @Bean
    public QuartzInitializerListener executorListener() {
        return new QuartzInitializerListener();
    }

    /*
     * 通过SchedulerFactoryBean获取Scheduler的实例
     */
    @Bean(name="Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

}

这份配置是我自己整理的，大家在使用时需要修改数据库的连接，可能有人回问了，我们一般项目都会有数据库连接的配置，我这个quartz使用我配置好的database可以么？
以我目前的研究来看，不行，细心的观众朋友可能已经看到了，我的配置类里注释掉了database。一开始我是想用spring依赖注入来配置database，但是都不能行事。研究了一阵子发现好像是quartz在初始化，用此种依赖注入方式注入进来的database对象时错误的。而且网上也么找到使用非quartz数据库连接的例子。好在quartz不需要占用太多连接。

还有就是数据库表了

#
# Quartz seems to work best with the driver mm.mysql-2.0.7-bin.jar
#
# PLEASE consider using mysql with innodb tables to avoid locking issues
#
# In your Quartz properties file, you'll need to set 
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;


CREATE TABLE QRTZ_JOB_DETAILS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    JOB_NAME  VARCHAR(100) NOT NULL,
    JOB_GROUP VARCHAR(100) NOT NULL,
    DESCRIPTION VARCHAR(100) NULL,
    JOB_CLASS_NAME   VARCHAR(100) NOT NULL,
    IS_DURABLE VARCHAR(1) NOT NULL,
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_TRIGGERS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    JOB_NAME  VARCHAR(100) NOT NULL,
    JOB_GROUP VARCHAR(100) NOT NULL,
    DESCRIPTION VARCHAR(100) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(100) NULL,
    MISFIRE_INSTR SMALLINT(2) NULL,
    JOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);

CREATE TABLE QRTZ_SIMPLE_TRIGGERS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    REPEAT_COUNT BIGINT(7) NOT NULL,
    REPEAT_INTERVAL BIGINT(12) NOT NULL,
    TIMES_TRIGGERED BIGINT(10) NOT NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CRON_TRIGGERS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    CRON_EXPRESSION VARCHAR(100) NOT NULL,
    TIME_ZONE_ID VARCHAR(80),
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    STR_PROP_1 VARCHAR(120) NULL,
    STR_PROP_2 VARCHAR(120) NULL,
    STR_PROP_3 VARCHAR(120) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_BLOB_TRIGGERS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    BLOB_DATA BLOB NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_CALENDARS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    CALENDAR_NAME  VARCHAR(100) NOT NULL,
    CALENDAR BLOB NOT NULL,
    PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    TRIGGER_GROUP  VARCHAR(100) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);

CREATE TABLE QRTZ_FIRED_TRIGGERS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    ENTRY_ID VARCHAR(95) NOT NULL,
    TRIGGER_NAME VARCHAR(100) NOT NULL,
    TRIGGER_GROUP VARCHAR(100) NOT NULL,
    INSTANCE_NAME VARCHAR(100) NOT NULL,
    FIRED_TIME BIGINT(13) NOT NULL,
    SCHED_TIME BIGINT(13) NOT NULL,
    PRIORITY INTEGER NOT NULL,
    STATE VARCHAR(16) NOT NULL,
    JOB_NAME VARCHAR(100) NULL,
    JOB_GROUP VARCHAR(100) NULL,
    IS_NONCONCURRENT VARCHAR(1) NULL,
    REQUESTS_RECOVERY VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);

CREATE TABLE QRTZ_SCHEDULER_STATE
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    INSTANCE_NAME VARCHAR(100) NOT NULL,
    LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
    CHECKIN_INTERVAL BIGINT(13) NOT NULL,
    PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);

CREATE TABLE QRTZ_LOCKS
  (
    SCHED_NAME VARCHAR(80) NOT NULL,
    LOCK_NAME  VARCHAR(40) NOT NULL, 
    PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);

commit;

到这里我们的quartz配置就完成了，下面我们就开始Job

第三步 创建定时任务类

下面我就创建定时任务类,需要继承org.quartz.Job类

import com.lenovo.lmp.common.util.SpringUtil;
import com.lenovo.lmp.outbound.service.WmsPickIngSchedule;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyJob implements Job {
    private static final Logger logger = LoggerFactory.getLogger(MyJob.class);


    /**
     * 核心方法,Quartz Job真正的执行逻辑.
     * @param context 中封装有Quartz运行所需要的所有信息
     * @throws JobExecutionException execute()方法只允许抛出JobExecutionException异常
     */
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        logger.info("================= MyJob ===============");
        String result = "error";
        try{
            MySchedule mySchedule = SpringUtil.getBean("mySchedule", MySchedule.class);
            result = (String) mySchedule.start();
        } catch (Exception e) {
            e.printStackTrace();
        }
        logger.info("================= MyJob : " + result);
    }
}

我这个Job类没有交给spring管理，所以我用的spring容器通过bean id 来获取我所要用的service。
servce就是我们要执行的业务代码。这样一来我们整个job的编写就完成了。剩下就是启动job了。

第四步 自动

启动我们只需要几部

public void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{

        // 启动调度器
        scheduler.start();

        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).requestRecovery(true).build();

        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
                .withSchedule(scheduleBuilder).build();

        try {
            scheduler.scheduleJob(jobDetail, trigger);

        } catch (SchedulerException e) {
            System.out.println("创建定时任务失败"+e);
            throw new Exception("创建定时任务失败");
        }
    }

我们需要启动调度器，构建job,构建表达式，在通过调度器启动job，具体代码如上。

但是大家可能觉着这样代码太死，不方便，我这里可以给大家一个controller
增删改查都有



import com.alibaba.fastjson.JSONObject;
import com.lenovo.lmp.common.model.JobAndTrigger;
import com.lenovo.lmp.common.service.IJobAndTriggerService;
import com.lenovo.lmp.common.util.SpringUtil;
import com.lenovo.mstool.client.auth.provider.IgnoreServiceAuth;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;

import com.github.pagehelper.PageInfo;


@RestController
@RequestMapping(value="/job")
public class JobController
{
    @Autowired
    private IJobAndTriggerService iJobAndTriggerService;

    //加入Qulifier注解，通过名称注入bean
    @Autowired @Qualifier("Scheduler")
    private Scheduler scheduler;

    private static Logger log = LoggerFactory.getLogger(JobController.class);


    @PostMapping(value="/addjob")
    @ResponseBody
    public void addjob(@RequestBody String context) throws Exception
    {
        JSONObject json = JSONObject.parseObject(context);
        String jobClassName = json.getString("jobClassName");
        String jobGroupName = json.getString("jobGroupName");
        String cronExpression = json.getString("cronExpression");
        addJob(jobClassName, jobGroupName, cronExpression);
    }

    public void addJob(String jobClassName, String jobGroupName, String cronExpression)throws Exception{

        // 启动调度器
        scheduler.start();

        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName).getClass()).withIdentity(jobClassName, jobGroupName).requestRecovery(true).build();

        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
                .withSchedule(scheduleBuilder).build();

        try {
            scheduler.scheduleJob(jobDetail, trigger);

        } catch (SchedulerException e) {
            System.out.println("创建定时任务失败"+e);
            throw new Exception("创建定时任务失败");
        }
    }


    @PostMapping(value="/pausejob")
    @ResponseBody
    public void pausejob(@RequestBody String context) throws Exception
    {
        JSONObject json = JSONObject.parseObject(context);
        String jobClassName = json.getString("jobClassName");
        String jobGroupName = json.getString("jobGroupName");
        jobPause(jobClassName, jobGroupName);
    }

    public void jobPause(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.pauseJob(JobKey.jobKey(jobClassName, jobGroupName));
    }


    @PostMapping(value="/resumejob")
    @ResponseBody
    public void resumejob(@RequestBody String context) throws Exception
    {
        JSONObject json = JSONObject.parseObject(context);
        String jobClassName = json.getString("jobClassName");
        String jobGroupName = json.getString("jobGroupName");
        jobresume(jobClassName, jobGroupName);
    }

    public void jobresume(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.resumeJob(JobKey.jobKey(jobClassName, jobGroupName));
    }


    @PostMapping(value="/reschedulejob")
    @ResponseBody
    public void rescheduleJob(@RequestBody String context) throws Exception
    {
        JSONObject json = JSONObject.parseObject(context);
        String jobClassName = json.getString("jobClassName");
        String jobGroupName = json.getString("jobGroupName");
        String cronExpression = json.getString("cronExpression");
        jobreschedule(jobClassName, jobGroupName, cronExpression);
    }

    public void jobreschedule(String jobClassName, String jobGroupName, String cronExpression) throws Exception
    {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobClassName, jobGroupName);
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            // 按新的cronExpression表达式重新构建trigger
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            System.out.println("更新定时任务失败"+e);
            throw new Exception("更新定时任务失败");
        }
    }


    @PostMapping(value="/deletejob")
    @ResponseBody
    public void deletejob(@RequestBody String context) throws Exception
    {
        JSONObject json = JSONObject.parseObject(context);
        String jobClassName = json.getString("jobClassName");
        String jobGroupName = json.getString("jobGroupName");
        jobdelete(jobClassName, jobGroupName);
    }

    public void jobdelete(String jobClassName, String jobGroupName) throws Exception
    {
        scheduler.pauseTrigger(TriggerKey.triggerKey(jobClassName, jobGroupName));
        scheduler.unscheduleJob(TriggerKey.triggerKey(jobClassName, jobGroupName));
        scheduler.deleteJob(JobKey.jobKey(jobClassName, jobGroupName));
    }


    @PostMapping(value="/queryjob")
    @ResponseBody
    public Object queryjob(@RequestParam(value="pageNum")Integer pageNum, @RequestParam(value="pageSize")Integer pageSize)
    {
        PageInfo<JobAndTrigger> jobAndTrigger = iJobAndTriggerService.getJobAndTriggerDetails(pageNum, pageSize);
        JSONObject map = new JSONObject();
        map.put("JobAndTrigger", jobAndTrigger);
        map.put("number", jobAndTrigger.getTotal());
        return map;
    }

    public static Job getClass(String classname) throws Exception
    {
        Class<?> class1 = Class.forName(classname);
        return (Job)class1.newInstance();
    }


}



import java.util.List;
import java.util.Map;

import com.baomidou.mybatisplus.plugins.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.lenovo.common.util.Convert;
import com.lenovo.lmp.common.dao.JobAndTriggerMapper;
import com.lenovo.lmp.common.model.JobAndTrigger;
import com.lenovo.lmp.common.service.IJobAndTriggerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;




@Service
public class JobAndTriggerImpl implements IJobAndTriggerService {

    @Autowired
    private JobAndTriggerMapper jobAndTriggerMapper;

    public PageInfo<JobAndTrigger> getJobAndTriggerDetails(int pageNum, int pageSize) {
        PageHelper.startPage(pageNum, pageSize);
        List<JobAndTrigger> list = jobAndTriggerMapper.getJobAndTriggerDetails();
        PageInfo<JobAndTrigger> page = new PageInfo<JobAndTrigger>(list);
        return page;
    }

}



import java.util.List;
import org.apache.ibatis.annotations.Select;

import com.lenovo.lmp.common.model.JobAndTrigger;

public interface JobAndTriggerMapper {
    @Select(" <script> SELECT " +
                   "QRTZ_JOB_DETAILS.JOB_NAME," +
                   "QRTZ_JOB_DETAILS.JOB_GROUP," +
                   "QRTZ_JOB_DETAILS.JOB_CLASS_NAME," +
                   "QRTZ_TRIGGERS.TRIGGER_NAME," +
                   "QRTZ_TRIGGERS.TRIGGER_GROUP," +
                   "QRTZ_CRON_TRIGGERS.CRON_EXPRESSION," +
                   "QRTZ_CRON_TRIGGERS.TIME_ZONE_ID" +
                   " FROM " +
                   "QRTZ_JOB_DETAILS" +
                   " JOIN QRTZ_TRIGGERS" +
                   " JOIN QRTZ_CRON_TRIGGERS ON QRTZ_JOB_DETAILS.JOB_NAME = QRTZ_TRIGGERS.JOB_NAME" +
                   " AND QRTZ_TRIGGERS.TRIGGER_NAME = QRTZ_CRON_TRIGGERS.TRIGGER_NAME" +
                   " AND QRTZ_TRIGGERS.TRIGGER_GROUP = QRTZ_CRON_TRIGGERS.TRIGGER_GROUP </script>")
    List<JobAndTrigger> getJobAndTriggerDetails();
}

以上就是Query使用指南的全部内容，当然使用过程中还是有一些问题需要注意

  1. 定时任务时间设置的不要太短，有几率服务器卡顿导致上一个任务没跑完，下一个任务就触发了，会有问题。一般来说这个quartz配置是分布式的，多个服务器只要在一个数据库下就只会有一个定时任务再跑。到点就会跑，所以时间太短会导致有几率同时两个job在运行。

2.如果没有job，可能会有数据库连接中断异常抛出，但是没关系，我们用的mysql，如果长时间没有信息传递mysql会中断连接，导致服务器异常，我们在配置里有连接中断重新连接的配置，所以不用担心。如果设置数据库连接属性也会解决此问题，但是会导致不安全，不建议更改数据库设置。

定时任务Quartz
m0_60375943的博客
02-10 1308
新建项目 一，定时任务 使用的情况： 每周末凌晨备份数据 触发条件 5 分钟后发送邮件通知 30 分钟未支付取消订单 每 1 小时去拉取数据 Scheduled创建定时任务 在SpringBoot的启动类类中加⼊ @EnableScheduling 注解,启⽤定时任务的配置 二，创建定时任务实现类 在pom.xml中添加 <dependency> <groupId>org.pro...
Quartz任务调度快速入门
路虽远，行则将至；事虽难，做则必成！
06-03 1080
转自：http://www.simpleframework.net/blog/v/29912.html概述了解Quartz体系结构Quartz对任务调度的领域问题进行了高度的抽象，提出了调度器、任务和触发器这3个核心的概念，并在org.quartz通过接口和类对重要的这些核心概念进行描述：●Job：是一个接口，只有一个方法void execute(JobExecutionConte
Quartz使用
yefriendly的专栏
05-28 5924
Spring中使用Quartz的２种方法开发环境：Spring2.0。如果包类没有Quartz包，则需要加入到类路径。A:extends QuartzJobBean方法1：定义任务（extends QuartzJobBean）package onlyfun.bb.Quartz;import org.quartz.JobExecutionContext;import org.
Quartz之基本使用
2401_85111824的博客
06-24 1233
外链图片转存中…(img-lOeBTNZk-1719170132975)]
Quartz简单使用
葫芦娃的博客
09-07 981
最近看Quartz相关资料，借此博客记录自己的见解。 一、什么是Quartz Quartz是一个开源的作业调度框架（定时触发相关相关事件），是由java语言编写。 官网地址：http://www.quartz-scheduler.org/ 源码地址：https://github.com/quartz-scheduler/quartz 二、Quartz中的设计模式 1、建造者模式：所有关
quartz使用指南
04-01
quartz使用指南,quartz使用指南,quartz使用指南
Quartz开发指南.docx
09-14
Quartz 开发指南 Quartz 是一个功能强大的任务日程管理系统，它可以与任何其他软件系统集成或者一起使用。Quartz 的主要特点包括： * 能嵌入到任何独立的应用中运行 * 能在应用服务器或者 Servlet 容器中实例化，...
quartz开发指南
06-29
一旦你配置好Job实现类并设定好调度时间表，Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候，Quartz框架将调用你Job实现类（作业类）上的execute()方法并允许做它该做的事情。无需报告任何东西给...
Quartz基本使用
m0_60413225的博客
02-10 4882
（一）定时任务 在很多情况下任务并非需要立即执行,而是需要往后或定期执行,这不可能人工去操作,所以定时任务就出 现了 使用定时任务的情况: 每周末凌晨备份数据 触发条件 5 分钟后发送邮件通知 30 分钟未支付取消订单 每 1 小时去拉取数据 Scheduled创建定时任务 在SpringBoot的启动类类中加⼊ @EnableScheduling 注解,启⽤定时任务的配置 创建定时任务实现类 注： @Component @Slf4j public.
定时器quartz的使用方法
03-25
当服务启动时自动调用某一个类中的方法，相隔一段时间后再重复执行该方法（相隔时间在配置文件中自己配置，此例直接运行即可）
SpringBoot 任务调度(开发总结)
weixiaohuai的博客
09-06 2642
一、背景： 由于前段时间(一直在忙项目，现在才有空总结一下。。。。)搞微信开发，大家都知道，微信access_token是会过期的(7200s)，所以要定时刷新，基于此需求，所以把定时任务调度整合进了项目。其实实现定时任务有几种方法，有spring原生定时器功能、quartz也可以实现，但quartz配置起来麻烦（要配置JobDetail,Trigger,Scheduler等等），本文主要采用T...
142 Quartz
wang_luwei的博客
09-11 362
文章目录一、引言1.1简介二、Quartz使用2.1导入依赖2.2定义job2.3API测试2.4配置2.5核心类说明三、Trgger3.1 SimpleTrigger3.2 CronTrigger [重点]3.2.1 Cron表达式组成3.2.2 Cron表达式符号3.2.3 Cron表达式示例四、Spring整合Quartz 【重点】4.1依赖4.2定义job4.3配置4.4操作4.4.1启动任务4.4.2任务操作4.4.2.1删除任务4.4.2.2暂停、恢复4.4.2.5批量操作 一、引言 1.1简介
quartz使用
dongs的博客
01-18 461
Quartz可以用来做什么？Quartz是一个任务调度框架。在web开发中，比如你遇到这样的问题想每天3点，下发邮件到指定的地方想每年4月1日自己给朋友发一封贺卡这些问题总结起来就是：在某一个有规律的时间点干某件事。并且时间的触发的条件可以非常复杂（比如每月最后一个工作日的17:50），复杂到需要一个专门的框架来干这个事。 Quartz就是来干这样的事，你给它一个触发条件的定义，它负责到了时间点，
Quartz的使用
最新发布
小星袁
11-05 2847
Job：工作任务调度的接口，任务类需要实现该接口。在里面编写任务执行的业务逻辑。Job实例在Quartz中的生命周期：每次调度器执行Job时，它在调用execute方法前会创建一个新的Job实例，当调用完成后，关联的Job对象实例会被释放，释放的实例会被垃圾回收机制回收。JobDetail：JobDetail为Job实例提供了许多设置属性，以及JobDataMap成员变量属性，它用来存储特定Job实例的状态信息，调度器需要借助JobDetail对象来添加Job实例。
Quartz使用方法
qq_21195045的博客
12-05 351
Quartz使用方法（源于官网http://www.quartz-scheduler.org/） 1、Maven管理quartz        org.quartz-scheduler      quartz      2.2.1          org.quartz-scheduler      quartz-jobs      2.2.1     2、实例化和执行
quartz 使用方法
David.tsai的博客
04-20 451
quartz 使用方法
quartz使用(一)
摩羯座
01-15 1328
quartz是方便的定时任务框架，这里是一个简单、入门的例子
Quartz作业调度框架详解与使用指南
"Quartz开发指南，作业调度" Quartz是一个强大的开源作业调度框架，专为Java应用程序设计，提供了一种灵活的方式来安排和执行作业。...通过学习和使用Quartz，开发者能够构建出高效、可靠的后台自动化处理系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

上单白起

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值