【RabbitMQ】RabbitMQ配置与交换机学习

【RabbitMQ】RabbitMQ配置与交换机学习

文章目录

  • 【RabbitMQ】RabbitMQ配置与交换机学习
    • 简介
    • 安装和部署
        • 1. 安装RabbitMQ
        • 2.创建virtual-host
        • 3. 添加依赖
        • 4.修改配置文件
    • WorkQueues模型
        • 1.编写消息发送测试类
        • 2.编写消息接收（监听）类
        • 3. 实现能者多劳
    • 交换机
      • Fanout交换机
        • 1.消息发送
        • 2.消息监听
      • Direct交换机
        • 1.消息发送
        • 2.消息接收
      • Topic交换机
        • 1.消息发送
        • 2.消息接收
    • 声明队列和交换机
        • 声明队列
        • 声明交换机
        • 绑定队列和交换机
          • 1.fanout示例
          • 2. direct示例
          • 3.基于注解的方式声明队列和交换机
        • 消息转换器
    • 总结

简介

RabbitMQ是一个开源的消息代理软件，它实现了高级消息队列协议（AMQP）。RabbitMQ支持多种消息传递协议，具有高可靠性、高可用性和高性能等特点。它允许应用程序通过消息队列进行异步通信，从而实现解耦和负载均衡。RabbitMQ的核心概念包括交换机（Exchange）、队列（Queue）和绑定（Binding），它们共同构成了消息的路由和传递机制。

RabbitMQ的架构如图：

47ab6076-c1b1-45e1-b8c4-f6c41a601b21

其中包含几个概念：

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

安装和部署

这里以Centos7为例：

1. 安装RabbitMQ
docker run \-e RABBITMQ_DEFAULT_USER=shijun \-e RABBITMQ_DEFAULT_PASS=123321 \-v mq-plugins:/plugins \--name mq \--hostname mq \-p 15672:15672 \-p 5672:5672 \--network hm-net\-d \rabbitmq:3.8-management

  1. -e RABBITMQ_DEFAULT_USER=shijun

    -e参数用于设置环境变量。这行代码用来设置RabbitMQ的默认用户名为shijun。

  2. -e RABBITMQ_DEFAULT_PASS=123321

    这行代码用来设置默认密码为123321。

  3. -p 15672:15672

    这行代码用来将宿主机的15672端口映射到容器的15672端口，15672端口是RabbitMQ管理控制台的默认端口。

  4. -p 5672:5672

    这行代码用来将宿主机的5672端口映射到容器的5672端口，5672端口是RabbitMQ的默认通信端口。

  5. --network hm-net

    这行代码将容器连接到名为hm-net的网络。

  6. -d

    -d参数表示以后台模式运行容器。

  7. rabbitmq:3.8-management

    这里是我们要运行的rabbitmq的Docker镜像，这里选择的是RabbitMQ 3.8版本，版本需要根据自己的SpringCloud版本来选择。

安装完成后访问：http://虚拟机IP地址:15672

输入刚才的账号密码：shijun 123321，就能进入控制台界面。

image-20240608222043550

2.创建virtual-host

由于RabbitMQ 每秒并发能力为几万，一般项目都不会达到这个规模，因此我们可以让多个项目使用同一个RabbitMQ 。要实现项目直接的隔离需要创建virtual-host，每个项目对应一个virtual-host。

按顺序点击，填入“Name”和“Descrption”，然后点击“Add virtual host”按钮：

image-20240609151722019

然后在右上角切换到创建的virtual-host：

image-20240609152323104

3. 添加依赖
        <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency><!--AMQP依赖，包含RabbitMQ--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-amqp</artifactId></dependency><!--单元测试--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency>
4.修改配置文件
logging:pattern:dateformat: MM-dd HH:mm:ss:SSS
spring:rabbitmq:host: 192.168.56.101 # 你的虚拟机IPport: 5672 # 端口virtual-host: /mq-demo # 虚拟主机username: shijun # 用户名password: 123321 # 密码

WorkQueues模型

Work queues，任务模型。简单来说就是让多个消费者绑定到一个队列，共同消费队列中的消息。

当消息处理比较耗时的时候，可能生产消息的速度会远远大于消息的消费速度。长此以往，消息就会堆积越来越多，无法及时处理。

此时就可以使用work 模型，多个消费者共同处理消息处理，消息处理的速度就能大大提高了。

image-20240609154853698

