爱威尔-spring4.x+quartz2定时任务动态添加（已开源）

spring配置文件：


	 


	只需要这一句话


	spring运行时加载：


	 

<pre class="prettyprint lang-java">package com.lauvan.scheduler.controller;

import javax.annotation.PostConstruct;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.lauvan.scheduler.service.ScheduleJobService;

/**
 * 定时任务初始化
 */
@Component
public class ScheduleJobInit {

/** 定时任务service */
    @Autowired
    private ScheduleJobService  scheduleJobService;

/**
     * 项目启动时初始化
     */
    @PostConstruct
    public void init() {
        scheduleJobService.init();
    }

}
</pre>
service的实现：

	 


	 

<pre class="prettyprint lang-java">package com.lauvan.scheduler.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.lauvan.base.dao.BaseDAOSupport;
import com.lauvan.scheduler.entity.ScheduleJob;
import com.lauvan.scheduler.service.ScheduleJobService;
import com.lauvan.scheduler.vo.ScheduleJobVo;
import com.lauvan.util.ScheduleUtils;
import com.lauvan.util.ValidateUtil;

@Service("scheduleJobService")
public class ScheduleJobServiceImpl extends BaseDAOSupportimplements ScheduleJobService {
	@Autowired
	private Scheduler scheduler;

public void init() {
		ListscheduleJobs = getListEntitys();
		for (ScheduleJob scheduleJob : scheduleJobs) {
			CronTrigger cronTrigger;
			try {
				cronTrigger = ScheduleUtils.getCronTrigger(scheduler,
						scheduleJob.getSch_name(), scheduleJob.getSch_group());
				if (cronTrigger!=null) {
					ScheduleUtils.deleteScheduleJob(scheduler, scheduleJob.getSch_name(), scheduleJob.getSch_group());
				}
				
				if (scheduleJob.getSch_isSync()) {
					if (ValidateUtil.isEmpty(scheduleJob.getSch_classnamesync())) {
						continue;
					}
				}else {
					if (ValidateUtil.isEmpty(scheduleJob.getSch_classname())) {
						continue;
					}
				}
				
				ScheduleUtils.createScheduleJob(scheduler, scheduleJob);
				/*// 不存在，创建一个
				if (cronTrigger == null) {
					
				} else {
					// 已存在，那么更新相应的定时设置
					ScheduleUtils.updateScheduleJob(scheduler, scheduleJob);
				}*/
			} catch (SchedulerException e) {
				e.printStackTrace();
			}
		}
	}

public ListqueryExecutingJobList() {
		try {
			ListexecutingJobs = executingJobs = scheduler.getCurrentlyExecutingJobs();;
			/*while (true) {
				executingJobs = scheduler.getCurrentlyExecutingJobs();
				if (executingJobs.size()>0) {
					break;
				}
			}*/
			
			ListjobList = new ArrayList(
					executingJobs.size());
			for (JobExecutionContext executingJob : executingJobs) {
				ScheduleJobVo job = new ScheduleJobVo();
				JobDetail jobDetail = executingJob.getJobDetail();
				JobKey jobKey = jobDetail.getKey();
				Trigger trigger = executingJob.getTrigger();
				job.setSch_name(jobKey.getName());
				job.setSch_group(jobKey.getGroup());
				job.setSch_jobTrigger(trigger.getKey().getName());
				Trigger.TriggerState triggerState = scheduler
						.getTriggerState(trigger.getKey());
				job.setSch_status(triggerState.name());
				if (trigger instanceof CronTrigger) {
					CronTrigger cronTrigger = (CronTrigger) trigger;
					String cronExpression = cronTrigger.getCronExpression();
					job.setSch_cronExpression(cronExpression);
				}
				jobList.add(job);
			}
			return jobList;
		} catch (SchedulerException e) {
			e.printStackTrace();
			return null;
		}

}
}
</pre>
实体类：

	 


	 

<pre class="prettyprint lang-java">package com.lauvan.scheduler.entity;

import java.io.Serializable;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;

