Trigger

方法

优先级（priority）

如果你的trigger很多（或者Quartz线程池的工作线程太少），Quartz可能没有足够的资源同时触发所有的trigger；这种情况下，你可能希望控制哪些trigger优先使用Quartz的工作线程，要达到该目的，可以在trigger上设置priority属性。

比如，你有N个trigger需要同时触发，但只有Z个工作线程，优先级最高的Z个trigger会被首先触发

错过触发（misfire instructions）

如果scheduler关闭了，或者Quartz线程池中没有可用的线程来执行job，此时持久性的trigger就会错过(miss)其触发时间，即错过触发(misfire)。当下次调度器启动或者有可以线程时，会检查处于misfire状态的Trigger。而misfire的状态值决定了调度器如何处理这个Trigger。

不同类型的trigger，有不同的misfire机制。它们默认都使用“智能机制（smart policy）”，即根据trigger的类型和配置动态调整行为

分类

SimpleTrigger

为需要在特定的日期/时间启动，且以一个可能的间隔时间重复执行n次的job所设计的

  1. startNow()：Scheduler开始执行时，触发器也即执行
  2. startAt()：在指定的时间开始执行
  3. endAt()：结束时间

执行间隔：

  1. withInterval(TimeSpan timeSpan)：通用的间隔执行方法
  2. withIntervalInHours(int hours)：以小时为间隔单位进行执行
  3. withIntervalInMinutes(int minutes)：以分钟为间隔单位进行执行
  4. withIntervalInSeconds(int seconds)：以秒为间隔单位进行执行

执行时间：

  1. withRepeatCount(int repeatCount)：执行多少次以后结束
  2. repeatForever()：永远执行
  3. repeatMinutelyForever()：一分钟执行一次(永远执行)
  4. repeatMinutelyForever(int minutes)：每隔几分钟执行一次(永远执行)
  5. repeatMinutelyForTotalCount(int count, int minutes)：每隔几分钟执行一次(执行次数为count)类似的还有秒、小时。
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
public class Trigger1 {

    public static void main(String[] args) throws SchedulerException {
        //创建一个JobDetail的实例，将该实例与HelloJob绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("testJob")
                .build();
        //开始时间 3秒钟之后 （具体时间按实际业务编写）
        Date sData = new Date();
        sData.setTime(sData.getTime() + 3000);
        //结束时间 20秒钟之后 （具体时间按实际业务编写）
        Date eData = new Date();
        eData.setTime(eData.getTime() + 20000);
        //创建一个Trigger实例，定义该job3秒之后执行，在6秒之后结束
        SimpleTrigger zhlTrigger = TriggerBuilder.newTrigger()
                    .withIdentity("test")
                    .startAt(sData) //设定开始时间
                    .endAt(eData)   //设定结束时间
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                            .withIntervalInSeconds(2) //每两秒打印一次
                            .withRepeatCount(2)) // 重复2次
                    .build();
        //创建Scheduler实例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail, zhlTrigger);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class HelloJob implements Job{
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //打印当前的执行时间 例如 2017-11-22 00:00:00
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("现在的时间是："+ sf.format(date));
        //具体的业务逻辑
        System.out.println("具体执行的业务...");
        JobKey key = jobExecutionContext.getJobDetail().getKey();
        Trigger trigger = jobExecutionContext.getTrigger();
        System.out.println("开始的时间："+sf.format(trigger.getStartTime()));
        System.out.println("结束的事件："+sf.format(trigger.getEndTime()));
    }
}

CronTrigger

指定对应的cron表达式执行任务

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
public class Trigger2 {

