SpringBoot集成Quartz实现持久化存储和可视化页面管理

前言

本文主要是Springboot集成Quartz实现定时任务的数据库存储以及前端页面的可视化管理，所使用的主要工具有：Springboot、Mybatis-Plus、Quartz、Layui、Mysql等

正文

1.准备环境

1.创建数据库

因为本例子中业务数据和定时数据是分开的，所以先创建两个空数据库，一个用于业务，一个用于Quartz，数据库名字任意，我的是：bml_base（业务）、bml_quartz（定时）

2.创建项目

创建一个Springboot项目，勾选一些必需依赖，例如druid、quartz、web、mysql、Mybatis-plus等，创建后删除一些不必要的文件（mvn那些），这些都是基础知识，具体略…

3.application.yml配置文件

注意：

​ 1.这里我把quartz配置与Springboot的配置都放在application.yml一个文件中了，这和网上的分开配置有一些不同。

​ 2.initialize-schema: never，我们第一次启动项目时可以将never改成always，这样Quartz会自动在bml_quartz数据库中创建相关表，我们也不用再导入脚本了

# mybatis-plus
mybatis-plus:
  # SQL语句输出在控制台
    configuration:
        log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
    # 映射文件相关
    mapper-locations: classpath*:bml/business/mapper/xml/*.xml
    type-aliases-package: bml.business.mapper

spring:
  datasource:
    # 业务数据源
    db1:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/bml_base?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
      username: root
      password: 123456
      type: com.alibaba.druid.pool.DruidDataSource
    # Quartz数据源
    db2:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://127.0.0.1:3306/bml_quartz?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false
      username: root
      password: 123456
      type: com.alibaba.druid.pool.DruidDataSource

  quartz:
    properties:
      org:
        quartz:
          scheduler:
            # 默认
            instanceName: DemoScheduler
            # 如果使用集群，instanceId必须唯一，设置成AUTO
            instanceId: AUTO
          jobStore:
            # 存储方式使用JobStoreTX 也就是数据库
            class: org.quartz.impl.jdbcjobstore.JobStoreTX
            driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
            # 表名前缀
            tablePrefix: QRTZ_
            # 是否使用集群
            isClustered: true
            clusterCheckinInterval: 10000
            useProperties: false
            misfireThreshold: 5000
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 20
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true
    job-store-type: jdbc
    jdbc:
      # 启动项目时是否初始化表
      initialize-schema: never

  mvc:
    # 静态资源文件过滤
    static-path-pattern: /static/**

  thymeleaf:
    # 禁用缓存
    cache: false

4.数据库配置类

使用多数据源时要配置一下，编写如下配置类即可：

@Configuration
public class DataSourceConfig {

    @Bean(name = "db1")
    @Primary
    @ConfigurationProperties("spring.datasource.db1")
    public DruidDataSource dataSource1 () {
        return DruidDataSourceBuilder.create().build();
    }

    @Bean(name = "db2")
    @ConfigurationProperties("spring.datasource.db2")
    @QuartzDataSource
    public DruidDataSource dataSource2 () {
        return DruidDataSourceBuilder.create().build();
    }
}

5.截图展示：

自此，搭建环境的工作就告一段落了…

2.业务实现（非重点）

本例子中，业务实现不是重点，这里只是简单地模拟一下实际开发环境，我们在业务数据中创建一个表，然后将表中数据展示在前台即可。

1.创建表

在bml_base（业务）数据库中任意创建一个表，插入一些数据，例如：

REATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `username` varchar(32) DEFAULT NULL COMMENT '用户名',
  `password` varchar(256) DEFAULT NULL COMMENT '密码',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8

2.Mybatis-Plus实现

快速实现：使用Mybatis-plus逆向工程快速生成entity、dao、service等，将业务模块都放在business包下，参考上面的图，编写Controller查询所有数据返回给前台即可，注意数据格式是JSON。

Controller如下：

@Controller
public class UserController {

    @Resource
    UserService userService;

    @ResponseBody
    @PostMapping("/admin/user")
    public BmlResult<Object> userList() {
        Map<String, Object> resultMap = new HashMap<>(100);
        resultMap.put("count",userService.count(null));
        resultMap.put("data",userService.list(null));
        return new BmlResult<>(resultMap,0);
    }
}

BmlResult是数据封装类，下文会经常使用，代码如下：

@Data
public class BmlResult<T> implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * 封装数据
     */
    private T data;
    /**
     * 返回状态码
     */
    private Integer status;
    /**
     * 返回自定义信息
     */
    private String msg;
    /**
     * 无参构造，不可或缺
     */
    public BmlResult() {
    }
    /**
     * 如没有数据返回，则可以自定义指定状态码和提示信息
     */
    public BmlResult(Integer status, String msg) {
        this.status = status;
        this.msg = msg;
    }
    /**
     * 用于返回查询的集合
     * @param data 封装数据
     * @param status 状态码
     */
    public BmlResult(T data,Integer status) {
        this.data = data;
        this.status = status;
    }
}

