spring + quartz 之动态任务调度

1、任务调度：根据特定的时间规则自动执行相应的业务逻辑，quartz算是一种比较简单灵活的实现方式，但是不支持分布式.

2、maven依赖：　

<dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
</dependency>

3、实现：

　　1、创建任务常量类：

package com.quartz;

/**
 * Created by xiao on 2015/9/28.
 */
public final class JobConstants {


    /**
     * Job状态
     */
    public static class JobStatus{
        /**
         * 未处理
         */
        public static final String JOB_UNPROCESSED = "0";

        /**
         * 执行成功
         */
        public static final String JOB_SUCCESSED = "1";

        /**
         * 执行失败
         */
        public static final String JOB_FAILED = "-1";

        /**
         * 过期
         */
        public static final String JOB_EXPIRED = "-2";
    }

    /**
     * 任务组
     */
    public static final class JobGruop{

        /**
         * 默认的任务组
         */
        public static final String JOB_DEFAULT_GROUP_ = "job_default_group_id";

        /**
         * 默认的任务组
         */
        public static final String JOB_DEFAULT_GROUP_NAME = "job_default_group_name";
    }

    public static final class JobName{

        /**
         * 默认的任务名
         */
        public static final String JOB_DEFAULT_ID = "job_default_id";

        /**
         * 默认的任务名
         */
        public static final String JOB_DEFAULT_NAME = "job_default_name";
    }

}

　　2、创建任务实体，封装任务参数：　

package com.quartz;

import java.util.Date;

/**
 * 任务 实体
 * Created by xiao on 2015/9/28.
 */
public final class Job implements java.io.Serializable {

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

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

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

    /**
     * 创建时间
     */
    private Date createTime;

    /**
     * 更新时间
     */
    private Date updateTime;

    /**
     * 任务状态
     */
    private String jobStatus;
    /**
     * cron表达式
     */
    private String cronExpression;

    /**
     * 简单时间表达式
     */
    private Date simpleExpression;

    /**
     * 任务执行时调用哪个类的方法 包名+类名
     */
    private String jobClassName;

    /**
     * 任务调用的方法名
     */
    private String jobMethodName;

    /**
     * 任务是否有状态(即并发执行同一个任务)
     */
    private boolean isConcurrent = true;

    /**
     * 描述
     */
    private String description;


    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 getJobGroupId() {
        return jobGroupId;
    }

    public void setJobGroupId(String jobGroupId) {
        this.jobGroupId = jobGroupId;
    }

    public String getJobGroup() {
        return jobGroup;
    }

