RabbitMQ 消息队列(Spring boot AMQP)

这篇具有很好参考价值的文章主要介绍了RabbitMQ 消息队列(Spring boot AMQP)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

🌸mq之间的对比


几种常见MQ的对比:

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

🌸RabbitMQ vs Apache Kafka


  • 消息模型:RabbitMQ 使用点对点和发布/订阅模型,而 Kafka 则是一个高吞吐量的分布式消息系统,适用于流处理、事件驱动和日志传输。
  • 可靠性:RabbitMQ 提供了丰富的可靠性机制,如消息确认和持久化。而 Kafka 通过数据复制和分区副本保障消息的持久性和容错性。
  • 延迟:RabbitMQ 在低延迟的场景下表现更好,适合需要实时处理的应用程序。Kafka 更适合大规模的实时数据流处理,但相对有较高的延迟。
  • 扩展性:Kafka 具备更好的水平扩展能力,可以轻松处理大量的并发连接和高吞吐量。
  • 使用场景:RabbitMQ 适用于传统的企业应用集成、任务调度等场景;Kafka 更适用于大规模的数据管道、日志聚合和实时流处理。

🌸RabbitMQ vs ActiveMQ


  • 协议支持:RabbitMQ 实现了 AMQP 协议,而 ActiveMQ 支持多种协议,包括 AMQP、STOMP、OpenWire 等。
  • 性能:RabbitMQ 在吞吐量方面表现更优,尤其在高并发和大规模消息交换的场景下。ActiveMQ 相对较慢,但对于中小型应用仍然具备足够的性能。
  • 可靠性:RabbitMQ 提供了丰富的可靠性机制,如消息确认和持久化。ActiveMQ 也提供了持久化、事务等机制来保证消息的可靠传递。
  • 功能和插件:RabbitMQ 提供了更多的功能和插件,例如消息优先级、RPC、延迟队列等。ActiveMQ 也有类似的功能,但相对较少一些。

🌸RabbitMQ vs RocketMQ


RabbitMQ和RocketMQ是两个流行的消息系统,用于构建分布式和可扩展的应用程序。虽然它们有相似的目标,但在它们之间存在几个区别,可以帮助您决定哪个更适合您特定的使用场景。

1. 开源性: RabbitMQ是用Erlang编写的开源消息代理,而RocketMQ也是由阿里巴巴集团开发的开源分布式消息系统,使用Java编写。这两个项目都有活跃的社区,并定期进行更新。

2. 语言支持: RabbitMQ为多种编程语言提供官方客户端库,包括Java、Python、Ruby、.NET等。另一方面,RocketMQ本地支持Java客户端,但也有由社区支持的其他语言(如Go、Python和C++)的客户端库。

3. 消息模式: RabbitMQ主要专注于支持AMQP(高级消息队列协议),并支持广泛的消息模式,如发布/订阅、请求/回复和工作队列。RocketMQ设计用于高吞吐量、低延迟的场景,并针对流式处理和事件驱动架构进行了优化。它支持发布/订阅、点对点和请求/回复消息模式。

4. 可扩展性和性能: RabbitMQ和RocketMQ都具有高度的可扩展性,但RocketMQ专门设计用于处理大量低延迟的消息。它通过消息批处理、消息压缩和分布式架构等功能实现这一点。如果您需要高性能的大规模消息传递,RocketMQ可能更合适。

5. 数据持久化: RabbitMQ默认将消息存储在磁盘上,即使代理重新启动也能确保持久性。相比之下,RocketMQ依靠预写日志和副本来实现容错和数据持久化。

6. 社区和生态系统: 作为一个流行的消息系统,RabbitMQ拥有成熟的社区和丰富的插件和集成生态系统。RocketMQ拥有不断增长的社区,并在中国市场上更常见,重点在于阿里巴巴的生态系统。

最终,在RabbitMQ和RocketMQ之间的选择取决于您的具体需求。如果您需要强大的语言支持、丰富的生态系统和灵活的消息模式,请选择RabbitMQ。另一方面,如果您优先考虑高吞吐量、低延迟和原生Java集成,请选择RocketMQ。

