1. Toy模板网首页
  2. > Toy博客

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始

9月前 作者：Xcong_Zhu 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

参考资料

  • RabbitMQ官方网站
  • RabbitMQ官方文档
  • 噼咔噼咔-动力节点教程

四、RabbitMQ ：Exchange 交换机

4.1 交换机类型

Exchange （简称X）翻译为交换机、交换器、路由器…

注意：交换机并不是所有消息中间件都有，但是是一个很好的概念

交换机分为以下四个类型

  • 扇形交换机：Fanout Exchange
  • 直连
  • 主题
  • 头部

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.2 扇形交换机 Fanout Exchange

4.2.1 概念

扇形交换机会将生产者的消息投递到所有绑定的队列中，不需要路由键，更不需要路由键匹配，相当于广播群发。

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.2.1 实例：生产者

环境，jdk1.8，ieda2022.3.3，springboot版本2.5.2

4.2.1.1 添加起步依赖
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

项目用到的几个依赖

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.2.1.2 配置文件

application.yml

spring:
  rabbitmq:
    host: 192.168.3.10
    port: 5672
    username: admin
    password: huiju@2022!
    virtual-host: hc-test

注意和控制台端口做出区分，控制台是15672，服务器端口是5672

4.2.1.3 JavaBean进行配置

思路整理

  • 定义一个扇形交换机 （命名
  • 定义一个队列A （命名queueA
  • 定义一个队列A （命名queueB
  • 核心配置：绑定交换机和队列

具体代码：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author zhuhuacong
 * @Date: 2023/10/13/ 17:25
 * @description rmq交换机配置
 */
@Configuration
public class ExchangeConfig {
    // 定义交换机
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("xcong.fanout");
    }

    // 定义两个不同的队列
    @Bean
    public Queue queueA(){
        return new Queue("xcong.fanout.A");
    }
    @Bean
    public Queue queueB(){
        return new Queue("xcong.fanout.B");
    }

    // 绑定队列，注意参数名称
    @Bean
    public Binding bindingA(FanoutExchange fanoutExchange , Queue queueA){
        return BindingBuilder.bind(queueA).to(fanoutExchange);
    }
    @Bean
    public Binding bindingB(FanoutExchange fanoutExchange , Queue queueB){
        return BindingBuilder.bind(queueB).to(fanoutExchange);
    }
}

注意：

  • 绑定队列时注意传入的参数名称要和bean 的名称一致
  • 不需要特意到rabbitmq界面里创建队列，只需要发送消息就会自动创建！
  • 但是：要求创建好virtual host
4.2.1.4 创建一个发送消息的业务
package com.zhc.rabbitmqdemo.demos.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.nio.charset.StandardCharsets;

/**
 * @Author zhuhuacong
 * @Date: 2023/10/13/ 17:39
 * @description 扇形X
 */
@RestController
@Slf4j
@RequestMapping("/fanout")
public class FanoutController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/{msg}")
    public void sendMessage(@PathVariable("msg") String msg){
        rabbitTemplate.convertAndSend("xcong.fanout","",msg.getBytes(StandardCharsets.UTF_8));
        log.info("成功发送消息 {} " ,msg);
    }
}

成功启动后访问http://localhost:12378/fanout/jjjj

可以检测是否发送成功：

  • 控制台消息如下：

    2023-10-13 17:47:53.593  INFO 30476 --- [io-12378-exec-2] o.s.a.r.c.CachingConnectionFactory       : Attempting to connect to: [192.168.3.10:5672]
2023-10-13 17:47:53.608  INFO 30476 --- [io-12378-exec-2] o.s.a.r.c.CachingConnectionFactory       : Created new connection: rabbitConnectionFactory#791c12e3:1/SimpleConnection@69c9eb7c [delegate=amqp://admin@192.168.3.10:5672/hc-test, localPort= 53349]
2023-10-13 17:47:53.675  INFO 30476 --- [io-12378-exec-2] c.z.r.demos.service.FanoutController     : 成功发送消息 jjjj
4.2.1.5 查看mq后台
  1. 使用client发送队列消息后，mq会自动帮我们创建交换机和队列，并进行绑定

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.2.1.6 如何在后台查看队列中的消息

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.2.2 实例： 消费者
4.2.2.1 依赖导入
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
4.2.2.2 配置文件
server:
  port: 12378

