java spring定时器配置_【spring配置】——spring整合Quartz定时器

最新推荐文章于 2022-05-06 21:30:10 发布
最新推荐文章于 2022-05-06 21:30:10 发布
阅读量562 收藏
点赞数
文章标签： java spring定时器配置
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_33746833/article/details/114557448
版权

第一种：为普通java类中的某个方法配置跑批任务

MethodInvokingJobDetailFactoryBean

CronTriggerBean

SchedulerFactoryBean

1.定义要跑批的类和方法：

package com.xy.utils.quartz;

import org.joda.time.DateTime;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

* 测试定时器类

* @author javaw

*

*/

public class TestQuartz {

public static Logger logger = LoggerFactory.getLogger(TestQuartz.class);

public void TestMethod(){

logger.info("Auto Execute TestMethod start! Date={}" ,new DateTime().toString("YYYY-MM-DD HH:mm:ss" ));

logger.info("**********测试跑批类************");

logger.info("Auto Execute TestMethod end! Date={}" ,new DateTime().toString("YYYY-MM-DD HH:mm:ss" ));

}

}

2.配置Spring定时器让quartz自动执行testMethod方法:

class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

3.写测试方法进行调用(不用启动tomcat):

public static void main(String[] args) {

SchedulerFactoryBean schedulerFactoryBean = (SchedulerFactoryBean) SpringUtilsFromClassPathXml.getBean( "testSchedulerFactoryBean");

//启动调度器

schedulerFactoryBean.start();

}

第二种：为继承QuartzJobBean的java类配置跑批任务

1.写java类继承QuartzJobBean，重写executeInternal 方法:

package com.xy.utils.quartz;

import org.joda.time.DateTime;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.scheduling.quartz.QuartzJobBean;

import org.springframework.scheduling.quartz.SchedulerFactoryBean;

/**

* 测试继承QuartzJobBean的java类配置定时器

* @author javaw

*

*/

public class TestQuartzExtendsJobBean extends QuartzJobBean{

private static Logger logger = LoggerFactory.getLogger(TestQuartzExtendsJobBean. class);

@Override

protected void executeInternal(JobExecutionContext context)

throws JobExecutionException {

logger.info("Auto Execute TestQuartzExtendsJobBean start! Date={}",new DateTime().toString( "YYYY-MM-DD HH:mm:ss"));

logger.info("**********"+content.getMergedJobDataMap().get("descString")+"************");

logger.info("Auto Execute TestQuartzExtendsJobBean end! Date={}",new DateTime().toString( "YYYY-MM-DD HH:mm:ss"));

}

}

2.配置文件：

class="org.springframework.scheduling.quartz.JobDetailBean">

value="com.xy.utils.quartz.TestQuartzExtendsJobBean"/>

class="org.springframework.scheduling.quartz.CronTriggerBean">

class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

第三种：定时任务持久化(JobDetailTx)

优势：

集群部署定时器通过故障切换和负载均衡的功能，提高调度器的可用性和扩展性。

本质：

集群上的所有节点通过共享一个数据库来来工作的。所有节点quartz通过启动两个维护线程来维护数据库状态实现集群管理，一个是检测节点状态线程，一个是恢复任务线程。一个 Quartz 集群中的每个节点是一个独立的 Quartz 应用，它又管理着其他的节点。

模式：

1.获取任务

负载均衡是自动完成的，集群的每个节点会尽快触发任务。当第一个节点获取到任务，会通过锁定，阻止其他线程获取到该任务。

2.故障切换

当一个节点执行任务失败(服务down掉或其他原因)，其他节点会检测到并标识在失败节点上正在执行的数据库中的任务。任何标记为可恢复(任务详细里的requests recovery属性)的任务都会被其他节点继续执行。没有标记可恢复的任务会被释放掉。

CREATE TABLE qrtz_job_details

(

....

JOB_NAME VARCHAR2(80) NOT NULL,

JOB_GROUP VARCHAR2(80) NOT NULL,

REQUESTS_RECOVERY VARCHAR2(1) NOT NULL, --可恢复标记

);

SchedulerFactoryBean

JobDetail

Trigger

Job

将定时任务持久化可以解决分布式跑批的问题，避免服务器重启信息丢失。

定时任务定义需要实例化JobDetail和Trigger，然后使用Scheduler进行调度。这个需要使用到Quartz的jar包。

每个jar包创建任务的方式都不相同。具体需要查看官方api。

quartz2.2.1中给出的示例：