🌸RabbitMQ vs Redis


  • 数据类型:Redis 是一个内存数据库,具有键值存储、列表、集合等数据结构,同时也支持发布/订阅模式。RabbitMQ 则专注于消息队列的功能。
  • 消息传递模型:RabbitMQ 提供了丰富的消息传递模型,更适合复杂的消息路由和消费者管理。Redis 的发布/订阅模式更适合简单的发布和订阅场景。
  • 持久化:RabbitMQ 提供了可靠的消息持久化机制,适用于需要持久化的消息传递。Redis 也可以通过持久化机制来保留数据,但主要关注于内存数据库的性能。
  • 性能:Redis 是一个非常快速的内存数据库,适用于低延迟和高吞吐量的场景。RabbitMQ 的性能也很好,但相对 Redis 来说稍慢一些。

这些比较提供了一些关键区别,但选择合适的 MQ 解决方案还应基于具体的使用案例、需求和性能要求。每个解决方案都有其优势和适用场景,因此您可能需要根据自己的情况进行评估和选择。
在 Redis 中,订阅和发布是一种基于发布/订阅模式的消息传递机制。通过使用 Redis 提供的 PUBLISH 命令进行消息发布,以及使用 SUBSCRIBE 命令进行消息订阅,您可以实现简单而强大的消息传递功能。以下是 Redis 订阅和发布的详细步骤:

🌸linux docker 部署 rabbitmq

docker怎么拉镜像已经写过很多遍了,还是不清楚可以看之前的例子https://blog.csdn.net/qq_39017153/article/details/131976173?spm=1001.2014.3001.5501

🌸拉去镜像


docker pull rabbitmq

15672(UI页面通信口,浏览器界面)、5672(client端通信口,最常用到的)、25672(server间内部通信口)、61613(stomp 消息传输)、1883(MQTT消息队列遥测传输)

🌸创建挂载目录


mkdir -p /data/apps/rabbitmq/data
mkdir -p /data/apps/rabbitmq/conf
mkdir -p /data/apps/rabbitmq/log

还是一样给你创建文件授权 我这里怕麻烦直接给的最大

chmod -R 777 /data/apps/rabbitmq

🌸运行镜像


docker run \
-p 5672:5672 -p 15672:15672 \
--name rabbitmq \
--hostname my-rabbit \
-v /data/apps/rabbitmq/data:/var/lib/rabbitmq \
-v /data/apps/rabbitmq/conf:/etc/rabbitmq \
-v /data/apps/rabbitmq/log:/var/log/rabbitmq \
-e RABBITMQ_DEFAULT_USER=admin \
-e RABBITMQ_DEFAULT_PASS=admin \
-d rabbitmq:latest

🌸安装可视化界面插件 : 进入容器


docker exec -it rabbitmq bash

进入容器后执行安装插件命令 ,执行完成 访问 ip+15672 即可访问

rabbitmq-plugins enable rabbitmq_management

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

🌸Springboot AMQP RabbitMQ发送消息示例

SpringAMQP是基于RabbitMQ封装的一套模板,并且还利用SpringBoot对其实现了自动装配,使用起来非常方便。
SpringAmqp的官方地址:https://spring.io/projects/spring-amqp

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式
RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式
SpringAMQP提供了三个功能:

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

🌸Basic Queue 简单队列模型


下面是一个使用Spring Boot和RabbitMQ的基本示例:

首先,确保你已经在项目中引入了Spring Boot和RabbitMQ的依赖。

<!-- pom.xml -->
<dependencies>
    <!-- Spring Boot Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>

    <!-- RabbitMQ Starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-amqp</artifactId>
    </dependency>
</dependencies>

🌸消息发送

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

接下来,配置RabbitMQ连接和相关属性。

# application.yml
spring:
  rabbitmq:
    host: 192.168.xxx.xxx # 主机名
    port: 5672 # 端口
    virtual-host: / # 虚拟主机
    username: itcast # 用户名
    password: 123321 # 密码
   listener:
      simple:
        prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息 