@Entity
@Table(name = "s_scheduleJob")
@DynamicInsert(true)
@DynamicUpdate(true)
public class ScheduleJob implements Serializable {

private static final long serialVersionUID = -4002861187039384373L;

/** 任务id */
	private Integer sch_id;

/** 任务名称 */
	private String sch_name;

/** 任务别名 */
	private String sch_aliasName;

/** 任务分组 */
	private String sch_group;

/** 触发器 */
	private String sch_jobTrigger;

/** 任务状态 */
	private String sch_status;

/** 任务运行时间表达式 */
	private String sch_cronExpression;

/** 是否异步 */
	private Boolean sch_isSync;

/** 任务描述 */
	private String sch_description;

/** 创建时间 */
	private Date sch_create;

/** 修改时间 */
	private Date sch_modify;
	/**
	 * 要执行的任务类
	 */
	private String sch_classname;
	private String sch_classnamesync;

@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public Integer getSch_id() {
		return sch_id;
	}

public void setSch_id(Integer sch_id) {
		this.sch_id = sch_id;
	}
	@Column(length = 100)
	public String getSch_name() {
		return sch_name;
	}

public void setSch_name(String sch_name) {
		this.sch_name = sch_name;
	}
	@Column(length = 50)
	public String getSch_aliasName() {
		return sch_aliasName;
	}

public void setSch_aliasName(String sch_aliasName) {
		this.sch_aliasName = sch_aliasName;
	}
	@Column(length = 50)
	public String getSch_group() {
		return sch_group;
	}

public void setSch_group(String sch_group) {
		this.sch_group = sch_group;
	}
	@Column(length = 100)
	public String getSch_jobTrigger() {
		return sch_jobTrigger;
	}

public void setSch_jobTrigger(String sch_jobTrigger) {
		this.sch_jobTrigger = sch_jobTrigger;
	}
	@Column(length = 1)
	public String getSch_status() {
		return sch_status;
	}

public void setSch_status(String sch_status) {
		this.sch_status = sch_status;
	}
	@Column(length = 100)
	public String getSch_cronExpression() {
		return sch_cronExpression;
	}

public void setSch_cronExpression(String sch_cronExpression) {
		this.sch_cronExpression = sch_cronExpression;
	}

public Boolean getSch_isSync() {
		return sch_isSync;
	}

public void setSch_isSync(Boolean sch_isSync) {
		this.sch_isSync = sch_isSync;
	}
	@Column(length = 500)
	public String getSch_description() {
		return sch_description;
	}

public void setSch_description(String sch_description) {
		this.sch_description = sch_description;
	}

public Date getSch_create() {
		return sch_create;
	}

public void setSch_create(Date sch_create) {
		this.sch_create = sch_create;
	}

public Date getSch_modify() {
		return sch_modify;
	}

public void setSch_modify(Date sch_modify) {
		this.sch_modify = sch_modify;
	}

@Column(length=100)
	public String getSch_classname() {
		return sch_classname;
	}

public void setSch_classname(String sch_classname) {
		this.sch_classname = sch_classname;
	}
	@Column(length=100)
	public String getSch_classnamesync() {
		return sch_classnamesync;
	}

public void setSch_classnamesync(String sch_classnamesync) {
		this.sch_classnamesync = sch_classnamesync;
	}
	
}
</pre>
controller类：

	 


	 

<pre class="prettyprint lang-java">package com.lauvan.scheduler.controller;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.lauvan.base.controller.BaseController;
import com.lauvan.base.vo.PageView;
import com.lauvan.scheduler.entity.ScheduleJob;
import com.lauvan.scheduler.service.ScheduleJobService;
import com.lauvan.scheduler.vo.ScheduleJobVo;
import com.lauvan.util.Json;
import com.lauvan.util.ValidateUtil;
@Controller
@RequestMapping("system/scheduleJob")
public class ScheduleJobController extends BaseController {

@Autowired
	private ScheduleJobService scheduleJobService;
	
	@RequestMapping("/list")
	public String list(Integer page, String query, Model model) {
		model.addAttribute("page", page);
		model.addAttribute("query", query);
		PageViewpageView = new PageView(8, page == null || page < 1 ? 1 : page); if("true".equals(query)) { StringBuffer jpql = new StringBuffer(""); Listparams = new ArrayList();
			pageView.setQueryResult(scheduleJobService.getScrollList(pageView.getFirstResult(), pageView.getMaxresult(), jpql.toString(), params.toArray()));
		} else {
			pageView.setQueryResult(scheduleJobService.getScrollList(pageView.getFirstResult(), pageView.getMaxresult()));
		}
		model.addAttribute("pageView", pageView);
		model.addAttribute("executingJobs", scheduleJobService.queryExecutingJobList());
		return "jsp/system/scheduleJob/scheduleJob_list";
	}
	@RequestMapping("/initjob")
	@ResponseBody
	public Json initjob() {
		scheduleJobService.init();
		return json("初始化成功");
	}
	
