使用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管理类 ，这个类中添加各种情况下 可使用的那些调用方法

　　

 public class QuartzManager {
     private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();  //创建一个SchedulerFactory工厂实例
     private static String JOB_GROUP_NAME = "FH_JOBGROUP_NAME";                      //任务组
     private static String TRIGGER_GROUP_NAME = "FH_TRIGGERGROUP_NAME";              //触发器组

     /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
      * @param jobName 任务名
      * @param cls 任务
      * @param time 时间设置，参考quartz说明文档
      */
     public static void addJob(String jobName, Class<? extends Job> cls, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();                                          //通过SchedulerFactory构建Scheduler对象
             JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();    //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
             CronTrigger trigger = (CronTrigger) TriggerBuilder
                     .newTrigger()                                                                         //创建一个新的TriggerBuilder来规范一个触发器
                     .withIdentity(jobName, TRIGGER_GROUP_NAME)                                            //给触发器起一个名字和组名
                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
                     .build();
             sched.scheduleJob(jobDetail, trigger);
             if (!sched.isShutdown()) {
                 sched.start();        // 启动
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  （带参数）
      * @param jobName 任务名
      * @param cls 任务
      * @param time 时间设置，参考quartz说明文档
      */
     public static void addJob(String jobName, Class<? extends Job> cls, String time, Map<String,Object> parameter) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();                                          //通过SchedulerFactory构建Scheduler对象
             JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();    //用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
             jobDetail.getJobDataMap().put("parameterList", parameter);                                //传参数
             CronTrigger trigger = (CronTrigger) TriggerBuilder
                     .newTrigger()                                                                         //创建一个新的TriggerBuilder来规范一个触发器
                     .withIdentity(jobName, TRIGGER_GROUP_NAME)                                            //给触发器起一个名字和组名
                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
                     .build();
             sched.scheduleJob(jobDetail, trigger);
             if (!sched.isShutdown()) {
                 sched.start();        // 启动
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**添加一个定时任务
      * @param jobName    任务名
      * @param jobGroupName    任务组名
      * @param triggerName    触发器名
      * @param triggerGroupName    触发器组名
      * @param jobClass    任务
      * @param time    时间设置，参考quartz说明文档
      */
     public static void addJob(String jobName, String jobGroupName,
             String triggerName, String triggerGroupName, Class<? extends Job> jobClass,
             String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
             CronTrigger trigger = (CronTrigger) TriggerBuilder     // 触发器
                     .newTrigger()
                     .withIdentity(triggerName, triggerGroupName)
                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
                     .build();
             sched.scheduleJob(jobDetail, trigger);
             if (!sched.isShutdown()) {
                 sched.start();        // 启动
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**添加一个定时任务  （带参数）
      * @param jobName    任务名
      * @param jobGroupName    任务组名
      * @param triggerName    触发器名
      * @param triggerGroupName    触发器组名
      * @param jobClass    任务
      * @param time    时间设置，参考quartz说明文档
      */
     public static void addJob(String jobName, String jobGroupName,
             String triggerName, String triggerGroupName, Class<? extends Job> jobClass,
             String time, Map<String,Object> parameter) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
             jobDetail.getJobDataMap().put("parameterList", parameter);                                //传参数
             CronTrigger trigger = (CronTrigger) TriggerBuilder     // 触发器
                     .newTrigger()
                     .withIdentity(triggerName, triggerGroupName)
                     .withSchedule(CronScheduleBuilder.cronSchedule(time))
                     .build();
             sched.scheduleJob(jobDetail, trigger);
             if (!sched.isShutdown()) {
                 sched.start();        // 启动
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     } 

     /** 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
      * @param jobName    任务名
      * @param time    新的时间设置
      */
     public static void modifyJobTime(String jobName, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();                              //通过SchedulerFactory构建Scheduler对象
             TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME);         //通过触发器名和组名获取TriggerKey
             CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);                //通过TriggerKey获取CronTrigger
             if (trigger == null) {
                 return;
             }
             String oldTime = trigger.getCronExpression();
             if (!oldTime.equalsIgnoreCase(time)) {
                 JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);                        //通过任务名和组名获取JobKey
                 JobDetail jobDetail = sched.getJobDetail(jobKey);
                 Class<? extends Job> objJobClass = jobDetail.getJobClass();
                 removeJob(jobName);
                 addJob(jobName, objJobClass, time);
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**修改一个任务的触发时间
      * @param triggerName    任务名称
      * @param triggerGroupName    传过来的任务名称
      * @param time    更新后的时间规则
      */
     public static void modifyJobTime(String triggerName, String triggerGroupName, String time) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();                              //通过SchedulerFactory构建Scheduler对象
             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName);     //通过触发器名和组名获取TriggerKey
             CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);                //通过TriggerKey获取CronTrigger
             if (trigger == null)  return;
             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
             String oldTime = trigger.getCronExpression();
             if (!oldTime.equalsIgnoreCase(time)) {
                 trigger = (CronTrigger)trigger.getTriggerBuilder()        //重新构建trigger
                         .withIdentity(triggerKey)
                         .withSchedule(scheduleBuilder)
                         .withSchedule(CronScheduleBuilder.cronSchedule(time))
                         .build();
                 sched.rescheduleJob(triggerKey, trigger);                //按新的trigger重新设置job执行
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**移除一个任务(使用默认的任务组名，触发器名，触发器组名)
      * @param jobName    任务名称
      */
     public static void removeJob(String jobName) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME);     //通过触发器名和组名获取TriggerKey
             JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);                        //通过任务名和组名获取JobKey
             sched.pauseTrigger(triggerKey);    // 停止触发器
             sched.unscheduleJob(triggerKey);// 移除触发器
             sched.deleteJob(jobKey);        // 删除任务
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**移除一个任务
      * @param jobName    任务名
      * @param jobGroupName    任务组名
      * @param triggerName    触发器名
      * @param triggerGroupName    触发器组名
      */
     public static void removeJob(String jobName, String jobGroupName,String triggerName, String triggerGroupName) {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName);     //通过触发器名和组名获取TriggerKey
             JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);                            //通过任务名和组名获取JobKey
             sched.pauseTrigger(triggerKey);    // 停止触发器
             sched.unscheduleJob(triggerKey);// 移除触发器
             sched.deleteJob(jobKey);        // 删除任务
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     } 

     /**
      * 启动所有定时任务
      */
     public static void startJobs() {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             sched.start();
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }  

     /**
      * 关闭所有定时任务
      */
     public static void shutdownJobs() {
         try {
             Scheduler sched = gSchedulerFactory.getScheduler();
             if (!sched.isShutdown()) {
                 sched.shutdown();
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }
 }  

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

　　

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/