任务调度quartz整理

一张图，了解quartz运行机制：

此图表示：Scheduler是容器，Trigger是多个触发器，jobDetail是多个任务，Calendar是多个日历。

jobDetail任务，需要指定类实现Job接口，并重写execute方法。并且Jobdetail初始化时需要指定任务执行的运行时类。

     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 {  

        }  

    }