企业级任务调度框架Quartz(3) 一个简单的Quartz 例子

1. 一个简单的Quartz 工程
    本示例应用比起众所周知的 System.out.println("Hello world from Quartz") 来还是要有趣些。当我们用Quartz 执行一个作业时，总是希望它能为我们执行一些有趣且有意义的任务。因此，接下来我们就要做一些有趣且有用的事情。
本章向您演示如何创建这么一个 Quartz 作业，Quartz 应用通知它要做事情的时候，就会去扫描指定的目录寻找 XML 文件。
假如在指定目录中找到了一个或多个 XML 文件的话，它将会打印出文件的一些概要信息。
且这个作业每格10秒执行一次;（时间间隔可以随意设置，这里只是一个演示而已）
   a.先创建一个执行该操作的作业类
     创建一个 Quartz Job 类
       每一个 Quartz Job 必须有一个实现了 org.quartz.Job 接口的具体类。这个接口仅有一个要你在 Job 中实现的方法，execute()，方法 execute() 的原型如下：

public void execute(JobExecutionContext context) throws JobExecutionException;

    当Quartz 调度器确定到时间要激发一个 Job 的时候，它就会生成一个Job实例，并调用这个实例的 execute() 方法。任务调度器只管调用 execute() 方法，而不关心执行的结果，除了在作业执行中出问题抛出的 org.quartz.JobExecutionException 异常。它只负责作业的启动执行，而并不负责对执行任务的检核工作，如果出现运行异常，则将抛出指定的异常；

     你可以在 execute() 方法中执行你的业务逻辑：例如，也许你会调用其他构造的实例上的方法，发送一个电子邮件，FTP 传一个文件、调用一个 Web 服务、调用一个EJB、执行一个工作流，或者像我们的例子中那样，检查某个特定的目录下是否存在文件，等等；我们的这个小例子只是一个简单的文件扫描的动 作；

     job类的代码如下：

import java.io.File;
import java.io.FileFilter;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * 扫描文件的作业任务
 * @author liuwei
 */
public class ScanDirectoryJob extends SimpleJob {

static Log logger = LogFactory.getLog(ScanDirectoryJob.class);
       /**
        * 默认构造函数
          */
       public ScanDirectoryJob(){
       }

      /**
       * 作业执行的方法
        */
public void execute(JobExecutionContext context)throws JobExecutionException {
     /**
      * 每一个作业都有一个作业明细 当 Quartz 调用 execute() 方法，会传递一个
       * org.quartz.JobExecutionContext 上下文变量， 里面封装有 Quartz 的运
       * 行时环境和当前正执行的Job。通过 JobexecutionContext，你可以访问到调度
       *器的信息，作业和作业上的触发器的信息，还有更多更多的信息。
      *JobExecutionContext 被用来访问org.quartz.JobDetail类，
       * JobDetail类持有 Job的详细信息，包括为Job实例指定的名称，Job所属
       *组， Job 是否被持久化(易失性)，和许多其他感兴趣的属性。
      */
      JobDetail jobDetail =context.getJobDetail();
      if(jobDetail ==null){
         throw new RuntimeException("请检查当前作业配置是否完整！");
      }

      if(logger.isDebugEnabled()){
         logger.debug("作业任务名："+jobDetail.getName()+"准备开始！");
      }

      /**
       * JobDetail 又持有一个指向 org.quartz.JobDataMap 的引用。
        *JobDataMap 中有为指定 Job 配置的自定义属性。我们从 JobDataMap
       * 中获得欲扫描的目录名，我们可以在 ScanDirectoryJob
       * 中硬编码这个目录名，但是这样的话我们难以重用这个 Job 来扫描别的目录了
        * 对于JobDataMap，我们可以通过两种方式来初始化它的相关信息，一种是属于
        *编码的形式，另一种为采用配置的的形式来实现；
        */
      JobDataMap dataMap = jobDetail.getJobDataMap();
      if(dataMap ==null){
         throw new RuntimeException("请检查当前作业信息是否完整！");
      }

      /* 获得目录名称 */
    String dirName = dataMap.getString("SCAN_DIR");

      /*匹配条件*/
    String matchName=dataMap.getString("MATCH_NAME");
      /*提示异常，若作业执行的目录不存在 */
    if (dirName == null) {
     throw new JobExecutionException("Directory not configured");
    }

      /* 获得目录对象，并判断目录对象是否存在 */
    File dir = new File(dirName);
    if (!dir.exists()) {
      throw new JobExecutionException("Invalid Dir " + dirName);
    }

       /* 扫描目录的文件过滤器，,xml为扫描的匹配条件 */
    FileFilter filter = new FileExtensionFileFilter(matchName);
        /* 根据文件过滤器筛选出符合条件的文件集合 */
    File[] files = dir.listFiles(filter);

    if (files == null || files.length <= 0) {
      if(logger.isDebugEnabled()){
         logger.debug("扫描作业失败，请检查扫描目标有效性！");
      }
    }

    /* 结果的个数 */
          int size = files.length;
    for (int i = 0; i < size; i++) {
       File file = files[i];
       File aFile = file.getAbsoluteFile();
       long fileSize = file.length();
       String msg = aFile + " - Size: " + fileSize;
       if(logger.isDebugEnabled()){
        logger.debug("扫描符合条件的文件："+msg);
         }
     }
     if(logger.isDebugEnabled()){
      logger.debug("作业任务名："+jobDetail.getName()+"操作完毕！");
     }

      }
}

    
    3.创建我们自己的文件过滤器
      文件过滤器的作用是用来过滤符合条件的文件;

