SpringQuartz动态设置定时任务

Quartz是一个很好用的工具，我们可以用它来定时执行任务，有时，我们需要知道当前有哪些定时任务，并通过列表形式列出来，甚至可能需要动态添加、修改定时任务。

Spring如何配置定时任务，这里不在赘述，本文仅通过Spring提供的API，实现对定时任务的动态操作。

获取当前所有定时任务

	/**
	 * 当前任务列表
	 */
	public List getTaskList() throws Exception{
		
		List<QuartzTask> list = new ArrayList<QuartzTask>();
		try {
            //CrawlerRun是项目里的一个类，定时任务通过Java代码方式设置，而非xml配置
            //scheduler可以通过SchedulerFactoryBean获取
			Scheduler scheduler = CrawlerRun.getScheduler();
			
			for (String jobGroup : scheduler.getJobGroupNames()) {
				 
				for (String jobName : scheduler.getJobNames(jobGroup)) {
			 
					  Trigger[] triggers = scheduler.getTriggersOfJob(jobName,jobGroup);
					  
					  CronTrigger trigger = (CronTrigger)triggers[0];
					  
					  String nextFireTime = new DateTool().FormatDate(trigger.getNextFireTime(),"yyyy-MM-dd HH:mm:ss");
					 
					  QuartzTask task = new QuartzTask();
					  
					  task.setJobName(jobName);
					  task.setJobGroup(jobGroup);
					  task.setDescription(scheduler.getJobDetail(jobName,jobGroup).getDescription());
					  task.setTriggerName(trigger.getName());
					  task.setTriggerGroup(trigger.getGroup());
					  task.setExpression(trigger.getCronExpression());
					  task.setTriggerState(scheduler.getTriggerState(trigger.getName(),trigger.getGroup()));
					  task.setNextFireTime(nextFireTime);
					  list.add(task);
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}
        return list;
	}

任务详情实体类

import org.quartz.Trigger;

/**
 * 定时任务
 * @author yangjl
 *
 */
public class QuartzTask {
	
	/**任务名称*/
	private String jobName;
	/**job组名*/
	private String jobGroup;
	/**job描述*/
	private String description;
	/**触发器名称*/
	private String triggerName;
	/**trigger组名**/
	private String triggerGroup;
	/**时间表达式*/
	private String expression;
	/**触发器状态*/
	private int triggerState;
	/**下次触发时间**/
	private String nextFireTime;
	/**状态*/
	private String state;
	
	
	public String getJobName() {
		return jobName;
	}
	public void setJobName(String jobName) {
		this.jobName = jobName;
	}
	public String getJobGroup() {
		return jobGroup;
	}
	public String getDescription() {
		return description;
	}
	public void setDescription(String description) {
		this.description = description;
	}
	public void setJobGroup(String jobGroup) {
		this.jobGroup = jobGroup;
	}
	public String getTriggerName() {
		return triggerName;
	}
	public void setTriggerName(String triggerName) {
		this.triggerName = triggerName;
	}
	public String getTriggerGroup() {
		return triggerGroup;
	}
	public void setTriggerGroup(String triggerGroup) {
		this.triggerGroup = triggerGroup;
	}
	public String getExpression() {
		return expression;
	}
	public void setExpression(String expression) {
		this.expression = expression;
	}
	public int getTriggerState() {
		return triggerState;
	}
	public void setTriggerState(int triggerState) {
		this.triggerState = triggerState;
	}
	public void setState(String state) {
		this.state = state;
	}
	public String getNextFireTime() {
		return nextFireTime;
	}
	public void setNextFireTime(String nextFireTime) {
		this.nextFireTime = nextFireTime;
	}
	public String getState() {
		if(triggerState == Trigger.STATE_NORMAL){
			state = "正常";
		} else if(triggerState == Trigger.STATE_PAUSED){
			state = "暂停";
		} else if(triggerState == Trigger.STATE_COMPLETE){
			state = "完成";
		} else if(triggerState == Trigger.STATE_ERROR){
			state = "异常";
		} else if(triggerState == Trigger.STATE_BLOCKED){
			state = "阻塞";
		} else if(triggerState == Trigger.STATE_NONE){
			state = "不存在";
		}
		return state;
	}
}

对定时任务的动态操作

package com.util;

import java.util.Date;

import org.json.simple.JSONObject;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;

import com.job36.util.DateTool;

/**
 * Quartz调度管理器
 */
public class QuartzTaskManager {
	
	private static QuartzTaskManager instance = new QuartzTaskManager();

	public static QuartzTaskManager getInstance() {
		return instance;
	}

	private QuartzTaskManager() {

	}
	
    /**
     * @Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
     * @param sched 调度器
     * @param jobName 任务名
     * @param cls 任务
     * @param time 时间设置，参考quartz说明文档
     * @Title: QuartzTaskManager.java
     */
    public static void addJob(Scheduler sched, String jobName,String description,@SuppressWarnings("rawtypes") Class cls, String time) {
        try {
            JobDetail jobDetail = new JobDetail(jobName,QuartzConst.JOB_GROUP_NAME, cls);// 任务名，任务组，任务执行类
            jobDetail.setDescription(description);
            // 触发器
            CronTrigger trigger = new CronTrigger(jobName,QuartzConst.TRIGGER_GROUP_NAME);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail,trigger);
            // 启动
            if (sched.isShutdown()) {
                sched.start();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 添加一个定时任务
     * @param sched 调度器
     * @param jobName 任务名
     * @param jobGroupName 任务组名
     * @param triggerName 触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass 任务
     * @param time 时间设置，参考quartz说明文档
     * @Title: QuartzTaskManager.java
     */
    public static void addJob(Scheduler sched, String jobName, String jobGroupName, String triggerName, String triggerGroupName, @SuppressWarnings("rawtypes") Class jobClass, String time) {
        try {
            JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名，任务组，任务执行类
            // 触发器
            CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组
            trigger.setCronExpression(time);// 触发器时间设定
            sched.scheduleJob(jobDetail,trigger);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
     * @param sched 调度器
     * @param jobName
     * @param time
     * @Title: QuartzTaskManager.java
     */
    @SuppressWarnings("rawtypes")
    public static void modifyJobTime(Scheduler sched, String jobName, String time) {
        try {
        	Trigger[] triggers = sched.getTriggersOfJob(jobName,QuartzConst.JOB_GROUP_NAME);
            CronTrigger trigger = (CronTrigger)triggers[0];
            if (trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(time)) {
                JobDetail jobDetail = sched.getJobDetail(jobName,QuartzConst.JOB_GROUP_NAME);
                Class objJobClass = jobDetail.getJobClass();
                removeJob(sched,jobName);
                addJob(sched,jobName,jobDetail.getDescription(),objJobClass,time);
                
                JSONObject json = new JSONObject();
                json.put("opreation","修改定时任务");
                json.put("currTime",new DateTool().FormatDate(new Date(),QuartzConst.DATE_FORMAT_TYPE));
                json.put("jobDescription",jobDetail.getDescription());
                json.put("oldTime",oldTime);
                json.put("newTime",time);
                System.out.println(json.toJSONString());
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 修改一个任务的触发时间
     * @param sched 调度器
     * @param triggerName
     * @param triggerGroupName
     * @param time
     * @Title: QuartzTaskManager.java
     */
    public static void modifyJobTime(Scheduler sched, String triggerName, String triggerGroupName, String time) {
        try {
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName, triggerGroupName);
            if (trigger == null) {
                return;
            }
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(time)) {
                CronTrigger ct = (CronTrigger) trigger;
                // 修改时间
                ct.setCronExpression(time);
                // 重启触发器
                sched.resumeTrigger(triggerName, triggerGroupName);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     * @param sched 调度器
     * @param jobName
     * @Title: QuartzTaskManager.java
     */
    public static void removeJob(Scheduler sched, String jobName) {
        try {
        	Trigger[] triggers = sched.getTriggersOfJob(jobName,QuartzConst.JOB_GROUP_NAME);
            CronTrigger trigger = (CronTrigger)triggers[0];
            sched.pauseTrigger(trigger.getName(), QuartzConst.TRIGGER_GROUP_NAME);// 停止触发器
            sched.unscheduleJob(jobName, QuartzConst.TRIGGER_GROUP_NAME);// 移除触发器
            sched.deleteJob(jobName, QuartzConst.JOB_GROUP_NAME);// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 移除一个任务
     * @param sched 调度器
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * @Title: QuartzTaskManager.java
     */
    public static void removeJob(Scheduler sched, String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        try {
            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器
            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器
            sched.deleteJob(jobName, jobGroupName);// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    /**
     * 执行任务
     * @param sched
     * @param jobName
     * @param time
     * @throws SchedulerException 
     */
    public static void triggerJob(Scheduler sched, String jobName) throws SchedulerException {
		sched.triggerJob(jobName,QuartzConst.JOB_GROUP_NAME);
		JobDetail jobDetail = sched.getJobDetail(jobName,QuartzConst.JOB_GROUP_NAME);
        
        JSONObject json = new JSONObject();
        json.put("opreation","执行定时任务");
        json.put("currTime",new DateTool().FormatDate(new Date(),QuartzConst.DATE_FORMAT_TYPE));
        json.put("jobDescription",jobDetail.getDescription());
        System.out.println(json.toJSONString());
    }

    /**
     * @Description:启动所有定时任务
     * @param sched调度器
     * @Title: QuartzTaskManager.java
     */
    public static void startJobs(Scheduler sched) {
        try {
            sched.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:关闭所有定时任务
     * @param sched 调度器
     * @Title: QuartzTaskManager.java
     */
    public static void shutdownJobs(Scheduler sched) {
        try {
            if (!sched.isShutdown()) {
                sched.shutdown();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
}