rabbitmq（1）：核心机制与 SpringAMQP 详解

garmin Chen2026-05-30 8:19

学习时整理，如有错误，欢迎指正

同步&异步

同步调用

同步调用是指一个方法、函数或模块在调用另一个功能时，必须等待其执行完成并返回结果后，才能继续向下执行。

优点：

  • 逻辑简单
    程序按照顺序执行，容易理解。
  • 开发方便
    符合人类正常思维流程。
  • 调试容易
    出现问题时容易定位代码执行位置。
  • 数据可靠
    能够立即获得返回结果，方便后续处理。

缺点：

  • 拓展性差
    同步调用中，模块之间依赖较强，一个功能变动可能影响多个调用方，系统难以灵活扩展。
  • 性能下降
    调用方需要一直等待结果返回，期间线程会被阻塞，导致资源利用率降低、整体执行效率下降。
  • 级联失败
    如果被调用方出现超时、异常或宕机，调用方也会受到影响；当依赖链较长时，故障会逐层传播，最终可能导致整个系统不可用。

异步调用

异步调用（Asynchronous Call）是指调用方发送请求后，不需要等待结果返回，可以继续执行后续操作；

被调用方处理完成后，再通过回调、通知或消息返回结果。

角色：

  • 消息发送者（Producer）

负责发送消息的一方，也就是原来的调用方。

它不会直接调用目标服务，而是把消息发送到消息队列中，然后立即继续执行后续操作。

例如：

订单服务下单后，发送"订单创建成功"消息。

  • 消息Broker

负责管理、存储、转发消息的中间组件。

可以理解为"消息中转站"

主要作用：

  1. 接收消息
  2. 暂存消息
  3. 转发消息
  4. 保证消息可靠传递

常见Broker：

  1. RabbitMQ
  2. Apache Kafka
  3. RocketMQ
  4. ActiveMQ
  • 消息接收者（Consumer）

负责接收并处理消息的一方，也就是原来的服务提供方。

它会不断监听消息队列，一旦收到消息，就执行对应业务。

例如：

库存服务收到"订单创建"消息后，进行扣减库存。

流程：

用户发起支付请求后，请求先进入支付服务。

支付服务优先完成核心业务：

  1. 调用用户服务扣减余额（50ms）
  2. 更新交易流水（50ms）

这两个属于支付核心逻辑，需要同步执行。

随后，支付服务不会再直接调用其它服务，而是把"支付成功"的消息发送到消息Broker（消息中间件）。

Broker接收到消息后，会异步通知多个下游服务：

  1. 交易服务更新订单状态
  2. 通知服务发送短信通知
  3. 积分服务增加用户积分

这些服务分别独立消费消息，并完成自己的业务。

优点：

  • 耦合度更低
    服务之间不再直接调用，而是通过消息Broker通信，各服务可以独立开发和部署。
  • 性能更好
    发送消息后即可返回，无需长时间阻塞等待，提高系统吞吐量和响应速度。
  • 业务拓展性强
    新增业务时，只需新增消息消费者即可，不需要修改原有代码。
  • 故障隔离，避免级联失败
    某个下游服务异常时，不会直接影响核心业务，其它服务仍可正常运行。

缺点：

  • 完全依赖于Broker的可靠性、安全性和性能
    如果消息中间件宕机、消息丢失或性能不足，整个异步系统都会受到影响。
  • 架构复杂，后期维护和调试麻烦
    需要处理消息丢失、重复消费、顺序消费、消息堆积等问题，排查问题也比同步调用更困难。

MQ技术选型

MQ ：MessageQueue消息队列，就是异步中的broker

RabbitMQ ActiveMQ RocketMQ Kafka
公司/社区 Rabbit Apache 阿里 Apache
开发语言 Erlang Java Java Scala&Java
协议支持 AMQP，XMPP，SMTP，STOMP OpenWire,STOMP，REST,XMPP,AMQP 自定义协议 自定义协议
可用性 高 一般 高 高
单机吞吐量 一般 差 高 非常高
消息延迟 微秒级 毫秒级 毫秒级 毫秒以内
消息可靠性 高 一般 高 一般

追求可用性：Kafka、 RocketMQ 、RabbitMQ

追求可靠性：RabbitMQ、RocketMQ

追求吞吐能力：RocketMQ、Kafka

