003-spring结合java类调用quartz

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

一、利弊

针对001 中设置，不方便程序中动态添加任务，只能使用配置进行配置任务，

适用于已知固定时刻需要执行的任务。

针对002中设置，不方便结合调用spring注入的实体

使用于程序内部新增添的任务

二、结合spring以及动态添加任务

1.编写ApplicationContext对象注入类

@Component
public class SpringContextUtil implements ApplicationContextAware {
// Spring应用上下文环境
private static ApplicationContext applicationContext; /**
* 实现ApplicationContextAware接口的回调方法。设置上下文环境
*
* @param applicationContext
*/
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
SpringContextUtil.applicationContext = applicationContext;
} /**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
} /**
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(String name) {
checkApplicationContext();
if (applicationContext.containsBean(name)) {
return (T) applicationContext.getBean(name);
}
return null;
} /**
* 从静态变量ApplicationContext中取得Bean, 自动转型为所赋值对象的类型.
*/
@SuppressWarnings("unchecked")
public static <T> T getBean(Class<T> clazz) {
checkApplicationContext();
return (T) applicationContext.getBean(clazz);
} private static void checkApplicationContext() {
if (applicationContext == null){
throw new IllegalStateException("applicaitonContext未注入,请在applicationContext.xml中定义SpringContextUtil");
}
} /**
* 同步方法注册bean到ApplicationContext中
*
* @param beanName
* @param clazz
* @param original bean的属性值
*/
public static synchronized void setBean(String beanName, Class<?> clazz,Map<String,Object> original) {
checkApplicationContext();
DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getAutowireCapableBeanFactory();
if(beanFactory.containsBean(beanName)){
return;
}
//BeanDefinition beanDefinition = new RootBeanDefinition(clazz);
GenericBeanDefinition definition = new GenericBeanDefinition();
//类class
definition.setBeanClass(clazz);
//属性赋值
definition.setPropertyValues(new MutablePropertyValues(original));
//注册到spring上下文
beanFactory.registerBeanDefinition(beanName, definition);
} /**
* 删除spring中管理的bean
* @param beanName
*/
public static void removeBean(String beanName){
ApplicationContext ctx = SpringContextUtil.getApplicationContext();
DefaultListableBeanFactory acf = (DefaultListableBeanFactory) ctx.getAutowireCapableBeanFactory();
if(acf.containsBean(beanName)) {
acf.removeBeanDefinition(beanName);
}
} /**
* 根据bean的id来查找对象
*
* @param id
* @return
*/ public static <T> T getBeanById(String id) {
return (T) applicationContext.getBean(id);
}
}

2.spring，xml配置

3.编写Job接口工厂

