Quartz学习——SSM和Quartz集成详解(四)

最新推荐文章于 2021-09-27 09:17:09 发布
最新推荐文章于 2021-09-27 09:17:09 发布
阅读量2.3k 收藏 1
点赞数
分类专栏： quartz 文章标签： quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wangyuanjun008/article/details/79122066
版权
本文详细介绍了一个使用Spring+SpringMVC+Mybatis框架结合Quartz实现定时任务的例子。包括项目配置、核心代码实现及运行效果展示。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

下面介绍SSM+Quartz的示例，项目地址: quartz-spring

一：环境介绍


工具：Spring Tool Suite + Mysql
框架：Spring+SpringMVC+Mybatis
前端: easy ui
日志：logback
构建工具：Maven
Quartz版本：2.2.3

二：SSM+Quartz集成详解

1.项目结构

这里写图片描述

2.配置文件介绍

（1）：在ApplicationContext.xml中添加下面的配置：

    <bean name="quartzScheduler"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="dataSource" ref="dataSource" /><!-- 读取spring配置的数据库，不去加载quartz.properties -->
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />
        <property name="configLocation" value="classpath:quartz.properties" />
    </bean>

（2）：添加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 = AUTO

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.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_

3.核心代码

package com.wyj.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang.StringUtils;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSON;
import com.wyj.entity.JobDto;
import com.wyj.entity.Retval;
import com.wyj.service.QuartzService;

/**
 * 定时任务 Controller
 * 
 * 
 * @author：WangYuanJun
 * @date：2018年1月7日 下午10:15:33
 */

@Controller
@RequestMapping(value = "/quartz")
public class QuartzController {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private Scheduler quartzScheduler;

    @Autowired
    private QuartzService quartzService;

    @RequestMapping("/index")
    public String index() {
        return "/quartz/list";
    }

    /**
     * 定时列表页
     * 
     * @return
     * @throws SchedulerException
     */
    @ResponseBody
    @RequestMapping(value = "/list")
    public String listJob(HttpServletRequest request, HttpServletResponse response) throws SchedulerException {
        List<JobDto> jobInfos = this.getSchedulerJobInfo();
        return JSON.toJSONString(jobInfos);
    }

