quartz spring 实现动态定时任务

阅读更多

源码：http://chuhanzhi.com/?p=45点击最下方链接即可下载

在实际项目应用中经常会用到定时任务，可以通过quartz和spring的简单配置即可完成，但如果要改变任务的执行时间、频率，废弃任务等就需要改变配置甚至代码需要重启服务器，这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一个实现。

参考文章：http://www.meiriyouke.net/?p=82

本文章适合对quartz和spring有一定了解的读者。
spring版本为3.2  quartz版本为2.2.1  如果使用了quartz2.2.1 则spring版本需3.1以上
1.
spring中引入注册bean

Xml代码  

  1. <bean id="schedulerFactoryBean"
  2. class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />
<bean id="schedulerFactoryBean"
		class="org.springframework.scheduling.quartz.SchedulerFactoryBean" />

为什么要与spring结合？
与spring结合可以使用spring统一管理quartz中任务的生命周期，使得web容器关闭时所有的任务一同关闭。如果不用spring管理可能会出现web容器关闭而任务仍在继续运行的情况，不与spring结合的话要自己控制任务在容器关闭时一起关闭。
2.创建保存计划任务信息的实体类

Java代码  

  1. /**
  2. *
  3. * @Description: 计划任务信息
  4. * @author snailxr
  5. * @date 2014年4月24日 下午10:49:43
  6. */
  7. public class ScheduleJob {
  8. public static final String STATUS_RUNNING = "1";
  9. public static final String STATUS_NOT_RUNNING = "0";
  10. public static final String CONCURRENT_IS = "1";
  11. public static final String CONCURRENT_NOT = "0";
  12. private Long jobId;
  13. private Date createTime;
  14. private Date updateTime;
  15. /**
  16. * 任务名称
  17. */
  18. private String jobName;
  19. /**
  20. * 任务分组
  21. */
  22. private String jobGroup;
  23. /**
  24. * 任务状态 是否启动任务
  25. */
  26. private String jobStatus;
  27. /**
  28. * cron表达式
  29. */
  30. private String cronExpression;
  31. /**
  32. * 描述
  33. */
  34. private String description;
  35. /**
  36. * 任务执行时调用哪个类的方法 包名+类名
  37. */
  38. private String beanClass;
  39. /**
  40. * 任务是否有状态
  41. */
  42. private String isConcurrent;
  43. /**
  44. * spring bean
  45. */
  46. private String springId;
  47. /**
  48. * 任务调用的方法名
  49. */
  50. private String methodName;
  51. //get  set.......
  52. }
/**
 *
* @Description: 计划任务信息
* @author snailxr
* @date 2014年4月24日 下午10:49:43
 */
public class ScheduleJob {

	public static final String STATUS_RUNNING = "1";
	public static final String STATUS_NOT_RUNNING = "0";
	public static final String CONCURRENT_IS = "1";
	public static final String CONCURRENT_NOT = "0";
	private Long jobId;

	private Date createTime;

	private Date updateTime;
	/**
	 * 任务名称
	 */
	private String jobName;
	/**
	 * 任务分组
	 */
	private String jobGroup;
	/**
	 * 任务状态 是否启动任务
	 */
	private String jobStatus;
	/**
	 * cron表达式
	 */
	private String cronExpression;
	/**
	 * 描述
	 */
	private String description;
	/**
	 * 任务执行时调用哪个类的方法 包名+类名
	 */
	private String beanClass;
	/**
	 * 任务是否有状态
	 */
	private String isConcurrent;
	/**
	 * spring bean
	 */
	private String springId;
	/**
	 * 任务调用的方法名
	 */
	private String methodName;

	//get  set.......
}

该实体类与数据库中的表对应，在数据库中存储多个计划任务。

注意：jobName 跟 groupName的组合应该是唯一的,beanClass springId至少有一个

在项目启动时运行以下代码：

Java代码  

  1. public void init() throws Exception {
  2. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  3. // 这里从数据库中获取任务信息数据
  4. List<ScheduleJob> jobList = scheduleJobMapper.getAll();
  5. for (ScheduleJob job : jobList) {
  6. addJob(job);
  7. }
  8. }
public void init() throws Exception {

		Scheduler scheduler = schedulerFactoryBean.getScheduler();

		// 这里从数据库中获取任务信息数据
		List<ScheduleJob> jobList = scheduleJobMapper.getAll();

		for (ScheduleJob job : jobList) {
			addJob(job);
		}
	}

