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

Posted Chiler

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了使用quartz.jar quartz-jobs.jar 实现定时任务 。实现 定时采集 接口数据相关的知识,希望对你有一定的参考价值。

  前言

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

 

  首先-创建一个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 * * * * ?");
    }

结语

 上面是我的可运行的方法  ,需要使用的朋友,直接代码复制 到自己的 项目中就可以 使用了 ,前提是 记得把包给 导入先  

 有什么问题 希望 可以在评论区 交流 !

 






以上是关于使用quartz.jar quartz-jobs.jar 实现定时任务 。实现 定时采集 接口数据的主要内容,如果未能解决你的问题,请参考以下文章

quartz-job实现实时或定时发送短信任务

quartz在web.xml的配置

Quartz

Quartz深入浅出

Java&Quartz实现任务调度

POM 丢失,没有可用的依赖信息