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

news2024/11/15 15:34:05

【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 # 你的虚拟机IP
    port: 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 {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public 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 {

    @Bean
    public 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 {

    @Bean
    public DirectExchange directExchange() {
        return ExchangeBuilder.directExchange("direct.exchange").durable(true).build();
    }

    @Bean
    public FanoutExchange fanoutExchange() {
        return ExchangeBuilder.fanoutExchange("fanout.exchange").durable(true).build();
    }

    @Bean
    public 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类型交换机
     */
    @Bean
    public FanoutExchange fanoutExchange(){
        return new FanoutExchange("demo.fanout");
    }

    /**
     * 第1个队列
     */
    @Bean
    public Queue fanoutQueue1(){
        return new Queue("fanout.queue1");
    }

    /**
     * 绑定队列和交换机
     */
    @Bean
    public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
        return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
    }

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

    /**
     * 绑定队列和交换机
     */
    @Bean
    public 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类型交换机
     */
    @Bean
    public DirectExchange directExchange(){
        return ExchangeBuilder.directExchange("direct.exchange").build();
    }

    /**
     * 第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");
    }
}
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类中声明队列：

    @Bean
    public 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.coloradmin.cn/o/1808123.html

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

相关文章

特种设备起重机指挥题库附答案

特种设备起重机指挥题库附答案

1、【多选题】力的三要素是指:( )。(ACD) A、力的大小 B、力的单位 C、力的方向 D、力的作用点 2、【多选题】司索作业规范正确的要求是( )(ABC) A、吊点正确 B、吊索挂设合理 C、绑扎牢靠 D、吊索长短一致 3、【多选题】圆柱形物体兜吊时&#xff0c;一定要放空圈&#…
阅读更多...
LearnDash+BuddyBoss：终极在线课程社区组合

LearnDash+BuddyBoss：终极在线课程社区组合

您是否希望使用 WordPress 建立在线课程社区&#xff1f; 如果是这样&#xff0c;没有比LearnDash和BuddyBoss在线课程社区更好的组合了。使用这两款产品&#xff0c;您可以创建和销售在线课程、创建群组和讨论&#xff0c;并为您的学生提供整个社交网络&#xff0c;所有这些都…
阅读更多...
用咖啡来理解springboot3的自动配置机制

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

大家好&#xff0c;这里是教授.F 目录 前提知识&#xff1a; 场景引入&#xff1a; 1.Starter依赖&#xff1a; 2.默认配置&#xff1a; 3.自定义配置&#xff1a; 4.条件化配置&#xff1a; 5.自动装配&#xff1a; 具体过程&#xff1a; 扫包路径的配置&#xff1a; 配置…
阅读更多...
JVisuaIVM监控Jstatd启动时报错

JVisuaIVM监控Jstatd启动时报错

一、 启动监控Jstatd报错 当我们在windows系统上面启动的时候好好的&#xff0c;在linux上面启动报错&#xff0c;提示报错如下&#xff0c;好像每一什么权限之类的 在tomcat下面查看你的项目使用的java版本&#xff0c;vi /usr/local/tomcat7-8083/bin/catalina.sh 查看我的…
阅读更多...
shell编程（三）—— 运算符

shell编程（三）—— 运算符

和其他编程语言一样&#xff0c;bash也有多种类型的运算符&#xff0c;本篇对bash的相关运算符做简单介绍。 一、运算符 1.1 算术运算符 常见的算术运算符&#xff0c;如加&#xff08;&#xff09;、减&#xff08;-&#xff09;、乘&#xff08;*&#xff09;、除&#xf…
阅读更多...
使用Leaflet-canvas-label进行个性化标注实践详解

使用Leaflet-canvas-label进行个性化标注实践详解

目录 前言 一、leaflet-canvas-label属性 1、地图展示属性 2、Canvas文本标注属性 3、事件列表 二、属性设置实战 1、标注放大比例 2、字体颜色和方向偏移 3、标注文字透明色设置 4、标注显示层级 三、事件绑定 1、颜色改变 2、事件绑定解析 3、标记初始化的一个小…
阅读更多...
html5实现个人网站源码

html5实现个人网站源码

文章目录 1.设计来源1.1 网站首页页面1.2 个人工具页面1.3 个人日志页面1.4 个人相册页面1.5 给我留言页面 2.效果和源码2.1 动态效果2.2 目录结构 源码下载 作者&#xff1a;xcLeigh 文章地址&#xff1a;https://blog.csdn.net/weixin_43151418/article/details/139564407 ht…
阅读更多...
427. 建立四叉树

427. 建立四叉树

427. 建立四叉树 题目难度-中等1. dfs分治 题目难度-中等 给你一个 n * n 矩阵 grid &#xff0c;矩阵由若干 0 和 1 组成。请你用四叉树表示该矩阵 grid 。 你需要返回能表示矩阵 grid 的 四叉树 的根结点。 四叉树数据结构中&#xff0c;每个内部节点只有四个子节点。此外…
阅读更多...
音程与和弦 音程协和度

音程与和弦 音程协和度

2个音符之间的音程计算 1234567&#xff0c;1到7的音程是7度&#xff0c;音程是计算总长度&#xff0c;看音级的个数。 Cubase中的音程计算 下面一个是4度&#xff0c;一个是3度&#xff0c;格子中深色的行就是黑键行。 根据半音数量来确定对应音程的专业术语叫法 旋律音程、…
阅读更多...
国产嵌入式仪器模块:电子负载模块及自动化测试软件

国产嵌入式仪器模块:电子负载模块及自动化测试软件

• 输入电流在 0–5 A 范围内线性可调 • 最大功率达 150 W&#xff0c;满足多种定制化应用场景 • 支持 CC/CR/CV 多种工作模式 • 支持多种辅助模块&#xff08;如 PD 控制、信号调制、二维码扫描&#xff09; 应用场景 • 负载能力测试&#xff08;电源或信号&#xff0…
阅读更多...
opencv--使用opencv实现旋转角度的模板匹配

opencv--使用opencv实现旋转角度的模板匹配

下面的例子是简单的使用opencv 实现的模板匹配流程&#xff0c;其中时间性能和精确度还需要调整&#xff0c;如果直接使用会出问题&#xff0c;所以这个只是例子&#xff0c;根据代码原理可以实现尺度变化的模板匹配和旋转尺度变化同时&#xff0c;具体根据实现的旋转代码进一步…
阅读更多...
【Unity学习笔记】反射

【Unity学习笔记】反射

文章目录 前言反射通过反射获取类型 Unity中的反射用反射在Unity中动态加载 前言 在我平时做项目的时候&#xff0c;由于我们做的项目都是很简单的&#xff0c;所以不怎么接触反射机制。最早了解反射机制是关于Invoke的时候&#xff0c;知道可以通过方法名来直接进行Invoke调用…
阅读更多...
【会议征稿，IEEE出版】第三届能源与电力系统国际学术会议 (ICEEPS 2024，7月14-16)

【会议征稿，IEEE出版】第三届能源与电力系统国际学术会议 (ICEEPS 2024，7月14-16)

如今&#xff0c;全球能源行业正面临着前所未有的挑战。一方面&#xff0c;加快向清洁、可再生能源转型是遏制能源环境污染问题的最佳途径之一&#xff1b;另一方面&#xff0c;电力系统中新能源发电、人工智能技术、电力电子装备等被广泛应用和期待&#xff0c;以提高能源可持…
阅读更多...
汇编：结构体

汇编：结构体

在32位汇编中&#xff0c;结构体&#xff08;structures&#xff09;用于组织和管理复杂的数据类型&#xff0c;结构体可以包含多个不同类型的数据项&#xff08;成员&#xff09;&#xff1b;在MASM&#xff08;Microsoft Macro Assembler&#xff09;中&#xff0c;使用结构体…
阅读更多...
Qt——升级系列（Level Four）：控件概述、QWidget 核心属性、按钮类控件

Qt——升级系列（Level Four）：控件概述、QWidget 核心属性、按钮类控件

目录 控件概述 QWidget 核心属性 核心属性概览 enabled geometry windowTitle windowIcon windowOpacity cursor font toolTip focusPolicy styleSheet 按钮类控件 Push Button Radio Buttion Check Box Tool Button 控件概述 Widget 是 Qt 中的核⼼概念. 英⽂原义是 "…
阅读更多...
10.结构体、共用体、枚举

10.结构体、共用体、枚举

头文件&#xff1a;#include<string.h> //struct&#xff1a;结构体关键字 //stu&#xff1a;结构体类型名&#xff0c;指定了一个结构体类型&#xff0c;它相当于一个模型&#xff0c;但其中并无具体数据&#xff0c;系统对之也不分配实际内存单元//使用结构体类型必须是…
阅读更多...
CDR2024软件破解Keygen激活工具2024最新版

CDR2024软件破解Keygen激活工具2024最新版

CorelDRAW Graphics Suite2024最新版&#xff0c;这是一款让我爱不释手的图形设计神器&#xff01;作为一个软件评测专家&#xff0c;我一直在寻找一款能够提升我的设计效率和创造力的工具。而这款软件&#xff0c;简直就是为我量身定制的&#xff01;&#x1f389; 「CorelDR…
阅读更多...
北航第五次数据结构与程序设计编程题复习

北航第五次数据结构与程序设计编程题复习

北航第五次数据结构与程序设计编程题复习 树叶节点遍历&#xff08;树-基础题&#xff09;计算器&#xff08;表达式计算-表达式树实现&#xff09;服务优化词频统计&#xff08;树实现&#xff09; 树叶节点遍历&#xff08;树-基础题&#xff09; 【问题描述】 从标准输入中…
阅读更多...
OpenCV学习(4.9) OpenCV中的轮廓

OpenCV学习(4.9) OpenCV中的轮廓

1.目标 了解轮廓是什么。学习寻找轮廓&#xff0c;绘制轮廓等您将看到以下功能&#xff1a;**cv.findContours()** &#xff0c;**cv.drawContours()* 2.什么是轮廓 轮廓可以简单地解释为连接具有相同颜色或强度的所有连续点(沿边界)的曲线。轮廓是用于形状分析以及对象检测…
阅读更多...
嵌入式学习——Linux高级编程复习（互斥锁、信号量、管道、信号）——day41

嵌入式学习——Linux高级编程复习（互斥锁、信号量、管道、信号）——day41

1. 同步和异步 1.1 同步 多个任务在某一时刻,先后执行顺序可以被确定 同步操作要求一系列操作严格按照顺序执行&#xff0c;一个操作只有在前一个操作完成之后才能开始。在计算机编程中&#xff0c;这意味着当一个程序或线程发出一个请求或调用后&#xff0c;它会暂停执行&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023