定时器 quartz 动态时间设置

第一，定义一个任务封装类 

package dynamicSetQuartz;

 

/**

 * 任务封装类

 * @author hwt

 *

 */

public class CustomJob {

public static final int JOB_ENABLED = 0; // 任务启用状态

public static final int JOB_DISABLED = 1; // 任务禁用状态

public static final int JOB_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.jobId+"Trigger";

}

/**

 * setter，getter方法

 * @return

 */

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;

}

}

 

 

二，然后在定义一个任务管理器类，里面包括有增，删，查，改

package dynamicSetQuartz;

 

import java.text.ParseException;

 

import org.quartz.CronTrigger;

import org.quartz.JobDataMap;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.Trigger;

import org.quartz.impl.StdScheduler;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

 

/**

 * 定时管理类

 * 包括 启用一个定时器，禁用一个定时器，得到定时器和任务详情

 * @author hwt

 *

 */

public class QuartzManager {

private static Scheduler scheduler;

static{

//得到scheduler对象

ApplicationContext context = new ClassPathXmlApplicationContext(

"applicationContext.xml");

scheduler = (StdScheduler) context.getBean("schedulerFactory");

}

/**

 * 启动一个trigger

 * @param job   任务封装对象

 * @param paramsMap  参数

 * @param isStateFull  是否是一个同步定时任务，true：同步，false：异步

 * @return

 */

public static boolean enableCronScheduler(CustomJob job,JobDataMap paramsMap,boolean isStateFull) {

if (job == null) {

return false;

}else {

try {

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(job.getTriggerName(), job.getJobGroup());

if (trigger == null) { //如果没有对应的trigger

JobDetail jobDetail = null;

if (isStateFull) {//任务同步执行

jobDetail = new JobDetail(job.getJobId(), job.getJobGroup(), job.getStateFulljobExecuteClass());

}else {//任务异步执行

jobDetail = new JobDetail(job.getJobId(), job.getJobGroup(), job.getJobExecuteClass());

}

jobDetail.setJobDataMap(paramsMap);//设置传入参数

//注意：得到trigger或者创建trigger时，是使用的任务封装类中的 jobID+"Trigger"

trigger = new CronTrigger(job.getTriggerName(), job.getJobGroup(),job.getCronExpression());

scheduler.scheduleJob(jobDetail, trigger); //启用用个trigger

}else {//如果存在对应的trigger

trigger.setCronExpression(job.getCronExpression());//修改时间规则

scheduler.rescheduleJob(job.getTriggerName(), job.getJobGroup(), trigger);//重新触发

}

return true;

} catch (SchedulerException e) {

e.printStackTrace();

return false;

} catch (ParseException e) {

e.printStackTrace();

return false;

}

}

}

/**

 * 改变job的定时时间

 * @param jobId

 * @param groupId

 * @param newCron

 * @return

 */

public static boolean changeJobCron(String jobId,String groupId,String newCron) {

if ("".equals(jobId) || "".equals(groupId) || jobId == null

|| groupId == null || newCron == null || "".equals(newCron)) {

return false;

}else {

try {

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(jobId+"Trigger", groupId);

if (trigger == null) { //如果没有对应的trigger

return false;

}else {//如果存在对应的trigger

trigger.setCronExpression(newCron);//修改时间规则

scheduler.rescheduleJob(jobId+"Trigger", groupId, trigger);//重新触发

return true;

}

} catch (SchedulerException e) {

e.printStackTrace();

return false;

} catch (ParseException e) {

e.printStackTrace();

return false;

}

}

}

/**

 * 得到job对应的Trigger，trigger的ID是 JObID+"Trigger"

 * @param jobId  任务ID

 * @param groupId  组ID

 * @return

 */

public static Trigger getJobTrigger(String jobId,String groupId){

if ("".equals(jobId) || "".equals(groupId) || jobId == null

|| groupId == null) {

return null;

}else {

try {

return scheduler.getTrigger(jobId+"Trigger", groupId);

} catch (SchedulerException e) {

e.printStackTrace();

return null;

}

}

}

/**

 * 得到jobDetail

 * @param jobId

 * @param groupId

 * @return

 */

public static JobDetail getJobDetail(String jobId,String groupId){

if ("".equals(jobId) || "".equals(groupId) || jobId == null

|| groupId == null) {

return null;

}else {

try {

return scheduler.getJobDetail(jobId, groupId);

} catch (SchedulerException e) {

e.printStackTrace();

return null;

}

}

}

/**

 * 禁用job

 * @param jobId

 * @param groupId

 * @return

 */

public static boolean disableScheduler(String jobId,String groupId){

if ("".equals(jobId) || "".equals(groupId) || jobId == null

|| groupId == null) {

return false;

}else {

//得到对应的trigger

Trigger trigger = getJobTrigger(jobId, groupId);

if (trigger != null) { //如果存在，删除对应的job任务

try {

scheduler.deleteJob(jobId, groupId);

return true;

} catch (SchedulerException e) {

e.printStackTrace();

return false;

}

}else {

return false;

}

}

}

}

 

三，测试任务类

package test;

 

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob;

 

import dynamicSetQuartz.QuartzManager;

 

/**

 * 任务类

 * @author hwt

 *

 */

public class JobOne extends StatefulMethodInvokingJob {

private static int i = 0;

private int j = 0; /*说明每次执行都是new了一个新的执行类，具有线程安全性*/

/**

 * 此处编写需要执行的任务内容

 * 通过context.getJobDataMap().get("id名字");得到传入的参数

 */

@Override

protected void executeInternal(JobExecutionContext context)

throws JobExecutionException {

i++;

j++; 

System.out.println("j====>" + j);/*说明每次执行都是new了一个新的执行类，具有线程安全性*/

System.out.println("这是我得第" + i + "次执行");

System.out.println("my name is QuartzJobOne");

System.out.println(context.getJobDetail().getJobDataMap().get("p2"));/*得到传入的数据*/

if(i == 3){

System.out.println("我只执行三次.....");

QuartzManager.disableScheduler("job1","job1_group");

}

}

}

 

4，测试类

public class Test {

public static void main(String[] args) {

CustomJob job = new CustomJob();

job.setJobId("job1");

job.setJobGroup("job1_group");

job.setJobName("第一个测试定时器");

job.setMemos("我是第一个测试定时器的描述");

job.setCronExpression("0/5 * * * * ?");//每五秒执行一次

job.setJobExecuteClass(JobOne.class);

JobDataMap paramsMap = new JobDataMap();

ArrayList<String> paramList = new ArrayList<String>();

paramList.add("one");

paramList.add("two");

paramList.add("three");

paramsMap.put("p1","p1");

paramsMap.put("p2",paramList);//传入的参数\

//启用scheduler

QuartzManager.enableCronScheduler(job, paramsMap, false);

}

}