Quartz任务调度——快速入门

最新推荐文章于 2023-02-23 17:25:30 发布

龍弟-idea

最新推荐文章于 2023-02-23 17:25:30 发布

阅读量3.6k

点赞数 11

分类专栏： # 微服务架构 java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_48838340/article/details/123376306

版权

java 同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

微服务架构

4 篇文章 0 订阅

订阅专栏

一、Quartz概念

Quartz 是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，它可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。Quartz 可以用来创建简单调度,以执行十个，百个，甚至是好几万个 Jobs 这样复杂的程序。

简单来说，quartz就是基于java实现的任务调度框架，用于执行你想要的任何任务。

二、Quartz运行环境

Quartz可以运行嵌入在另一个独立式应用程序
Quartz可以在应用程序服务器(或servlet容器)内被实例化，并且参与事务
Quartz可以作为一个独立的程序运行(其自己的Java虚拟机内)，可以通过RMl使用
Quartz可以被实例化，作为独立的项目集群(负载平衡和故障转移功能)，用于作业的执行

三、Quartz设计模式

Builder模式

Factory模式

组件模式

链式编程

四、Quartz学习的核心概念

①任务job

job就是想要实现的任务类，每个job必须实现org,quartz.job接口，且只需实现接口的excute()方法

②触发器Trigger

Trigger为你执行任务的触发器，比如你想每天三点定时发送一份邮件，Trigger会设置3点执行该任务

③调度器Scheduler

Scheduler为任务的调度器，它会将任务job及触发器Trigger整合起来，负责基于Trigger设定的时间来执行job。

五、Qutarz的体系结构

六、Quartz的几个常用API

以下是Quartz编程API几个重要接口，也是Quartz的重要组件.

Scheduler 用于与调度程序交互的主程序接口。
Scheduler调度程序-任务执行计划表，只有安排进执行计划的任务Job(通过scheduler.scheduleJob方法安排进执行计划），当它预先定义的执行时间到了的时候（任务触发trigger )，该任务才会执行。
Job我们预先定义的希望在未来时间能被调度程序执行的任务类，我们可以自定义。
JobDetail使用jobDetail来定义定时任务的实例，JobDetail实例是通过JobBuilder类创建的。JobDataMap可以包含不限量的（序列化的）数据对象，在job实例执行的时候，可以使用其中的数据;JobDataMap是Java Map接口的一个实现，额外增加了一些便于存取基本类型的数据的方法。
Trigger触发器，Trigger对象是用来触发执行ob的。当调度一个job时，我们实例一个触发器然后调整它的属性来满足job执行的条件。表明任务在什么时候会执行。定义了一个已经被安排的任务将会在什么时候执行的时间条件，比如每2秒就执行一次。
JobBuilder -用于声明一个任务实例，也可以定义关于该任务的详情比如任务名、组名等，这个声明的实例将会作为一个实际执行的任务。
TriggerBuilder触发器创建器，用于创建触发器trigger实例。
JobListener、TriggerListener、SchedulerListener监听器，用于对组件的监听。

七、Quartz的使用

入门案例

public class HelloJob implements Job {
    @Override
    public void excute(JobExecutionContext context)throws JobExecutionException{
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //工作内容
        System.out.println("正在执行数据库的备份工作，备份数据库的时间:"+dateString);
    }
}

public class HelloSchedulerDemo {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloJob.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                . build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startNow()//马上启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5) ) //每5秒重复执行一次
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        scheduler.start();
    }
}

Job和JobDetail介绍

job:工作任务调度的接口，任务类需要实现该接口，该接口中定义excute方法，类似JDK提供的TimeTask类的run方法，在里面编写任务执行的业务逻辑
Job实例在Quartz中的生命周期:每次调度器执行Job时,它在调用execute方法前会创建一个新的job实例 ，当调用完成后,关联的Job对象实例会被释放,释放的实例会被垃圾回收机利回收。
jobDetail:jobDetail为job实例提供了许多设置属性，以及jobDetaMap成员变量属性，它用来存储特定job实例的状态信息，调度器需要借助jobDetail对象来添加job实例
jobDetail重要属性:name、group、jobClass、jobDataMap

        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloJob.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                . build();
        System.out.println("name: "+jobDetail.getKey().getName());
        System.out.println("组的名称:"+jobDetail.getKey().getGroup());//如果没有组名:Default
        System.out.println("任务类:"+jobDetail.getJobClass().getName());