创建发送消息的生产者。

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MessageProducer {
    private final RabbitTemplate rabbitTemplate;

    @Autowired
    public MessageProducer(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    public void sendMessage(String message) {
        rabbitTemplate.convertAndSend("my-queue", message);
    }
}

🌸消息接收


创建消息队列

@Configuration
public class FanoutConfig {
    // itcast.fanout
 @Bean
    public Queue fanoutQueue1(){
        return new Queue("my-queue");
    }
}

创建接收消息的消费者。

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

@Component
public class MessageConsumer {

    @RabbitListener(queues = "my-queue")
    public void receiveMessage(String message) {
        System.out.println("Received message: " + message);
    }
}

最后,在启动类上添加注解@EnableRabbit,以启用RabbitMQ相关功能。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableRabbit
public class RabbitMQDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(RabbitMQDemoApplication.class, args);
    }
}

通过以上示例,你已经完成了一个简单的Spring Boot和RabbitMQ集成的应用程序。当调用MessageProducersendMessage()方法时,消息将会发送到名为"my-queue"的队列中,并被MessageConsumerreceiveMessage()方法接收和处理。

🌸添加消息对象序列化


为需要重写序列化对象,因为默认使用的是JDK对象序列化,性能差,有安全漏洞,所以推荐使用JSON序列化

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
    @Bean
    public MessageConverter messageConverter(){
        return new Jackson2JsonMessageConverter();
    }

🌸使用对象发送消息


    @Test
    public void test() {
        String queueName = "object.queue";
        Map<String,Object> msg =new HashMap<>();
        msg.put("name","柳岩");
        msg.put("age","18");
        rabbitTemplate.convertAndSend(queueName,msg);
    }
  @RabbitListener(queues = "object.queue")
    public void listenObjectQueue(Map<String,Object> msg){
        System.out.println("接收到object.queue的消息:" + msg);
    }

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

到mq界面上可以看到我们的柳岩了

🌸 发布/订阅(Exchange交换机)


RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式
可以看到,在订阅模型中,多了一个exchange角色,而且过程略有变化:

  • Publisher:生产者,也就是要发送消息的程序,但是不再发送到队列中,而是发给X(交换机)
  • Exchange:交换机,图中的X。一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于Exchange的类型。Exchange有以下4种类型:
    • Fanout:广播,将消息交给所有绑定到交换机的队列

    • Direct:定向,把消息交给符合指定routing key 的队列

    • Topic:通配符,把消息交给符合routing pattern(路由模式) 的队列

    • headers: 头交换机(headers exchange)使用多个消息属性来代替路由键建立路由规则。(由于很少用这里就不展开说了)

  • Consumer:消费者,与以前一样,订阅队列,没有变化
  • Queue:消息队列也与以前一样,接收消息、缓存消息。

🌸Fanout

Fanout,英文翻译是扇出,我觉得在MQ中叫广播更合适。

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

在广播模式下,消息发送流程是这样的:

  • 1) 可以有多个队列
  • 2) 每个队列都要绑定到Exchange(交换机)
  • 3) 生产者发送的消息,只能发送到交换机,交换机来决定要发给哪个队列,生产者无法决定
  • 4) 交换机把消息发送给绑定过的所有队列
  • 5) 订阅队列的消费者都能拿到消息

准备做的事情:

  • 创建一个交换机 itcast.fanout,类型是Fanout
  • 创建两个队列fanout.queue1和fanout.queue2,绑定到交换机itcast.fanout
    RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

🌸声明队列和交换机


Spring提供了一个接口Exchange,来表示所有不同类型的交换机:

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

在consumer中创建一个类,声明队列和交换机:

package cn.itcast.mq.config;

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("itcast.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);
    }
}

🌸消息发送

在publisher服务的SpringAmqpTest类中添加测试方法:

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

🌸消息接收

在consumer服务的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 + "】");
}

🌸总结

交换机的作用是什么?

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

声明队列、交换机、绑定关系的Bean是什么?

  • Queue
  • FanoutExchange
  • Binding

