Java定时任务调度之Quartz

最新推荐文章于 2024-07-30 07:15:00 发布

PzzZ

最新推荐文章于 2024-07-30 07:15:00 发布

阅读量518

点赞数

分类专栏： java 文章标签：任务调度 quartz

java 专栏收录该内容

59 篇文章 1 订阅

订阅专栏

Quartz :openSymphony提供的开源任务调度框架官网：http://www.quartz-scheduler.org/

Quartz主要用到的设计模式：Builder模式、factory模式、组件模式、链式写法

Quartz核心：调度器、任务、触发器

Quartz组成：JobDetail实现类、Trigger（simpleTrigger、cronTrigger）触发器、scheduler调度器（组合Job和Trigger）

Job：实现业务逻辑的任务接口

Job接口（重写execute函数）

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

JobDataMap：（1）在进行任务调度时JobDataMap存储在JobExecutionContext中，非常方便获取。

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

（3）JobDataMap实现了JDK的map接口，并且添加了一些方便的方法来存取基本数据类型。

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

JobDetail(描述Job的实现类)、JobBuilder（创建Job实例）、JobStore（保存执行信息）、name、group、 Jobclass、JobDataMap

Trigger：触发器

TriggerBuilder（定义触发器实例）

JobKey：Job实例标示

StartTime:触发器的时间首次触发，参数类型java.util.Date

EndTime:不再被触发的时间，参数类型java.util.Date

默认为SimpleTrigger，CronTrigger,基于日历作业调度，比SimpleTrigger更常用。

cron表达式：用来配置CronTrigger实例，是由7个自表达式组成的字符串，描述了时间表的详细信息。

格式：【秒】【分】【时】【日】【月】【周】【年】

通配符说明：* （每）？（不指定值）-（区间），（多个值）/（递增，5/15表示5秒开始每15秒一次）

L（最后）W（工作日，5W表示离5号最近的工作日，LW可以组合使用）#（序号，第几个），周字段不区分大小写，利用工具在线生成。

Scheduler：组合Job和Trigger，所有的实例应该由SchedulerFactory来创建。

监听器：JobListener、TriggerListener、SchedulerListener

创建方式：（1）SchedulerFactory sfact=new StdSchedulerFactory();

Scheduler scheduler=sfact.getScheduler();

（2）DirectScherFactory factory=DirectSchedulerFactory.getInstance();

Scheduler scheduler=dactory.getScheduler();

函数：start()开始；standyby()挂起;shutdown(true/false)是否自行完毕再关闭;

关于StdSchedulerFactory:使用一组参数来创建和初始化Quartz调度器，一般参数存储在quartz。properties中。 quartz.properties:（1）调度器属性：org.quartz.scheduler.instanceName：区分调度器实例

org.quartz.scheduler.instanceId;唯一标识，AUTO自动生成

（2）线程池属性：threadCount:threadpriority:org.quartz.threadPool.class

下面给出一小段例子：

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

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class HelloScheduler {

	public static void main(String[] args) throws SchedulerException {
		Date date = new Date();
		date.setTime((date.getTime()+6000L));
		//创建一个JobDetail，与HelloJob绑定
		JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
				.withIdentity("myJob", "group1").usingJobData("jobMessage", true).usingJobData("jobNum",1).build();
		System.out.println(jobDetail.getKey().getName());
		System.out.println(jobDetail.getKey().getGroup());
		System.out.println(jobDetail.getKey().DEFAULT_GROUP);
		System.out.println(jobDetail.getJobClass().getName());
		//创建一个Trigger，定义该job立即执行，每隔两秒钟执行一次
		SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1").usingJobData("triggerMessage", false).usingJobData("triggerNum",2).startNow().endAt(date)
				.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).withRepeatCount(1)).build();//重复次数，最终时间取最小
		//创建一个scheduler实例
		SchedulerFactory sfact = new StdSchedulerFactory();
	
		Scheduler s = sfact.getScheduler();
		s.start();
		
		Date date1 = new Date();
		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String currentTime =sf.format(date1);
		
		System.out.println(currentTime);
		s.scheduleJob(jobDetail, trigger);
	}
}