实现效果:

JobExecutionContext介绍

①当Scheduler调用一个job ,就会将]obExecutionContext传递给Job的execute()方法;
②Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据。

    //获取JobDetail的内容
        JobKey jobKey= jobExecutionContext.getJobDetail().getKey();
        System.out.println("工作任务名称:"+jobKey.getName()+"  ;工作任务的组:"+jobKey.getGroup());
        System.out.println("任务类的名称(带路径):"+jobExecutionContext.getJobDetail().getJobClass().getName());
        System.out.println("任务类的名称:"+jobExecutionContext.getJobDetail().getJobClass().getSimpleName());

JobDataMap介绍

（1）使用Map获取

●在进行任务调度时, JobDataMap存储在JobExecutionContext中，非常方便获取。
●JobDataMap可以用来装载任何可序列化的数据对象,当job实例对象被执行时这些参数对象会传递给它。
●JobDataMap实现了JDK的Map接口,并且添加了非常方便的方法用来存取基本数据类型。
HelloSchedulerDemo.java

public class HelloSchedulerDemo {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloJob.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .usingJobData("message","打印日志") //传递参数，名称message
                . build();
        System.out.println("name: "+jobDetail.getKey().getName());
        System.out.println("组的名称:"+jobDetail.getKey().getGroup());//如果没有组名:Default
        System.out.println("任务类:"+jobDetail.getJobClass().getName());

        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startNow()//马上启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5) ) //每5秒重复执行一次
                .usingJobData("message","simple触发器") //传递参数，名称message
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        scheduler.start();
    }
}

HelloJob.java

public class HelloJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //获取JobDetail的内容
        JobKey jobKey= jobExecutionContext.getJobDetail().getKey();
        System.out.println("工作任务名称:"+jobKey.getName()+"  ;工作任务的组:"+jobKey.getGroup());
        System.out.println("任务类的名称(带路径):"+jobExecutionContext.getJobDetail().getJobClass().getName());
        System.out.println("任务类的名称:"+jobExecutionContext.getJobDetail().getJobClass().getSimpleName());

        //从JobDetail对象中获取jobDataMap的数据
        JobDataMap jobDataMap=jobExecutionContext.getJobDetail().getJobDataMap();
        String jobDataMessage = jobDataMap.getString("message");
        System.out.println("任务数据的参数值:"+jobDataMessage);
        //获取Trigger对象中获取jobDataMap的数据
        JobDataMap triggerDataMap = jobExecutionContext.getTrigger().getJobDataMap();
        String triggerDataMessage=triggerDataMap.getString("message");
        System.out.println("触发器的参数值:"+triggerDataMessage);
        //获取Trigger的内容
        TriggerKey key=jobExecutionContext.getTrigger().getKey();
        System.out.println("触发器名称:"+key.getName()+" ;触发器的组:"+key.getGroup());
        //获取其他内容
        System.out.println("当前任务的执行时间:"+dateFormat.format(jobExecutionContext.getFireTime()));
        System.out.println("下一次任务的执行时间:"+dateFormat.format(jobExecutionContext.getNextFireTime()));

        //工作内容
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是:"+dateString);
    }
}

(2 ) Job实现类中添加setter方法对应JobDataMap的键值, Quartz框架默认的jobFactory实现类在初始化job实例对象时会自动地调用这些setter方法。

    private String message;

    public void setMessage(String message) {
        this.message = message;
    }

注意:如果遇到同名的key,Trigger中的.usingJobData("message","simple触发器")会覆盖JobDetail中的.usingJobData("message","打印日志")

有状态的job和无状态的job

