Quartz简单实现定时任务管理(SSM+Quartz)

首先你得有一个用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