首先你得有一个用Maven搭好的SSM框架,数据库用的Mysql,这里只有关于Quartz的部分。其实有大神总结的很好了,但做完后总有些地方不一样,所以写这篇作为笔记。这里先把大神的写的分享给大家:https://blog.csdn.net/u010648555/article/details/60767633

一、准备工作

1. 在maven的pom文件中添加Quartz的Jar坐标

<!-- quartz 定时器 -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.1</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>2.2.1</version>
</dependency>
2. 在web.xml中添加quartz的监听器

<!-- 配置quartz监听器 -->
<listener>
<listener-class>
org.quartz.ee.servlet.QuartzInitializerListener
</listener-class>
</listener>
3. 添加quartz.properties配置文件

# Configure Main Scheduler Properties
org.quartz.scheduler.instanceName: dufy_test
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

# Configure ThreadPool
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 2
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000

# 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.isClustered = false

# 表前缀
org.quartz.jobStore.tablePrefix:qrtz_
#org.quartz.jobStore.dataSource:qzDS

# 下面是数据库的配置,交给Spring管理了
#org.quartz.dataSource.qzDS.driver:com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz_test
#org.quartz.dataSource.qzDS.user:root
#org.quartz.dataSource.qzDS.password:123
#org.quartz.dataSource.qzDS.maxConnection:10
4. 添加Spring配置:applicationContext-quartz.xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.0.xsd">

<!-- =========JDBC版=========== -->
<!--
持久化数据配置,需要添加quartz.properties
-->
<bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="dataSource" ref ="dataSource" />
<property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
<property name="configLocation" value="classpath:resource/quartz.properties"/>
</bean>
</beans>
5. 将Quartz自带的表导入Mysql

create table qrtz_job_details(
sched_name varchar(120) not null,
job_name varchar(80) not null,
job_group varchar(80) not null,
description varchar(120),
job_class_name varchar(128) not null,
is_durable integer not null,
is_nonconcurrent integer not null,
is_update_data integer not null,
requests_recovery integer not null,
job_data blob(2000),
primary key (sched_name,job_name,job_group)
);

create table qrtz_triggers(
sched_name varchar(120) not null,
trigger_name varchar(80) not null,
trigger_group varchar(80) not null,
job_name varchar(80) not null,
job_group varchar(80) not null,
description varchar(120),
next_fire_time bigint,
prev_fire_time bigint,
priority integer,
trigger_state varchar(16) not null,
trigger_type varchar(8) not null,
start_time bigint not null,
end_time bigint,
calendar_name varchar(80),
misfire_instr smallint,
job_data blob(2000),
primary key (sched_name,trigger_name,trigger_group),
foreign key (sched_name,job_name,job_group) references qrtz_job_details(sched_name,job_name,job_group)
);

create table qrtz_simple_triggers(
sched_name varchar(120) not null,
trigger_name varchar(80) not null,
trigger_group varchar(80) not null,
repeat_count bigint not null,
repeat_interval bigint not null,
times_triggered bigint not null,
primary key (sched_name,trigger_name,trigger_group),
foreign key (sched_name,trigger_name,trigger_group) references qrtz_triggers(sched_name,trigger_name,trigger_group)
);

create table qrtz_cron_triggers(
sched_name varchar(120) not null,
trigger_name varchar(80) not null,
trigger_group varchar(80) not null,
cron_expression varchar(120) not null,
time_zone_id varchar(80),
primary key (sched_name,trigger_name,trigger_group),
foreign key (sched_name,trigger_name,trigger_group) references qrtz_triggers(sched_name,trigger_name,trigger_group)
);

CREATE TABLE qrtz_simprop_triggers(
sched_name varchar(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)
);

create table qrtz_blob_triggers(
sched_name varchar(120) not null,
trigger_name varchar(80) not null,
trigger_group varchar(80) not null,
blob_data blob(2000),
primary key (sched_name,trigger_name,trigger_group),
foreign key (sched_name,trigger_name,trigger_group) references qrtz_triggers(sched_name,trigger_name,trigger_group)
);

create table qrtz_calendars(
sched_name varchar(120) not null,
calendar_name varchar(80) not null,
calendar blob(2000) not null,
primary key (calendar_name)
);

create table qrtz_fired_triggers(
sched_name varchar(120) not null,
entry_id varchar(95) not null,
trigger_name varchar(80) not null,
trigger_group varchar(80) not null,
instance_name varchar(80) not null,
fired_time bigint not null,
sched_time bigint not null,
priority integer not null,
state varchar(16) not null,
job_name varchar(80),
job_group varchar(80),
is_nonconcurrent integer,
requests_recovery integer,
primary key (sched_name,entry_id)
);