在控制台创建一个work.queue队列：

image-20240609155329959

1.编写消息发送测试类
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class SpringAmqpTest {@Autowiredprivate RabbitTemplate rabbitTemplate;@Testpublic void testWorkQueue() throws InterruptedException {// 队列名称String queueName = "work.queue";// 消息String message = "hello, message_";for (int i = 0; i < 50; i++) {// 发送消息，每20毫秒发送一次，相当于每秒发送50条消息rabbitTemplate.convertAndSend(queueName, message + i);Thread.sleep(20);}}
}
  • RabbitTemplate：Spring AMQP提供的模板类，用于发送和接收消息。
  • rabbitTemplate.convertAndSend(queueName, message + i);：使用RabbitTemplate发送消息到指定的队列。
2.编写消息接收（监听）类
@Component
public class SpringRabbitListener {/*** 监听名为"work.queue"的RabbitMQ队列，接收并处理来自队列的消息。* 通过延迟执行模拟消息处理时间* * @param msg 从队列中接收到的消息内容，以字符串形式提供* @throws InterruptedException 如果线程在睡眠期间被中断，则抛出此异常*/@RabbitListener(queues = "work.queue")public void listenWorkQueue1(String msg) throws InterruptedException {// 输出接收到消息的时间，以便跟踪消息处理的时间点System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());// 模拟消息处理时间，让线程睡眠20毫秒Thread.sleep(20);}@RabbitListener(queues = "work.queue")public void listenWorkQueue2(String msg) throws InterruptedException {System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());Thread.sleep(200);}
}
  • @RabbitListener：此注解用来设置该方法应该作为RabbitMQ消息队列的监听器。这意味着当队列中有消息发布时，Spring框架会自动调用此方法来处理这些消息。
  • queues = "work.queue"：指定要监听的RabbitMQ队列的名称，在这个例子中是work.queue。
  • 注意到这两消费者，都设置了Thead.sleep，模拟任务耗时：
    • 消费者1 sleep了20毫秒，相当于每秒钟处理50个消息
    • 消费者2 sleep了200毫秒，相当于每秒处理5个消息

运行后查看结果：

image-20240609163135799

观察可以发现：

  1. 一个消息只会被一个消费者处理
  2. 当有很多消息时，会平均分配（一个消费者负责奇数的消息，一个消费者负责偶数的消息）

但问题是消费者之间的消费能力可能不一样，有的消费能力强，有消费的弱，会出现部分消费者一直空闲而其他消费者一直繁忙的状况，没有充分利用每一个消费者的能力

3. 实现能者多劳

修改配置文件：

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

再次运行，查看结果：

image-20240609164615309

观察可以发现：

消费者2处理了大概5条消息，而消费者1处理了40多条消息，成功实现"能者多劳"。

交换机

在之前的RabbitMQ的架构图中我们可以看到，里面还有一项Exchange没有提到，那就是RabbitMQ中的交换机。

交换机是RabbitMQ中用于接收生产者发送的消息并将这些消息路由到一个或多个队列的组件。

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

交换机有不同的类型，常见的有以下几种：

  • Fanout Exchange（扇出交换机）：将消息广播到所有绑定的队列，不考虑路由键。
  • Direct Exchange（直连交换机）：根据消息的路由键精确匹配队列。
  • Topic Exchange（主题交换机）：根据路由键的模式匹配队列。
  • Headers Exchange（头交换机）：根据消息的头部信息匹配队列。

Fanout交换机

扇出交换机将消息广播到所有绑定的队列，而不考虑路由键。这种交换机非常适合需要将消息广播到多个消费者的场景。

假如说当订单服务有了一笔新订单之后就要去通知短信服务、商品服务等等，有了交换机之后就只需要将消息发给交换机，然后为每一个微服务创建一个队列并绑定，之后当有消息时，交换机就会把消息发送到所有队列，就能实现一个消息被多个消费者处理了。

image-20240610112130389

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

  1. 创建Fanout交换机

    image-20240609170548383

  2. 创建两个队列fanout.queue1、fanout.queue2：

    image-20240609170655932

  3. 点击刚刚创建的交换机，进入：

    image-20240609170907536

  4. 将刚才创建的两个队列绑定到交换机，

image-20240609171002978
1.消息发送

在SpringAmqpTest类中添加测试方法：

@Test
public void testFanoutExchange() {// 交换机名称String exchangeName = "demo.fanout";// 消息String message = "hello, everyone!";rabbitTemplate.convertAndSend(exchangeName, "", message);
}

abbitTemplate.convertAndSend(exchangeName, "", message);中的第二个参数用来指定路由键。对于Fanout交换机，路由键没有实际意义，因此可以传递一个空字符串。

2.消息监听

在SpringRabbitListener中添加两个方法：

@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {System.out.println("消费者1接收到Fanout消息：【" + msg + "】");
}@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {System.out.println("消费者2接收到Fanout消息：【" + msg + "】");
}

运行代码，查看结果：

image-20240609173012677

交换机的作用是什么？

  • 接收publisher发送的消息
  • 将消息按照规则路由到与之绑定的队列
  • 不能缓存消息，路由失败，消息丢失
  • FanoutExchange的会将消息路由到每个绑定的队列

Direct交换机

在Fanout模式中，一条消息，会被所有订阅的队列都消费。但是，在某些场景下，我们希望不同的消息被不同的队列消费。这时就要用到Direct类型的Exchange。

直连交换机根据消息的路由键精确匹配队列。只有当消息的路由键与绑定的路由键完全匹配时，消息才会被路由到相应的队列。

image-20240610112328443

在Direct模型下：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

  1. 创建direct.queue1和direct.queue2两个队列，之后创建一个direct类型的交换机：

    image-20240609174620595

  2. 绑定队列到交换机，最终结果如图所示：

    image-20240609184743239

1.消息发送

在SpringAmqpTest类中添加测试方法：

@Test
public void testSendDirectExchange1() {// 交换机名称String exchangeName = "demo.direct";// 消息String message = "红色警报！日本乱排核废水，导致海洋生物变异，惊现哥斯拉！";// 发送消息rabbitTemplate.convertAndSend(exchangeName, "red", message);
}@Test
public void testSendDirectExchange2() {// 交换机名称String exchangeName = "demo.direct";// 消息String message = "最新报道，哥斯拉是居民自治巨型气球，虚惊一场！";// 发送消息rabbitTemplate.convertAndSend(exchangeName, "blue", message);
}
2.消息接收

在SpringRabbitListener中添加方法：

@RabbitListener(queues = "direct.queue1")
public void listenDirectQueue1(String msg) {System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");
}@RabbitListener(queues = "direct.queue2")
public void listenDirectQueue2(String msg) {System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");
}

运行测试类中的testSendDirectExchange1，查看结果：

image-20240609185400537

运行测试类中的testSendDirectExchange2，查看结果：

image-20240609185710182

观察可以发现：

  • 当发送的消息的Routing key为red时，两个消息队列都能收到

  • 当发送的消息的Routing key为red时，只有消息队列1才能收到

Topic交换机

Topic交换机（Topic Exchange）是RabbitMQ中一种功能强大的交换机类型，它通过路由键的模式匹配将消息路由到一个或多个队列。Topic交换机允许使用通配符来匹配路由键，从而实现灵活的消息路由。

  • 通配符

    ：在绑定键中，可以使用两个特殊字符来实现模式匹配：

    • *：匹配一个单词。
    • #：匹配零个或多个单词。
image-20240610112445760

如图所示，假如此时publisher发送的消息使用的RoutingKey共有四种：

  • china.news 代表有中国的新闻消息；
  • china.weather 代表中国的天气消息；
  • japan.news 则代表日本新闻
  • japan.weather 代表日本的天气消息；

解释：

  • topic.queue1：绑定的是china.# ，凡是以 china.开头的routing key 都会被匹配到，包括：
    • china.news
    • china.weather
  • topic.queue2：绑定的是#.news ，凡是以 .news结尾的 routing key 都会被匹配。包括:
    • china.news
    • japan.news

更多范例：

假设我们有以下绑定键：

  • *.orange.*
  • *.*.rabbit
  • lazy.#

我们可以通过以下路由键进行消息路由：

  • 路由键quick.orange.rabbit将匹配第一个和第二个绑定键。
  • 路由键lazy.orange.elephant将匹配第一个和第三个绑定键。
  • 路由键lazy.brown.fox将匹配第三个绑定键。
  • 路由键lazy将匹配第三个绑定键。

按照之前的流程创建Topic交换机和队列并进行绑定，最终结果如下：

1.消息发送

在SpringAmqpTest类中添加测试方法：

@Test
public void testSendTopicExchange1() {// 交换机名称String exchangeName = "demo.topic";// 消息String message = "喜报！孙悟空大战哥斯拉，胜!";// 发送消息rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}@Test
public void testSendTopicExchange1() {// 交换机名称String exchangeName = "demo.topic";// 消息String message = "喜报！孙悟空大战哥斯拉，胜!";// 发送消息rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
}
2.消息接收

在SpringRabbitListener中添加方法：

@RabbitListener(queues = "topic.queue1")
public void listenTopicQueue1(String msg){System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");
}@RabbitListener(queues = "topic.queue2")
public void listenTopicQueue2(String msg){System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");
}

运行测试类中的testSendTopicExchange1后观察结果：

image-20240609204043494

观察发现两个消息队列都收到了，说明china.# 和#.news都匹配成功了。

运行测试类中的testSendTopicExchange2后观察结果：

image-20240609204427086

观察可以发现只有消息队列1匹配成功，说明china.#匹配成功。

声明队列和交换机

之前我们创建交换机是通过控制台创建的，然而实际开发中是不推荐使用这种方式，因为可能会出现一些问题，更推荐让程序员通过代码来判断交换机和队列是否存在，如果没有再进行创建。

在实际开发中，RabbitMQ的配置类一般放到消费者包下，生产者一般会关心消息是否发送成功。

声明队列

队列是RabbitMQ中用于存储消息的组件。Spring AMQP通过Queue类来声明队列。队列有以下几个重要属性：

  • name：队列名称。
  • durable：是否持久化。持久化队列在RabbitMQ重启后仍然存在，信息持久到磁盘。
  • exclusive：是否排他。排他队列只能被创建它的连接使用，并且在连接断开时自动删除。
  • autoDelete：是否自动删除。当最后一个消费者断开连接后，自动删除队列。

比如：

import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class RabbitMQQueueConfig {@Beanpublic Queue myQueue() {return new Queue("simple.queue");}
}

声明了一个名为simple.queue的队列，默认为持久化、非排他、非自动删除。

image-20240610095936480
声明交换机

使用ExchangeBuilder声明交换机，ExchangeBuilder类提供了多种方法来配置交换机的属性。以下是一些常用的方法：

  • durable()：声明持久化交换机。
  • autoDelete()：声明自动删除交换机。
  • withArgument()：添加交换机的自定义参数。
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.amqp.core.HeadersExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class RabbitMQExchangeConfig {@Beanpublic DirectExchange directExchange() {return ExchangeBuilder.directExchange("direct.exchange").durable(true).build();}@Beanpublic FanoutExchange fanoutExchange() {return ExchangeBuilder.fanoutExchange("fanout.exchange").durable(true).build();}@Beanpublic TopicExchange topicExchange() {return ExchangeBuilder.topicExchange("topic.exchange").durable(true).build();}}
绑定队列和交换机

在RabbitMQ中，绑定关系（Binding）是交换机和队列之间的连接。绑定关系告诉交换机如何将消息路由到队列。在Spring AMQP中，我们可以使用BindingBuilder类来声明和配置绑定关系。

BindingBuilder类提供了一些静态方法来创建绑定关系。常用的方法包括：

  • bind()：绑定队列到交换机。
  • to()：指定交换机。
  • with()：指定路由键（用于直连交换机和主题交换机）。
  • where()：指定头部信息（用于头交换机）。
1.fanout示例
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;@Configuration
public class FanoutConfig {/*** 声明交换机* @return Fanout类型交换机*/@Beanpublic FanoutExchange fanoutExchange(){return new FanoutExchange("demo.fanout");}/*** 第1个队列*/@Beanpublic Queue fanoutQueue1(){return new Queue("fanout.queue1");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);}/*** 第2个队列*/@Beanpublic Queue fanoutQueue2(){return new Queue("fanout.queue2");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);}
}

在控制台删除demo.fanout交换机和fanout.queue2 、fanout.queue2这两个队列，再次运行代码会发现删除的又重新出现了：

image-20240610102527887
2. direct示例

direct交换机

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;@Configuration
public class DirectConfig {/*** 声明交换机* @return Direct类型交换机*/@Beanpublic DirectExchange directExchange(){return ExchangeBuilder.directExchange("direct.exchange").build();}/*** 第1个队列*/@Beanpublic Queue directQueue1(){return new Queue("direct.queue1");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange){return BindingBuilder.bind(directQueue1).to(directExchange).with("red");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange){return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");}/*** 第2个队列*/@Beanpublic Queue directQueue2(){return new Queue("direct.queue2");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange){return BindingBuilder.bind(directQueue2).to(directExchange).with("red");}/*** 绑定队列和交换机*/@Beanpublic Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange){return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");}
}
3.基于注解的方式声明队列和交换机