3.定时任务实现（重点）

1.创建任务

参考项目结构图：创建两个任务

Job1：输出id为1的用户名和当前时间，当然，实际开发远没有这么简单，你也可以做点别的

package bml.quartz.job;

public class OneJob extends QuartzJobBean {
    @Resource
    UserService userService;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        User user = userService.getById(1);
        System.out.println("第一任务输出用户名："+user.getUsername()+"当前时间："+dateFormat.format(new Date()));
    }
}

Job2：统计一下业务表User中共有多少数据

package bml.quartz.job;

public class TwoJob implements Job {
    @Resource
    UserService userService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        int count = userService.count(null);
        System.out.println("模拟午夜统计总人数"+dateFormat.format(new Date())+"用户总数是："+count);
    }
}

注意：job1和job2实现方式不一样，一个是extends QuartzJobBean，一个是implements Job，这两种方式都行

2.创建VO

我们要在前端展示任务列表，就要新建一个用于保存数据的实体类，新建类如下：

package bml.quartz.entity;

@Data
public class QuartzJobVO {
    private String jobName;
    private String jobGroup;
    private String jobClassName;
    private String description;
    private String triggerName;
    private String triggerGroup;
    private String triggerState;
    private String cronExpression;
    private String timeZone;
}

3.实现方法

类似于Service层，实现定时任务的CRUD方法：

package bml.quartz.service;

@Configuration
public class QuartzService {

    @Resource
    Scheduler scheduler;

    public void prepareJob(Scheduler scheduler) throws SchedulerException {
        JobDetail jobDetail1 = newJob(OneJob.class)
                .withIdentity("job1", "group1")
                .withDescription("任务一描述：每隔10秒输出用户一的用户名")
                .build();
        JobDetail jobDetail2 = newJob(TwoJob.class)
                .withIdentity("job2", "group1")
                .withDescription("任务二描述: 模拟每天午夜时统计一下总人数")
                .build();

        CronTrigger cronTrigger1 = newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
                .withSchedule(
                        CronScheduleBuilder.cronSchedule("0/10 * 10-23 * * ?")
                                .withMisfireHandlingInstructionDoNothing())
                .build();
        CronTrigger cronTrigger2 = newTrigger()
                .withIdentity("trigger2", "group1")
                .startNow()
                .withSchedule(
                        CronScheduleBuilder.cronSchedule("0/30 * 10-23 * * ?")
                                .withMisfireHandlingInstructionDoNothing())
                .build();
        scheduler.scheduleJob(jobDetail1, cronTrigger1);
        scheduler.scheduleJob(jobDetail2, cronTrigger2);
    }

    public void startJob() throws SchedulerException {
        prepareJob(scheduler);
        scheduler.start();
    }