@PersistJobDataAfterExecution注解的使用//多次调用job的时候，会对job进行持久化，即保存一个数据信息
有状态的job可以理解为多次Job调用期间可以持有一些状态信息。这些状态信息存储JobDataMap中,而默认的无状态job每次调用时都会创建一个新的JobDataMap。

HelloJob类没有添加@PersistjobDataAfterExecution注解，每次调用时都会创建一个新的JobDataMap。不会累加;
HelloJob类添加@PersistJobDataAfterExecution注解，多次Job调用期间可以持有一些状态信息，即可以实现count的累加。

Trigger的介绍

Quartz有一些不同的触发最类型,不过,用得最多的是SimpleTrgger和CronTrigger,
(1 ) jobKey
表示job实例的标识,触发器被触发时,该指定的job实例会被执行。
( 2 ) startTime
表示触发器的时间表，第一次开始被触发的时间 ,它的教据类型是java.util.Date.
( 3 ) endTime
指定触发器终止被触发的时间,它的数据类型是java.util.Date.

HelloTrigger.java

@PersistJobDataAfterExecution //多次调用job的时候，会对job进行持久化，即保存一个数据信息
public class HelloTrigger implements Job {


    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //获取JobDetail的内容
        JobKey jobKey= jobExecutionContext.getJobDetail().getKey();
        System.out.println("工作任务名称:"+jobKey.getName()+"  ;工作任务的组:"+jobKey.getGroup());
        System.out.println("任务类的名称(带路径):"+jobExecutionContext.getJobDetail().getJobClass().getName());
        System.out.println("任务类的名称:"+jobExecutionContext.getJobDetail().getJobClass().getSimpleName());

        //从JobDetail对象中获取jobDataMap的数据
        JobDataMap jobDataMap=jobExecutionContext.getJobDetail().getJobDataMap();
        String jobDataMessage = jobDataMap.getString("message");
        System.out.println("任务数据的参数值:"+jobDataMessage);
        //获取Trigger对象中获取jobDataMap的数据
        JobDataMap triggerDataMap = jobExecutionContext.getTrigger().getJobDataMap();
        String triggerDataMessage=triggerDataMap.getString("message");
        System.out.println("触发器的参数值:"+triggerDataMessage);
        //获取Trigger的内容
        TriggerKey key=jobExecutionContext.getTrigger().getKey();
        System.out.println("触发器名称:"+key.getName()+" ;触发器的组:"+key.getGroup());
        //获取其他内容
        System.out.println("当前任务的执行时间:"+dateFormat.format(jobExecutionContext.getFireTime()));
        System.out.println("下一次任务的执行时间:"+dateFormat.format(jobExecutionContext.getNextFireTime()));

        //工作内容
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是:"+dateString);

        //获取jobKey、startTime、endTime
        Trigger trigger=jobExecutionContext.getTrigger();
        System.out.println("jobKey的名称:"+trigger.getJobKey().getName()+"jobKey的组名称:"+trigger.getJobKey().getGroup());
        System.out.println("任务的开始时间:"+dateFormat.format(trigger.getStartTime())+"任务的结束时间:"+dateFormat.format(trigger.getEndTime()));
    }
}

HelloSchedulerDemoTrigger.java

public class HelloSchedulerDemoTrigger {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //设置任务的开始时间
        Date startDate=new Date();
        //任务的开始时间推迟三秒
        startDate.setTime(startDate.getTime()+3000);
        //设置任务的结束时间
        Date endDate=new Date();
        //任务的结束时间推迟10秒(10秒后停止)
        endDate.setTime(endDate.getTime()+10000);
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloTrigger.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .usingJobData("message","打印日志") //传递参数，名称message
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
//                .startNow()//马上启动触发器
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().repeatSecondlyForever(5))
                .startAt(startDate) //设置任务的开始时间
                .endAt(endDate)//设置任务的结束时间
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        scheduler.start();
    }
}

SimpleTrigger触发器

SimpleTrigger对于设置和使用是最为简单的一种QuartzTrigger.
它是为那种需要在特定的日期/时间启动，且以一个可能的间隔时间重复执行n次的Job所设计的。

案例一:表示在一个指定的时间段内，执行一次作业任务

