Quartz入门看这一篇文章就够了

最新推荐文章于 2024-05-18 09:56:16 发布
最新推荐文章于 2024-05-18 09:56:16 发布
阅读量1.7k 收藏 11
点赞数 3
分类专栏： 编程学习 工作总结 文章标签： java servlet jvm 学习 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andrew_Chenwq/article/details/128823001
版权

第一章 Quartz简介

第一节 Quartz是什么?

1

Quartz [kwɔːts]是一个完全由Java编写的开源的作业调度框架

第二节 Quartz可以用来做什么?

  • 比如说买火车票下单之30分钟之后,查看是否付款
  • 付款完成之后,在乘车日期的时候是否乘车
  • 或者每个月1号扣房贷
  • 每个月20号自动还信用卡
  • 想定时在某一个时间,在到了那个时间的时候去执行某个任务

第二章 快速入门

第一节 常用API介绍

  • Job接口 
    1

    首先我们需要定义实现一个定时功能的接口,我们可以称之为Task(或Job)如定时发送邮件的task(Job)重启机器的task(Job)优惠券到期发送短信提醒的task(Job)

     

  • Trigger [ˈtrɪɡə(r)] 触发器 
    1

    有了任务之后,还需要一个能够实现触发任务去执行的触发器,触发器Trigger最基本的功能是指定Job的执行时间,执行间隔,运行次数等

     

  • Scheduler [ˈʃɛdjuːlə]调度器 
    1

    有了Job和Trigger后，怎么样将两者结合起来呢?即怎样指定Trigger去执行指定的Job呢?这时需要一个Schedule,来负责这个功能的实现

     

1
2
3
4

上面三个是Quartz的基本组成部分
1. 调度器: Scheduler
2. 任务:   Job,以及JobDetail
3. 触发器: Trigger,包括SimpleTrigger和CronTrigger

第二节 简单使用（API）

2.1 添加依赖

1
2
3
4
5
6

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.0</version>
</dependency>

2.2 简单代码

  • 自定义一个任务

    1
2
3
4
5
6
7
8
9
10
11
12
13

    /**
 * 创建一个被执行的任务
 */
public class HelloJob implements Job{
	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("任务被执行...."+sdf.format(new Date()));
	}
}

  • 启动任务,并设置每5秒执行一次

    1
2
3
4
5
6
7
8
9
10
11
12

    public static void main(String[] args) throws SchedulerException{
	//1.创建自定义的任务(job)对象
	JobDetail job = JobBuilder.newJob(HelloJob.class).build();
	//2.创建触发器(Trigger)对象,并设置触发规则,每格五秒触发一次Job
	Trigger trigger = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(5)).build();
	//3.创建任务调度(Scheduler)对象
	Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
	//4.将任务和触发器联系到一起
	scheduler.scheduleJob(job, trigger);
	//5.启动任务
	scheduler.start();
}

    2.3 核心对象介绍

  • JobDetail

    1

    JobDetail内部指定了Job的更详细的属性,比如说任务名称,任务群组等

  • Trigger

    1

    一个类，用于描述触发Job执行的时间规则
    • SimpleTrigger 
      1

      一次或者固定时间间隔周期的触发规则
    • CronTrigger 
      1

      通过cron表达式描述出更为复杂的触发规则

  • Scheduler

    1
2
3
4
5

    1. 代表一个Quartz的独立运行容器
2. Trigger和JobDetail被注册到Scheduler中
3. 二者在Scheduler中拥有各自的名称（name）和组名（group）
4. Trigger和JobDetail的名称和组名的组合必须唯一，但是Trigger的名称和组名的组合可以和JobDetail的相同，因为它们类型不同
5. 一个Job可以绑定多个Trigger

  • Calendar

    1

    Quartz提供的日历类。一个Trigger可以和多个Calendar关联，以此来排除一些特殊的日期

第三节 触发器API的使用

3.1 SimpleTrigger对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

