spring3.2.0 quartz-2.2.1 整合实现动态定时任务

最新推荐文章于 2018-08-23 14:39:35 发布

weixin_33843409

最新推荐文章于 2018-08-23 14:39:35 发布

阅读量101

点赞数

文章标签： java

原文链接：https://my.oschina.net/u/2289161/blog/849550

版权

2019独角兽企业重金招聘Python工程师标准>>>

spring3.2.0 quartz-2.2.1 实现动态定时任务

spring 和 quartz的整合很简单，但是实现动态定时任务却有一点麻烦，下面详细介绍一下 spring3.2.0和quzrtz2.2.1 的整合实现定时任务的的动态加载

类介绍

QuartzManager.java 任务的管理（添加、删除、启动、任务列表等），更多功能看官方文档：http://www.quartz-scheduler.org/documentation/quartz-2.2.x/tutorials/

MyJobFactory.java job自动注入Spring容器

OverOrderJobExample.java/CloseOrderJobExample.java job执行内容

源代码

MyJobFactory.java

package chaomeiman.yueshou.job;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.AdaptableJobFactory;

@Configuration("myJobFactory")
public class MyJobFactory extends AdaptableJobFactory{

	@Autowired
	private AutowireCapableBeanFactory capableBeanFactory;

	@Override
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		//调用父类的方法
		Object jobInstance = super.createJobInstance(bundle);
		capableBeanFactory.autowireBeanProperties(jobInstance, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false);
		return jobInstance;
	}
}

配置applicationContext.xml

<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobFactory" ref="myJobFactory"/>
    </bean>

QuartzManager.java

package chaomeiman.yueshou.job;


import chaomeiman.yueshou.model.main.JobInfo;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.context.annotation.Configuration;

import static org.quartz.JobBuilder.newJob;

@Configuration
public class QuartzManager {

	/**
	 * 关闭所有定时任务
	 */
	public static void shutdownJobs(Scheduler sched) {
		try {
			if (! sched.isShutdown()) {
				sched.shutdown();
			}
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	/**
	 * 添加任务调度
	 * @param scheduler
	 * @param job
	 * @param classz
	 * @throws SchedulerException
	 */
	public void addJob(Scheduler scheduler, JobInfo job, Class classz) throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getJob_name(), job.getJob_group());
		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
		if (null == trigger) {
			//不存在触发器，创建一个
			JobDetail jobDetail = newJob(classz).withIdentity(job.getJob_name(), job.getJob_group()).build();
			jobDetail.getJobDataMap().put("jobInfo", job);
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getJob_quartz_time());
			//按新的cronExpression表达式构建一个新的trigger
			trigger = TriggerBuilder.newTrigger().withIdentity(job.getJob_name(), job.getJob_group()).withSchedule(scheduleBuilder).build();
			scheduler.scheduleJob(jobDetail, trigger);
		} else {
			// Trigger已存在，那么更新相应的定时设置
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getJob_quartz_time());
			//按新的cronExpression表达式重新构建trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
			//按新的trigger重新设置job执行
			scheduler.rescheduleJob(triggerKey, trigger);
		}
	}

	/**
	 * 删除任务调度
	 * @param scheduler
	 * @param job
	 * @param classz
	 * @throws SchedulerException
	 */
	public void removeJob(Scheduler scheduler, JobInfo job, Class classz) throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getJob_name(), job.getJob_group());
		CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
		if (null == trigger) {
			//不存在触发器，创建一个
			JobDetail jobDetail = newJob(classz).withIdentity(job.getJob_name(), job.getJob_group()).build();
			jobDetail.getJobDataMap().put("jobInfo", job);
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getJob_time());
			//按新的cronExpression表达式构建一个新的trigger
			trigger = TriggerBuilder.newTrigger().withIdentity(job.getJob_name(), job.getJob_group()).withSchedule(scheduleBuilder).build();
			scheduler.scheduleJob(jobDetail, trigger);
		} else {
			// Trigger已存在，那么更新相应的定时设置
			//表达式调度构建器
			CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getJob_time());
			//按新的cronExpression表达式重新构建trigger
			trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
			//按新的trigger重新设置job执行
			scheduler.rescheduleJob(triggerKey, trigger);
		}
	}

	/**
	 * 获取任务调度列表
	 * @param scheduler
	 * @throws SchedulerException
	 */
	public void listJob(Scheduler scheduler) throws SchedulerException {
		for(String group: scheduler.getJobGroupNames()) {
			for(JobKey jobKey : scheduler.getJobKeys(GroupMatcher.groupEquals(group))) {
				System.out.println("Found job identified by: " + jobKey);
			}
		}
	}



	/**
	 * 启动所有定时任务
	 */
	public void startJobs(Scheduler scheduler) {
		try {
			scheduler.start();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}
}