/**
 * 文件过滤器实现类
 * @author liuwei
 */
public class FileExtensionFileFilter implements FileFilter {

    /**
     * 文件后缀名
     */
    private String matchName;

    /**
     * 构造函数
     * @param matchName
     */
    public FileExtensionFileFilter(String matchName){
        this.matchName=matchName;
    }

    /**
     * 文件过滤器的主要实现方法
     */
  public boolean accept(File pathname) {
     if(pathname.isFile()&&pathname.getName().endsWith(matchName)){
        return true;
     }else{
    return false;
     }
   }
}

  
    c.任务调度器
     如何来让我们的作业运行？
     到目前为止，我们已经创建了一个 Quartz job，但还没有决定怎么处置它－－明显地，我们需以某种方式为这个 Job 设置一个运行时间表。时间表可以是一次性的事件，或者我们可能会安装它在除周日之外的每个午夜执行。

      你即刻将会看到，Quartz Schduler 是框架的心脏与灵魂。所有的 Job 都通过 Schduler 注册；必要时，Scheduler 也会创建 Job 类的实例，并执行实例的 execute() 方法。它就是每一个作业需要依赖于它的任务调度者，没有它的指令，作业类的存在是毫无意义的；
      Scheduler为任务调度器：
      Scheduler 会为每一次执行创建新的 Job 实例；Scheduler 在每次执行时都会为 Job 创建新的实例。这就意味着 Job 的任何实例变量在执行结束之后便会丢失。与此相反
概念则可用述语有状态的（J2EE世界里常见语）来表达，但是应用 Quartz  ，一个有状态的 Job 并不用多少开销，而且很容易的配置。当你创建一个有状态的 Job 时，有一些东西对于 Quartz 来说是独特的。最主要的就是不会出现两个有着相同状态的 Job 实例并发执行（这句话没有很好的理解！两个相同状态的job实例，这种情况很正常，并发执行所产生的影响会是执行后的状态信息无法同步）。这可能会影响到程序的伸缩性。但我们，我们可能会被一个持续上一个作业任务相关信息的内容所影响；
     创建一个自己的任务调度器，并将作业在上面进行注册;

 import java.util.Date;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.quartz.JobDataMap;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.Trigger;
 import org.quartz.TriggerUtils;
 import org.quartz.impl.StdSchedulerFactory;
/**
 * 一个简短的作业调度器
 * @author liuwei
 */