@PersistJobDataAfterExecution //多次调用job的时候，会对job进行持久化，即保存一个数据信息
public class HelloSimpleTrigger implements Job {
    
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //工作内容
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是:"+dateString);

    }
}

public class HelloSchedulerDemoSimpleTrigger {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //设置任务的开始时间
        Date startDate=new Date();
        //任务的开始时间推迟三秒
        startDate.setTime(startDate.getTime()+3000);
        //设置任务的结束时间
        Date endDate=new Date();
        //任务的结束时间推迟10秒(10秒后停止)
        endDate.setTime(endDate.getTime()+10000);
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloSimpleTrigger.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .usingJobData("message","打印日志") //传递参数，名称message
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startAt(startDate) //设置任务的开始时间
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        scheduler.start();
    }
}

案例二:或在指定的时间间隔内多次执行作业任务

        // 3:触发器(Trigger),马上执行，然后每5秒重复执行一次
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startAt(startDate) //设置任务的开始时间
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5).withRepeatCount(3))//5秒后重复执行,只重复执行4次(默认值是0)
                .build();

案例三:指定任务的结束时间

        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //设置任务的开始时间
        Date startDate=new Date();
        //任务的开始时间推迟三秒
        startDate.setTime(startDate.getTime()+3000);
        //设置任务的结束时间
        Date endDate=new Date();
        //任务的结束时间推迟10秒(10秒后停止)
        endDate.setTime(endDate.getTime()+10000);
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloSimpleTrigger.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .usingJobData("message","打印日志") //传递参数，名称message
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startAt(startDate) //设置任务的开始时间
                .endAt(endDate)
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5).withRepeatCount(3))//5秒后重复执行,只重复执行4次(默认值是0)
                .build();

需要注意的点
●SimpleTrigger的属性有 :开始时间、结束时间、重复次数和重复的时间间隔。
●重复次数属性的值可以为0、正整数、或常量SimpleTrigger.REPEAT_ INDEFINITELY。
●重复的时间间隔属性值必须为大于0或长整型的正整数,以毫秒作为时间单位,当重复的时间间隔为0时,意味着与Trigger同时触发执行。
●如果有指定结束时间属性值,则结束时间属性优先于重复次数属性,这样的好处在于:当我们需要创建一个每间隔10秒钟触发一次直到指定的结束时间的 Trigger ,而无需去计算从开始到结束的所重复的次数,我们只需简单的指定结束时间和使用REPEAT_ INDEFINITELY作为重复次数的属性值即可。

CronTrigger触发器
如果你需要像日历那样按日程来触发任务,而不是像SimpleTrigger那样每隔特定的间隔时间触发, CronTriggers通常比SimpleTrigger更有用,因为它是基于日历的作业调度器。
使用CronTrigger ,你可以指定诸如“每个周五中午”,或者"每个工作日的9:30"”或者“从每个周一-、周三、周五的上午9 : 00到上午10 : 00之间每隔五分钟”这样日程安排来触发。甚至,像SimpleTrigger一样，CronTrigger也有一个startTIme以指定日程从什么时候开始,也有一一个 (可选的) endTIme以指定何时日程不再继续。
Cron表达式被用来配置CronTrigger实例。Cron表达式是一个由7个子表达式组成的字符串。每个子表达式都描述了一个单独的日程细节。这些子表达式用空格分隔,分别表示:
1. Seconds秒
2. Minutes分钟
3. Hours小时
4. Day-oF-Month月中的天
5. Month月
6. Day-of-Week周中的天
7. Year (optional field)年(可选的城)

取值:

单个子表达式可以包含范围或者列表。例如∶前面例子中的周中的天这个域(这里是"WED")可以被替换为"MON-FRI","MON, WED,FRI"或者甚至"MON-WED,SAT""。
所有的域中的值都有特定的合法范围，这些值的合法范围相当明显，例如∶秒和分域的合法值为0到59，小时的合法范围是0到23，Day-of-Month中值得合法凡范围是1到31，但是需要注意不同的月份中的天数不同。月份的合法值是1到12。或者用字符串JAN.FEB MAR,APR, MAY,JUN,JUL,AUG, SEP, OCT,NOV及DEC来表示。Days-of-Week可以用1到7来表示（1=星期日）或者用字符串SUN,MON,TUE, WED,THU, FRI和SAT来表示.

