【2025版】2小时候学会MQ消息队列，全是干货

最新推荐文章于 2026-01-08 17:10:56 发布
原创 最新推荐文章于 2026-01-08 17:10:56 发布 · 1.2k 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #spring #rabbitmq

文章目录

认识RabbitMQ

RabbitMQ的架构如图
在这里插入图片描述
重要概念：

  • publisher：生产者，也就是发送消息的一方
  • consumer：消费者，也就是消费消息的一方
  • queue：队列，存储消息。生产者投递的消息会暂存在消息队列中，等待消费者处理
  • exchange：交换机，负责消息路由。生产者发送的消息由交换机决定投递到哪个队列。
  • virtual host：虚拟主机，起到数据隔离的作用。每个虚拟主机相互独立，有各自的exchange、queue

1. 安装

我们使用docker来安装RabbitMQ，如果对docker还不熟悉，可以先看这篇文章：
https://blog.youkuaiyun.com/fim77/article/details/143844100（推荐快速入门，后续学习其他知识也会方便很多）

1.1 拉取镜像

docker pull rabbitmq:management
在这里插入图片描述

1.2 运行容器

docker run -d --hostname my-rabbit --name rabbit-mq -p 5672:5672 -p 15672:15672 -e RABBITMQ_DEFAULT_USER=paran -e RABBITMQ_DEFAULT_PASS=123 rabbitmq:management
在这里插入图片描述

1.3 访问RabbitMQ管理端页面

输入上一步创建容器时设置的用户名和密码，登录（如果没设置，默认账号和密码是guest）
在这里插入图片描述

2. 收发消息

2.1 交换机（exchange）

tip:交换机只转发消息，不会保存消息
RabbitMQ默认会初始化一些交换机，交换机（Exchange）是消息队列系统中的一个核心概念，它决定了消息将被发送到哪个或哪些队列。当生产者（Producer）发送消息时，并不是直接将消息发送到队列中，而是先发送给交换机。交换机会根据特定的规则和绑定（Bindings）决定如何处理这些消息，比如是否丢弃、路由到一个或多个队列等。
在这里插入图片描述
交换机的类型有四种：

  1. Fanout：广播，将消息交给所有绑定到交换机的队列。
  2. Direct：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列
  3. Topic：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符
  4. Headers：头匹配，基于MQ的消息头匹配，用的较少。

1) Fanout 交换机

特点：Fanout 交换机会将接收到的消息广播到所有绑定到该交换机的队列。

工作原理：当消息到达 fanout 交换机时，它会直接将该消息复制并发送到所有绑定在这个交换机上的队列，而不管消息的内容、路由键（routing key）是什么。

用途：适用于广播模式，比如广播通知给多个消费者，所有队列都会收到消息。

2) Direct 交换机

特点：Direct 交换机基于精确匹配的路由键将消息发送到队列。

工作原理：当消息到达 direct 交换机时，交换机会根据消息的路由键（routing key）找到与之完全匹配的队列，并将消息传递给该队列。

用途：适用于一对一的路由模式，比如基于某些条件决定将消息发送到特定队列的场景。

示例：你有一个 direct 交换机，并且有多个队列，每个队列绑定一个特定的路由键。比如队列A绑定的路由键是"error"，队列B绑定的路由键是"info"。如果你发送一个路由键为"error"的消息，只有队列A会收到该消息。

3) Topic 交换机

特点：Topic 交换机允许更复杂的路由规则，基于路由键的模式匹配来决定消息的传递。

工作原理：Topic 交换机会根据消息的路由键和队列绑定时指定的模式进行匹配。路由键通常由多个单词组成，用点（.）分隔。可以使用通配符（*和#）来匹配路由键中的部分内容。

*（星号）：匹配一个词。

#（井号）：匹配零个或多个词。

用途：适用于更复杂的消息路由需求，比如基于多个条件选择性地发送消息。

示例：

你有一个 topic 交换机和多个队列，每个队列都绑定了不同的模式。比如：