JobDetail job = newJob(MyJob.class)

.withIdentity("myJob")

.build();

Trigger trigger = newTrigger()

.withIdentity(triggerKey("myTrigger", "myTriggerGroup"))

.withSchedule(simpleSchedule()

.withIntervalInHours(1)

.repeatForever())

.startAt(futureDate(10, MINUTES))

.build();

scheduler.scheduleJob(job, trigger);

导入jar包后，写如下测试类：

package com.xy.utils.scheduler;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerFactory;

import org.quartz.SimpleScheduleBuilder;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import org.quartz.impl.StdSchedulerFactory;

public class quartzTest {

public static void main(String args[]) throws Exception {

JobDetail jobDetail= JobBuilder.newJob(TestJob.class)

.withIdentity("job","group")

.build();

Trigger trigger= TriggerBuilder.newTrigger().withIdentity("job","group").startNow().withSchedule(

SimpleScheduleBuilder.simpleSchedule()

.withIntervalInSeconds(10)   //时间间隔

.withRepeatCount(10)        //重复次数n+1

)

.build();

SchedulerFactory sf = new StdSchedulerFactory();

Scheduler sched = sf.getScheduler();

sched.scheduleJob(jobDetail, trigger);

sched.start();

}

}

定时执行的任务类：

package com.xy.utils.scheduler;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class TestJob implements Job {

public void execute(JobExecutionContext arg0) throws JobExecutionException {

System.out.println("*****执行批处理任务******");

}

}

91935ef99f96914244f63d813e08e746.png

这种任务并没有持久化到数据库中。

在Spring中配置SchedulerFactoryBean：

配置quartz.properties:

下载了quartz.jar后，在\quartz-2.2.1\src\org\quartz\目录下有个quartz.properties的文件，可以根据自己的需要更改其中的配置内容。

#批处理常量表 QUARTZ2.2.1

#============================================================================

# Configure Main Scheduler Properties

#============================================================================

org.quartz.scheduler.instanceName = MyQuartzScheduler

org.quartz.scheduler.instanceId = AUTO

#============================================================================

# Configure ThreadPool

#============================================================================

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

org.quartz.threadPool.threadCount = 10

org.quartz.threadPool.threadPriority = 5

org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread:true

#============================================================================

# Configure JobStore

#============================================================================

org.quartz.jobStore.misfireThreshold = 10000

org.quartz.jobStore.class = org.springframework.scheduling.quartz.LocalDataSourceJobStore

org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

org.quartz.jobStore.isClustered = true --是否集群部署

#任务表前缀

org.quartz.jobStore.tablePrefix = test_qrtz_

创建任务表：

jar包文件中，给出了所有数据库的建表语句。可以根据给出的sql语句创建表。

6c74be495f947ffca196de468b17a2d5.png

调度类：

package com.xy.utils.scheduler;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SimpleScheduleBuilder;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import com.xy.utils.SpringUtils.SpringUtilsFromClassPathXml;

public class quartzTest {

//从Spring中获取调度bean工厂

public static Scheduler scheduler = (Scheduler)SpringUtilsFromClassPathXml.getBean("schedulerBeanFactory");

public static void main(String args[]) throws Exception {

JobDetail jobDetail= JobBuilder.newJob(TestJob.class)

.withIdentity("job","group")

.build();

Trigger trigger= TriggerBuilder.newTrigger().withIdentity("job","group").startNow().withSchedule(

SimpleScheduleBuilder.simpleSchedule()

.withIntervalInSeconds(10) //时间间隔

.repeatForever()

)

.build();

scheduler.scheduleJob(jobDetail, trigger);

scheduler.start();

}

}

任务类(需要实现job接口)：

package com.xy.utils.scheduler;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class TestJob implements Job {

public void execute(JobExecutionContext arg0) throws JobExecutionException {

System.out.println("*****执行批处理任务******");

}

}

此时执行该类就会将任务数据写入数据库中。

634d89b3e3a762d3e23145fa78ecab10.png

调度任务工具类：

自定义任务调度工具类：

package com.xy.utils.scheduler;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Date;

import org.quartz.CronScheduleBuilder;

import org.quartz.CronTrigger;

import org.quartz.DateBuilder;

import org.quartz.Job;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerException;

import org.quartz.SimpleScheduleBuilder;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import org.quartz.TriggerKey;

import org.quartz.DateBuilder.IntervalUnit;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.xy.common.SysContent;