public class SimpleScheduler {
static Log logger = LogFactory.getLog(SimpleScheduler.class);
private Scheduler scheduler;
/**
 * 一个调度器的启动
 */
public void startScheduler() {
   try {
      LogUtil.print("运行任务开始");
      /*将扫描目录的作业job注册到作业调度器上*/
      this.registJobtoScheduler();
      // 启动任务调度器
       this.getScheduler().start();
      LogUtil.print("运行任务完毕");
    } catch (SchedulerException ex) {
      logger.error(ex);
    }
}

/**
 * 一个调度器的暂停操作
 * @param scheduler
 */
public void modifyScheduler(Scheduler scheduler) {
    try {
       //判断当前任务调度是否属于非暂停模式，如果属于的话，则可以进行暂停操作
      if (!scheduler.isInStandbyMode()) {
       //暂停调度器
        scheduler.standby();
       }
      scheduler.start();
    } catch (SchedulerException ex) {
      logger.error(ex);
    }
}
/**
 * 注册一个JOb到作业调度器
 * @throws SchedulerException
 * 注册一个作业到任务调度器上需要两个参数
 * a.作业明细对象
 * b.作业触发器对象
 */
public void registJobtoScheduler() throws SchedulerException{
    LogUtil.print("将作业注册到调度器上");
    Scheduler scheduler=this.getScheduler();
    String dirPath = "E:\重要";
    String matchName = ".rar";
    //创建一个作业明细对象 三个重要的属性 作业名称，作业所属组别，作业类
    JobDetail jobDetail = new JobDetail
    ("ScanDirectory",scheduler.DEFAULT_GROUP, ScanDirectoryJob.class);
    //创建一个作业数据Map对象 它继承于DirtyFlagMap ,该类又继承与map
    //所以该对象可以通过map的形式存储作业的相关属性信息
    JobDataMap jobDataMap=new JobDataMap();
    jobDataMap.put("SCAN_DIR", dirPath);
    jobDataMap.put("MATCH_NAME", matchName);
    jobDetail.setJobDataMap(jobDataMap);
    //创建一个触发器对象，该对象的作用是用来触发作业的执行
    Trigger trigger = TriggerUtils.makeSecondlyTrigger(10);
    trigger.setName("scanTrigger");
    trigger.setStartTime(new Date());
    //通过将作业明细作业数据结合注册到任务调度器上以实现对一个作业类的注册
    scheduler.scheduleJob(jobDetail, trigger);
}

private void setScheduler(Scheduler scheduler){
        this.scheduler=scheduler;
}
/**
 * 根据调度器工厂获得一个调度器
 * @return
 */
private Scheduler getScheduler(){
    Scheduler  scheduler=null;
    try {
   LogUtil.print("获取任务调度器实例");
   //根据调度器工厂获得一个任务调度器的实例
   scheduler = StdSchedulerFactory.getDefaultScheduler();
   }catch (SchedulerException ex) {
    logger.error(ex);
   }
    return scheduler;
 }
}

   d.启动任务调度器，并实现作业的执行/**

 * 启动一个已经在调度器上注册过的任务 有的要 Quartz 来执行的作业必须通过调度器来
 *  注册。 大多情况下，这会在调度器启动前做好; 因为每一个 Job
 * 都必须用 Scheduler 来注册，所以先定义一个 JobDetail， 并关联到这个
 * Scheduler 实例
 * @author liuwei
 */
public class StartJobBySchedler {
    static Log logger = LogFactory.getLog(StartJobBySchedler.class);

    /**
     * 启动任务调度器上的一个作业
      *
     * @param args
     */
    public static void main(String[] args) throws SchedulerException {
    /* 声明一个任务调度器 */
    SimpleScheduler2 simpleScheduler = new SimpleScheduler2();
    simpleScheduler.startScheduler();
   }
}

  
   e.执行结果如下
2009-02-06 00:57:38,156 [SimpleScheduler]-[DEBUG] 运行任务开始
2009-02-06 00:57:38,171 [SimpleScheduler]-[DEBUG] 将作业注册到调度器上
2009-02-06 00:57:38,171 [SimpleScheduler]-[DEBUG] 获取任务调度器实例
2009-02-06 00:57:38,421 [org.quartz.simpl.SimpleThreadPool]-[INFO] Job execution threads will use class loader of thread: main
2009-02-06 00:57:38,515 [org.quartz.core.SchedulerSignalerImpl]-[INFO] Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
2009-02-06 00:57:38,515 [org.quartz.core.QuartzScheduler]-[INFO] Quartz Scheduler v.1.6.4 created.
2009-02-06 00:57:38,546 [org.quartz.simpl.RAMJobStore]-[INFO] RAMJobStore initialized.
2009-02-06 00:57:38,562 [org.quartz.impl.StdSchedulerFactory]-[INFO] Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
2009-02-06 00:57:38,562 [org.quartz.impl.StdSchedulerFactory]-[INFO] Quartz scheduler version: 1.6.4
2009-02-06 00:57:38,687 [SimpleScheduler]-[DEBUG] 获取任务调度器实例
2009-02-06 00:57:38,703 [org.quartz.core.QuartzScheduler]-[INFO] Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
2009-02-06 00:57:38,703 [SimpleScheduler]-[DEBUG] 运行任务完毕
2009-02-06 00:57:38,703 [org.quartz.simpl.SimpleJobFactory]-[DEBUG] Producing instance of Job 'DEFAULT.ScanDirectory', class=ScanDirectoryJob
2009-02-06 00:57:38,718 [org.quartz.core.JobRunShell]-[DEBUG] Calling execute on job DEFAULT.ScanDirectory
2009-02-06 00:57:38,718 [ScanDirectoryJob]-[DEBUG] 作业任务名：ScanDirectory准备开始！
2009-02-06 00:57:38,718 [ScanDirectoryJob]-[DEBUG] ScanDirectory fired at Fri Feb 06 00:57:38 CST 2009
2009-02-06 00:57:38,718 [ScanDirectoryJob]-[DEBUG] Next fire time Fri Feb 06 00:57:48 CST 2009
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 扫描符合条件的文件：E:重要10月考核.rar - Size: 75058
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 扫描符合条件的文件：E:重要8月绩效.rar - Size: 86177
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 扫描符合条件的文件：E:重要贷中组5月考核.rar - Size: 77959
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 扫描符合条件的文件：E:重要贷中组6月考核.rar - Size: 32950
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 扫描符合条件的文件：E:重要贷中组7月考核.rar - Size: 32565
2009-02-06 00:57:38,781 [ScanDirectoryJob]-[DEBUG] 作业任务名：ScanDirectory操作完毕！