    /**
     * 新建job
     * 
     * @param jobDto
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/add")
    public Retval save(JobDto jobDto) {
        Retval retval = Retval.newInstance();
        try {
            quartzService.addJob(jobDto.getJobName(), jobDto.getJobGroupName(), jobDto.getTriggerName(), jobDto.getTriggerGroupName(), Class.forName(jobDto.getJobClass()), jobDto.getCronExpression());
        } catch (Exception e) {
            logger.error(e.getMessage());
        }

        return retval;
    }

    /**
     * 编辑job
     * 
     * @param jobDto
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/edit", method = RequestMethod.POST)
    public Retval edit(JobDto jobDto) {
        Retval retval = Retval.newInstance();
        try {
            boolean result = quartzService.modifyJobTime(jobDto.getOldJobName(), jobDto.getOldJobGroupName(), jobDto.getOldTriggerName(), jobDto.getOldTriggerGroupName(), jobDto.getJobName(), jobDto.getJobGroupName(), jobDto.getTriggerName(), jobDto.getTriggerGroupName(), jobDto.getCronExpression());
            if (result) {
                retval.put("message", "修改任务成功!");
            } else {
                retval.put("message", "修改任务失败!");
            }
        } catch (Exception e) {
            logger.error(e.getMessage());
        }

        return retval;
    }

    /**
     * 暂停job
     * 
     * @param jobName
     * @param jobGroupName
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/stopJob", method = RequestMethod.POST)
    public Retval stopJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroupName") String jobGroupName) {
        Retval retval = Retval.newInstance();
        if (StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName)) {
            retval.fail();
            retval.put("message", "暂停失败");
        } else {
            try {
                quartzService.pauseJob(jobName, jobGroupName);
                retval.put("message", "暂停成功");
            } catch (Exception e) {
                logger.error(e.getMessage());
            }

        }
        return retval;
    }

    /**
     * 恢复job
     * 
     * @param jobName
     * @param jobGroupName
     * @return
     */
    @ResponseBody
    @RequestMapping(value = "/resumeJob", method = RequestMethod.POST)
    public Retval resumeJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroupName") String jobGroupName) {
        Retval retval = Retval.newInstance();
        if (StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName)) {
            retval.fail();
            retval.put("message", "恢复失败");
        } else {
            try {
                quartzService.resumeJob(jobName, jobGroupName);
                retval.put("message", "恢复成功");
            } catch (Exception e) {
                logger.error(e.getMessage());
            }

        }

        return retval;
    }

    /**
     * 删除job
     * 
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * @return
     */
    @RequestMapping(value = "/deleteJob", method = RequestMethod.POST)
    @ResponseBody
    public Retval deleteJob(@RequestParam("jobName") String jobName, @RequestParam("jobGroupName") String jobGroupName, @RequestParam("triggerName") String triggerName, @RequestParam("triggerGroupName") String triggerGroupName) {
        Retval retval = Retval.newInstance();

        if (StringUtils.isEmpty(jobName) || StringUtils.isEmpty(jobGroupName) || StringUtils.isEmpty(triggerName) || StringUtils.isEmpty(triggerGroupName)) {
            retval.fail();
            retval.put("message", "删除失败");
        } else {
            try {
                quartzService.removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                retval.put("message", "删除成功");
            } catch (Exception e) {
                logger.error(e.getMessage());
            }
        }

        return retval;
    }

    private List<JobDto> getSchedulerJobInfo() throws SchedulerException {
        List<JobDto> jobInfos = new ArrayList<JobDto>();
        List<String> triggerGroupNames = quartzScheduler.getTriggerGroupNames();
        for (String triggerGroupName : triggerGroupNames) {
            Set<TriggerKey> triggerKeySet = quartzScheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(triggerGroupName));
            for (TriggerKey triggerKey : triggerKeySet) {
                Trigger t = quartzScheduler.getTrigger(triggerKey);
                if (t instanceof CronTrigger) {
                    CronTrigger trigger = (CronTrigger) t;
                    JobKey jobKey = trigger.getJobKey();
                    JobDetail jd = quartzScheduler.getJobDetail(jobKey);
                    JobDto jobInfo = new JobDto();
                    jobInfo.setJobName(jobKey.getName());
                    jobInfo.setJobGroupName(jobKey.getGroup());
                    jobInfo.setTriggerName(triggerKey.getName());
                    jobInfo.setTriggerGroupName(triggerKey.getGroup());
                    jobInfo.setCronExpression(trigger.getCronExpression());
                    jobInfo.setNextFireTime(trigger.getNextFireTime());
                    jobInfo.setPreviousFireTime(trigger.getPreviousFireTime());
                    jobInfo.setStartTime(trigger.getStartTime());
                    jobInfo.setEndTime(trigger.getEndTime());
                    jobInfo.setJobClass(jd.getJobClass().getCanonicalName());
                    // jobInfo.setDuration(Long.parseLong(jd.getDescription()));
                    Trigger.TriggerState triggerState = quartzScheduler.getTriggerState(trigger.getKey());
                    jobInfo.setJobStatus(triggerState.toString());// NONE无,
                                                                  // NORMAL正常,
                                                                  // PAUSED暂停,
                                                                  // COMPLETE完全,
                                                                  // ERROR错误,
                                                                  // BLOCKED阻塞
                    JobDataMap map = quartzScheduler.getJobDetail(jobKey).getJobDataMap();
                    if (null != map && map.size() != 0) {
                        jobInfo.setCount(Long.valueOf((String) map.get("count")));
                        jobInfo.setJobDataMap(map);
                    } else {
                        jobInfo.setJobDataMap(new JobDataMap());
                    }
                    jobInfos.add(jobInfo);
                }
            }
        }
        return jobInfos;
    }
}

4.job

package com.wyj.job;

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * Job任务
 * 
 * 
 * @author：WangYuanJun
 * @date：2018年1月5日 下午10:22:42
 */
public class HelloWorldJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("----hello world---" + new Date());
    }

}

三：运行效果介绍

这里写图片描述
这里写图片描述

