quartz 添加任务调度

package com.lec.util.job;  
  
import java.text.ParseException;  
import java.util.Date;  
import java.util.HashMap;  
import org.quartz.CronTrigger;  
import org.quartz.Job;  
import org.quartz.JobDetail;  
import org.quartz.Scheduler;  
import org.quartz.SchedulerException;  
import org.quartz.SchedulerFactory;  
import org.quartz.SimpleTrigger;  
import org.quartz.Trigger;  
import org.quartz.impl.StdSchedulerFactory;  
  
import com.lec.assurance.utils.StringHandler;  
  
/** 
 * CronTrigger任务调度器 
 * @author lcy 
 *  Dec 1, 2011 
 */  
public class CronTriggerRunner {  
    private static SchedulerFactory sf = new StdSchedulerFactory();  
      
      
      
    /** 
     * 根据任务名和任务组名查询一个任务 
     * @param jobName 
     * @param jobGroupName 
     * @return 
     * @throws SchedulerException 
     */  
    public static JobDetail getJob(String jobName,String jobGroupName) throws SchedulerException{  
        Scheduler sched = sf.getScheduler();  
        JobDetail jobDetail=sched.getJobDetail(jobName, jobGroupName);  
        if(jobDetail != null){  
            return jobDetail;  
        }  
        return null;  
    }  
         