public static void main(String[] args) throws SchedulerException {
		
	//1.创建自定义的任务(job)对象
	JobDetail job = JobBuilder.newJob(HelloJob.class).build();
	//2.创建触发器 设置任务启动5秒后开始执行job,一秒执行一次，执行5秒
	Date startDate = new Date();//开始时间
	startDate.setTime(startDate.getTime() + 2000);//设置5秒之后在执行
	Date endDate = new Date();//结束时间
	endDate.setTime(startDate.getTime() + 5000);//结束时间推迟5秒
	/**
	 * withIdentity               : 给任务添加名称和群组方便统一管理,比如可以设置多个触发器名字不同但是群组相同,因为一个任务可以绑定多个触发器
	 *  - name                    : 设置任务名称
	 *  - group                   : 设置群组名称
	 * startNow                   : 立即生效
	 * startAt                    : 触发器开始时间
	 * endAt                      : 触发器结束时间
	 * withSchedule               : 设置规则
	 * withIntervalInMilliseconds : 每隔1000毫秒执行一次Job(HelloJob);还可以使用withIntervalInSeconds方法单位是秒
	 * repeatForever              : 循环执行
	 */
	Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "triggerGroup1").
	startNow().
	startAt(startDate).
	endAt(endDate).
	withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInMilliseconds(1000).repeatForever()).
	build();
	//3.创建任务调度(Scheduler)对象
	Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
	//4.将任务和触发器联系到一起
	scheduler.scheduleJob(job, trigger);
	//5.启动任务
	scheduler.start();
}

3.2 CronTrigger对象

3.2.1 CronTrigger对象介绍

1
2
3

1. CronTrigger功能非常强大
2. 是基于日历的作业调度,而SimpleTrigger是精准指定间隔,所以相比SimpleTrigger,CroTrigger更加常用
3. CroTrigger是基于Cron表达式的

3.2.2 CronTrigger对象使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public static void main(String[] args) throws SchedulerException {
		
	//1.创建自定义的任务(job)对象
	JobDetail job = JobBuilder.newJob(HelloJob.class).build();
	//2.创建触发器,创建一个每天下午16时54分开始执行的触发器
	CronTrigger trigger = TriggerBuilder.newTrigger()
			.withIdentity("job01","group01")
			.startNow()
			.withSchedule(CronScheduleBuilder.cronSchedule("0 54 16 * * ?"))
			.build();
	//3.创建任务调度(Scheduler)对象
	Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
	//4.将任务和触发器联系到一起
	scheduler.scheduleJob(job, trigger);
	//5.启动任务
	scheduler.start();
}

3.2.3 Cron表达式

  • Cron表达式的语法格式 
    1
2
3
4
5

    Cron表达式是由7个子表达式组成的字符串,其中"年" 是可选的，可以不指定,格式如下:
[秒] [分] [小时] [日] [月] [周] [年]

例如1: 
表达式:  * 30 10 ? * 1/5 *    --> (从后向前解释) --> [指定年份]的[周一到周五][指定月][不指定日][上午10时][30分][指定秒]
  • 表达式的每个位置涉及到的符号的取值范围
位置时间域名允许值允许的特殊字符
1秒0-59, - * /
2分钟0-59, - * /
3小时0-23, - * /
4日期1-31, - * ? / L W C
5月份1-12, - * /
6星期1-7, - * ? / L C #
7年(可选)空值1970-2099, - * /

其中特殊字符的含义如下:

符号名称备注
星号（*）可用在所有字段中，表示对应时间域的每一个时刻。例如，*在分钟字段时，表示“每分钟”
问号（?）该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符
减号（-）表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12
逗号（,）表示一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五
斜杠（/）x/y表达一个等步长序列，x为起始值，y为增量步长值。如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用*/y，它等同于0/y
L该字符只在日期和星期字段中使用，代表“Last”的意思，但它在两个字段中意思不同。L在日期字段中，表示这个月份的最后一天，如一月的31号，非闰年二月的28号；如果L用在星期中，则表示一个星期的最后一天（也就是星期六，国外星期第一天为周天）。但是，如果L出现在星期字段里，而且在前面有一个数值X，则表示“这个月的最后一个星期X-1”，例如，6L表示该月的最后一个星期五，5L表示该月的最后一个星期四，以此类推
W该字符只能出现在日期字段里，是对前导日期的修饰，表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日，如果该月15号是星期六，则匹配14号星期五；如果15日是星期日，则匹配16号星期一；如果15号是星期二，那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月，如你指定1W，如果1号是星期六，结果匹配的是3号星期一，而非上个月最后的那天
LW组合在日期字段可以组合使用LW，它的意思是当月的最后一个工作日
井号（#）该字符只能在星期字段中使用，表示当月某个工作日。如6#3表示当月的第三个星期五（6表示星期五，#3表示当前的第三个），而4#5表示当月的第五个星期三，假设当月没有第五个星期三，忽略不触发
C该字符只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天
  • 常见的Cron表达式(大小写不敏感)
表示式说明
“0 0 12 * * ?”每天12点运行
“0 15 10 ? * *”每天10:15运行
“0 15 10 * * ?”每天10:15运行
“0 15 10 * * ? *”每天10:15运行
“0 15 10 * * ? 2008”在2008年的每天10:15运行
“0 * 14 * * ?”每天14点到15点之间每分钟运行一次，开始于14:00，结束于14:59
“0 0/5 14 * * ?”每天14点到15点每5分钟运行一次，开始于14:00，结束于14:55
“0 0/5 14,18 * * ?”每天14点到15点每5分钟运行一次，此外每天18点到19点每5钟也运行一次
“0 0-5 14 * * ?”每天14:00点到14:05，每分钟运行一次
“0 10,44 14 ? 3 WED”3月每周三的14:10分到14: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 2014-2016”在2014,2015,2016年每个月的最后一个星期五的10:15分运行
“0 15 10 ? * 6#3”每月第三个星期五的10:15分运行
  • 在线生成Cron表达式的工具地址 
    1
2

    旧版地址 : https://cron.qqe2.com/
新版地址 : https://qqe2.com/cron

第四节 Spring整合Quartz

Spring整合Quartz依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context-support</artifactId>
	<version>4.3.26.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>4.3.26.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.quartz-scheduler</groupId>
	<artifactId>quartz</artifactId>
	<version>>2.2.3</version>
</dependency>

4.1 方式一(JobDetailFactoryBean)

  • 创建任务类(实现Job接口) 
    1
2
3
4
5
6
7
8
9
10
11
12

    /**
 * 创建自定义任务类
 */
public class MyJob implements Job{

	public void execute(JobExecutionContext context) throws JobExecutionException {
		System.out.println("我的任务被执行了..."+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	}
}
  • 创建Spring配置文件(spring.xml) 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 创建任务 -->
	<bean id="job" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<!-- job名称 -->
		<property name="name" value="job1"></property>
		<!-- job分组 -->
		<property name="group" value="group1"></property>
		<!-- 指定具体的Job类 -->
		<property name="jobClass" value="com.qianfeng.qs.MyJob"></property>
	</bean>
	<!-- 创建触发器 -->
	<bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<!-- 设置触发器名称 -->
		<property name="name" value="trigger1"></property>
		<!-- 设置触发器群组 -->
		<property name="group" value="trigger_group1"></property>
		<!-- 设置触发的任务 -->
		<property name="jobDetail" ref="job"></property>
		<!-- 设置Cron表达式,每隔5s运行一次 -->
		<property name="cronExpression" value="*/5 * * * * ?"></property>
	</bean>
	<!-- 创建任务调度器 -->
	<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<ref bean="trigger"/>
			</list>
		</property>
	</bean>
</beans>
  • 测试 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

