Quartz2动态化，实现增删改等操作。

今天在搭建框架的时候，集成了Quartz2,以前也经常使用Quartz，从事了电子商务这个行业之后，经常有需求要添加类似于限时抢购这样的营销功能，这个时候我们需要动态的处理Quartz无疑是最好的，以前只需要通过一点配置就可以实现定时调度任务处理，但是如果想动态的改变调度，操作调度甚至增加修改调度的时候，还需要修改配置文件再重启项目？带着这样的疑问我查了一些资料，发现很多人都已经提出了相关的解决方案，现在推荐2个帖子，我也是通过向他们学习才能在短时间内完成该需求。

我学习过的帖子：

spring3整合quartz2，实现动态添加、修改、暂停、重启定时任务

Quartz实现动态定时任务

非常感谢以上俩个帖子，接下来写一些自己的东西，在思想上并不会有太大的改变，但是更加适合新手参考和学习：

我的环境：

首先我的开发环境是jdk1.7.9，springmvc4.2.5，quartz2.2，相关的jar资源我也已经上传，现在放出链接：

http://download.csdn.net/detail/klsstt/9487032

配置quartz2:

在配置上，由于任务调度(job)和触发器（tigger）都需要我们动态实现，所以配置方面就不需要再进行配置了，因此quartz2的配置很简洁，只需要一句话
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />

我们只需要指定需要注入schedulerFactoryBean（调度容器）即可。

配置完成之后，我们需要创建相关job的库和表，这里为了实现演示，就不创建数据层了，我们直接写死即可，

与job相关的bean和工厂如下：

package com.sys.dto;

/**
 * 计划任务信息
 * auto: klsstt time: 2016-04-11 11:08
 */
public class ScheduleJob {
 
    /** 任务id */
    private String jobId;
 
    /** 任务名称 */
    private String jobName;
 
    /** 任务分组 */
    private String jobGroup;
 
    /** 任务状态 0禁用 1启用 2删除*/
    private String jobStatus;
 
    /** 任务运行时间表达式 */
    private String cronExpression;
 
    /** 任务描述 */
    private String desc;

	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 String getJobStatus() {
		return jobStatus;
	}

	public void setJobStatus(String jobStatus) {
		this.jobStatus = jobStatus;
	}

	public String getCronExpression() {
		return cronExpression;
	}

	public void setCronExpression(String cronExpression) {
		this.cronExpression = cronExpression;
	}

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}
 
}

注意引入的jar包不能缺少：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import com.sys.dto.ScheduleJob;

public class QuartzJobFactory implements Job {
	 public void execute(JobExecutionContext context) throws JobExecutionException {
         System.out.println("任务成功运行");
         ScheduleJob scheduleJob = (ScheduleJob)context.getMergedJobDataMap().get("scheduleJob");
         System.out.println("任务名称 = [" + scheduleJob.getJobName() + "]");
         System.out.println("任务状态 = [" + scheduleJob.getJobStatus() + "]");
         //根据name 与 group组成的唯一标识来判别该执行何种操作……
    }
}

通过工厂类实现不同的job，这是动态调度的核心思想，如果这里都不能理解，建议再看看上门我提到的相关帖子，讲的很详细。