public class SchedulerJobUtils {

private static Logger logger = LoggerFactory.getLogger(SchedulerJobUtils.class);

public static Scheduler scheduler = (Scheduler)SysContent.applicationContext.getBean("schedulerBeanFactory");

//public static Scheduler scheduler = (Scheduler)SpringUtilsFromClassPathXml.getBean("schedulerBeanFactory");

public static String dateFormate = "ss mm HH dd MM ? yyyy";

public static SimpleDateFormat cronSdf = new SimpleDateFormat(dateFormate);

public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

/**

* 数据库放入一个指定时间的任务，任务只执行一次

* @see 适合对数据进行定时删除，修改等等

* @param 

* @param clazz  要执行任务类class，任务类必须继承Job类

* @param jobName 任务名称

* @param groupName 分组名称

* @param executeTime 执行时间，格式:yyyy-MM-dd HH:mm:ss

* @return

*/

public static boolean putSpecifyTimeSchedulerJobToDB(Class extends Job> clazz,String jobName,String groupName,String executeTime){

//定义一个job

JobDetail job = JobBuilder.newJob(clazz).withIdentity(jobName, groupName).build();

//定义一个TriggerKey

TriggerKey triggerKey = TriggerKey.triggerKey(jobName, groupName);

SchedulerJob schedulerJob = new SchedulerJob();

schedulerJob.setJobName(jobName);

schedulerJob.setGroupName(groupName);

job.getJobDataMap().put("schedulerJob", schedulerJob);

Date executeDate = null;

try {

executeDate = sdf.parse(executeTime);

} catch (ParseException e) {

logger.info("method putSchedulerJobToDB execute error!exception={}",e);

}

String dbExecuteTime = cronSdf.format(executeDate);

CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(CronScheduleBuilder.cronSchedule(dbExecuteTime)).build();

try {

scheduler.scheduleJob(job, cronTrigger);

} catch (SchedulerException e) {

logger.info("method putSchedulerJobToDB execute error!exception={}",e);

}

return true;

}

/**

* 数据库放入一条指定开始时间，指定间隔时间，指定次数的任务

* @param 

* @param clazz 任务类

* @param jobName  任务名

* @param groupName 分组名

* @param seconds   间隔时间，以秒为单位

* @param count 执行次数，0为一直执行

* @param startSecondsToNow 开始时间(距离现在?秒)

* @return

* @throws SchedulerException

*/

@SuppressWarnings("unchecked")

public static boolean putPeriodSchedulerJobToDB(Class extends Job> clazz,String jobName,String groupName,

int seconds,int count,int startSecondsToNow){

JobDetail jobDetail= JobBuilder.newJob(clazz).withIdentity(jobName,groupName).build();

TriggerBuilder triggerBuilder = TriggerBuilder.newTrigger().withIdentity(jobName,groupName);

if(startSecondsToNow==0){

triggerBuilder.startNow();

}else{

triggerBuilder.startAt(DateBuilder.futureDate(startSecondsToNow,IntervalUnit.SECOND));

}

SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(seconds);

if(count==0){

scheduleBuilder.repeatForever();

}else{

scheduleBuilder.withRepeatCount(count);

}

Trigger trigger = triggerBuilder.withSchedule(scheduleBuilder).build();

try {

scheduler.scheduleJob(jobDetail,trigger);

} catch (SchedulerException e) {

logger.info("put putPeriodSchedulerJobToDB error,error={}",e);

}

return true;

}

}

任务类：

package com.xy.utils.scheduler;

import org.joda.time.DateTime;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class TestSchedulerTask implements Job{

private static Logger logger = LoggerFactory.getLogger(TestSchedulerTask.class);

public void execute(JobExecutionContext context) throws JobExecutionException {

logger.info("**********TestSchedulerTask1 start at={}",new DateTime().toString("yyyy-MM-dd HH:mm:ss"));

logger.info("**********I'm Ok!************");

logger.info("**********TestSchedulerTask1 end at={}",new DateTime().toString("yyyy-MM-dd HH:mm:ss"));

}

/**

* 调度任务工具类测试

* 10秒执行一次，无限次数，30秒后开始

* @param args

*/

public static void main(String[] args) {

System.out.println(SchedulerJobUtils.putPeriodSchedulerJobToDB(TestSchedulerTask.class, "myJob", "myGroup", 10, 0, 30));

}

}

数据库里的任务表：

cab3f1e391313683787ff5fd57c33d96.png

打印出的日志：

2016-01-10 00:37:34,810  INFO TestSchedulerTask1:14 - **********TestSchedulerTask1 start at=2016-01-10 00:37:34

