码迷,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
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!