浅谈Trigger(SimpleTrigger&CronTrigger)

 1.Trigger是什么

　　Quartz中的触发器用来告诉调度程序作业什么时候触发，即Trigger对象是用来触发执行job的。

 2.Quartz中的Trigger

 3.触发器通用属性:

JobKey:表示job实例的标识，触发器被触发时，该指定的job实例会执行

StartTime:表示触发器的时间表 首次被触发的时间，值类型是Java.util.Date

EndTime:指定触发器的不再触发的时间，它的值类型是Java.util.Date

例如:通过Trigger设置开始时间，结束时间以及在Job中通过trigger获取job标识与trigger的开始时间与结束时间

HelloJob.java(通过trigger获取job标识与trigger的开始时间与结束时间)

package cn.qlq.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.Trigger;
import org.quartz.TriggerKey;

public class HelloJob implements Job {
    

    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        // 1.获取Trigger
        Trigger trigger = context.getTrigger();
        //2.通过trigger获取job标识
        JobKey jobKey = trigger.getJobKey();
        System.out.println("Job's key:"+"name:"+jobKey.getName()+"	group:"+jobKey.getGroup());getClass();
        System.out.println("Start time : "+sf.format(trigger.getStartTime()));
        System.out.println("End time : "+sf.format(trigger.getEndTime()));
        
    }
    
}

HelloScheduler.java(用Trigger设置开始时间，结束时间)

package cn.qlq.quartz;

import static org.quartz.DateBuilder.newDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.GregorianCalendar;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.calendar.AnnualCalendar;

public class HelloScheduler {
    public static void main(String[] args) {
        try {
            //1. 创建一个JodDetail实例 将该实例与Hello job class绑定    (链式写法)
            JobDetail jobDetail = newJob(HelloJob.class) // 定义Job类为HelloQuartz类，这是真正的执行逻辑所在
                    .withIdentity("myJob") // 定义name/group
                    .build();

            //2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            //2.1设置Trigger的开始时间(3s后开始)
            Date startTime = new Date();
            startTime.setTime(startTime.getTime()+3000);
            //2.2设置Trigger的结束时间(6s后开始)
            Date endTime = new Date();
            endTime.setTime(endTime.getTime()+6000);
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startAt(startTime)
                    .endAt(endTime)
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                    .build();
            
            //3. 创建scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            //4. 将trigger和jobdetail加入这个调度
            scheduler.scheduleJob(jobDetail, trigger);

            //5. 启动scheduler
            scheduler.start();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果:

Job's key:name:myJob    group:DEFAULT
Start time : 2018-04-04 10:43:54
End time : 2018-04-04 10:43:57
Job's key:name:myJob    group:DEFAULT
Start time : 2018-04-04 10:43:54
End time : 2018-04-04 10:43:57

---------------------------浅谈SimpleTrigger----------------------

SimpleTrigger的作用

　　在一个指定时间段内执行一次作业任务或是在指定时间间隔内执行多次作业任务

 

 例一:4秒钟后执行任务并且只执行一次

HelloJob.java
package cn.qlq.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job {
    

    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date = new Date();
        System.out.println("current exec time is :"+sf.format(date));
    }
    
}

 HelloScheduler.java

package cn.qlq.quartz;

import static org.quartz.JobBuilder.newJob;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class HelloScheduler {
    public static void main(String[] args) {
        try {
            // 1. 创建一个JodDetail实例 将该实例与Hello job class绑定 (链式写法)
            JobDetail jobDetail = newJob(HelloJob.class) // 定义Job类为HelloQuartz类，这是真正的执行逻辑所在
                    .withIdentity("myJob") // 定义name/group
                    .build();
            // 打印当前的时间
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            Date date = new Date();
            System.out.println("current time is :" + sf.format(date));

            // 2. 定义一个Trigger，定义该job在4秒后执行，并且执行一次
            Date startTime = new Date();
            startTime.setTime(startTime.getTime()+4000L);
            SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .startAt(startTime)
                    .build();

            // 3. 创建scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

            // 4. 将trigger和jobdetail加入这个调度
            scheduler.scheduleJob(jobDetail, trigger);

            // 5. 启动scheduler
            scheduler.start();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

结果:

current time is :2018-04-05 10:16:33
current exec time is :2018-04-05 10:16:37

 例二:一个jobjob在4秒后首次执行，并且每隔两秒执行一次,重复执行无数次

修改上面的HelloScheduler中Trigger的定义

            // 2. 定义一个Trigger，定义该job在4秒后首次执行，并且每隔两秒执行一次
            Date startTime = new Date();
            startTime.setTime(startTime.getTime() + 4000L);
            SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .startAt(startTime)//定义开始时间
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            SimpleScheduleBuilder
                            .simpleSchedule()
                            .withIntervalInSeconds(2)//定义时间间隔是2秒
                            .withRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY)//定义重复执行次数是无限次
                            )
                    .build();

 例三:一个jobjob在4秒后首次执行，并且每隔两秒执行一次,重复执行3次

 修改上面的HelloScheduler中Trigger的定义

            // 2. 定义一个Trigger，定义该job在4秒后首次执行，并且每隔两秒执行一次，重复3次
            Date startTime = new Date();
            startTime.setTime(startTime.getTime() + 4000L);
            SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .startAt(startTime)//定义开始时间
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            SimpleScheduleBuilder
                            .simpleSchedule()
                            .withIntervalInSeconds(2)//定义时间间隔是2秒
                            .withRepeatCount(3)//定义重复执行次数是无限次
                            )
                    .build();

 结果:

current time is :2018-04-05 10:27:40
current exec time is :2018-04-05 10:27:44
current exec time is :2018-04-05 10:27:46
current exec time is :2018-04-05 10:27:48
current exec time is :2018-04-05 10:27:50

 例四:定义开始时间在4s后，结束时间在6s后，同时也定义每隔两秒执行一次,重复执行3次

  修改上面的HelloScheduler中Trigger的定义

            // 2. 定义一个Trigger，定义该job在4秒后执行,6s后停止
            //2.1设置开始时间为4s后
            Date startTime = new Date();
            startTime.setTime(startTime.getTime() + 4000L);
            //2.2设置结束时间为6s后
            Date endTime = new Date();
            endTime.setTime(endTime.getTime() + 6000L);
            SimpleTrigger trigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .startAt(startTime)//定义开始时间为4s后
                    .endAt(endTime)//定义结束时间为6s后
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            SimpleScheduleBuilder
                            .simpleSchedule()
                            .withIntervalInSeconds(2)//定义时间间隔是2秒
                            .withRepeatCount(3)//定义重复执行次数是无限次
                            )
                    .build();