    /** 
    * 添加一个CronTrigger定时任务 
    * @param jobName 任务名 
    * @param jobGroupName 任务组名 
    * @param triggerName 触发器名 
    * @param triggerGroupName 触发器组名 
    * @param job     任务 
    * @param time    时间设置，参考quartz说明文档 
    * @param params 传递参数 
    * @throws SchedulerException 
    * @throws ParseException  
    */  
    public static void addJob(String jobName,String jobGroupName,String triggerName,  
            String triggerGroupName,String time,HashMap<String,Object> params,  
            Job jobClass) throws SchedulerException, ParseException{  
       Scheduler sched = sf.getScheduler();  
       JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass.getClass());//任务名，任务组，任务执行类  
       if(params != null){  
              jobDetail.getJobDataMap().put("params",params);  
          }  
       //触发器  
       CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);//触发器名,触发器组  
       trigger.setCronExpression(time);//触发器时间设定  
       sched.scheduleJob(jobDetail,trigger);  
       if(!sched.isShutdown())  
           sched.start();  
    }  
      
    /** 
     * 添加一个SimpleTrigger定时任务 
     * @param jobName 任务名 
     * @param jobGroupName 任务组名 
     * @param triggerName 触发器名 
     * @param triggerGroupName 触发器组名 
     * @param startTime 开始时间 
     * @param repeatInterval 间隔时间 
     * @param repeatCount 调用次数 
     * @param jobClass 任务 
     * @param params 传递参数 
     * @throws SchedulerException 
     */  
    public static void addJob(String  jobName,String  jobGroup,  
            String  triggerName,String  triggerGroup,Date startTime,  
            Integer repeatInterval,Integer repeatCount,Job jobClass,  
            HashMap<String,Object> params) throws   
            SchedulerException{  
        JobDetail jobDetail = new JobDetail(jobName, jobGroup, jobClass.getClass());  
        if(params != null){  
             jobDetail.getJobDataMap().put("params",params);  
         }  
        //触发器  
        SimpleTrigger simpleTrigger = new SimpleTrigger(triggerName, triggerGroup);  
        //设置开始时间  
        simpleTrigger.setStartTime(startTime);  
        //设置间隔时间  
        simpleTrigger.setRepeatInterval(repeatInterval);  
        //设置调用次数  
        simpleTrigger.setRepeatCount(repeatCount);  
          
        Scheduler sched = sf.getScheduler();  
        sched.scheduleJob(jobDetail,simpleTrigger);  
        if(!sched.isShutdown())  
           sched.start();  
    }  
         
    /**  
    * 根据任务名和任务组名修改任务的触发时间 
    * @param jobName 任务名 
    * @param jobGroupName 任务组名 
    * @param time 
    * @throws SchedulerException 
    * @throws ParseException 
    */  
    public static void modifyJobTime(String jobName,String jobGroupName,String time)   
            throws SchedulerException, ParseException{  
        Scheduler sched = sf.getScheduler();  
        Trigger[] trigger = sched.getTriggersOfJob(jobName,jobGroupName);  
        if(trigger != null){  
            for(int i=0;i<trigger.length;i++){  
                ((CronTrigger)trigger[i]).setCronExpression(time);  
                sched.resumeTrigger(trigger[i].getName(),trigger[i].getGroup());  
            }  
        }  
    }  
         
    /** 
    * 根据触发器名修改一个任务的触发时间 
    * @param triggerName触发器名 
    * @param triggerGroupName触发器组名 
    * @param time 
    * @throws SchedulerException 
    * @throws ParseException 
    */  
    public static void modifyTriggerTime(String triggerName,String triggerGroupName,  
                 String time)  throws SchedulerException, ParseException{  
        Scheduler sched = sf.getScheduler();  
        Trigger trigger = sched.getTrigger(triggerName,triggerGroupName);  
        if(trigger != null){  
            //修改时间  
            ((CronTrigger)trigger).setCronExpression(time);  
           //重启触发器  
           sched.resumeTrigger(triggerName,triggerGroupName);  
       }  
    }  
      
    /** 
    * 移除任务 
    * @param jobName任务名 
    * @param jobGroupName任务组名 
    * @param triggerGroupName触发器组名 
    * @throws SchedulerException 
    */  
    public static void removeJob(String jobName,String jobGroupName,String triggerGroupName)   
            throws SchedulerException{  
      Scheduler sched = sf.getScheduler();  
      String[] triggerNames = sched.getTriggerNames(triggerGroupName);  
      if(triggerNames!=null){  
          for(int i=0;i<triggerNames.length;i++){  
              sched.pauseTrigger(triggerNames[i],triggerGroupName);//停止触发器  
              sched.unscheduleJob(triggerNames[i],triggerGroupName);//移除触发器   
          }  
      }  
      sched.deleteJob(jobName,jobGroupName);//删除任务  
    }  
         
    /** 
    * 移除一个任务 
    * @param jobName任务名 
    * @param jobGroupName任务组名 
    * @param triggerName触发器名 
    * @param triggerGroupName触发器组名 
    * @throws SchedulerException 
    */  
    public static void removeJob(String jobName,String jobGroupName,  
            String triggerName,String triggerGroupName)   
            throws SchedulerException{  
      Scheduler sched = sf.getScheduler();  
      sched.pauseTrigger(triggerName,triggerGroupName);//停止触发器  
      sched.unscheduleJob(triggerName,triggerGroupName);//移除触发器  
      sched.deleteJob(jobName,jobGroupName);//删除任务  
    }  
      
    /** 
     * 停止一个任务 需要注意的是：这里停止的job必须是实现InterruptableJob的 
     * @param jobName 
     * @param jobGroupName 
     * @throws SchedulerException 
     */  
    public static void stopJob(String jobName,String jobGroupName) throws SchedulerException {  
          Scheduler sched = sf.getScheduler();  
          sched.interrupt(jobName, jobGroupName);  
    }  
      
    /** 
     * 计算时间表达式 
     * @param second        秒 
     * @param minute        分 
     * @param hour          时 
     * @param day           日期 
     * @param month         月份 
     * @param week          星期 
     * @param year          年份 
     * @param isContactYear 是否包括年份 
     * @return 
     */  
    public static String getCexpress(String second,String minute,String hour,  
            String day,String month,String week,String year,boolean isContactYear) {  
        String cexpress="";  
        //秒，默认为"0" 取值范围：0-59  
        if(StringHandler.isValidStr(second)){  
            cexpress+=Integer.parseInt(second)+" ";  
        }else{  
            cexpress+="0 ";  
        }  
          
        /** 
         * 分 取值范围：0-59 
         * 默认为"*"      表示每一分钟 
         * 如果是0 12     表示整12:00触发 
         * 如果是0/5 12   表示在每天下午12点到12:55期间的每5分钟触发 ， 
         * 如果是0-5 12   表示12:00到12:05期间的每1分钟触发 
         * 如果是10,15 12 表示12:10和12:15触发 
         */  
        if(StringHandler.isValidStr(minute)){  
            cexpress+=minute+" ";  
        }else{  
            cexpress+="* ";  
        }  
          
        /** 
         * 小时 取值范围：0-23 
         * 默认为"*"      表示每一个小时 
         * 如果是0        表示凌晨触发 
         * 如果是0-5        表示凌晨到5:00期间 
         * 如果是10,15    表示10:00和15:00触发 
         */  
        if(StringHandler.isValidStr(hour)){  
            cexpress+=hour+" ";  
        }else{  
            cexpress+="* ";  
        }  
          
        /** 
         * 日期 取值范围：1-31 
         * 默认为"*" 表示每天 
         * 如果是15  表示每个月的15号 
         * 如果是L   表示每个月最后一天  
         * 注：在指定了星期的时候，把日期这里设置为"?" 
         */  
        if(StringHandler.isValidStr(day)){  
            cexpress+=day+" ";  
        }else{  
            cexpress+="* ";  
        }  
          
        /** 
         * 月份 取值范围：1-12 
         * 默认为"*"  表示每个月 
         * 如果是 12  表示12月份 
         */  
        if(StringHandler.isValidStr(month)){  
            cexpress+=month+" ";  
        }else{  
            cexpress+="* ";  
        }  
          
        /** 
         * 星期  取值范围：1-7 MON,TUE,WED,THU,FRI,SAT,SUN  其中1表示星期日，以此类推 
         * 默认为"?" 
         * 如果是WED      表示每个星期三 
         * 如果是MON-FRI  表示星期一到星期五 
         * 如果是6L       表示每月最后一个星期五 
         * 如果是6#3      表示每月第三个星期五 
         */  
        if(StringHandler.isValidStr(week)){  
            cexpress+=week+" ";  
        }else{  
            cexpress+="? ";  
        }  
          
        //如果包括年份  
        if(isContactYear){  
            /** 
             * 年份  取值范围：1970-2099 
             * 默认值为空 
             * 如果是2010 表示只有2010年触发时间 
             * 如果是2010,2020 表示只有2010 
             */  
            if(StringHandler.isValidStr(year)){  
                cexpress+=year;   
            }  
        }  
          
        return cexpress;  
    }  
  
    public static void main(String [] args){  
        try {  
            /*--------------------创建一个指定时间执行的job-----------------------*/  
            JobDetail jobDetail = new JobDetail("fundsrecord_jobname_folkholdersId1",   
                    "fundsrecord_jobgroupname_folkholdersId1",FundsrecordJob.class);  
            // ①-1：创建CronTrigger，指定组及名称  
            CronTrigger cronTrigger = new CronTrigger("fundsrecord_triggername_folkholdersId1",  
                    "fundsrecord_triggergroupname_folkholdersId1");  
            // ①-2：定义Cron表达式  
            String timeexp = "";  
            String second = "0";  
            String minute = "15";  
            String hour = "0";  
            String day = "L";//当月的最后一天  
            String month = "";  
            String week = "?";  
            month = "6,12";  
            timeexp = getCexpress(second, minute, hour, day, month, week, null, false);  
              
            if(!"0 * * * * ?".equals(timeexp)){//如果没有设置时间则不执行  
                CronExpression cexp = new CronExpression(timeexp);  
                // ①-3：设置Cron表达式  
                cronTrigger.setCronExpression(cexp);  
                Scheduler scheduler = sf.getScheduler();  
                scheduler.scheduleJob(jobDetail, cronTrigger);  
                scheduler.start();  
            }  
              
              
            /*--------------------创建一个间隔一定时间执行的job-----------------------*/  
            String jobName = "fundsrecord_jobname_folkholdersId2";  
            String jobGroupName = "fundsrecord_jobgroupname_folkholdersId2";  
            String triggerName = "fundsrecord_triggername_folkholdersId2";  
            String triggerGroupName = "fundsrecord_triggergroupname_folkholdersId2";  
            Date beginTime = new Date(System.currentTimeMillis() + 60000L);//当前时间过60秒钟后开始  
            Integer repeatInterval = 5000;//以毫秒为单位  
            Integer repeatCount = 0;  
            HashMap<String, Object> map = new HashMap<String,Object>();  
            map.put("folkholdersId", "2");  
            try {  
                CronTriggerRunner.addJob(jobName,jobGroupName,triggerName,  
                        triggerGroupName,beginTime,repeatInterval,  
                        repeatCount,new FundsrecordJob(),map);  
            } catch (SchedulerException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
       } catch (Exception e) {  
           e.printStackTrace();  
       }  
    }  
      
      
}  

 

