定时任务-quartz的使用，实现可页面化管理
使用spring+quartz实现定时任务的页面化管理。主要特点：
1.时间表达式等信息配置在数据库中，从而实现页面化管理。
2.可以手动执行或者停止单个任务，也可以使一个任务加入或者移出自动运行列表。
下面开始介绍用法，在这之前先说明框架的版本。spring3.2.4+quartz1.6.0
一.配置文件
只需要在spring的配置文件中加入：
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
</bean>
<bean id="jobManager" class="com.temobi.quartz.JobManager">
</bean>
说明：scheduler对象是spring管理定时任务的对象。
jobManager是我们自定义加载定时任务列表的对象，此对象加载所有任务列表后，将他们加入到自动运行列表。
二.jobManager代码：
public class JobManager implements InitializingBean {
private static final Log log = LogFactory.getLog(JobManager.class);
@Autowired
TaskJobService taskJobService;
@Autowired
QuartzManager quartzManager;
@Override
public void afterPropertiesSet() throws Exception {
loadAllJob();
}
private void loadAllJob(){
List<TaskJob> list =taskJobService.getTaskList();
quartzManager.enableCronSchedule(list);
}
}
说明：
1.实现spring中InitializingBean接口，并覆盖afterPropertiesSet方法，则该方法会在应用启动的时候而且其他servlet执行完成之后执行，此处用来加载所有定时任务，并加入定时任务自动运行列表。
2.quartzManager是我们自定义的定时任务管理类，用来实现我们文章开头说的功能。
三.QuartzManager代码
@Controller
public class QuartzManager {
@Autowired
Scheduler scheduler;
private static final Log log = LogFactory.getLog(QuartzManager.class);
public void enableCronSchedule(List<TaskJob> list) {
for(TaskJob task : list){
SchedulingJob job = new SchedulingJob();
job.setJobId(task.getId());
job.setJobName(task.getJobName());
//job.setMemos(task.getNote());
job.setCronExpression(task.getJobCronExpression());
try{
String className= task.getJobClass().trim();
Class clazz = Class.forName(className);
job.setStateFulljobExecuteClass(clazz);
}catch(Exception e){
e.printStackTrace();
continue;
}
JobDataMap paramsMap = new JobDataMap();
paramsMap.put("jobName", task.getJobName());
if(task.getParamsKey1()!=null && task.getParamsValue1()!=null){
paramsMap.put(task.getParamsKey1(), task.getParamsValue1());
}
if(task.getParamsKey2()!=null && task.getParamsValue2()!=null){
paramsMap.put(task.getParamsKey2(), task.getParamsValue2());
}
if(task.getParamsKey3()!=null && task.getParamsValue3()!=null){
paramsMap.put(task.getParamsKey3(), task.getParamsValue3());
}
enableCronSchedule(job, paramsMap, true);
log.info("系统结束初始化任务："+task.getId()+":"+task.getJobName()+":"+task.getJobId());
}
}
/**
* 启动一个自定义的job
*
* @param schedulingJob
* 自定义的job
* @param paramsMap
* 传递给job执行的数据
* @param isStateFull
* 是否是一个同步定时任务，true：同步，false：异步
* @return 成功则返回true，否则返回false
*/
public boolean enableCronSchedule(SchedulingJob schedulingJob, JobDataMap paramsMap, boolean isStateFull) {
if (schedulingJob == null) {
return false;
}
try {
//scheduler = (Scheduler) ApplicationHelper.getBean("scheduler");
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(schedulingJob.getTriggerName(),
schedulingJob.getJobGroup());
if (null == trigger) {// 如果不存在该trigger则创建一个
JobDetail jobDetail = null;
if (isStateFull) {
jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),
schedulingJob.getStateFulljobExecuteClass());
} else {
jobDetail = new JobDetail(schedulingJob.getJobId(), schedulingJob.getJobGroup(),
schedulingJob.getJobExecuteClass());
}
jobDetail.setJobDataMap(paramsMap);
trigger = new CronTrigger(schedulingJob.getTriggerName(), schedulingJob.getJobGroup(),
schedulingJob.getCronExpression());
scheduler.scheduleJob(jobDetail, trigger);
} else {
// Trigger已存在，那么更新相应的定时设置
trigger.setCronExpression(schedulingJob.getCronExpression());
scheduler.rescheduleJob(trigger.getName(), trigger.getGroup(), trigger);
}
} catch (Exception e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* 禁用一个job
*
* @param jobId
* 需要被禁用的job的ID
* @param jobGroupId
* 需要被警用的jobGroupId
* @return 成功则返回true，否则返回false
*/
public boolean disableSchedule(String jobId) {
if (jobId.equals("")) {
return false;
}
try {
String jobGroupId="DEFAULT";
Trigger trigger = getJobTrigger(jobId, jobGroupId);
if (null != trigger) {
scheduler.deleteJob(jobId, jobGroupId);
}
} catch (SchedulerException e) {
e.printStackTrace();
return false;
}
return true;
}
/**
* 得到job的详细信息
*
* @param jobId
* job的ID
* @param jobGroupId
* job的组ID
* @return job的详细信息,如果job不存在则返回null
*/
public JobDetail getJobDetail(String jobId, String jobGroupId) {
if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {
return null;
}
try {
return scheduler.getJobDetail(jobId, jobGroupId);
} catch (SchedulerException e) {
e.printStackTrace();
return null;
}
}
/**
* 得到job对应的Trigger
*
* @param jobId
* job的ID
* @param jobGroupId
* job的组ID
* @return job的Trigger,如果Trigger不存在则返回null
*/
public Trigger getJobTrigger(String jobId, String jobGroupId) {
if (jobId.equals("") || jobGroupId.equals("") || null == jobId || jobGroupId == null) {
return null;
}
try {
return scheduler.getTrigger(jobId + "Trigger", jobGroupId);
} catch (SchedulerException e) {
e.printStackTrace();
return null;
}
}
}
说明：
1.主要方法有三个，启动一个任务，禁用一个任务，启动多个任务。启动即加入自动运行列表，禁用即移出自动运行列表。
2.TaskJob是一个任务对象，和数据库表结构相对应，后面给出数据库设计。
3.程序中有类似，
paramsMap.put(task.getParamsKey1(), task.getParamsValue1());
这样的代码，意思是假如你：如果你在数据库的ParamsKey1值为"username",ParamsValue1的值为"zhangsang".那么你在具体的job中给定变量名为"username"的变量并给出set/get方法，就可以得到值"zhangsang",此功能适用于给定时任务配置固定参数，并且参数名字随便你定。我们这里给了三个备用的，你也可以扩展，步骤就是数据库加一个字段，在上面的程序中paramsMap放入这个字段，当然你也可以不用参数。你数据库没有配置任何值，表示该定时任务没有固定参数。
4.SchedulingJob是一个定时任务执行参数的bean。即 将Taskjob对象的值经过处理转换成SchedulingJob对象，然后用SchedulingJob对象的值调用定时任务的API。
SchedulingJob对象主要做的事就是，TriggerName和JobGroup分别给出默认值。根据className生成StateFulljobExecuteClass的Class对象。
四。SchedulingJob代码：
public class SchedulingJob {
public static final int JS_ENABLED = 0; // 任务启用状态
public static final int JS_DISABLED = 1; // 任务禁用状态
public static final int JS_DELETE = 2; // 任务已删除状态
private String jobId; // 任务的Id，一般为所定义Bean的ID
private String jobName; // 任务的描述
private String jobGroup; // 任务所属组的名称
private int jobStatus; // 任务的状态，0：启用；1：禁用；2：已删除
private String cronExpression; // 定时任务运行时间表达式
private String memos; // 任务描述
private Class<?> stateFulljobExecuteClass;//同步的执行类，需要从StatefulMethodInvokingJob继承
private Class<?> jobExecuteClass;//异步的执行类，需要从MethodInvokingJob继承
/**
* 得到该job的Trigger名字
* @return
*/
public String getTriggerName() {
return this.getJobId() + "Trigger";
}
public String getJobId() {
return jobId;
}
public void setJobId(String jobId) {
this.jobId = jobId;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public String getJobGroup() {
if(jobGroup==null){
jobGroup = Scheduler.DEFAULT_GROUP;
}
return jobGroup;
}
public void setJobGroup(String jobGroup) {
this.jobGroup = jobGroup;
}
public int getJobStatus() {
return jobStatus;
}
public void setJobStatus(int jobStatus) {
this.jobStatus = jobStatus;
}
public String getCronExpression() {
return cronExpression;
}
public void setCronExpression(String cronExpression) {
this.cronExpression = cronExpression;
}
public String getMemos() {
return memos;
}
public void setMemos(String memos) {
this.memos = memos;
}
public Class<?> getStateFulljobExecuteClass() {
return stateFulljobExecuteClass;
}
public void setStateFulljobExecuteClass(Class<?> stateFulljobExecuteClass) {
this.stateFulljobExecuteClass = stateFulljobExecuteClass;
}
public Class<?> getJobExecuteClass() {
return jobExecuteClass;
}
public void setJobExecuteClass(Class<?> jobExecuteClass) {
this.jobExecuteClass = jobExecuteClass;
}
public static int getJS_ENABLED() {
return JS_ENABLED;
}
public static int getJS_DISABLED() {
return JS_DISABLED;
}
public static int getJS_DELETE() {
return JS_DELETE;
}
}
五。具体JOB实现
只要继承QuartzJobBean类，覆盖executeInternal方法即可。在job中可能通过get方法的方式得到jobDetail对象中JobDataMap(详见QuartzManager类)中同名参数值。示例代码。
@Controller
public class ContentJob extends QuartzJobBean{
@Autowired
TaskJobService taskJobService;
private String beginDate;
private String endDate;
/**
* 手动执行任务
* @param request
*/
@RequestMapping("/contentJobManual.do")
public void manual(HttpServletRequest request) {
String startDate=request.getParameter("startDate");
String endDate=request.getParameter("endDate");
TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");
Map<String, String> param = new HashMap<String, String>();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
String today=sdf.format(new Date());
if(StringUtils.isEmpty(startDate)){
param.put("beginDate", today);
}else{
param.put("beginDate", startDate);
}
if(StringUtils.isEmpty(endDate)){
param.put("endDate", today);
}else{
param.put("endDate", endDate);
}
taskJobService.callStatisticContent(param);
}
@Override
public void executeInternal(JobExecutionContext context) {
TaskJobService taskJobService = (TaskJobService) ApplicationHelper.getBean("taskJobService");
Map<String, String> param = new HashMap<String, String>();
SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
String today=sdf.format(new Date());
if(StringUtils.isEmpty(beginDate)){
param.put("beginDate", today);
}else{
param.put("beginDate", beginDate);
}
if(StringUtils.isEmpty(endDate)){
param.put("endDate", today);
}else{
param.put("endDate", endDate);
}
taskJobService.callStatisticContent(param);
}
public String getBeginDate() {
return beginDate;
}
public void setBeginDate(String beginDate) {
this.beginDate = beginDate;
}
public String getEndDate() {
return endDate;
}
public void setEndDate(String endDate) {
this.endDate = endDate;
}
六。手动执行一个任务。可以将该job类声明成一个@Controller。另外写一个方法如上例中的manual方法。
扩展：目前还不能将自动运行的方法和手动执行的方法（即executeInternal方法和manual方法）写成一个。因为自动运行的方法不是一个action类，它不在web环境中，是通过反射实现的。如果把executeInternal这个方法强行配置成具有web功能的方法（即类上面加@Controller，方法上面加@RequestMapping("/contentJobManual.do")）也是不行的，因为该方法没有HttpServletRequest对象，获取不了参数。除非你的定时任务没有参数。当然你也不能修改该方法的参数类型，因为他是覆盖QuartzJobBean的方法。
七。数据库设计。
ID VARCHAR2(60) N
JOB_CLASS VARCHAR2(255) N
JOB_NAME VARCHAR2(60) N
JOB_CRON_EXPRESSION VARCHAR2(60) N
JOB_SERVICE_BEAN VARCHAR2(60) Y
PARAMS_KEY1 VARCHAR2(60) Y
PARAMS_VALUE1 VARCHAR2(60) Y
PARAMS_KEY2 VARCHAR2(60) Y
PARAMS_VALUE2 VARCHAR2(60) Y
PARAMS_KEY3 VARCHAR2(60) Y
PARAMS_VALUE3 VARCHAR2(60) Y
NOTE VARCHAR2(255) Y
JOB_STATUS VARCHAR2(1) Y
UPDATETIME DATE Y
JOB_AUTORUN VARCHAR2(1) Y
JOB_GROUP VARCHAR2(60) Y
说明：JOB_STATUS表示是否有效任务，JOB_AUTORUN表示是否自动运行，JOB_SERVICE_BEAN表示手动执行的请求URL，JOB_CLASS表示JOB类的全路径，JOB_GROUP表示任务属于哪个组，方便对任务的分组管理（批量启动，禁止等），区别于quartz的API所要求的同名参数，其实也可以把这个值传给API。其它字段比较好理解。该表对应的bean是taskjob。
八。页面管理。
主要功能是将一个任务加入或者移出自动运行队列（通过quartzManager对象）。和任务的增删查改。示例代码如下：
@Controller
public class TaskJobAction{
private static final Log log = LogFactory.getLog(TaskJobAction.class);
@Autowired
TaskJobService taskJobService;
@Autowired
QuartzManager quartzManager;
@RequestMapping("/enableTask.do")
public void enableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {
String parameterStr="";
parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
parameterStr = StringUtils.trim(parameterStr);
parameterStr =URLDecoder.decode(parameterStr,"utf-8");
Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
String id=p.get("id");
if(!StringUtils.isEmpty(id)){
TaskJob task=taskJobService.getTaskById(id);
List<TaskJob> list=new ArrayList<TaskJob>();
list.add(task);
quartzManager.enableCronSchedule(list);
task.setJobEnabled("Y");
taskJobService.update(task);//将任务设置成自动运行状态
}
}
@RequestMapping("/disableTask.do")
public void disableTask(HttpServletRequest request, HttpServletResponse response) throws IOException {
String parameterStr="";
parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
parameterStr = StringUtils.trim(parameterStr);
parameterStr =URLDecoder.decode(parameterStr,"utf-8");
Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
String id=p.get("id");
if(!StringUtils.isEmpty(id)){
TaskJob task=taskJobService.getTaskById(id);
quartzManager.disableSchedule(task.getJobId());
task.setJobEnabled("N");
taskJobService.update(task);//将任务设置成非运行状态
}
}
@RequestMapping("/add.do")
public void add(HttpServletRequest request, HttpServletResponse response) throws IOException {
String parameterStr="";
parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
parameterStr = StringUtils.trim(parameterStr);
Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
String jobjson=p.get("jobjson");
jobjson=URLDecoder.decode(jobjson,"utf-8");
TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);
String jobName=URLDecoder.decode(task.getJobName(),"utf-8");
task.setJobName(jobName);
if(!StringUtils.isEmpty(jobjson)){
taskJobService.insert(task);
}
}
@RequestMapping("/update.do")
public void update(HttpServletRequest request, HttpServletResponse response) throws IOException {
String parameterStr="";
parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
parameterStr = StringUtils.trim(parameterStr);
Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
String jobjson=p.get("jobjson");
jobjson=URLDecoder.decode(jobjson,"utf-8");
TaskJob task=JsonUtil.toObject(jobjson, TaskJob.class);
String jobName=URLDecoder.decode(task.getJobName(),"utf-8");
task.setJobName(jobName);
if(!StringUtils.isEmpty(jobjson)){
taskJobService.update(task);
}
}
@RequestMapping("/delete.do")
public void delete(HttpServletRequest request, HttpServletResponse response) throws IOException {
String parameterStr="";
parameterStr = IOUtils.toString(request.getInputStream(), InputConstant.CHAR_SET);
parameterStr = StringUtils.trim(parameterStr);
parameterStr =URLDecoder.decode(parameterStr,"utf-8");
Map<String, String> p = JsonUtil.getParameterMap(parameterStr);
String idStr=p.get("idStr");
if(!StringUtils.isEmpty(idStr)){
taskJobService.delete(idStr);
}
}
@ResponseBody
@RequestMapping("/taskList.do")
public RecordResultBean list(HttpServletRequest request, HttpServletResponse response,@RequestParam("pageSize") int pageSize,
@RequestParam("startIndex") int startIndex) throws IOException {
int pageNum=startIndex/pageSize+1;
String startDate=request.getParameter("startDate");
String endDate=request.getParameter("endDate");
String jobName=request.getParameter("jobName");
if (!StringUtils.isEmpty(jobName)) {
jobName=URLDecoder.decode(jobName, "UTF-8");
jobName=URLDecoder.decode(jobName, "UTF-8");
}
RecordResultBean resultBean = new RecordResultBean();
try {
Pager pager = new Pager(pageNum, pageSize);
Map<String, Object> map = new HashMap<String, Object>();
map.put("jobName",jobName);
pager.setKeys(map);
pager = taskJobService.findPage(pager);
if (pager == null || pager.getTotalCount() == 0) {
resultBean.setResult(false);
} else {
resultBean.setResult(true);
resultBean.setBean(pager);
}
}catch(Exception ex) {
log.warn(JDKStackTrace.getJDKStrack(ex));
}
return resultBean;
}
由于很久没来CSDN了，看到很多小伙伴在要程序源码，其实这篇文章也是我转的，原文也没有源码。不过根据原文和查看的一些资料做了一个定时发布天气微博的程序，SHH+easyui架构的，也实现了页面控制任务的功能，由于时间很长了，源码仅作参考，下载地址:
http://download.csdn.net/detail/a78460750/9865995
