前言
将项目中的所有定时任务都统一管理吧，使用 quartz 定时任务
设计思路
使用 quartz 的相关jar 包，懒得去升级了，我使用的是 quart 1.6
写一个定时任务管理类
用一张数据库表去统一定时任务
项目启动的时候也启动定时任务管理，同时启动开启状态的定时任务
制定页面去管理数据库的定时任务，如果，任务有修改删除停止等，修改对应修改定时任务
项目停止时，停止定时任务
部分实现代码
数据库脚本
DROP TABLE IF EXISTS `sys_scheduler`;
CREATE TABLE `sys_scheduler` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`cron` varchar(255) NOT NULL DEFAULT '',
`job_name` varchar(255) DEFAULT NULL,
`job_class` varchar(255) NOT NULL DEFAULT '',
`modify_time` datetime DEFAULT NULL,
`is_start` char(1) DEFAULT '0' COMMENT '任务状态是否启动，1-启动中，0-未启动',
PRIMARY KEY (`id`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;
/*Data for the table `sys_scheduler` */
insert into `sys_scheduler`(`id`,`cron`,`job_name`,`job_class`,`modify_time`,`is_start`) values (1,'0 30 * * * ?','示例定时任务','com.common.job.ExampleJob','2016-05-06 16:42:14','0');
定时任务管理（数据库的操作类省略）
package com.common.utils;
import java.util.Iterator;
import java.util.List;
import org.apache.log4j.Logger;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import com.common.dao.SysSchedulerDao;
import com.common.model.SysScheduler;
/**
* 定时任务 管理类
* @author ppnie
*
*/
public class SchedulerManager
{
static SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
static Scheduler sched = null;
static SchedulerManager schedulerMgr = null;
private static final Logger logger = Logger.getLogger(SchedulerManager.class.getName());
/**
* 创建定时任务单例，并且初始化启动定时任务
* @return
*/
public static SchedulerManager getInstance()
{
if (schedulerMgr == null)
{
schedulerMgr = new SchedulerManager();
schedulerMgr.init();
}
return schedulerMgr;
}
/**
* 初始化定时任务
*/
public void init()
{
try
{
sched = schedFact.getScheduler();
}
catch (Exception e)
{
logger.error("init1:" + e.getMessage());
}
start();
/*从数据库启动定时任务 */
SysSchedulerDao ssdao = new SysSchedulerDao();
List<SysScheduler> cdLists = ssdao.getSchedulerListByStart(ssdao.need_start);
Iterator<SysScheduler> ir = cdLists.iterator();
// System.out.println("-------------------Init Scheduler------------------");
while (ir.hasNext())
{
SysScheduler scheduler = ir.next();
scheduleJob(scheduler);
}
}
public void scheduleJob(SysScheduler scheduler)
{
scheduleJob(""+scheduler.getId(),scheduler.getJobClass(),scheduler.getCron());
if (isStarted())
{
System.out.println("Schedule " + scheduler.getJobName()+" class="+scheduler.getJobClass() + " cron=" + scheduler.getCron());
}
}
/**
* 添加某个任务到任务调度器
* @param jobId 任务id
* @param jobClass 任务job 类名
* @param cron 定时时间
* 设置定时器调度的时程表格式 秒 分 时 天 月 周 0 0 12 * * ? 每天中午十二点触发 0 15 10 15 * ? 每月15号的10：15触发 0 15 10 ? * 2-6
* 每个周一、周二、周三、周四、周五的10：15触发
*/
public void scheduleJob(String jobId, String jobClass, String cron)
{
if (isStarted())
{
try
{
Class cls = Class.forName(jobClass);
JobDetail jobDetail = new JobDetail(jobId, Scheduler.DEFAULT_GROUP, cls);
CronTrigger trigger = new CronTrigger(jobId, Scheduler.DEFAULT_GROUP, cron);
sched.scheduleJob(jobDetail, trigger);
}
catch (Exception e)
{
System.out.println("scheduleJob这里报错"+jobClass);
logger.error("scheduleJob:" + e.getMessage());
}
}
}
/**
*
* @param jobId
* @param jobClass
* @param cron
* @param data_map
*/
public void scheduleJob(String jobId, String jobClass, String cron, String data_map)
{
if (isStarted())
{
System.out.println("Schedule " + jobClass + " cron=" + cron);
try
{
Class cls = Class.forName(jobClass);
JobDetail jobDetail = new JobDetail(jobId, Scheduler.DEFAULT_GROUP, cls);
CronTrigger trigger = new CronTrigger(jobId, Scheduler.DEFAULT_GROUP, cron);
sched.scheduleJob(jobDetail, trigger);
}
catch (Exception e)
{
logger.error("scheduleJob:" + e.getMessage());
}
}
}
/**
* 根据jobId 在 任务调度器 中删除某个任务
* @param jobId
*/
public void delJob(String jobId)
{
try
{
sched.deleteJob(jobId, Scheduler.DEFAULT_GROUP);
}
catch (Exception e)
{
logger.error("deleteJob:" + e.getMessage());
}
}
/**
* 重新发布任务，在这里是根据jobId 修改任务执行时间 corn
* @param jobId
* @param cron
*/
public void rescheduleJob(String jobId, String cron)
{
try
{
JobDetail jd = sched.getJobDetail(jobId, Scheduler.DEFAULT_GROUP);
JobDataMap jdm = jd.getJobDataMap();
CronTrigger trigger = new CronTrigger("" + jobId, Scheduler.DEFAULT_GROUP, cron);
trigger.setJobName("" + jobId);
trigger.setJobGroup(Scheduler.DEFAULT_GROUP);
trigger.setJobDataMap(jdm);
sched.rescheduleJob(jobId, Scheduler.DEFAULT_GROUP, trigger);
}
catch (Exception e)
{
logger.error("rescheduleJob:" + e);
}
}
/**
* 启动 任务调度器
* 只有在Scheduler 有实例或standby 模式才能调用start() 方法
*/
public void start()
{
try
{
sched.start();
}
catch (Exception e)
{
logger.error("start:" + e);
}
}
/**
* 关闭 任务调度器Scheduler
* 一旦调用shutdown() 方法之后就不能在调用start() 方法
*/
public void shutdown()
{
System.out.println("------------------Shutdown Scheduler------------------");
try
{
sched.shutdown();
}
catch (Exception e)
{
logger.error("shutdown:" + e.getMessage());
}
schedulerMgr = null;
}
/**
* 判断 任务调度器Scheduler 是否被启动
* @return
*/
public boolean isStarted()
{
boolean re = false;
try
{
re = sched.isStarted();
}
catch (Exception e)
{
logger.error("isStarted:" + e.getMessage());
}
return re;
}
/**
* 判断 任务调度器Scheduler 是否关闭
* @return
* @throws SchedulerException
*/
public boolean isShutdown()
{
boolean re = false;
try
{
sched.isShutdown();
}
catch (SchedulerException e)
{
logger.error("isShutdown:" + e.getMessage());
}
return re;
}
/**
* 设置 Scheduler 为 standby 模式
* standby 模式时 Scheduler 暂时停止查找 Job 去执行
*/
public void standby() {
System.out.println("------------------Standby Scheduler------------------");
try {
sched.standby();
}
catch (Exception e) {
logger.error("standby:" + e.getMessage());
}
}
/**
* 判断Scheduler 操作是否是 standby 模式
*/
public boolean isInStandbyMode() {
boolean re = false;
try {
re = sched.isInStandbyMode();
} catch (Exception e) {
logger.error("isInStandbyMode:" + e.getMessage());
}
return re;
}
/**
* 判断任务是否存在
* @param jobId
* @return
*/
public boolean checkExists(String jobId)
{
boolean re = false;
try
{
CronTrigger trigger = (CronTrigger)sched.getTrigger("" + jobId, Scheduler.DEFAULT_GROUP);
return trigger != null;
}
catch (SchedulerException e)
{
logger.error("checkExists:" + e.getMessage());
}
return re;
}
}
而随着项目的启停，可以建立一个servlet ，在init 方法中初始化 任务管理类，destory 方法中 关闭
<servlet>
<servlet-name>SysSchedulerServlet</servlet-name>
<servlet-class>com.common.servlet.SysSchedulerServlet</servlet-class>
<load-on-startup>0</load-on-startup>
</servlet>
该贴被panpan.nie编辑于2016-6-2 16:25:11
当前位置：
论坛首页 »
自由讨论区 »
Android, Python及开发编程讨论区
»
发起投票
技术讨论
加好友
发消息
2016-6-2 16:24:35 |
赞(
操作