spring:
  rabbitmq:
    host: 192.168.3.10
    port: 5672
    username: admin
    password: huiju@2022!
    virtual-host: hc-test
4.2.2.3 添加消费者（接受者）类

注意使用几个关键注解：

  • 在对应的方法上添加@RabbitListener
  • 可以传入参数queues，属性为队列名（可以多个
@Service
@Slf4j
public class ConsumerService {

    @RabbitListener(queues = {"xcong.fanout.A", "xcong.fanout.B"})
    public void revicerMsg(Message message) {
        byte[] body = message.getBody();
        MessageProperties messageProperties = message.getMessageProperties();
        String consumerQueue = messageProperties.getConsumerQueue();
        String receivedExchange = messageProperties.getReceivedExchange();

        log.info("接收到的消息：{} . 消息队列 ：{} , 交换机名称：{}",new String(body) , consumerQueue , receivedExchange);
    }
}

  • 为了便于接受消息，设置打印了参数信息

  • 在生产者出产生消息，然后控制台输出：

    接收到的消息：一个普通的信息 . 消息队列 ：xcong.fanout.B , 交换机名称：xcong.fanout
接收到的消息：一个普通的信息 . 消息队列 ：xcong.fanout.A , 交换机名称：xcong.fanout

    成功接受消息

4.3 直连交换机 Direct Exchange

4.3.1 介绍

根据 路由键 匹配，进行路由消息队列。

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

流程梳理如下：

  1. 生产者将消息发送到交换机X
  2. 交换机会根据路由键匹配队列
  3. 并且同一个键也可以匹配多个队列
4.3.2 实例：生产者

具体的依赖和配置都不变，不做赘述了。接下来的示例只会解释不同的部分

4.3.2.1 配置交换机和队列

思路整理

  1. （可选引入spring提供的注解@ConfigurationProperties 从配置文件中读取属性
  2. 定义交换机
  3. 定义队列
  4. 绑定交换机和队列（注意：需要指定key
package com.zhc.rabbitmqdemo.demos.config;

import org.springframework.amqp.core.*;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author zhuhuacong
 * @Date: 2023/10/16/ 9:58
 * @description 直连交换机
 */
@Configuration
public class DirectExchangeConfig {
    public static String exchangeName = "xcong.direct";
    public static String queueC = "xcong.direct.C";
    public static String queueD = "xcong.direct.D";

    // 创建交换机
    @Bean
    public DirectExchange directExchange(){
        // 使用建造者模式
        return ExchangeBuilder.directExchange(exchangeName).build();
    }

    // 创建队列
    @Bean
    public Queue queueC(){
        return QueueBuilder.durable(queueC).build();
    }
    // 创建队列
    @Bean
    public Queue queueD(){
        return QueueBuilder.durable(queueD).build();
    }

    // 绑定队列
    @Bean
    public Binding bindingC(DirectExchange directExchange , Queue queueC){
        return BindingBuilder.bind(queueC).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingD1(DirectExchange directExchange , Queue queueD){
        return BindingBuilder.bind(queueD).to(directExchange).with("error");
    }
    @Bean
    public Binding bindingD2(DirectExchange directExchange , Queue queueD){
        return BindingBuilder.bind(queueD).to(directExchange).with("info");
    }
    @Bean
    public Binding bindingD3(DirectExchange directExchange , Queue queueD){
        return BindingBuilder.bind(queueD).to(directExchange).with("warning");
    }

}
4.3.2.2 发送消息
@RestController
@Slf4j
@RequestMapping("/direct")
public class DirectController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/{key}/{msg}")
    public void sentErrorMsg(@PathVariable("msg") String msg , @PathVariable("key")String key){
        log.info("准备发送的信息：{} ， 路由键 :{}",msg , key);
        rabbitTemplate.convertAndSend(exchangeName , key , msg.getBytes(StandardCharsets.UTF_8));
        log.info("成功发送");
    }
}
4.3.2.3 测试接口并查看后台

