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

【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;
  }
}
}