Quartz的使用案例-阿里云开发者社区

一.介绍

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

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

void execute(JobExecutionContext context)

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

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

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

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

二.测试代码

1.测试代码一:

Hello.java

 1 import java.util.Date;
 2 
 3 import org.quartz.Job;
 4 import org.quartz.JobExecutionContext;
 5 import org.quartz.JobExecutionException;
 6 
 7 public class HelloJob implements Job {
 8     @Override
 9     public void execute(JobExecutionContext context) throws JobExecutionException {
10         System.out.println(String.format("Hello World! Time:%s", new Date()));
11     }
12 }

HelloWorldDeamo.java

 1 import org.quartz.JobBuilder;
 2 import org.quartz.JobDetail;
 3 import org.quartz.Scheduler;
 4 import org.quartz.SchedulerFactory;
 5 import org.quartz.SimpleScheduleBuilder;
 6 import org.quartz.Trigger;
 7 import org.quartz.TriggerBuilder;
 8 import org.quartz.impl.StdSchedulerFactory;
 9 
10 public class HelloWorldDemo {
11 
12     public static void main(String[] args) {
13         try {
14             // 通过schedulerFactory获取一个调度器
15             SchedulerFactory schedulerfactory = new StdSchedulerFactory();
16             // 通过schedulerFactory获取一个调度器
17             Scheduler scheduler = schedulerfactory.getScheduler();
18             // 创建jobDetail实例，绑定Job实现类
19             JobDetail jobDetail = JobBuilder.newJob(HelloJob.class).withIdentity("helloJob", "jobGroup1").build();
20             // 定义调度触发规则，本例中使用SimpleScheduleBuilder创建了一个5s执行一次的触发器
21             Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "triggerGroup1").startNow()
22                     .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
23                     .build();
24             // 把作业和触发器注册到任务调度中
25             scheduler.scheduleJob(jobDetail, trigger);
26             // 启动调度
27             scheduler.start();
28             // 60s后关闭
29             Thread.sleep(1000 * 30);
30             scheduler.shutdown();
31             System.out.println("调度任务结束");
32         } catch (Exception e) {
33             e.printStackTrace();
34         }
35     }
36 }

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

 1 import org.quartz.CronTrigger;
 2 import org.quartz.JobDetail;
 3 import org.quartz.Scheduler;
 4 import org.quartz.Trigger;
 5 import org.quartz.impl.StdSchedulerFactory;
 6 
 7 /**
 8  * 负责url调度
 9  * 每天凌晨向url仓库中添加入口url
10  */
11 public class UrlManager {
12     public static void main(String[] args){
13         try{
14             //获取默认调度器
15             Scheduler defaultScheduler = StdSchedulerFactory.getDefaultScheduler();
16             //开启调度器
17             defaultScheduler.start();
18             //任务  
19             JobDetail jobDetail = new JobDetail("url_job",Scheduler.DEFAULT_GROUP,UrlJob.class);
20             //触发时间 凌晨一点   前三个参数是 秒 分 时
21             Trigger trigger = new CronTrigger("url_job", Scheduler.DEFAULT_GROUP,"0 0 1 * * ?");
22             //添加调度任务和触发时间
23             defaultScheduler.scheduleJob(jobDetail,trigger);
24             
25         }catch (Exception e){
26             e.printStackTrace();
27         }
28     }
29 }

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

QuartzUtil.java

 1 import org.quartz.Job;
 2 import org.quartz.JobBuilder;
 3 import org.quartz.JobDetail;
 4 import org.quartz.Scheduler;
 5 import org.quartz.SchedulerException;
 6 import org.quartz.SchedulerFactory;
 7 import org.quartz.SimpleScheduleBuilder;
 8 import org.quartz.Trigger;
 9 import org.quartz.TriggerBuilder;
10 import org.quartz.impl.StdSchedulerFactory;
11 import org.slf4j.Logger;
12 import org.slf4j.LoggerFactory;
13 
14 /**
15  * 任务调度公共类
16  */
17 public class QuartzUtil {
18 
19     private final static String JOB_GROUP_NAME = "QUARTZ_JOBGROUP_NAME";//任务组
20     private final static String TRIGGER_GROUP_NAME = "QUARTZ_TRIGGERGROUP_NAME";//触发器组
21     private static Logger log = LoggerFactory.getLogger(QuartzUtil.class);//日志
22 
23     /**
24      * 添加任务的方法
25      * @param jobName  任务名
26      * @param triggerName  触发器名
27      * @param jobClass  执行任务的类
28      * @param seconds  间隔时间
29      * @throws SchedulerException
30      */
31     public static void addJob(String jobName,String triggerName,Class<? extends Job> jobClass,int seconds) throws SchedulerException{
32         log.info("==================initialization=================");
33         //创建一个SchedulerFactory工厂实例
34         SchedulerFactory sf = new StdSchedulerFactory();
35         //通过SchedulerFactory构建Scheduler对象 
36         Scheduler sche = sf.getScheduler();
37         log.info("===================initialize finshed===================");
38 
39         log.info("==============add the Job to Scheduler==================");  
40 
41         //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
42         JobDetail jobDetail = JobBuilder.newJob(jobClass)
43                                 .withIdentity(jobName, JOB_GROUP_NAME)
44                                 .build();
45         //构建一个触发器，规定触发的规则
46         Trigger trigger = TriggerBuilder.newTrigger()//创建一个新的TriggerBuilder来规范一个触发器
47                             .withIdentity(triggerName, TRIGGER_GROUP_NAME)//给触发器起一个名字和组名
48                             .startNow()//立即执行
49                             .withSchedule(
50                                 SimpleScheduleBuilder.simpleSchedule()
51                                 .withIntervalInSeconds(seconds)//时间间隔  单位：秒
52                                 .repeatForever()//一直执行
53                             )
54                             .build();//产生触发器
55         //向Scheduler中添加job任务和trigger触发器
56         sche.scheduleJob(jobDetail, trigger);
57         //启动
58         sche.start();
59     }
60 
61     /**
62      * 测试
63      * @param args
64      */
65     public static void main(String[] args) {
66         try {
67             //添加第一个任务  每隔10秒执行一次
68             QuartzUtil.addJob("job1", "trigger1", TestJobOne.class, 2);
69 
70             //添加第二个任务  每隔20秒执行一次
71             QuartzUtil.addJob("Job2", "trigger2", TestJobTwo.class, 5);
72         } catch (SchedulerException e) {
73             e.printStackTrace();
74         }
75     }
76 }

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

}