quartz 定时任务管理

一、立即执行

Scheduler scheduler = schedulerFactoryBean.getScheduler();
JobKey jobKey = JobKey.jobKey("job_name", JobKey.DEFAULT_GROUP);
scheduler.triggerJob(jobKey);

关于schedulerFactoryBean，可通过注解注入

@Autowired
private SchedulerFactoryBean schedulerFactoryBean;

如不行，则通过spring获取bean

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;

public class Springfactory implements BeanFactoryAware {

    private static BeanFactory beanFactory;  

    // private static ApplicationContext context;  

    public void setBeanFactory(BeanFactory factory) throws BeansException {
        Springfactory.beanFactory = factory;
    }

    /** 
     * 根据beanName名字取得bean 
     * @param beanName 
     * @return 
     */  
    @SuppressWarnings("unchecked")
	public static <T> T getBean(String beanName) {
        if (null != beanFactory) {
            return (T) beanFactory.getBean(beanName);
        }
        return null;
    }  
} 

Scheduler scheduler = Springfactory.getBean("schedulerFactoryBean");

二、动态修改时间

因为是分布式系统，所以采用的是disconf来统一管理quartz的配置文件

如不知道disconf，可先自行百度，此处不详说

import java.util.List;
import java.util.Properties;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.PropertiesLoaderUtils;
import org.springframework.stereotype.Service;

import com.baidu.disconf.client.common.annotations.DisconfUpdateService;
import com.baidu.disconf.client.common.update.IDisconfUpdate;

@Service
@Scope("singleton")
@DisconfUpdateService(confFileKeys = { "quartz.properties" })
public class QuartzServiceUpdateCallback implements IDisconfUpdate{

	private static final Logger logger = LoggerFactory.getLogger(QuartzServiceUpdateCallback.class);
	@Override
	public void reload() throws Exception {
		Scheduler scheduler = Springfactory.getBean("schedulerFactoryBean");

		//加载配置文件
		PathMatchingResourcePatternResolver pathMatchingResourcePatternResolver = new PathMatchingResourcePatternResolver();
		Resource[] resourceList = pathMatchingResourcePatternResolver.getResources(
				this.getClass().getAnnotation(DisconfUpdateService.class).confFileKeys()[0]);
		Properties props = PropertiesLoaderUtils.loadProperties(new EncodedResource(resourceList[0], "GBK"));

		for (Object key : props.keySet()) {
			String newTime = props.getProperty(key.toString());
			JobKey jobKey = new JobKey(key.toString());

			List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
			for (Trigger trigger : triggers) {
				if (trigger instanceof CronTrigger && !newTime.equalsIgnoreCase(((CronTrigger) trigger).getCronExpression())) {
					logger.info("Updating property {}.cronExpression from {} to {}", trigger.getKey().getName(),
							((CronTrigger) trigger).getCronExpression(), newTime);
					
					TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
					trigger = triggerBuilder.withIdentity(trigger.getKey().getName(), TriggerKey.DEFAULT_GROUP).withSchedule(
									CronScheduleBuilder.cronSchedule(newTime)).build();
					scheduler.rescheduleJob(trigger.getKey(), trigger);
				}
			}
		}
	}
}

disconf管理配置文件，但是回调函数并不能知道配置文件里具体是哪个属性发生变化，所以只能通过读取下载的最新的配置文件与

内存里的定时任务的时间表达式进行比较

若相同，则不管

若不同，则重新设置该任务的时间表达式，并生效

这样子就ok了。