Spring Boot2.x + Quartz 定时任务模块

最新推荐文章于 2024-08-19 19:38:53 发布
最新推荐文章于 2024-08-19 19:38:53 发布
阅读量642 收藏 5
点赞数
分类专栏： springBoot学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhiwengang/article/details/119137548
版权

介绍       

项目是为定时任务模块，可以作为熟悉了解定时任务框架项目也可以将本模块直接移植进自己的项目中

软件涉及技术

SpringBoot2.x + MyBatis3 +MyBatis3-Plus + MySQL8 + Quartz(定时任务框架) +Swagger2（接口文档框架） 

效果截图

 

 

项目整体结构： 

 

 项目重点细节说明

 项目之pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.zzg</groupId>
	<artifactId>sb-Quartz</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.1.2.RELEASE</version>
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
		<!-- 集中定义管理依赖版本号 -->
		<commons-lang.version>2.6</commons-lang.version>
		<commons-codec.version>1.10</commons-codec.version>
		<commons-lang3.version>3.9</commons-lang3.version>
		<commons-net.version>3.6</commons-net.version>
		<commons-io.version>2.6</commons-io.version>
		<commons-collections.version>3.2.1</commons-collections.version>
		<commons-text.version>1.8</commons-text.version>
		<common-fileupload.version>1.3.1</common-fileupload.version>
		<servlet-api.version>3.1.0</servlet-api.version>
		<httpclient.version>4.5.2</httpclient.version>
		<fastjson.version>1.2.48</fastjson.version>
	</properties>

	<dependencies>
		<!--starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
		</dependency>
		<!-- test -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<!--web -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<!-- quartz -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-quartz</artifactId>
		</dependency>

		<!-- 数据库连接池druid -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>druid-spring-boot-starter</artifactId>
			<version>1.1.10</version>
		</dependency>
		<!--mysql 驱动程序 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<scope>runtime</scope>
		</dependency>

		<!-- Swagger2 集成 -->
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger2</artifactId>
			<version>2.7.0</version>
		</dependency>
		<dependency>
			<groupId>io.springfox</groupId>
			<artifactId>springfox-swagger-ui</artifactId>
			<version>2.7.0</version>
		</dependency>

		<!-- 数据库文档自动生成 -->
		<dependency>
			<groupId>cn.smallbun.screw</groupId>
			<artifactId>screw-core</artifactId>
			<version>1.0.5</version>
		</dependency>
		<dependency>
			<groupId>org.freemarker</groupId>
			<artifactId>freemarker</artifactId>
			<version>2.3.30</version>
		</dependency>

		<!--lombok -->
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
		</dependency>
		<!-- mybatis-plus 集成 -->
		<dependency>
			<groupId>com.baomidou</groupId>
			<artifactId>mybatis-plus-boot-starter</artifactId>
			<version>3.4.1</version>
		</dependency>
		<!--validation -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-validation</artifactId>
		</dependency>
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-annotations</artifactId>
			<version>2.9.0</version>
		</dependency>

		<!--common-lang 常用工具包 -->
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>${commons-lang.version}</version>
		</dependency>
		<!--commons-lang3 工具包 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>${commons-lang3.version}</version>
		</dependency>

		<!--commons-codec 加密工具包 -->
		<dependency>
			<groupId>commons-codec</groupId>
			<artifactId>commons-codec</artifactId>
			<version>${commons-codec.version}</version>
		</dependency>
		<!--commons-net 网络工具包 -->
		<dependency>
			<groupId>commons-net</groupId>
			<artifactId>commons-net</artifactId>
			<version>${commons-net.version}</version>
		</dependency>
		<!--common-io 工具包 -->
		<dependency>
			<groupId>commons-io</groupId>
			<artifactId>commons-io</artifactId>
			<version>${commons-io.version}</version>
		</dependency>
		<!--common-collection 工具包 -->
		<dependency>
			<groupId>commons-collections</groupId>
			<artifactId>commons-collections</artifactId>
			<version>${commons-collections.version}</version>
		</dependency>
		<!--common-fileupload 工具包 -->
		<dependency>
			<groupId>commons-fileupload</groupId>
			<artifactId>commons-fileupload</artifactId>
			<version>${common-fileupload.version}</version>
		</dependency>
		<!-- common-text 工具包 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-text</artifactId>
			<version>${commons-text.version}</version>
		</dependency>
		<!-- 集成servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${servlet-api.version}</version>
		</dependency>
		<!-- 集成Apache HttpClient -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>${httpclient.version}</version>
		</dependency>
		<!-- 集成fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>${fastjson.version}</version>
		</dependency>
	</dependencies>