create table qrtz_paused_trigger_grps(
sched_name varchar(120) not null,
trigger_group varchar(80) not null,
primary key (sched_name,trigger_group)
);

create table qrtz_scheduler_state(
sched_name varchar(120) not null,
instance_name varchar(80) not null,
last_checkin_time bigint not null,
checkin_interval bigint not null,
primary key (sched_name,instance_name)
);

create table qrtz_locks(
sched_name varchar(120) not null,
lock_name varchar(40) not null,
primary key (sched_name,lock_name)
);
6. 自己建立管理定时任务的表,我简单写了几个必须的属性

public class QuartzTask {

/*
* 这个类用于展示定时的任务,同时作用于定时任务的恢复、删除、中止;
**/

private Long jobId;

private String jobClass; //任务类的全限定类名

private String jobGroup; //任务组名

private String jobName; //任务名

private String triggerName; //任务触发器名

private String triggerGroupName; //任务触发器组名

private String cronExpr; //时间表达式

private Integer jobStatus; //任务状态

private String startTime; //任务开始时间
7. 准备俩简单的Jsp页面用于添加定时任务和定时任务列表展示

大致效果如下:

二、简单代码实现

1.写个任务类,本想做个功能,失败了,就简单控制台输出了

public class MyJob implements Job{

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

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {

log.info("MyJob is start ..................");

log.info("Hello quzrtz "+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));

log.info("MyJob is end .....................");

}
}
2. Controller层:QuartzController

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

@Autowired
private QuartzTaskService quartzTaskService;

/**
* 添加定时任务
* */
@RequestMapping(value = "add",method = RequestMethod.POST)
public ModelAndView addQtz(QuartzTask qt){

try {
//1.成功启动定时任务
this.quartzTaskService.addQtz(qt);

//2.封装QuartzTask,执行保存
this.quartzTaskService.saveAddQtz(qt);

return new ModelAndView("success");

} catch (Exception e) {
e.printStackTrace();
}
return new ModelAndView("error");

}

/**
* 定时任务列表
* */
@RequestMapping(value = "list",method = RequestMethod.GET)
public ModelAndView listQtz(){

try {
//1.查询所有定时任务
List<QuartzTask> list = this.quartzTaskService.listQtz();
ModelAndView mv = new ModelAndView();
mv.addObject("qtzList",list);
mv.setViewName("quartz-list");

return mv;

} catch (Exception e) {
e.printStackTrace();
}
return new ModelAndView("error");

}

/**
* 删除定时任务
* */
@RequestMapping(value = "delete",method = RequestMethod.GET)
public ModelAndView deleteQtz(QuartzTask qt){

try {
// 执行删除
this.quartzTaskService.deleteQtz(qt);

// 根据id删除定时任务列表数据
this.quartzTaskService.deleteQtzTask(qt.getJobId());

return new ModelAndView("success");

} catch (Exception e) {
e.printStackTrace();
}
return new ModelAndView("error");

}

/**
* 中止定时任务
* */
@RequestMapping(value = "pause",method = RequestMethod.GET)
public ModelAndView pauseQtz(QuartzTask qt){

try {
// 执行中止
this.quartzTaskService.pauseQtz(qt);

return new ModelAndView("success");

} catch (Exception e) {
e.printStackTrace();
}
return new ModelAndView("error");

}

/**
* 恢复定时任务
* */
@RequestMapping(value = "resume",method = RequestMethod.GET)
public ModelAndView resumeQtz(QuartzTask qt){

try {
// 执行中止
this.quartzTaskService.resumeQtz(qt);

return new ModelAndView("success");

} catch (Exception e) {
e.printStackTrace();
}
return new ModelAndView("error");

}
}
3. Service层:QuartzTaskServiceImpl