小结，发送消息时的路由key和队列的key一致，就可以将消息发送到指定的UI队列

访问接口/direct/info/一个普通的信息：队列D接收到消息

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

访问接口/direct/error/一个报错的信息：队列CD都接收到消息

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

访问接口/direct/warning/一个警告：队列D接收到消息

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.3.3 接收消息

接受消息代码一致，截图展示一下结果

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.4 主题交换机 Topic Exchange

4.4.1 介绍

通配符匹配（路由键），相当于模糊查询

  • #匹配多个单词，用来表示任意数量的单词（一个或多个

  • *匹配一个单词（必须且只有一个）

    • 用.来隔开为一个单词

举个例子：左边是队列的路由键，而右边是发送的路由键

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.4.2 实例

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.4.2.1 配置
@Configuration
public class TopicExchangeConfig {
    public static String exchangeName = "xcong.topic";
    public static String queue1 = "xcong.queue.1";
    public static String queue2 = "xcong.queue.2";

    @Bean
    public TopicExchange topicExchange(){
        return ExchangeBuilder.topicExchange(exchangeName).build();
    }

    @Bean
    public Queue queue1(){
        return QueueBuilder.durable(queue1).build();
    }
    @Bean
    public Queue queue2(){
        return QueueBuilder.durable(queue2).build();
    }


    @Bean
    public Binding binding1(TopicExchange topicExchange , Queue queue1){
        return BindingBuilder.bind(queue1).to(topicExchange).with("*.orange.*");
    }

    @Bean
    public Binding binding2A(TopicExchange topicExchange , Queue queue2){
        return BindingBuilder.bind(queue2).to(topicExchange).with("*.*.rabbit");
    }

    @Bean
    public Binding binding2B(TopicExchange topicExchange , Queue queue2){
        return BindingBuilder.bind(queue2).to(topicExchange).with("lazy.#");
    }
}
4.4.2.3 接口
@RestController
@Slf4j
@RequestMapping("/topic")
public class TopicController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/{key}/{msg}")
    public void sendMsg(@PathVariable("key")String key , @PathVariable("msg")String msg){
        log.info("发送的信息：{}，发送的键：{}", msg , key);
        Message message = MessageBuilder.withBody(msg.getBytes(StandardCharsets.UTF_8)).build();
        rabbitTemplate.convertAndSend(TopicExchangeConfig.exchangeName , key , message);

    }
}
4.4.2.4 测试

  • 访问接口/topic/ssss/一条普通的消息：无法再后台查询到接受的消息（无匹配）

  • 访问接口/topic/lazy.orange.rabbit/一条普通的消息：队列1和2都可查

    【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

  • 访问接口/topic/A.orange.B/一条普通的消息:只有队列1接收到消息

    【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.4.3 消费者实例（略

4.5 头部交换机 Headers Exchanges

4.5.1 概述

头部交换机使用较少，要知道，每一次消息不只包含body，还有头部信息headers。

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

4.5.2 生产者代码

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

注意：

  1. 头部交换机的不同之处在于，在绑定交换机时，配置的参数不一样
  2. 可以是string，也可以是map<Stirng，object>
  3. 绑定的方法whereAll 和whereAny涉及到两种不同的匹配机制：前者是全匹配，后者是任意一个匹配即可
4.5.2.1 配置
@Configuration
public class HeaderExchangeConfig {
    public static String exchangeName = "xcong.header";

    @Bean
    public HeadersExchange headersExchange(){
        return ExchangeBuilder.headersExchange(exchangeName).build();
    }