有了Job工厂之后，我们需要一个实现动态调度的控制器：

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.sys.job.impl.QuartzJobFactory;
import com.sys.dto.ScheduleJob;
@Controller
@RequestMapping("/quartz")
public class QuartzController {
	@Autowired
	private SchedulerFactoryBean schedulerFactoryBean;
	/**
	 * 任务创建与更新(未存在的就创建，已存在的则更新)
	 * @param request
	 * @param response
	 * @param scheduleJob
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/update", method={RequestMethod.POST,RequestMethod.GET})
	public String updateQuartz(HttpServletRequest request,HttpServletResponse response,
	        @ModelAttribute("scheduleJob") ScheduleJob job,ModelMap model){
	    try {
	        Scheduler scheduler = schedulerFactoryBean.getScheduler();
	        if(null!=job){
	            //获取触发器标识
	            TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
	            //获取触发器trigger
	            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
	            if(null==trigger){//不存在任务
	                //创建任务
	                JobDetail jobDetail = JobBuilder.newJob(QuartzJobFactory.class)
	                        .withIdentity(job.getJobName(), job.getJobGroup())
	                        .build();
	                 
	                jobDetail.getJobDataMap().put("scheduleJob", job);
	                 
	                //表达式调度构建器
	                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
	                        .getCronExpression());
	                 
	                //按新的cronExpression表达式构建一个新的trigger
	                trigger = TriggerBuilder.newTrigger()
	                        .withIdentity(job.getJobName(), job.getJobGroup())
	                        .withSchedule(scheduleBuilder)
	                        .build();
	                 
	                scheduler.scheduleJob(jobDetail, trigger);
	                 
	                //把任务插入数据库
	                int result = 1;//quartzBS.add(job);
	                if(result!=0){
	                    model.addAttribute("msg", "您的任务创建成功！");
	                }else{
	                    model.addAttribute("msg", "您的任务创建失败！");
	                }
	            }else{//存在任务
	                 
	                // Trigger已存在，那么更新相应的定时设置
	                //表达式调度构建器
	                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job
	                        .getCronExpression());
	                 
	                //按新的cronExpression表达式重新构建trigger
	                trigger = trigger.getTriggerBuilder()
	                        .withIdentity(triggerKey)
	                        .withSchedule(scheduleBuilder)
	                        .build();
	                 
	                //按新的trigger重新设置job执行
	                scheduler.rescheduleJob(triggerKey, trigger);
	                 
	                //更新数据库中的任务
	                int result = 1;//quartzBS.update(job);
	                if(result==1){
	                    model.addAttribute("msg", "您的任务更新成功！");
	                }else{
	                    model.addAttribute("msg", "您的任务更新失败！");
	                }
	            }
	             
	        }
	    } catch (SchedulerException e) {
	        e.printStackTrace();
	    }
	    return "/blank";
	}
	 
	/**
	 * 暂停任务
	 * @param request
	 * @param response
	 * @param job
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/pause", method={RequestMethod.POST,RequestMethod.GET})
	public String pauseQuartz(HttpServletRequest request,HttpServletResponse response,
	        @ModelAttribute("scheduleJob") ScheduleJob scheduleJob,ModelMap model){
	 
	        Scheduler scheduler = schedulerFactoryBean.getScheduler();
	        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
	        try {
	            scheduler.pauseJob(jobKey);
	        } catch (SchedulerException e) {
	            e.printStackTrace();
	        }
	 
	        return "/warn.jsp";
	}
	/**
	 * 恢复任务
	 * @param request
	 * @param response
	 * @param scheduleJob
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/resume", method={RequestMethod.POST,RequestMethod.GET})
	public String resumeQuartz(HttpServletRequest request,HttpServletResponse response,
	        @ModelAttribute("scheduleJob") ScheduleJob scheduleJob,ModelMap model){
	 
	        Scheduler scheduler = schedulerFactoryBean.getScheduler();
	        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
	        try {
	            scheduler.resumeJob(jobKey);
	        } catch (SchedulerException e) {
	            e.printStackTrace();
	        }
	 
	        return "/warn.jsp";
	}
	/**
	 * 删除任务
	 * @param request
	 * @param response
	 * @param scheduleJob
	 * @param model
	 * @return
	 */
	@RequestMapping(value="/delete", method={RequestMethod.POST,RequestMethod.GET})
	public String deleteQuartz(HttpServletRequest request,HttpServletResponse response,
	        @ModelAttribute("scheduleJob") ScheduleJob scheduleJob,ModelMap model){
	 
	        Scheduler scheduler = schedulerFactoryBean.getScheduler();
	        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
	        try {
	            scheduler.deleteJob(jobKey);
	        } catch (SchedulerException e) {
	            e.printStackTrace();
	        }
	        return "/warn.jsp";
	}
	public static void main(String[] args) {
			System.out.println("QuartzAction");
		}
	}

然后我们通过前台的jsp来控制创建调度：

<form method="post" action="quartz/update.do" name="scheduleJob">
		<input name="jobName" value="job1"/>
		<input name="jobId" value="0"/>
		<input name="cronExpression" value="0/1 * * * * ?"/>
		<input type="submit">提交</input>
	</form>

通过表单将参数映射到scheduleJob，然后传给工厂类，创造出对应的任务调度。

具体复杂的过程就在控制器里面对job的各种状态处理，理解了整个思想，实现起来就基本没有什么问题。