    public void setJobGroup(String jobGroup) {
        this.jobGroup = jobGroup;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public Date getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(Date updateTime) {
        this.updateTime = updateTime;
    }

    public String getJobStatus() {
        return jobStatus;
    }

    public void setJobStatus(String jobStatus) {
        this.jobStatus = jobStatus;
    }

    public String getCronExpression() {
        return cronExpression;
    }

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

    public Date getSimpleExpression() {
        return simpleExpression;
    }

    public void setSimpleExpression(Date simpleExpression) {
        this.simpleExpression = simpleExpression;
    }

    public String getJobClassName() {
        return jobClassName;
    }

    public void setJobClassName(String jobClassName) {
        this.jobClassName = jobClassName;
    }

    public String getJobMethodName() {
        return jobMethodName;
    }

    public void setJobMethodName(String jobMethodName) {
        this.jobMethodName = jobMethodName;
    }

    public boolean isConcurrent() {
        return isConcurrent;
    }

    public void setConcurrent(boolean concurrent) {
        isConcurrent = concurrent;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

　　3、创建任务管理器，实现了任务动态的增、删、更新、暂停等操作　　　

package com.quartz;

import com.quartz.job.DefaultJobFactory;
import com.quartz.job.DisallowConcurrentJobFactory;
import org.quartz.*;
import org.quartz.impl.StdScheduler;
import org.quartz.impl.matchers.GroupMatcher;
import util.FastJsonUtil;
import util.StringUtil;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

/**
 * 任务调度管理器， 实现任务的动态操作
 * Created by xiao on 2015/9/28.
 */
public class JobManager {

    //为调度管理器注入工厂bean
    private StdScheduler scheduler;

    //调度名称
    private static final String SCHEDULER_NAME = "scheduler";

    public StdScheduler getScheduler() {
        return scheduler;
    }

    public void setScheduler(StdScheduler scheduler) {
        this.scheduler = scheduler;
    }

    /**
     * 添加任务
     * @param job
     * @throws SchedulerException
     */
    public void addJob(Job job) throws SchedulerException, ClassNotFoundException {
        if (job == null || StringUtil.isEmptyString(job.getJobId())) return;
        if(StringUtil.isEmptyString(job.getCronExpression())
                && null == job.getSimpleExpression()) return;
        if (StringUtil.isEmptyString(job.getJobClassName())) return;
        if(StringUtil.isEmptyString(job.getJobName()))
            job.setJobName(JobConstants.JobName.JOB_DEFAULT_NAME);
        if(null == job.getSimpleExpression()) {
            addCronJob(job);
        }else{
            addSimpleJob(job);
        }
    }

    /**
     * 添加 cron 表达式任务
     * @param job
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    private void addCronJob(Job job) throws SchedulerException, ClassNotFoundException {
        //根据任务id和任务组Id创建触发器key
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(), job.getJobGroup());
        //获取触发器对象
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        // 不存在，创建一个
        if (null == trigger) {
            JobDetail jobDetail = JobBuilder.newJob(job.isConcurrent() ? DefaultJobFactory.class : DisallowConcurrentJobFactory.class)
                    .withIdentity(job.getJobId(), job.getJobGroup()).build();
            jobDetail.getJobDataMap().put(SCHEDULER_NAME, FastJsonUtil.objToJson(job));
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(
                            job.getCronExpression())).build();
            scheduler.scheduleJob(jobDetail, trigger);
        } else {
            updateJobCron(job);
        }
    }

    /**
     * 添加 简单时间 表达式任务
     * @param job
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    private void addSimpleJob(Job job) throws SchedulerException {
        //根据任务id和任务组Id创建触发器key
        TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobId(), job.getJobGroup());
        //获取触发器对象
        SimpleTrigger trigger = (SimpleTrigger) scheduler.getTrigger(triggerKey);
        // 不存在，创建一个
        if (null == trigger) {
            JobDetail jobDetail = JobBuilder.newJob(job.isConcurrent() ? DefaultJobFactory.class : DisallowConcurrentJobFactory.class)
                    .withIdentity(job.getJobId(), job.getJobGroup()).build();
            jobDetail.getJobDataMap().put(SCHEDULER_NAME, FastJsonUtil.objToJson(job));
            trigger = TriggerBuilder.newTrigger()
                    .withIdentity(triggerKey)
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule())
                    .startAt(job.getSimpleExpression()).build();
            scheduler.scheduleJob(jobDetail, trigger);
        } else {
            updateJobSimple(job);
        }
    }

    /**
     * 更新job时间表达式
     *
     * @param job
     * @throws SchedulerException
     */
    public void updateJobCron(Job job) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(
                job.getJobId(), job.getJobGroup());
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule(job.getCronExpression())).build();
        scheduler.rescheduleJob(triggerKey, trigger);
    }

    /**
     * 更新job时间表达式
     *
     * @param job
     * @throws SchedulerException
     */
    public void updateJobSimple(Job job) throws SchedulerException {
        TriggerKey triggerKey = TriggerKey.triggerKey(
                job.getJobId(), job.getJobGroup());
        SimpleTrigger trigger = (SimpleTrigger) scheduler.getTrigger(triggerKey);
        trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                .withSchedule(SimpleScheduleBuilder.simpleSchedule())
                .startAt(job.getSimpleExpression()).build();
        scheduler.rescheduleJob(triggerKey, trigger);
    }

    /** 获取所有计划中的任务列表
     * @return
     * @throws SchedulerException
     **/
    public List<Job> getAllJob() throws SchedulerException {
        GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
        Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
        List<Job> jobList = new ArrayList<>();
        for (JobKey jobKey : jobKeys) {
            List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
            for (Trigger trigger : triggers) {
                Job job = new Job();
                job.setJobId(jobKey.getName());
                job.setJobGroup(jobKey.getGroup());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                job.setJobStatus(triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    job.setCronExpression(cronExpression);
                }
                jobList.add(job);
            }
        }
        return jobList;
    }

    /**
     * 所有正在运行的job
     *
     * @return
     * @throws SchedulerException
     */
    public List<Job> getRunningJob() throws SchedulerException {
        List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
        List<Job> jobList = new ArrayList<>(executingJobs.size());
        for (JobExecutionContext executingJob : executingJobs) {
            Job job = new Job();
            JobDetail jobDetail = executingJob.getJobDetail();
            JobKey jobKey = jobDetail.getKey();
            Trigger trigger = executingJob.getTrigger();
            job.setJobName(jobKey.getName());
            job.setJobGroup(jobKey.getGroup());
            Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
            job.setJobStatus(triggerState.name());
            if (trigger instanceof CronTrigger) {
                CronTrigger cronTrigger = (CronTrigger) trigger;
                String cronExpression = cronTrigger.getCronExpression();
                job.setCronExpression(cronExpression);
            }
            jobList.add(job);
        }
        return jobList;
    }

    /**
     * 暂停一个job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void pauseJob(Job scheduleJob) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobId(), scheduleJob.getJobGroup());
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复一个job
     *
     * @param job
     * @throws SchedulerException
     */
    public void resumeJob(Job job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除一个job
     *
     * @param scheduleJob
     * @throws SchedulerException
     */
    public void deleteJob(Job scheduleJob) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(scheduleJob.getJobId(), scheduleJob.getJobGroup());
        scheduler.deleteJob(jobKey);

    }

    /**
     * 立即执行job
     *
     * @param job
     * @throws SchedulerException
     */
    public void triggerJob(Job job) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(job.getJobId(), job.getJobGroup());
        scheduler.triggerJob(jobKey);
    }


}