    @Bean
    public Queue queue9(){
        return QueueBuilder.durable("xcong.queue.9").build();
    }
    @Bean
    public Queue queue10(){
        return QueueBuilder.durable("xcong.queue.10").build();
    }

    @Bean
    public Binding binding9(HeadersExchange headersExchange , Queue queue9){
        Map<String , Object> headers = new HashMap<>();
        headers.put("type" , "m");
        headers.put("status",1);

        return BindingBuilder.bind(queue9).to(headersExchange).whereAll(headers).match();
    }

    @Bean
    public Binding binding10(HeadersExchange headersExchange , Queue queue10){
        Map<String , Object> headers = new HashMap<>();
        headers.put("type" , "s");
        headers.put("status",2);

        return BindingBuilder.bind(queue10).to(headersExchange).whereAny(headers).match();
    }
}

访问控制台可以看到匹配规则：

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始,学习笔记,学习,笔记,spring boot,rabbitmq,java-rabbitmq

注意看q10是匹配规则就是all ，而q10的规则是any文章来源地址https://www.toymoban.com/news/detail-722928.html

4.5.2.2 测试接口
@RestController
@Slf4j
@RequestMapping("/header")
public class HeadersController {
    @Resource
    private RabbitTemplate rabbitTemplate;

    @GetMapping("/{type}/{status}/{msg}")
    public void sendMsg(@PathVariable("type")String type , @PathVariable("status")Integer status , @PathVariable("msg")String msg){
        log.info("(头部交换器)发送的信息：{}，发送的头部为< type : {} , status : {}>", msg , type ,status);
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setHeader("type",type);
        messageProperties.setHeader("status" , status);
        Message message = MessageBuilder.withBody(msg.getBytes(StandardCharsets.UTF_8)).andProperties(messageProperties).build();
        rabbitTemplate.convertAndSend(HeaderExchangeConfig.exchangeName , "" , message);

    }
}
4.5.2.3 接口测试
  • 访问/header/k/1/一个普通的消息：没有匹配
  • 访问/header/m/1/一个普通的消息：匹配Q9
  • 访问/header/s/1/一个普通的消息：匹配Q10（走了任意匹配
4.5.3 消费者（略