Java代码  

  1. /**
  2. * 添加任务
  3. *
  4. * @param scheduleJob
  5. * @throws SchedulerException
  6. */
  7. public void addJob(ScheduleJob job) throws SchedulerException {
  8. if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
  9. return;
  10. }
  11. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  12. log.debug(scheduler + ".......................................................................................add");
  13. TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
  14. CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
  15. // 不存在，创建一个
  16. if (null == trigger) {
  17. Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;
  18. JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();
  19. jobDetail.getJobDataMap().put("scheduleJob", job);
  20. CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
  21. trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
  22. scheduler.scheduleJob(jobDetail, trigger);
  23. } else {
  24. // Trigger已存在，那么更新相应的定时设置
  25. CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
  26. // 按新的cronExpression表达式重新构建trigger
  27. trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  28. // 按新的trigger重新设置job执行
  29. scheduler.rescheduleJob(triggerKey, trigger);
  30. }
  31. }
/**
	 * 添加任务
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void addJob(ScheduleJob job) throws SchedulerException {
		if (job == null || !ScheduleJob.STATUS_RUNNING.equals(job.getJobStatus())) {
			return;
		}

		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		log.debug(scheduler + ".......................................................................................add");
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

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

		// 不存在，创建一个
		if (null == trigger) {
			Class clazz = ScheduleJob.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;

			JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();

			jobDetail.getJobDataMap().put("scheduleJob", job);

			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

			trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();

			scheduler.scheduleJob(jobDetail, trigger);
		} else {
			// Trigger已存在，那么更新相应的定时设置
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

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

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

看到代码第20行根据scheduleJob类中CONCURRENT_IS来判断任务是否有状态。来给出不同的Job实现类

Java代码  

  1. /**
  2. *
  3. * @Description: 若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作
  4. * @author snailxr
  5. * @date 2014年4月24日 下午5:05:47
  6. */
  7. @DisallowConcurrentExecution
  8. public class QuartzJobFactoryDisallowConcurrentExecution implements Job {
  9. public final Logger log = Logger.getLogger(this.getClass());
  10. @Override
  11. public void execute(JobExecutionContext context) throws JobExecutionException {
  12. ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
  13. TaskUtils.invokMethod(scheduleJob);
  14. }
  15. }
/**
 *
 * @Description: 若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作
 * @author snailxr
 * @date 2014年4月24日 下午5:05:47
 */
@DisallowConcurrentExecution
public class QuartzJobFactoryDisallowConcurrentExecution implements Job {
	public final Logger log = Logger.getLogger(this.getClass());

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
		TaskUtils.invokMethod(scheduleJob);

	}
}

Java代码  

  1. /**
  2. *
  3. * @Description: 计划任务执行处 无状态
  4. * @author snailxr
  5. * @date 2014年4月24日 下午5:05:47
  6. */
  7. public class QuartzJobFactory implements Job {
  8. public final Logger log = Logger.getLogger(this.getClass());
  9. @Override
  10. public void execute(JobExecutionContext context) throws JobExecutionException {
  11. ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
  12. TaskUtils.invokMethod(scheduleJob);
  13. }
  14. }
/**
 *
 * @Description: 计划任务执行处 无状态
 * @author snailxr
 * @date 2014年4月24日 下午5:05:47
 */
public class QuartzJobFactory implements Job {
	public final Logger log = Logger.getLogger(this.getClass());

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
		TaskUtils.invokMethod(scheduleJob);
	}
}

真正执行计划任务的代码就在TaskUtils.invokMethod(scheduleJob)里面

通过scheduleJob的beanClass或springId通过反射或spring来获得需要执行的类,通过methodName来确定执行哪个方法