	@RequestMapping("/add")
	@ResponseBody
	public Json add(ScheduleJobVo scheduleJobVo) {
		ScheduleJob scheduleJob = new ScheduleJob();
		BeanUtils.copyProperties(scheduleJobVo, scheduleJob);
		scheduleJob.setSch_create(new Date());
		try {
			scheduleJobService.save(scheduleJob);
			return json(true, "定时任务添加成功");
		} catch (Exception e) {
			e.printStackTrace();
			return json("定时任务添加失败");
		}
	}
	@RequestMapping("/editip")
	public String editip(Integer id,Model model) {
		model.addAttribute("scheduleJob", scheduleJobService.find(id));
		return "jsp/system/scheduleJob/scheduleJob_edit";
	}
	@RequestMapping("/edit")
	@ResponseBody
	public Json edit(ScheduleJobVo scheduleJobVo) {
		if (ValidateUtil.isEmpty(scheduleJobVo.getSch_id())) {
			return json("定时任务ID没有获取到");
		}
		ScheduleJob scheduleJob = scheduleJobService.find(scheduleJobVo.getSch_id());
		BeanUtils.copyProperties(scheduleJobVo, scheduleJob);
		try {
			scheduleJobService.update(scheduleJob);
			return json(true, "定时任务修改成功");
		} catch (Exception e) {
			e.printStackTrace();
			return json("定时任务修改失败");
		}
	}
}
</pre>
任务类 同步和异步的：

	 


	 

<pre class="prettyprint lang-java">package com.lauvan.scheduler.factory;

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

import com.lauvan.scheduler.entity.ScheduleJob;

/**
 * 任务工厂类,非同步
 */
@DisallowConcurrentExecution
public class JobFactory implements Job {

public void execute(JobExecutionContext context) throws JobExecutionException {

ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("jobParam");

System.out.println("jobName:" + scheduleJob.getSch_name() + "  " + scheduleJob);

}
}
</pre>
<pre class="prettyprint lang-java">package com.lauvan.scheduler.factory;

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

import com.lauvan.scheduler.entity.ScheduleJob;

/**
 * 同步的任务工厂类
 */
public class JobSyncFactory implements Job {

public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

JobDataMap mergedJobDataMap = jobExecutionContext.getMergedJobDataMap();
        ScheduleJob scheduleJob = (ScheduleJob) mergedJobDataMap.get("jobParam");

System.out.println("jobName:" + scheduleJob.getSch_name() + "  " + scheduleJob);

}
}
</pre>
最重要的辅助类：

	 


	 


	 

<pre class="prettyprint lang-java">package com.lauvan.util;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
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 com.lauvan.scheduler.entity.ScheduleJob;

/**
 * 定时任务辅助类
 */