    /**
     * 获取任务列表 用于前端展示
     */
    public List<QuartzJobVO> getList() throws SchedulerException {
        List<QuartzJobVO> list = new ArrayList<>();
        // 再获取Scheduler下的所有group
        List<String> triggerGroupNames = scheduler.getTriggerGroupNames();
        for (String groupName : triggerGroupNames) {
            // 组装group的匹配，为了模糊获取所有的triggerKey或者jobKey
            GroupMatcher groupMatcher = GroupMatcher.groupEquals(groupName);
            // 获取所有的triggerKey
            Set<TriggerKey> triggerKeySet = scheduler.getTriggerKeys(groupMatcher);
            for (TriggerKey triggerKey : triggerKeySet) {
                // 通过triggerKey在scheduler中获取trigger对象
                CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                // 获取trigger拥有的Job
                JobKey jobKey = trigger.getJobKey();
                JobDetailImpl jobDetail = (JobDetailImpl) scheduler.getJobDetail(jobKey);
                // 组装页面需要显示的数据
                QuartzJobVO quartzJobsVO = new QuartzJobVO();
                quartzJobsVO.setJobName(jobDetail.getName());
                quartzJobsVO.setJobGroup(groupName);
                quartzJobsVO.setDescription(jobDetail.getDescription());
                // 获取全类名 也可以获取包名
                Class<? extends Job> jobClass = jobDetail.getJobClass();
                quartzJobsVO.setJobClassName(jobClass.getName());
                quartzJobsVO.setTriggerName(triggerKey.getName());
                quartzJobsVO.setTriggerGroup(triggerKey.getGroup());
                // 任务当前状态
                quartzJobsVO.setTriggerState(scheduler.getTriggerState(triggerKey).toString());
                quartzJobsVO.setCronExpression(trigger.getCronExpression());
                quartzJobsVO.setTimeZone(trigger.getTimeZone().getID());
                list.add(quartzJobsVO);
            }
        }
        return list;
    }
    
    /**
     * 动态添加一个定时任务 类名一定要写全
     * @param className 根据类名得到类 比如：bml.quartz.job.OneJob
     */
    public void addJob(String jobName, String triggerName, String description, String className, String cron) throws SchedulerException, ClassNotFoundException {
        JobDetail jobDetail = newJob((Class<? extends Job>) Class.forName(className))
                .withIdentity(jobName, "group1")
                .withDescription(description)
                .build();
        CronTrigger cronTrigger = newTrigger()
                .withIdentity(triggerName, "group1")
                .startNow()
                .withSchedule(
                        CronScheduleBuilder.cronSchedule(cron)
                                .withMisfireHandlingInstructionDoNothing())
                .build();
        scheduler.scheduleJob(jobDetail, cronTrigger);
    }

    /**
     *  shutdown(true)表示等待所有正在执行的任务执行完毕后关闭Scheduler
     *  shutdown(false),即shutdown()表示直接关闭Scheduler
     */
    public void shutdown() throws SchedulerException {
        scheduler.shutdown(true);
    }

    /**
     * 02-暂停某个任务
     */
    public void pauseOneJob(String name, String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name, group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null) {
            return;
        }
        scheduler.pauseJob(jobKey);
    }

    /**
     * 03-暂停所有任务
     * 区别在于触发失火指令应用行为.
     * 在standby()后调用start()时,任何在待机状态下出现的失火将被忽略.
     * 当您在pauseAll()之后调用resumeAll()时,将会应用在调度程序暂停时出现的所有失火.
     * standby之后就不能再调用了？？？
     */
    public void pauseAllJob() throws SchedulerException {
        scheduler.pauseAll();
    }

    /**
     * 04-恢复一个任务
     */
    public void resumeOneJob(String name, String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name, group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null) {
            return;
        }
        scheduler.resumeJob(jobKey);
    }

    /**
     * 05-恢复所有任务
     */
    public void resumeAllJob() throws SchedulerException {
        scheduler.resumeAll();
    }

    /**
     * 06-修改某个任务的执行时间
     */
    public boolean updateJob(String name, String group, String cron) throws SchedulerException {
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(name, group);
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldTime = cronTrigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(cron)) {
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(cronScheduleBuilder).build();
            date = scheduler.rescheduleJob(triggerKey, trigger);
        }
        return date != null;
    }

    /**
     * 07-删除某个任务 删除后该任务将不再执行
     */
    public void deleteOneJob(String name, String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name, group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (jobDetail == null) {
            return;
        }
        scheduler.deleteJob(jobKey);
    }
}

4.Controller层

该层主要就是与前端页面交互，代码如下：

package bml.quartz.controller;

@RestController
public class QuartzController {

    @Resource
    QuartzService quartzService;

