Quartz

Quartz 定时任务

  • 场景：

    1. Quartz 工作原理：组成部分

    2. 使用简单的定时任务

    3. 动态任务管理

    4. 3个组件：

      1. job：要执行的任务，接口

        自定义执行任务时，需要实现job接口 实现execute方法

        下有系统实现类JobDetail，通过此类加载自定义的任务

      2. trigger：触发器（什么时候执行任务）

        下有两个子类 1)SimpleTrigger：不能精确到时分秒；
        2)CronTrigger：自定义

        Cron表达式：声明时间规则

      3. Scheduler：调度器，把job任务和trigger触发器结合在一起

    定时任务实际上是新开启的线程，如果没到执行的时间，线程sleep

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
public class MyJob implements Job{
    //具体要执行的任务
    public void excute(JobExcutionContext context) throws JobExcutionException{
        System.out.println("hello,quartz"+new Date());
    }
}


public class TestSimpleJob{
    public static void main(String[] args){
        //1.声明一个触发器
        //withIdentity("")  给创建的触发器一个唯一的标识
        //withSchedule()   在哪个调度器下工作，声明时间调度规则
        //withIntervalInSeconds(1) 隔一秒后执行触发器
        //repeatFo  规则：永远重复
        //stratNow()  开始执行
       Trigger trigger = TriggerBuilder.newTrigger()
             .withIdentity("test1018")
             .withSchedule(CronScheduleBuilder.cronSchedule("0/5 12 11 18 10 ?"))
              .startNow().build();
        //2.创建要执行的任务，通过JobDetail类创建
        JobDetail job = JobBuilder.newJob(MyJob.class).withIdentity("myjob").build();
        //3.创建调度器：把触发器和任务（job）结合到一起。Scheduler是一个单例模式
        try{
          Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
            scheduler.scheduleJob(job,trigger);
            //开始调度
            scheduler.start();
        }catch(SchedulerException e){
            e.printStackTrace();
        }
        System.out.println("任务执行结束");
    }
}

Cron表达式

  • 在触发器中声明复杂的时间规则需要使用Cron表达式
  • Cron表达式:生命时间的时间规则
    • 秒 0-59
    • 分 0-59
    • 时 0-23
    • 日 1-31
    • 月 1-12 or JAN-DEC
    • 周 1-7 or SUN-SAT
    • 年 （年可以省略）empty or 1970-2099
  • 特殊符号：
    • ？任意值
    • ，分隔符 19,20,21
    • - 范围 8-10
    • / 增幅 0/5 从0开始，每次增加5
    • L 最后一个 日:最后一天，月:最后一月
    • W
    • #

一般情况下 日期和星期写一个就可以，否则就是几号并且是周几的情况下执行

动态定时任务

  1. 根据需要随时向现有的定时任务中添加新的定时任务
  2. 动态修改已存在的定时任务的时间规则
  3. 停止/恢复某个定时任务
  4. 删除某个定时任务

添加定时任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
public class QuartzUtil {
    //声明静态的常量的调度工厂:获得调度器
 private static final SchedulerFactory factory = new StdSchedulerFactory();
    //动态添加任务
 //参数:1.人物的的名字 2.任务所在组的名字 3.触发器的名字  4.触发器所在组的名字  5.任务类     
   public static void addJob(String jobName,String jobGroupName,
         String triggerName,String triggerGroupName,
         String cron,Class jobClass){
//       创建触发器
      Trigger trigger = TriggerBuilder.newTrigger()
             .withIdentity(triggerName,triggerGroupName)
               .withSchedule(CronScheduleBuilder.cronSchedule(cron))
             .startNow().build();
        //2.创建要执行的任务，通过JobDetail类创建
        JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();
        //3.创建调度器：把触发器和任务（job）结合到一起。Scheduler是一个单例模式
        try{
            Scheduler scheduler = factory.getScheduler();
         System.out.println(scheduler);
            scheduler.scheduleJob(job,trigger);
            //开始调度
            scheduler.start();
        }catch(SchedulerException e){
            e.printStackTrace();
        }
  }

动态修改已存在的定时任务的时间规则

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
//    动态修改调度器中的任务，修改时间规则
// 参数:1.新Cron表达式 2.触发器的名字 3.触发器所在组
    public static void updateJob(String newCron, String triggerName, String triggerGroup) {
      try {
//           1.先获取调度器
           Scheduler scheduler = factory.getScheduler();
//         2.创建一个TriggerKey,通过key到调度器中获取触发器
           TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
//           3.通过key到调度器中获取触发器
          CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//         4.到触发器中获取到原有的Cron
          String oldCron = trigger.getCronExpression();
//         5.判断是否一致
           if (!oldCron.equals(newCron)) {
//             创建新触发器
             Trigger newTrigger =TriggerBuilder.newTrigger()
                    .withIdentity(triggerName, triggerGroup)
                    .withSchedule(CronScheduleBuilder.cronSchedule(newCron))
                    .startNow().build();
//             替换原有触发器
                scheduler.rescheduleJob(triggerKey, newTrigger);
          }


  } catch (SchedulerException e) {
       e.printStackTrace();
  }
}</code></pre></td>

删除定时任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
//    删除定时任务
 public static void deleteJob(String jobName, String jobGroup, Sting triggerName, String triggerGroup) {
      try {
//   获取调度器
          Scheduler scheduler = factory.getScheduler();
// 声明TriggerKey
           TriggerKey triggerKey = new TriggerKey(triggerName, triggerGroup);
//           停止调度工作
         scheduler.pauseTrigger(triggerKey);
           scheduler.unscheduleJob(triggerKey);
//          删除一个任务
         scheduler.deleteJob(JobKey.jobKey(jobName, jobGroup));
        } catch (SchedulerException e) {
           e.printStackTrace();
      }
    }

暂停定时任务

1
2
3
4
5
6
7
8
9
10
11
 
//    暂停任务
   public static void pauseJob(String jobName,String jobGroup) {
        try {
           Scheduler scheduler = factory.getScheduler();
         JobKey jobKey = JobKey.jobKey(jobName,jobGroup);
          scheduler.pauseJob(jobKey);
       } catch (SchedulerException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
      }
    }

恢復定時任務

1
2
3
4
5
6
7
8
9
10
11
12
 
public static void resumeJob(String jobName,String jobGroup) {
       Scheduler scheduler;
      try {
           scheduler = factory.getScheduler();
           JobKey jobKey = JobKey.jobKey(jobName,jobGroup);
          scheduler.resumeJob(jobKey);
      } catch (SchedulerException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
      }
        

  }

测试一下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
public class TestUtil {
 public static void main(String[] args) {
//     添加第一个任务
        QuartzUtil.addJob("fjob", "jgroup", "tr1", "trgroup", "0/5 0/1 13 18 10 ?", MyJob.class);
//     添加第二个任务
        QuartzUtil.addJob("fjob2", "jgroup", "tr2", "trgroup", "0/1 0/1 13 18 10 ?", MyJob2.class);
//           修改任务
       QuartzUtil.updateJob("0/3 0/1 15 18 10 ?", "tr1", "trgroup");
     QuartzUtil.updateJob("0/6 0/1 15 18 10 ?", "tr2", "trgroup");
//     删除任务
       QuartzUtil.deleteJob("fjob", "jgroup", "tr1", "trgroup");
        //暫停任務
        QuartzUtil.pauseJob("fjob", "jgroup");
        //恢復任務
       QuartzUtil.resumeJob("fjob","jgroup");
    }
}