队列A绑定模式"*.error"，这意味着它将接收所有路由键包含error的消息（例如"system.error"）。

队列B绑定模式"*.info"，它将接收所有路由键包含info的消息（例如"system.info"）。

队列C绑定模式"system.#"，它将接收所有以"system."开头的消息。

当发送一个路由键为"system.error"的消息时，队列A和队列C都会接收到这条消息。

2.2 队列

基本上不需要改什么设置，填个队列名字就可以创建队列了
在这里插入图片描述
创建完之后就可以看到队列的信息总览了
在这里插入图片描述

2.3 绑定关系

这里我们用fanout类型的交换机作为演示，绑定交换机到hello.q1队列
在这里插入图片描述

绑定完之后能查看绑定关系
在这里插入图片描述
在这里插入图片描述

2.4 发消息

在交换机这里可以模拟发消息
在这里插入图片描述
在队列这里可以看到消息已经发过来了，因为这里是管理端，能看到消息，并不是把消息消费了，看了之后消息仍然在队列里面
在这里插入图片描述

3. 数据隔离

假设有两个用户，他们的交换机、队列等数据需要相互隔离，互不影响，这里创建一个新账户做演示
在这里插入图片描述
可以看到新账户是没有virtual hosts的，对于默认账号，是有一个名字为/的virtual hosts的
在这里插入图片描述
切换刚创建的账号登录，添加一个virtual hosts
在这里插入图片描述
创建好之后可以看到新创建的virtual hosts已经归属到当前账号了
在这里插入图片描述
但是我们仍然能看到其他虚拟主机的信息
在这里插入图片描述
可以在右上角切换虚拟主机，可以只查看指定虚拟主机的内容
在这里插入图片描述

4. SpringAMQP

将来开发编程肯定不是在控制台这样手动操作的，是需要写在代码里面的，手动操作繁琐，容易出错，而且也不方便自动化执行，如果从研发环境转到生产环境，这些配置肯定不可能再手动点一遍配出来，如果能通过执行代码的方式把这些交换机、队列重新自动化的配置好，那肯定是更准确，更方便的。

由于RabbitMQ采用了AMQP协议，因此它具备跨语言的特性。任何语言只要遵循AMQP协议收发消息，都可以与RabbitMQ交互。并且RabbitMQ官方也提供了各种不同语言的客户端。

但是，RabbitMQ官方提供的Java客户端编码相对复杂，一般生产环境下我们更多会结合Spring来使用。而Spring的官方刚好基于RabbitMQ提供了这样一套消息收发的模板工具：SpringAMQP。并且还基于SpringBoot对其实现了自动装配，使用起来非常方便。

4.1 环境配置

创建一个父工程，俩子工程，父工程只有一个pom文件，只用来做依赖管理
子工程一个用来发消息，一个用来接消息
父pom如下


<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.paran.test</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>pom</packaging>
    
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.12</version> <!-- 版本根据你的需求进行修改 -->
    </parent>
    
    <name>parent-project</name>
    <url>http://maven.apache.org</url>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

	    <dependency>
	      <groupId>com.fasterxml.jackson.dataformat</groupId>
	      <artifactId>jackson-dataformat-xml</artifactId>
	      <version>2.9.10</version>
	    </dependency>
    
    </dependencies>
    <modules>
        <module>consumer</module>
        <module>publisher</module>
    </modules>
</project>

子工程继承父工程，pom如下，另外一个类似

<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>
  <parent>
    <groupId>com.paran.test</groupId>
    <artifactId>parent-project</artifactId>
    <version>1.0-SNAPSHOT</version>
    <relativePath>../pom.xml</relativePath> <!-- 指向父POM的相对路径 -->
  </parent>
  <artifactId>consumer</artifactId>

  <packaging>jar</packaging>

  <name>consumer</name>
  <url>http://maven.apache.org</url>
</project>

4.2 消息收发初体验

1) 消息发送