@Service
public class QuartzTaskServiceImpl implements QuartzTaskService {

@Autowired
private QuartzDao quartzDao;

@Autowired
private Scheduler scheduler;

@Override
public void addQtz(QuartzTask qt) {

try {
// 1.创建一个JobDetail实例,指定Quartz
String cla = qt.getJobClass();
Class clazz = Class.forName(cla);
JobDetail jobDetail = JobBuilder.newJob(clazz) // 任务执行类
.withIdentity(qt.getJobName(), qt.getJobGroup())// 任务名,任务组
.build();
CronScheduleBuilder builder = CronScheduleBuilder.cronSchedule(qt.getCronExpr());

// 2.创建Trigger(触发器)
Trigger trigger = TriggerBuilder.newTrigger().withIdentity(qt.getTriggerName(), qt.getTriggerGroupName())
.startNow().withSchedule(builder).build();

// 3.告诉调度器使用该触发器来安排作业
scheduler.scheduleJob(jobDetail, trigger);

// 4.启动
if (!scheduler.isShutdown()) {
scheduler.start();
}

} catch (Exception e) {
throw new RuntimeException(e);
}
}

@Override
public void saveAddQtz(QuartzTask qt) {

qt.setJobId(1l);
qt.setJobStatus(1);
qt.setStartTime(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss ").format(new Date()));

this.quartzDao.saveAddQtz(qt);

}

@Override
public List<QuartzTask> listQtz() {

return quartzDao.listQtz();
}

@Override
public void deleteQtz(QuartzTask qt) {

try {
// 停止触发器
scheduler.pauseTrigger(TriggerKey.triggerKey(qt.getTriggerName(), qt.getTriggerGroupName()));
// 移除触发器
scheduler.unscheduleJob(TriggerKey.triggerKey(qt.getTriggerName(), qt.getTriggerGroupName()));
// 删除任务
scheduler.deleteJob(JobKey.jobKey(qt.getJobName(), qt.getJobGroup()));
} catch (Exception e) {
throw new RuntimeException(e);
}
}

@Override
public void deleteQtzTask(Long jobId) {

this.quartzDao.deleteQtzTask(jobId);

}

@Override
public void pauseQtz(QuartzTask qt) {

try {
scheduler.pauseJob(JobKey.jobKey(qt.getJobName(), qt.getJobGroup()));
} catch (SchedulerException e) {
e.printStackTrace();
}

}

@Override
public void resumeQtz(QuartzTask qt) {

try {
scheduler.resumeJob(JobKey.jobKey(qt.getJobName(), qt.getJobGroup()));
} catch (SchedulerException e) {
e.printStackTrace();
}

}

}
4. 与数据库交互的QuartzTask.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<!-- 根标签,对应一个Dao接口 -->
<mapper namespace="cn.jindou.crm.mapper.QuartzDao">

<resultMap type="cn.jindou.crm.pojo.QuartzTask" id="quartzMap">
<id column="job_id" property="jobId"/>
<result column="job_class" property="jobClass"/>
<result column="job_group" property="jobGroup"/>
<result column="job_name" property="jobName"/>
<result column="trigger_name" property="triggerName"/>
<result column="trigger_groupName" property="triggerGroupName"/>
<result column="cron_expr" property="cronExpr"/>
<result column="job_status" property="jobStatus"/>
<result column="start_time" property="startTime"/>
</resultMap>

<insert id="saveAddQtz" parameterType="cn.jindou.crm.pojo.QuartzTask">
INSERT INTO quartz
(job_id,job_class,job_group,job_name,trigger_name,trigger_groupName,cron_expr,job_status,start_time)
VALUES(#{jobId},#{jobClass},#{jobGroup},#{jobName},#{triggerName},#{triggerGroupName},#{cronExpr},#{jobStatus},#{startTime});
</insert>

<select id="listQtz" resultMap="quartzMap">
select * from quartz;
</select>

<delete id="deleteQtzTask" parameterType="java.lang.Long">
DELETE from quartz where job_id = #{jobId};
</delete>

</mapper>

我这里只做了简单实现,还有很多地方不懂,继续努力。
---------------------
原文:https://blog.csdn.net/weixin_38943098/article/details/87807678

Quartz简单实现定时任务管理(SSM+Quartz)的更多相关文章

  1. springmvc+quartz简单实现定时调度

    一.简介:Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用.Quartz可以用来创建简单或为运行十 ...

  2. Quartz 定时任务管理

    前言 将项目中的所有定时任务都统一管理吧,使用 quartz 定时任务 设计思路 使用 quartz 的相关jar 包,懒得去升级了,我使用的是 quart 1.6 写一个定时任务管理类 用一张数据库 ...

  3. 基于Quartz实现简单的定时发送邮件

    一.什么是Quartz Quartz 是一个轻量级任务调度框架,只需要做些简单的配置就可以使用:它可以支持持久化的任务存储,即使是任务中断或服务重启后,仍可以继续运行.Quartz既可以做为独立的应用 ...

  4. Spring Boot集成持久化Quartz定时任务管理和界面展示

    本文是对之前的一篇文章Spring+SpringMVC+mybatis+Quartz整合代码部分做的一个修改和补充, 其中最大的变化就是后台框架变成了Spring Boot. 本工程所用到的技术或工具 ...

  5. SpringBoot2.x集成Quartz实现定时任务管理(持久化到数据库)

    1. Quartz简介   Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目.   Quartz是一个完全由Java编写的开源作业调度框架,为在Java应 ...

  6. Spring结合Quartz实现多任务定时调用(转载)

    Quartz框架提供了丰富的任务调度支持,比如,在 何时执行何种任务,它是一个开源的由OpenSymphony维护的项目,开发者能够在Java EE,或单独的Java SE应用中使用它.无论是简单的任 ...

  7. 定时调度框架Quartz随笔

    最近项目中的定时批处理用到了quartz定时任务,在此记录下quartz的配置吧,一个小demo仅供参考,也方便自己今后复习! 下面直接来步骤吧! 一.首先,要搭起能让quartz正常运行的环境,至少 ...

  8. Quartz.net 的开源任务管理平台

    Quartz.net 的开源任务管理平台 前面总结了很多,关于Quartz.net 的文章,介绍了如何使用Quartz.net.不清楚的朋友,可以看我之前的系列文章,http://www.cnblog ...

  9. windows 服务实现定时任务调度(Quartz.Net)

    我们通常在一些情况下需要软件具有一个自动执行某些任务的功能,但是又不希望直接启动软件,或者每次都要手动的来启动软件,这时我们可可以考虑到windows服务了. 首先创建一个windows服务项目(详细 ...

随机推荐

  1. 解决CentOS 7中php-fpm进程数过多导致服务器内存资源消耗较大的问题

    本文由荒原之梦原创,原文链接:http://zhaokaifeng.com/?p=653 什么是php-fpm: php-fpm即FastCGI进程管理器,用于控制php的内存和进程等. 操作环境: ...

  2. Java集合类的详解与应用

    Java集合类的详解与应用 集合简介: 1.定义:可以同时存储不同类型的数据 他的存储空间会随着数据的增大而增大 2.缺点:只能存储引用数据类型 3.优点:更加合理的利用空间,封装了更多的方法,用起来 ...

  3. Tar专题

    下面的脚本根据当前的系统时间生成压缩文件名,并备份文件到指定目录: DIR=/www/webbackup/web/ FILE_NAME=`date +%y%m%d%H` FILE_NAME=$DIR/ ...

  4. FPGA学习笔记(一)——初识FPGA

    ###### [该随笔部分内容转载自小梅哥]       ######### FPGA(Field-Programmable Gate Array,现场可编程门阵列),正如其名,FPGA内部有大量的可 ...

  5. 25个让Java程序员更高效的Eclipse插件

    Eclipse提供了一个可扩展插件的开发系统.这就使得Eclipse在运行系统之上可以实现各种功能.这些插件也不同于其他的应用(插件的功能是最难用代码实现的).拥有合适的Eclipse插件是非常重要的 ...

  6. vagrant命令

    $ vagrant init      # 初始化 $ vagrant up        # 启动虚拟机$ vagrant halt      # 关闭虚拟机$ vagrant reload     ...

  7. JDBC连接MySQL数据库基础

    主要内容 MySQL的基本操作和基本SQL语法 使用JDBC进行MySQL数据库的开发 使用DriverManager.Connection.PreparedStatement.ResultSet对数 ...

  8. System.out.println()

    System是java.lang中的类,out为System中的一个静态数据成员,out是java.io.PrintStream类的对象,而println()是java.io.PrintStream类 ...

  9. BZOJ4554: [Tjoi2016&Heoi2016]游戏 luoguP2825 loj2057

    题面描述:尽可能多的放置符合要求的炸弹. 分析: 在i,j处放置炸弹,则在第i行,上一个硬石头之后,下一个硬石头之前,第j列,上一个硬石头之后,下一个硬石头之前,不能再次放置炸弹. 首先,这个题,一看 ...

  10. 猴子 JDFZ模拟赛

    猴子(弱) Description 话说NP做梦,梦见自己变成了一只猴子,并且有很多香蕉树,这些香蕉树都种在同一直线上,而NP则在这排香蕉树的第一棵树上.NP当然想吃尽量多的香蕉,但它又不想在地上走, ...