AI 助理
备案控制台
开发者社区 数据库 文章 正文

spring quartz分布式任务计划

2017-11-14 1039
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
环境：
通过maven管理的spring mvc工程，且已经成功连接数据库。

数据库表结构
/*Table structure for table `qrtz_calendars` */

DROP TABLE IF EXISTS `qrtz_calendars`;

CREATE TABLE `qrtz_calendars` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `CALENDAR_NAME` varchar(200) NOT NULL,
  `CALENDAR` blob NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`CALENDAR_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_fired_triggers` */

DROP TABLE IF EXISTS `qrtz_fired_triggers`;

CREATE TABLE `qrtz_fired_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `ENTRY_ID` varchar(95) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `INSTANCE_NAME` varchar(200) NOT NULL,
  `FIRED_TIME` bigint(13) NOT NULL,
  `SCHED_TIME` bigint(13) NOT NULL,
  `PRIORITY` int(11) NOT NULL,
  `STATE` varchar(16) NOT NULL,
  `JOB_NAME` varchar(200) DEFAULT NULL,
  `JOB_GROUP` varchar(200) DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`ENTRY_ID`),
  KEY `IDX_QRTZ_FT_TRIG_INST_NAME` (`SCHED_NAME`,`INSTANCE_NAME`),
  KEY `IDX_QRTZ_FT_INST_JOB_REQ_RCVRY` (`SCHED_NAME`,`INSTANCE_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_FT_J_G` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_FT_T_G` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_FT_TG` (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_job_details` */

DROP TABLE IF EXISTS `qrtz_job_details`;

CREATE TABLE `qrtz_job_details` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `JOB_NAME` varchar(200) NOT NULL,
  `JOB_GROUP` varchar(200) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `JOB_CLASS_NAME` varchar(250) NOT NULL,
  `IS_DURABLE` varchar(1) NOT NULL,
  `IS_NONCONCURRENT` varchar(1) NOT NULL,
  `IS_UPDATE_DATA` varchar(1) NOT NULL,
  `REQUESTS_RECOVERY` varchar(1) NOT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_J_REQ_RECOVERY` (`SCHED_NAME`,`REQUESTS_RECOVERY`),
  KEY `IDX_QRTZ_J_GRP` (`SCHED_NAME`,`JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_locks` */

DROP TABLE IF EXISTS `qrtz_locks`;

CREATE TABLE `qrtz_locks` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `LOCK_NAME` varchar(40) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`LOCK_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_paused_trigger_grps` */

DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;

CREATE TABLE `qrtz_paused_trigger_grps` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_scheduler_state` */

DROP TABLE IF EXISTS `qrtz_scheduler_state`;

CREATE TABLE `qrtz_scheduler_state` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `INSTANCE_NAME` varchar(200) NOT NULL,
  `LAST_CHECKIN_TIME` bigint(13) NOT NULL,
  `CHECKIN_INTERVAL` bigint(13) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`INSTANCE_NAME`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

DROP TABLE IF EXISTS `qrtz_blob_triggers`;

CREATE TABLE `qrtz_blob_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `BLOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `SCHED_NAME` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_cron_triggers` */

DROP TABLE IF EXISTS `qrtz_cron_triggers`;

CREATE TABLE `qrtz_cron_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `CRON_EXPRESSION` varchar(120) NOT NULL,
  `TIME_ZONE_ID` varchar(80) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_simple_triggers` */

DROP TABLE IF EXISTS `qrtz_simple_triggers`;

CREATE TABLE `qrtz_simple_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `REPEAT_COUNT` bigint(7) NOT NULL,
  `REPEAT_INTERVAL` bigint(12) NOT NULL,
  `TIMES_TRIGGERED` bigint(10) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_simprop_triggers` */

DROP TABLE IF EXISTS `qrtz_simprop_triggers`;

CREATE TABLE `qrtz_simprop_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `STR_PROP_1` varchar(512) DEFAULT NULL,
  `STR_PROP_2` varchar(512) DEFAULT NULL,
  `STR_PROP_3` varchar(512) DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13,4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13,4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

/*Table structure for table `qrtz_triggers` */

DROP TABLE IF EXISTS `qrtz_triggers`;

