SSM整合Quartz(MySql，SpringMVC，Spring，Mybatis)

最新推荐文章于 2022-07-21 09:10:08 发布

zdwhong

最新推荐文章于 2022-07-21 09:10:08 发布

阅读量582

点赞数 2

分类专栏： Quartz 文章标签： Quartz SSM

本文链接：https://blog.csdn.net/zengdongwen/article/details/101270892

版权

Quartz 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

1、Quartz下载

Quartz下载地址：http://www.quartz-scheduler.org/downloads/，本自行选择下载不同的版

2、表的作用及其字段含义

2.1 创建表的语句的sql文件位置

对应不同的数据库，Quartz提供了不同的sql脚本来创建qrtz_开头的11张表，sql脚本在docs\dbTables下面。

2.2 11张表的主要用途：

序号表名说明
1. qrtz_calendars 以 Blob 类型存储 Quartz 的 Calendar 信息
2. qrtz_cron_triggers 存储 Cron类型的Trigger，包括 Cron 表达式和时区信息
3. qrtz_fired_triggers 存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息
4. qrtz_paused_trigger_grps 存储已暂停的 Trigger 组的信息
5. qrtz_scheduler_state 存储少量的有关调度器 (Scheduler) 的状态，和别的调度器 (Scheduler)实例(假如是用于一个集群中)
6. qrtz_locks 存储程序的非观锁的信息(假如使用了悲观锁)
7. qrtz_job_details 存储每一个已配置的 Job 的详细信息(jobDetail)
8. qrtz_job_listeners 存储有关已配置的 Job 监听器的信息
9. qrtz_simple_triggers 存储简单的 Trigger，包括重复次数，间隔，以及已触的次数
10. qrtz_blog_triggers 以 Blob 类型存储的Trigger(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，JobStore 并不知道如何存储实例的时候)
11. qrtz_trigger_listeners 存储已配置的触发器监听器 ( Trigger Listener ) 的信息
12. qrtz_triggers 存储已配置的触发器 (Trigger) 的信息

注意：上面加粗的四张表，是cron方式需要用到的4张数据表，这次主要使用的就是这种模式。

2.3 表字段含义

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;
--保存job详细信息的表
CREATE TABLE QRTZ_JOB_DETAILS(
    SCHED_NAME VARCHAR(120) NOT NULL,--调度程序的名称
    JOB_NAME VARCHAR(200) NOT NULL,--job的名字
    JOB_GROUP VARCHAR(200) NOT NULL,--job所属组的名称
    DESCRIPTION VARCHAR(250) NULL,
    JOB_CLASS_NAME VARCHAR(250) NOT NULL,--job实现类的类全名,quartz就是根据这个路径到classpath找到该job类
    IS_DURABLE VARCHAR(1) NOT NULL,--是否持久化,值为1，quartz会把job持久化到数据库中
    IS_NONCONCURRENT VARCHAR(1) NOT NULL,
    IS_UPDATE_DATA VARCHAR(1) NOT NULL,
    REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
    JOB_DATA BLOB NULL,--一个blob字段，存放持久化job对象
    PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
)ENGINE=InnoDB;

--保存trigger触发器信息表
CREATE TABLE QRTZ_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,--调度程序的名称
    TRIGGER_NAME VARCHAR(200) NOT NULL,--触发器名称
    TRIGGER_GROUP VARCHAR(200) NOT NULL,--触发器所属组名称
    JOB_NAME VARCHAR(200) NOT NULL,--job名称，对应QRTZ_JOB_DETAILS的JOB_NAME
    JOB_GROUP VARCHAR(200) NOT NULL,--job所属组的名称，对应QRTZ_JOB_DETAILS的JOB_GROUP 
    DESCRIPTION VARCHAR(250) NULL,
    NEXT_FIRE_TIME BIGINT(13) NULL,
    PREV_FIRE_TIME BIGINT(13) NULL,
    PRIORITY INTEGER NULL,
    TRIGGER_STATE VARCHAR(16) NOT NULL,--当前trigger状态，设置为ACQUIRED,如果设置为WAITING,则job不会触发
    TRIGGER_TYPE VARCHAR(8) NOT NULL,
    START_TIME BIGINT(13) NOT NULL,
    END_TIME BIGINT(13) NULL,
    CALENDAR_NAME VARCHAR(200) 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))--指明了和表QRTZ_JOB_DETAILS外键关系
ENGINE=InnoDB;

--存储simple触发器表
CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) 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))
ENGINE=InnoDB;

