使用quartz.jar 、quartz-jobs.jar 实现定时任务。实现定时采集接口数据

本文主要是介绍使用quartz.jar 、quartz-jobs.jar 实现定时任务。实现定时采集接口数据，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

　　定时任务管理，在java中有很多种的方式，有java自带的注解方式@Scheduled 等，现在我要说的是一种也是使用比较广泛的一种quartz管理
　　使用此类需要的加jar包有 quartz.jar 、quartz-jobs.jar （我这里用的版本是2.2.1），log4j-1.2.17.jar，slf4j-api-1.7.21.jar，slf4j-log4j12-1.7.21.jar (都是必须要的包)

　　也可以通过maven管理，只需引入一个quartz包即可，如下：
　　tip:在使用log4j版本时使用此版本 org.slf4j.Logger; org.slf4j.LoggerFactory;

<dependency>
　　<groupId>org.quartz-scheduler</groupId>
　　<artifactId>quartz</artifactId>
　　<version>2.2.1</version>
　　</dependency>

首先-创建一个quartz管理类，这个类中添加各种情况下可使用的那些调用方法

  1 public class QuartzManager {  
  2     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();  //创建一个SchedulerFactory工厂实例
  3     private static String JOB_GROUP_NAME = "FH_JOBGROUP_NAME";                      //任务组
  4     private static String TRIGGER_GROUP_NAME = "FH_TRIGGERGROUP_NAME";              //触发器组
  5   
  6     /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  
  7      * @param jobName 任务名
  8      * @param cls 任务
  9      * @param time 时间设置，参考quartz说明文档
 10      */
 11     public static void addJob(String jobName, Class<? extends Job> cls, String time) {  
 12         try {  
 13             Scheduler sched = gSchedulerFactory.getScheduler();                                          //通过SchedulerFactory构建Scheduler对象
 14             JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();    //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
 15             CronTrigger trigger = (CronTrigger) TriggerBuilder
 16                     .newTrigger()                                                                         //创建一个新的TriggerBuilder来规范一个触发器
 17                     .withIdentity(jobName, TRIGGER_GROUP_NAME)                                            //给触发器起一个名字和组名
 18                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
 19                     .build();
 20             sched.scheduleJob(jobDetail, trigger);  
 21             if (!sched.isShutdown()) {  
 22                 sched.start();        // 启动  
 23             }  
 24         } catch (Exception e) {  
 25             throw new RuntimeException(e);  
 26         }  
 27     }  
 28     
 29     /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  （带参数）
 30      * @param jobName 任务名
 31      * @param cls 任务
 32      * @param time 时间设置，参考quartz说明文档
 33      */
 34     public static void addJob(String jobName, Class<? extends Job> cls, String time, Map<String,Object> parameter) {  
 35         try {  
 36             Scheduler sched = gSchedulerFactory.getScheduler();                                          //通过SchedulerFactory构建Scheduler对象
 37             JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();    //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
 38             jobDetail.getJobDataMap().put("parameterList", parameter);                                //传参数
 39             CronTrigger trigger = (CronTrigger) TriggerBuilder
 40                     .newTrigger()                                                                         //创建一个新的TriggerBuilder来规范一个触发器
 41                     .withIdentity(jobName, TRIGGER_GROUP_NAME)                                            //给触发器起一个名字和组名
 42                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
 43                     .build();
 44             sched.scheduleJob(jobDetail, trigger);  
 45             if (!sched.isShutdown()) {  
 46                 sched.start();        // 启动  
 47             }  
 48         } catch (Exception e) {  
 49             throw new RuntimeException(e);  
 50         }  
 51     }  
 52   
 53     /**添加一个定时任务 
 54      * @param jobName    任务名 
 55      * @param jobGroupName    任务组名 
 56      * @param triggerName    触发器名 
 57      * @param triggerGroupName    触发器组名 
 58      * @param jobClass    任务 
 59      * @param time    时间设置，参考quartz说明文档 
 60      */
 61     public static void addJob(String jobName, String jobGroupName,  
 62             String triggerName, String triggerGroupName, Class<? extends Job> jobClass,  
 63             String time) {  
 64         try {  
 65             Scheduler sched = gSchedulerFactory.getScheduler();  
 66             JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
 67             CronTrigger trigger = (CronTrigger) TriggerBuilder     // 触发器  
 68                     .newTrigger()
 69                     .withIdentity(triggerName, triggerGroupName)
 70                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
 71                     .build();
 72             sched.scheduleJob(jobDetail, trigger);
 73             if (!sched.isShutdown()) {  
 74                 sched.start();        // 启动  
 75             } 
 76         } catch (Exception e) {  
 77             throw new RuntimeException(e);  
 78         }  
 79     }  
 80     
 81     /**添加一个定时任务  （带参数）
 82      * @param jobName    任务名 
 83      * @param jobGroupName    任务组名 
 84      * @param triggerName    触发器名 
 85      * @param triggerGroupName    触发器组名 
 86      * @param jobClass    任务 
 87      * @param time    时间设置，参考quartz说明文档 
 88      */
 89     public static void addJob(String jobName, String jobGroupName,  
 90             String triggerName, String triggerGroupName, Class<? extends Job> jobClass,  
 91             String time, Map<String,Object> parameter) {  
 92         try {  
 93             Scheduler sched = gSchedulerFactory.getScheduler();  
 94             JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
 95             jobDetail.getJobDataMap().put("parameterList", parameter);                                //传参数
 96             CronTrigger trigger = (CronTrigger) TriggerBuilder     // 触发器  
 97                     .newTrigger()
 98                     .withIdentity(triggerName, triggerGroupName)
 99                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
100                     .build();
101             sched.scheduleJob(jobDetail, trigger);
102             if (!sched.isShutdown()) {  
103                 sched.start();        // 启动  
104             } 
105         } catch (Exception e) {  
106             throw new RuntimeException(e);  
107         }  
108     } 
109   
110     /** 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名) 
111      * @param jobName    任务名 
112      * @param time    新的时间设置
113      */
114     public static void modifyJobTime(String jobName, String time) {  
115         try {  
116             Scheduler sched = gSchedulerFactory.getScheduler();                              //通过SchedulerFactory构建Scheduler对象
117             TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME);         //通过触发器名和组名获取TriggerKey
118             CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);                //通过TriggerKey获取CronTrigger
119             if (trigger == null) {  
120                 return;  
121             }  
122             String oldTime = trigger.getCronExpression();  
123             if (!oldTime.equalsIgnoreCase(time)) {  
124                 JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);                        //通过任务名和组名获取JobKey
125                 JobDetail jobDetail = sched.getJobDetail(jobKey); 
126                 Class<? extends Job> objJobClass = jobDetail.getJobClass();  
127                 removeJob(jobName);  
128                 addJob(jobName, objJobClass, time);  
129             }  
130         } catch (Exception e) {  
131             throw new RuntimeException(e);  
132         }  
133     }  
134     
135     /**修改一个任务的触发时间 
136      * @param triggerName    任务名称
137      * @param triggerGroupName    传过来的任务名称
138      * @param time    更新后的时间规则
139      */
140     public static void modifyJobTime(String triggerName, String triggerGroupName, String time) {  
141         try {  
142             Scheduler sched = gSchedulerFactory.getScheduler();                              //通过SchedulerFactory构建Scheduler对象
143             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName);     //通过触发器名和组名获取TriggerKey
144             CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);                //通过TriggerKey获取CronTrigger
145             if (trigger == null)  return;  
146             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
147             String oldTime = trigger.getCronExpression();  
148             if (!oldTime.equalsIgnoreCase(time)) {  
149                 trigger = (CronTrigger)trigger.getTriggerBuilder()        //重新构建trigger
150                         .withIdentity(triggerKey)
151                         .withSchedule(scheduleBuilder)
152                         .withSchedule(CronScheduleBuilder.cronSchedule(time))
153                         .build();
154                 sched.rescheduleJob(triggerKey, trigger);                //按新的trigger重新设置job执行
155             }
156         } catch (Exception e) {  
157             throw new RuntimeException(e);  
158         }  
159     }  
160     
161     /**移除一个任务(使用默认的任务组名，触发器名，触发器组名) 
162      * @param jobName    任务名称
163      */
164     public static void removeJob(String jobName) {  
165         try {  
166             Scheduler sched = gSchedulerFactory.getScheduler();  
167             TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME);     //通过触发器名和组名获取TriggerKey
168             JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);                        //通过任务名和组名获取JobKey
169             sched.pauseTrigger(triggerKey);    // 停止触发器  
170             sched.unscheduleJob(triggerKey);// 移除触发器  
171             sched.deleteJob(jobKey);        // 删除任务  
172         } catch (Exception e) {  
173             throw new RuntimeException(e);  
174         }  
175     }  
176     
177     /**移除一个任务
178      * @param jobName    任务名
179      * @param jobGroupName    任务组名
180      * @param triggerName    触发器名
181      * @param triggerGroupName    触发器组名
182      */
183     public static void removeJob(String jobName, String jobGroupName,String triggerName, String triggerGroupName) {  
184         try {  
185             Scheduler sched = gSchedulerFactory.getScheduler();  
186             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName);     //通过触发器名和组名获取TriggerKey
187             JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);                            //通过任务名和组名获取JobKey
188             sched.pauseTrigger(triggerKey);    // 停止触发器  
189             sched.unscheduleJob(triggerKey);// 移除触发器  
190             sched.deleteJob(jobKey);        // 删除任务  
191         } catch (Exception e) {  
192             throw new RuntimeException(e);  
193         }  
194     } 
195     
196     /**
197      * 启动所有定时任务 
198      */
199     public static void startJobs() {  
200         try {  
201             Scheduler sched = gSchedulerFactory.getScheduler();  
202             sched.start();  
203         } catch (Exception e) {  
204             throw new RuntimeException(e);  
205         }  
206     }  
207   
208     /**
209      * 关闭所有定时任务 
210      */
211     public static void shutdownJobs() {  
212         try {  
213             Scheduler sched = gSchedulerFactory.getScheduler();  
214             if (!sched.isShutdown()) {  
215                 sched.shutdown();  
216             }  
217         } catch (Exception e) {  
218             throw new RuntimeException(e);  
219         }  
220     }  
221 }