</project>

 数据库 schedule_job

CREATE TABLE `schedule_job` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '任务id',
  `job_name` varchar(255) CHARACTER SET utf8 DEFAULT NULL COMMENT '任务名称',
  `cron_expression` varchar(255) CHARACTER SET utf8 DEFAULT NULL COMMENT 'cron表达式',
  `bean_name` varchar(255) CHARACTER SET utf8 DEFAULT NULL COMMENT '服务名称',
  `method_name` varchar(255) CHARACTER SET utf8 DEFAULT NULL COMMENT '方法名称',
  `status` tinyint(4) NOT NULL DEFAULT '0' COMMENT '状态 0 启动 1 停止',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `del_flag` tinyint(4) NOT NULL DEFAULT '0' COMMENT '软删除标记 0 正常 1 删除',
  PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8mb4 ROW_FORMAT=DYNAMIC COMMENT='定时任务';

 schedule_job 表对应的类

 com.zzg.entity.ScheduleJob

com.zzg.mapper.ScheduleJobMapper

com.zzg.service.ScheduleJobService

com.zzg.service.impl.ScheduleJobServiceImpl

ScheduleJobMapper.xml

 定时任务配置对象

package com.zzg.config;

import org.quartz.Scheduler;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;


/**
 * 定时任务配置对象
 * @author zzg
 *
 */
public class QuartzConfig {
	@Bean
    public SchedulerFactoryBean schedulerFactoryBean(){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //覆盖已存在的任务
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        //延时60秒启动定时任务，避免系统未完全启动却开始执行定时任务的情况
        schedulerFactoryBean.setStartupDelay(60);
        return schedulerFactoryBean;
    }

    /** 创建schedule **/
    @Bean(name = "scheduler")
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }
}

枚举类：JobOperateEnum.java

package com.zzg.enums;

import java.io.Serializable;

public enum  JobOperateEnum {
	START(0, "启动"),
    PAUSE(1, "暂停"),
    DELETE(2, "删除");

    private final Integer value;
    private final String desc;

    JobOperateEnum(final Integer value, final String desc) {
        this.value = value;
        this.desc = desc;
    }

    public Serializable getValue() {
        return this.value;
    }

    public String getDesc() {
        return this.desc;
    }

    public String getEnumName() {
        return name();
    }
}

定时任务工厂类

package com.zzg.quartz;

import java.lang.reflect.Method;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import com.zzg.entity.ScheduleJob;
import com.zzg.util.SpringContextUtil;

public class QuartzFactory implements Job {

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		// TODO Auto-generated method stub
		// 获取调度数据
		ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");

