10.1 pom.xml添加如下配置:
<!-- quartz定时任务 -->
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
</dependency>
10.2 resources目录增加配置文件quartz.properties
# thread-pool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=10
# job-store
org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
10.3 Quartz定时任务例子
1. 数据库创建定时任务调度表
CREATE TABLE `job_config` (
`id` INT(11) NOT NULL AUTO_INCREMENT,
`create_time` DATETIME DEFAULT NULL,
`cron_time` VARCHAR(50) NOT NULL COMMENT '执行时间 例:0/8 * * * * ?',
`full_entity` VARCHAR(255) NOT NULL COMMENT '任务类全路径',
`group_name` VARCHAR(100) NULL COMMENT '任务组名称',
`name` VARCHAR(100) NOT NULL COMMENT '任务名',
`status` VARCHAR(2) NOT NULL COMMENT '任务状态，0-无效 1-有效',
`update_time` DATETIME DEFAULT NULL,
`remark` VARCHAR(255) NOT NULL COMMENT '备注',
PRIMARY KEY (`id`),
UNIQUE KEY `group_name` (`group_name`,`name`)
)
DEFAULT CHARSET = utf8;
INSERT INTO `job_config` (`create_time`, `cron_time`, `full_entity`, `group_name`, `name`, `status`, `update_time`, `remark`) VALUES (now(), '0/7 * * * * ?', 'com.smallbss.quartz.CallEPCJob', 'instructions', 'call_ecp', '1', now(),'定时发指令');
2. <!--[endif]-->配置config启动定时任务
QuartzConfig类：
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import java.util.List;
@Configuration
public class QuartzConfig {
Logger logger = LoggerFactory.getLogger(getClass());
@Autowired
private ApplicationContext applicationContext;
@Autowired
private QuartzConfigService quartzConfigService;
@Bean
public StdSchedulerFactory stdSchedulerFactory() {
StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
// 获取JobConfig集合
List<QuartzBean> quartzList = quartzConfigService.findAllByStatus(1);
logger.debug("Setting the Scheduler up");
for (QuartzBean quartz : quartzList) {
try {
Boolean flag = SchedulerUtil.createScheduler(quartz, applicationContext);
logger.info("quartz job " + quartz.getName() + " Path:" + quartz.getFullEntity() + " start... 执行结果："
+ flag);
} catch (Exception e) {
e.printStackTrace();
}
}
return stdSchedulerFactory;
}
}
SchedulerUtil 类：
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.text.ParseException;
public class SchedulerUtil {
// 定时任务Scheduler的工厂类，Quartz提供
private static StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
// CronTrigger的工厂类
private static CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
// JobDetail的工厂类
private static JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
// 自动注入Spring Bean的工厂类
private static AutoWiringSpringBeanJobFactory jobFactory = new AutoWiringSpringBeanJobFactory();
// 定时任务Scheduler的工厂类，Spring Framework提供
private static SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
static {
// 加载指定路径的配置
schedulerFactoryBean.setConfigLocation(new ClassPathResource("quartz.properties"));
}
/**
* 创建定时任务，根据参数，创建对应的定时任务，并使之生效
*
* @param config
* @param context
* @return
*/
public static boolean createScheduler(QuartzBean config, ApplicationContext context) {
try {
// 创建新的定时任务
return create(config, context);
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 删除旧的定时任务，创建新的定时任务
*
* @param oldConfig
* @param config
* @param context
* @return
*/
public static Boolean modifyScheduler(QuartzBean oldConfig, QuartzBean config, ApplicationContext context) {
if (oldConfig == null || config == null || context == null) {
return false;
}
try {
String oldJobClassStr = oldConfig.getFullEntity();
String oldName = oldJobClassStr + oldConfig.getId();
String oldGroupName = oldConfig.getGroupName();
// 1、清除旧的定时任务
delete(oldName, oldGroupName);
// 2、创建新的定时任务
return create(config, context);
} catch (SchedulerException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 提取的删除任务的方法
*
* @param oldName
* @param oldGroupName
* @return
* @throws SchedulerException
*/
private static Boolean delete(String oldName, String oldGroupName) throws SchedulerException {
TriggerKey key = new TriggerKey(oldName, oldGroupName);
Scheduler oldScheduler = schedulerFactory.getScheduler();
// 根据TriggerKey获取trigger是否存在，如果存在则根据key进行删除操作
Trigger keyTrigger = oldScheduler.getTrigger(key);
if (keyTrigger != null) {
oldScheduler.unscheduleJob(key);
}
return true;
}
/**
* 提取出的创建定时任务的方法
*
* @param config
* @param context
* @return
*/
private static Boolean create(QuartzBean config, ApplicationContext context) {
try {
// 创建新的定时任务
String jobClassStr = config.getFullEntity();
Class clazz = Class.forName(jobClassStr);
String name = jobClassStr + config.getId();
String groupName = config.getGroupName();
String description = config.toString();
String time = config.getCronTime();
JobDetail jobDetail = createJobDetail(clazz, name, groupName, description);
if (jobDetail == null) {
return false;
}
Trigger trigger = createCronTrigger(jobDetail, time, name, groupName, description);
if (trigger == null) {
return false;
}
jobFactory.setApplicationContext(context);
schedulerFactoryBean.setJobFactory(jobFactory);
schedulerFactoryBean.setJobDetails(jobDetail);
schedulerFactoryBean.setTriggers(trigger);
schedulerFactoryBean.afterPropertiesSet();
Scheduler scheduler = schedulerFactoryBean.getScheduler();
if (!scheduler.isShutdown()) {
scheduler.start();
}
return true;
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (SchedulerException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 根据指定的参数，创建JobDetail
*
* @param clazz
* @param name
* @param groupName
* @param description
* @return
*/
public static JobDetail createJobDetail(Class clazz, String name, String groupName, String description) {
jobDetailFactory.setJobClass(clazz);
jobDetailFactory.setName(name);
jobDetailFactory.setGroup(groupName);
jobDetailFactory.setDescription(description);
jobDetailFactory.setDurability(true);
jobDetailFactory.afterPropertiesSet();
return jobDetailFactory.getObject();
}
/**
* 根据参数，创建对应的CronTrigger对象
*
* @param job
* @param time
* @param name
* @param groupName
* @param description
* @return
*/
public static CronTrigger createCronTrigger(JobDetail job, String time, String name, String groupName,
String description) {
factoryBean.setName(name);
factoryBean.setJobDetail(job);
factoryBean.setCronExpression(time);
factoryBean.setDescription(description);
factoryBean.setGroup(groupName);
try {
factoryBean.afterPropertiesSet();
} catch (ParseException e) {
e.printStackTrace();
}
return factoryBean.getObject();
}
}
AutoWiringSpringBeanJobFactory类：
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
public final class AutoWiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
private transient AutowireCapableBeanFactory beanFactory;
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
beanFactory = applicationContext.getAutowireCapableBeanFactory();
}
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
beanFactory.autowireBean(job);
return job;
}
}
QuartzBean 类
import java.util.Date;
public class QuartzBean {
private Integer id;
private String name;
private String fullEntity;
private String groupName;
private String cronTime;
private String status;
private Date createTime;
private Date updateTime;
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getFullEntity() {
return fullEntity;
}
public void setFullEntity(String fullEntity) {
this.fullEntity = fullEntity;
}
public String getGroupName() {
return groupName;
}
public void setGroupName(String groupName) {
this.groupName = groupName;
}
public String getCronTime() {
return cronTime;
}
public void setCronTime(String cronTime) {
this.cronTime = cronTime;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getUpdateTime() {
return updateTime;
}
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
}
QuartzConfigService 类：
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class QuartzConfigService {
@Autowired
private CommonService cs;
public List<QuartzBean> findAllByStatus(Integer status) {
String sql = "select * from job_config where status='1'";
return MapToJobConfigList(cs.queryBySql(sql));
}
public List<QuartzBean> MapToJobConfigList(List<Map<String, Object>> list) {
List<QuartzBean> jobList = new ArrayList<QuartzBean>();
QuartzBean quartzBean = null;
for (Map<String, Object> map : list) {
quartzBean = new QuartzBean();
quartzBean.setId((Integer) map.get("id"));
quartzBean.setCreateTime((Date) map.get("create_time"));
quartzBean.setCronTime((String) map.get("cron_time"));
quartzBean.setFullEntity((String) map.get("full_entity"));
quartzBean.setGroupName((String) map.get("group_name"));
quartzBean.setName((String) map.get("name"));
quartzBean.setStatus((String) map.get("status"));
quartzBean.setUpdateTime((Date) map.get("update_time"));
jobList.add(quartzBean);
}
return jobList;
}
}
CallEPCJob 类：
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
public class CallEPCJob implements Job {
@Autowired
private Logger logger=LoggerFactory.getLogger(CallEPCJob.class);
public void execute(JobExecutionContext context) {
logger.info("-----CallEPCJob--------");
}
}
相关推荐
Spring Boot作为一个轻量级的Java框架，提供了与各种定时任务库集成的能力，其中Quartz是一个广泛应用的开源作业调度框架。本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的...
在这个"springboot与scheduler结合的定时任务工具、实例项目"中，我们将深入探讨如何在Spring Boot应用中利用Spring Scheduler来执行计划任务。 首先，Spring Scheduler提供了一个方便的方式来安排和执行周期性任务...
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
本教程将深入探讨如何通过Web接口来控制Spring Boot中的定时任务，使其能够在运行时动态开启或关闭。 首先，我们需要引入`spring-boot-starter-quartz`或者`spring-boot-starter-scheduled`依赖来启用Spring Boot的...
Spring Boot简化了Spring应用的初始搭建以及开发过程，提供了开箱即用的功能，而Quartz则是一个强大的任务调度库，常用于实现定时任务。 Spring Boot是一个基于Spring框架的快速开发工具，它通过预配置的starter ...
在Spring框架中，Quartz是一个强大的任务调度库，可以用于执行定时任务。本文将深入探讨如何在Spring中配置Quartz以实现多个定时任务。 首先，我们需要理解Quartz的基本概念。Quartz是一个开源的工作调度框架，它...
在Spring框架中，定时任务是实现系统自动化运行关键任务的重要工具。Spring提供了多种方式来创建和管理定时任务，包括基于接口的TaskExecutor、基于注解的@Scheduled和集成Quartz Scheduler。下面将详细讲解这三种...
首先，我们需要引入Spring Boot的`spring-boot-starter-quartz`或者`spring-boot-starter-task`依赖，这两个都是Spring框架提供的定时任务支持。`spring-boot-starter-quartz`基于Quartz库，而`spring-boot-starter-...
当我们结合 Spring Boot 和 Quartz，我们可以构建一个强大的定时任务管理系统，这在许多业务场景中非常有用，比如数据清理、报告生成、定期发送邮件等。 首先，让我们深入理解一下Spring Boot如何与Quartz集成。在...
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
本项目名为“schedule-job”，是基于Spring Boot框架与Quartz库构建的分布式任务调度系统，它允许开发者方便地定义、管理和执行定时任务。 【Spring Boot基础知识】 Spring Boot是由Pivotal团队提供的全新框架，其...
Quartz Scheduler的Spring-Boot自动配置只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。...
5. **监控与管理**：为了更好地管理和监控定时任务，可以利用Quartz提供的JMX支持，或者使用第三方的监控工具，如Spring Boot Actuator，实时查看任务状态和执行情况。 6. **心得分享**：在实践中，要注意任务的...
2. 创建Quartz配置类，初始化Scheduler并配置定时任务。 3. 实现自定义Job类，编写具体的任务逻辑。 4. 使用配置文件动态配置定时任务。 5. 创建服务类处理任务的增删改查操作。 6. 创建Controller提供Web接口供用户...
SpringBoot作为轻量级的框架，简化了Spring应用的初始搭建以及开发过程，而Quartz则是一个功能强大的作业调度框架，可以精确地控制任务的执行时间和频率。 在SpringBoot项目中集成Quartz，首先需要引入相关的依赖。...
在IT行业中，定时任务是许多系统不可或缺的一部分，用于在特定时间执行特定的业务逻辑。SpringBoot作为Java领域中广泛使用的微服务框架，提供了方便的集成其他组件的能力。本篇文章将详细探讨如何在SpringBoot项目中...
在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...
在Spring Boot框架中，`springboot-scheduler`是用于实现定时任务的重要组件，它基于Spring的Task Execution和Scheduling模块，使得在应用中添加和管理定时任务变得简单易行。这个"springboot-scheduler定时任务学习...
总结，Spring Boot集成Quartz定时器能够方便地创建和管理定时任务，同时利用Spring的依赖注入，使得Job可以灵活地调用其他服务或组件。这种方式使得我们的任务更加模块化和易于维护。在实际开发中，根据项目需求，...
在Spring框架中集成Quartz是一款常见的任务调度解决方案，它允许开发者在应用中安排定时任务的执行。Quartz是一个开源的作业调度框架，可以用来在Java应用程序中安排复杂的作业任务。以下将详细介绍如何在Spring中...