--存储cron表达式表
CREATE TABLE QRTZ_CRON_TRIGGERS (
    SCHED_NAME VARCHAR(120) NOT NULL,--调度程序名称
    TRIGGER_NAME VARCHAR(200) NOT NULL,--触发器名称
    TRIGGER_GROUP VARCHAR(200) NOT NULL,--触发器所属组名称
    CRON_EXPRESSION VARCHAR(120) NOT NULL,--cron表达式
    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))--指明了和表QRTZ_TRIGGERS外键关系
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) 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))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) 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(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit;

2、环境搭建

用IDEA搭建一个maven工程，引入相关的依赖（我引入的依赖有些是本次没用的）。最终的工程结构如下：

2.1 pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zdw.quartz</groupId>
    <artifactId>spring-quartz-web2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <!--打包方式为war-->
    <packaging>war</packaging>

    <!-- 提取版本属性 -->
    <properties>
        <spring.version>4.2.4.RELEASE</spring.version>
        <mybatis.version>3.2.8</mybatis.version>
        <mybatis.spring.version>1.2.2</mybatis.spring.version>
        <slf4j.version>1.6.4</slf4j.version>
        <log4j.version>1.2.17</log4j.version>
        <jackson.version>2.4.2</jackson.version>
        <druid.version>1.0.9</druid.version>
        <mysql.version>5.1.32</mysql.version>
        <jstl.version>1.2</jstl.version>
        <servlet-api.version>2.5</servlet-api.version>
        <jsp-api.version>2.0</jsp-api.version>
        <commons-io.version>1.3.2</commons-io.version>
        <commons-fileupload.version>1.3.1</commons-fileupload.version>
    </properties>

    <!-- 版本锁定 -->
    <dependencyManagement>
        <dependencies>
            <!-- Spring -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-webmvc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aspects</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jms</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>

            <!-- Mybatis -->
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>${mybatis.version}</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>${mybatis.spring.version}</version>
            </dependency>

            <!-- 日志处理 -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>${log4j.version}</version>
            </dependency>

            <!-- Jackson Json处理工具包 -->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>${jackson.version}</version>
            </dependency>

            <!-- 连接池 -->
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>${druid.version}</version>
            </dependency>

            <!-- MySql -->
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>${mysql.version}</version>
            </dependency>

            <!-- io包 -->
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons-io.version}</version>
            </dependency>

            <!-- 文件上传组件 -->
            <dependency>
                <groupId>commons-fileupload</groupId>
                <artifactId>commons-fileupload</artifactId>
                <version>${commons-fileupload.version}</version>
            </dependency>

            <!-- JSP相关 -->
            <dependency>
                <groupId>jstl</groupId>
                <artifactId>jstl</artifactId>
                <version>${jstl.version}</version>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>servlet-api</artifactId>
                <version>${servlet-api.version}</version>
                <scope>provided</scope>
            </dependency>
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>jsp-api</artifactId>
                <version>${jsp-api.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- 添加依赖 -->
    <dependencies>
        <!-- Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <!-- Mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
        </dependency>

        <!-- 日志处理 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
        </dependency>

        <!-- Jackson Json处理工具包 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

        <!-- 连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
        </dependency>

        <!-- MySql -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!-- io包 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
        </dependency>

        <!-- 文件上传组件 -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
        </dependency>

        <!-- JSP相关 -->
        <dependency>
            <groupId>jstl</groupId>
            <artifactId>jstl</artifactId>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jsp-api</artifactId>
            <scope>provided</scope>
        </dependency>

        <!--quartz依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>

    </dependencies>

    <build>
        <!-- java编译插件 -->
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
        </plugins>

        <!--配置资源文件映射 -->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

2.2 配置文件

2.2.1 db.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_quartz?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123

2.2.2 log4j.properties

### set log levels ###
log4j.rootLogger = INFO,D

###输出到控制台###
log4j.logger.toConsole=debug,stdout
log4j.appender.stdout = org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target = System.out
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout


log4j.appender.stdout.layout.ConversionPattern =%d{yyyy-MM-dd HH\:mm\:ss} [%5p] - %c -%F(%L) -%m%n

### 输出到日志文件 ###
##  其中File 可以采用绝对路径 亦可以采用相对路径 catalina.home 是tomcat目录  如果没有logs文件夹 将会报错  ##
##  更加倾向于将日志文件放在  tomcat的日志目录下${catalina.home}/logs/salesmanb2bError.log ##
##  绝对路径如：e:/salesmanb2bError.log ##
log4j.logger.daily=INFO,D
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = ${catalina.home}/logs/helloworld/helloworld.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = INFO
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern =%d{yyyy-MM-dd HH\:mm\:ss} [%5p] - %c -%F(%L) -%m%n


##log4j.logger.org.apache.ibatis=debug,stdout
##log4j.logger.java.sql=debug,stdout

2.2.3 applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
						http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
						http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    <!-- 加载数据库连接信息配置文件 -->
    <context:property-placeholder location="classpath:db.properties" />

    <!--druid连接池  -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--<bean id="customJobFactory" class="com.zdw.quartz.factory.CustomJobFactory"></bean>-->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="dataSource" ref="dataSource" /> <!-- 这里就设置Spring的数据源就行了 -->
        <property name="schedulerName" value="MyScheduler"/>
        <property name="overwriteExistingJobs" value="true"/>
        <!-- 必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动  -->
        <property name="startupDelay" value="2" />
        <!--<property name="jobFactory" ref="customJobFactory"/>-->
        <property name="configLocation" value="classpath:quartz.properties" />
    </bean>

    <!-- 开启事物 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
    <!-- 事物注解驱动-->
    <tx:annotation-driven />
</beans>

2.2.4 springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
						http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
						http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">

    <!-- 配置扫描注解  @Controller @Service -->
    <context:component-scan base-package="com.zdw.quartz" />

    <!-- SpringMVC使用<mvc:annotation-driven>自动加载RequestMappingHandlerMapping和RequestMappingHandlerAdapter -->
    <mvc:annotation-driven />

    <!-- 配置静态资源映射 -->
    <!--
    <mvc:resources location="/js/" mapping="/js/**"/>
    <mvc:resources location="/css/" mapping="/css/**"/>
     <mvc:resources location="/imgs/" mapping="/imgs/**"/>
     <mvc:resources location="/font/" mapping="/font/**"/>
     -->

    <!-- 配置视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!-- 配置逻辑视图的前缀 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 配置逻辑视图的后缀 -->
        <property name="suffix" value=".jsp" />

    </bean>

</beans>

2.2.5 quartz的核心配置文件quartz.properties

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#
#集群配置
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.instanceId = zdw
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
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000
org.quartz.jobStore.clusterCheckinInterval = 20000  
org.quartz.jobStore.isClustered = true  
#============================================================================
# Configure JobStore
#============================================================================
#默认配置，数据保存到内存
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
#持久化配置
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties:true
#数据库表前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS

#============================================================================
# Configure Datasources
#============================================================================
#JDBC驱动
org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/spring_quartz?characterEncoding=utf-8
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:123

2.3 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
		  http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

    <display-name>spring-quartz-web2</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>

    <!-- spring监听器 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 指定spring核心配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>

    <!-- 处理POST提交乱码问题 -->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!-- 配置前端控制器 -->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定配置文件位置和名称 如果不设置,默认找/WEB-INF/<servlet-name>-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

3、代码实现

3.1 后端代码

3.1.1 封装quartz信息的pojo

package com.zdw.quartz.pojo;

import java.io.Serializable;
import java.util.Date;

public class QuartzInfo implements Serializable {
    private java.lang.String schedName;//调度器名称
    private java.lang.String jobName;//job名称
    private java.lang.String jobGroup;//job所属组名
    private java.lang.String description;
    private java.lang.String jobClassName;//job类的全限定名
    private java.lang.String isDurable;//是否持久化，1表示持久化
    private java.lang.String isNonconcurrent;
    private java.lang.String isUpdateData;
    private java.lang.String requestsRecovery;
    private byte[] jobData;//blob字段，存储持久化信息
    private java.lang.String triggerName;//trigger的名称
    private java.lang.String triggerGroup;//trigger所属组名
    private java.lang.String cronExpression;//cron表达式
    private java.util.Date nextFireTime;//下次执行时间
    private java.util.Date prevFireTime;//上次执行时间
    private java.util.Date startTime;//开始时间
    private java.lang.String priority;//优先级
    private java.lang.String triggerState;//trigger的状态
    private Integer timeValue;
    private String timeType;

    /get/set方法
}

3.3.2 CustomJobFactory

要让Quartz的Job使用Spring注入的Bean，就需要自定义工程类，具体可参考：https://blog.csdn.net/a67474506/article/details/38402059

package com.zdw.quartz.factory;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;

public class CustomJobFactory extends SpringBeanJobFactory {

    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        //进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

3.3.3 WebContextListener

当项目重启的时候，需要查询数据库中已经存在的定时任务，然后启动，所以需要书写一个监听器类，监听到项目的启动，主要是使用注解：@PostConstruct。

package com.zdw.quartz.listener;

import com.zdw.quartz.service.QuartzService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;

/**
 * 项目启动就查询数据库的定时任务并执行
 */
@Component
public class WebContextListener {

    @Autowired
    private QuartzService quartzService;

    @PostConstruct//这个注解至关重要
    public void init() {
        System.err.println("-------------------------项目启动，定时任务开启-----------------------");
        try {
            quartzService.resumeAll();//查询数据库所有的定时任务，并启动
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

注意：因为上面我们的类上加了注解：@Component，并且，该类也是在com.zdw.quartz包的子包下面的，而我们的项目启动时候会扫描com.zdw.quartz及其子包下面的bean（这在springmvc.xml中有配置）。所以项目启动的时候，会去实例化该类：WebContextListener，实例化的时候就会执行init方法。

3.3.4 自定义简单的job

package com.zdw.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class QuartzJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("--------------第一个测试job开始执行----------------");
        try {
            Thread.sleep(4000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("++++++++++++++第一个测试job执行完成++++++++++++++++");
    }
}

3.3.5 定义接口QuartzService

为了遵循面向接口开发的特性，定义接口QuartzService，实现job的动态增删改查操作：

package com.zdw.quartz.service;

import com.zdw.quartz.pojo.QuartzInfo;
import org.quartz.JobDetail;
import org.quartz.SchedulerException;

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

public interface QuartzService {
    /**
     * 查询所有定时任务列表
     */
    List<QuartzInfo> getAllJobList() throws Exception;

    /**
     * 新增cron任务
     * @param entity
     * @return
     */
    boolean addCronJob(QuartzInfo entity) throws Exception;

    /**
     * 查询数据库中定时任务，并启动
     */
    void resumeAll();

    /**
     * 暂停任务
     * @param entity
     */
    void pauseJob(QuartzInfo entity) throws SchedulerException;

    /**
     * 恢复任务，对应暂停任务
     * @param entity
     */
    void resumeJob(QuartzInfo entity) throws SchedulerException;

    /**
     * 立即执行任务（只执行一次）
     * @param entity
     */
    void triggerJob(QuartzInfo entity) throws SchedulerException;


    /**
     * 删除任务
     * @param entity
     */
    void deleteJob(QuartzInfo entity) throws SchedulerException;

    /**
     * 修改定时任务
     * @param entity
     */
    void editJob(QuartzInfo entity) throws Exception;
}

3.3.6 定义实现类QuartzServiceImpl

package com.zdw.quartz.service.impl;

import com.zdw.quartz.pojo.QuartzInfo;
import com.zdw.quartz.service.QuartzService;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.io.InputStream;
import java.util.*;

/**
 * Create By zdw on 2019/9/30
 */
@Service
public class QuartzServiceImpl implements QuartzService {

    @Autowired
    private Scheduler scheduler;//这种方式是吧调度容器交给spring管理

    //这种方式是手动的初始化调度容器
    //private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();// 初始化调度容器

    @Override
    public List<QuartzInfo> getAllJobList() throws Exception {
        //Scheduler scheduler = schedulerFactory.getScheduler();

        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);

        List<QuartzInfo> jobList = new ArrayList<>(jobKeys.size());
        for (JobKey jobKey : jobKeys) {
            QuartzInfo entity = new QuartzInfo();
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);//根据jobKey得到所有的相关触发器
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            entity.setJobName(jobDetail.getKey().getName());
            entity.setJobGroup(jobDetail.getKey().getGroup());
            Class<? extends Job> jobClass = jobDetail.getJobClass();
            Class<? extends Class> aClass = jobClass.getClass();
            entity.setJobClassName(jobClass.toString());

            for (Trigger trigger : triggers) {
                entity.setTriggerName(trigger.getKey().getName());
                entity.setTriggerGroup(trigger.getKey().getGroup());
                entity.setStartTime(trigger.getStartTime());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());//触发器状态
                entity.setTriggerState(triggerState.name());//设置触发器状态
                Date nextFireTime = trigger.getNextFireTime();//下次执行时间
                if(!StringUtils.isEmpty(nextFireTime)){
                    entity.setNextFireTime(new Date(nextFireTime.getTime()));//下次执行时间
                    entity.setSchedName(scheduler.getSchedulerName());//调度器名称
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        entity.setCronExpression(cronExpression);//设置cron表达式的值
                    }else if(trigger instanceof SimpleTrigger){
                        SimpleTrigger simpleTrigger = (SimpleTrigger) trigger;
                        long milliseconds = simpleTrigger.getRepeatInterval();
                        entity.setTimeValue((int) (milliseconds/1000));
                    }
                    jobList.add(entity);//添加到集合中
                }
            }
        }

        return jobList;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean addCronJob(QuartzInfo entity) throws Exception {
        //Scheduler scheduler = schedulerFactory.getScheduler();//手动管理
        JobDetail jobDetail = JobBuilder
                .newJob((Class<? extends Job>) Class.forName(entity.getJobClassName()))
                .withIdentity(entity.getJobName(),entity.getJobGroup())
                .build();
        /*withMisfireHandlingInstructionDoNothing
            ——不触发立即执行
            ——等待下次Cron触发频率到达时刻开始按照Cron频率依次执行

            withMisfireHandlingInstructionIgnoreMisfires
            ——以错过的第一个频率时间立刻开始执行
            ——重做错过的所有频率周期后
            ——当下一次触发频率发生时间大于当前时间后，再按照正常的Cron频率依次执行

            withMisfireHandlingInstructionFireAndProceed
            ——以当前时间为触发频率立刻触发一次执行
            ——然后按照Cron频率依次执行*/
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(entity.getTriggerName(),entity.getTriggerGroup())
                .startNow()
                .withSchedule(CronScheduleBuilder.cronSchedule(entity.getCronExpression()).withMisfireHandlingInstructionFireAndProceed())
                .build();
        //构建任务
        scheduler.scheduleJob(jobDetail, trigger);
        // 启动
        if (!scheduler.isShutdown())
            scheduler.start();
        return true;
    }

    @Override
    public void resumeAll() {
        try {
            /*Properties prop = new Properties();
            InputStream in = this.getClass().getResourceAsStream("/quartz.properties");
            prop.load(in);
            prop.setProperty("org.quartz.dataSource.qzDS.driver", "com.mysql.jdbc.Driver");
            prop.setProperty("org.quartz.dataSource.qzDS.URL", "jdbc:mysql://localhost:3306/spring_quartz?characterEncoding=utf-8");
            prop.setProperty("org.quartz.dataSource.qzDS.user", "root");
            prop.setProperty("org.quartz.dataSource.qzDS.password", "123");
            //prop.setProperty("org.quartz.dataSource.qzDS.maxConnection", "");
            SchedulerFactory schedulerFactory = new StdSchedulerFactory(prop);
            Scheduler scheduler = schedulerFactory.getScheduler();*/
            //-------------------------上面这种方式是手动处理---------------------

            scheduler.start();
            System.out.println("---------------恢复所有的任务-------------");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void pauseJob(QuartzInfo entity) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(entity.getJobName(), entity.getJobGroup());
        scheduler.pauseJob(jobKey);//暂停任务
    }

    @Override
    public void resumeJob(QuartzInfo entity) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(entity.getJobName(), entity.getJobGroup());
        scheduler.resumeJob(jobKey);//恢复任务
    }

    @Override
    public void triggerJob(QuartzInfo entity) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(entity.getJobName(), entity.getJobGroup());
        scheduler.triggerJob(jobKey);
    }

    @Override
    public void deleteJob(QuartzInfo entity) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(entity.getJobName(), entity.getJobGroup());
        scheduler.pauseJob(jobKey);//暂停任务
        scheduler.deleteJob(jobKey);//删除任务
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void editJob(QuartzInfo entity) throws Exception {
        //得到页面传过来的下一次执行时间
        Date nextFireTime = entity.getNextFireTime();

        TriggerKey triggerKey = TriggerKey.triggerKey(entity.getTriggerName(), entity.getTriggerGroup());
        CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(triggerKey);
        if(cronTrigger==null){
            throw new RuntimeException("trigger不存在");
        }
        String cronExpression = cronTrigger.getCronExpression();
        Date nextFireTime1 = cronTrigger.getNextFireTime();//数据库本来的下一次执行时间
        if(nextFireTime.equals(nextFireTime1)){//说明只修改了cron表达式
            if(cronExpression.equals(entity.getCronExpression())){//说明修改了cron表达式
                cronTrigger = TriggerBuilder.newTrigger()
                        .withIdentity(entity.getTriggerName(),entity.getTriggerGroup())
                        .startNow()
                        .withSchedule(CronScheduleBuilder.cronSchedule(entity.getCronExpression()).withMisfireHandlingInstructionFireAndProceed())
                        .build();
                // 按新的trigger重新设置job执行
                scheduler.rescheduleJob(triggerKey,cronTrigger);
            }

        }else{//说明要修改下次执行时间，那就只能先删除改定时任务，然后新增一个新的
            deleteJob(entity);//删除
            addCronJob(entity);//新增
        }

    }
}

3.3.7 定义控制器QuartzController

控制器用来接收页面的请求，并响应浏览器；

package com.zdw.quartz.controller;

import com.zdw.quartz.pojo.QuartzInfo;
import com.zdw.quartz.service.QuartzService;
import org.quartz.JobDetail;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;

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

@Controller
@RequestMapping("/quartz")
public class QuartzController {

    @Autowired
    private QuartzService quartzService;

    //这个方法是接收json类型的数据，用posman进行测试用的
    @RequestMapping(value = "/addCronJobForJson",method = RequestMethod.POST)
    @ResponseBody
    public Map<String,Object> addCronJobForJson(@RequestBody QuartzInfo entity){
        Map<String,Object> result = new HashMap<>();
        try {
            boolean isTrue= quartzService.addCronJob(entity);
            if(isTrue){
                result.put("success",true);
                result.put("msg","添加成功");
            }else{
                result.put("success",true);
                result.put("msg","添加失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");

        }
        return result;
    }

    //添加一个任务，这方法是接收页面的表单参数的
    @RequestMapping(value = "/addCronJob")
    @ResponseBody
    public Map<String,Object> addCronJob(QuartzInfo entity){
        Map<String,Object> result = new HashMap<>();
        try {
            quartzService.addCronJob(entity);
            result.put("success",true);
            result.put("msg","添加成功");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");
        }
        return result;
    }

    @RequestMapping("quartzList")
    public ModelAndView getAllList(){
        ModelAndView modelAndView = new ModelAndView();
        List<QuartzInfo> quartzList = null;
        try {
            quartzList = quartzService.getAllJobList();
        } catch (Exception e) {
            e.printStackTrace();
        }
        modelAndView.addObject("quartzList",quartzList);
        modelAndView.setViewName("quartzList");
        return modelAndView;
    }

    //暂停当前任务
    @RequestMapping(value = "/pauseJob",method = RequestMethod.PUT)
    @ResponseBody
    public Map<String,Object> pauseCronJob(@RequestParam("jobName") String jobName,
                                           @RequestParam("jobGroup") String jobGroup){
        Map<String,Object> result = new HashMap<>();
        try {
            QuartzInfo entity = new QuartzInfo();
            entity.setJobName(jobName);
            entity.setJobGroup(jobGroup);
            //调用方法进行暂停
            quartzService.pauseJob(entity);
            result.put("success",true);
            result.put("msg","暂停任务成功");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");
        }
        return result;
    }

    //恢复当前任务，对应暂停任务
    @RequestMapping(value = "resumeJob",method = RequestMethod.PUT)
    @ResponseBody
    public Map<String,Object> resumeJob(@RequestParam("jobName") String jobName,
                                           @RequestParam("jobGroup") String jobGroup){
        Map<String,Object> result = new HashMap<>();
        try {
            QuartzInfo entity = new QuartzInfo();
            entity.setJobName(jobName);
            entity.setJobGroup(jobGroup);
            //调用方法进行暂停
            quartzService.resumeJob(entity);
            result.put("success",true);
            result.put("msg","恢复任务成功");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","恢复任务出现异常");
        }
        return result;
    }

    //删除一个任务
    @RequestMapping(value = "/deleteJob",method = RequestMethod.DELETE)
    @ResponseBody
    public Map<String,Object> deleteCronJob(@RequestParam("jobName") String jobName,
                                            @RequestParam("jobGroup") String jobGroup){
        Map<String,Object> result = new HashMap<>();
        try {
            QuartzInfo entity = new QuartzInfo();
            entity.setJobName(jobName);
            entity.setJobGroup(jobGroup);
            //调用方法进行删除
            quartzService.deleteJob(entity);
            result.put("success",true);
            result.put("msg","删除成功");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");
        }
        return result;
    }

    //立即执行当前任务（只执行一次，之后按cron表达式执行）
    @RequestMapping(value = "/startJobNow",method = RequestMethod.GET)
    @ResponseBody
    public Map<String,Object> startCronJobNow(@RequestParam("jobName") String jobName,
                                              @RequestParam("jobGroup") String jobGroup){
        Map<String,Object> result = new HashMap<>();
        try {
            QuartzInfo entity = new QuartzInfo();
            entity.setJobName(jobName);
            entity.setJobGroup(jobGroup);
            //调用方法进行启动
            quartzService.triggerJob(entity);
            result.put("success",true);
            result.put("msg","执行成功，该定时任务执行了一次");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");
        }
        return result;
    }

    //修改定时任务，一般只允许修改cron表达式和下次执行时间
    @RequestMapping(value = "/editJob",method = RequestMethod.POST)
    @ResponseBody
    public Map<String,Object> editJob(QuartzInfo entity){
        Map<String,Object> result = new HashMap<>();
        try {
            //调用方法进行启动
            quartzService.editJob(entity);
            result.put("success",true);
            result.put("msg","修改成功");
        } catch (Exception e) {
            e.printStackTrace();
            result.put("success",false);
            result.put("msg","出现异常");
        }
        return result;
    }
}

3.2 前端代码

3.2.1 首页index.jsp

index.jsp必须放到webapp根目录下，就是要和WEB-INF同级，不能放到其下面，否则项目启动是找不到index.jsp页面的。index.jsp页面中只有一个连接，可以进入到定时任务的列表管理页面。当我们没有写任何代码，启动服务，应该就能访问index.jsp页面的。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>首页</title>
</head>
<body>
    SSM项目的首页<br/>
    <a href="${pageContext.request.contextPath}/quartz/quartzList">定时任务列表</a><br/>
</body>
</html>

3.2.2 quartzList.jsp

这个页面是定时任务列表管理页面，可以对定时任务进行动态的增删改查，用到了bootstrap，不过可能样式不好看，前端不熟练。

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>定时任务列表</title>
    <link rel="stylesheet" href="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/css/bootstrap.min.css">
    <script src="https://cdn.staticfile.org/jquery/2.1.1/jquery.min.js"></script>
    <script src="https://cdn.staticfile.org/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>

</head>
<body>
<table class="table table-bordered" id="table">
    <thead>
    <tr>
        <th scope="col" width="30px">序号</th>
        <th scope="col" width="120px">触发器名称</th>
        <th scope="col" width="50px">触发器所属组名称</th>
        <th scope="col" width="120px">任务名称</th>
        <th scope="col" width="50px">任务所属组名称</th>
        <th scope="col" width="300px">任务的类全名</th>
        <th scope="col" width="100px">cron表达式</th>
        <th scope="col" width="50px">触发器状态</th>
        <th scope="col" width="100px">下次执行时间</th>
        <th scope="col" width="150px">操作</th>
    </tr>
    </thead>
    <tbody>
    <c:forEach items="${quartzList}" var="quartz" varStatus="status">
        <tr>
            <th scope="row" width="30px" id="id">${ status.index + 1}</th>
            <td width="120px">${quartz.triggerName}</td>
            <td width="50px">${quartz.triggerGroup}</td>
            <td width="120px">${quartz.jobName}</td>
            <td width="50px">${quartz.jobGroup}</td>
            <td width="300px">${quartz.jobClassName}</td>
            <td width="100px">${quartz.cronExpression}</td>
            <td width="50px">${quartz.triggerState}</td>
            <td width="100px"><fmt:formatDate pattern="yyyy-MM-dd HH:mm:ss" value="${quartz.nextFireTime}"/></td>
            <td width="150px">
                <button class="btn btn-primary btn-sm" onclick="pauseJob('${quartz.jobName}','${quartz.jobGroup}')">暂停</button>
                <button class="btn btn-primary btn-sm" onclick="resumeJob('${quartz.jobName}','${quartz.jobGroup}')">恢复</button>
                <button class="btn btn-primary btn-sm" onclick="deleteJob('${quartz.jobName}','${quartz.jobGroup}')">删除</button>
                <button class="btn btn-primary btn-sm" onclick="startJobNow('${quartz.jobName}','${quartz.jobGroup}')">执行</button>
                <button class="btn btn-primary btn-sm" onclick="openEditModal('${ status.index + 1}')">修改</button>
            </td>
        </tr>
    </c:forEach>
    </tbody>
</table>


<%--新增的模态框--%>
<!-- 按钮触发模态框 -->
<button class="btn btn-primary btn-sm" data-toggle="modal" data-target="#addModal">点击新增定时任务</button>
<!-- 模态框（Modal） -->
<div class="modal fade" id="addModal" tabindex="-1" role="dialog" aria-labelledby="myModalLabel" aria-hidden="true">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
                <h4 class="modal-title" id="addModalLabel">定时任务新增</h4>
            </div>
            <div class="modal-body">
                <form role="form" id="form">
                    <div class="form-group">
                        <label for="jobName">job名称</label>
                        <input type="text" class="form-control" name="jobName" id="jobName" placeholder="请输入">
                    </div>
                    <div class="form-group">
                        <label for="jobGroup">jobGroup组名称</label>
                        <input type="text" class="form-control" name="jobGroup" id="jobGroup" placeholder="请输入">
                    </div>
                    <div class="form-group">
                        <label for="triggerName">trigger名称</label>
                        <input type="text" class="form-control" name="triggerName" id="triggerName" placeholder="请输入">
                    </div>
                    <div class="form-group">
                        <label for="triggerGroup">triggerGroup组名称</label>
                        <input type="text" class="form-control" name="triggerGroup" id="triggerGroup" placeholder="请输入">
                    </div>
                    <div class="form-group">
                        <label for="cronExpression">cron表达式</label>
                        <input type="text" class="form-control" name="cronExpression" id="cronExpression" placeholder="请输入">
                    </div>
                    <div class="form-group">
                        <label for="jobClassName">job实现类的完全路径</label>
                        <input type="text" class="form-control" name="jobClassName" id="jobClassName" placeholder="请输入">
                    </div>
                    <button type="button" class="btn btn-default" data-dismiss="modal">关闭</button>
                    <button type="submit" class="btn btn-default" onclick="addCronJob()">提交</button>
                </form>
            </div>
        </div><!-- /.modal-content -->
    </div><!-- /.modal-dialog -->
</div>



<%--修改的模态框--%>
<!-- 模态框（Modal） -->
<div class="modal fade" id="editModal" tabindex="-1" role="dialog" aria-labelledby="editModalLabel" aria-hidden="true">
    <div class="modal-dialog">
        <div class="modal-content">
            <div class="modal-header">
                <button type="button" class="close" data-dismiss="modal" aria-hidden="true">×</button>
                <h4 class="modal-title" id="editModalLabel">定时任务修改</h4>
            </div>
            <div class="modal-body">
                <form role="form" id="formEdit">
                    <div class="form-group">
                        <label for="jobName">job名称</label>
                        <input type="text" class="form-control" name="jobName" id="jobNameEdit" disabled>
                    </div>
                    <div class="form-group">
                        <label for="jobGroup">jobGroup组名称</label>
                        <input type="text" class="form-control" name="jobGroup" id="jobGroupEdit" disabled>
                    </div>
                    <div class="form-group">
                        <label for="triggerName">trigger名称</label>
                        <input type="text" class="form-control" name="triggerName" id="triggerNameEdit" disabled>
                    </div>
                    <div class="form-group">
                        <label for="triggerGroup">triggerGroup组名称</label>
                        <input type="text" class="form-control" name="triggerGroup" id="triggerGroupEdit" disabled>
                    </div>
                    <div class="form-group">
                        <label for="cronExpression">cron表达式</label>
                        <input type="text" class="form-control" name="cronExpression" id="cronExpressionEdit">
                    </div>
                    <div class="form-group">
                        <label for="jobClassName">job实现类的完全路径</label>
                        <input type="text" class="form-control" name="jobClassName" id="jobClassNameEdit" disabled>
                    </div>
                    <%--<div class="form-group">
                        <label for="nextFireTime">下次执行时间</label>
                        <input type="text" class="form-control" name="nextFireTime" id="nextFireTimeEdit" >
                    </div>--%>
                    <button type="button" class="btn btn-default" data-dismiss="modal">关闭</button>
                    <button type="submit" class="btn btn-default" onclick="editCronJob()">修改</button>
                </form>
            </div>
        </div><!-- /.modal-content -->
    </div><!-- /.modal-dialog -->
</div>

<!-- 关闭 -->
<script>
    $(function() {
        $('#addModal').modal('hide');
    });
    //打开修改任务的模态框，并赋值
    function openEditModal(id) {
        //cells[]里面的下标从0开始，不过第一列是序号，所以我们不需要
        var triggerName = document.getElementById("table").rows[id].cells[1].innerText;
        var triggerGroup = document.getElementById("table").rows[id].cells[2].innerText;
        var jonName = document.getElementById("table").rows[id].cells[3].innerText;
        var jobGroup = document.getElementById("table").rows[id].cells[4].innerText;
        var jobClassName = document.getElementById("table").rows[id].cells[5].innerText;
        var cronExpression = document.getElementById("table").rows[id].cells[6].innerText;
        /*var nextFireTime = document.getElementById("table").rows[id].cells[8].innerText;*/
        //给修改的模态框的标签赋值
        $("#jobNameEdit").val(jonName);
        $("#jobGroupEdit").val(jobGroup);
        $("#triggerNameEdit").val(triggerName);
        $("#triggerGroupEdit").val(triggerGroup);
        $("#jobClassNameEdit").val(jobClassName);
        $("#cronExpressionEdit").val(cronExpression);
        /*$("#nextFireTimeEdit").val(nextFireTime);*/

        $('#editModal').modal('show');//打开模态框
    }

</script>


</body>
<script type="text/javascript">
    //新增job
    function addCronJob() {
        $.ajax({
            type: "POST",//方法类型
            dataType: "json",//预期服务器返回的数据类型
            url: "${pageContext.request.contextPath}/quartz/addCronJob" ,//url
            data: $('#form').serialize(),//提交的表单数据
            success: function (data) {
                if(data.success){
                    alert(data.msg);
                    //刷父页面
                    parent.location.reload();
                }else{
                    alert(data.msg);
                }
            },
            error: function (data) {
                alert("提交出现异常");
            }
        });
    }
    //暂停任务
    function pauseJob(jobName,jobGroup){
        $.ajax({
            type:"put",
            url:"${pageContext.request.contextPath}/quartz/pauseJob?jobName="+jobName+"&jobGroup="+jobGroup,
            dataType:"json",
            success:function (data) {
                if(data.success){
                    alert(data.msg);
                    //删除成功，刷新页面
                    location.reload(true);
                    //window.location.reload();
                }else{
                    alert(data.msg);
                }
            }
        });
    }
    //恢复任务
    function resumeJob(jobName,jobGroup) {
        $.ajax({
            type:"put",
            url:"${pageContext.request.contextPath}/quartz/resumeJob?jobName="+jobName+"&jobGroup="+jobGroup,
            dataType:"json",
            success:function (data) {
                if(data.success){
                    alert(data.msg);
                    //删除成功，刷新页面
                    location.reload(true);
                    //window.location.reload();
                }else{
                    alert(data.msg);
                }
            }
        });
    }
    //删除任务
    function deleteJob(jobName,jobGroup) {
        $.ajax({
            type:"delete",
            url:"${pageContext.request.contextPath}/quartz/deleteJob?jobName="+jobName+"&jobGroup="+jobGroup,
            dataType:"json",
            success:function (data) {
                if(data.success){
                    alert(data.msg);
                    //删除成功，刷新页面
                    location.reload(true);
                    //window.location.reload();
                }else{
                    alert(data.msg);
                }
            }
        });
    }

    //立即执行任务
    function startJobNow(jobName,jobGroup) {
        $.ajax({
            type:"get",
            url:"${pageContext.request.contextPath}/quartz/startJobNow?jobName="+jobName+"&jobGroup="+jobGroup,
            dataType:"json",
            success:function (data) {
                if(data.success){
                    alert(data.msg);
                    //删除成功，刷新页面
                    location.reload(true);
                    //window.location.reload();
                }else{
                    alert(data.msg);
                }
            }
        });
    }
    //修改任务
    function editCronJob() {
        /*$.ajax({
            type: "POST",//方法类型
            dataType: "json",//预期服务器返回的数据类型
            url: "${pageContext.request.contextPath}/quartz/editJob",//url
            data: $('#formEdit').serialize(),//提交的表单数据
            success: function (data) {
                if(data.success){
                    alert(data.msg);
                    //刷父页面
                    parent.location.reload();
                }else{
                    alert(data.msg);
                }
            },
            error: function (data) {
                alert("提交出现异常");
            }
        });*/
    }
</script>
</html>

注意：页面上面我引入的js和css样式，是通过网络引入的，必须要有网才行，当然我们也可以自己找到相关的js和css，放到本地，进行本地引入。

4、测试

上面已经把代码都贴完了，下面就可以启动项目，进行测试了。

4.1 启动配置

控制台中文乱码解决办法：-Dfile.encoding=UTF-8

4.2 页面测试

上面配置好之后，浏览器访问：http://localhost:9800，效果如图：

点击定时任务列表，页面效果如下：

点击新增定时任务按钮，出现新增模态框，如下：

填写完信息之后，点击提交，会刷新页面，效果如下：

zdwhong

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
1
评论
SSM整合Quartz(MySql，SpringMVC，Spring，Mybatis)

1、Quartz下载Quartz下载地址：http://www.quartz-scheduler.org/downloads/，本自行选择下载不同的版2、表的作用及其字段含义2.1 创建表的语句的sql文件位置对应不同的数据库，Quartz提供了不同的sql脚本来创建qrtz_开头的11张表，sql脚本在docs\dbTables下面。2.2 11张表的主要用途：...
复制链接

扫一扫