Quartz的使用案例

一.介绍

项目中的调度任务可以使用Quartz任务调度框架

1、Job接口：这个接口里面只定义了一个方法,excute

void execute(JobExecutionContext context)  

然后定义一个类实现该接口，就可以定义自己需要执行的任务了，JobExecutionContext类提供调度上下文的各种信息

2、JobDetail：用于描叙Job实现类及其他的一些静态信息

3、Trigger：描叙触发Job执行的时间触发规则

4、Scheduler：运行容器，使用SchedulerFactory创建Scheduler实例

二.测试代码

1.测试代码一:

Hello.java

 import java.util.Date;

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

 public class HelloJob implements Job {
     @Override
     public void execute(JobExecutionContext context) throws JobExecutionException {
         System.out.println(String.format("Hello World! Time:%s", new Date()));
     }
 }

HelloWorldDeamo.java

 import org.quartz.JobBuilder;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerFactory;
 import org.quartz.SimpleScheduleBuilder;
 import org.quartz.Trigger;
 import org.quartz.TriggerBuilder;
 import org.quartz.impl.StdSchedulerFactory;

 public class HelloWorldDemo {

     public static void main(String[] args) {
         try {
             // 通过schedulerFactory获取一个调度器
             SchedulerFactory schedulerfactory = new StdSchedulerFactory();
             // 通过schedulerFactory获取一个调度器
             Scheduler scheduler = schedulerfactory.getScheduler();
             // 创建jobDetail实例，绑定Job实现类
             JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJob", "jobGroup1").build();
             // 定义调度触发规则，本例中使用SimpleScheduleBuilder创建了一个5s执行一次的触发器
             Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "triggerGroup1").startNow()
                     .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
                     .build();
             // 把作业和触发器注册到任务调度中
             scheduler.scheduleJob(jobDetail, trigger);
             // 启动调度
             scheduler.start();
             // 60s后关闭
             Thread.sleep(1000 * 30);
             scheduler.shutdown();
             System.out.println("调度任务结束");
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

2.另外一个程序(定义触发器和获得调取器和上面有所不同):

 import org.quartz.CronTrigger;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.Trigger;
 import org.quartz.impl.StdSchedulerFactory;

 /**
  * 负责url调度
  * 每天凌晨向url仓库中添加入口url
  */
 public class UrlManager {
     public static void main(String[] args){
         try{
             //获取默认调度器
             Scheduler defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
             //开启调度器
             defaultScheduler.start();
             //任务
             JobDetail jobDetail = new JobDetail("url_job",Scheduler.DEFAULT_GROUP,UrlJob.class);
             //触发时间 凌晨一点   前三个参数是 秒 分 时
             Trigger trigger = new CronTrigger("url_job", Scheduler.DEFAULT_GROUP,"0 0 1 * * ?");
             //添加调度任务和触发时间
             defaultScheduler.scheduleJob(jobDetail,trigger);

         }catch (Exception e){
             e.printStackTrace();
         }
     }
 }

3.测试代码二(对调度封装)

QuartzUtil.java

 import org.quartz.Job;
 import org.quartz.JobBuilder;
 import org.quartz.JobDetail;
 import org.quartz.Scheduler;
 import org.quartz.SchedulerException;
 import org.quartz.SchedulerFactory;
 import org.quartz.SimpleScheduleBuilder;
 import org.quartz.Trigger;
 import org.quartz.TriggerBuilder;
 import org.quartz.impl.StdSchedulerFactory;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 /**
  * 任务调度公共类
  */
 public class QuartzUtil {

     private final static String JOB_GROUP_NAME = "QUARTZ_JOBGROUP_NAME";//任务组
     private final static String TRIGGER_GROUP_NAME = "QUARTZ_TRIGGERGROUP_NAME";//触发器组
     private static Logger log = LoggerFactory.getLogger(QuartzUtil.class);//日志

     /**
      * 添加任务的方法
      * @param jobName  任务名
      * @param triggerName  触发器名
      * @param jobClass  执行任务的类
      * @param seconds  间隔时间
      * @throws SchedulerException
      */
     public static void addJob(String jobName,String triggerName,Class<? extends Job> jobClass,int seconds) throws SchedulerException{
         log.info("==================initialization=================");
         //创建一个SchedulerFactory工厂实例
         SchedulerFactory sf = new StdSchedulerFactory();
         //通过SchedulerFactory构建Scheduler对象
         Scheduler sche = sf.getScheduler();
         log.info("===================initialize finshed===================");

         log.info("==============add the Job to Scheduler==================");  

         //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
         JobDetail jobDetail = JobBuilder.newJob(jobClass)
                                 .withIdentity(jobName, JOB_GROUP_NAME)
                                 .build();
         //构建一个触发器，规定触发的规则
         Trigger trigger = TriggerBuilder.newTrigger()//创建一个新的TriggerBuilder来规范一个触发器
                             .withIdentity(triggerName, TRIGGER_GROUP_NAME)//给触发器起一个名字和组名
                             .startNow()//立即执行
                             .withSchedule(
                                 SimpleScheduleBuilder.simpleSchedule()
                                 .withIntervalInSeconds(seconds)//时间间隔  单位：秒
                                 .repeatForever()//一直执行
                             )
                             .build();//产生触发器
         //向Scheduler中添加job任务和trigger触发器
         sche.scheduleJob(jobDetail, trigger);
         //启动
         sche.start();
     }

     /**
      * 测试
      * @param args
      */
     public static void main(String[] args) {
         try {
             //添加第一个任务  每隔10秒执行一次
             QuartzUtil.addJob("job1", "trigger1", TestJobOne.class, 2);

             //添加第二个任务  每隔20秒执行一次
             QuartzUtil.addJob("Job2", "trigger2", TestJobTwo.class, 5);
         } catch (SchedulerException e) {
             e.printStackTrace();
         }
     }
 }

TestJobOne.java

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * 实际执行任务的业务类,需要实现Job接口
 */
public class TestJobOne implements Job {
    /**
     * 执行任务的方法
     */
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("================执行任务一....");
        //do more...这里可以执行其他需要执行的任务
    }
}

TestJobTwo.java

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * 实际执行任务的业务类,需要实现Job接口
 */
public class TestJobTwo implements Job {
    /**
     * 执行任务的方法
     */
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("================执行任务二....");
        //do more...这里可以执行其他需要执行的任务
    }

}