基于@Bean的方式声明队列和交换机比较麻烦，Spring还提供了基于注解方式来声明。

修改SpringRabbitListener类：


@Component
public class SpringRabbitListener {// .......@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue1"),exchange = @Exchange(name = "demo.direct", type = ExchangeTypes.DIRECT),key = {"red", "blue"}))public void listenDirectQueue1(String msg){System.out.println("消费者1接收到direct.queue1的消息：【" + msg + "】");}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "direct.queue2"),exchange = @Exchange(name = "demo.direct", type = ExchangeTypes.DIRECT),key = {"red", "yellow"}))public void listenDirectQueue2(String msg){System.out.println("消费者2接收到direct.queue2的消息：【" + msg + "】");}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue1"),exchange = @Exchange(name = "demo.topic", type = ExchangeTypes.TOPIC),key = "china.#"))public void listenTopicQueue1(String msg){System.out.println("消费者1接收到topic.queue1的消息：【" + msg + "】");}@RabbitListener(bindings = @QueueBinding(value = @Queue(name = "topic.queue2"),exchange = @Exchange(name = "demo.topic", type = ExchangeTypes.TOPIC),key = "#.news"))public void listenTopicQueue2(String msg){System.out.println("消费者2接收到topic.queue2的消息：【" + msg + "】");}// .......}

@QueueBinding注解包含以下几个主要部分：