追求消息低延迟：RabbitMQ、Kafka

安装

Shell 复制代码 
docker run \
 -e RABBITMQ_DEFAULT_USER=root \
 -e RABBITMQ_DEFAULT_PASS=1234 \
 -v mq-plugins:/plugins \
 --name mq \
 --hostname mq \
 -p 15672:15672 \
 -p 5672:5672 \
 --network hm-net\
 -d \
 rabbitmq:3.8-management
  • 15672：RabbitMQ提供的管理控制台的端口
  • 5672：RabbitMQ的消息发送处理接口

结构

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

数据隔离

作用：

当只搭建一套MQ集群，公司内的多个不同项目同时使用时，为了避免互相干扰， 我们会利用virtual host的隔离特性，将不同项目隔离。一般会做两件事情：

  • 给每个项目创建独立的运维账号，将管理权限分离。
  • 给每个项目创建不同的virtual host，将每个项目的数据隔离。

SpringAMQP

概述：

文档地址：Spring AMQP

amop：

Advanced Message Queuing Protocol，是用于在应用程序之间传递业务消息的开放标准。

该协议与语言和平台无关，更符合微服务中独立性的要求。

springamop：

Spring AMQP 是基于 AMQP 协议定义的一套 API 规范，

提供了模板来发送和接收消息。

包含两部分，其中 spring-amqp 是基础抽象，spring-rabbit 是底层的默认实现。

SpringAMQP提供了三个功能：

  • 自动声明队列、交换机及其绑定关系
  • 基于注解的监听器模式，异步接收消息
  • 封装了RabbitTemplate工具，用于发送消息

使用：

配置项信息：

YAML 复制代码 
spring:
  rabbitmq:
    host:  # 你的虚拟机IP
    port:  # 端口
    virtual-host:  # 虚拟主机
    username:  # 用户名
    password: # 密码

发送：

java 复制代码 
@SpringBootTest
public class SpringAmqpTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleQueue() {
        // 队列名称
        String queueName = "simple.queue";
        // 消息
        String message = "hello, spring amqp!";
        // 发送消息
        rabbitTemplate.convertAndSend(queueName, message);
    }
}

接收：

java 复制代码 
@Component
public class SpringRabbitListener {
        // 利用RabbitListener来声明要监听的队列信息
    // 将来一旦监听的队列中有了消息，就会推送给当前服务，调用当前方法，处理消息。
    // 可以看到方法体中接收的就是消息体的内容
    @RabbitListener(queues = "simple.queue")
    public void listenSimpleQueueMessage(String msg) throws InterruptedException {
        System.out.println("spring 消费者接收到消息：【" + msg + "】");
    }
}

work模式

概述：

Work Queue（工作队列）模式，也叫竞争消费者模式，是消息队列中最常见的一种模型。

核心思想：

一个生产者发送消息到一个队列，多个消费者共同消费这个队列中的消息。

队列中的每条消息只会被其中一个消费者处理，实现"任务分摊"。

流程：

  1. 生产者（Producer）
    • 发送消息到Queue
  2. 消息队列（Queue）
    • 负责缓存消息
    • 按顺序存储任务
  3. 多个消费者（Consumer）
    • 同时监听同一个队列
    • 谁先抢到消息谁处理

特点：

  • 一条消息只能被消费一次
  • 多个消费者之间是竞争关系
  • 可以提升系统吞吐量
  • 适合异步任务处理

典型场景：

  • 订单处理
  • 短信发送
  • 邮件发送
  • 图片压缩
  • 日志处理
  • 秒杀削峰

使用：

默认为轮询：

发送消息：

用循环模拟

java 复制代码 
public void testWorkQueue1() {
    String queueName = "queue1";
    for(int i=0;i<50;i++)
    {
        String Message = "message"+i+ LocalDateTime.now();
        rabbitTemplate.convertAndSend(queueName, Message);
    }

}

接受消息：

java 复制代码 
    @RabbitListener(queues = "queue1")
    public void receive1(String msg){
        System.out.println("workqueue1:receive msg:"+msg);
    }
    @RabbitListener(queues = "queue1")
    public void receive2(String msg){
        System.out.println("workqueue2:receive msg:"+msg);
    }

此时两个queue交替处理信息

添加配置后，能者多劳：

