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所设计的

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

执行间隔：

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

执行时间：

withRepeatCount(int repeatCount)：执行多少次以后结束
repeatForever()：永远执行
repeatMinutelyForever()：一分钟执行一次(永远执行)
repeatMinutelyForever(int minutes)：每隔几分钟执行一次(永远执行)
repeatMinutelyForTotalCount(int count, int minutes)：每隔几分钟执行一次(执行次数为count)类似的还有秒、小时。

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);
    }
}

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表达式执行任务

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小时等于多少毫秒。
支持不是固定长度的间隔，比如：间隔为月和年。但劣势是精度只能到秒。

参数：

interval：执行间隔
intervalUnit：执行间隔的单位（秒、分钟、小时、天、月、年、星期）

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秒执行一次，并且只要周一至周五执行

参数：

onEveryDay：每天
onMondayThroughFriday：周一至周五，即工作日
onSaturdayAndSunday：周六至周天，即休息日e
onDaysOfTheWeek：用数组的形式单独来指定一周中的哪几天
startingDailyAt：表示开始于几点（区别于前面的StartAt）
endingDailyAt：表示结束于几点（区别于前面的EndAt）

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);
    }
}