quartz任务调度整合springMVC学习二

之前写了quartz整合spring的使用的静态调用，但实际工作中可能会需要用到动态的任务调度，不是写死在spring里面，而是可以由管理员配置怎么执行，这里就需要将quartz中trigger 和 job的信息存入数据库持久化，不过在整合springmvc前，我觉得先熟悉quartz的单独使用会更有助于学习，以下以query2.2.2为例，做了一些测试。
1、首先是创建任务调度工厂：

//创建调度器工厂
SchedulerFactory schedulerFactory=new StdSchedulerFactory();

2、从调度器工厂中获取调度器

//从调度工厂中获取调度器
Scheduler scheduler=schedulerFactory.getScheduler();

3、建立工作，两种写法:一种是JobDetailImpl直接实例化一个调用器，参数依次为名称，组，调用方法所在的类(需要实现Job接口),第二种是用JobDetail接口去创建。

//创建一个工作，指向执行的类，这里有必要说明一下，quartz在2.0以后将JobDetail改成了接口,我之前测试的时候直接用JobDetail去建实例一直报错,原因就是用了2.0以后的包
//JobDetailImpl job=new JobDetailImpl("jobName","jobGroup",SimpleJob.class);
JobDetail job=JobBuilder.newJob(SimpleJob.class).withIdentity("jobName","jobGroup").build();
//这样建立的工作只会去调用类里面默认的execute方法,如果想要动态的去调用，可以通过JobDataMap去传一些参数，JobDataMap跟map用法差不多，把想传的参数put进去就行，我在SimpleJob类里面写了一个反射，动态的去调用方法，当然也可以用if else的形式选择去执行那个方法，放射的写法如下：
String str=Job.getJobDetail().getJobDataMap().getString("method");
this.getClass().getMethod(str).invoke(null,null);
//SimpleJob.class.getMethod(str).invoke(null,null);都一样

4、创建触发器，分为简单的触发器和定时的触发器，同样各有两种写法

简单触发器一：
//SimpleTriggerImpl simpleTrigger=new SimpleTriggerImpl("spt");
//simpleTrigger.setStartTime(new Date());
//simpleTrigger.setRepeatInterval(6000);
//simpleTrigger.setRepeatCount(5);
简单触发器二：
Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup") .withSchedule(
SimpleScheduleBuilder.repeatSecondlyForever()).startAt(new Date()).build(）;                    // 执行规则此处为每秒重复永久执行        执行时间(startAt可自定义启动时间)
定时触发器一：
//CronTriggerImpl cronTriggerImpl=new CronTriggerImpl("crt1");
//cronTriggerImpl.setStartTime(new Date());
//cronTriggerImpl.setCronExpression("0/10 * * * * ? ");
定时触发器二：
Trigger trigger=TriggerBuilder.newTrigger().withIdentity("simpleTrigger", "triggerGroup").withSchedule(
CronScheduleBuilder.cronSchedule("0 42 10 * * ? *")).startNow().build();
//执行规则 表达式参照一里面的规则            执行时间(startNow为立即启动)
//关于这边的执行规则的方法可以网上找一个quartz的说明文档

5、将工作与触发器放入调度器

//有多个工作，可以添加多个进去
scheduler.scheduleJob(job, trigger);
//scheduler.scheduleJob(job2, trigger2);添加工作

//创建key JobKey key=new JobKey("jobName","jobGroup");

//scheduler.deleteJob(key);删除任务
//scheduler.pauseJob(key);暂停任务
//开始执行
scheduler.start();

然后在贴上一个写好的util类

public class JobUtil {
private final static Logger logger = LogManager.getLogger();
/**
* 获取JobKey
* @param job
* @return
*/
public static JobKey getJobKey(QuartzJob job){
return JobKey.jobKey(job.getJobName(), job.getJobGroup());
}
/**
* 获取TriggerKey
* @param job
* @return
*/
public static TriggerKey getTriggerKey(QuartzJob job){
return TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
}
/**
* 获取CronTrigger
* @param scheduler
* @param job
* @return
*/
public static CronTrigger getCronTrigger(Scheduler scheduler, QuartzJob job){
try {
TriggerKey triggerKey = getTriggerKey(job);
return (CronTrigger) scheduler.getTrigger(triggerKey);
} catch (SchedulerException e) {
logger.error(e);
}
return null;
}
/**
* 新增Job
* @param scheduler
* @param job
* @throws ClassNotFoundException
*/
public static void insertJob(Scheduler scheduler, QuartzJob quartzJob) throws ClassNotFoundException{
String jobName = quartzJob.getJobName();
String jogGroup = quartzJob.getJobGroup();
String cronExpression = quartzJob.getCronExpression();
Class _class = Class.forName(quartzJob.getJobClassName());
//构建任务
JobDetail jobDetail = JobBuilder.newJob(_class).withIdentity(jobName, jogGroup).build();
//放入参数，在运行时获取
jobDetail.getJobDataMap().put(Cast.job_params, quartzJob);
//构建调度表达式
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
//构建trigger
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, jogGroup)
.withSchedule(cronScheduleBuilder).build();
try {
//构建job
scheduler.scheduleJob(jobDetail, cronTrigger);
} catch (SchedulerException e) {
//日志记录
logger.error(e);
}
}
/**
* 运行一次
* @param scheduler
* @param job
* @throws SchedulerException
*/
public static void runJob(Scheduler scheduler, QuartzJob job) throws SchedulerException{
JobKey jobKey = getJobKey(job);
scheduler.triggerJob(jobKey);
}
/**
* 更新定时任务
* @param scheduler
* @param job
*/
public static void updateJob(Scheduler scheduler, QuartzJob job){
try {
TriggerKey triggerKey = getTriggerKey(job);
String cronExpression = job.getCronExpression();
//构建调度表达式
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//重新构建trigger
cronTrigger = cronTrigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(cronScheduleBuilder).build();
scheduler.rescheduleJob(triggerKey, cronTrigger);
} catch (SchedulerException e) {
logger.error(e);
}
}
/**
* 删除任务
* @param scheduler
* @param job
*/
public static void deleteJob(Scheduler scheduler, QuartzJob job){
try {
JobKey jobKey = getJobKey(job);
scheduler.deleteJob(jobKey);
} catch (SchedulerException e) {
logger.error(e);
}
}
/**
* 暂停任务
* @param scheduler
* @param job
*/
public static void pauseJob(Scheduler scheduler, QuartzJob job){
try {
JobKey jobKey = getJobKey(job);
scheduler.pauseJob(jobKey);
} catch (SchedulerException e) {
logger.error(e);
}
}
}

大致就这些，下次把quartz整合进springMVC在测试一下