Java代码  

  1. public class TaskUtils {
  2. public final static Logger log = Logger.getLogger(TaskUtils.class);
  3. /**
  4. * 通过反射调用scheduleJob中定义的方法
  5. *
  6. * @param scheduleJob
  7. */
  8. public static void invokMethod(ScheduleJob scheduleJob) {
  9. Object object = null;
  10. Class clazz = null;
  11. //springId不为空先按springId查找bean
  12. if (StringUtils.isNotBlank(scheduleJob.getSpringId())) {
  13. object = SpringUtils.getBean(scheduleJob.getSpringId());
  14. } else if (StringUtils.isNotBlank(scheduleJob.getBeanClass())) {
  15. try {
  16. clazz = Class.forName(scheduleJob.getBeanClass());
  17. object = clazz.newInstance();
  18. } catch (Exception e) {
  19. // TODO Auto-generated catch block
  20. e.printStackTrace();
  21. }
  22. }
  23. if (object == null) {
  24. log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，请检查是否配置正确！！！");
  25. return;
  26. }
  27. clazz = object.getClass();
  28. Method method = null;
  29. try {
  30. method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
  31. } catch (NoSuchMethodException e) {
  32. log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，方法名设置错误！！！");
  33. } catch (SecurityException e) {
  34. // TODO Auto-generated catch block
  35. e.printStackTrace();
  36. }
  37. if (method != null) {
  38. try {
  39. method.invoke(object);
  40. } catch (IllegalAccessException e) {
  41. // TODO Auto-generated catch block
  42. e.printStackTrace();
  43. } catch (IllegalArgumentException e) {
  44. // TODO Auto-generated catch block
  45. e.printStackTrace();
  46. } catch (InvocationTargetException e) {
  47. // TODO Auto-generated catch block
  48. e.printStackTrace();
  49. }
  50. }
  51. }
  52. }
public class TaskUtils {
	public final static Logger log = Logger.getLogger(TaskUtils.class);

	/**
	 * 通过反射调用scheduleJob中定义的方法
	 *
	 * @param scheduleJob
	 */
	public static void invokMethod(ScheduleJob scheduleJob) {
		Object object = null;
		Class clazz = null;
                //springId不为空先按springId查找bean
		if (StringUtils.isNotBlank(scheduleJob.getSpringId())) {
			object = SpringUtils.getBean(scheduleJob.getSpringId());
		} else if (StringUtils.isNotBlank(scheduleJob.getBeanClass())) {
			try {
				clazz = Class.forName(scheduleJob.getBeanClass());
				object = clazz.newInstance();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}

		}
		if (object == null) {
			log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，请检查是否配置正确！！！");
			return;
		}
		clazz = object.getClass();
		Method method = null;
		try {
			method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
		} catch (NoSuchMethodException e) {
			log.error("任务名称 = [" + scheduleJob.getJobName() + "]---------------未启动成功，方法名设置错误！！！");
		} catch (SecurityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		if (method != null) {
			try {
				method.invoke(object);
			} catch (IllegalAccessException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}

	}
}

对任务的暂停，删除，修改等操作

Java代码  

  1. **
  2. * 获取所有计划中的任务列表
  3. *
  4. * @return
  5. * @throws SchedulerException
  6. */
  7. public List<ScheduleJob> getAllJob() throws SchedulerException {
  8. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  9. GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
  10. Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
  11. List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
  12. for (JobKey jobKey : jobKeys) {
  13. List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
  14. for (Trigger trigger : triggers) {
  15. ScheduleJob job = new ScheduleJob();
  16. job.setJobName(jobKey.getName());
  17. job.setJobGroup(jobKey.getGroup());
  18. job.setDescription("触发器:" + trigger.getKey());
  19. Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
  20. job.setJobStatus(triggerState.name());
  21. if (trigger instanceof CronTrigger) {
  22. CronTrigger cronTrigger = (CronTrigger) trigger;
  23. String cronExpression = cronTrigger.getCronExpression();
  24. job.setCronExpression(cronExpression);
  25. }
  26. jobList.add(job);
  27. }
  28. }
  29. return jobList;
  30. }
  31. /**
  32. * 所有正在运行的job
  33. *
  34. * @return
  35. * @throws SchedulerException
  36. */
  37. public List<ScheduleJob> getRunningJob() throws SchedulerException {
  38. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  39. List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
  40. List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
  41. for (JobExecutionContext executingJob : executingJobs) {
  42. ScheduleJob job = new ScheduleJob();
  43. JobDetail jobDetail = executingJob.getJobDetail();
  44. JobKey jobKey = jobDetail.getKey();
  45. Trigger trigger = executingJob.getTrigger();
  46. job.setJobName(jobKey.getName());
  47. job.setJobGroup(jobKey.getGroup());
  48. job.setDescription("触发器:" + trigger.getKey());
  49. Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
  50. job.setJobStatus(triggerState.name());
  51. if (trigger instanceof CronTrigger) {
  52. CronTrigger cronTrigger = (CronTrigger) trigger;
  53. String cronExpression = cronTrigger.getCronExpression();
  54. job.setCronExpression(cronExpression);
  55. }
  56. jobList.add(job);
  57. }
  58. return jobList;
  59. }
  60. /**
  61. * 暂停一个job
  62. *
  63. * @param scheduleJob
  64. * @throws SchedulerException
  65. */
  66. public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
  67. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  68. JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
  69. scheduler.pauseJob(jobKey);
  70. }
  71. /**
  72. * 恢复一个job
  73. *
  74. * @param scheduleJob
  75. * @throws SchedulerException
  76. */
  77. public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
  78. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  79. JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
  80. scheduler.resumeJob(jobKey);
  81. }
  82. /**
  83. * 删除一个job
  84. *
  85. * @param scheduleJob
  86. * @throws SchedulerException
  87. */
  88. public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
  89. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  90. JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
  91. scheduler.deleteJob(jobKey);
  92. }
  93. /**
  94. * 立即执行job
  95. *
  96. * @param scheduleJob
  97. * @throws SchedulerException
  98. */
  99. public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
  100. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  101. JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
  102. scheduler.triggerJob(jobKey);
  103. }
  104. /**
  105. * 更新job时间表达式
  106. *
  107. * @param scheduleJob
  108. * @throws SchedulerException
  109. */
  110. public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
  111. Scheduler scheduler = schedulerFactoryBean.getScheduler();
  112. TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
  113. CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
  114. CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
  115. trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  116. scheduler.rescheduleJob(triggerKey, trigger);
  117. }