hello.q1是之前演示的时候创建的队列，可以测试一下往这个队列发消息
publisher模块（子工程之一）的配置文件：

spring:
  rabbitmq:
    host: localhost # 你的虚拟机IP
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: paran # 用户名
    password: 123 # 密码

测试代码

package com.paran.test;

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class SpringAmpqTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testPublish() {
        String queueName = "hello.q1";
        String message = "Hello World!";
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

发完之后在RabbitMQ的后台可以看到消息的内容
在这里插入图片描述

2）消息接收


import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Component
public class Listener {
    @RabbitListener(queues = "hello.q1")
    public void listenQueueMessage(String msg){
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

2025-04-19 15:17:58.762  INFO 5780 --- [           main] com.paran.App                            : Starting App using Java 1.8.0_151 on c42038b38c1bfcd with PID 5780 (E:\projects\java_projects\RabbitMQ\consumer\target\classes started by Paran in E:\projects\java_projects\RabbitMQ)
2025-04-19 15:17:58.763  INFO 5780 --- [           main] com.paran.App                            : No active profile set, falling back to 1 default profile: "default"
2025-04-19 15:17:59.546  INFO 5780 --- [           main] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [localhost:5672]
2025-04-19 15:17:59.562  INFO 5780 --- [           main] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#3e8f7922:0/SimpleConnection@4b4dd216 [delegate=amqp://paran@127.0.0.1:5672/, localPort= 58179]
spring 消费者接收到消息：【hello,778899】
spring 消费者接收到消息：【Hello World!】
2025-04-19 15:17:59.588  INFO 5780 --- [           main] com.paran.App

4.3 声明队列和交换机

之前的队列和交换机，以及他们的绑定关系都是在控制台操作的，但是在实际开发时，队列和交换机是程序员定义的，将来项目上线，又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来，交给运维。在这个过程中是很容易出现错误的。因此推荐的做法是由程序启动时检查队列和交换机是否存在，如果不存在自动创建。

1) 基于@Bean注解

@Configuration
public class FanoutConfig {

    @Bean
    public FanoutExchange fanoutExchange(){
        //return ExchangeBuilder.fanoutExchange("new.fanout").build();
        return new FanoutExchange("new.fanout");
    }

    @Bean
    public Queue fanoutQueue1(){
        //QueueBuilder.durable("fanout.queue1").build();
        return new Queue("fanout.queue1");
    }
    @Bean
    public Binding bindingQueue1(Queue queue,FanoutExchange exchange){
        return BindingBuilder.bind(queue).to(exchange);

    }
}

项目启动起来自动创建交换机和队列，项目关闭之后交换机和队列仍然会保留
在这里插入图片描述

在这里插入图片描述
演示一下direct类型的交换机如何绑定队列

public class DirectConfig {
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("new.direct").build();
    }
    
    @Bean
    public Queue directQueue1(){
        return new Queue("direct.queue1");
    }
    
    @Bean
    public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
    }

    @Bean
    public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange) {
        return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
    }
}

这里使用.with()来绑定key，每个队列都要绑定一次，甚至一个队列要绑定多个key，这样做太麻烦了，下面介绍另外一种办法

2) 基于@RabbitListener注解（推荐）

@Component
public class DirectConfig {
    @RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue1"),
    exchange = @Exchange(name = "new.direct",type = ExchangeTypes.DIRECT),key = {"red","blue"}))
    public void listenDirectQueue1(String msg){
        System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
    }
}

这样也会自动创建交换机和队列，在单元测试中可以发个消息试一下能不能收到
如果key不是指定的red或者blue是收不到消息的
rabbitTemplate.convertAndSend一般有两个常用的重载
两个参数的：参数一是队列名，参数二是消息
三个参数的：参数一是交换机名，参数二是路由key，参数三是消息
参数二可以写""或者null

