`
sanry
  • 浏览: 37335 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

现有web系统替换成Spring Boot2框架 之10 定时任务Quartz Scheduler

spring bootmaven定时任务quartz 
阅读更多

 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--------");

}

}

 

分享到：
| 现有web系统替换成Spring Boot2框架 之9 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    springboot整合quartz定时任务yml文件配置方式

    在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...

    Springboot整合Quartz实现定时任务数据库动态配置

    Spring Boot作为一个轻量级的Java框架，提供了与各种定时任务库集成的能力，其中Quartz是一个广泛应用的开源作业调度框架。本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的...

    springboot与scheduler结合的定时任务工具、实例项目

    在这个"springboot与scheduler结合的定时任务工具、实例项目"中，我们将深入探讨如何在Spring Boot应用中利用Spring Scheduler来执行计划任务。 首先，Spring Scheduler提供了一个方便的方式来安排和执行周期性任务...

    Spring Boot 通过web开启和关闭定时任务

    本教程将深入探讨如何通过Web接口来控制Spring Boot中的定时任务，使其能够在运行时动态开启或关闭。 首先，我们需要引入`spring-boot-starter-quartz`或者`spring-boot-starter-scheduled`依赖来启用Spring Boot的...

    spring boot + quartz 动态管理 分布式

    Spring Boot简化了Spring应用的初始搭建以及开发过程，提供了开箱即用的功能，而Quartz则是一个强大的任务调度库，常用于实现定时任务。 Spring Boot是一个基于Spring框架的快速开发工具，它通过预配置的starter ...

    spring多个定时任务quartz配置

    在Spring框架中，Quartz是一个强大的任务调度库，可以用于执行定时任务。本文将深入探讨如何在Spring中配置Quartz以实现多个定时任务。 首先，我们需要理解Quartz的基本概念。Quartz是一个开源的工作调度框架，它...

    Spring 定时任务源码（spring 三种定时任务的实现方式）

    在Spring框架中，定时任务是实现系统自动化运行关键任务的重要工具。Spring提供了多种方式来创建和管理定时任务，包括基于接口的TaskExecutor、基于注解的@Scheduled和集成Quartz Scheduler。下面将详细讲解这三种...

    springboot定时任务的动态开启关闭

    首先，我们需要引入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，我们可以构建一个强大的定时任务管理系统，这在许多业务场景中非常有用，比如数据清理、报告生成、定期发送邮件等。 首先，让我们深入理解一下Spring Boot如何与Quartz集成。在...

    Springboot2-Quartz 后台可动态配置的定时任务

    本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...

    schedule-job, 基于Spring Boot Quartz 的分布式任务调度系统.zip

    本项目名为“schedule-job”，是基于Spring Boot框架与Quartz库构建的分布式任务调度系统，它允许开发者方便地定义、管理和执行定时任务。 【Spring Boot基础知识】 Spring Boot是由Pivotal团队提供的全新框架，其...

    spring-boot-starter-quartz：Quartz-Scheduler的Spring-Boot自动配置

    Quartz Scheduler的Spring-Boot自动配置只是Quartz Scheduler的Spring-Boot启动器。 当然，Quartz Scheduler已经有好几个启动器，但是它们都不能满足我的所有需求，因此我创建了自己的启动器。 这只是一个业余项目。...

    spring+quartz实现动态设置定时任务

    5. **监控与管理**：为了更好地管理和监控定时任务，可以利用Quartz提供的JMX支持，或者使用第三方的监控工具，如Spring Boot Actuator，实时查看任务状态和执行情况。 6. **心得分享**：在实践中，要注意任务的...

    springboot整合Quartz实现动态配置定时任务源码

    2. 创建Quartz配置类，初始化Scheduler并配置定时任务。 3. 实现自定义Job类，编写具体的任务逻辑。 4. 使用配置文件动态配置定时任务。 5. 创建服务类处理任务的增删改查操作。 6. 创建Controller提供Web接口供用户...

    java-springboot-quartz-定时任务.zip

    SpringBoot作为轻量级的框架，简化了Spring应用的初始搭建以及开发过程，而Quartz则是一个功能强大的作业调度框架，可以精确地控制任务的执行时间和频率。 在SpringBoot项目中集成Quartz，首先需要引入相关的依赖。...

    SpringBoot集成Quartz分布式定时任务

    在IT行业中，定时任务是许多系统不可或缺的一部分，用于在特定时间执行特定的业务逻辑。SpringBoot作为Java领域中广泛使用的微服务框架，提供了方便的集成其他组件的能力。本篇文章将详细探讨如何在SpringBoot项目中...

    springboot2.3集成quartz定时任务持久化数据库,支持集群

    在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...

    springboot-scheduler定时任务学习demo源码

    在Spring Boot框架中，`springboot-scheduler`是用于实现定时任务的重要组件，它基于Spring的Task Execution和Scheduling模块，使得在应用中添加和管理定时任务变得简单易行。这个"springboot-scheduler定时任务学习...

    spring boot集成quartz定时器

    总结，Spring Boot集成Quartz定时器能够方便地创建和管理定时任务，同时利用Spring的依赖注入，使得Job可以灵活地调用其他服务或组件。这种方式使得我们的任务更加模块化和易于维护。在实际开发中，根据项目需求，...

    springboot的schedule和quartz到底怎么选以及如何支持并发和避坑

    在开发Java Web应用程序时，定时任务的实现是一个常见的需求，Spring Boot为我们提供了两种主要的解决方案：Spring Boot的`@Scheduled`注解和Quartz Scheduler。本文将深入探讨这两种选择的适用场景、优缺点，以及...

Magicbox
Global site tag (gtag.js) - Google Analytics