注意：
上面程序提供了一个理解如何编程式安排一个 Job 很好的例子。代码首先调用createScheduler() 方法从Scheduler 工厂获取一个 Scheduler 的实例。
得到 Scheduler 实例之后，把它传递给 registJobtoScheduler() 方法，
由它把 Job 同 Scheduler 进行关联。在这里我们并不是直接使用Job对象与
之关联;而是使用作业明细和作业数据map来实现的；

首先，创建了我们想要运行的 Job 的 JobDetail 对象。JobDetail 构造器的参数中包含指派给 Job 的名称，逻辑组名，和实现 org.quartz.Job
接口的全限类名称。我们可以使用 JobDetail 的别的构造器。

public JobDetail();
public JobDetail(String name, String group, Class jobClass);
public JobDetail(String name, String group, Class jobClass,boolean volatility, boolean durability, boolean recover);

一个 Job 在同一个 Scheduler 实例中通过名称和组名能唯一被标识。假如你增加两个具体相同名称和组名的 Job，程序会抛出 ObjectAlreadyExistsException 的异常。
在本章前面有说过，JobDetail 扮演着某一 Job 定义的角色。它带有 Job 实例的属性，能在运行时被所关联的 Job 访问到。其中在使用 JobDetail 时，的一个最重要的东西就是 JobDataMap，它被用来存放 Job 实例的状态和参数。上面的程序中待扫描的目录名称就是通过  scheduleJob() 方法存入到 JobDataMap 中的。

    触发器的作用
    Trigger 的责任就是触发一个 Job 去执行。当用 Scheduler 注册一个 Job 的时候要创建一个 Trigger 与这个 Job 相关联。Quartz 提供了四种类型的 Trigger，
但其中两种是最为常用的，它们就是在下面章节中要用到的 SimpleTrigger 和  CronTrigger.

SimpleTrigger 是两个之中简单的那个，它主要用来激发单事件的 Job，Trigger 在指定时间激发，并重复 n 次--两次激发时间之间的延时为 m，然后结束作业。我们上面的代码中通过TriggerUtils创建的触发器就是属于SimpleTrigger ；

CronTrigger 非常复杂且强大。它是基于通用的公历，当需要用一种较复杂的时间表去执行一个 Job 时用到。例如，四月至九月的每个星期一、星期三、或星期五的午夜。所以它才是我们实际应用正，最主要的作业执行的触发器

Trigger，Quartz 包含了一个工具类，org.quartz.TriggerUtils. TriggerUtils 提供了许多便捷的方法简化了构造和配置 trigger.

补充其它几个类：

LogUtil.java

import org.apache.log4j.Logger;

public class LogUtil {
    
    private static final Logger logger = Logger.getLogger(LogUtil.class);
    
    public static <T> void print(T t) {
        logger.info(t);
    }
}

SimpleJob.java

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public abstract class SimpleJob implements Job {
    
    public abstract void execute(JobExecutionContext context) throws JobExecutionException;  
}

log4j.properties

#log4j的简单配置，使用控制台做为输出目的地

log4j.rootLogger=DEBUG,A1,logfile
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n

log4j.appender.logfile=org.apache.log4j.RollingFileAppender
##log4j.appender.logfile.File=/logs/crawl.log
log4j.appender.logfile.File=E:/log4j_logs/ChaseQuartz.log
log4j.appender.logfile.MaxFileSize=512KB
# Keep three backup files.
log4j.appender.logfile.MaxBackupIndex=5
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

引入：jar包