@SpringBootTest
public class AppTest
{
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        String exchangeName= "new.direct";
        String message = "Hello 1234567";
        // 发送消息
        //rabbitTemplate.convertAndSend(queueName, message);
        rabbitTemplate.convertAndSend(exchangeName,"blue",message);
    }
}

2025-04-19 16:27:04.064  INFO 11324 --- [           main] com.paran.App                            : Starting App using Java 1.8.0_151 on c42038b38c1bfcd with PID 11324 (E:\projects\java_projects\RabbitMQ\consumer\target\classes started by Paran in E:\projects\java_projects\RabbitMQ)
2025-04-19 16:27:04.065  INFO 11324 --- [           main] com.paran.App                            : No active profile set, falling back to 1 default profile: "default"
2025-04-19 16:27:04.829  INFO 11324 --- [           main] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [localhost:5672]
2025-04-19 16:27:04.844  INFO 11324 --- [           main] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#2c104774:0/SimpleConnection@2e8ab815 [delegate=amqp://paran@127.0.0.1:5672/, localPort= 50415]
2025-04-19 16:27:04.910  INFO 11324 --- [           main] com.paran.App                            : Started App in 1.032 seconds (JVM running for 1.604)
消费者1接收到direct.queue1的消息：【Hello 123】
消费者1接收到direct.queue1的消息：【Hello 1234567】

5. 配置JSON转换器

消息不止可以发送String类型的，也可以发送任意类型的Java对象，在数据传输时，它会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。只不过，默认情况下Spring采用的序列化方式是JDK序列化。JDK的序列化存在很多弊端，所以这里要换一换。

默认情况发送object，在控制台看到的消息格式非常不友好
在这里插入图片描述
在publisher和consumer中引入依赖

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.10</version>
</dependency>

import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.amqp.support.converter.MessageConverter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {
    @Bean
    public MessageConverter messageConverter(){
        // 1.定义消息转换器
        Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
        // 2.配置自动创建消息id，用于识别不同消息，也可以在业务中基于ID判断是否是重复消息
        jackson2JsonMessageConverter.setCreateMessageIds(true);
        return jackson2JsonMessageConverter;
    }
}

配置好消息转换器之后，我们就可以直接发个自定义的对象试试了

  @Test
    public void testSimpleQueue() {
        String exchangeName= "new.direct";
        rabbitTemplate.convertAndSend(exchangeName,"blue",Person.builder().age(18).name("paran").build());
    }

在这里插入图片描述
在@RabbitListener修饰的方法那里，入参可以写rabbitTemplate.convertAndSend里发送的类Person，也可以用Message（org.springframework.amqp.core.Message）来接，实际上在发送的时候也是先转成Message后发的

如果用Message来接的话，可以用getMessageProperties().getMessageId()来获取MessageId（如果在配置消息转换器的时候设置了jackson2JsonMessageConverter.setCreateMessageIds(true);）

如果获取消息体，可以用getBody()，这时候就是我们的Person对象了