@PersistJobDataAfterExecution //多次调用job的时候，会对job进行持久化，即保存一个数据信息
public class HelloCronTrigger implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //工作内容
        System.out.println("正在进行数据库的备份工作，备份数据库的时间是:"+dateString);

    }
}

public class HelloSchedulerDemoCronTrigger {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        //设置任务的开始时间
        Date startDate=new Date();
        //任务的开始时间推迟三秒
        startDate.setTime(startDate.getTime()+3000);
        //设置任务的结束时间
        Date endDate=new Date();
        //任务的结束时间推迟10秒(10秒后停止)
        endDate.setTime(endDate.getTime()+10000);
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloCronTrigger.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .usingJobData("message","打印日志") //传递参数，名称message
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
//                .startAt(startDate) //设置任务的开始时间
//                .endAt(endDate)//设置任务的结束时间
                  .startNow() //马上开始
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * 9 4 ?"))//日历 每5秒执行一次
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //启动
        scheduler.start();
    }
}

小提示:
L和W可以一起使用J（企业可用在工资计算)
'#'可表示月中第几个周几。(企业可用在计算母亲节和父亲节)
周字段英文字母不区分大小写，例如MON==mon。
利用工具，在线生成。

大家都知道，一个作业，比较重要的三个要素就是Schduler , jobDetail , Trigger ;而Trigger对于job而言就好比一个驱动器;没有触发器来定时驱动作业，作业就无法运行;对于Job而言，一个job可以对应多个Trigger，但对于Trigger而言，一个Trigger只能对应一个job;所以一
个Trigger只能被指派给一个Job;如果你需要一个更复杂的触发计划，你可以创建多个Trigger并指派它们给同一个Job。

scheduler的创建方式:

stdSchedulerFactory:
Quartz默认的SchedulerFactory
使用一组参数( java.util.Properties）来创建和初始化Quartz调度器
配置参数一般存储在quartz.properties文件中
调用getScheduler方法就能创建和初始化调度器对象

SchedulerFactory schedulerFactory = new stdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getscheduler();

我们也可以在项目的资源下添加quartz.properties文件，去覆盖底层的配置文件。

组成部分
调度器属性
org.quartz.scheduler.instanceName属性用来区分特定的调度器实例，可以按照功能用途来给调度器起名。org.quartz.scheduler.nstanceld属性和前者一样，也允许任何字符串，但这个值必须在所有调度器实例中是唯一的，尤其是在一个集群环境中，作为集群的唯一key。假如你想Quartz帮你生成这个值的话，可以设置为AUTO。

线程池属性
threadCount
处理]ob的线程个数，至少为1，但最多的话最好不要超过100，在多数机器上设置该值超过100的话就会显得相当不实用了，特别是在你的Job执行时间较长的情况下
threadPriority
线程的优先级，优先级别高的线程比级别低的线程优先得到执行。最小为1，最大为10，默认为5

org.quartz.threadPool.class
一个实现了org.quartz.spi.ThreadPool接口的类，Quartz自带的线程池实现类是org.quartz.smpl.SimpleThreadPool
·作业存储设置
描述了再调度器实例的生命周期+，Job和Trigger信息是如何被存储的。·插件配置
满足特定需求用到的Quartz插件的配置。
·插件配置
满足特定需求用到的Quartz插件的配置。

八、Quartz监听器

概念

Quartz的监听器用于当任务调度中你所关注事件发生时,能够及时获取这一事件的通知。类似于任务执行过程中的邮件、短信类的提醒。Quartz监听器主要有JobListener、TriggerListener、 SchedulerListener三种 ,顾名思义,分别表示任务、触发器、调度器对应的监听器。三者的使用方法类似,在开始介绍三种监听器之前,需要明确两个概念:全局监听器与非全局监听器,二者的区别在于:
全局监听器能够接收到所有的Job/Trigger的事件通知,
而非全局监听器只能接收到在其上注册的Job或Trigger的事件,不在其上注册的Job或Trigger则不会进行监听。