SSM整合Quartz
songyilianblog的博客
11-24 1133
Quartz1.整合1.1 mysql中创建quartz表1.2 添加quartz依赖1.3 添加quartz.properties1.4 编写quartzConfig文件1.4.1 quartz的初始化配置1.4.2 创建job 实例工厂1.5 编写定时任务1.5.1 静态方式编写定时任务1.5.2 动态方式编写定时任务2.quartz2.1 quartz概念2.2 quartz核心要素2.2.1 要素关系2.2.2 要素作用2.3 quartz优点2.4 quartz数据表2.4.1 数据表获取路径2
Quartz整合SSM详解
黄文孝同学的博客
02-28 8209
前言：Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目，完全基于Java实现 Spring和Quart整合流程详解： 第一步：导入依赖（Maven管理）： <dependencies> <dependency> <groupId>org.springframework</groupId> <artif...
动态QuartzDemo,整合SSM框架
07-18
看了人人开源的动态Quartz,感觉比较实用,就单独的摘了出来,加入了部分的layer弹窗
SSM框架极简便携式集成Quartz任务调度
CatalpaFlat的博客
11-17 1247
SSM框架整合Quartz任务调度SSM集成Quartz，实际操作只需两步： 1.配置自定义的Job（添加job的相关属性，修改任务方法） 2.将Job注册到JobRegister 即可在项目中运行属于你的Quartz任务调度，方便实用，易于操作。1.添加maven依赖<dependency> <groupId>org.quartz-scheduler</groupId> <artif
ssm集成quartz完成定时任务
11-01
该项目是简单的实现quartz持久化集成ssm的，实现定时任务，仅为本人学习的一个简单实例
SSM项目整合Quartz
weixin_33940102的博客
03-25 249
一、背景 　　　　SSM项目中要用到定时器，初期使用Timer，后来用spring 的schedule，都比较简单，所以功能比较单一而且他们不能动态的配置时间。后来就研究quartz，准备整合到项目中。Quartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。 二、quartz的官网下载压缩包 　　最好下载稳定版，...
基于SSM+quartz的定时任务管理demo
05-10
【SSM+Quartz 定时任务管理Demo详解】 在Java Web开发中，定时任务是一项常见且重要的功能，用于执行一些周期性或者特定时间点的任务，例如数据统计、备份、清理等。本Demo以"基于SSM+quartz的定时任务管理"为主题...
详解Spring整合Quartz实现动态定时任务
08-31
* Quartz框架提供了多种监控和管理工具，包括Quartz管理控制台和Quartz监听器等，用于监控和管理定时任务的执行情况。 * 在Spring项目中使用Quartz框架实现定时任务需要注意事务处理和并发控制问题，防止定时任务的...
SSM框架与Apache CXF集成详解及技术扩展
ssm框架集成apache cxf知识点详解： 标题中的“ssm框架集成apache cxf”涉及到的是Java开发领域中的几个主流技术栈的集成应用。SSM指的是Spring、SpringMVC和Mybatis三种框架的组合，而Apache CXF是一个开源的服务...
Quartz详解入门必备
黄文孝同学的博客
02-28 6395
Quartz是什么 Java中的**定时任务**调度框架！！！ Java中我们可以常看到定时框架： Quartz框架 Spring Task框架 但是Quartz框架使用的成都比较多，调度简单 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。 Quartz可以用来创建简单或为运行十个...
ssm整合quartz定时任务实现动态增删改查，暂停任务，恢复任务
01-16
ssm整合quartz 并持久化到数据库中，实现动态增删改查，暂停任务，恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载地址 地址1：链接：https://pan.baidu.com/s/1d3TveY 密码：g1t1 地址2：链接: https://pan.baidu.com/s/1dGoUgJv 密码: m7qx
ssm-springMVC-整合Quartz（解决了无法注入service问题）.doc
06-02
ssm-springMVC-整合Quartz（解决了无法注入service问题）.doc
quartz 和ssm整合
weixin_30621711的博客
10-08 174
xml配置文件中的代码 <bean id="myJob" class="top.lapa.web.job.SelectPayOrNotJob"></bean> <!-- jobDetail --> <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodIn...
ssm+quartz创建定时任务
shine0112的博客
06-07 2014
1.在项目中导入jar包（之前看资料，别人说Spring框架自带quartz，直接可以使用，但自己实践时发现有几个方法不存在，所以就下载jar包导入了） Spring的jar包自然是必须的，然后在quartz官网下载jar包（Quartz 2.1.7），解压后导入下面两个包。   2.在Spring的配置文件头部定义以下信息 1 xmlns:task="http://www.spr
SSM-Quartz定时器
weixin_45203607的博客
09-27 346
SSM-Quartz定时器用法 我们就不搞乱七八糟的了 直接使用最佳方案 Quartz注解版 而一般情况使用Quartz都会搭配着数据库进行使用… 小二上代码 来了客官… 项目结构 需要的Maven <dependencies> <!--quartz--> <dependency> <groupId>org.quartz-scheduler</groupId> <arti
SSM整合Quartz(八)
两个蝴蝶飞
04-30 1082
> 勿以恶小而为之，勿以善小而不为--------------------------刘备 > 劝诸君，多行善事积福报，莫作恶 主要内容: SSM整合 Quartz, 解决 userService对象注入的问题
SSM项目使用Quartz定时任务
柠檬味拥抱的博客
09-24 335
Maven添加依赖： <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.1</version> </dependency> gradle添加依赖： compile group: 'org.quartz-scheduler', name: 'qu
SSM整合Quartz框架
weweeeeeeee的博客
06-07 3832
1.Quartz概述 Quartz是一款开源的优秀任务调度框架，易上手使用简单 运行环境 Quartz 可以运行嵌入在另一个独立式应用程序 Quartz 可以在应用程序服务器(或servlet容器)内被实例化，并且参与XA事务 Quartz 可以作为一个独立的程序运行(其自己的Java虚拟机内)，可以通过RMI使用 Quartz 可以被实例化，作为独立的项目集群(负载平衡和故障转移功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值