		// 获取对应的Bean
		Object object = SpringContextUtil.getBean(scheduleJob.getBeanName());
		try {
			// 利用反射执行对应方法
			Method method = object.getClass().getMethod(scheduleJob.getMethodName());
			method.invoke(object);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

定时任务服务层 IQuartzService.java

package com.zzg.service;

import org.quartz.SchedulerException;

import com.zzg.entity.ScheduleJob;
import com.zzg.enums.JobOperateEnum;

public interface IQuartzService {
	/**
     * 服务器启动执行定时任务
     */
    void timingTask();

    /**
     * 新增定时任务
     * @param job 任务
     */
    void addJob(ScheduleJob job);

    /**
     * 操作定时任务
     * @param jobOperateEnum 操作枚举
     * @param job 任务
     */
    void operateJob(JobOperateEnum jobOperateEnum, ScheduleJob job) throws SchedulerException;

    /**
     * 启动所有任务
     */
    void startAllJob() throws SchedulerException;

    /**
     * 暂停所有任务
     */
    void pauseAllJob() throws SchedulerException;
}

定时任务服务层实现类 QuartzServiceImpl.java

package com.zzg.service.impl;

import java.util.List;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.zzg.entity.ScheduleJob;
import com.zzg.enums.JobOperateEnum;
import com.zzg.quartz.QuartzFactory;
import com.zzg.service.IQuartzService;
import com.zzg.service.ScheduleJobService;

@Service
public class QuartzServiceImpl implements IQuartzService {
	/**
	 * 调度器
	 */
	@Autowired
	private Scheduler scheduler;

	@Autowired
	private ScheduleJobService scheduleJobService;

	@Override
	public void timingTask() {
		// TODO Auto-generated method stub
		// 查询数据库是否存在需要定时的任务
		List<ScheduleJob> scheduleJobs = scheduleJobService.list();
		if (scheduleJobs != null) {
			scheduleJobs.forEach(this::addJob);
		}
	}

	@Override
	public void addJob(ScheduleJob job) {

		try {
			// 创建触发器
			Trigger trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName())
					.withSchedule(CronScheduleBuilder.cronSchedule(job.getCronExpression())).startNow().build();

			// 创建任务
			JobDetail jobDetail = JobBuilder.newJob(QuartzFactory.class).withIdentity(job.getJobName()).build();

			// 传入调度的数据，在QuartzFactory中需要使用
			jobDetail.getJobDataMap().put("scheduleJob", job);

			// 调度作业
			scheduler.scheduleJob(jobDetail, trigger);

		} catch (Exception e) {
			throw new RuntimeException(e);
		}
	}

	@Override
	public void operateJob(JobOperateEnum jobOperateEnum, ScheduleJob job) throws SchedulerException {
		// TODO Auto-generated method stub
		JobKey jobKey = new JobKey(job.getJobName());
		JobDetail jobDetail = scheduler.getJobDetail(jobKey);
		if (jobDetail == null) {
			// 抛异常
		}
		switch (jobOperateEnum) {
		case START:
			scheduler.resumeJob(jobKey);
			break;
		case PAUSE:
			scheduler.pauseJob(jobKey);
			break;
		case DELETE:
			scheduler.deleteJob(jobKey);
			break;
		}
	}

	@Override
	public void startAllJob() throws SchedulerException {
		// TODO Auto-generated method stub
		 scheduler.start();
	}

	@Override
	public void pauseAllJob() throws SchedulerException {
		// TODO Auto-generated method stub
		 scheduler.standby();
	}

}

JobSchedule.java 实现开机自运行

package com.zzg.quartz.components;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

import com.zzg.service.IQuartzService;

/**
 * 项目启动后,后台任务自带加载运行
 * 
 * @author zzg
 *
 */
@Component
public class JobSchedule implements CommandLineRunner {
	@Autowired
	private IQuartzService taskService;

	@Override
	public void run(String... args) throws Exception {
		// TODO Auto-generated method stub
		System.out.println("任务调度开始==============任务调度开始");
		taskService.timingTask();
		System.out.println("任务调度结束==============任务调度结束");
	}

}

动态定时任务功能实现

静态部分

顾名思义，静态部分就是写一个方法，数据库录入一条数据，当项目启动的时候，就会触发定时任务，等到了时间就会运行。

package com.zzg.quartz.job;

import java.util.Date;

import org.springframework.stereotype.Component;

@Component("JobTest")
public class LogTest {
	public void log() {
		System.out.println("-------------------Log任务执行开始-------------------");
		System.out.println(new Date().toLocaleString());
		System.out.println("-------------------Log任务执行结束-------------------");
	}
}

数据库表 schedule_job

执行效果

动态部分

动态部分就是在静态部分的基础上，加入controller，直接通过接口来实时操作定时任务

package com.zzg.controller;

import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.zzg.common.Result;
import com.zzg.entity.ScheduleJob;
import com.zzg.enums.JobOperateEnum;
import com.zzg.service.IQuartzService;
import com.zzg.service.ScheduleJobService;

import io.swagger.annotations.ApiOperation;

@RestController
@RequestMapping("/api/quartz")
public class QuartzController {
	@Autowired
	private ScheduleJobService scheduleJobService;
	@Autowired
	private IQuartzService quartzService;
	
