quartz+spring 实现任务调度

最新推荐文章于 2021-03-03 15:07:40 发布

wcfeng_9527

最新推荐文章于 2021-03-03 15:07:40 发布

阅读量443

点赞数

CC 4.0 BY-SA版权

分类专栏： java

本文链接：https://blog.csdn.net/wcfeng_9527/article/details/50580764

java 专栏收录该内容

19 篇文章

订阅专栏

本文详细介绍了如何使用Quartz和Spring实现任务调度，包括配置文件、自定义任务工厂、任务执行流程以及如何整合Quartz与Spring。通过实例演示了如何创建、启动和停止定时任务，覆盖了Cron表达式和时间间隔两种调度方式。

记录一下quartz+spring 的任务调度

配置：

quartz.properties：

org.quartz.threadPool.threadCount=1
org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore

spring.xml:

<!-- 解决SimpleJob使用Spring容器对象 -->
    <bean id="myJobFactory" class="com.shijie99.InterfaceMonitor.scheduler.MyJobFactory"></bean>
    <!-- sping整合Quartz配置 -->
    <bean name="schedulerFactoryBean"
        class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobFactory" ref="myJobFactory"></property>
        <property name="configLocation" value="classpath:quartz.properties" />
    </bean>

web.xml:

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
	<listener>
		<listener-class>com.shijie99.InterfaceMonitor.listener.InterfaceMonitorInitListener</listener-class>
	</listener>

	<filter>
		<filter-name>characterEncodingFilter</filter-name>
		<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
		<init-param>
			<param-name>encoding</param-name>
			<param-value>UTF-8</param-value>
		</init-param>
	</filter>
	<servlet>
		<servlet-name>dispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>classpath:spring.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<filter-mapping>
		<filter-name>characterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>
	<servlet-mapping>
		<servlet-name>dispatcherServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>


	<welcome-file-list>
		<welcome-file>index.jsp</welcome-file>
	</welcome-file-list>
</web-app>

MyJobFactory 类：

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

public class MyJobFactory extends AdaptableJobFactory {

	 //这个对象Spring会帮我们自动注入进来,也属于Spring技术范畴.
	  @Autowired
	  private AutowireCapableBeanFactory capableBeanFactory;
	  
	  protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
	    //调用父类的方法
	    Object jobInstance = super.createJobInstance(bundle);
	    //进行注入,这属于Spring的技术,不清楚的可以查看Spring的API.
	    capableBeanFactory.autowireBean(jobInstance);
	    return jobInstance;
	  }
}

BaseJob类：

import org.apache.log4j.Logger;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.impl.JobDetailImpl;

import com.shijie99.InterfaceMonitor.util.DateUtil;
/**
 * 处理Job基类
 */
public abstract class BaseJob implements Job {

	protected static Logger loggerJob = Logger.getLogger("Q_JOB_LOG");
	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		JobDetailImpl jobDetail = (JobDetailImpl) context.getJobDetail();
		loggerJob.info("执行任务JobKey:["+jobDetail.getKey()+"],执行时间:"+DateUtil.format(context.getFireTime(), DateUtil.YYYYMMDDHHMMSS));
		process(context.getMergedJobDataMap());
		loggerJob.info("任务完成JobKey:["+jobDetail.getKey()+"]");
	}
	
	/**
	 * 业务处理
	 * @param jobDataMap
	 */
	public abstract void process(JobDataMap jobDataMap);

}

ScheduleHandler类：

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class ScheduleHandler {

	public ScheduleHandler() {
	}

	private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

	public Scheduler getScheduler() throws SchedulerException {
		return schedulerFactory.getScheduler();
	}
}

DailyTimeIntervalScheduleHandler 类:


import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.quartz.DailyTimeIntervalScheduleBuilder;
import org.quartz.DailyTimeIntervalTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

/**
 * 按时间间隔任务调度处理类
 */
@Component
public class DailyTimeIntervalScheduleHandler extends ScheduleHandler {

	private static Logger logger = Logger.getLogger("Q_SCHEDULE_LOG");
	
	@Autowired
	private SchedulerFactoryBean schedulerFactoryBean;

	private Class<? extends Job> jobClass = null;

	public DailyTimeIntervalScheduleHandler() {
	}