package com.lec.util.job;  
  
import java.util.HashMap;  
  
import org.quartz.InterruptableJob;  
import org.quartz.JobDataMap;  
import org.quartz.JobExecutionContext;  
import org.quartz.JobExecutionException;  
import org.quartz.SchedulerException;  
import org.quartz.UnableToInterruptJobException;  
  
/** 
 * 任务调度器 
 * @author lcy 
 *  May 24, 2011 
 */  
public class FundsrecordJob implements InterruptableJob {  
  
    @Override  
    public void execute(JobExecutionContext context) throws JobExecutionException {  
        JobDataMap map = context.getMergedJobDataMap();  
        Object obj = map.get("params");  
        if(obj != null ){  
            HashMap<String,Object> params = (HashMap<String,Object>)obj;  
            dojob();//在这个任务调度器里面需要执行的方法  
            Long folkholdersId = Long.parseLong((String)params.get("folkholdersId"));  
            try {  
                CronTriggerRunner.stopJob("fundsrecord_jobname_folkholdersId"+folkholdersId,  
                        "fundsrecord_jobgroupname_folkholdersId"+folkholdersId);//停止本次job  
            } catch (SchedulerException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            }  
              
        }  
    }  
    public void interrupt() throws UnableToInterruptJobException {  
          
    }  
  
}