JobListener

任务调度过程中，与任务]ob相关的事件包括i job开始要执行的提示job执行完成的提示灯
1) getName方法︰用于获取该JobListener的名称。
2) jobToBeExecuted方法:Scheduler在JobDetail将要被执行时调用这个方法。
3) jobExecutionVetoed方法 :Scheduler在obDetail即将被执行，但又被TriggerListerner否决时会调用该方法
4) jobWasExecuted方法: Scheduler在JobDetail被执行之后调用这个方法

@PersistJobDataAfterExecution //多次调用job的时候，会对job进行持久化，即保存一个数据信息
public class HelloJobListener implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //输出当前时间
        Date date=new Date();
        SimpleDateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String dateString=dateFormat.format(date);
        //工作内容
        System.out.println("正在进行数据库的备份工作，备份数据库的时间:"+dateString);
    }
}

TiggerListener

任务调度过程中，与触发器Trigger相关的事件包括︰触发器触发、触发器未正常触发、触发器完成等。

public interface TriggerListener {

    String getName();

    
    void triggerFired(Trigger trigger, JobExecutionContext context);

    boolean vetoJobExecution(Trigger trigger, JobExecutionContext context);

    
    void triggerMisfired(Trigger trigger);


    void triggerComplete(Trigger trigger, JobExecutionContext context,
            CompletedExecutionInstruction triggerInstructionCode);

}

public class HelloSchedulerDemoTriggerListener {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloJobListener.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startNow()//马上启动触发器
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5).withRepeatCount(3))
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //创建并注册一个全局的Trigger Listener
        scheduler.getListenerManager().addTriggerListener(new MyTriggerListener("simplename"), EverythingMatcher.allTriggers());
        //创建并注册一个局部的Trigger Listener
        scheduler.getListenerManager().addTriggerListener(new MyTriggerListener("simplename"), KeyMatcher.keyEquals(TriggerKey.triggerKey("trigger1","group1")));
        //启动
        scheduler.start();
    }
}

public class MyTriggerListener implements TriggerListener {

    private String name;
    //构造方法，自定义传递的名称，默认是MyTriggerListener
    public MyTriggerListener(String name){
        this.name=name;
    }

    @Override
    public String getName() {
        String name = this.getClass().getSimpleName();
        System.out.println("触发器的名称:"+name);
        return name;
    }

    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext context) {
        String name = trigger.getKey().getName();
        System.out.println(name+"被触发");
    }

    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) {
        String name=trigger.getKey().getName();
        System.out.println(name+"没有被触发");
        return true; //true:表示不会执行job的方法
    }

    @Override
    public void triggerMisfired(Trigger trigger) {
        String name = trigger.getKey().getName();
        //Scheduler调用这个方法是在Trigger错过触发时
        System.out.println(name+"错过触发");
    }

    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext context, Trigger.CompletedExecutionInstruction triggerInstructionCode) {
        String name = trigger.getKey().getName();
        //Trigger被触发并且完成了Job的执行，Scheduler调用这个方法
        System.out.println(name+" 完成之后触发");

    }
}

其中:
1) getName方法︰用于获取触发器的名称
2)triggerFired方法:当与监听器相关联的Trigger被触发，Job上的execute()方法将被执行时，Scheduler就调用该方法。
3) vetoJobExecution方法:在Trigger触发后，Job将要被执行时由Scheduler调用这个方法。TriggerListener给了一个选择去否决Job的执行。假如这个方法返回true，这个Job将不会为此次Trigger触发而得到执行。
4)triggerMisfired方法 :Scheduler调用这个方法是在Trigger错过触发时。你应该关注此方法中持续时间长的逻辑∶在出现许多错过触发的Trigger时，长逻辑会导致骨牌效应。你应当保持这上方法尽量的小。
5) triggerComplete方法:Trigger被触发并且完成了Job的执行时，Scheduler调用这个方法。