2016-01-10 00:37:34,810  INFO TestSchedulerTask1:15 - **********I'm Ok!************

2016-01-10 00:37:34,811  INFO TestSchedulerTask1:16 - **********TestSchedulerTask1 end at=2016-01-10 00:37:34

2016-01-10 00:37:44,690  INFO TestSchedulerTask1:14 - **********TestSchedulerTask1 start at=2016-01-10 00:37:44

2016-01-10 00:37:44,691  INFO TestSchedulerTask1:15 - **********I'm Ok!************

2016-01-10 00:37:44,691  INFO TestSchedulerTask1:16 - **********TestSchedulerTask1 end at=2016-01-10 00:37:44

2016-01-10 00:37:54,697  INFO TestSchedulerTask1:14 - **********TestSchedulerTask1 start at=2016-01-10 00:37:54

2016-01-10 00:37:54,697  INFO TestSchedulerTask1:15 - **********I'm Ok!************

2016-01-10 00:37:54,697  INFO TestSchedulerTask1:16 - **********TestSchedulerTask1 end at=2016-01-10 00:37:54

黑科技玩机
关注
Quartz任务中调用Spring容器中bean及动态调度任务
John_Kong19的专栏
08-31 1040
[size=medium]Quartz 是开源任务调度框架中的翘首，它提供了强大任务调度机制，同时保持了使用的简单性。Quartz 允许开发人员灵活地定义触发器的调度时间表，并可以对触发器和任务进行关联映射。此外，Quartz提供了调度运行环境的持久化机制，可以保存并恢复调度现场，即使系统因故障关闭，任务调度现场数据并不会丢失。此外，Quartz还提供了组件式的侦听器、各种插件、线程池等功能。 ...
定时器Quartz ClassNotFound org.springframework.scheduling.quartz.SchedulerFactoryBean
weixin_33896726的博客
01-08 161
转自：https://blog.csdn.net/truong/article/details/37508003 没有添加spring-context-support-3.2.4.RELEASE.jar包 pom配置 <dependency> <groupId>org.springframework</groupId> <ar...
Spring整合Quartz框架实现定时任务跑批（Maven完整版）
reggergdsg的博客
08-01 1万+
Quartz 介绍 Quartz is a full-featured, open source job scheduling service that can be integrated with, or used along side virtually any Java application - from the smallest stand-alone application
ClassNotFound org.springframework.scheduling.quartz.SchedulerFactoryBean
qq_27173485的博客
03-13 1442
定时器报错Quartz ClassNotFound org.springframework.scheduling.quartz.SchedulerFactoryBean       需要依赖包"org.springframework:spring-context-support","org.quartz-scheduler:quartz:2.2.3", "org.springframework:s...
org.springframework.scheduling.quartz.SchedulerFactoryBean#0
a623397674a的专栏
09-20 3829
Cannot resolve reference to bean 'configTrigger' while setting bean property 'triggers' with key [0]; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean w
Spring中的Quartz配置-Spring-定时器-java定时器.doc
06-27
Spring 中的 Quartz 配置-Spring 定时器-java 定时器 在 Spring 框架中，Quartz 是一个非常流行的开源作业调度器，可以实现任务的定时执行。在本篇文章中，我们将讨论如何在 Spring 中配置 Quartz，以实现 Java ...
JAVA中 Spring定时器的两种实现方式
09-03
在Java的Spring框架中，定时任务的实现有多种方式，其中两种常见的实现是基于Java的`Timer`类和OpenSymphony的`Quartz`库。这两种定时器在Spring中的使用和配置有所不同，各有优缺点，适合不同的应用场景。 1. **...
quartzDaoImp.rar_quartz_spring定时_定时器
09-14
本项目"quartzDaoImp.rar_quartz_spring定时_定时器"提供了一段基于Spring集成Quartz实现定时任务的代码示例，可供学习和交流。 首先，了解Quartz的基本概念。Quartz允许开发者定义“作业”（Job）和“触发器”...
java Quartz定时器任务与Spring task定时的几种实现方法
08-31
在Java开发中，定时任务的实现有多种方式，其中Java Quartz和Spring Task是常用的两种解决方案。本文将详细介绍这两种定时任务的实现方法，并对比它们的特点。 首先，我们来看Java自带的`java.util.Timer`类。虽然...
定时器的配置文件（两种方式：springmvc自带定时,Quartz与spring结合的定时）
11-24
本篇文章将详细讲解两种在Spring MVC框架中实现定时任务的方法：Spring MVC自带的定时器以及Quartz与Spring的集成。 首先，我们来看看Spring MVC自带的定时任务。Spring MVC作为Spring框架的一个模块，主要处理HTTP...
Quartz异常-Error creating bean with name 'org.springframework.scheduling.quartz.SchedulerFactoryBean
TianXinCoord的博客
10-24 1万+
目录 一、问题描述 二、问题分析 三、问题解决 四、工程源码 4.1maven配置 4.2 web.xml 4.3 spring配置文件 4.4 Quartz配置文件 4.5 定时任务类 4.6 工程总体结构 一、问题描述     今天使用Quartz+Spring测试定时任务时，发现报异常：Error creating bean with name 'org.spring...
Spring2.5 定时器 错误 org.springframework.scheduling.quartz.SchedulerFactoryBean#0
z707208280的专栏
12-19 2万+
Spring2.5 定时器 错误 记录一下   一、 开发环境 MyEclipse6.5 、jdk1.5 、J2EE5 二、 使用技术 struts2 、hibernate、 Spring2.5 (1)、发生问题：严重: Exception sending context initialized event to listener instance of class org.springf
spring的定时执行代码 跑批
weixin_30603633的博客
10-15 255
最近公司上线了抽奖的活动，活动需求 1：每天凌晨更新状态，实现自动开启和关闭活动 2：活动结束自动抽取中奖号码 在这里提供spring的定时调度功能 1：首先是配置文件 在你的web.xml中，查看配置文件的路径，路径很多的时候 比如classpath*:spring-*.xml这种 只需要在其中一个spring-xx.xml配置 <!-- 加载所有的配置文件 -...
java跑批_【多线程应用】使用java自带线程池开发一个跑批程序
weixin_32137855的博客
02-22 935
前言多线程是java的比较重要的特性之一，现在记录一个使用多线程解决实际问题的栗子背景假设有一个模型服务，它的功能是通过输入的手机号来计算分数。例如支付宝的芝麻分。现在我有一个很大的客户手机号集合，数据量集是百万级别的。产品的要求是用尽可能短的时间将客户手机号集合中的每一个手机号都要匹配出分数。可行性分析假设模型服务成功处理一笔交易的时间是50ms，如果使用传统单线程的方式，每秒最多处理20笔交易...
JAVA如何实现多线程跑批,01、高并发(1)-线程的基础理论
weixin_31264565的博客
03-11 1018
内容导航从操作系统的发展了解进程、线程模型线程的优势线程的应用场景线程的生命周期线程的启动实现原理一、了解进程、线程模型每学习一个新的技术，我们都需要先去了解这个技术的背景，这个过程看似浪费时间，其实对于后续的学习过程中，能够促进理解很多问题。对于线程这个概念，可以先从操作系统讲起。因为操作系统的发展带来了软件层面的变革。从多线程的发展来看，可以将操作系统的发展分为三个历史阶段。1.真空管/穿孔打...
Quartz与Spring集成—— SchedulerFactoryBean的初始化分析
热门推荐
beliefer的博客
07-25 7万+
Quartz是一个开源的定时调度框架，支持集群部署。我们可以通过其Java API来使用它，或者通过Spring来配置与管理，也可以结合使用两种方式。本文重点分析Quartz与Spring集成时的初始化过程。
找不到org.springframework.scheduling.quartz.SchedulerFactoryBean类
小蜗牛的博客
04-09 8092
在spring整合quartz项目中，找不到org.springframework.scheduling.quartz.SchedulerFactoryBean类 解决方法之一 导入spring-context-support-4.2.4.RELEASE.jar包
Java——通过Java代码启动批处理文件（二）
前方一片光明
05-06 3386
前言 兄弟篇：Java——通过Java代码启动批处理文件（一） 第一篇是直接执行批处理文件，但是有两种情况不能处理： 1.路径里面带有空格的情况，2.环境变量设置问题； 本篇文章主要解决路径里面的空格问题，以及环境变量设置问题：The CATALINA_HOME environment variable is not defined correctly @Override public void exeCmdInFolder(String folderPath, String batName).
Spring Quartz定时器配置与使用实战
"本文档详细介绍了如何在Spring框架中使用Quartz定时器进行简单的配置和实际应用。首先，我们明确了所需的依赖项，包括Spring、Quartz、JTA等相关jar包，如quartz-all-1.6.0.jar、spring-quartz-1.8.4.jar等。这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值