OverOrderJobExample.java

package chaomeiman.yueshou.job;

import chaomeiman.yueshou.service.OrderService;
import code.ResultCodeUtil;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import util.LogUtil;

public class OverOrderJobExample extends ResultCodeUtil implements Job {

	@Autowired
	private OrderService orderService;

	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		LogUtil.loger("---------开始执行完成订单任务-------");
//		JobDataMap jobDataMap = arg0.getJobDetail().getJobDataMap();
		if (orderService != null) {
			try {
				//自动完成订单
				//每天零点执行，将支付成功并已接单的订单自动完成
				orderService.jobOverOrderInfo();
			} catch (Exception e) {
				e.printStackTrace();
			}
		} else {
			// TODO: 2017/2/25 获取任务调度信息失败
			LogUtil.loger("执行完成订单任务失败，orderService获取失败");
		}
		LogUtil.loger("---------执行完成订单任务结束-------");
	}
}

test.java

@Resource
	private Scheduler scheduler ;

	public Scheduler getScheduler() {
		return scheduler;
	}

	public void setScheduler(Scheduler scheduler) {
		this.scheduler = scheduler;
	}

	@Test
	public void testJob() throws Exception {

		String jobTime = "2017-02-27 16:54";
		DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm");
		LocalDateTime localDateTime = LocalDateTime.parse(jobTime, formatter);
		int H = localDateTime.getHour();
		int m = localDateTime.getMinute();
		int s = localDateTime.getSecond();
		int d = localDateTime.getDayOfMonth();
		int M = localDateTime.getMonthValue();
		int y = localDateTime.getYear();
		/** 秒 是 0-59 , - * /
		 分 是 0-59 , - * /
		 时 是 0-23 , - * /
		 日 是 1-31 , - * ? / L W C
		 月 是 1-12 或 JAN-DEC , - * /
		 周 是 1-7 或 SUN-SAT , - * ? / L C #
		 年 否 空 或 1970-2099 , - * /
		 **/
		String jobQuartzTime = s + " " + m + " " + " " + H + " " + d + " " + M + " " + "?" + " " + y;
		String uuid = UUIDUtil.getUUID();
		JobInfo jobInfo = new JobInfo();
		jobInfo.setUuid("a05eb41e833d499b883768ae1f25be69");
		jobInfo.setUuid2(CoderUtil.encryptMD5(System.currentTimeMillis()+uuid, CoderUtil.ENCODING_FORMAT_UTF_8));
		jobInfo.setJob_name("201702271437220000000581");
		jobInfo.setJob_quartz_time(jobQuartzTime);
		jobInfo.setJob_time("2017-02-27 14:45:00");
		jobInfo.setJob_group("closeOrder");
		jobInfo.setOrder_number("201702271437220000000581");
		jobInfo.setUser_uuid("93cd68fcb95043febd28d6ad86666029");
//		jobInfoMapper.insert(jobInfo);
		QuartzManager quartzManager = new QuartzManager();
		quartzManager.startJobs(scheduler);
		quartzManager.addJob(scheduler, jobInfo, CloseOrderJobExample.class);
		quartzManager.startJobs(scheduler);
		Thread.sleep(310000);
	}

结果：