  1. value：定义队列，使用@Queue注解。
  2. exchange：定义交换机，使用@Exchange注解。
  3. key：定义路由键，使用字符串数组。

删除交换机和队列后再次运行会发现又重新出现：

image-20240610105323455
消息转换器

Spring的消息发送代码接收的消息体是一个Object：

image-20240610105507926

在数据传输时，它会把你发送的消息序列化为字节发送给MQ，接收消息的时候，还会把字节反序列化为Java对象。

只不过，默认情况下Spring采用的序列化方式是JDK序列化。众所周知，JDK序列化存在下列问题：

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

因此我们可以配置JSON转换器来解决这个问题。

  1. 引入Jackson依赖：
        <dependency><groupId>com.fasterxml.jackson.dataformat</groupId><artifactId>jackson-dataformat-xml</artifactId></dependency>

  1. 配置消息转换器

    在publisher和consumer两个服务的启动类中添加一个Bean即可：

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

测试：

在FanoutConfig类中声明队列：

    @Beanpublic Queue objectQueue() {return new Queue("object.queue");}

在SpringAmqpTest类中添加：

@Test
public void testSendMap() throws InterruptedException {// 准备消息Map<String,Object> msg = new HashMap<>();msg.put("name", "柳岩");msg.put("age", 21);// 发送消息rabbitTemplate.convertAndSend("object.queue", msg);
}

在SpringRabbitListener类中添加：

@RabbitListener(queues = "object.queue")
public void listenSimpleQueueMessage(Map<String, Object> msg) throws InterruptedException {System.out.println("消费者接收到object.queue消息：【" + msg + "】");
}

运行测试类查看结果：

image-20240610110529216

总结

本文较为详细的记录了RabbitMQ的安装配置以及交换机学习，希望本文对大家学习RabbitMQ有所帮助。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/851010.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

C++类与对象（拷贝与类的内存管理）

C++类与对象（拷贝与类的内存管理）

感谢大佬的光临各位&#xff0c;希望和大家一起进步&#xff0c;望得到你的三连&#xff0c;互三支持&#xff0c;一起进步 个人主页&#xff1a;LaNzikinh-CSDN博客 文章目录 前言一.对象的动态建立和释放二.多个对象的构造和析构三.深拷贝与浅拷贝四.C类的内存管理总结 前言 …
阅读更多...
element-plus日历组件el-calendar自定义内容，每天绑定不同的值

element-plus日历组件el-calendar自定义内容，每天绑定不同的值

效果 代码 <template><el-calendar v-model"calendarDate"><template #date-cell"{ data }"><p :class"data.isSelected ? is-selected : ">{{ data.day.split("-").slice(1).join("-") }}{{ d…
阅读更多...
IDEA创建SpringBoot项目的时候，如何使用Java8，怎么办？

IDEA创建SpringBoot项目的时候，如何使用Java8，怎么办？

在创建springboot项目的时候,IDEA提示&#xff0c;最低Java版本要求17&#xff0c;但是实际上我们可能不需要这么高的版本&#xff0c;怎么使用Java8呢&#xff1f; 解决办法 修改Server URL地址即可&#xff1a;https://start.aliyun.com
阅读更多...
天才程序员周弈帆 | Stable Diffusion 解读（二）：论文精读

天才程序员周弈帆 | Stable Diffusion 解读（二）：论文精读

本文来源公众号“天才程序员周弈帆”&#xff0c;仅用于学术分享&#xff0c;侵权删&#xff0c;干货满满。 原文链接&#xff1a;Stable Diffusion 解读&#xff08;二&#xff09;&#xff1a;论文精读 【小小题外话】端午安康&#xff01; 在上一篇文章天才程序员周弈帆 …
阅读更多...
【数据结构】排序（上）

【数据结构】排序（上）

个人主页~ 堆排序看这篇~ 还有这篇~ 排序 一、排序的概念及应用1、概念2、常见的排序算法 二、常见排序的实现1、直接插入排序&#xff08;1&#xff09;基本思想&#xff08;2&#xff09;代码实现&#xff08;3&#xff09;时间复杂度&#xff08;4&#xff09;空间复杂度 2…
阅读更多...
【设计模式】创建型设计模式之 工厂模式

【设计模式】创建型设计模式之 工厂模式

一、介绍 工厂模式可以分为 3 个小类 简单工厂模式工厂方法模式抽象工厂模式 工厂模式的工厂类&#xff0c;并不一定以 Factory 结尾&#xff0c;例如 DataFormat、Calender 他们都是工厂类&#xff0c;通过静态方法来创建实例。 除此之外&#xff0c;创建对象的方法名称一…
阅读更多...
VBA即用型代码手册：删除重复行Delete Duplicate Rows

VBA即用型代码手册：删除重复行Delete Duplicate Rows

我给VBA下的定义&#xff1a;VBA是个人小型自动化处理的有效工具。可以大大提高自己的劳动效率&#xff0c;而且可以提高数据的准确性。我这里专注VBA,将我多年的经验汇集在VBA系列九套教程中。 作为我的学员要利用我的积木编程思想&#xff0c;积木编程最重要的是积木如何搭建…
阅读更多...
streamlit：如何快速构建一个应用，不会前端也能写出好看的界面

streamlit：如何快速构建一个应用，不会前端也能写出好看的界面

通过本文你可以了解到&#xff1a; 如何安装streamlit&#xff0c;运行起来第一个demo熟悉streamlit的基本语法&#xff0c;常用的一些组件使用streamlit库构建应用 大模型学习参考&#xff1a; 大模型学习资料整理&#xff1a;如何从0到1学习大模型&#xff0c;搭建个人或企业…
阅读更多...
（二）深度学习基础练习题（54道选择题）

（二）深度学习基础练习题（54道选择题）

本文整理了深度学习基础知识相关的练习题&#xff0c;共54道&#xff0c;适用于想巩固深度学习基础的同学。来源&#xff1a;如荷学数据科学题库&#xff08;技术专项-深度学习&#xff09;。 1&#xff09; 2&#xff09; 3&#xff09; 4&#xff09; 5&#xff09; 6&#…
阅读更多...
音程与和弦 音程协和度

音程与和弦 音程协和度

2个音符之间的音程计算 1234567&#xff0c;1到7的音程是7度&#xff0c;音程是计算总长度&#xff0c;看音级的个数。 Cubase中的音程计算 下面一个是4度&#xff0c;一个是3度&#xff0c;格子中深色的行就是黑键行。 根据半音数量来确定对应音程的专业术语叫法 旋律音程、…
阅读更多...
用咖啡来理解springboot3的自动配置机制

用咖啡来理解springboot3的自动配置机制

大家好&#xff0c;这里是教授.F 目录 前提知识&#xff1a; 场景引入&#xff1a; 1.Starter依赖&#xff1a; 2.默认配置&#xff1a; 3.自定义配置&#xff1a; 4.条件化配置&#xff1a; 5.自动装配&#xff1a; 具体过程&#xff1a; 扫包路径的配置&#xff1a; 配置…
阅读更多...
解锁ChatGPT：从GPT-2实践入手解密ChatGPT

解锁ChatGPT：从GPT-2实践入手解密ChatGPT

⭐️我叫忆_恒心&#xff0c;一名喜欢书写博客的研究生&#x1f468;‍&#x1f393;。 如果觉得本文能帮到您&#xff0c;麻烦点个赞&#x1f44d;呗&#xff01; 近期会不断在专栏里进行更新讲解博客~~~ 有什么问题的小伙伴 欢迎留言提问欧&#xff0c;喜欢的小伙伴给个三连支…
阅读更多...
【深度学习】—— 神经网络介绍

【深度学习】—— 神经网络介绍

神经网络介绍 本系列主要是吴恩达深度学习系列视频的笔记&#xff0c;传送门&#xff1a;https://www.coursera.org/deeplearning-ai 目录 神经网络介绍神经网络的应用深度学习兴起的原因 神经网络&#xff0c;全称人工神经网络&#xff08;Artificial Neural Network&#xf…
阅读更多...
私有化AI搜索引擎FreeAskInternet

私有化AI搜索引擎FreeAskInternet

什么是 FreeAskInternet FreeAskInternet 是一个完全免费、私有且本地运行的搜索聚合器&#xff0c;并使用 LLM 生成答案&#xff0c;无需 GPU。用户可以提出问题&#xff0c;系统将使用 searxng 进行多引擎搜索&#xff0c;并将搜索结果合并到ChatGPT3.5 LLM 中&#xff0c;并…
阅读更多...
Python私教张大鹏 Vue3整合AntDesignVue之Breadcrumb 面包屑

Python私教张大鹏 Vue3整合AntDesignVue之Breadcrumb 面包屑

显示当前页面在系统层级结构中的位置&#xff0c;并能向上返回。 何时使用 当系统拥有超过两级以上的层级结构时&#xff1b; 当需要告知用户『你在哪里』时&#xff1b; 当需要向上导航的功能时。 案例&#xff1a;面包屑导航基本使用 核心代码&#xff1a; <template…
阅读更多...
【Linux文件篇】系统文件、文件描述符与重定向的实用指南

【Linux文件篇】系统文件、文件描述符与重定向的实用指南

W...Y的主页 &#x1f60a; 代码仓库分享&#x1f495; 前言&#xff1a;相信大家对文件都不会太陌生、也不会太熟悉。在没有学习Linux操作系统时&#xff0c;我们在学习C或C时都学过如何去创建、打开、读写等待文件的操作&#xff0c;知道一些语言级别的一些接口与函数。但…
阅读更多...
冯喜运：6.10周一黄金原油行情趋势分析及独家操作建议

冯喜运：6.10周一黄金原油行情趋势分析及独家操作建议

【黄金消息面分析】&#xff1a;上周全球金融市场惊现戏剧性大逆转&#xff0c;美国多项经济数据证实劳动力市场降温&#xff0c;9月降息重返视野令全球风险情绪几乎陷入狂热状态&#xff0c;全球股市接连创新高&#xff0c;但上周五意外“爆表”的非农令市场惊现大逆转&#x…
阅读更多...
基于pytorch_lightning测试resnet18不同激活方式在CIFAR10数据集上的精度

基于pytorch_lightning测试resnet18不同激活方式在CIFAR10数据集上的精度

基于pytorch_lightning测试resnet18不同激活方式在CIFAR10数据集上的精度 一.曲线1.train_acc2.val_acc3.train_loss4.lr 二.代码 本文介绍了如何基于pytorch_lightning测试resnet18不同激活方式在CIFAR10数据集上的精度 特别说明: 1.NoActive:没有任何激活函数 2.SparseActiva…
阅读更多...
调研管理系统的设计

调研管理系统的设计

管理员账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;管理员管理&#xff0c;基础数据管理&#xff0c;教师类型管理&#xff0c;课程类型管理&#xff0c;公告类型管理 前台账户功能包括&#xff1a;系统首页&#xff0c;个人中心&#xff0c;论坛&#…
阅读更多...
腾讯云和windows11安装frp，实现内网穿透

腾讯云和windows11安装frp，实现内网穿透

一、内网穿透目的 实现公网上&#xff0c;访问到windows上启动的web服务 二、内网穿透的环境准备 公网服务器、windows11的电脑、frp软件(需要准备两个软件&#xff0c;一个是安装到公网服务器上的&#xff0c;一个是安装到windows上的) frp下载地址下载版本 1.此版本(老版…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023