使用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;

　　<!-- quartz定時器 -->
　　<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 * * * * ?");
    }

結語

　上面是個人可運行的方法  ，須要使用的朋友，直接代碼複製 到本身的 項目中就能夠 使用了 ，前提是 記得把包給 導入先  

　有什麼問題 但願 能夠在評論區 交流 ！

   quartz定時時間生成器：http://cron.qqe2.com/