public class ScheduleUtils {

/**
     * 获取触发器key
     * 
     * @param jobName
     * @param jobGroup
     * @return
     */
    public static TriggerKey getTriggerKey(String jobName, String jobGroup) {
        return TriggerKey.triggerKey(jobName, jobGroup);
    }

/**
     * 获取表达式触发器
     *
     * @param scheduler the scheduler
     * @param jobName the job name
     * @param jobGroup the job group
     * @return cron trigger
     * @throws SchedulerException 
     */
    public static CronTrigger getCronTrigger(Scheduler scheduler, String jobName, String jobGroup) throws SchedulerException {
    	TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
        return (CronTrigger) scheduler.getTrigger(triggerKey);
    }

/**
     * 创建任务
     *
     * @param scheduler the scheduler
     * @param scheduleJob the schedule job
     * @throws SchedulerException 
     */
    public static void createScheduleJob(Scheduler scheduler, ScheduleJob scheduleJob) throws SchedulerException {
        createScheduleJob(scheduler, scheduleJob.getSch_name(), scheduleJob.getSch_group(),
            scheduleJob.getSch_cronExpression(), scheduleJob.getSch_isSync(), scheduleJob,scheduleJob.getSch_classname(),scheduleJob.getSch_classnamesync());
    }

/**
 * 创建定时任务
 * @param scheduler
 * @param jobName
 * @param jobGroup
 * @param cronExpression
 * @param isSync
 * @param param
 * @param sch_classname
 * @param sch_classnamesync
 * @throws SchedulerException
 */
 @SuppressWarnings("unchecked")
	public static void createScheduleJob(Scheduler scheduler, String jobName, String jobGroup,
 String cronExpression, boolean isSync, Object param,String sch_classname,String sch_classnamesync) throws SchedulerException {
 	Class class1 = null;
 	Class class2 = null;
 	try {
			class1 = Class.forName(sch_classname);
			class2 = Class.forName(sch_classnamesync);
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
 //同步或异步
 Class jobClass = isSync ? (Class) class2 : (Class) class1;
// Class jobClass = isSync ? JobSyncFactory.class : JobFactory.class;

//构建job信息
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();

//放入参数，运行时的方法可以获取
        jobDetail.getJobDataMap().put("jobParam", param);

//表达式调度构建器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

//按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup)
            .withSchedule(scheduleBuilder).build();

scheduler.scheduleJob(jobDetail, trigger);
    }
    
    /**
     * 运行一次任务
     * 
     * @param scheduler
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException 
     */
    public static void runOnce(Scheduler scheduler, String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.triggerJob(jobKey);
    }

/**
     * 暂停任务
     * 
     * @param scheduler
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException 
     */
    public static void pauseJob(Scheduler scheduler, String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.pauseJob(jobKey);
    }

/**
     * 恢复任务
     *
     * @param scheduler
     * @param jobName
     * @param jobGroup
     * @throws SchedulerException 
     */
    public static void resumeJob(Scheduler scheduler, String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
        scheduler.resumeJob(jobKey);
    }

/**
     * 获取jobKey
     *
     * @param jobName the job name
     * @param jobGroup the job group
     * @return the job key
     */
    public static JobKey getJobKey(String jobName, String jobGroup) {
        return JobKey.jobKey(jobName, jobGroup);
    }

/**
     * 更新定时任务
     *
     * @param scheduler the scheduler
     * @param scheduleJob the schedule job
     * @throws SchedulerException 
     */
    public static void updateScheduleJob(Scheduler scheduler, ScheduleJob scheduleJob) throws SchedulerException {
        updateScheduleJob(scheduler, scheduleJob.getSch_name(), scheduleJob.getSch_group(),
            scheduleJob.getSch_cronExpression(), scheduleJob.getSch_isSync(), scheduleJob);
    }

/**
     * 更新定时任务
     *
     * @param scheduler the scheduler
     * @param jobName the job name
     * @param jobGroup the job group
     * @param cronExpression the cron expression
     * @param isSync the is sync
     * @param param the param
     * @throws SchedulerException 
     */
    public static void updateScheduleJob(Scheduler scheduler, String jobName, String jobGroup,
                                         String cronExpression, boolean isSync, Object param) throws SchedulerException {
    	TriggerKey triggerKey = ScheduleUtils.getTriggerKey(jobName, jobGroup);

//表达式调度构建器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

//按新的cronExpression表达式重新构建trigger
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder)
            .build();

//按新的trigger重新设置job执行
        scheduler.rescheduleJob(triggerKey, trigger);
    }

/**
 * 删除定时任务
 *
 * @param scheduler
 * @param jobName
 * @param jobGroup
 * @throws SchedulerException 
 */
 public static void deleteScheduleJob(Scheduler scheduler, String jobName, String jobGroup) throws SchedulerException {
 	scheduler.deleteJob(getJobKey(jobName, jobGroup));
 }
 
}
</pre>
这里变化最大的是：

	 


	创建定时任务中：


	 


	Class class1 = null; 
 Class class2 = null; 
 try { 
 class1 = Class.forName(sch_classname); 
 class2 = Class.forName(sch_classnamesync); 
 } catch (ClassNotFoundException e) { 
 e.printStackTrace(); 
 }


	动态加载每个任务类。


	你看懂了么？好吧 看懂看不懂 都没关系，多看看。对了，可以看看之前的文件：

<h4 style="font-size:32px;font-family:'Microsoft Yahei', Tahoma, SimSun;color:#666666;">
	Spring 整合Quartz 2实现定时任务 
</h4>

	<a href="http://www.dexcoder.com/selfly/article/1822" target="_blank">http://www.dexcoder.com/selfly/article/1822</a>


	 


	开源例子：<a href="http://git.oschina.net/weir/scheduler-test-web" target="_blank">http://git.oschina.net/weir/scheduler-test-web</a>