yml 复制代码 
spring:
  rabbitmq:
    listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息，处理完成才能获取下一个消息

使用sleep模拟处理时的延迟

java 复制代码 
    @RabbitListener(queues = "queue1")
    public void receive1(String msg) throws InterruptedException {
        System.out.println("workqueue1:receive msg:"+msg);
        Thread.sleep(10);
    }
    @RabbitListener(queues = "queue1")
    public void receive2(String msg) throws InterruptedException {
        System.out.println("workqueue2:receive msg:"+msg);
        Thread.sleep(200);
    }

此时queue1处理更多，处理消息条数大致为为20：1

转换机

  • Publisher：生产者，不再发送消息到队列中，而是发给交换机
  • Exchange：交换机，一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。
  • Queue：消息队列也与以前一样，接收消息、缓存消息。不过队列一定要与交换机绑定。
  • Consumer：消费者，与以前一样，订阅队列，没有变化

Exchange （交换机）：只负责转发消息，不具备存储消息的能力，

因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

交换机的类型有四种：

  • Fanout：广播，将消息交给所有绑定到交换机的队列。我们最早在控制台使用的正是Fanout交换机
  • Direct：订阅，基于RoutingKey（路由key）发送给订阅了消息的队列
  • Topic：通配符订阅，与Direct类似，只不过RoutingKey可以使用通配符
  • Headers：头匹配，基于MQ的消息头匹配，用的较少。

fanout交换机

广播交换机

概述：

  • 可以有多个队列
  • 每个队列都要绑定到Exchange（交换机）
  • 生产者发送的消息，只能发送到交换机
  • 交换机把消息发送给绑定过的所有队列
  • 订阅队列的消费者都能拿到消息

使用：

发送消息

java 复制代码 
@Test
public void testFanoutExchange() {
    String exchangeName = "fanoutExchange";
    String message = "hello spring amqp!";
    rabbitTemplate.convertAndSend(exchangeName,"", message);
}

参数routing必须设置为空，fanout模式无视routingkey

接受消息：

java 复制代码 
@RabbitListener(queues="fanoutqueue1")
public void receive3(String msg) throws InterruptedException {
    System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
}
@RabbitListener(queues="fanoutqueue2")
public void receive4(String msg) throws InterruptedException {
    System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
}

两者都能收到

direct交换机

概述：

根据 RoutingKey（路由键）进行精确匹配，把消息发送到对应队列。

生产者发送消息时：

  • 会指定：
    • Exchange（交换机）
    • RoutingKey（路由键）

队列绑定交换机时：

  • 也会指定一个 BindingKey（绑定键）

Direct Exchange 会：

判断 RoutingKey 是否与 BindingKey 完全一致。

一致消息则进入对应队列，不一致则不投递

使用：

  1. 声明一个名为hmall.direct的交换机
  2. 声明队列direct.queue1，绑定hmall.direct，bindingKey为blud和red
  3. 声明队列direct.queue2，绑定hmall.direct，bindingKey为yellow和red
  4. 在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2
  5. 在publisher中编写测试方法，向hmall.direct发送消息

发送消息：

java 复制代码 
    @Test
    public void testDirectExchange() {
        String exchangeName = "directExchange";
        String message = "hello red";
        rabbitTemplate.convertAndSend(exchangeName,"red", message);
        rabbitTemplate.convertAndSend(exchangeName,"blue", message);
    }

接收消息：

java 复制代码 
    @RabbitListener(queues="directqueue1")
    public void receive5(String msg) throws InterruptedException {
        System.out.println("消费者1接收到direct消息：【" + msg + "】");
    }
    @RabbitListener(queues="directqueue2")
    public void receive6(String msg) throws InterruptedException {
        System.out.println("消费者2接收到direct消息：【" + msg + "】");
    }

其中，queue1 BindingKey 为blue和red

​ queue2 BindingKey 为yellow和red

Topic交换机

概述：

Topic可以根据RoutingKey把消息路由到不同的队列

但Exchange可以让队列在绑定BindingKey 的时候使用通配符

使他更具灵活性

通配符规则：

  • #：匹配一个或多个词
  • *：匹配不多不少恰好1个词

例：

  • item.#：能够匹配item.spu.insert 或者 item.spu
  • item.*：只能匹配item.spu

使用：

发送消息：