　　4、创建任务执行类，这个类需要实现 org.quarzt.Job 接口, Job接口有一个excute(JobExecutionContext context) 方法, 调度被处罚以后会自动执行, 再次我们实现这个方法, 通过反射来转发到我们创建任务时指定执行的方法, 代码如下：

package com.quartz.job;

import com.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import util.FastJsonUtil;
import util.StringUtil;

/**
 * Created by xiao on 2015/9/29.
 */
public class DefaultJobFactory extends  AbstractJobFactory implements org.quartz.Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {
        String scheduleJob = (String) context.getMergedJobDataMap().get("scheduler");
        if(!StringUtil.isEmptyString(scheduleJob)){
            Job job = FastJsonUtil.jsonToObj(scheduleJob, Job.class);
            invoke(job);
        }

    }
}

package com.quartz.job;

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import util.FastJsonUtil;
import util.StringUtil;

/**
 * Created by xiao on 2015/9/29.
 */
@DisallowConcurrentExecution
public class DisallowConcurrentJobFactory extends  AbstractJobFactory implements Job {

    public void execute(JobExecutionContext context) throws JobExecutionException {

        String scheduleJob = (String) context.getMergedJobDataMap().get("scheduler");
        if(!StringUtil.isEmptyString(scheduleJob)){
            com.quartz.Job job = FastJsonUtil.jsonToObj(scheduleJob, com.quartz.Job.class);
            invoke(job);
        }
    }
}

package com.quartz.job;

import com.quartz.Job;
import util.SpringBeanUtil;
import util.StringUtil;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by xiao on 2016/4/29.
 */
public class AbstractJobFactory {

    public void invoke(Job job){
        if(!StringUtil.isEmptyString(job.getJobClassName())){
            try {
                Class<?> clazz = Class.forName(job.getJobClassName());
                //从spring容器获取bean,否则无法注入
                Object obj = SpringBeanUtil.getBeanByType(clazz);
                //反射方法
                Method method = obj.getClass().getDeclaredMethod(job.getJobMethodName());
                method.invoke(obj, job);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (NoSuchMethodException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }
}

　　获取bean 工具类：

package util;

import org.springframework.web.context.ContextLoader;
import org.springframework.web.context.WebApplicationContext;

public final class SpringBeanUtil {

    //获取web容器上下文
    private static WebApplicationContext wac = ContextLoader
            .getCurrentWebApplicationContext();

    /**
     * 违背了 Spring 依赖注入思想
     *
     * @param beanId
     * @return
     */
    public static Object getBeanByName(String beanId) throws Exception {
        if (StringUtil.isEmptyString(beanId)) {
            throw new Exception("beanId is null");
        }
        return wac.getBean(beanId);

    }

    /**
     *  违背spring的ioc解耦思想。
     */
    public static  <T> T getBeanByType(Class clazz) {
        if (clazz == null) {
            return null;
        }
        return (T) wac.getBean(clazz);
    }
}

　　FastJson 序列化工具类, FastJson是阿里开源的号称最快的序列化工具

package util;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;

/**
 * FastJson 序列化工具
 *
 * @author xiao
 *
 */
public final class FastJsonUtil {

    /**
     * 序列化参数
     */
    private static final SerializerFeature[] features = {
            SerializerFeature.WriteMapNullValue,
            SerializerFeature.WriteNullBooleanAsFalse,
            SerializerFeature.WriteNullStringAsEmpty,
            SerializerFeature.WriteNullListAsEmpty,
            SerializerFeature.WriteNullNumberAsZero };

    /**
     * 对象转换成json 支持list,map,array
     *
     * @param obj
     * @return
     */
    public static String objToJson(Object obj) {
        return JSON.toJSONString(obj, features);
    }


    /**
     * json 转换成对象
     *
     * @param json
     * @param clazz
     * @return
     */
    public static <T> T jsonToObj(String json, Class<?> clazz) {
        return (T) JSON.parseObject(json, clazz);
    }
}

　　5、最后一步, 在spring中集成,配置如下：

    <!-- 任务管理器 -->
    <bean class="com.quartz.JobManager">
        <property name="scheduler">
        <!-- 将触发器注入任务工程 -->
            <bean id="scheduler" lazy-init="false" scope="singleton"
                  class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>
        </property>
    </bean>