quartz代码

package com.sugon.example.service.quartz.intf.export;

import java.util.Map;

import org.quartz.Job;

/**
 * 调度服务接口
 * @author Admin
 *
 */
public interface IScheduleService {

    /**
     * 周期性调度任务(主要处理固定时间间隔的任务,如每隔30秒执行一次,每隔10秒执行一次等)
     * @param jobName 任务名
     * @param task 任务
     * @param repeatInterval 重复间隔
     * @param repeatCount 重复次数,如果为null,则无限
     * @param param 任务所需的参数
     * @return
     * @throws Exception
     */
    boolean schedule(String jobName,Class<? extends Job> task,Long repeatInterval,Integer repeatCount,Map<String,Object> param)throws Exception;

    /**
     * 周期性调度任务(主要处理每月15号或每天下午的3点的任务)
     * @param jobName 任务名
     * @param task 任务所代表的类
     * @param cronExpre cron 表达式
     * @param params 参数对象
     * @return
     * @throws Exception
     */
    boolean schedule(String jobName,Class<? extends Job> task,String cronExpre,Map<String,Object> params) throws Exception;

    /**
     * 指定的任务是否已在队列中
     * @param jobName 任务名
     * @return true:存在 false:不存在
     * @throws Exception
     */
    boolean existsInScheduler(String jobName) throws Exception;

    /**
     * 修改任务的时间
     * @param jobName 任务名称
     * @param time cron表达式
     * @param so 任务参数
     * @throws Exception
     */
    void modifyJobTime(String jobName,String time,Map<String,Object> param) throws Exception;

    /**
     * 修改任务时间(主要是固定重复间隔、重复次数)
     * @param jobName 任务名
     * @param repeatInterval 重复间隔
     * @param repeatCount 重复次数
     * @param param 任务所需的参数
     * @throws Exception
     */
    void modifyJobTime(String jobName,Long repeatInterval,Integer repeatCount,Map<String,Object> param) throws Exception;

    /**
     * 得到所有队列中的任务名称
     * @return 任务名称数组
     * @throws Exception
     */
    String[] getAllJobNames() throws Exception;

    /**
     * 从调度器中移除指定的任务
     * @param jobName 任务名
     * @throws Exception
     */
    void removeJobFromScheduler(String jobName)throws Exception;
}

/**###############################################implementation#####################################################*/

package com.sugon.example.service.quartz.intf.impl;

import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import javax.annotation.PostConstruct;

import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;

import com.sugon.example.service.quartz.intf.export.IScheduleService;
/**
 * 调度服务实现类
 * @author Admin
 * @see IScheduleService
 */
@Service("scheduleService")
public class ScheduleServiceImpl implements IScheduleService {

    private static IScheduleService scheduleService = null;
    private static SchedulerFactory schedulerFactory = null;
    private static Scheduler scheduler=null;
    private static final String DEFAULT_JOB_GROUP="defaultJobGroup";
    private static final String DEFAULT_TRIGGER_NAME="defaultTriggerName";
    private static final String DEFAULT_TRIGGER_GROUP="defaultTriggerGroup";
    private static Object obj = new Object();
    private ScheduleServiceImpl(){}
    static{

        schedulerFactory = new StdSchedulerFactory();
        try {
            scheduler = schedulerFactory.getScheduler();
        } catch (SchedulerException e) {
            System.out.println("obtain scheduler obj error!!");
        };
    }
    public static IScheduleService getInstance(){

          synchronized (obj) {

               if (null == scheduleService){

                   scheduleService = new ScheduleServiceImpl();
               }
          }
          return scheduleService;
    }

    @Override
    public boolean schedule(String jobName,Class<? extends Job> task, Long repeatInterval,
            Integer repeatCount,Map<String,Object> param) throws Exception {
        Assert.notNull(task,"task can't be null!!");
        Assert.notNull(repeatInterval,"repeat interval can't be null!!");
        if (!existsInScheduler(jobName)) {// 如果给定的任务不在任务队列中

            JobDetail jobDetail = new JobDetail(jobName,DEFAULT_JOB_GROUP,task);
            JobDataMap jdm = convertToJobDataMap(param);
            jobDetail.setJobDataMap(jdm);
            SimpleTrigger simpleTrigger=new SimpleTrigger(jobName,DEFAULT_TRIGGER_GROUP);
            simpleTrigger.setStartTime(new Date());
            simpleTrigger.setRepeatInterval(repeatInterval);
            simpleTrigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
            if (null != repeatCount) {

                simpleTrigger.setRepeatCount(repeatCount);
            }
            scheduler.scheduleJob(jobDetail, simpleTrigger);
            if (!scheduler.isStarted()) {
                scheduler.start();
            }

        }
         return true;
    }