**
	 * 获取所有计划中的任务列表
	 *
	 * @return
	 * @throws SchedulerException
	 */
	public List<ScheduleJob> getAllJob() throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
		Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
		List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
		for (JobKey jobKey : jobKeys) {
			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
			for (Trigger trigger : triggers) {
				ScheduleJob job = new ScheduleJob();
				job.setJobName(jobKey.getName());
				job.setJobGroup(jobKey.getGroup());
				job.setDescription("触发器:" + trigger.getKey());
				Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
				job.setJobStatus(triggerState.name());
				if (trigger instanceof CronTrigger) {
					CronTrigger cronTrigger = (CronTrigger) trigger;
					String cronExpression = cronTrigger.getCronExpression();
					job.setCronExpression(cronExpression);
				}
				jobList.add(job);
			}
		}
		return jobList;
	}

	/**
	 * 所有正在运行的job
	 *
	 * @return
	 * @throws SchedulerException
	 */
	public List<ScheduleJob> getRunningJob() throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
		List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
		for (JobExecutionContext executingJob : executingJobs) {
			ScheduleJob job = new ScheduleJob();
			JobDetail jobDetail = executingJob.getJobDetail();
			JobKey jobKey = jobDetail.getKey();
			Trigger trigger = executingJob.getTrigger();
			job.setJobName(jobKey.getName());
			job.setJobGroup(jobKey.getGroup());
			job.setDescription("触发器:" + trigger.getKey());
			Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
			job.setJobStatus(triggerState.name());
			if (trigger instanceof CronTrigger) {
				CronTrigger cronTrigger = (CronTrigger) trigger;
				String cronExpression = cronTrigger.getCronExpression();
				job.setCronExpression(cronExpression);
			}
			jobList.add(job);
		}
		return jobList;
	}

	/**
	 * 暂停一个job
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
		scheduler.pauseJob(jobKey);
	}

	/**
	 * 恢复一个job
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
		scheduler.resumeJob(jobKey);
	}

	/**
	 * 删除一个job
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
		scheduler.deleteJob(jobKey);

	}

	/**
	 * 立即执行job
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
		scheduler.triggerJob(jobKey);
	}

	/**
	 * 更新job时间表达式
	 *
	 * @param scheduleJob
	 * @throws SchedulerException
	 */
	public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
		Scheduler scheduler = schedulerFactoryBean.getScheduler();

		TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());

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

		CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());

		trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

		scheduler.rescheduleJob(triggerKey, trigger);
	}

小提示

更新表达式，判断表达式是否正确可用一下代码

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("xxxxx");

抛出异常则表达式不正确

原文地址：https://www.cnblogs.com/kaschie/p/11216111.html

时间： 2024-10-10 05:18:06

quartz spring 实现动态定时任务的相关文章