CREATE TABLE `qrtz_triggers` (
  `SCHED_NAME` varchar(120) NOT NULL,
  `TRIGGER_NAME` varchar(200) NOT NULL,
  `TRIGGER_GROUP` varchar(200) NOT NULL,
  `JOB_NAME` varchar(200) NOT NULL,
  `JOB_GROUP` varchar(200) NOT NULL,
  `DESCRIPTION` varchar(250) DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) NOT NULL,
  `TRIGGER_TYPE` varchar(8) NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_J` (`SCHED_NAME`,`JOB_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_JG` (`SCHED_NAME`,`JOB_GROUP`),
  KEY `IDX_QRTZ_T_C` (`SCHED_NAME`,`CALENDAR_NAME`),
  KEY `IDX_QRTZ_T_G` (`SCHED_NAME`,`TRIGGER_GROUP`),
  KEY `IDX_QRTZ_T_STATE` (`SCHED_NAME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_STATE` (`SCHED_NAME`,`TRIGGER_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_N_G_STATE` (`SCHED_NAME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NEXT_FIRE_TIME` (`SCHED_NAME`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST` (`SCHED_NAME`,`TRIGGER_STATE`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_STATE`),
  KEY `IDX_QRTZ_T_NFT_ST_MISFIRE_GRP` (`SCHED_NAME`,`MISFIRE_INSTR`,`NEXT_FIRE_TIME`,`TRIGGER_GROUP`,`TRIGGER_STATE`),
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
pom.xml配置文件
pom.xml中定义版本信息

<!-- 定义版本 -->
<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <java.version>1.7</java.version>
  <org.springframework.version>4.2.5.RELEASE</org.springframework.version>
  <quartz.version>2.2.2</quartz.version>
  <servlet.version>3.1.0</servlet.version>
  <jsp.version>2.2</jsp.version>
  <jstl.version>1.2</jstl.version>
  <druid.version>1.0.20</druid.version>
  <mysql-connector-java.version>5.1.38</mysql-connector-java.version>
  <slf4j.version>1.7.19</slf4j.version>
</properties>
pom.xml中添加quartz管理

<!-- quartz定时任务 begin -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>${quartz.version}</version>
    <exclusions>
        <exclusion>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>${quartz.version}</version>
</dependency>
<!-- quartz定时任务 end -->
任务计划执行类
package com.quartz.task.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.util.Calendar;

/**
 * 类名：TaskOneJob<br>
 * 描述：<br>
 * 创建人：zhangzhiqiang<br>
 * 创建时间：2016/9/12 13:30<br>
 *
 * @version v1.0
 */

public class TaskOneJob extends QuartzJobBean {

    Logger logger = LoggerFactory.getLogger(TaskOneJob.class);

    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        logger.info("---------TaskOneJob----------->>>>" + Calendar.getInstance().getTimeInMillis());
        System.out.println("---------TaskOneJob----------->>>>" + Calendar.getInstance().getTimeInMillis());

    }
}
任务计划和集群配置文件
resource目录下添加applicationContext-task.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:task="http://www.springframework.org/schema/task" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">
    <description>spring任务调度，quartz任务调度</description>

    <task:annotation-driven executor="quartzTaskExecutor" />
    <task:executor id="quartzTaskExecutor" keep-alive="900" pool-size="10" queue-capacity="20" />

    <!-- Quartz集群Schduler -->
    <bean id="clusterQuartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <!-- Triggers集成 -->
        <property name="triggers">
            <list>
                <ref bean="taskOneJobTrigger" />
            </list>
        </property>
        <!-- quartz配置文件路径, 指向cluster配置 -->
        <property name="configLocation" value="classpath:quartz-cluster.properties" />
        <!-- 启动时延期2秒开始任务 -->
        <property name="startupDelay" value="2" />
        <!-- 保存Job数据到数据库所需的数据源 -->
        <property name="dataSource" ref="dataSource" />
        <!-- Job接受applicationContext的成员变量名 -->
        <property name="applicationContextSchedulerContextKey" value="applicationContext" />
        <!-- 修改job时，更新到数据库 -->
        <property name="overwriteExistingJobs" value="true" />
    </bean>

    <!-- 定时任务 -->
    <bean id="taskOneJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="taskOneJobDetail" />
        <!-- 每5秒执行一次 -->
        <property name="cronExpression" value="*/5 * * * * ? " />
    </bean>
    <bean id="taskOneJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="durability" value="true" />
        <property name="jobClass" value="com.quartz.task.job.TaskOneJob" />
    </bean>
</beans>
resource目录下添加进群配置文件quartz-cluster.properties

#============================================================================
# Configure Main Scheduler Properties
#============================================================================

org.quartz.scheduler.instanceName = ClusteredScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.scheduler.skipUpdateCheck = true

#============================================================================
# Configure ThreadPool
#============================================================================

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5

#============================================================================
# Configure JobStore
#============================================================================

org.quartz.jobStore.misfireThreshold = 60000

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties = false
org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.jobStore.isClustered = true
org.quartz.jobStore.clusterCheckinInterval =15000
测试
最后启动程序，看配置是否正确。如果运行正确会输出如下类似结果：

信息: Deployment of web application directory D:\soft\apache-tomcat-7.0.65\webapps\manager has finished in 135 ms
---------TaskOneJob----------->>>>1473662280157
---------TaskOneJob----------->>>>1473662285083
---------TaskOneJob----------->>>>1473662290072

---------TaskOneJob----------->>>>1473662295058





本文转自秋楓博客园博客，原文链接：http://www.cnblogs.com/rwxwsblog/p/5864897.html，如需转载请自行联系原作者

文章标签：
Spring
关系型数据库
Java
数据库
关键词：
Spring分布式
分布式spring
quartz分布式
分布式quartz
Spring Quartz
嗯哼9925
目录
相关文章
HELLO程序员
|
24天前
|
存储 安全 Java
管理 Spring 微服务中的分布式会话
在微服务架构中，管理分布式会话是确保用户体验一致性和系统可扩展性的关键挑战。本文探讨了在 Spring 框架下实现分布式会话管理的多种方法，包括集中式会话存储和客户端会话存储（如 Cookie），并分析了它们的优缺点。同时，文章还涵盖了与分布式会话相关的安全考虑，如数据加密、令牌验证、安全 Cookie 政策以及服务间身份验证。此外，文中强调了分布式会话在提升系统可扩展性、增强可用性、实现数据一致性及优化资源利用方面的显著优势。通过合理选择会话管理策略，结合 Spring 提供的强大工具，开发人员可以在保证系统鲁棒性的同时，提供无缝的用户体验。
HELLO程序员
33 0
啦啦啦191
|
2月前
|
监控 Java API
Spring Boot 3.2 结合 Spring Cloud 微服务架构实操指南 现代分布式应用系统构建实战教程
Spring Boot 3.2 + Spring Cloud 2023.0 微服务架构实践摘要 本文基于Spring Boot 3.2.5和Spring Cloud 2023.0.1最新稳定版本，演示现代微服务架构的构建过程。主要内容包括： 技术栈选择：采用Spring Cloud Netflix Eureka 4.1.0作为服务注册中心，Resilience4j 2.1.0替代Hystrix实现熔断机制，配合OpenFeign和Gateway等组件。 核心实操步骤： 搭建Eureka注册中心服务 构建商品
啦啦啦191
375 3
HELLO程序员
|
24天前
|
NoSQL Java 调度
分布式锁与分布式锁使用 Redis 和 Spring Boot 进行调度锁（不带 ShedLock）
分布式锁是分布式系统中用于同步多节点访问共享资源的机制，防止并发操作带来的冲突。本文介绍了基于Spring Boot和Redis实现分布式锁的技术方案，涵盖锁的获取与释放、Redis配置、服务调度及多实例运行等内容，通过Docker Compose搭建环境，验证了锁的有效性与互斥特性。
HELLO程序员
76 0
分布式锁与分布式锁使用 Redis 和 Spring Boot 进行调度锁（不带 ShedLock）
阿里云云原生
|
5月前
|
人工智能 负载均衡 Java
Spring AI Alibaba 发布企业级 MCP 分布式部署方案
本文介绍了Spring AI Alibaba MCP的开发与应用，旨在解决企业级AI Agent在分布式环境下的部署和动态更新问题。通过集成Nacos，Spring AI Alibaba实现了流量负载均衡及节点变更动态感知等功能。开发者可方便地将企业内部业务系统发布为MCP服务或开发自己的AI Agent。文章详细描述了如何通过代理应用接入存量业务系统，以及全新MCP服务的开发流程，并提供了完整的配置示例和源码链接。未来，Spring AI Alibaba计划结合Nacos3的mcp-registry与mcp-router能力，进一步优化Agent开发体验。
阿里云云原生
1992 15
北风几吹夏
|
5月前
|
监控 Java 调度
SpringBoot中@Scheduled和Quartz的区别是什么？分布式定时任务框架选型实战
本文对比分析了SpringBoot中的`@Scheduled`与Quartz定时任务框架。`@Scheduled`轻量易用，适合单机简单场景，但存在多实例重复执行、无持久化等缺陷；Quartz功能强大，支持分布式调度、任务持久化、动态调整和失败重试，适用于复杂企业级需求。文章通过特性对比、代码示例及常见问题解答，帮助开发者理解两者差异，合理选择方案。记住口诀：单机简单用注解，多节点上Quartz；若是任务要可靠，持久化配置不能少。
北风几吹夏
497 4
别惹CC
|
7月前
|
存储 Java 文件存储
🗄️Spring Boot 3 整合 MinIO 实现分布式文件存储
本文介绍了如何基于Spring Boot 3和MinIO实现分布式文件存储。随着应用规模扩大，传统的单机文件存储方案难以应对大规模数据和高并发访问，分布式文件存储系统成为更好的选择。文章详细讲解了MinIO的安装、配置及与Spring Boot的整合步骤，包括Docker部署、MinIO控制台操作、Spring Boot项目中的依赖引入、配置类编写及工具类封装等内容。最后通过一个上传头像的接口示例展示了具体的开发和测试过程，强调了将API操作封装成通用工具类以提高代码复用性和可维护性的重要性。
别惹CC
1303 7
🗄️Spring Boot 3 整合 MinIO 实现分布式文件存储
互联网课堂
|
资源调度 Java 调度
Spring Cloud Alibaba 集成分布式定时任务调度功能
定时任务在企业应用中至关重要，常用于异步数据处理、自动化运维等场景。在单体应用中，利用Java的`java.util.Timer`或Spring的`@Scheduled`即可轻松实现。然而，进入微服务架构后，任务可能因多节点并发执行而重复。Spring Cloud Alibaba为此发布了Scheduling模块，提供轻量级、高可用的分布式定时任务解决方案，支持防重复执行、分片运行等功能，并可通过`spring-cloud-starter-alibaba-schedulerx`快速集成。用户可选择基于阿里云SchedulerX托管服务或采用本地开源方案（如ShedLock）
互联网课堂
306 1
dufadayang
|
11月前
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架，实现分布式事务的管理和处理。在实际应用中，还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时，要注意处理各种可能出现的问题，以保障分布式事务的顺利执行。
dufadayang
758 53
蓝易云
|
10月前
|
存储 NoSQL Java
使用lock4j-redis-template-spring-boot-starter实现redis分布式锁
通过使用 `lock4j-redis-template-spring-boot-starter`，我们可以轻松实现 Redis 分布式锁，从而解决分布式系统中多个实例并发访问共享资源的问题。合理配置和使用分布式锁，可以有效提高系统的稳定性和数据的一致性。希望本文对你在实际项目中使用 Redis 分布式锁有所帮助。
蓝易云
577 5
蓝易云
|
10月前
|
缓存 NoSQL Java
Spring Boot中的分布式缓存方案
Spring Boot提供了简便的方式来集成和使用分布式缓存。通过Redis和Memcached等缓存方案，可以显著提升应用的性能和扩展性。合理配置和优化缓存策略，可以有效避免常见的缓存问题，保证系统的稳定性和高效运行。
蓝易云
274 3

热门文章

最新文章

  • 1
    Spring Cloud Gateway 全解析：路由配置、断言规则与过滤器实战指南
  • 2
    【Spring】原理解析：Spring Boot 自动配置
  • 3
    spring boot2升级boot3指南
  • 4
    微服务配置管理：Spring Cloud Config 实践指南
  • 5
    基于Spring AI Alibaba + Spring Boot + Ollama搭建本地AI对话机器人API
  • 6
    使用 Spring 的 @Aspect 和 @Pointcut 注解简化面向方面的编程 (AOP)
  • 7
    Spring 微服务和多租户：处理多个客户端
  • 8
    【Spring】原理：Bean的作用域与生命周期
  • 9
    Spring Boot四层架构深度解析
  • 10
    Spring Cloud 微服务架构技术解析与实践指南
  • 1
    “你还活着吗？” “我没死，只是网卡了！”——来自分布式世界的“生死契约”
    52
  • 2
    “卧槽，系统又崩了！”——别慌，这也许是你看过最通俗易懂的分布式入门
    119
  • 3
    去中心化不只是区块链：智能设备的“分布式大脑”
    155
  • 4
    基于分布式模型预测控制DMPC的单向拓扑结构下异构车辆车队研究（Matlab代码实现）
    40
  • 5
    基于遗传算法的新的异构分布式系统任务调度算法研究（Matlab代码实现）
    99
  • 6
    Apache Kafka 分布式流处理平台技术详解与实践指南
    194
  • 7
    基于串行并行ADMM算法的主从配电网分布式优化控制研究（Matlab代码实现）
    47
  • 8
    【孤岛划分】分布式能源接入弹性配电网模型研究【IEEE33节点】（Matlab代码实现）
    120
  • 9
    【ADMM、碳排放】基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究【IEEE6节点、IEEE30节点、IEEE118节点】（Matlab代码实现）
    80
  • 10
    分布式系统太大管不过来？运维效率提升的那些真招实料
    52

    • 相关课程

    更多
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • 分布式文件存储系统技术及实现
  • 分布式协调系统 Zookeeper 快速入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库
    • 下一篇
    深度 | 从0到3.0，揭秘阿里云洛神云网络的进化之路