🌸Direct

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

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

在Direct模型下:

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

案例需求如下

  1. 利用@RabbitListener声明Exchange、Queue、RoutingKey

  2. 在consumer服务中,编写两个消费者方法,分别监听direct.queue1和direct.queue2

  3. 在publisher中编写测试方法,向itcast. direct发送消息

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

🌸基于注解声明队列和交换机


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

在consumer的SpringRabbitListener中添加两个消费者,同时基于注解来声明队列和交换机:

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

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "direct.queue2"),
    exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
    key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
    System.out.println("消费者接收到direct.queue2的消息:【" + msg + "】");
}

🌸消息发送


在publisher服务的SpringAmqpTest类中添加测试方法:

@Test
public void testSendDirectExchange() {
    // 交换机名称
    String exchangeName = "itcast.direct";
    // 消息
    String message = "红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

🌸总结


描述下Direct交换机与Fanout交换机的差异?

  • Fanout交换机将消息路由给每一个与之绑定的队列
  • Direct交换机根据RoutingKey判断路由给哪个队列
  • 如果多个队列具有相同的RoutingKey,则与Fanout功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解?

  • @Queue
  • @Exchange

🌸Topic

🌸说明

Topic类型的ExchangeDirect相比,都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符!

Routingkey 一般都是有一个或多个单词组成,多个单词之间以”.”分割,例如: item.insert

通配符规则:

#:匹配一个或多个词

*:匹配不多不少恰好1个词

举例:

item.#:能够匹配item.spu.insert 或者 item.spu

item.*:只能匹配item.spu

图示:

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

解释:

  • Queue1:绑定的是china.# ,因此凡是以 china.开头的routing key 都会被匹配到。包括china.news和china.weather
  • Queue2:绑定的是#.news ,因此凡是以 .news结尾的 routing key 都会被匹配。包括china.news和japan.news

案例需求:

实现思路如下:

  1. 并利用@RabbitListener声明Exchange、Queue、RoutingKey

  2. 在consumer服务中,编写两个消费者方法,分别监听topic.queue1和topic.queue2

  3. 在publisher中编写测试方法,向itcast. topic发送消息

RabbitMQ 消息队列(Spring boot AMQP),Springboot,并发编程,rabbitmq,分布式

🌸消息发送

在publisher服务的SpringAmqpTest类中添加测试方法:

/**
     * topicExchange
     */
@Test
public void testSendTopicExchange() {
    // 交换机名称
    String exchangeName = "itcast.topic";
    // 消息
    String message = "喜报!孙悟空大战哥斯拉,胜!";
    // 发送消息
    rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

🌸消息接收

在consumer服务的SpringRabbitListener中添加方法:

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue1"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "china.#"
))
public void listenTopicQueue1(String msg){
    System.out.println("消费者接收到topic.queue1的消息:【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
    value = @Queue(name = "topic.queue2"),
    exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
    key = "#.news"
))
public void listenTopicQueue2(String msg){
    System.out.println("消费者接收到topic.queue2的消息:【" + msg + "】");
}

🌸总结

描述下Direct交换机与Topic交换机的差异?

  • Topic交换机接收的消息RoutingKey必须是多个单词,以 **.** 分割
  • Topic交换机与队列绑定时的bindingKey可以指定通配符
  • #:代表0个或多个词
  • *:代表1个词

🌸在使用MQ(消息队列)时,需要注意以下几个问题


🌸1. 消息丢失:


  • 解决方案:
    • 开启消息持久化:将消息保存到持久化存储介质(如磁盘)中,以确保即使在系统故障或重启后,消息也能够被恢复。
    • 设置合适的消息超时时间:根据业务需求,合理设置消息的过期时间,避免长期滞留的消息占用资源。
    • 使用备份和冗余机制:在分布式环境下,可以使用主备架构、多副本复制等机制来保障消息的可靠性。

🌸2. 消息顺序:


  • 解决方案:
    • 使用单一消息队列:为了确保消息的有序处理,可以使用单一消息队列,使消息按照先后顺序进行处理。
    • 对消息进行分区:如果需要水平扩展,可以将消息划分为多个分区,并根据分区进行顺序处理。

