Spring+Quartz实现动态添加定时任务

标签: spring quartz 任务 | 发表时间:2014-01-10 12:16 | 作者:suipian1029
出处:http://www.iteye.com
【1】.配置定时器
<bean id="supplyBidInfoDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  <property name="targetObject">
   <ref bean="supplyBidInfo"/>
  </property>
  <property name="targetMethod">
   <value>doAutoJob</value>
  </property>
</bean>
<bean id="supplyBidInfoTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
  <property name="jobDetail">
   <ref bean="supplyBidInfoDetail"/>
  </property>
  <property name="cronExpression">
   <value>0 0 0 * * ?</value><!-- 每天晚上0点执行一次 -->
  </property>
</bean>

//如果全部定时任务都要动态生成,可以只配置这一个即可

<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  <property name="triggers">
   <list>
    <ref bean="supplyBidInfoTrigger"/>
   </list>
  </property>
</bean>

【2】.定时器工具类

/**
*
*
* Description: 计时器工具类
*
* <pre>
* Modification History:
* Date         Author      Version     Description
* ------------------------------------------------------------------
* 2013-7-19    lanzhongliang   1.0      1.0 Version
* </pre>
*/
@Repository("scheduleInfoManager")
@Scope("prototype")
public class ScheduleInfoManager {
private static Scheduler scheduler;// 调度器
static {
  scheduler = (StdScheduler) Environment.getInstance().getBean("schedulerFactoryBean");
}

/**
  *
  *
  * Description: 启动一个自定义的job
  *
  * @param schedulingJob
  *            自定义的job
  * @param paramsMap
  *            传递给job执行的数据
  * @param isStateFull
  *            是否是一个同步定时任务,true:同步,false:异步
  * @return 成功则返回true,否则返回false
  * @Author lanzhongliang
  * @Create 2013-7-19 下午03:57:22
  */
public static boolean enableCronSchedule(ScheduleJobEntity schedulingJob, JobDataMap paramsMap, boolean isStateFull) {
  if (schedulingJob == null) {
   return false;
  }
  try {
   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;
}

/**
  *
  *
  * Description: 禁用一个job
  *
  * @param jobId
  *            需要被禁用的job的ID
  * @param jobGroupId
  *            需要被禁用的jobGroupId
  * @return 成功则返回true,否则返回false
  * @Author lanzhongliang
  * @Create 2013-7-19 下午04:03:24
  */
public static boolean disableSchedule(String jobId, String jobGroupId) {
  if (StringUtil.isBlank(jobId) || StringUtil.isBlank(jobGroupId)) {
   return false;
  }
  try {
   Trigger trigger = getJobTrigger(jobId, jobGroupId);
   if (null != trigger) {
    scheduler.deleteJob(jobId, jobGroupId);
   }
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  }
  return true;
}

/**
  *
  * Description: 得到job的详细信息
  *
  * @param jobId
  *            job的ID
  * @param jobGroupId
  *            job的组ID
  * @return job的详细信息,如果job不存在则返回null
  * @Author lanzhongliang
  * @Create 2013-7-19 下午04:07:08
  */
public static JobDetail getJobDetail(String jobId, String jobGroupId) {
  if (StringUtil.isBlank(jobId) || StringUtil.isBlank(jobGroupId)) {
   return null;
  }
  try {
   return scheduler.getJobDetail(jobId, jobGroupId);
  } catch (SchedulerException e) {
   e.printStackTrace();
   return null;
  }
}

/**
  *
  *
  * Description: 得到job对应的Trigger
  *
  * @param jobId
  *            job的ID
  * @param jobGroupId
  *            job的组ID
  * @return job的Trigger,如果Trigger不存在则返回null
  * @Author lanzhongliang
  * @Create 2013-7-19 下午04:09:00
  */
public static 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;
  }
}

}

【3】.封装的定时任务实体类

/**
*
*
* Description:任务实体类
*
* <pre>
* Modification History:
* Date         Author      Version     Description
* ------------------------------------------------------------------
* 2013-7-19    lanzhongliang   1.0      1.0 Version
* </pre>
*/
public class ScheduleJobEntity {

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() {
  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;
}

}
【4】.定时任务执行类,通过反射机制操纵业务执行类

/**
*
*
* Description:同步定时任务执行类
*
* <pre>
* Modification History:
* Date         Author      Version     Description
* ------------------------------------------------------------------
* 2013-7-19    lanzhongliang   1.0      1.0 Version
* </pre>
*/
public class SynchroExecuteJobAction extends StatefulMethodInvokingJob {

@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
  try {
   String methodName = context.getJobDetail().getJobDataMap().getString("method_name");
   // 通过获取参数:方法名,通过反射机制执行相应方法
   ScheduleExecute s = new ScheduleExecute();
   s.getClass().getMethod(methodName, JobExecutionContext.class).invoke(s, context);
  } catch (Exception e) {
   e.printStackTrace();
  }
}
}
/**
*
*
* Description:异步定时任务执行类
*
* <pre>
* Modification History:
* Date         Author      Version     Description
* ------------------------------------------------------------------
* 2013-7-22    lanzhongliang   1.0      1.0 Version
* </pre>
*/
public class AsynchroExecuteJobAction extends MethodInvokingJob {

@Override
protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
  try {
   String methodName = context.getJobDetail().getJobDataMap().getString("method_name");
   // 通过获取参数:方法名,通过反射机制执行相应方法
   ScheduleExecute s = new ScheduleExecute();
   s.getClass().getMethod(methodName, JobExecutionContext.class).invoke(s, context);
  } catch (Exception e) {
   e.printStackTrace();
  }
}
}



