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，
实现任务对象的暂停，删除，重新安排等操作