🌸3. 幂等性:


  • 解决方案:
    • 唯一标识符:为每条消息生成唯一的标识符,在消息处理前检查该标识符是否已经处理过,避免重复消费。
    • 幂等性校验:记录已处理的消息ID或内容,并在每次接收到消息时进行查重,确保同一消息不会被处理多次。
    • 事务性处理:将消息的处理逻辑与更新数据库、缓存等操作放在同一个事务中,并通过回滚事务来避免重复处理。

🌸4. 性能和吞吐量:


  • 解决方案:
    • 优化代码逻辑:合理设计消息生产者和消费者的代码逻辑,减少不必要的网络通信或资源占用。
    • 合理配置MQ参数:根据系统需求,调整MQ的配置参数,如队列长度、批量发送等,以提高性能和吞吐量。
    • 水平扩展:通过增加消息队列的实例或增加消费者线程数等方式,实现水平扩展,提升处理能力。

🌸5. 容错性和可靠性:


  • 解决方案:
    • 主备架构:使用主备模式,当主节点故障时,自动切换到备份节点,确保消息服务的高可用性。
    • 多副本复制:将消息队列的内容复制到多个节点上,实现数据的冗余备份,确保数据的安全性和可靠性。

🌸6. 监控和调优:


  • 解决方案:
    • 实时监控:配置监控系统,实时监测消息的发送和消费情况,及时发现异常并进行处理。
    • 性能调优:定期进行性能分析和调优,根据监控数据调整配置参数,提升系统的性能和吞吐量。

综上所述,针对MQ使用中需要注意的问题,我们提供了相应的解决方案。根据具体的业务需求和系统环境,可以结合这些解决方案来确保消息队列的稳定运行和可靠性。

🌸总结


  1. 灵活性和可靠性:RabbitMQ 提供了丰富的消息传递模型和功能,使开发者能够设计出灵活而复杂的消息路由机制。它还提供了可靠的消息传递机制,包括消息确认、持久化等,确保消息的可靠传递。

  2. 可扩展性和高性能:RabbitMQ 具备良好的水平扩展能力,可以轻松处理大量的并发连接和高吞吐量。它的性能表现稳定,并且在大规模部署中经得起考验。

  3. 协议支持和跨平台兼容性:RabbitMQ 基于 AMQP(Advanced Message Queuing Protocol)标准,并支持多种编程语言和平台。这意味着您可以使用多种语言和技术栈来与 RabbitMQ 进行交互,从而方便地集成到您的现有系统中。

  4. 社区支持和稳定性:RabbitMQ 是一个广受欢迎的开源项目,拥有活跃的社区支持和持续的更新。它已经经过多年的稳定运行和广泛应用,在很多大型企业和组织中被广泛信赖。

  5. 丰富的功能和插件:RabbitMQ 提供了许多有用的功能和插件,如消息优先级、延迟队列、RPC(Remote Procedure Call)等。这些功能可以根据具体需求进行配置和扩展,使得 RabbitMQ 更加灵活且适用于各种场景。

  6. 管理和监控:RabbitMQ 提供了直观的管理界面,方便您管理队列、交换机、绑定等,并监控关键性能指标和健康状态。这使您能够方便地查看和管理消息传递的整个过程。文章来源地址https://www.toymoban.com/news/detail-648312.html


  • 总而言之,选择 RabbitMQ 的原因是它提供了一个可靠、灵活且功能强大的消息传递解决方案。它广泛应用于企业集成、异步任务处理、实时数据流处理等各种场景。
  • 当然,在选择消息队列解决方案时,您还需要考虑其他因素,如团队经验、技术栈兼容性等。但基于其特点和广泛的应用,RabbitMQ 是一个值得考虑且常见的选择。

到了这里,关于RabbitMQ 消息队列(Spring boot AMQP)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

原文地址:https://blog.csdn.net/qq_39017153/article/details/132141114

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

领支付宝红包 赞助服务器费用

相关文章

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包