 结果:

current time is :2018-04-05 10:34:46
current exec time is :2018-04-05 10:34:50

　　表明endAt()的优先级高级后面定义的频度。也就是如果定义了结束时间，会在指定时间结束。

SimpleTrigger总结:

　　1.重复次数可以是0，正整数或是SimpleTrigger.REPEAT_INDEFINITELY常量值。我们点击发现REPEAT_INDEFINITELY是-1，也就是-1表示无线次。

　　2.重复执行时间间隔必须为0或长整数。可以用小时，分钟，秒数的单位限制间隔

　　3.一旦指定了endTime参数，那么它会覆盖重复次数参数的效果。

-----------------------------浅谈CronTrigger---------------------------------

0.CronTrigger的作用

 基于日历的作业调度器，而不是像SimpleTrigger那样精确指定间隔时间，比SimpleTrigger更常用。

1.Cron表达式

用于配置CronTrigger实例

是由7个子表达式组成的字符串，描述了时间表的详细信息

格式：[秒][分][小时][日][月][周][年]

书写规则:知道确定日期的写上，不知道的用*代替 　(年可以省略，只写前6个)　

2.Cron表达式特殊字符意义对应表

特殊符号解释

Cron表达式举例

 Cron表达式小提示

L和W可以一组合使用
周字段英文字母不区分大小写即MON与mon相同
利用工具，在线生成　　http://cron.qqe2.com/

3.例子:

HelloJob.java

package cn.qlq.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job {
    

    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        Date date = new Date();
        System.out.println("current exec time is :"+sf.format(date));
    }
    
}

 例一:每秒钟都执行上面job，重复无数次

HelloScheduler.java

package cn.qlq.quartz;

import static org.quartz.JobBuilder.newJob;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class HelloScheduler {
    public static void main(String[] args) {
        try {
            // 1. 创建一个JodDetail实例 将该实例与Hello job class绑定 (链式写法)
            JobDetail jobDetail = newJob(HelloJob.class) // 定义Job类为HelloQuartz类，这是真正的执行逻辑所在
                    .withIdentity("myJob") // 定义name/group
                    .build();
            // 打印当前的时间
            SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            Date date = new Date();
            System.out.println("current time is :" + sf.format(date));

            // 2. 定义一个Trigger，定义该job立即执行,并且每秒都执行一次。重复无数次
            CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            CronScheduleBuilder
                            .cronSchedule("* * * * * ? *")
                            )
                    .build();

            // 3. 创建scheduler
            SchedulerFactory sfact = new StdSchedulerFactory();
            Scheduler scheduler = sfact.getScheduler();

            // 4. 将trigger和jobdetail加入这个调度
            scheduler.scheduleJob(jobDetail, trigger);

            // 5. 启动scheduler
            scheduler.start();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 结果:

current time is :2018-04-05 10:56:37
current exec time is :2018-04-05 10:56:37
current exec time is :2018-04-05 10:56:38
current exec time is :2018-04-05 10:56:39
current exec time is :2018-04-05 10:56:40

 .....

 例二:2018年内每天11点18开始执行，每隔5s执行一次

修改上面HelloScheduler中的Trigger:

            // 2. 2018年内每天11点18开始执行，每隔5s执行一次
            CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            CronScheduleBuilder
                            .cronSchedule("0/5 18 11 ? * * 2018")
                            )
                    .build();

 例三:每天的14点整至14点59分55秒，以及18点整至18点59分55秒，每5秒钟执行一次

            CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
                    .withIdentity("myTrigger", "group1")// 定义名字和组
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            CronScheduleBuilder
                            .cronSchedule("0/5 0 14,18 * * ? *")
                            )
                    .build();
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/qlqwjy/p/8721963.html