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...这里可以执行其他需要执行的任务  
    }

}