	@PostMapping("/startAllJob")
	@ApiOperation("开始所有定时任务")
	public Result startAllJob() throws SchedulerException {
		quartzService.startAllJob();
	    return Result.ok();
	}

	@PostMapping("/pauseAllJob")
	@ApiOperation("暂停所有定时任务")
	public Result pauseAllJob() throws SchedulerException {
		quartzService.pauseAllJob();
	    return Result.ok();
	}
	
	@PostMapping("/startJob")
	@ApiOperation("启动定时任务")
	public Result start(@RequestBody ScheduleJob form) {
		
		try {
			quartzService.operateJob(JobOperateEnum.START,form);
			// 补充业务逻辑
			ScheduleJob entity = scheduleJobService.getById(form.getId());
			entity.setStatus(0);
			scheduleJobService.saveOrUpdate(entity);
		} catch (SchedulerException e) {
			// 堆栈异常输出
			e.printStackTrace();
			return Result.error("启动定时任务失败");
		}
	    return Result.ok();
	}

	@PostMapping("/pauseJob")
	@ApiOperation("暂停定时任务")
	public Result pause(@RequestBody ScheduleJob form) {
		try {
			quartzService.operateJob(JobOperateEnum.PAUSE, form);
			
			// 补充业务逻辑
			ScheduleJob entity = scheduleJobService.getById(form.getId());
			entity.setStatus(1);
			scheduleJobService.saveOrUpdate(entity);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return Result.error("暂停定时任务失败");
		}
	    return Result.ok();
	}

	@PostMapping("/deleteJob")
	@ApiOperation("删除定时任务")
	public Result delete(@RequestBody ScheduleJob form) {
		try {
			quartzService.operateJob(JobOperateEnum.DELETE, form);
			
			// 补充其他业务逻辑
			scheduleJobService.removeById(form.getId());
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			return Result.error("删除定时任务失败");
		}
	    return Result.ok();
	}
}

 

 知识拓展：CronTrigger配置完整格式

[秒] [分] [小时] [日] [月] [周] [年]

参数

  1. 秒（0~59）
  2. 分钟（0~59）
  3. 小时（0~23）
  4. 天（0~31，但是你需要考虑你月的天数）
  5. 月（0~11）
  6. 周（1~7）
  7. 年份（1970－2099）（可省略）

eg:

  1. 0 0 0/1 * * ? // 每小时执行一次
  2. 0 0 12 * * ? // 每天12点触发
  3. 0 0 22 L * ? // 每月最后一天的22点触发

