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

 

原创文章,作者:ItWorker,如若转载,请注明出处:https://blog.ytso.com/15792.html

(0)
上一篇 2021年7月19日
shasha 2018年12月11日 编程语言 592 0 编程语言
下一篇 2021年7月19日

相关推荐

发表回复

登录后才能评论