Quartz定时任务框架学习总结

首先关于Quartz的一篇详细介绍的文章可以参考我博客中的一篇关于介绍该框架的文章。

 

 

我做的该项目是一个网站预警系统，通过自己定义一个抽象类，采用策略模式，然后相关的监控子程序继承该类，配置配置文件的方式集成到预警系统中。

 

首先我通过我的主客户端程序的例子来解释Quartz来介绍我常用到的API

注释：QUARTZ中首先是一个组对应多个trigger

package client;

import org.dom4j.Document;
import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

import com.util.DataUtil;
import com.util.Log;
import com.util.PrintUtil;
import com.util.XmlHandle;

public class Client {

 /**
  * @param args
  */
 public static XmlHandle xmlHandle = XmlHandle.getInstance();
 public static Document document ;
 
 public static String TRIGGER_GROUP="JOBCN_GROUP_MAIL";//我自己制定的组名称，指定名称
 public static void main(String[] args) {
  document = xmlHandle.getXmlFromFile("conf\\alarm-config.xml");
  try {
    String reload = xmlHandle.getSingleXmlData(document,"/conf","reload");
    
    SchedulerFactory schedulerFactory = new StdSchedulerFactory();
    Scheduler scheduler = schedulerFactory.getScheduler();
    if("".equals(reload)||reload==null||"true".equals(reload))
    {
     
    }
    //如果重启Client端，那么首先将所有的任务队列全部删除，然后重新组装CLIENT端
    String[] triggerGroups = scheduler.getTriggerGroupNames();//该方法是得到所有的组名称
    for (int i = 0; i < triggerGroups.length; i++) {
      String[] triggers = scheduler.getTriggerNames(triggerGroups[i]);//该方法是得到该组里面所有的trigger
      for (int j = 0; j < triggers.length; j++) {

       Trigger tg = scheduler.getTrigger(triggers[j],
         triggerGroups[i]);
       
       if (tg instanceof CronTrigger)
       {
        //System.out.println(tg.getFullName()+":"+TRIGGER_GROUP+"."+"CronTrigger_"+bean.getClassName());
        //System.out.println(tg.getJobName()+":"+tg.getJobGroup());
        scheduler.deleteJob(tg.getJobName(), tg.getJobGroup());//该方法是删除指定的任务，传入的是trigger的名字和组名
        
       }
      }
    }
    
    JobDetail jobDetail = new JobDetail("JOB_MAIL", "Group_MAIL",AlarmClient.class);
    //①-1：创建CronTrigger，指定组及名称 

   JobDataMap dataMap = new JobDataMap();
     dataMap.put("bean", bean);//我们可以将我们要传入的某个类通过JobDataMap的载体传到对应的job中
     jobDetail.setJobDataMap(dataMap);
    CronTrigger cronTrigger = new CronTrigger("CronTrigger_MAIL",TRIGGER_GROUP);
    CronExpression cexp = new CronExpression("0/30 * * * * ?");//①-2：定义Cron表达式
    cronTrigger.setCronExpression(cexp);//①-3：设置Cron表达式
    scheduler.scheduleJob(jobDetail, cronTrigger);//④ 注册并进行调度
    scheduler.start();
   
  
 } catch (Exception e) {
  //e.printStackTrace();
 }

 }

}

具体任务类的定义，只注明主体方法：

public void execute(JobExecutionContext jobCtx) throws JobExecutionException {

  //我们制定一个具体的任务，必须实现execute方法，该方法传入一个job的上下文，通过下面的代码来得到保存在datamap中的数据，注意，如果要通过载体传输的数据一定要实现Serializable接口

例如：我们传的 public class AlarmBean implements Serializable
  JobDetail jobDetail =jobCtx.getJobDetail();  

  JobDataMap dataMap = jobDetail.getJobDataMap();  

  this.bean = getBean(dataMap);
  
  System.out.println("Test:"+bean.getMailHost());
 }

 

public AlarmBean getBean(Map map)
 {
  AlarmBean beans = null;
  Iterator it = map.entrySet().iterator();
     while(it.hasNext())
     {
       try {
     Map.Entry m = (Map.Entry) it.next();
     beans = (AlarmBean) m.getValue();
    } catch (Exception e) {
     e.printStackTrace();
    }
     }
   return beans;
 }

 

 

 

 

 

 

Quartz中SimpleTrigger的探讨

让我们继续用第一个例子中StringTest.
1.来写一个每隔10秒启动一次任务的例子.

import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

public class SimpleTriggerTest
{

    public static void main(String[] args) throws Exception
    {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 系统当前时间10秒后
        long startTime = System.currentTimeMillis() + 10000L;
        SimpleTrigger trigger = new SimpleTrigger("myTrigger", null, new Date(
                startTime), null, 0, 0L);

        JobDetail jobDetail = new JobDetail();
        jobDetail.setJobClass(StringTest.class);
        jobDetail.setName("test");
        jobDetail.setGroup("A");

        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();
    }
}

2.创建一个触发器,立即启动,每隔60秒,启动一次.

SimpleTrigger trigger = new SimpleTrigger("myTrigger",
                                            null,
                                            new Date(),
                                            null,
                                            SimpleTrigger.REPEAT_INDEFINITELY,
                                            60L * 1000L);

3.创建一个触发器,立即启动.从现在开始的第10秒到第40秒重复运行.

long endTime = System.currentTimeMillis() + 40000L;

  SimpleTrigger trigger = new SimpleTrigger("myTrigger",
                                            "myGroup",
                                            new Date(),
                                            new Date(endTime),
                                            SimpleTrigger.REPEAT_INDEFINITELY,
                                            10L * 1000L);

4.创建一个触发器,在2008年5月9日,上午10点半执行,重复5次,每隔30秒一次.

java.util.Calendar cal = new java.util.GregorianCalendar(2008, cal.MARCH, 9);
  cal.set(cal.HOUR, 10);
  cal.set(cal.MINUTE, 30);
  cal.set(cal.SECOND, 0);
  cal.set(cal.MILLISECOND, 0);

  Data startTime = cal.getTime()

  SimpleTrigger trigger = new SimpleTrigger("myTrigger",
                                            null,
                                            startTime,
                                            null,
                                            5,
                                            30L * 1000L);

仔细体会SimpleTrigger的例子,你会发现用这个制作执行计划会更简单方便.