package com.test.HelloQuartz;

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{

	//JobDataMap传过来的值可自动保存在属性里
	private boolean jobMessage;
	
	private boolean triggerMessage;
	
	private int jobNum;
	
	private int triggerNum;
	
	
	public boolean isJobMessage() {
		return jobMessage;
	}


	public void setJobMessage(boolean jobMessage) {
		this.jobMessage = jobMessage;
	}


	public boolean isTriggerMessage() {
		return triggerMessage;
	}


	public void setTriggerMessage(boolean triggerMessage) {
		this.triggerMessage = triggerMessage;
	}


	public int getJobNum() {
		return jobNum;
	}


	public void setJobNum(int jobNum) {
		this.jobNum = jobNum;
	}


	public int getTriggerNum() {
		return triggerNum;
	}


	public void setTriggerNum(int triggerNum) {
		this.triggerNum = triggerNum;
	}


	public void execute(JobExecutionContext context) throws JobExecutionException {
		//编写业务逻辑
		Date date = new Date();
		SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String currentTime =sf.format(date);
		
		System.out.println(currentTime);
		JobKey jobKey = context.getJobDetail().getKey();
		TriggerKey triggerKey = context.getTrigger().getKey();
		System.out.println(jobKey.getName());
		System.out.println(triggerKey.getName());
		/*JobDataMap dataMap = context.getJobDetail().getJobDataMap();
		JobDataMap tdataMap =context.getTrigger().getJobDataMap();
		boolean jobMessage = dataMap.getBoolean("jobMessage");
                int jobNum = dataMap.getInt("jobNum");
                boolean triggerMessage = tdataMap.getBoolean("triggerMessage");
                int triggerNum = tdataMap.getInt("triggerNum");
                System.out.println(jobMessage);
                System.out.println(jobNum);
                System.out.println(triggerMessage);
                System.out.println(triggerNum);	*/
		
		System.out.println(jobMessage);
		System.out.println(jobNum);
		System.out.println(triggerMessage);
		System.out.println(triggerNum);
		
	}	
	
}

一、Quartz的特点
* 按作业类的继承方式来分，主要有以下两种：
1.作业类继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
2.作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
* 按任务调度的触发时机来分，主要有以下两种：
1.每隔指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.SimpleTriggerBean
2.每到指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.CronTriggerBean一、Quartz的特点
* 按作业类的继承方式来分，主要有以下两种：
1.作业类继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
2.作业类不继承org.springframework.scheduling.quartz.QuartzJobBean类的方式
* 按任务调度的触发时机来分，主要有以下两种：
1.每隔指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.SimpleTriggerBean
2.每到指定时间则触发一次，对应的调度器为org.springframework.scheduling.quartz.CronTriggerBean
注：这两种触发方式均可以跟两种作业继承方式相互组合来使用。
下面简单演示一下在spring对Quartz的用法。
二、作业类继承org.springframework.scheduling.quartz.QuartzJobBean类，每到指定时间则触发一次
1.编写作业类
注：这两种触发方式均可以跟两种作业继承方式相互组合来使用。
下面简单演示一下在spring对Quartz的用法。
二、作业类继承org.springframework.scheduling.quartz.QuartzJobBean类，每到指定时间则触发一次
1.编写作业类

spring配置quartz

applicationContext-quartz.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

    <bean id="mainTask" class="com.liaofang.service.MainTask"/>   
  
    <bean id="mainJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
                       <ref bean="mainTask"/>
         </property>
        <property name="targetMethod">
            <value>execute</value> 
        </property>
       
</bean>
<bean id="timeTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
       <property name="jobDetail">
           <ref bean="mainJob"/>
        </property>
<!-- 
0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时
0 0 12 ? * WED 表示每个星期三中午12点 
"0 0 12 * * ?" 每天中午12点触发 
"0 15 10 ? * *" 每天上午10:15触发 
"0 15 10 * * ?" 每天上午10:15触发 
"0 15 10 * * ? *" 每天上午10:15触发 
"0 15 10 * * ? 2005" 2005年的每天上午10:15触发 
"0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发 
"0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发 
"0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
"0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
"0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 
"0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发 
"0 15 10 15 * ?" 每月15日上午10:15触发 
"0 15 10 L * ?" 每月最后一日的上午10:15触发 
"0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发 
"0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
上面这个是quartz的语法 定时单位
 -->
        <property name="cronExpression">
            <value>0 59 23 * * ?</value> 
        </property>
</bean>
<bean id="sfb" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref local="timeTrigger"/>
            </list>
        </property>
</bean>
</beans>

web.xml

<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring/applicationContext-*.xml</param-value>
	</context-param>
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	 <listener-class>
       org.springframework.web.context.request.RequestContextListener
     </listener-class>
	</listener>

java类

package com.liaofang.service;


public class MainTask {
	

    public void execute(){
        
    	
     	//逻辑
    
    
    }
    
}

最近在整理一些资源工具，放在网站分享 http://tools.maqway.com
欢迎关注公众号：麻雀唯伊，不定时更新资源文章，生活优惠，或许有你想看的

PzzZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录