	/**
	 * 启动定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void start(List<ScheduleJob> jobList,Class<? extends Job> jobClass) throws SchedulerException {
		logger.info("启动任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			startJob(job,jobClass);
		}
		logger.info("启动任务列表 - 结束");
	}
	
	/**
	 * 启动定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void start(List<ScheduleJob> jobList) throws SchedulerException {
		logger.info("启动任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			startJob(job,this.jobClass);
		}
		logger.info("启动任务列表 - 结束");
	}
	
	/**
	 * 停止定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void stop(List<ScheduleJob> jobList) throws SchedulerException {
		logger.info("停止任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			stopJob(job);
		}
		logger.info("停止任务列表 - 结束");
	}

	private void startJob(ScheduleJob job,Class<? extends Job> jobClass)
			throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(),
				job.getJobGroup());
		JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());

		JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey)
				.withDescription(job.getDesc()).build();
		Map<String, Object> jobDataMap = job.getJobDataMap();
		if (jobDataMap != null) {
			jobDetail.getJobDataMap().putAll(jobDataMap);
		}
//		//间隔时间调度构建器
		DailyTimeIntervalScheduleBuilder scheduleBuilder = DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule();
//		//设置间隔时间 分钟
		scheduleBuilder.withIntervalInMinutes(job.getDailyTimeInterval());
		DailyTimeIntervalTrigger dtrigger = TriggerBuilder.newTrigger()
				.withIdentity(triggerKey).withDescription(job.getDesc())
				.withSchedule(scheduleBuilder).build();
		
		
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		scheduler.scheduleJob(jobDetail, dtrigger);
		scheduler.start();
		
		logger.info("启动任务JobKey:["+jobKey+"] DailyTimeInterval:["+job.getDailyTimeInterval()+" min]");
	}
	
	private void stopJob(ScheduleJob job)
			throws SchedulerException {
		JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		scheduler.deleteJob(jobKey);
		logger.info("停止任务JobKey:["+jobKey+"] CronExp:["+job.getDailyTimeInterval()+" min]");
	}

	public Class<? extends Job> getJobClass() {
		return jobClass;
	}
	public void setJobClass(Class<? extends Job> jobClass) {
		this.jobClass = jobClass;
	}

}

CronScheduleHandler 类：



import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;

/**
 * 表达式任务调度处理类
 */
@Component
public class CronScheduleHandler extends ScheduleHandler {

	private static Logger logger = Logger.getLogger("Q_SCHEDULE_LOG");
	
	@Autowired
	private SchedulerFactoryBean schedulerFactoryBean;

	private Class<? extends Job> jobClass = null;

	public CronScheduleHandler() {
	}

	/**
	 * 启动定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void start(List<ScheduleJob> jobList,Class<? extends Job> jobClass) throws SchedulerException {
		logger.info("启动任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			startJob(job,jobClass);
		}
		logger.info("启动任务列表 - 结束");
	}
	
	/**
	 * 启动定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void start(List<ScheduleJob> jobList) throws SchedulerException {
		logger.info("启动任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			startJob(job,this.jobClass);
		}
		logger.info("启动任务列表 - 结束");
	}
	
	/**
	 * 停止定时任务List
	 * 
	 * @param jobList
	 * @throws SchedulerException
	 */
	public void stop(List<ScheduleJob> jobList) throws SchedulerException {
		logger.info("停止任务列表 - 开始");
		for (ScheduleJob job : jobList) {
			stopJob(job);
		}
		logger.info("停止任务列表 - 结束");
	}

	private void startJob(ScheduleJob job,Class<? extends Job> jobClass)
			throws SchedulerException {
		TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(),
				job.getJobGroup());
		JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());

		JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey)
				.withDescription(job.getDesc()).build();
		Map<String, Object> jobDataMap = job.getJobDataMap();
		if (jobDataMap != null) {
			jobDetail.getJobDataMap().putAll(jobDataMap);
		}
		// 表达式调度构建器
		CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
				.cronSchedule(job.getCronExpression());
		// 按cronExpression表达式构建一个trigger
		CronTrigger trigger = TriggerBuilder.newTrigger()
				.withIdentity(triggerKey).withDescription(job.getDesc())
				.withSchedule(scheduleBuilder).build();
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		scheduler.scheduleJob(jobDetail, trigger);
		scheduler.start();
		logger.info("启动任务JobKey:["+jobKey+"] DailyTimeInterval:["+job.getDailyTimeInterval()+"]");
	}
	
	private void stopJob(ScheduleJob job)
			throws SchedulerException {
		JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());
		Scheduler scheduler = schedulerFactoryBean.getScheduler();
		scheduler.deleteJob(jobKey);
		logger.info("停止任务JobKey:["+jobKey+"] CronExp:["+job.getCronExpression()+"]");
	}

	public Class<? extends Job> getJobClass() {
		return jobClass;
	}
	public void setJobClass(Class<? extends Job> jobClass) {
		this.jobClass = jobClass;
	}

}

ScheduleJob类：

import java.util.Map;

public class ScheduleJob {

	/** 任务id */
	private String jobId;

	/** 任务名称 */
	private String jobName;

	/** 任务分组 */
	private String jobGroup;

	/** 任务运行时间表达式 */
	private String cronExpression;
	
	/** 任务运行间隔时间*/
	private Integer dailyTimeInterval;
	
	private String desc;
	
	
	private Map<String,Object> jobDataMap;

	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 String getCronExpression() {
		return cronExpression;
	}

	public void setCronExpression(String cronExpression) {
		this.cronExpression = cronExpression;
	}

	public Map<String, Object> getJobDataMap() {
		return jobDataMap;
	}

	public void setJobDataMap(Map<String, Object> jobDataMap) {
		this.jobDataMap = jobDataMap;
	}