spring boot 整合 quartz 集群环境 实现 动态定时任务配置【原】

最近做了一个spring boot 整合 quartz  实现 动态定时任务配置,在集群环境下运行的 任务.能够对定时任务,动态的进行增删改查,界面效果图如下: 1. 在项目中引入jar 2. 将需要的表导入数据库 官网上有不同数据库的脚本,找到对应的,导入即可 3. java 代码 将quartz 的相关配置文件,配置为暴露bean,方便后期引用. 有一处关键的地方,就是注入spring 上下文,也可以算是一个坑.如果,不注入spring 上下文,那么新添加的定时任务job,是新new 的一个

quartz+spring 实现多任务动态定时器问题

? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"   

SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）

# 一.在JAVA开发领域,目前可以通过以下几种方式进行定时任务 1.单机部署模式 Timer:jdk中自带的一个定时调度类,可以简单的实现按某一频度进行任务执行.提供的功能比较单一,无法实现复杂的调度任务. ScheduledExecutorService:也是jdk自带的一个基于线程池设计的定时任务类.其每个调度任务都会分配到线程池中的一个线程执行,所以其任务是并发执行的,互不影响. Spring Task:Spring提供的一个任务调度工具,支持注解和配置文件形式,支持Cron表达式,使用

Quartz+Spring 实现任务监控

Quartz是一个优秀的任务调度框架,完全基于Java实现,功能强大,易于集成,最近在写了一个小项目,算是对之前接触到的技术做一个总结吧,在这个项目中使用Quartz实现对任务的监控,最终实现的效果如图: 添加效果: 目前已经实现了对Quartz任务的动态添加.暂停.恢复.删除等功能,该项目中使用的是CronTrigger,CronTrigger可以配置灵活的时间规则,是和企业级的应用. JobDetail界面效果图: 对quartz的研究还在继续,项目也做了不少了,暂时真正研究Quartz应该

java spring框架的定时任务

由于测试的原因,最近有接触java spring  @Scheduled的定时任务,当时还以为配置起来表达式和crontab是完全一样的,没想到还有些许不一样. 在spring中,一个cron表达式至少有6个或者7个被空格分隔的时间元素. 如下: 举例: 0 0/5 * * * ?就是每隔5分钟触发 0 15 10 * * ?   每天上午10:15触发 ps:用法: 然后再在配置文件(如application.properties文件)中设置  即可. 而在linux contab中,是5位时

Spring实现动态数据源，支持动态加入、删除和设置权重及读写分离

当项目慢慢变大,訪问量也慢慢变大的时候.就难免的要使用多个数据源和设置读写分离了. 在开题之前先说明下,由于项目多是使用Spring,因此下面说到某些操作可能会依赖于Spring. 在我经历过的项目中,见过比較多的读写分离处理方式,主要分为两步: 1.对于开发者,要求serivce类的方法名必须遵守规范,读操作以query.get等开头,写操作以update.delete开头. 2.配置一个拦截器,根据方法名推断是读操作还是写操作,设置对应的数据源. 以上做法能实现最简单的读写分离.但对应的也会

spring 数据源动态切换 与dubbo服务

1:问题描述 项目用了spring数据源动态切换,服务用的是dubbo.在运行一段时间后程序异常,更新操作没有切换到主库上.这个问题在先调用读操作后再调用写操作会出现.经分析原因有3: 第一:当程序运行一段时间后调用duboo服务时,读操作与写操作有可能会在一个线程里,当这种情况出现时 2:数据源配置 <idclass>    <name>       <key-type>          <keyvalue-ref/>          <keyv

quartz spring配置实例代码demo下载

原文:quartz spring配置实例代码demo下载 源代码下载地址:http://www.zuidaima.com/share/1550463459560448.htm

Spring实现动态数据源，支持动态添加、删除和设置权重及读写分离

当项目慢慢变大,访问量也慢慢变大的时候,就难免的要使用多个数据源和设置读写分离了. 在开题之前先说明下,因为项目多是使用Spring,因此以下说到某些操作可能会依赖于Spring. 在我经历过的项目中,见过比较多的读写分离处理方式,主要分为两步: 1.对于开发人员,要求serivce类的方法名必须遵守规范,读操作以query.get等开头,写操作以update.delete开头. 2.配置一个拦截器,依据方法名判断是读操作还是写操作,设置相应的数据源. 以上做法能实现最简单的读写分离,但相应的也