Paran-ia
关注
异步处理优化：多线程线程池与消息队列的选择与应用
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
12-01 169万+
本文讨论了两种常见的异步处理方式：多线程线程池和消息队列（MQ）。通过将非核心逻辑异步化，可以提升系统的性能和响应速度。多线程线程池适用于本地并发任务，适合需要快速响应的场景，但无法处理跨服务任务。消息队列则适用于分布式系统，能够解耦服务并保证任务的可靠性和顺序性，适合处理高并发和高可靠性要求的任务。文章提供了实际代码示例，帮助开发者根据业务需求选择合适的异步处理方式。
消息队列MQ面试题解，基础面试题
qq_46248151的博客
01-26 1341
一个queue，有多个consumer去消费，这样就会造成顺序的错误，consumer从MQ里面读取数据是有序的，但是每个consumer的执行时间是不固定的，无法保证先读到消息的consumer一定先完成操作，这样就会出现消息并没有按照顺序执行，造成数据顺序错误，并且执行的时候是多线程执行的，并不能保证执行的顺序性。
消息队列MQ入门（超详细）
彬的博客
11-05 7917
channel:操作MQ的工具exchange:路由信息到队列中queue:缓存消息virtual host:虚拟主机，是对queue、exchange等资源的逻辑分组SpringAmqp的官网地址: https://spring.io/projects/spring-amqpAMQP: 是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。Spring AMQP: 是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。
thingsboard run 运行日志（错误）分析-7070端口占用
工控智联驿站
03-19 1392
在日志的前面部分，其他服务如 Tomcat 成功启动，端口 8080 正常，这说明主要的 HTTP 服务没有问题。用户需要检查该端口的占用情况，并释放它，或者修改配置文件中的端口号。接下来，需要确认用户是否在之前的运行中没有正确关闭 ThingsBoard，或者有其他进程占用了 7070 端口。此外，用户可能在配置中错误地指定了端口，或者有其他服务（如另一个 ThingsBoard 实例）正在使用该端口。总结来说，主要问题是端口冲突，解决方法是释放 7070 端口或更改配置中的端口。
消息队列MQ的基础知识
热门推荐
u013905744的专栏
06-01 3万+
MQ是什么？RabbitMQ是什么？AMQP是什么？ 消息队列（ message queuing ）使用消息将应用程序连接起来。这些消息通过像RabbitMQ 这样的消息代理服务器在应用程序之间路由。这就像是在应用程序之间放置一个邮局。 RabbitMQ是一个消息代理和队列服务器。 AMQP，即Advanced Message Queuing Protocol，一个提供统一消息服务的应用层标...
MQ入门总结（一）消息队列概念和使用场景
echojson的专栏
03-26 2862
转载：Java Jedis操作Redis示例（一）——pub/sub模式实现消息队列转载：消息队列的定义，以及引入消息队列可解决的问题转载：大型网站架构之分布式消息队列转载：架构设计：系统间通信（19）——MQ：消息协议（上）转载：架构设计：系统间通信（20）——MQ：消息协议（下）转载：消息系统该Push/Pull模式分析消息即是信息的载体。为了让消息发送者和消息接收者都能够明白消息所承载的信息...
消息队列 MQ 入门理解
夙梦流尘的博客
06-21 1万+
功能特性：应用场景：消息队列 MQ 可应用于如下几个场景：分布式事务在传统的事务处理中，多个系统之间的交互耦合到一个事务中，响应时间长，影响系统可用性。引入分布式事务消息，交易系统和消息队列之间，组成一个事务处理，能保证分布式系统之间数据的最终一致。；下游业务系统（购物车、积分、其他）相互隔离，并行处理。实时计算通过消息队列（MQ），将源端不停产生的数据实时流入到计算引擎，实现实时计算。可采用如下...
MQ消息队列的优缺点介绍以及对比选型
终生学习践行者
10-21 6291
详细介绍了MQ消息队列的有点和缺点，以及MQ消息队列的选型。
一文了解消息队列MQ（超详细+干货满满）
adobe754的博客
01-12 6135
一文了解消息队列MQ（超详细+干货满满）
SpringCloud-MQ消息队列
踏雨歌青春，诗酒趁年华
03-02 3200
本文介绍了Spring Cloud中常见的消息队列，重点探讨了RabbitMQ、Apache Kafka和ActiveMQ等消息中间件在分布式系统中的应用。通过解释消息队列的优势，如异步通信、解耦服务、可靠性和分布式事务，读者能够深入了解消息队列在微服务架构中的关键作用。进一步探讨了Spring Cloud对不同消息队列系统的支持，并提供了简单的使用示例。这篇文章旨在帮助开发者更好地理解消息队列的概念和应用，为构建弹性、可维护的分布式系统提供指导。
C# 实现消息的收发IBM WebSphere MQ 消息队列
02-12
2. **创建队列管理器和队列**：在WebSphere MQ服务器上，你需要创建一个队列管理器以及用于发送和接收消息的队列。 3. **配置appconfig文件**：在C#项目中，你需要在appconfig文件中设置连接到MQ服务器的参数，包括...
MQ消息队列
04-05
《MQ消息队列详解》 在信息技术领域，消息队列（Message Queue，简称MQ）是一种重要的中间件技术，它在分布式系统中起到了桥梁的作用，帮助各个组件之间进行异步通信和解耦。本文将深入探讨MQ消息队列的核心概念、...
rabbitmq消息队列的简单入门
jsaber的博客
01-10 2万+
一rabbitmq rabbitmq降低主程序线程压力,是一种非阻塞模式的分布式消息队列服务器，有生产者生产到rabbitmq，消费者消费 二。rabbitmq安装 1.安装rabbitmq 安装过程 参考 （http://www.rabbitmq.com/install-rpm.html）  rabbitmq-server 目前安装包被包含在 Fedora rpm仓库中 F
阿里Java面试被问：单元测试的最佳实践
2501_94505843的博客
01-04 884
本文系统介绍了软件测试的最佳实践，主要包含以下内容：1. 测试金字塔原则，推荐70%单元测试+20%集成测试+10%端到端测试的比例；2. 测试代码质量标准，包括命名规范、AAA模式等；3. Mock与Stub的使用场景和区别；4. 测试数据管理策略；5. 断言最佳实践；6. 测试隔离与可重复性；7. 测试性能与维护建议；8. 边界条件测试方法；9. 有意义的测试覆盖率目标；10. TDD开发流程。文章提供了大量代码示例，并总结了单元测试检查清单和测试金字塔指导原则，强调应重点关注业务逻辑、复杂算法和边界条
面向微服务事件驱动与异步消息可靠处理的互联网系统高可用设计与多语言工程实践分享
2501_94180531的博客
01-05 423
事件驱动解耦服务，提高吞吐可靠投递与幂等消费保证消息一致性监控、重试与顺序控制是稳定性的关键微服务事件驱动与异步消息可靠处理，使系统在高并发和复杂业务场景下保持稳定与可控。通过在多语言系统中统一幂等语义、结合可靠投递、顺序控制和监控策略，互联网系统能够在异步流程中实现高可用和长期可维护性。这篇关于事件驱动与异步消息可靠处理的工程实践分享，希望为你在微服务高可用设计中提供可落地、长期有效的参考思路。
TDengine JAVA 语言连接器入门指南
TDengine(老段）专注时序数据库领域
01-04 1717
JAVA 语言连接器
windows下的守护进程|nssm
slongzhang的博客
01-06 1078
NSSM（Non-Sucking Service Manager）是Windows系统中将普通程序封装为系统服务的工具。使用步骤包括：下载解压NSSM，以管理员身份运行CMD/PowerShell；通过图形界面或命令行安装服务，配置可执行文件路径、参数等；使用start/stop/restart命令管理服务；支持通过edit命令修改配置或remove删除服务；建议配置日志功能方便排查问题。核心功能是实现进程守护，确保程序异常退出后自动重启。
【Spring Boot】 接口性能优化“十板斧”：从数据库连接到 JVM 调优的全链路提升
最新发布
夜雨的博客
01-08 387
【Spring Boot】 接口性能优化“十板斧”：从数据库连接到 JVM 调优的全链路提升。Spring Boot 接口性能优化是一个系统工程，而非单点的技术修补。上述“十板斧”涵盖了从数据库交互、应用架构设计、代码逻辑实现到底层运行时环境的全方位策略。
SpringBoot3 + GraalVM安装和初次打包
风不知从何处起的小屋
01-08 496
本文介绍了使用GraalVM将Spring Boot项目打包为原生可执行文件的完整流程。
深入解析MQ消息队列技术与应用
MQ消息队列（Message Queue）是一种应用程序之间的通信方法，它允许不同应用或者同一应用的不同部分通过队列的形式进行信息传递。消息队列是一个先进先出的数据结构，可以存储消息，直到它们被应用读取。这种技术在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值