public class JobFactory extends AdaptableJobFactory { @Autowired
private AutowireCapableBeanFactory capableBeanFactory; @Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
//调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
//进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}

4.注入Job工厂，以及quartz调度工厂

5.java帮助类

public class TaskJobUtil {
private static final Logger logger = LoggerFactory.getLogger(TaskJobUtil.class); private TaskJobUtil() {
} /**
* 添加任务
*
* @param job 要调用的job类
* @param jobName job名称
* @param cronExpression 任务触发时间表达式
* @param param 需要用到的参数，可在job类中的context获得
*/
public static void addJob(Job job, String jobName, String cronExpression, Map param) {
Scheduler scheduler = null;
try {
removeJob(jobName, job.getClass().getCanonicalName() + "Group");//删除原任务
scheduler= (StdScheduler)SpringContextUtil.getBean("schedulerFactoryBean");
JobDetail jobDetail = getJobDetail(job, jobName, param);
String jobGroup = jobDetail.getGroup();
CronTrigger cronTrigger = getCronTrigger(job, jobName, jobGroup, cronExpression);
scheduler.scheduleJob(jobDetail, cronTrigger);
logger.info("添加任务：" + jobName);
startScheduler();
} catch (SchedulerException e) {
logger.error("", e);
}
} /**
* 对外停止任务调度器方法
*/
public static void stopJob() {
shutdownScheduler();
} /**
* 启动调度器
*/
protected static void startScheduler() {
Scheduler scheduler = null;
try {
scheduler= (StdScheduler)SpringContextUtil.getBean("schedulerFactoryBean");
//如果调度器未启动，启动调度器
if (scheduler != null && !scheduler.isStarted()) {
scheduler.start();
}
} catch (SchedulerException e) {
logger.error("", e);
}
} /**
* 关闭调度器，关闭后任务也都清除
*/
protected static void shutdownScheduler() {
Scheduler scheduler = null;
try {
scheduler= (StdScheduler)SpringContextUtil.getBean("schedulerFactoryBean");
//如果调度器未关闭，关闭调度器
if (scheduler != null && !scheduler.isShutdown()) {
scheduler.shutdown();
}
} catch (SchedulerException e) {
logger.error("", e);
}
} /**
* 获取JobDetail
*
* @param job
* @param param
* @return
*/
protected static JobDetail getJobDetail(Job job, String jobName, Map param) {
Class jobClazz = job.getClass();
if (jobName == null || "".equals(jobName)) {
jobName = jobClazz.getCanonicalName();
}
String jobGroup = jobClazz.getCanonicalName() + "Group"; JobDetail jobDetail = new JobDetail();
jobDetail.setDurability(true);
jobDetail.setRequestsRecovery(true);
jobDetail.setName(jobName);
jobDetail.setGroup(jobGroup);
jobDetail.setJobClass(jobClazz); if (param != null && param.size() > 0) {
JobDataMap jobDataMap = new JobDataMap(param);//存放参数
jobDetail.setJobDataMap(jobDataMap); logger.info("任务 " + jobName + " jobDetail存放的参数：" + param);
}
return jobDetail;
} /**
* 获取触发器
*
* @param job
* @param jobName
* @param cronExpression
* @return
*/
protected static CronTrigger getCronTrigger(Job job, String jobName, String jobGroup, String cronExpression) {
Class jobClazz = job.getClass();
String triggerName = jobName+jobClazz.getCanonicalName() + "Trigger";
String triggerGroup = jobClazz.getCanonicalName() + "TriggerGroup"; CronTrigger cronTrigger = new CronTrigger();
cronTrigger.setName(triggerName);
cronTrigger.setGroup(triggerGroup);
cronTrigger.setJobName(jobName);
cronTrigger.setJobGroup(jobGroup);
try {
cronTrigger.setCronExpression(cronExpression);//触发任务的时间表达式
} catch (Exception e) {
logger.error("",e);
} logger.info("任务 " + jobName + " 触发时间：" + cronExpression);
return cronTrigger;
} /**
* 删除job
*
* @param jobName
* @param jobGroup
*/
public static void removeJob(String jobName, String jobGroup) {
logger.info("删除任务：jobName：" + jobName + " jobGroup：" + jobGroup);
Scheduler scheduler = null;
String[] jobNames = null;
try {
scheduler= (StdScheduler)SpringContextUtil.getBean("schedulerFactoryBean");
jobNames = scheduler.getJobNames(jobGroup);
if (jobNames == null || jobNames.length == 0) {
return;
}
for (String name : jobNames) {
if (name.equals(jobName)) {
scheduler.pauseTrigger(jobName, jobGroup);//停止触发器
scheduler.pauseJob(jobName, jobGroup);//暂停job
scheduler.unscheduleJob(jobName, jobGroup);//取消预订的job
scheduler.deleteJob(jobName, jobGroup);//删除job
}
} } catch (SchedulerException e) {
logger.error("", e);
}
} /**
* 获取任务列表
*
* @return
*/
public static Map<String, List<String>> getJobList() {
Scheduler scheduler = null;
Map<String, List<String>> map = null;
try {
scheduler= (StdScheduler)SpringContextUtil.getBean("schedulerFactoryBean");
String[] jobGroupNames = scheduler.getJobGroupNames();
if (jobGroupNames == null || jobGroupNames.length == 0) {
return null;
} map = new HashMap<String, List<String>>();
for (String jobGroup : jobGroupNames) {
String[] jobNames = scheduler.getJobNames(jobGroup);
if (jobNames == null || jobNames.length == 0) {
continue;
}
List<String> jobNameList = new ArrayList<String>();
for (String jobName : jobNames) {
jobNameList.add(jobName);
}
map.put(jobGroup, jobNameList);
}
} catch (SchedulerException e) {
logger.error("", e);
}
logger.info("获取job列表：" + map);
return map;
}
}