	public String getDesc() {
		return desc;
	}

	public void setDesc(String desc) {
		this.desc = desc;
	}

	public Integer getDailyTimeInterval() {
		return dailyTimeInterval;
	}

	public void setDailyTimeInterval(Integer dailyTimeInterval) {
		this.dailyTimeInterval = dailyTimeInterval;
	}
	
}

InterfaceMonitorJobs类：

import org.apache.log4j.Logger;
import org.quartz.JobDataMap;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.shijie99.InterfaceMonitor.scheduler.BaseJob;
import com.shijie99.InterfaceMonitor.service.InterfaceMonitorService;

@Component
public class InterfaceMonitorJobs extends BaseJob {

	private static Logger logger = Logger.getLogger("Q_JOB_LOG");
	@Autowired
	private InterfaceMonitorService service;
	
	public void process(JobDataMap jobDataMap) {
		logger.info("定时监控任务--开始");
		service.monitorSecletInterface();
		logger.info("定时监控任务--结束");
	}
}

InterfaceMonitorInitListener类：


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import org.apache.log4j.Logger;
import org.quartz.Job;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

import com.shijie99.InterfaceMonitor.job.InfoClearJobs;
import com.shijie99.InterfaceMonitor.job.InterfaceMonitorJobs;
import com.shijie99.InterfaceMonitor.scheduler.CronScheduleHandler;
import com.shijie99.InterfaceMonitor.scheduler.DailyTimeIntervalScheduleHandler;
import com.shijie99.InterfaceMonitor.scheduler.ScheduleJob;
import com.shijie99.InterfaceMonitor.util.ConfigUtils;
import com.shijie99.InterfaceMonitor.util.Constant;

/**
 * 初始化运行全部任务
 */
@Component
public class InterfaceMonitorInitListener implements ServletContextListener,
		ApplicationListener<ContextRefreshedEvent> {
	private static Logger logger = Logger
			.getLogger(InterfaceMonitorInitListener.class);

	private static String QM_STAT_SWITCH = "";
	private static String CRON_EXPRESSION = "0 0 0 * * ?";

	@Autowired
	private DailyTimeIntervalScheduleHandler dailyTimeIntervalScheduleHandler;
	
	@Autowired
	private CronScheduleHandler cronScheduleHandler;
	@Override
	public void contextDestroyed(ServletContextEvent arg0) {

	}

	@Override
	public void contextInitialized(ServletContextEvent event) {
		logger.info("加载配置文件:开始......");
		String realPath = event.getServletContext().getRealPath("/");
		ConfigUtils.setPath(realPath);
		logger.info("加载配置文件:完成......");
		ConfigUtils.showProperties();

		QM_STAT_SWITCH = ConfigUtils.getString("switch");
	}

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		// 启动监控信息统计定时任务
		if (Constant.SWITCH_ON.equals(QM_STAT_SWITCH)) {
			logger.info("启动定时任务...");
			Map<String, Object> jobDataMapProc = new HashMap<>();
			//启动定时监控任务
			this.startDailyTimeIntervalJob("interfaceMonitor", "qm",Constant.CRONMIN, jobDataMapProc,
					InterfaceMonitorJobs.class);
			//启动定时清除任务
			this.startCronJob("clearInfo", "qm",CRON_EXPRESSION, jobDataMapProc,
					InfoClearJobs.class);
		}

	}
	
	// 启动按时间间隔启动的任务
		private void startCronJob(String group, String jobId,String cronExpression,
				Map<String, Object> jobDataMap, Class<? extends Job> clazz) {
			try {
				List<ScheduleJob> jobList = new ArrayList<>();
				ScheduleJob job = new ScheduleJob();
				job.setJobId(jobId);
				job.setJobName(jobId + "_" + group);
				job.setJobGroup(group);
				job.setJobDataMap(jobDataMap);
				job.setCronExpression(cronExpression);
				jobList.add(job);
				// 将任务放到缓存中
				Constant.jobList.add(job);

				if (jobList.size() > 0) {
					cronScheduleHandler.start(jobList, clazz);
				}
			} catch (SchedulerException e) {
				logger.error("异常信息:", e);
			}
		}
	
	// 启动按时间间隔启动的任务
	private void startDailyTimeIntervalJob(String group, String jobId,Integer DailyTimeInterval,
			Map<String, Object> jobDataMap, Class<? extends Job> clazz) {
		try {
			List<ScheduleJob> jobList = new ArrayList<>();
			ScheduleJob job = new ScheduleJob();
			job.setJobId(jobId);
			job.setJobName(jobId + "_" + group);
			job.setJobGroup(group);
			job.setJobDataMap(jobDataMap);
			job.setDailyTimeInterval(DailyTimeInterval);
			jobList.add(job);
			// 将任务放到缓存中
			Constant.jobList.add(job);

			if (jobList.size() > 0) {
				dailyTimeIntervalScheduleHandler.start(jobList, clazz);
			}
		} catch (SchedulerException e) {
			logger.error("异常信息:", e);
		}
	}

}