    @PostMapping("/quartz/list")
    public BmlResult<Object> getAllJobs() {
        Map<String, Object> resultMap = new HashMap<>(100);
        try {
            List<QuartzJobVO> list = quartzService.getList();
            resultMap.put("status",0);
            resultMap.put("count",list.size());
            resultMap.put("data",list);
        } catch (SchedulerException e) {
            resultMap.put("status",1);
            resultMap.put("count",0);
            resultMap.put("data",null);
            e.printStackTrace();
        }
        return new BmlResult<>(resultMap,0);
    }

    @PostMapping("/quartz/start")
    public BmlResult<Object> startQuartzJob() {
        try {
            quartzService.startJob();
            return new BmlResult<>(200,"启动成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"启动失败...");
        }
    }

    @PostMapping(value = "/quartz/pause")
    public BmlResult<Object> pauseQuartzJob(String name, String group) {
        try {
            quartzService.pauseOneJob(name, group);
            return new BmlResult<>(200,"暂停成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"暂停失败...");
        }
    }

    @PostMapping(value = "/quartz/pauseAll")
    public BmlResult<Object> shutQuartzJob() {
        try {
            quartzService.pauseAllJob();
            return new BmlResult<>(200,"暂停成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"暂停失败...");
        }
    }

    @PostMapping(value = "/quartz/resume")
    public BmlResult<Object> resumeOneJob(String name, String group) {
        try {
            quartzService.resumeOneJob(name, group);
            return new BmlResult<>(200,"恢复成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"恢复失败...");
        }
    }

    @PostMapping(value = "/quartz/resumeAll")
    public BmlResult<Object> resumeAll() {
        try {
            quartzService.resumeAllJob();
            return new BmlResult<>(200,"恢复成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"恢复失败...");
        }
    }

    @PostMapping(value = "/quartz/delete")
    public BmlResult<Object> delete(String name, String group) {
        try {
            // 从数据库中删除该任务 无法恢复
            quartzService.deleteOneJob(name, group);
            return new BmlResult<>(200,"删除成功！");
        } catch (SchedulerException e) {
            e.printStackTrace();
            return new BmlResult<>(400,"删除失败...");
        }
    }

    @PostMapping(value = "/quartz/update")
    public BmlResult<Object> modifyJob(@RequestParam("triggerName") String name,
                                       @RequestParam("triggerGroup") String group,
                                       @RequestParam("cronExpression") String cron) throws SchedulerException {
        boolean b = quartzService.updateJob(name, group, cron);
        if (b) {
            return new BmlResult<>(200,"更新成功！");
        } else {
            return new BmlResult<>(400,"更新失败...");
        }
    }

    @PostMapping(value = "/quartz/add")
    public BmlResult<Object> addJob(@RequestParam("add_JobName") String jobName,
                                    @RequestParam("add_triggerName") String triggerName,
                                    @RequestParam("add_description") String description,
                                    @RequestParam("add_JobClass") String className,
                                    @RequestParam("add_cron") String cron) {
        try {
            quartzService.addJob(jobName, triggerName, description, className, cron);
            return new BmlResult<>(200,"添加成功！");
        } catch (Exception e) {
            e.printStackTrace();
            return new BmlResult<>(400,"添加失败...");
        }
    }
}

自此，后端代码的工作就算结束了，接下来是前端展示部分。

4.前端页面

这里只展示Quartz页面，User就不展示了：

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="utf-8">
    <title>后台管理系统</title>
    <meta name="renderer" content="webkit">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <meta name="viewport" content="width=device-width, initial-scale=1.0, minimum-scale=1.0, maximum-scale=1.0, user-scalable=0">
    <link rel="stylesheet" th:href="@{/static/layuiadmin/layui/css/layui.css}" media="all">
    <link rel="stylesheet" th:href="@{/static/layuiadmin/style/admin.css}" media="all">
    <script>
        /^http(s*):\/\//.test(location.href) || alert('请先部署到 localhost 下再访问');
    </script>
</head>
<body>

<div class="layui-fluid layui-anim" lay-title="定时管理">
    <div class="layui-row">
        <div class="layui-col-md12">
            <div class="layui-card">
                <div class="layui-card-body">
                    <hr class="layui-bg-green">
                    <table id="quartz" class="layui-table" lay-filter="quartz"></table>
                </div>
            </div>
        </div>
    </div>
</div>

<div class="layui-fluid" id="quartz-update" style="display: none">
    <form class="layui-form" action="" lay-filter="quartz-update-form" id="quartz-update-form">
        <div class="layui-form-item">
            <label class="layui-form-label">Trigger名：</label>
            <div class="layui-input-block">
                <input id="triggerName" name="triggerName" autocomplete="off" class="layui-input" readonly>
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Trigger组：</label>
            <div class="layui-input-block">
                <input id="triggerGroup" name="triggerGroup" autocomplete="off" class="layui-input" readonly>
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Cron表式：</label>
            <div class="layui-input-block">
                <input id="cron" name="cron" autocomplete="off" class="layui-input" required>
            </div>
        </div>
    </form>
</div>

<div class="layui-fluid" id="quartz-add" style="display: none">
    <form class="layui-form" action="" lay-filter="quartz-add-form" id="quartz-add-form">
        <div class="layui-form-item">
            <label class="layui-form-label">Job名：</label>
            <div class="layui-input-block">
                <input id="add_JobName" name="add_JobName" autocomplete="off" class="layui-input" required>
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Job执行类：</label>
            <div class="layui-input-block">
                <input id="add_JobClass" name="add_JobClass" autocomplete="off" class="layui-input" required>
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Job描述：</label>
            <div class="layui-input-block">
                <input id="add_description" name="add_description" autocomplete="off" class="layui-input">
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Trigger名：</label>
            <div class="layui-input-block">
                <input id="add_triggerName" name="add_triggerName" autocomplete="off" class="layui-input" required>
            </div>
        </div>
        <div class="layui-form-item">
            <label class="layui-form-label">Cron表式：</label>
            <div class="layui-input-block">
                <input id="add_cron" name="add_cron" autocomplete="off" class="layui-input" required>
            </div>
        </div>
    </form>
</div>

<script type="text/html" id="toolbarDemo">
    <div class="layui-btn-container">
        <button class="layui-btn layui-btn-normal layui-btn-sm" lay-event="startJob">启动Job</button>
        <button class="layui-btn layui-btn-normal layui-btn-sm" lay-event="addJob">添加Job</button>
        <button class="layui-btn layui-btn-normal layui-btn-sm" lay-event="resumeAll">恢复所有任务</button>
        <button class="layui-btn layui-btn-normal layui-btn-sm" lay-event="pauseAll">暂停所有任务</button>
    </div>
</script>

<script type="text/html" id="barDemo">
    <a class="layui-btn layui-btn-normal layui-btn-xs" lay-event="pause">暂停</a>
    <a class="layui-btn layui-btn-xs" lay-event="update">修改</a>
    <a class="layui-btn layui-btn-warm layui-btn-xs" lay-event="resume">启动</a>
    <a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="delete">删除</a>
</script>

<script th:src="@{/static/Jquery/jquery-3.4.1.js}"></script>
<script th:src="@{/static/layuiadmin/layui/layui.js}"></script>
<script data-th-inline="none" type="text/javascript">

    layui.use(['table','form','jquery'],function () {
        var layer = layui.layer;
        var table = layui.table;
        var form = layui.form;
        form.render();

        table.render({
            elem: '#quartz',
            method:'POST',
            dataType:'JSON',
            url: 'http://localhost:8080/quartz/list',
            id: 'quartzReload',
            page: true,
            toolbar: '#toolbarDemo',
            defaultToolbar: [],
            limits:[10,20,50],
            // 从封装的数据结构里拿到结果
            parseData:function(result) {
                return {
                    "code": result.data.status,
                    "count": result.data.count,
                    "data":result.data.data
                }
            },
            cols: [[
                {field: 'jobName', title: 'Job名', width: "6%"},
                {field: 'jobGroup', title: 'Job组', width: "7%"},
                {field: 'jobClassName', title: 'Job全类名', width: "14%"},
                {field: 'description', title: 'Job描述', width: "10%"},
                {field: 'triggerName', title: 'Trigger名', width: "8%"},
                {field: 'triggerGroup', title: 'Trigger组', width: "8%"},
                {field: 'triggerState', title: '状态', width: "8%"},
                {field: 'cronExpression', title: 'CRON表达式', width: "12%"},
                {field: 'timeZone', title: '时区', width: "10%"},
                {fixed: 'right', title:'操作',align: 'center', toolbar: '#barDemo', width: '17%'}
            ]],
        });

        table.on('toolbar(quartz)', function(obj){
            if(obj.event === 'pauseAll'){
                layer.confirm('<div style="text-align: center;">确定暂停所有任务?</div>',{title: '确认暂停框',btn: ['暂停','取消']}, function (index) {
                    $.ajax({
                        url: "http://localhost:8080/quartz/pauseAll",
                        type: 'POST',
                        dataType: "json",
                        success: function (result) {
                            if (result.status === 200) {
                                // 刷新任务状态
                                table.reload('quartzReload', {
                                    page: {
                                        curr: 1
                                    }
                                });
                                layer.close(index);
                                layer.msg(result.msg,{icon: 6});
                            } else {
                                layer.close(index);
                                layer.msg(result.msg,{icon: 5})
                            }
                        },
                        error: function () {
                            layer.close(index);
                            layer.msg("未知错误,请稍后再试！",{icon: 5})
                        }
                    })
                })
            }
            if(obj.event === 'resumeAll'){
                layer.confirm('<div style="text-align: center;">是否恢复所有任务?</div>',{title: '确认恢复框',btn: ['恢复','取消']}, function (index) {
                    $.ajax({
                        url: "http://localhost:8080/quartz/resumeAll",
                        type: 'POST',
                        dataType: "json",
                        success: function (result) {
                            if (result.status === 200) {
                                table.reload('quartzReload', {
                                    page: {
                                        curr: 1
                                    }
                                });
                                layer.close(index);
                                layer.msg(result.msg,{icon: 6});
                            } else {
                                layer.close(index);
                                layer.msg(result.msg,{icon: 5})
                            }
                        },
                        error: function () {
                            layer.close(index);
                            layer.msg("未知错误,请稍后再试！",{icon: 5})
                        }
                    })
                })
            }
            if (obj.event === 'startJob') {
                $.ajax({
                    url: "http://localhost:8080/quartz/start",
                    type: 'POST',
                    dataType: "json",
                    success: function (result) {
                        if (result.status === 200) {
                            table.reload('quartzReload', {
                                page: {
                                    curr: 1
                                }
                            });
                            layer.close(index);
                            layer.msg(result.msg,{icon: 6});
                        } else {
                            layer.close(index);
                            layer.msg(result.msg,{icon: 5})
                        }
                    },
                    error: function () {
                        layer.close(index);
                        layer.msg("未知错误,请稍后再试！",{icon: 5})
                    }
                })
            }
            if (obj.event === 'addJob') {
                layer.open({
                    type: 1,
                    resize: true,
                    btn: ['添加', '取消'],
                    area: ['520px', '400px'],
                    content: $('#quartz-add'),
                    title: '添加定时任务',
                    btn1:function (index) {
                        $.ajax({
                            url: "http://localhost:8080/quartz/add",
                            type: 'POST',
                            data: {
                                add_JobName: $('#add_JobName').val(),
                                add_JobClass: $('#add_JobClass').val(),
                                add_description: $('#add_description').val(),
                                add_triggerName: $('#add_triggerName').val(),
                                add_cron: $('#add_cron').val(),
                            },
                            dataType: "json",
                            success: function (result) {
                                if (result.status === 200) {
                                    table.reload('quartzReload', {
                                        page: {
                                            curr: 1
                                        }
                                    });
                                    layer.close(index);
                                    layer.msg(result.msg,{icon: 6});
                                } else {
                                    layer.close(index);
                                    layer.msg(result.msg,{icon: 5})
                                }
                            },
                            error: function () {
                                layer.close(index);
                                layer.msg("未知错误,请稍后再试！",{icon: 5})
                            }
                        });
                        return false;
                    }
                })
            }
        });

        // 监听行工具事件
        table.on('tool(quartz)', function(obj){
            var data = obj.data;
            // console.log(data);
            var jobName = data.jobName;
            var jobGroup = data.jobGroup;

            if(obj.event === 'pause'){
                layer.confirm('<div style="text-align: center;">确认暂停该任务?</div>',{title: '确认暂停框',btn: ['暂停','取消']}, function (index) {
                    $.ajax({
                        url: "http://localhost:8080/quartz/pause",
                        type: 'POST',
                        data: {name: jobName, group: jobGroup},
                        dataType: "json",
                        success: function (result) {
                            if (result.status === 200) {
                                table.reload('quartzReload', {
                                    page: {
                                        curr: 1
                                    }
                                });
                                layer.close(index);
                                layer.msg(result.msg,{icon: 6});
                            } else {
                                layer.close(index);
                                layer.msg(result.msg,{icon: 5})
                            }
                        },
                        error: function () {
                            layer.close(index);
                            layer.msg("未知错误,请稍后再试！",{icon: 5})
                        }
                    })
                })
            }
            if(obj.event === 'update'){
                console.log("点击了更新按钮");
                layer.open({
                    type: 1,
                    resize: true,
                    btn: ['更新', '取消'],
                    area: ['450px', '300px'],
                    content: $('#quartz-update'),
                    title: 'Job信息修改',
                    success: function () {
                        form.val("quartz-update-form", {
                            "triggerName": data.triggerName,
                            "triggerGroup": data.triggerGroup,
                            "cron": data.cronExpression,
                        })
                    },
                    btn1:function (index) {
                        $.ajax({
                            url: "http://localhost:8080/quartz/update",
                            type: 'POST',
                            data: {
                                triggerName: $('#triggerName').val(),
                                triggerGroup: $('#triggerGroup').val(),
                                cronExpression: $('#cron').val(),
                            },
                            dataType: "json",
                            success: function (result) {
                                if (result.status === 200) {
                                    table.reload('quartzReload', {
                                        page: {
                                            curr: 1
                                        }
                                    });
                                    layer.close(index);
                                    layer.msg(result.msg,{icon: 6});
                                } else {
                                    layer.close(index);
                                    layer.msg(result.msg,{icon: 5})
                                }
                            },
                            error: function () {
                                layer.close(index);
                                layer.msg("未知错误,请稍后再试！",{icon: 5})
                            }
                        });
                        return false;
                    }
                })
            }
            if(obj.event === 'resume'){
                layer.confirm('<div style="text-align: center;">确认恢复该任务?</div>',{title: '确认恢复框',btn: ['恢复','取消']}, function (index) {
                    $.ajax({
                        url: "http://localhost:8080/quartz/resume",
                        type: 'POST',
                        data: {name: jobName, group: jobGroup},
                        dataType: "json",
                        success: function (result) {
                            if (result.status === 200) {
                                table.reload('quartzReload', {
                                    page: {
                                        curr: 1
                                    }
                                });
                                layer.close(index);
                                layer.msg(result.msg,{icon: 6});
                            } else {
                                layer.close(index);
                                layer.msg(result.msg,{icon: 5})
                            }
                        },
                        error: function () {
                            layer.close(index);
                            layer.msg("未知错误,请稍后再试！",{icon: 5})
                        }
                    })
                });
            }
            if(obj.event === 'delete'){
                // 删除任务之后要在前端页面也删除
                layer.confirm('<div style="text-align: center;">确认删除该任务?</div>',{title: '确认删除框',btn: ['删除','取消']}, function (index) {
                    $.ajax({
                        url: "http://localhost:8080/quartz/delete",
                        type: 'POST',
                        data: {name: jobName, group: jobGroup},
                        dataType: "json",
                        success: function (result) {
                            if (result.status === 200) {
                                // 前端删除数据
                                obj.del();
                                layer.close(index);
                                layer.msg(result.msg,{icon: 6});
                            } else {
                                layer.close(index);
                                layer.msg(result.msg,{icon: 5})
                            }
                        },
                        error: function () {
                            layer.close(index);
                            layer.msg("未知错误,请稍后再试！",{icon: 5})
                        }
                    })
                });
            }
        });
    });
</script>
</body>
</html>

5.效果展示

定时任务：



添加任务：（执行类需要写成全类名，例如：bml.quartz.job.OneJob）

其他按钮就不再一一截图了，都能正常使用。

结语

结语写点什么呢？？？
本想附上源码地址，但是一想到Github经常抽风打不开，还要上传什么的就很麻烦，也不想弄…

12月6号补充源码链接：Github