 源码下载地址：

百度网盘下载地址及其提取码（包含项目源码+项目初始化脚本）:

链接：https://pan.baidu.com/s/19rqjrBvRX6PNbcSuyTU5BQ 
提取码：1234 
 

 

在奋斗的大道
关注
专栏目录
SpringBoot2.x学习-任务调度-Quartz集成
Java开发
04-11 618
文章目录一、Quartz介绍1.1 介绍说明1.2 地址和类库说明1.3 Quartz基础结构二、Spring Boot集成Quartz2.1添加quartz依赖2.2 Cron Triggers简单例子三、自定义动态配置任务3.1定义表存储任务信息3.2 Quartz配置四、集群配置 一、Quartz介绍 1.1 介绍说明 Quartz 是 OpenSymphony 开源组织在任务调度领域的一个开源项目，自2001年发布以来，已经被众多项目作为任务调度的解决方案。 Quartz完全基于 Java 实现，
spring整合定时任务组件Quartz
qq_41543905的博客
01-11 319
Quartz是Job scheduling（任务调度）领域的一个开源项目，Quartz既可以单独使用也可以跟spring框架整合使用，在实际开发中一般会使用后者。使用Quartz可以开发一个或者多个定时任务，每个定时任务可以单独指定执行的时间，例如每隔1小时执行一次、每个月第一天上午10点执行一次、每个月最后一天下午5点执行一次等。 什么：是一个做后台任务调度的开源框架 作用：定时后台任务开发 什么时候用：需要后定时/重复执行任务时可以使用 下面是总体步骤： 引入maven依赖 创建一个任务类，做任务的方
Spring Boot实现定时任务
最新发布
这河里吗l的博客
08-19 2130
定时任务是指在预定的时间点或按照特定的时间间隔自动执行的任务。操作系统维护：例如，定期清理临时文件、更新系统补丁等。数据备份：定期对重要数据进行备份，以防数据丢失。自动化测试：例如，在每天凌晨自动运行软件测试脚本。网站维护：比如定时发布新内容、定时发送邮件提醒等。数据分析：例如，定期汇总和分析业务数据，生成报告。
spring集成quartz报org.springframework.scheduling.quartz.CronTriggerBean异常
weixin_39309402的博客
08-14 3598
spring集成quartz项目做定时任务，但是启动tomcat报错： ClassNotFoundException: org.springframework.scheduling.quartz.CronTriggerBean………… 查阅资料，得知spring和quartz存在版本不兼容的问题，如果引入的quartz依赖是1.8.6以及以前的版本，依赖类是： org.springframe...
SpringBoot定时任务--选型/对比/框架
热门推荐
IT利刃出鞘的博客
09-21 1万+
在项目中我们经常会用到定时任务。本文介绍一些定时任务框架的区别。
Spring实现定时任务方法
java_2017_csdn的博客
08-18 5243
 Spring实现定时任务方法   标签： springquartztask 2017-03-11 02:02 190人阅读 评论(0) 收藏 举报 分类： spring（3） 作者同类文章X task quartz 版权声明：本文为博主原创文章，未经博主允许不得转载。
使用Spring Boot + Quartz 实现分布式定时任务平台
HongYu012的博客
03-23 4309
本文将从项目实战出发来介绍分布式定时任务的实现。在某些应用场景下要求任务必须具备高可用性和可扩展性，单台服务器不能满足业务需求，这时就需要使用Quartz实现分布式定时任务。 一、分布式任务应用场景 定时任务系统在应用平台中的重要性不言而喻，特别是互联网电商、金融等行业更是离不开定时任务。在任务数量不多、执行频率不高时，单台服务器完全能够满足。 但是随着业务逐渐增加，定时任务系统必须具备高可用和水平扩展的能力，单台服务器已经不能满足需求。因此需要把定时任务系统部署到集群中，实现分布式定时任务系统集群。
精通Spring+4.x++企业应用开发实战源码
10-02
此外，Spring还提供了强大的整合能力，可以与众多开源技术无缝对接，如MyBatis、Hibernate、Quartz定时任务、Apache CXF和 Axis webservices、Spring Boot、Spring Security等，极大地丰富了企业应用的构建选项。...
spring+quartz定时任务
12-23
Spring与Quartz的集成主要基于Spring的`TaskExecution`和`TaskScheduling`模块，它允许我们以声明式的方式配置定时任务，同时也支持编程式的任务调度。以下将详细介绍如何利用Spring和Quartz实现多任务的定时功能。 ...
xboot：基于Spring Boot 2.x的一站式前分离快速开发平台XBoot微信小程序+ Uniapp前端：Vue + iView管理员简介：Spring Boot 2.x Spring Security JWTJPA + Mybatis-PlusRedisElasticsearchActiviti分布式限制流同步锁验证编码SnowFlake雪花算法ID生成动态权限管理数据权限工作流代码生成定时任务第三方社交账号，短信登录单点登录OAuth2开放平台
02-03
xboot-module：多模块版本 项目简介 代码拥有详细注释无复杂逻辑核心使用SpringBoot 2.3.6.RELEASE JWT /基于Redis可配置单设备登录令牌交互任意切换支持点单登录提供开放平台 JPA + Mybatis-Plus任意切换 操作...
Spring Boot 3.x 系列【34】服务监控 | Spring Boot Actuator 入门案例
记录知识、锤炼自我
05-19 817
Spring Boot Actuator是Spring Boot除了自动配置外另一个重要的核心功能，提供了spring-boot-actuator模块用于后台应用程序运行监控、指标收集、审计等功能，可以通过使用HTTP端点或使用JMX来管理和监控你的应用程序。
springframework.scheduling.quartz工作调度器使用（二）-自定义多线程池任务
HarryChenj的专栏
04-13 1248
实现场景一：频率H1（5分钟）任务定时执行，但频率内任务执行所需时间超过频率时间段，出现频率内任务未执行完成，被下一次执行的任务中途中断的情况;公司平台系统场景：定时任务 每5分钟可查询平台日志数据表记录大约为100万行，每1万行写入一个文件，即5分钟内需要生成100个文件，并存储到磁盘，但操作系统实际IO读写最高效率（假设）为  10个/1分钟，在当前任务在生成第50个文件时，下一间隔任务开始执...
【SpringBoot】通过@Scheduled实现定时任务
Robin的博客
02-16 1616
Scheduled定时任务是Spring boot自身提供的功能，所以不需要引入Maven依赖包在项目入口main方法上加注解。
SpringBoot2.0整合quartz实现多定时任务动态配置，实现任务增删改，生成Cron表达式
振钧
08-02 2884
部分内容转载自“尔笑惹千愁”，链接https://blog.csdn.net/lx1309244704/article/details/81810373 在我们日常的开发中，很多时候，定时任务都不是写死的，而是写到数据库中，从而实现定时任务的动态配置，下面就通过一个简单的示例，来实现这个功能。 一、添加依赖包 <!-- quartz --> <dependency> ...
springboot项目集成xxl-job定时任务框架
m0_74399067的博客
07-28 641
定时任务时基于给定的时间点、给定的时间间隔或者给定的执行次数自动执行的程序。任务调度是系统的重要组成部分，同时涉及到多线程并发、运行时间规则定制及解析、线程池的维护等诸多方面的工作。
【Spring Boot】定时任务
2401_83045332的博客
08-17 3285
在Spring Boot中，定时任务的实现通常使用@Scheduled注解。@Scheduled可以用于在指定的时间间隔或特定的时间点执行任务。Spring提供了多种方式来配置定时任务，如使用固定速率，固定延迟或Cron表达式等。如果是分布式系统或者想要时间可以灵活变化，可以选择一些定时任务框架xxl-job,elastic-job等在 Spring Boot 中，通过使用@Scheduled。
【SpringBoot整合系列】SpringBoot整合定时任务【Quartz】
低调做人，低调编码，神码都是浮云
04-01 1802
SpringBoot整合定时任务
SpringBoot 使用Schedule定时框架
GyaoG的专栏
05-08 1963
一、引言 在开发过程中，我们往往需要实现一些定时功能比如执行定时任务、定时发送统计数据等，现在虽然有java有很多类似Saturn(唯品会自主研发的分布式的定时任务的调度平台)，但是在一些比较小的项目而又没有搭建好的分布式定时任务中台时，可以使用Schedule定时任务框架，使用起来简单而且就算分布式项目也可以通过使用分布式锁将Schedule实现分布式定时任务功能。 二、Schedule定时框架的使用 1、添加依赖 使用IDEA的Spring Initiallzr...
springboot2.0整合quartz
weixin_43865381的博客
12-23 761
目录 `Quartz``Quartz` 简介`Quartz` 优点核心概念`Quartz` 的作业存储类型`Cron` 表达式`Cron` 语法`Cron` 语法中每个时间元素的说明`Cron` 语法中特殊字符说明在线 `Cron` 表达式生成器 `springbo...
springboot+vue+quartz 实现定时任务调度
05-22
首先，需要在 Spring Boot 中集成 Quartz。可以通过添加以下依赖来实现： ```xml <!-- Quartz --> <groupId>org.quartz-scheduler <artifactId>quartz <version>2.3.0 ``` 然后，在 Spring Boot 中配置 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值