    public static void main(String[] args) throws SchedulerException {
        //创建一个JobDetail的实例，将该实例与HelloJob绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("test")
                .build();
        //开始时间 3秒钟之后 （具体时间按实际业务编写）
        Date sData = new Date();
        sData.setTime(sData.getTime() + 3000);
        //结束时间 20秒钟之后 （具体时间按实际业务编写）
        Date eData = new Date();
        eData.setTime(eData.getTime() + 20000);
        //创建一个Trigger实例，定义该job3秒之后执行，在6秒之后结束
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("testTrigger")
                .startAt(sData) //设定开始时间
                .endAt(eData)   //设定结束时间
                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                .build();
        //创建Scheduler实例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail, trigger);
    }
}

CalendarIntervalTrigger

用来触发基于定时重复的JobDetail，Trigger将会每隔N个Calendar在Trigger中定义的时间单元触发一次，这个Trigger不适合使用SimpleTrigger完成（例如由于每一个月的时间不是固定的描述），也不适用于CronTrigger（例如每5个月）

相较于SimpleTrigger有两个优势：

  1. 更方便，比如：每隔1小时执行，你不用自己去计算1小时等于多少毫秒。
  2. 支持不是固定长度的间隔，比如：间隔为月和年。但劣势是精度只能到秒。

参数：

  1. interval：执行间隔
  2. intervalUnit：执行间隔的单位（秒、分钟、小时、天、月、年、星期）
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
public class Trigger4 {

    public static void main(String[] args) throws SchedulerException {
        //创建一个JobDetail的实例，将该实例与HelloJob绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("test")
                .build();
        //开始时间 3秒钟之后 （具体时间按实际业务编写）
        Date sData = new Date();
        sData.setTime(sData.getTime() + 3000);
        //结束时间 20秒钟之后 （具体时间按实际业务编写）
        Date eData = new Date();
        eData.setTime(eData.getTime() + 20000);
        //创建一个Trigger实例，定义该job3秒之后执行，在20秒之后结束
        CalendarIntervalTrigger intervalTrigger = TriggerBuilder.newTrigger()
                .withIdentity("testTrigger")
                .startAt(sData) //设定开始时间
                .endAt(eData)   //设定结束时间
                .withSchedule(CalendarIntervalScheduleBuilder.calendarIntervalSchedule()
                        .withIntervalInSeconds(5))	// 每隔5秒执行一次
                .build();
        //创建Scheduler实例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail, intervalTrigger);
    }
}

DailyTimeIntervalTrigger

指定每天的某个时间段内，以一定的时间间隔执行任务，并且可以支持星期的设置

适合的任务类似于：指定每天9：00至18：00，每隔10秒执行一次，并且只要周一至周五执行

参数：

  1. onEveryDay：每天
  2. onMondayThroughFriday：周一至周五，即工作日
  3. onSaturdayAndSunday：周六至周天，即休息日e
  4. onDaysOfTheWeek：用数组的形式单独来指定一周中的哪几天
  5. startingDailyAt：表示开始于几点 （区别于前面的StartAt）
  6. endingDailyAt：表示结束于几点 （区别于前面的EndAt）
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
public class Trigger3 {

    public static void main(String[] args) throws SchedulerException {
        //创建一个JobDetail的实例，将该实例与HelloJob绑定
        JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                .withIdentity("test")
                .build();
        //开始时间 3秒钟之后 （具体时间按实际业务编写）
        Date sData = new Date();
        sData.setTime(sData.getTime() + 3000);
        //结束时间 20秒钟之后 （具体时间按实际业务编写）
        Date eData = new Date();
        eData.setTime(eData.getTime() + 20000);
        //创建一个Trigger实例，定义该job3秒之后执行，在20秒之后结束
        DailyTimeIntervalTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("testTrigger")
                .startAt(sData) //设定开始时间
                .endAt(eData)   //设定结束时间
                .withSchedule(DailyTimeIntervalScheduleBuilder.dailyTimeIntervalSchedule()
                        .withIntervalInSeconds(3)
                        .onEveryDay()) //每天每隔3秒执行一次
                .build();
        //创建Scheduler实例
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = stdSchedulerFactory.getScheduler();
        scheduler.start();
        scheduler.scheduleJob(jobDetail, trigger);
    }
}