SchedulerListener

SchedulerListener会在Scheduler的生命周期中关键事件发生时被调用。与Scheduler有关的事件包括∶增加一个job/trigger，删除一个job/trigger , scheduler发生严重错误，关闭scheduler等。

public interface SchedulerListener {

    void jobScheduled(Trigger trigger);

    void jobUnscheduled(TriggerKey triggerKey);

    void triggerFinalized(Trigger trigger);

    void triggerPaused(TriggerKey triggerKey);

    void triggersPaused(String triggerGroup);

    void triggerResumed(TriggerKey triggerKey);

    void triggersResumed(String triggerGroup);

    void jobAdded(JobDetail jobDetail);

    void jobDeleted(JobKey jobKey);

    void jobPaused(JobKey jobKey);

    void jobsPaused(String jobGroup);
    

    void jobResumed(JobKey jobKey);

    void jobsResumed(String jobGroup);

    void schedulerError(String msg, SchedulerException cause);

    void schedulerInStandbyMode();

    void schedulerStarted();

    void schedulerStarting();

    void schedulerShutdown();

    void schedulerShuttingdown();

    void schedulingDataCleared();
}

其中:
1) jobScheduled方法∶用于部署JobDetail时调用2) jobUnscheduled方法∶用于卸载JobDetail时调用Ⅰ
3)triggerFinalized方法:当一个Trigger来到了再也不会触发的状态时调用这个方法。除非这个Job已设置成了持久性，否则它就会从Scheduler中移除。
4)triggersPaused方法 :Scheduler调用这个方法是发生在一个Trigger或Trigger组被暂停时。假如是Trigger组的话，triggerName参数将为null。
5) triggersResumed方法 :Scheduler调用这个方法是发生成一个Trigger或 Trigger组从暂停中恢复时，假如是Trigger组的话，假如是Trigger组的话，triggerName参数将为null。参数将为null。
6) jobsPaused方法:当一个或一组JobDetail暂停时调用这个方法。
7)jobsResumed方法:当一个或一组Job从暂停上恢复时调用这个方法。假如是一个Job组，jobName参数将为null。

8) schedulerError方法∶在Scheduler的正常运行期间产生一个严重错误时调用这个方法
9) schedulerStarted方法:当Scheduler开启时，调用该方法
10) schedulerlnStandbyMode方法:当Scheduler处于StandBy模式时，调用该方法
11) schedulerShutdown方法:当Scheduler停止时，调用该方法
12) schedulingDataCleared方法:当Scheduler中的数据被清除时，调用该方法。

public class HelloSchedulerDemoSchedulerListener {
    public static void main(String[] args) throws Exception {
        // 1:调度器(Scheduler) ，从工厂中获取调度的实例(默认:实例化new StdSchedulerFactory();)
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        // 2:任务实例(JobDetail)
        JobDetail jobDetail= JobBuilder.newJob(HelloJobListener.class)//加载任务类，与HelloJob完成绑定,要求HelloJob实现Job接口
                .withIdentity("job1", "group1")// 参数1:任务的名称(唯- 实例) ;参数2:任务组的名称
                .build();
        // 3:触发器(Trigger)
        Trigger trigger= TriggerBuilder.newTrigger()
                .withIdentity("trigger1", "group1")// 参数1:触发器的名称(唯一实例) ;参数2:触发器组的名称
                .startNow()//马上启动触发器
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5).withRepeatCount(3))
                .build();
        //让调度器关联任务和触发器，保证按照触发器定义的条件执行任务
        scheduler.scheduleJob(jobDetail,trigger);
        //串讲调度器的监听
        scheduler.getListenerManager().addSchedulerListener(new MySchedulerListener());
        //移除对应的调度器的监听
        scheduler.getListenerManager().removeSchedulerListener(new MySchedulerListener());
        //启动
        scheduler.start();
        //线程延迟7秒后关闭
        Thread.sleep(7000L);
        //关闭调度器
        scheduler.shutdown();
    }
}