    @Override
    public boolean schedule(String jobName,Class<? extends Job> task, String cronExpre,Map<String,Object> params)
            throws Exception {
        Assert.notNull(task,"task can't be null!!");
        Assert.notNull(cronExpre,"cron expression can't be null!!");
        if (!existsInScheduler(jobName)) {// 如果给定的任务不在任务队列中

            JobDetail jobDetail = new JobDetail(jobName,DEFAULT_JOB_GROUP,task);
            JobDataMap jdm = convertToJobDataMap(params);
            jobDetail.setJobDataMap(jdm);
            CronTrigger cronTrigger = new CronTrigger(jobName,DEFAULT_TRIGGER_GROUP);
            cronTrigger.setCronExpression(cronExpre);
            scheduler.scheduleJob(jobDetail, cronTrigger);
            if (!scheduler.isStarted()) {
                scheduler.start();
            }
        }
        return true;
    }

    @Override
    public boolean existsInScheduler(String jobName)
            throws Exception {

        Assert.notNull(jobName,"jobName can't be null!!");
        JobDetail jobDetail = scheduler.getJobDetail(jobName, DEFAULT_JOB_GROUP);
        return (null == jobDetail ? false:true);
    }

    @Override
    public String[] getAllJobNames() throws Exception {

        String[] jobNames = scheduler.getJobNames(DEFAULT_JOB_GROUP);

        return (null == jobNames?new String[0]:jobNames);
    }
    public void modifyJobTime(String jobName,String time,Map<String,Object> param) throws Exception{

        JobDetail jobDetail = scheduler.getJobDetail(jobName, DEFAULT_JOB_GROUP);
        if (null != jobDetail) {
             @SuppressWarnings("unchecked")
             Class<? extends Job> jobClass = jobDetail.getJobClass();
             JobDataMap jobDataMap = jobDetail.getJobDataMap();
             Map<String,Object> so = convertToMap(jobDataMap);
             if (null !=param && !param.isEmpty()){

                 so = param;
             }
             removeJobFromScheduler(jobName);
             schedule(jobName,jobClass,time,so);
        }
    }

    @Override
    public void removeJobFromScheduler(String jobName) throws Exception {

        scheduler.pauseTrigger(jobName,DEFAULT_TRIGGER_NAME);// 停止触发器
        scheduler.unscheduleJob(jobName, DEFAULT_TRIGGER_NAME);// 移除触发器
        scheduler.deleteJob(jobName, DEFAULT_JOB_GROUP);// 删除任务
    }

    /**
     * 将jobDataMap转换为map
     * @param jobDataMap
     * @return
     */
    private Map<String,Object> convertToMap(JobDataMap jobDataMap) {

        Map<String,Object> so = new HashMap<String,Object>();
        if (null != jobDataMap) {
            @SuppressWarnings("unchecked")
            Set<Map.Entry<String,Object>> keys = jobDataMap.entrySet();
            Iterator<Map.Entry<String,Object>> iterator = keys.iterator();
            while(iterator.hasNext()) {

                 Entry<String,Object> entry = iterator.next();
                 so.put(entry.getKey(),entry.getValue());
            }
        }
        return so;
    }
    /**
     * 将map转换为JobDataMap
     * @param so
     * @return
     */
    private JobDataMap convertToJobDataMap(Map<String,Object> so) {

        JobDataMap jdm = new JobDataMap();
        if (null != so) {

            Set<Map.Entry<String,Object>> keys = so.entrySet();
            Iterator<Map.Entry<String,Object>> iterator = keys.iterator();
            while(iterator.hasNext()) {

                 Entry<String,Object> entry = iterator.next();
                 jdm.put(entry.getKey(),entry.getValue());
            }
        }
        return jdm;
    }

    @Override
    public void modifyJobTime(String jobName, Long repeatInterval,
            Integer repeatCount, Map<String, Object> param) throws Exception {

        JobDetail jobDetail = scheduler.getJobDetail(jobName,DEFAULT_JOB_GROUP);
        if (null != jobDetail) {
             @SuppressWarnings("unchecked")
             Class<? extends Job> jobClass = jobDetail.getJobClass();
             JobDataMap jobDataMap = jobDetail.getJobDataMap();
             Map<String,Object> so = convertToMap(jobDataMap);
             if (null !=param && !param.isEmpty()){

                 so = param;
             }
             removeJobFromScheduler(jobName);
             schedule(jobName,jobClass,repeatInterval,repeatCount,so);
        }
    }
}