java 复制代码 
    @Test
    public void topicExchange() {
        String exchangeName = "topicExchange";
        String message1 = "sunny";
        String message2 = "raining";
        String message3 = "cloudy";
        rabbitTemplate.convertAndSend(exchangeName,"china.news", message1);
        rabbitTemplate.convertAndSend(exchangeName,"japan.news", message2);
        rabbitTemplate.convertAndSend(exchangeName,"china.weather", message3);
    }

接收消息：

java 复制代码 
    @RabbitListener(queues="topicqueue1")
    public void receive7(String msg) throws InterruptedException {
        System.out.println("消费者1接收到topic消息：【" + msg + "】");
    }
    @RabbitListener(queues="topicqueue2")
    public void receive8(String msg) throws InterruptedException {
        System.out.println("消费者2接收到topic消息：【" + msg + "】");
    }

接收内容：

shell 复制代码 
消费者2接收到topic消息：【sunny】
消费者1接收到topic消息：【sunny】
消费者2接收到topic消息：【raining】
消费者1接收到topic消息：【cloudy】

@Bean的方式声明队列和交换机

springamqp封装好exchange可直接使用

也可使用exchangebuilder就简化操作

而在绑定队列和交换机时，则需要使用BindingBuilder来创建Binding对象

使用：

java 复制代码 
@Configuration
public class DirectConfig {

    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("hmall.direct").build();
        //return new DirectExchange("hmall.direct",true,false);
    }

    /**
     * 第1个队列
     */
    @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");
    }

    /**
     * 第2个队列
     */
    @Bean
    public Queue directQueue2(){
        return new Queue("direct.queue2");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
    }
    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){
        return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
    }
}

然而，使用with方法只能绑定一个key，需要多次绑定，故代码重复

基于注解方式来声明

java 复制代码 
@RabbitListener(bindings = @QueueBinding(
            value=@Queue(name="direct.queue1"),
            exchange=@Exchange(name="directExchange"),
            key={"red","blue"}
    ))
    public void directQueue1Listener(String msg) throws InterruptedException {
        System.out.println("directQueue1Listener"+msg);
    }
   @RabbitListener(bindings = @QueueBinding(
            value=@Queue(name="direct.queue2"),
            exchange=@Exchange(name="directExchange"),
            key={"red","yellow"}
    ))
    public void directQueue2Listener(String msg) throws InterruptedException {
        System.out.println("directQueue2Listener"+msg);
    }

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
}
相关推荐
Mr_sst2 小时前
AI 大模型应用开发实习｜如何找岗 + 面试真题 + 面经总结
java·人工智能·ai·面试·职场和发展
phltxy2 小时前
RabbitMQ 应用问题
数据库·分布式·rabbitmq
星晨雪海2 小时前
基于 SpringBoot + Redis (Lettuce) + RabbitMQ 实现「Redis 预扣库存 + 异步同步数据库」
数据库·spring boot·java-rabbitmq
weelinking2 小时前
【产品】10_搭建前端框架——把你的原型变成真实页面
java·大数据·前端·数据库·人工智能·python·前端框架
一 乐2 小时前
图书电子商务网站系统|基于SprinBoot+vue图书电子商务网站设计与实现(源码+数据库+文档)
java·前端·数据库·vue.js·论文·毕设·图书电子商务网站系统
西敏寺的乐章2 小时前
01-倒排索引原理-搜索引擎为什么能秒搜
java·elasticsearch·搜索引擎
yaoxin5211232 小时前
421. Java 日期时间 API - 包结构 & 方法命名规范
java·前端·python
方也_arkling10 小时前
【Java-Day08】static / final / 枚举
java·开发语言
橙淮11 小时前
Spring Bean作用域与生命周期全解析
java·spring
热门推荐
01GitHub 镜像站点02DeepSeek V4 + Claude Code thinking mode 400 错误修复方案03【AI】2026 年具身智能模型和世界模型总结04Codex 接入 DeepSeek API 完整配置文档05【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法06裂开！ChatGPT 居然开始要手机号验证，附详细解决方法07CC-Switch & Claude 基于 Linux 服务器安装使用指南08CC-Switch 全平台下载、安装与使用全指南（Windows/macOS/Linux）09几个好用的ip纯净度检测网站10API Key 登录 Codex 也能用插件了，还支持会话删除和导出