到了这里，关于【学习笔记】RabbitMQ02：交换机，以及结合springboot快速开始的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【图解RabbitMQ-6】说说交换机在RabbitMQ中的四种类型以及使用场景

    【图解RabbitMQ-6】说说交换机在RabbitMQ中的四种类型以及使用场景

    🧑‍💻作者名称：DaenCode 🎤作者简介：CSDN实力新星，后端开发两年经验，曾担任甲方技术代表，业余独自创办智源恩创网络科技工作室。会点点Java相关技术栈、帆软报表、低代码平台快速开发。技术尚浅，闭关学习中······ 😎人生感悟：尝尽人生百味，方知世间冷暖。

    2024年02月07日
    浏览(78)
  • 【RabbitMQ】 RabbitMQ 消息的延迟 —— 深入探索 RabbitMQ 的死信交换机，消息的 TTL 以及延迟队列

    【RabbitMQ】 RabbitMQ 消息的延迟 —— 深入探索 RabbitMQ 的死信交换机，消息的 TTL 以及延迟队列

    消息队列是现代分布式应用中的关键组件，用于实现异步通信、解耦系统组件以及处理高并发请求。消息队列可以用于各种应用场景，包括任务调度、事件通知、日志处理等。在消息队列的应用中，有时需要实现消息的延迟处理、处理未能成功消费的消息等功能。 本文将介绍

    2024年02月05日
    浏览(73)
  • 消息队列-RabbitMQ：Exchanges、绑定 bindings以及3大常用交换机（Fanout exchange、Direct exchange、Topics exchange）

    消息队列-RabbitMQ：Exchanges、绑定 bindings以及3大常用交换机（Fanout exchange、Direct exchange、Topics exchange）

    RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列 。实际上， 通常生产者甚至都不知道这些消息传递传递到了哪些队列中 。 相反， 生产者只能将消息发送到交换机 (exchange) ， 交换机工作 的内容非常简单， 一方面它接收来自生产者的消息 ， 另一

    2024年04月08日
    浏览(50)
  • RabbitMQ 备份交换机和死信交换机

    RabbitMQ 备份交换机和死信交换机

      为处理生产者将消息推送到交换机中，交换机按照消息中的路由键及自身策略无法将消息投递到指定队列中造成消息丢失的问题，可以使用备份交换机。   为处理在消息队列中到达TTL的过期消息，可采用死信交换机进行消息转存。可以通过死信交换机的方式实现延迟队

    2024年02月14日
    浏览(49)
  • 利用消息中间件RabbitMQ创建队列以及扇出（Fanout）、订阅（Direct）、主题（Topic）交换机来完成消息的发送和监听接收（完整版）

    利用消息中间件RabbitMQ创建队列以及扇出（Fanout）、订阅（Direct）、主题（Topic）交换机来完成消息的发送和监听接收（完整版）

    目录 一、前期项目环境准备 1.1父项目以及子项目 1.2配置pom.xml 1.3配置application.yml 二、扇出（Fanout） 交换机实现消息的发送和接收 2.1编写子项目consumer（消费者，接收消息）的代码实现扇出（Fanout）交换机接收消息 2.1.1consumer子项目结构 2.1.2FanoutConfig类的实现扇出（Fanout）交

    2024年02月05日
    浏览(56)
  • RabbitMQ之Exchange（交换机）属性及备用交换机解读

    RabbitMQ之Exchange（交换机）属性及备用交换机解读

    目录 基本介绍 主要结论 备用交换机  springboot代码实战（备用交换机） 实战架构 工程概述 RabbitConfigDeal 配置类：创建队列及交换机并进行绑定  MessageService业务类：发送消息及接收消息 主启动类RabbitMq01Application：实现ApplicationRunner接口 在 RabbitMQ 中，交换机主要用来将生产

    2024年02月02日
    浏览(49)
  • 【RabbitMQ】RabbitMQ的交换机

    【RabbitMQ】RabbitMQ的交换机

    在上文中， 都没有交换机，生产者直接发送消息到队列。 而一旦引入交换机，消息发送的模式会有很大变化：可以看到，在订阅模型中，多了一个exchange角色，而且过程略有变化： Publisher：生产者，不再发送消息到队列中，而是发给交换机 Exchange：交换机，一方面，接收生

    2024年03月12日
    浏览(54)
  • 【RabbitMQ（day3）】扇形交换机和主题交换机的应用

    【RabbitMQ（day3）】扇形交换机和主题交换机的应用

    扇型交换机将消息路由给绑定到它身上的所有队列，而不会理会绑定的路由键。如果 N 个队列绑定到某个扇型交换机上，当有消息发送给此扇型交换机时，交换机会将消息的拷贝分别发送给这所有的 N 个队列。扇型用来交换机处理消息的广播路由。 因为扇型交换机投递信息的

    2024年02月14日
    浏览(48)
  • 【学习日记2023.6.19】 之 RabbitMQ服务异步通信_消息可靠性_死信交换机_惰性队列_MQ集群

    【学习日记2023.6.19】 之 RabbitMQ服务异步通信_消息可靠性_死信交换机_惰性队列_MQ集群

    消息队列在使用过程中，面临着很多实际问题需要思考： 消息从发送，到消费者接收，会经历多个过程： 其中的每一步都可能导致消息丢失，常见的丢失原因包括： 发送时丢失： 生产者发送的消息未送达exchange 消息到达exchange后未到达queue MQ宕机，queue将消息丢失 consumer接收

    2024年02月11日
    浏览(54)
  • RabbitMQ交换机(1)

    RabbitMQ交换机(1)

    RabbitMQ消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列 。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。 相反，生产者只能将消息发送到交换机(exchange)， 交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将

    2024年01月17日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包