动态创建定时任务

import java.text.ParseException;

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.Trigger;
import org.quartz.impl.StdSchedulerFactory;
/**
 * <pre>
 *  动态创建定时任务
 * </pre>
 *
 * @author xueyunlong
 * @create 2013年12月9日 下午3:10:20
 * @modify
 * @since   JDK1.6
 */
public class QuartzManager {

    private static SchedulerFactory sf = new StdSchedulerFactory();
       private static String TRIGGER_GROUP_NAME = "trigger1";
     
      
       /**
        *  添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
        * @param jobName 任务名
        * @param job     任务
        * @param time    时间设置，参考quartz说明文档
        * @throws SchedulerException
        * @throws ParseException
        */
       public static void addJob(String jobName,Job job,String time)
                                   throws SchedulerException, ParseException{
           Scheduler sched = sf.getScheduler();
           JobDetail jobDetail = new JobDetail(jobName, Scheduler.DEFAULT_GROUP, job.getClass());//任务名，任务组，任务执行类
           //触发器
           CronTrigger  trigger =
                new CronTrigger(jobName, TRIGGER_GROUP_NAME);//触发器名,触发器组
           trigger.setCronExpression(time);//触发器时间设定
           sched.scheduleJob(jobDetail,trigger);
           //启动
           if(!sched.isShutdown())
              sched.start();
       }
      
      
       /**
        *  添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
        * @param jobName 任务名
        * @param job     任务
        * @param time    时间设置，参考quartz说明文档
        * @throws SchedulerException
        * @throws ParseException
        */
       public static void addJob(String jobName,Job job,String time,JobDetail jobDetail)
                                   throws SchedulerException, ParseException{
           Scheduler sched = sf.getScheduler();
           //触发器
           CronTrigger  trigger =
                new CronTrigger(jobName, TRIGGER_GROUP_NAME);//触发器名,触发器组
           trigger.setCronExpression(time);//触发器时间设定
           sched.scheduleJob(jobDetail,trigger);
           //启动
           if(!sched.isShutdown())
              sched.start();
       }
      
       /**
        * 添加一个定时任务
        * @param jobName 任务名
        * @param jobGroupName 任务组名
        * @param triggerName  触发器名
        * @param triggerGroupName 触发器组名
        * @param job     任务
        * @param time    时间设置，参考quartz说明文档
        * @throws SchedulerException
        * @throws ParseException
        */
       public static void addJob(String jobName,String jobGroupName,
                                 String triggerName,String triggerGroupName,
                                 Job job,String time)
                                   throws SchedulerException, ParseException{
           Scheduler sched = sf.getScheduler();
           JobDetail jobDetail = new JobDetail(jobName, jobGroupName, job.getClass());//任务名，任务组，任务执行类
           //触发器
           CronTrigger  trigger =
                new CronTrigger(triggerName, triggerGroupName);//触发器名,触发器组
           trigger.setCronExpression(time);//触发器时间设定
           sched.scheduleJob(jobDetail,trigger);
           if(!sched.isShutdown())
              sched.start();
       }
      
       /**
        * 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
        * @param jobName
        * @param time
        * @throws SchedulerException
        * @throws ParseException
        */
       public static void modifyJobTime(String jobName,String time)
                                      throws SchedulerException, ParseException{
           Scheduler sched = sf.getScheduler();
           Trigger trigger =  sched.getTrigger(jobName,TRIGGER_GROUP_NAME);
           if(trigger != null){
               CronTrigger  ct = (CronTrigger)trigger;
               ct.setCronExpression(time);
               sched.resumeTrigger(jobName,TRIGGER_GROUP_NAME);
           }
       }
      
       /**
        * 修改一个任务的触发时间
        * @param triggerName
        * @param triggerGroupName
        * @param time
        * @throws SchedulerException
        * @throws ParseException
        */
       public static void modifyJobTime(String triggerName,String triggerGroupName,
                                        String time)
                                      throws SchedulerException, ParseException{
           Scheduler sched = sf.getScheduler();
           Trigger trigger =  sched.getTrigger(triggerName,triggerGroupName);
           if(trigger != null){
               CronTrigger  ct = (CronTrigger)trigger;
               //修改时间
               ct.setCronExpression(time);
               //重启触发器
               sched.resumeTrigger(triggerName,triggerGroupName);
           }
       }
      
       /**
        * 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
        * @param jobName
        * @throws SchedulerException
        */
       public static void removeJob(String jobName)
                                   throws SchedulerException{
           Scheduler sched = sf.getScheduler();
           sched.pauseTrigger(jobName,TRIGGER_GROUP_NAME);//停止触发器
           sched.unscheduleJob(jobName,TRIGGER_GROUP_NAME);//移除触发器
           sched.deleteJob(jobName,Scheduler.DEFAULT_GROUP);//删除任务
       }
      
       /**
        * 移除一个任务
        * @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);//删除任务
       }
    }

测试类：

public class QuartzTest {
   
   public static void main(String[] args) {
       // TODO Auto-generated method stub
   ServerExceptionJob job = new ServerExceptionJob();
         String job_name ="11";
       try {
           JobDetail jobDetail = new JobDetail(job_name, Scheduler.DEFAULT_GROUP, TestJob.class);

         //传送数据
           jobDetail.getJobDataMap().put("ip", "127.0.0.1");
           jobDetail.getJobDataMap().put("port", "8010");
           jobDetail.getJobDataMap().put("commonDAO",
                                    commonDAO); // 注入commaonDao
           QuartzManager.addJob(job_name,job,"0 9/10 * * * ?",jobDetail);
          
//           Thread.sleep(10000);
//           System.out.println("【修改时间】");
//           QuartzManager.modifyJobTime(job_name,"0/10 * * * * ?");
//           Thread.sleep(20000);
//           System.out.println("【移除定时】");
//           QuartzManager.removeJob(job_name);
//           Thread.sleep(10000);
//          
//           System.out.println("\n【添加定时任务】");
//           QuartzManager.addJob(job_name,job,"0/5 * * * * ?");
          
       }  catch (Exception e) {
           e.printStackTrace();
       }
   }

 

 

/**
 * <pre>
 *  异常的服务，新的定时任务业务处理
 * </pre>
 *
 * @author xueyunlong
 * @create 2013年12月9日 下午3:18:16
 * @modify
 * @since JDK1.6
 */
public class ServerExceptionJob implements Job, StatefulJob {

    protected Log logger = LogFactory.getLog(getClass());

    @Override
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String ip = dataMap.get("ip").toString();
        String port = dataMap.get("port").toString();
        logger.info("新的定时任务开户执行 ip:" + ip + "端口：" + port);

       //获取注入的bean
        CommonDAO commonDAO = (CommonDAO) dataMap.get("commonDAO");

}

}