    public static void main(String[] args) throws SchedulerException, InterruptedException {
    //如果只是启动任务,那么只需要创建IOC容器即可
	ApplicationContext ioc = new ClassPathXmlApplicationContext("spring.xml");
	// 获取调度器
	StdScheduler scheduler = (StdScheduler) ioc.getBean("scheduler");
	// 获取任务
	JobKey jobKey = JobKey.jobKey("job1", "group1");
	// 任务的暂停(3秒之后暂停3秒)
	Thread.sleep(3000);
	scheduler.pauseJob(jobKey);
	// 任务的恢复(暂停3秒后恢复)
	Thread.sleep(3000);
	scheduler.resumeJob(jobKey);
	// 任务的删除(3秒之后删除)
	Thread.sleep(3000);
	scheduler.deleteJob(jobKey);
}

4.2 方式二(MethodInvokingJobDetailFactoryBean)

  • 创建任务类 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

    /**
 * 创建自定义任务类
 */
public class MyJob{
	/**
	 * 任务方法1(此方法用于测试SimpleTrigger触发器)
	 */
	public void task1() {
		System.out.println("SimpleTrigger生效了..."+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	}
	
	/**
	 * 任务方法2(此方法用于测试CronTrigger触发器)
	 */
	public void task2() {
		System.out.println("CronTrigger生效了..."+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
	}
}
  • 创建Spring配置文件(spring.xml) 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 将自定义任务类加入到IOC容器中 -->
	<bean id="myJob" class="com.qianfeng.qs.MyJob"></bean>
	
	<!-- 配置固定时长的任务类,并注入被任务调度类和任务方法 -->
	<bean id="jobDetail1" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
		<!-- 注册被调度类 -->
		<property name="targetObject" ref="myJob"></property>
		<!-- 注册被调度方法 -->
		<property name="targetMethod" value="task1"></property>
		<!-- 设置任务名称 -->
		<property name="name" value="job1"></property>
		<!-- 设置任务群组名称 -->
		<property name="group" value="group1"></property>
	</bean>
	
	<!-- 配置cron表达式的任务类,并注入被任务调度类和任务方法 -->
	<bean id="jobDetail2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
		<!-- 注册被调度类 -->
		<property name="targetObject" ref="myJob"></property>
		<!-- 注册被调度方法 -->
		<property name="targetMethod" value="task2"></property>
		<!-- 设置任务名称 -->
		<property name="name" value="job2"></property>
		<!-- 设置任务群组名称 -->
		<property name="group" value="group1"></property>
	</bean>
	
	<!-- 配置固定时长的触发器并配置任务的时间 -->
	<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
		<!-- 配置此触发器作用的任务类 -->
		<property name="jobDetail" ref="jobDetail1"></property>
		<!-- 指定触发器执行的时间间隔 -->
		<property name="repeatInterval" value="1000"></property>
	</bean>
	
	<!-- 配置cron表达式的触发器并配置任务的规则 -->
	<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<!-- 配置此触发器作用的任务类 -->
		<property name="jobDetail" ref="jobDetail2"></property>
		<!-- 指定触发器执行的时间间隔 -->
		<property name="cronExpression" value="0/1 * * * * ?"></property>
	</bean>
	
	<!-- 配置调度 -->
	<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<ref bean="simpleTrigger"/>
				<ref bean="cronTrigger"/>
			</list>
		</property>
	</bean>
	
</beans>
  • 测试 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14

    public static void main(String[] args) throws InterruptedException, SchedulerException{
	// 如果只是启动任务,那么只需要创建IOC容器即可
	ApplicationContext ioc = new ClassPathXmlApplicationContext("spring.xml");
	// 获取调度器
	StdScheduler scheduler = (StdScheduler) ioc.getBean("scheduler");
	// 获取某一个组的所有任务
	GroupMatcher<JobKey> group1 = GroupMatcher.groupEquals("group1");
	// 3秒之后暂停当前组的所有任务
	Thread.sleep(3000);
	scheduler.pauseJobs(group1);
	// 5秒之后恢复当前组的任务
	Thread.sleep(5000);
	scheduler.resumeJobs(group1);
}

第五节 Quartz默认配置文件

  • 简介 
    1
2
3
4

    设置quartz的初始化配置
quartz.properties 是Quartz的默认配置,主要使用配置和调度工厂类(StdSchedulerFactory)实例化调度对象(Scheduler)
默认存在于 quartz依赖的org.quartz.Scheduler路径下,如果想修改默认值可以在当前classpath下创建同名文件修改默认值
或者直接配置到spring的xml文件中
  • xml配置 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

	<!-- 创建任务 -->
	<bean id="job" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
		<!-- job名称 -->
		<property name="name" value="job1"></property>
		<!-- job分组 -->
		<property name="group" value="group1"></property>
		<!-- 指定具体的Job类 -->
		<property name="jobClass" value="com.qianfeng.qs.MyJob"></property>
	</bean>
	<!-- 创建触发器 -->
	<bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
		<!-- 设置触发器名称 -->
		<property name="name" value="trigger1"></property>
		<!-- 设置触发器群组 -->
		<property name="group" value="trigger_group1"></property>
		<!-- 设置触发的任务 -->
		<property name="jobDetail" ref="job"></property>
		<!-- 设置Cron表达式,每隔5s运行一次 -->
		<property name="cronExpression" value="*/1 * * * * ?"></property>
	</bean>
	<!-- 创建任务调度器 -->
	<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
		<property name="triggers">
			<list>
				<ref bean="trigger"/>
			</list>
		</property>
		<!-- 
			设置quartz的初始化配置
			quartz.properties 是Quartz的默认配置,主要使用配置和调度工厂类(StdSchedulerFactory)实例化调度对象(Scheduler)
			默认存在于 quartz依赖的org.quartz.Scheduler路径下,如果想修改默认值可以在当前classpath下创建同名文件修改默认值
			或者直接配置到spring的xml文件中
		 -->
		<!-- <property name="configLocation" value="classpath:quartz.properties"></property> -->
		<!-- <property name="quartzProperties">
			<props>
				<prop key="org.quartz.scheduler.instanceName">DefaultQuartzScheduler</prop>
			</props>
		</property> -->
	</bean>
</beans>

第六节 Quartz和Spring框架整合解决在任务中不能注入的问题

6.1 Quartz不能注入service或者dao(mapper)层原因

1

这个Job是由quartz实例化出来的,不受Spring的管理,所以就导致注入失败

6.2 解决方案

  • 如何将非Spring的IOC容器创建的bean加入到IOC容器中? 
    1
2
3
4
5
6
7

    我们的任务是由Spring框架的spring-context-support依赖中SpringBeanJobFactory类的createJobInstance方法创建
但是只是创建了对象却没有加入到IOC容器中,所以要想将任务加入到IOC容器中首先就是需要继承SpringBeanJobFactory类并重写createJobInstance方法
将创建的任务对象手动加入到IOC容器中,那么问题来了,我们创建好了任务之后怎么加入到Spring的IOC容器中呢???

↓↓↓↓↓↓↓↓

AutowireCapableBeanFactory可以实现对已存在实例进行管理,捆绑并填充并不由Spring管理生命周期并已存在的对象.
  • 重写用于生成job实例的SpringBeanJobFactory 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

    /**
 * 重写SpringBeanJobFactory类,用于生成job实例,并且使用AutowireCapableBeanFactory类
 * 的autowireBean方法将新生成的job实例加入到IOC中
 */
public class CustomerJobFactory extends SpringBeanJobFactory {
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        //创建job实例
        Object jobInstance = super.createJobInstance(bundle);
        //将job实例通过AutowireCapableBeanFactory的autowireBean方法加入到IOC中进行管理
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}
  • 将重写了的SpringBeanJobFactory加入到IOC中进行实例化 
    1
2

    <!--设置id方便被引用-->
<bean id="customJobFactory" class="com.qianfeng.task.CustomJobFactory"></bean>
  • Quartz在Spring中的配置 
    1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

    <!--将重写了的SpringBeanJobFactory加入到IOC中进行实例化-->
<bean id="customJobFactory" class="com.qianfeng.task.CustomJobFactory"></bean>

<!--配置quartz-->
<bean id="job" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <!-- job名称 -->
    <property name="name" value="job1"></property>
    <!-- job分组 -->
    <property name="group" value="group1"></property>
    <!-- 指定具体的Job类 -->
    <property name="jobClass" value="com.qianfeng.job.HelloJob"></property>
</bean>
<!-- 创建触发器 -->
<bean id="trigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <!-- 设置触发器名称 -->
    <property name="name" value="trigger1"></property>
    <!-- 设置触发器群组 -->
    <property name="group" value="trigger_group1"></property>
    <!-- 设置触发的任务 -->
    <property name="jobDetail" ref="job"></property>
    <!-- 设置Cron表达式,每隔5s运行一次 -->
    <property name="cronExpression" value="*/5 * * * * ?"></property>
</bean>
<!-- 创建任务调度器 -->
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <!--在调度器中重新引入自定义的SpringBeanJobFactory,这时的任务已经被加入到了IOC中-->
    <property name="jobFactory" ref="customJobFactory"></property>
    <property name="triggers">
        <list>
            <ref bean="trigger"/>
        </list>
    </property>
</bean>
IT枫斗者
关注
  • 3
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
quartz入门共3页.pdf.zip
11-22
quartz入门共3页.pdf.zip
Quartz如何从入门到精通.pdf
09-04
Quartz让任务调度简单，Quartz框架整合了许多额外功能，但就其简易形式看，你会发现它易用得简直让人受不了！简单地创建一个实现org.quartz.Job接口的Java类。Job接口包含唯一的方法：execute()。在你的Job接口实现...
Quartz快速入门
程序猿_杨Sir
04-04 3487
一、Quartz概念 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与2EE与|2SE应用程序相结合也可以单独使用。 quartz是开源且具有丰富特性的"任务调度库"，能够集成于任何的java应用，小到独立的应用，大至电子商业系统。quartz能够创建亦简单亦复杂的调度，以执行上十、上百，甚至上万的任务。任务job被定义为标准的java组件，能够执行任何你想要实现的功能。quartz调度框架包含许多企业级的特性，如JTA事务、集群的支持。 简而言
Quartz简介
ThinkWon的博客
11-22 1万+
文章目录Quartz 是什么What is the Quartz Job Scheduling Library?使用场景特点Quartz 使用的设计模式核心元素SchedulerTriggerCalendarJobDetailJobJobExecutionContext核心元素之间的关系Quartz 类图主要线程数据存储 最近做了一个活动管理的项目，项目中有活动开始通知和活动结束通知等功能，需要创建大量的定时任务，最后选择使用 Quartz 分布式调度框架。本文主要是对Quartz的简单介绍，了解 Qua
Quartz 配置
最新发布
tokyou的专栏
05-18 972
Quartz 是一个功能强大的开源作业调度库，提供了丰富的配置选项来控制作业调度的行为和特性。
Quartz入门——定时任务动态添加修改及持久化与自动恢复
Robod的博客
08-16 5403
这篇文章就带小伙伴们了解一下Quartz的基本使用。包括基本概念以及如何动态地的定时任务进行CRUD，并且如何实现定时任务的持久化以及任务恢复
Quartz 快速入门案例，看这一篇就够了
~~~~~~~BUG FLY~~~~~~~~~
02-14 7126
Quartz 是基于 Java 实现的任务调度框架，对任务的创建、修改、删除、触发以及监控这些操作直接提供了 api，这意味着开发人员拥有最大的操作权，也带来了更高的灵活性。
任务调度 Quartz 框架使用指南
墨鸦的博客
09-14 7359
任务调度 Quartzh 框架使用指南
quartz scheduler 入门教程
07-08
quartz scheduler 入门教程 Quartz Scheduler 是一种功能丰富、开源的任务调度程序库，可以在任何 Java 程序中使用。它可以用来创建简单或者复杂的执行次数可以达成千上万的任务。任务可以是任何 Java 可以做的事情...
定时任务框架Quartz
m0_53151031的博客
02-11 8385
一、spring自带调度器 二、Quartz集成 三、Quartz内存版基本使用
quartz动态任务管理
07-01
quartz动态任务管理源码，为了方便各位需要者。
quartz获取所有运行中Job的方法
热门推荐
tensorzhl的专栏
03-06 1万+
每个job都会有job执行上下文：JobExecutionContext 。 public void execute(JobExecutionContext context) ; 通过job执行上下文获取Scheduler： context.getScheduler(); 然后调用getJobKeys就可以获得所有运行中的Job了： Set&lt;JobKey&gt; jobKeySet =...
Quartz入门
萝卜_7
08-30 560
Quartz任务调度 1. Quartz概念 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目 Quartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。 Quartz 可以与 J2EE 与 J2SE 应用程序相结合也可以单独使用。 Quartz 允许程序开发人员根据时间的间隔来调度作业。 Quartz 实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。 2. 核心 Jo
Quartz入门例子简介 从入门到菜鸟(一)
weixin_30414635的博客
05-03 230
摘要: 前面用过Quartz的功能，学新工具一般都是先用再写再看源码。其实应用场景很容易想象，比如每个月20号要发工资，数据库里面某些字段要标记为已发，或者要进行记账之类的，那么这时候可以用quartz来写表达式，就可以让系统自动的在每个月20号执行这些任务。 刚接触quartz这个词并不是在学习过程中。。。而是WOW里面的界面插件。。。 汗=。=言归正传，入门教程，不喜勿喷。网上看到...
Quartz入门例子简介 从入门到菜鸟(三)
weixin_30751947的博客
05-03 99
前面两个博客讲的都是简单触发器，直接传入一个时间让任务执行，这一话讲CronTrigger的例子。CronTrigger也是Quartz最重要的特色之一，通过Quartz特有的Cron表达式来确定某类时间，能完成类似"每个月二十号XXX，每个星期三XXX"之类的任务。先对MyJob做个小的修改，时间用中文来输出，不然看起来太费劲，逻辑上没有任何修改。Java代码 publiccl...
浅谈+详解Quartz定时任务，快速入门Quartz。
EatingSoilLang
11-13 754
大部分公司都会用到定时任务功能。举两个生活中的例子，例如火车票购票之后，后台就会插入一条待支付的task(job)；再比如说优惠券快到期了，通过定时任务向未使用的用户发送提醒…还有很多类似的实际应用场景。这些提醒或者计时的工作当然不可能人工操作，那么我们就必须实现一个定时任务去实现这些功能。 Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。但是相较于Timer， Quartz增加了
Quartz定时任务（纯java方式实现）
_cheny
11-21 7954
1.首先说一下Quartz的三个核心概念 任务：就是执行的工作内容。Quartz提供Job接口来支持任务定义 触发器：定义触发Job执行的时间触发规则。Quartz提供Trigger类及其子类支持触发器功能， 调度器：Quartz提供了Scheduler接口，将工作任务和触发器绑定，保证任务可以在正确的时间执行 2.这是定时任务需要用到的jar包 这里附加
Quartz.NET入门用法
06-09
Quartz.NET是一款开源的任务调度框架，可以用于在.NET应用程序中调度作业（Job）和触发器（Trigger）。...当然，这只是Quartz.NET的入门用法，Quartz.NET还有很多高级功能和配置选项，可以根据具体需求进行使用和配置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

IT枫斗者

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值