public class MySchedulerListener implements SchedulerListener {
    @Override
    public void jobScheduled(Trigger trigger) {
        String name=trigger.getKey().getName();
        //用于部署JobDetail时调用
        System.out.println(name+"完成部署");
    }

    @Override
    public void jobUnscheduled(TriggerKey triggerKey) {
        //用于卸载JobDetail时调用
        String name = triggerKey.getName();
        System.out.println(name+"完成卸载");
    }

    @Override
    public void triggerFinalized(Trigger trigger) {
        String name = trigger.getKey().getName();
        //当一个Trigger来到了再也不会触发的状态时调用这个方法。除非这个Job已设置成了持久性，否则它就会从Scheduler中移除。
        System.out.println("触发器被移除");
    }

    @Override
    public void triggerPaused(TriggerKey triggerKey) {
        String name = triggerKey.getName();
        //Scheduler调用这个方法是发生在一个Trigger或Trigger组被暂停时。假如是Trigger组的话，triggerName参数将为null。
        System.out.println(name+"正在被暂停");
    }

    @Override
    public void triggersPaused(String triggerGroup) {
        //
        System.out.println("触发器组"+triggerGroup+" 正在被暂停");
    }

    @Override
    public void triggerResumed(TriggerKey triggerKey) {
        //triggersResumed方法 :Scheduler调用这个方法是发生成一个Trigger或 Trigger组从暂停中恢复时，假如是Trigger组的话，假如是Trigger组的话，triggerName参数将为null。参数将为null。
        String name=triggerKey.getName();
        System.out.println(name+"正在从暂停中");
    }

    @Override
    public void triggersResumed(String triggerGroup) {
      //
        System.out.println("触发器组"+triggerGroup+"正在从暂停中恢复");
    }

    @Override
    public void jobAdded(JobDetail jobDetail) {
        System.out.println(jobDetail.getKey()+"添加工作任务");
    }

    @Override
    public void jobDeleted(JobKey jobKey) {
        System.out.println(jobKey+"删除工作任务");
    }

    @Override
    public void jobPaused(JobKey jobKey) {
        System.out.println(jobKey+"工作任务正在被暂停");
    }

    @Override
    public void jobsPaused(String jobGroup) {
        System.out.println("工作组"+jobGroup+"正在被暂停");
    }

    @Override
    public void jobResumed(JobKey jobKey) {
        System.out.println(jobKey+"正在从暂停中恢复");
    }

    @Override
    public void jobsResumed(String jobGroup) {
        System.out.println("工作组"+jobGroup+"正在从暂停中恢复");
    }

    @Override
    public void schedulerError(String msg, SchedulerException cause) {
        //在Scheduler的正常运行期间产生一个严重错误时调用这个方法
        System.out.println("产生严重错误的时候调用"+msg+" "+cause.getUnderlyingException());
    }

    @Override
    public void schedulerInStandbyMode() {
        //当Scheduler处于StandBy模式时，调用该方法
        System.out.println("调度器被挂起模式的时候调用");
    }

    @Override
    public void schedulerStarted() {
    //当Scheduler开启时，调用该方法
        System.out.println("调度器开启的时候调用");
    }

    @Override
    public void schedulerStarting() {
        System.out.println("调度器正在开启的时候调用");
    }

    @Override
    public void schedulerShutdown() {
        System.out.println("调度器关闭的时候调用");
    }

    @Override
    public void schedulerShuttingdown() {
        System.out.println("调度器正在关闭的时候调用");
    }

    @Override
    public void schedulingDataCleared() {
        //当Scheduler中的数据被清除时，调用该方法。
        System.out.println("调度器的数据被清除的时候");
    }
}

龍弟-idea

关注

11
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
6
评论
Quartz任务调度——快速入门

一、Quartz概念Quartz 是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，它可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。Quartz 可以用来创建简单调度,以执行十个，百个，甚至是好几万个 Jobs 这样复杂的程序。简单来说，quartz就是基于java实现的任务调度框架，用于执行你想要的任何任务。二、Quartz运行环境Quartz可以被实例化，作为独立的项目集群(负载平衡和故障转移功能)，用于作业的执行三、Quar
复制链接

扫一扫