码迷，mamicode.com
首页 > 其他好文 > 详细

第一个quartz程序

时间：2018-04-04 23:38:39      阅读：202      评论：0      收藏：0      [点我收藏+]

标签：private   编写   绑定   调用   回收   ann   current   是什么   stack   

1.maven配置:

        <!--quartz -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.1.7</version>
        </dependency>

 

技术分享图片

 

2.编写程序(实现每两秒打印当前日期并且不停的打印)

  • 实现job类(HelloJob.java)
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.TriggerKey;

public class HelloJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("current time is:"+sf.format(date));
        System.out.println("hello world");
        // 编写具体的业务逻辑
    }
}

 

 

  • HelloScheduler .java开启任务调度
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.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绑定    (链式写法XX.XX.XX)
            JobDetail jobDetail = newJob(HelloJob.class) // 定义Job类为HelloQuartz类，这是真正的执行逻辑所在
                    .withIdentity("myJob","group1") // 定义name/group
                    .build();//2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startNow()//现在开始
                    .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();
        }
    }
}

 

 

 

运行结果:

技术分享图片

 

3.浅谈job&jobDetail

  • job简介

　　Job:接口非常容易实现，只有一个execute方法，类似于Timer的run方法，在里面编写业务逻辑。

　　技术分享图片

 

　　job实例在quartz中的声明周期:

　　　　每次调度器在执行job时，它在执行execute方法前创建一个job实例

　　　　当调用完成之后，关联的job对象实例会被释放，释放的实例被垃圾回收期你回收。

 

  •  jobDetail简介

　　JobDetail为Job实例提供了许多设置属性，以及JobDataMap成员变量属性，它用来存储特定job实例的状态信息系，调度器需要借助Jobdetail对象来添加Job实例。

 

重要属性:

　　name：任务的名称，必须属性

　　group：任务所在的组，也是必须，默认值是DEFAULT，必须的

　　jobclass:任务的实现类，必须的

　　jobdatamap:用于传递传参数

 

例如:将上面代码改造获取jobDetail的属性

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.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,默认组是DEFAULT
                    .build();
            System.out.println("jobDetail‘s name:"+jobDetail.getKey().getName());
            System.out.println("jobDetail‘s group:"+jobDetail.getKey().getGroup());
            System.out.println("jobDetail‘s jobClass:"+jobDetail.getJobClass().getName());

            //2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startNow()//现在开始
                    .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();
        }
    }
}

 

结果:

技术分享图片

 

 4.浅谈JobExecutionContext与JobDataMap

  • JobExecutionContext简介

(1)当Scheduler调用一个Job，就会将JobExecutionContext传递给job的execute方法

　　quartz无法调用job的有参构造函数，所以创建job的实例的时候是运用反射机制，通过newInstance创建实例，并且通过JobDetail描述的name与group属性然后给Job设置一些属性。

(2)Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job本身的明细数据。

 

  • JobDataMap简介:

1.JobDataMap是什么?

(1)在进行任务调度时JobDataMap存储在JobExecutionContext中，非常方便获取

(2)JobDataMap可以用来装载任何可以序列化的数据对象，当job实例对象被执行时这些参数对象会传递给它

(3)JobDataMap实现了JDK的Map接口，并且添加了一些非常方便的方法用来存取数据基本数据类型。

 

2.获取JobDataMap的两种方式:

  • 第一种方式:从JobExecutionContext实例中获取

(1)从实例中获取JobDetail与Trigger单独的JobDataMap的方法

例如:

HelloJob.java(JobExecutionContext获取JobDataMap以及获取JobDetail和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.TriggerKey;

public class HelloJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("current time is:"+sf.format(date));
        // 编写具体的业务逻辑
        JobKey key = context.getJobDetail().getKey();//获取JobDetail的标识信息
        System.out.println("JobDetail‘s name and group are "+key.getName()+":"+key.getGroup());
        TriggerKey triggerKey = context.getTrigger().getKey();//获取Trigger的标识信息
        System.out.println("Trigger‘s name and group are "+triggerKey.getName()+":"+triggerKey.getGroup());
        //获取JobDetail通过JobDataMap传递的参数信息
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String jobMessage = jobDataMap.getString("message");
        Float floatValue = jobDataMap.getFloat("floatValue");
        System.out.println(jobMessage+"\t"+floatValue);
        //获取Trigger通过JobDataMap传递的信息
        JobDataMap triggerDataMap = context.getTrigger().getJobDataMap();
        String triggerMessage = triggerDataMap.getString("message");
        Double DoubleValue = triggerDataMap.getDouble("DoubleValue");
        System.out.println(triggerMessage+"\t"+DoubleValue);
        
    }
}

 

 

 HelloScheduler.java  通过usingJobData传递一些参数(JobDetail和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.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
                    .usingJobData("message","Hello myjob1")//使用JobDataMap传递参数给Job，传递一个string类型参数
                    .usingJobData("floatValue",8.5f)//使用JobDataMap传递参数给Job，传递一个float类型
                    .build();

            //2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startNow()//现在开始
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                    .usingJobData("message","Hello trigger1")
                    .usingJobData("DoubleValue",2.5D)
                    .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-04 09:53:15
JobDetail‘s name and group are myJob:DEFAULT
Trigger‘s name and group are myTrigger:group1
Hello myjob1 8.5
Hello trigger1 2.5

 

 (2)从实例中获取JobDetail与Trigger合并的JobDataMap的方法

 　　理论上是将JobDatail的JobDataMap和Trigger的JobDataMap合并，当我们获取两者有相同的key值的时候，优先获取的是Trigger的值，也就是JobDatail的会被覆盖

 

例如:

HelloJob.java(获取两者合并后的JobDataMap)

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.TriggerKey;

public class HelloJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("current time is:"+sf.format(date));
        // 编写具体的业务逻辑
        JobKey key = context.getJobDetail().getKey();//获取JobDetail的标识信息
        System.out.println("JobDetail‘s name and group are "+key.getName()+":"+key.getGroup());
        TriggerKey triggerKey = context.getTrigger().getKey();//获取Trigger的标识信息
        System.out.println("Trigger‘s name and group are "+triggerKey.getName()+":"+triggerKey.getGroup());
        //获取JobDetail通过JobDataMap传递的参数信息(获取两者合并后的JobDataMap)
        JobDataMap jobDataMap = context.getMergedJobDataMap();
        String message = jobDataMap.getString("message");
        Float floatValue = jobDataMap.getFloat("floatValue");
        System.out.println("message is :"+message);
        System.out.println("floatValue is :"+floatValue);
        Double DoubleValue = jobDataMap.getDouble("DoubleValue");
        System.out.println("DoubleValue is :"+DoubleValue);
        
    }
}

 

 

HelloScheduler.java

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.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
                    .usingJobData("message","Hello myjob1")//使用JobDataMap传递参数给Job，传递一个string类型参数
                    .usingJobData("floatValue",8.5f)//使用JobDataMap传递参数给Job，传递一个float类型
                    .build();

            //2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startNow()//现在开始
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                    .usingJobData("message","Hello trigger1")
                    .usingJobData("DoubleValue",2.5D)
                    .build();
            
            //3. 创建scheduler
            Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

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

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

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

 

运行结果:(如果JobDetail和Trigger的传递参数相同，使用合并后的JobDataMap获取的时候优先获取Trigger的参数)

技术分享图片

 

  • 第二种方式:Job实现类添加setter方法对应JobDataMap的键值(Quartz框架默认的JobFactory实现类在初始化job实例对象时会自动调用这些setter方法)

 例如:

HelloJob.java(添加成员属性，并且添加对应的get，set方法，类似于struts的属性注入，当我们在使用JobDataMap添加数据的时候会自动映射到这个类的成员实现方法中，需要注意的是成员属性的名字要和jobDataMap添加时候的key值相同)

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.TriggerKey;

public class HelloJob implements Job {
    
    private String message;
    private Float floatValue;
    private Double DoubleValue;

    public void execute(JobExecutionContext context) throws JobExecutionException {
        //打印当前的时间
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println("current time is:"+sf.format(date));
        // 编写具体的业务逻辑
        JobKey key = context.getJobDetail().getKey();//获取JobDetail的标识信息
        System.out.println("JobDetail‘s name and group are "+key.getName()+":"+key.getGroup());
        TriggerKey triggerKey = context.getTrigger().getKey();//获取Trigger的标识信息
        System.out.println("Trigger‘s name and group are "+triggerKey.getName()+":"+triggerKey.getGroup());
        System.out.println("message is :"+message);
        System.out.println("floatValue is :"+floatValue);
        System.out.println("DoubleValue is :"+DoubleValue);
    }

    public String getMessage() {
        return message;
    }

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

    public Float getFloatValue() {
        return floatValue;
    }

    public void setFloatValue(Float floatValue) {
        this.floatValue = floatValue;
    }

    public Double getDoubleValue() {
        return DoubleValue;
    }

    public void setDoubleValue(Double doubleValue) {
        DoubleValue = doubleValue;
    }
    
}

 

HelloScheduler.java

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.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
                    .usingJobData("message","Hello myjob1")//使用JobDataMap传递参数给Job，传递一个string类型参数
                    .usingJobData("floatValue",8.5f)//使用JobDataMap传递参数给Job，传递一个float类型
                    .build();

            //2. 定义一个Trigger，定义该job立即执行，并且每两秒钟执行一次，直到永远
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")// 定义名字和组
                    .startNow()//现在开始
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                    .usingJobData("message","Hello trigger1")
                    .usingJobData("DoubleValue",2.5D)
                    .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-04 10:11:29
JobDetail‘s name and group are myJob:DEFAULT
Trigger‘s name and group are myTrigger:group1
message is :Hello trigger1
floatValue is :8.5
DoubleValue is :2.5

 

 5.浅谈Trigger

 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()+"\tgroup:"+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

 

第一个quartz程序

标签：private   编写   绑定   调用   回收   ann   current   是什么   stack   

原文地址：https://www.cnblogs.com/qlqwjy/p/8719250.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！