【5】.定时任务具体业务执行类


/**
*
*
* Description:定时任务逻辑执行类
*
* <pre>
* Modification History:
* Date         Author      Version     Description
* ------------------------------------------------------------------
* 2013-7-22    lanzhongliang   1.0      1.0 Version
* </pre>
*/
public class ScheduleExecute {
private Logger logger = LogDefault.getLogger(getClass());
private BidInfoService bidInfoService;

public ScheduleExecute(){
  bidInfoService = (BidInfoService)Environment.getInstance().getBean("bidInfoService");
}

/**
  *
  * Description: 自动补充到期招投标所需金额定时任务执行方法
  *
  * @return void
  * @throws Exception
  * @Author lanzhongliang
  * @Create 2013-7-22 下午04:16:08
  */
public void supplyBidQuartz(JobExecutionContext context) {
  try {
   logger.info("【动态定时任务】执行将到期借款标金额补全【开始】");
   JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
   Integer bidId = jobDataMap.getInt("bid_id");
   String retStr = bidInfoService.updateBidInfoQuartz(bidId);
   if ("F".equals(retStr)) {
    logger.info("【动态定时任务】执行将到期借款标金额补全【失败】");
   }
   logger.info("【动态定时任务】执行将到期借款标金额补全【结束】");
  } catch (Exception e) {
   e.printStackTrace();
   return;
  }
}
}



已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [spring quartz 任务] 推荐:

quartz spring 实现动态定时任务

- - 企业架构 - ITeye博客
在实际项目应用中经常会用到定时任务,可以通过quartz和spring的简单配置即可完成,但如果要改变任务的执行时间、频率,废弃任务等就需要改变配置甚至代码需要重启服务器,这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现. 参考文章: http://www.meiriyouke.net/?p=82.

Spring+quartz 实现动态管理任务

- - 寒江孤影
在实际项目应用中经常会用到定时任务,可以通过quartz和spring的简单配置即可完成,但如果要改变任务的执行时间、频率,废弃任务等就需要改变配置甚至代码需要重启服务器,这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现. 本文章适合对quartz和spring有一定了解的读者.

Spring实现后台的任务调度TimerTask和Quartz

- - CSDN博客互联网推荐文章
最近整后台,涉及到两个后台调度的问题. 一是以时间间隔为条件的轮询调度;. 运用场景:每隔5分钟抓取数据;. 二是一某个时间点为条件的轮询调度;. 运用场景:后台日志货报表生成上传,每个周一生成上一周的,每个月初生成上一月. 其实按周来执行调度,用前面一个场景也可以实现,但是按月生成,因为每月时间不固定,必须动态判断和执行.

Spring 任务调度Quartz的cron表达式

- - ITeye博客
Spring支持基于Quartz的任务调度,那么其cron表达式类似于Linux的crontab,有7个字符构成,详情如下:. 表达一个列表值,如在星期字段中使用“MON,WED,FRI”,则表示星期一,星期三和星期五. 表达一个范围,如在小时字段中使用“10-12”,则表示从10到12点,即等同于10,11,12.

Spring+Quartz实现动态添加定时任务

- - 编程语言 - ITeye博客
   0 0 0 * * ?. //如果全部定时任务都要动态生成,可以只配置这一个即可. * Description: 计时器工具类. private static Scheduler scheduler;// 调度器.   * Description: 启动一个自定义的job.

spring quartz 集群配置

- - CSDN博客推荐文章
Quartz 是一个开源的作业调度框架,它完全由 Java 写成,并设计用于 J2SE 和 J2EE 应用中. 它提供了巨大的灵活性而不牺牲简单性. 你能够用它来为执行一个作业而创建简单的或复杂的调度. 在项目中有大量的后台任务需要调度执行,如构建索引、统计报表、周期同步数据等等,要求任务调度系统具备高可用性、负载均衡特性,使用Quartz 会很方便.

quartz 任务的增删改

- - 编程语言 - ITeye博客
从网上找了好多例子,要么太老,要么用不了. * 添加一个定时任务,使用默认的任务组名,触发器名,触发器组名. * @param jobName 任务名. * @param cls 任务. * @param time 时间设置,参考quartz说明文档. Scheduler scheduler = schedulerFactory.getScheduler();//创建一个触发器表.

Quartz任务监控管理 (1)

- - Java - 编程语言 - ITeye博客
Quartz任务监控管理,类似Windows任务管理器,可以获得运行时的实时监控,查看任务运行状态,动态增加任务,暂停、恢复、移除任务等. 对于动态增加任务,可以参加我的前一篇文章《Quartz如何在Spring动态配置时间》,本文在前文的基础上扩展,增加暂停、恢复、移除任务等功能,实现Quartz任务监控管理.

Quartz实现动态定时任务

- - 编程语言 - ITeye博客
转http://my.oschina.net/u/1177710/blog/284608.      由于最近工作要实现定时任务的执行,而且要求定时周期是不固定的,所以就用到了quartz来实现这个功能;.      spring3.1以下的版本必须使用quartz1.x系列,3.1以上的版本才支持quartz 2.x,不然会出错.

使用Quartz和Obsidian来调度任务

- - Java译站
在介绍使用到的Quartz和Obsidian的API之前,首先我得声明一下,一般来说使用API并不是调度任务的最佳方式. Quartz提供了一个通过XML来配置作业的机制,而Obsidian则为你提供了一套完整的管理和监控的WEB应用. 然而,有一些使用场景还是强烈推荐使用API的,我们来看一下吧.