quartz定时任务之自定义注解实现动态配置任务

项目需求：定时任务

实现方式？

spring自带定时任务，jdk自带Timer，quartz实现。

优缺点，spring，基于注解实现，配置简单，但是后期任务丰富，之后，修改配置较为困难，且不容易控制

jdk自带，实现简单，不便于控制，

quartz，功能强大，可配置。

所以为了以后项目的扩展，果断采用quartz，引入quartz jar包，

quartz-2.2.3.jar quartz-jobs-2.2.3.jar

spring 4.0

quartz实现任务配置

编写执行代码：

@Component
public class TestJob {
public void exe(){
System.out.println("hello test");
}
}

<!--定义jobdetail-->
<bean id="testTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject" ref="testJob "/>
<property name="targetMethod" value="exe"/>
</bean>
<!--定义触发器-->
<bean id="handletrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
<property name="jobDetail" ref="testTask"/>
<property name="cronExpression" value="${handle_cron}"/>
</bean>
以上操作，每次
<!--定义调度器-->
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="testtrigger"/>
<ref bean="testtrigger1"/>
<ref bean="testtrigger2"/>
</list>
</property>
<property name="autoStartup" value="true"/>
</bean>

每次新增一个调度任务，都需要在xml里添加这些配置，真心麻烦

减少配置

1.分析

为了减少xml的配置，我们可以观察一下，spring项目中，启动一个任务的配置顺序，不难发现，

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean和org.springframework.scheduling.quartz.CronTriggerFactoryBean

是实例化一个任务对象的java对象，都是spring对quartz的封装，

其次是org.springframework.scheduling.quartz.SchedulerFactoryBean

调度器，实现对上一步任务对象的调度

所以我们要减少配置，就要从SchedulerFactoryBean入手，重写SchedulerFactoryBean，使他能够自动注册任务对象，这其中用到了自定义注解

2.代码实现

自定义注解

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Job {
//定时任务分组
String group() default "default";
//执行任务方法
String executeMethod() default "execute";
//执行任务表达式,可支持${}表达式，默认从config/job.properties加载配置cron表达式
String cron() default "";

}

重写的任务调度器SchedulerFactoryBean，实现自动装配任务

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import org.quartz.JobKey;
import org.quartz.Trigger;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
/**
*
* @author ll
* 动态配置任务添加
*后期可以从数据库中配置任务，提供接口停止，重新安排，暂停任务等接口
*/
@Component
public class EcrDynamicScheduler extends SchedulerFactoryBean  implements ApplicationContextAware {
private static ApplicationContext applicationContext;
//默认配置文件地址
private static final String DEFAULT_CONFIG_PATH="config/job.properties";
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext=applicationContext;
init();
}
private void init(){
//获取自定义注解bean对象
Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(Job.class);
if(beansWithAnnotation!=null){
try {
Collection<Object> values = beansWithAnnotation.values();
MethodInvokingJobDetailFactoryBean jobBean=null;
CronTriggerFactoryBean triggerBean=null;
List<Trigger> triggerBeans=new ArrayList<Trigger>();
//读取默认cron表达式配置文件
Properties properties=PropertiesUtils.getProperties(DEFAULT_CONFIG_PATH);
for(Object targetObject:values){
//创建jobbean
jobBean=new MethodInvokingJobDetailFactoryBean();
//获取bean上的注解
Job jobAnno = targetObject.getClass().getAnnotation(Job.class);
//获取注解内容
String group = jobAnno.group();
String executeMethod = jobAnno.executeMethod();
String beanName=targetObject.getClass().getSimpleName();
String cron=jobAnno.cron();
if(cron.contains("${")){//如果cron是el表达式,则从配置文件中获取
cron=properties.getProperty(cron.substring(2, cron.indexOf("}")), "");
}
jobBean.setTargetObject(targetObject);
jobBean.setGroup(group);
jobBean.setTargetMethod(executeMethod);
jobBean.setBeanName(beanName+"_jobBean");
//jobkey:group.beanName.executeMethod
jobBean.setName(beanName+"."+executeMethod);
jobBean.afterPropertiesSet();
//创建触发器
triggerBean=new CronTriggerFactoryBean();
triggerBean.setJobDetail(jobBean.getObject());
triggerBean.setCronExpression(cron);
triggerBean.setBeanName(beanName+"_triggerBean");
triggerBean.setName(beanName+"."+executeMethod);
triggerBean.afterPropertiesSet();
triggerBeans.add(triggerBean.getObject());
}
Trigger[] triggers =  triggerBeans.toArray(new Trigger[triggerBeans.size()]);
//交给执行器执行
setAutoStartup(true);
setTriggers(triggers);

} catch (Exception e) {
e.printStackTrace();
}

}
}
}

这个重写的SchedulerFactoryBean比较简单，也是因为项目需求也比较简单，所以就没有写太多功能，其实还有很多可以扩充的地方，可以保存任务对象jobkey和jobdetail，

实现任务对象的暂停，删除，重新安排等操作