其次-创建具体任务实现类

public class SwapJob implements Job {protected Logger logger = Logger.getLogger(this.getClass());public void execute(JobExecutionContext context) throws JobExecutionException {
　　　　　System.out.println("我现在是每20秒 打印一次哦");
/*
　　　　这下面的方法 是我 用的Httpclient做测试的 后端请求接收接口数据用的 ，可以不用管，直接删除就好String url=null;String responseResult=null;try {//获取HttpClient对象HttpClient client =  new HttpClient();  //设置url url = "http://localhost:8080/FrontC/combotree/gover"; //获取post请求对象PostMethod method = new PostMethod(url); //执行请求对象 返回请求状态码int requestStatus=  client.executeMethod(method);//判断是否请求成功if(requestStatus==200){//接收响应数据responseResult = method.getResponseBodyAsString();     }//将String数据转化成json数据   用于之后json转对象使用
            System.out.println(JSONObject.parse(responseResult));}catch (Exception e){e.printStackTrace();     } finally {System.out.println("请求成功执行！");}

*/

} 

}

最后-使用调用QuartzManager中的方法，将参数传入

 public static void main(String[] args) {//任务名称      //具体需要完成的任务　　//时间间隔 （想要不用的时间，格式在网上就可以找到）QuartzManager.addJob("获取dept数据", SwapJob.class, "0/20 * * * * ?");}