RabbitMQ基础知识

于 2024-08-22 18:09:36 发布
阅读量778 收藏 17
点赞数 24
文章标签： rabbitmq 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44106059/article/details/141434667
版权

RabbitMQ 是一个实现了高级消息队列协议（AMQP）的开源消息代理软件，主要使用 Erlang 编程语言编写。

Erlang 语言具有高并发、分布式、可靠性强等特点，非常适合用于构建像 RabbitMQ 这样的分布式消息中间件。它能够有效地处理大量的并发连接和消息传递，确保系统的稳定性和可靠性。

以下是对 RabbitMQ 的详细介绍：

一、主要特点

  1. 可靠性高
    • 确保消息能够可靠地传输，即使在网络故障或服务器故障的情况下也能保证消息不丢失。它通过持久化机制、确认机制和事务机制等多种方式来实现消息的可靠传递。
    • 持久化机制可以将消息存储在磁盘上，即使服务器重启，消息也不会丢失。确认机制要求接收者在接收到消息后发送确认信号，确保消息被正确处理。事务机制则提供了一种原子性的操作方式，保证一组消息的发送和处理要么全部成功，要么全部失败。
  2. 灵活的路由
    • 支持多种消息路由模式，可以根据不同的需求将消息发送到不同的队列。RabbitMQ 提供了四种交换机类型，分别是直连交换机（Direct Exchange）、扇形交换机（Fanout Exchange）、主题交换机（Topic Exchange）和头交换机（Headers Exchange）。
    • 直连交换机将消息路由到那些 binding key 与 routing key 完全匹配的队列中。扇形交换机将消息广播到所有绑定到它的队列中，忽略 routing key。主题交换机通过通配符的方式进行消息路由，routing key 由多个单词组成，以点号分隔。头交换机根据消息的头部属性进行路由，队列通过指定消息头的键值对来绑定到交换机。
  3. 高吞吐量
    • 能够处理大量的消息，适用于高并发的应用场景。RabbitMQ 采用了高效的消息存储和传输机制，可以快速地处理大量的消息。它还支持集群部署，可以通过增加服务器节点来提高系统的吞吐量和可用性。
  4. 多种编程语言支持
    • 可以使用多种编程语言进行开发，如 Java、Python、C# 等。RabbitMQ 提供了丰富的客户端库，方便不同编程语言的开发者使用。这些客户端库提供了与 RabbitMQ 服务器进行通信的接口，使得开发者可以轻松地发送和接收消息。
  5. 分布式架构
    • 可以在分布式环境中部署，实现高可用性和可扩展性。RabbitMQ 支持集群部署，可以将多个服务器节点组成一个集群，提高系统的可用性和吞吐量。在集群中，消息可以在不同的节点之间进行复制和路由，确保消息的可靠传递。此外，RabbitMQ 还支持 Federation 和 Shovel 插件，可以实现跨数据中心的消息传递和复制。

二、工作原理

  1. 消息生产者（Producer）将消息发送到 RabbitMQ 服务器。
    • 生产者通过连接到 RabbitMQ 服务器，创建一个通道（Channel），并使用该通道将消息发送到指定的交换机（Exchange）。在发送消息时，生产者需要指定消息的 routing key，以便 RabbitMQ 根据 routing key 将消息路由到相应的队列（Queue）。
  2. 交换机根据路由规则将消息路由到一个或多个队列。
    • RabbitMQ 服务器中的交换机根据不同的类型和路由规则，将接收到的消息路由到一个或多个队列中。交换机的类型包括直连交换机、扇形交换机、主题交换机和头交换机，每种类型的交换机都有不同的路由规则。
  3. 消息消费者（Consumer）从队列中获取消息并进行处理。
    • 消费者通过连接到 RabbitMQ 服务器，创建一个通道，并使用该通道从指定的队列中获取消息。消费者可以采用推模式（Push）或拉模式（Pull）获取消息。在推模式下，RabbitMQ 服务器会主动将消息推送给消费者；在拉模式下，消费者需要主动从队列中拉取消息。

三、应用场景

  1. 异步通信
    • 在分布式系统中，不同的组件之间可能需要进行异步通信。例如，在一个电商系统中，当用户下单后，订单系统可以将订单信息发送到消息队列中，然后由库存系统、支付系统等其他组件从消息队列中获取订单信息并进行处理。这样可以避免订单系统等待其他系统的响应，提高系统的响应速度和吞吐量。
  2. 解耦
    • 在复杂的系统中，不同的模块之间可能存在紧密的耦合关系。通过使用消息队列，可以将不同模块之间的通信解耦，使得各个模块可以独立地进行开发、测试和部署。例如，在一个物流系统中，订单系统、运输系统和仓储系统之间可以通过消息队列进行通信，当订单状态发生变化时，订单系统将消息发送到消息队列中，运输系统和仓储系统从消息队列中获取消息并进行相应的处理。
  3. 流量削峰
    • 在高并发的系统中，可能会出现瞬间的流量高峰，导致系统压力过大。通过使用消息队列，可以将瞬间的流量高峰缓存起来，然后由系统逐步处理，从而避免系统因瞬间的流量高峰而崩溃。例如，在一个秒杀系统中，当用户发起秒杀请求时，系统可以将请求发送到消息队列中，然后由后台系统逐步处理这些请求，避免因瞬间的流量高峰而导致系统崩溃。
  4. 数据同步
    • 在分布式系统中，不同的数据存储之间可能需要进行数据同步。通过使用消息队列，可以将数据变更事件发送到消息队列中，然后由其他数据存储从消息队列中获取事件并进行相应的处理，从而实现数据的同步。例如，在一个分布式数据库系统中，当一个数据库节点的数据发生变化时，该节点可以将数据变更事件发送到消息队列中，然后由其他数据库节点从消息队列中获取事件并进行相应的处理，从而实现数据的同步。

总之，RabbitMQ 是一个功能强大、灵活可靠的消息代理软件，广泛应用于分布式系统中的异步通信、解耦、流量削峰和数据同步等场景。其使用 Erlang 编程语言编写，充分发挥了 Erlang 语言在高并发、分布式和可靠性方面的优势。

Direct Exchange（直连交换机）案例

配置类：

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

@Configuration
public class RabbitMQConfig {

    public static final String DIRECT_EXCHANGE_NAME = "directExchange";
    public static final String DIRECT_QUEUE_NAME = "directQueue";
    public static final String DIRECT_ROUTING_KEY = "directKey";

    @Bean
    public DirectExchange directExchange() {
        return new DirectExchange(DIRECT_EXCHANGE_NAME);
    }

    @Bean
    public Queue directQueue() {
        return new Queue(DIRECT_QUEUE_NAME);
    }

    @Bean
    public Binding directBinding() {
        return BindingBuilder.bind(directQueue()).to(directExchange()).with(DIRECT_ROUTING_KEY);
    }
}

生产者服务类：

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

@Service
public class DirectMessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendDirectMessage(String message) {
        rabbitTemplate.convertAndSend(RabbitMQConfig.DIRECT_EXCHANGE_NAME, RabbitMQConfig.DIRECT_ROUTING_KEY, message);
    }
}

消费者服务类：

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

@Service
public class DirectMessageConsumer {

    @RabbitListener(queues = RabbitMQConfig.DIRECT_QUEUE_NAME)
    public void receiveDirectMessage(String message) {
        System.out.println("Received direct message: " + message);
    }
}

Fanout Exchange（扇形交换机）案例

配置类：

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 {

    public static final String FANOUT_EXCHANGE_NAME = "fanoutExchange";
    public static final String FANOUT_QUEUE_1_NAME = "fanoutQueue1";
    public static final String FANOUT_QUEUE_2_NAME = "fanoutQueue2";

    @Bean
    public FanoutExchange fanoutExchange() {
        return new FanoutExchange(FANOUT_EXCHANGE_NAME);
    }

    @Bean
    public Queue fanoutQueue1() {
        return new Queue(FANOUT_QUEUE_1_NAME);
    }

    @Bean
    public Queue fanoutQueue2() {
        return new Queue(FANOUT_QUEUE_2_NAME);
    }

    @Bean
    public Binding fanoutBinding1() {
        return BindingBuilder.bind(fanoutQueue1()).to(fanoutExchange());
    }

    @Bean
    public Binding fanoutBinding2() {
        return BindingBuilder.bind(fanoutQueue2()).to(fanoutExchange());
    }
}

生产者服务类：

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

@Service
public class FanoutMessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendFanoutMessage(String message) {
        rabbitTemplate.convertAndSend(FanoutConfig.FANOUT_EXCHANGE_NAME, "", message);
    }
}

消费者服务类 1：

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

@Service
public class FanoutMessageConsumer1 {

    @RabbitListener(queues = FanoutConfig.FANOUT_QUEUE_1_NAME)
    public void receiveFanoutMessage1(String message) {
        System.out.println("Received fanout message 1: " + message);
    }
}

消费者服务类 2：

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

@Service
public class FanoutMessageConsumer2 {

    @RabbitListener(queues = FanoutConfig.FANOUT_QUEUE_2_NAME)
    public void receiveFanoutMessage2(String message) {
        System.out.println("Received fanout message 2: " + message);
    }
}

Topic Exchange（主题交换机）案例

配置类：

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

@Configuration
public class TopicConfig {

    public static final String TOPIC_EXCHANGE_NAME = "topicExchange";
    public static final String TOPIC_QUEUE_1_NAME = "topicQueue1";
    public static final String TOPIC_QUEUE_2_NAME = "topicQueue2";
    public static final String TOPIC_ROUTING_KEY_1 = "topic.key1";
    public static final String TOPIC_ROUTING_KEY_2 = "topic.key2.*";

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE_NAME);
    }

    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE_1_NAME);
    }

    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE_2_NAME);
    }

    @Bean
    public Binding topicBinding1() {
        return BindingBuilder.bind(topicQueue1()).to(topicExchange()).with(TOPIC_ROUTING_KEY_1);
    }

    @Bean
    public Binding topicBinding2() {
        return BindingBuilder.bind(topicQueue2()).to(topicExchange()).with(TOPIC_ROUTING_KEY_2);
    }
}

生产者服务类：

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

@Service
public class TopicMessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendTopicMessage(String routingKey, String message) {
        rabbitTemplate.convertAndSend(TopicConfig.TOPIC_EXCHANGE_NAME, routingKey, message);
    }
}

消费者服务类 1：

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

@Service
public class TopicMessageConsumer1 {

    @RabbitListener(queues = TopicConfig.TOPIC_QUEUE_1_NAME)
    public void receiveTopicMessage1(String message) {
        System.out.println("Received topic message 1: " + message);
    }
}

消费者服务类 2：

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

@Service
public class TopicMessageConsumer2 {

    @RabbitListener(queues = TopicConfig.TOPIC_QUEUE_2_NAME)
    public void receiveTopicMessage2(String message) {
        System.out.println("Received topic message 2: " + message);
    }
}

Headers Exchange（头交换机）案例

配置类：

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

import java.util.HashMap;
import java.util.Map;

@Configuration
public class HeadersConfig {

    public static final String HEADERS_EXCHANGE_NAME = "headersExchange";
    public static final String HEADERS_QUEUE_1_NAME = "headersQueue1";
    public static final String HEADERS_QUEUE_2_NAME = "headersQueue2";

    @Bean
    public HeadersExchange headersExchange() {
        return new HeadersExchange(HEADERS_EXCHANGE_NAME);
    }

    @Bean
    public Queue headersQueue1() {
        return new Queue(HEADERS_QUEUE_1_NAME);
    }

    @Bean
    public Queue headersQueue2() {
        return new Queue(HEADERS_QUEUE_2_NAME);
    }

    @Bean
    public Binding headersBinding1() {
        Map<String, Object> headers1 = new HashMap<>();
        headers1.put("type", "important");
        return BindingBuilder.bind(headersQueue1()).to(headersExchange()).whereAll(headers1).match();
    }

    @Bean
    public Binding headersBinding2() {
        Map<String, Object> headers2 = new HashMap<>();
        headers2.put("type", "normal");
        return BindingBuilder.bind(headersQueue2()).to(headersExchange()).whereAll(headers2).match();
    }
}

生产者服务类：

import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class HeadersMessageProducer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public void sendHeadersMessage(String type, String message) {
        MessageProperties properties = new MessageProperties();
        properties.setHeader("type", type);
        Message amqpMessage = new Message(message.getBytes(), properties);
        rabbitTemplate.send(HeadersConfig.HEADERS_EXCHANGE_NAME, "", amqpMessage);
    }
}

消费者服务类 1：

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

@Service
public class HeadersMessageConsumer1 {

    @RabbitListener(queues = HeadersConfig.HEADERS_QUEUE_1_NAME)
    public void receiveHeadersMessage1(String message) {
        System.out.println("Received important headers message: " + message);
    }
}

消费者服务类 2：

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

@Service
public class HeadersMessageConsumer2 {

    @RabbitListener(queues = HeadersConfig.HEADERS_QUEUE_2_NAME)
    public void receiveHeadersMessage2(String message) {
        System.out.println("Received normal headers message: " + message);
    }
}

死信队列实现步骤

  1. 添加依赖
    • 在项目的pom.xml文件中添加 RabbitMQ 的依赖：
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-amqp</artifactId>
     </dependency>
  1. 配置 RabbitMQ
    • 在application.properties或application.yml文件中配置 RabbitMQ 的连接信息：
     spring.rabbitmq.host=localhost
     spring.rabbitmq.port=5672
     spring.rabbitmq.username=guest
     spring.rabbitmq.password=guest
  1. 定义普通队列、死信交换器和死信队列
    • 使用@Bean注解在配置类中定义普通队列、死信交换器和死信队列：
     import org.springframework.amqp.core.Binding;
     import org.springframework.amqp.core.BindingBuilder;
     import org.springframework.amqp.core.DirectExchange;
     import org.springframework.amqp.core.Queue;
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;

     @Configuration
     public class RabbitMQConfig {

         // 普通队列名称
         public static final String NORMAL_QUEUE_NAME = "normalQueue";
         // 死信队列名称
         public static final String DEAD_LETTER_QUEUE_NAME = "deadLetterQueue";
         // 普通交换器名称
         public static final String NORMAL_EXCHANGE_NAME = "normalExchange";
         // 死信交换器名称
         public static final String DEAD_LETTER_EXCHANGE_NAME = "deadLetterExchange";

         @Bean
         public Queue normalQueue() {
             return new Queue(NORMAL_QUEUE_NAME, true, false, false);
         }

         @Bean
         public Queue deadLetterQueue() {
             return new Queue(DEAD_LETTER_QUEUE_NAME, true, false, false);
         }

         @Bean
         public DirectExchange normalExchange() {
             return new DirectExchange(NORMAL_EXCHANGE_NAME);
         }

         @Bean
         public DirectExchange deadLetterExchange() {
             return new DirectExchange(DEAD_LETTER_EXCHANGE_NAME);
         }

         @Bean
         public Binding normalQueueBinding() {
             return BindingBuilder.bind(normalQueue()).to(normalExchange()).with("normalRoutingKey");
         }

         @Bean
         public Binding deadLetterQueueBinding() {
             return BindingBuilder.bind(deadLetterQueue()).to(deadLetterExchange()).with("deadLetterRoutingKey");
         }
     }
  1. 设置死信参数
    • 在定义普通队列时，设置死信交换器和死信路由键等参数：
     @Bean
     public Queue normalQueue() {
         return QueueBuilder.durable(NORMAL_QUEUE_NAME)
                .withArgument("x-dead-letter-exchange", DEAD_LETTER_EXCHANGE_NAME)
                .withArgument("x-dead-letter-routing-key", "deadLetterRoutingKey")
                .build();
     }
  1. 消费者和生产者
    • 生产者发送消息到普通队列：
     import org.springframework.amqp.rabbit.core.RabbitTemplate;
     import org.springframework.stereotype.Component;

     @Component
     public class MessageProducer {

         private final RabbitTemplate rabbitTemplate;

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

         public void sendMessage(String message) {
             rabbitTemplate.convertAndSend(RabbitMQConfig.NORMAL_EXCHANGE_NAME, "normalRoutingKey", message);
         }
     }
  • 消费者从死信队列中获取消息进行处理：
     import org.springframework.amqp.rabbit.annotation.RabbitListener;
     import org.springframework.stereotype.Component;

     @Component
     public class DeadLetterQueueConsumer {

         @RabbitListener(queues = RabbitMQConfig.DEAD_LETTER_QUEUE_NAME)
         public void consumeDeadLetterMessage(String message) {
             System.out.println("Received dead letter message: " + message);
         }
     }

延时消息队列实现步骤

  1. 安装 RabbitMQ Delayed Message Exchange 插件
    • RabbitMQ 本身不支持原生的延时消息队列，需要安装 Delayed Message Exchange 插件来实现。可以从 RabbitMQ 官网下载插件并按照说明进行安装。
  2. 配置延时交换器
    • 在配置类中定义延时交换器：
     import org.springframework.amqp.core.Binding;
     import org.springframework.amqp.core.BindingBuilder;
     import org.springframework.amqp.core.CustomExchange;
     import org.springframework.context.annotation.Bean;
     import org.springframework.context.annotation.Configuration;

     @Configuration
     public class DelayedQueueConfig {

         // 延时交换器名称
         public static final String DELAYED_EXCHANGE_NAME = "delayedExchange";
         // 延时队列名称
         public static final String DELAYED_QUEUE_NAME = "delayedQueue";

         @Bean
         public CustomExchange delayedExchange() {
             return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false);
         }

         @Bean
         public Binding delayedQueueBinding() {
             return BindingBuilder.bind(delayedQueue()).to(delayedExchange()).with("delayedRoutingKey").noargs();
         }
     }
  1. 发送延时消息
    • 生产者发送延时消息到延时交换器：
     import org.springframework.amqp.rabbit.core.RabbitTemplate;
     import org.springframework.stereotype.Component;

     @Component
     public class DelayedMessageProducer {

         private final RabbitTemplate rabbitTemplate;

         public DelayedMessageProducer(RabbitTemplate rabbitTemplate) {
             this.rabbitTemplate = rabbitTemplate;
         }

         public void sendDelayedMessage(String message, long delayInMilliseconds) {
             rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME, "delayedRoutingKey", message, msg -> {
                 msg.getMessageProperties().setDelay(delayInMilliseconds);
                 return msg;
             });
         }
     }
  1. 消费者处理延时消息
    • 消费者从延时队列中获取消息进行处理：
     import org.springframework.amqp.rabbit.annotation.RabbitListener;
     import org.springframework.stereotype.Component;

     @Component
     public class DelayedQueueConsumer {

         @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
         public void consumeDelayedMessage(String message) {
             System.out.println("Received delayed message: " + message);
         }
     }

通过以上步骤，就可以在 Spring Boot 3 中实现 RabbitMQ 的死信队列和延时消息队列。在实际应用中，可以根据具体的业务需求进行调整和扩展。

RabbitMQ 的常见面试题及答案

一、基础概念类

  1. 请简要介绍 RabbitMQ 的作用和特点。
    • 作用：RabbitMQ 是一个实现了高级消息队列协议（AMQP）的开源消息代理软件，主要用于在分布式系统中存储和转发消息，实现应用程序之间的异步通信。
    • 特点：高可靠、高可用、可扩展性强、支持多种消息协议、灵活的路由机制、提供多种交换器类型等。
  2. RabbitMQ 中有哪些主要的组件？
    • 队列（Queue）：用于存储消息，消费者从队列中获取消息进行处理。
    • 交换器（Exchange）：接收生产者发送的消息，并根据一定的规则将消息路由到一个或多个队列。
    • 绑定（Binding）：定义了交换器和队列之间的关系，通过路由键将两者关联起来。
    • 通道（Channel）：在客户端和 RabbitMQ 服务器之间建立的通信通道，用于发送和接收消息。
  3. 解释一下 RabbitMQ 的工作流程。
    • 生产者将消息发送到交换器。
    • 交换器根据预先配置的路由规则将消息路由到一个或多个队列。
    • 消费者从队列中获取消息并进行处理。

二、技术实现类

  1. 如何在 Java 项目中使用 RabbitMQ？
    • 添加 RabbitMQ 的客户端库依赖，如com.rabbitmq:amqp-client。
    • 创建连接工厂，设置连接参数（如主机名、端口、用户名、密码等）。
    • 通过连接工厂创建连接，再从连接中创建通道。
    • 使用通道声明队列、交换器和绑定关系。
    • 生产者使用通道发送消息，消费者使用通道从队列中获取消息并处理。
  2. 如何声明一个队列和交换器，并将它们绑定起来？
    • 使用通道的queueDeclare方法声明队列，可以设置队列名称、是否持久化、是否独占、是否自动删除等参数。
    • 使用通道的exchangeDeclare方法声明交换器，可以设置交换器名称、类型、是否持久化等参数。
    • 使用通道的queueBind方法将队列和交换器绑定起来，指定路由键。
  3. 在 Java 中如何发送和接收消息？
    • 发送消息：生产者使用通道的basicPublish方法将消息发送到指定的交换器和路由键。
    • 接收消息：消费者使用通道的basicConsume方法订阅一个队列，当有消息到达队列时，会自动调用注册的回调方法进行处理。

三、高级特性类

  1. RabbitMQ 的消息确认机制是怎样的？
    • RabbitMQ 提供了两种消息确认方式：自动确认和手动确认。
    • 自动确认：消费者在接收到消息后立即自动确认，不管消息是否被成功处理。这种方式可能会导致消息丢失，如果消费者在处理消息过程中出现异常崩溃，而消息已经被确认，那么该消息就不会被重新投递。
    • 手动确认：消费者在处理完消息后，显式地调用channel.basicAck方法进行确认。如果处理过程中出现异常，可以调用channel.basicNack或channel.basicReject方法拒绝消息，让 RabbitMQ 重新投递该消息。
  2. 如何实现 RabbitMQ 的消息持久化？
    • 对于队列，可以在声明队列时设置durable=true，这样队列在 RabbitMQ 服务器重启后不会丢失。
    • 对于消息，可以在发送消息时设置消息的deliveryMode为 2，表示持久化消息。这样即使 RabbitMQ 服务器重启，持久化的消息也不会丢失。
  3. 如何处理 RabbitMQ 中的死信队列？
    • 当消息被拒绝（basic.reject/basic.nack）且requeue=false，或者消息过期、队列达到最大长度等情况时，消息会被放入死信队列。
    • 可以创建一个专门的死信队列，并在正常队列的声明中指定死信交换器和路由键，当满足死信条件时，消息会被路由到死信队列，然后可以由专门的消费者来处理死信消息。
  4. RabbitMQ 如何实现消息的负载均衡？
    • 可以启动多个消费者，每个消费者订阅同一个队列。RabbitMQ 会自动将队列中的消息均衡地分配给各个消费者，实现负载均衡。

四、性能优化类

  1. 如何提高 RabbitMQ 的性能？
    • 合理设置队列和交换器的参数，如队列的大小、持久化选项等。
    • 使用批量发送和接收消息的方式，减少网络开销。
    • 优化消费者的处理逻辑，提高消息处理速度。
    • 调整 RabbitMQ 的内存和磁盘配置，以适应不同的负载情况。
  2. 在高并发场景下，如何保证 RabbitMQ 的稳定性？
    • 增加 RabbitMQ 服务器的硬件资源，如内存、CPU 等。
    • 合理设置连接数、通道数等参数，避免资源耗尽。
    • 监控 RabbitMQ 的运行状态，及时发现和处理问题。
    • 使用集群模式部署 RabbitMQ，提高系统的可用性和可扩展性。

在 RabbitMQ 中，如何保证消息的顺序性？

一、单线程消费

一个简单的方法是确保同一个队列的消息始终由同一个消费者以单线程的方式进行处理。这样可以保证消息按照在队列中的顺序被依次处理。

二、拆分队列

  1. 业务分析：
    • 如果一个业务场景中有多个不同类型的消息混合在一个队列中，可能会导致消息处理顺序混乱。可以根据业务类型将消息拆分成不同的队列，每个队列由独立的消费者进行处理。
    • 例如，在一个电商系统中，订单创建、订单支付和订单发货的消息如果混在一个队列中，可能由于不同类型消息处理时间的差异而导致顺序混乱。可以将这三种类型的消息分别放入不同的队列进行处理。
  2. 实现方式：
    • 生产者在发送消息时，根据消息的类型将其发送到对应的队列中。
    • 每个队列都有一个专门的消费者进行处理，确保同一类型的消息按照顺序处理。

三、避免重试机制影响顺序性

  1. 问题分析：
    • 当消息处理失败需要重试时，如果不加以控制，重试的消息可能会被插入到队列的中间位置，从而破坏消息的顺序性。
    • 例如，消息 M1、M2、M3 依次进入队列，M2 处理失败进行重试。如果不做特殊处理，重试的 M2 可能会在 M3 被处理之前再次进入队列并被处理，导致顺序混乱。
  2. 解决方案：
    • 可以将重试的消息放入一个专门的重试队列，而不是直接插入到原始队列中。当消息处理失败时，将其发送到重试队列，并设置一个延迟时间，等延迟时间过后再从重试队列中取出消息进行处理。
    • 或者使用消息版本号的方式，每次重试时增加消息的版本号，消费者在处理消息时，根据版本号判断是否是重试的消息，并按照顺序进行处理。

需要注意的是，在分布式环境中，完全保证消息的顺序性是非常困难的，因为可能会出现网络延迟、节点故障等各种不可预测的情况。但通过以上方法，可以在一定程度上提高消息处理的顺序性。

在 RabbitMQ 中，如何保证消息的幂等性？

一、数据库唯一约束

  1. 适用场景：
    • 当消息的处理结果会影响数据库中的数据时，可以利用数据库的唯一约束来保证幂等性。
    • 例如，一个订单处理系统，接收到订单创建的消息后，会在数据库中插入订单记录。如果重复收到相同的订单创建消息，需要确保不会重复插入订单记录。
  2. 实现方式：
    • 在数据库表中，为关键字段设置唯一约束，例如订单号。
    • 当消费者接收到消息并进行处理时，尝试将数据插入数据库。如果插入操作因为唯一约束失败，说明该消息已经被处理过，直接忽略即可。

二、使用唯一标识符和缓存

  1. 适用场景：
    • 对于一些不直接操作数据库，但需要进行复杂业务处理的场景，可以使用唯一标识符和缓存来实现幂等性。
    • 比如，一个消息处理过程中需要调用多个外部服务，并且处理结果不直接存储在数据库中。
  2. 实现方式：
    • 生产者在发送消息时，为每条消息生成一个唯一标识符（如 UUID），并将其包含在消息中。
    • 消费者接收到消息后，提取唯一标识符，并检查缓存中是否已经存在该标识符。如果存在，说明该消息已经被处理过，直接忽略；如果不存在，将标识符存入缓存，并进行消息的处理。

三、记录消息处理状态

  1. 适用场景：
    • 当消息的处理过程比较复杂，可能涉及多个步骤或状态变化时，可以通过记录消息的处理状态来保证幂等性。
    • 例如，一个审批流程系统，消息表示一个审批任务，审批过程可能经过多个阶段。需要确保每个审批任务在每个阶段只被处理一次。
  2. 实现方式：
    • 创建一个消息处理状态表，记录每个消息的处理状态和进度。
    • 消费者接收到消息后，根据消息的唯一标识查询状态表。如果消息已经处于已处理状态，直接忽略；如果消息处于未处理状态，进行处理，并更新状态表中的状态信息。

总之，保证消息的幂等性需要根据具体的业务场景选择合适的方法。在实际应用中，可以结合多种方法来提高幂等性的保证程度。

果肉冻憨皮
关注
  • 24
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
rabbitmq基础知识总结 | Spring Boot 25
学Java，找哪吒
02-11 5508
一、RabbitMQ简介 RabbitMQ即一个消息队列，主要是用来实现应用程序的异步和解耦，同时也能起到消息缓冲，消息分发的作用。 消息中间件在互联网公司的使用中越来越多，消息中间件最主要的作用是解耦，中间件最标准的用法是生产者生产消息传送到队列，消费者从队列中拿取消息并处理，生产者不用关心是谁来消费，消费者不用关心谁在生产消息，从而达到解耦的目的。在分布式的系统中，消息队列也会被用在很多其...
什么是RabbitMQ以及它的特点？
m0_58524181的博客
10-09 1940
RabbitMQ是什么以及RabbitMQ的特点
RabbitMQ的高级特性及其特点
JackMa的博客
05-26 2416
全局生效：对于order-service远程调用的所有服务都是用的是RandomRule。被调用方使用局部生效：对于调用user-service的服务使用的是RandomRule。调用方使用如果在某一时刻，服务B出现故障（可能就卡在那里了），而这时服务A依然有大量的请求，在调用服务B，那么，由于服务A没办法再短时间内完成处理，新来的请求就会导致线程数不断地增加，这样，CPU的资源很快就会被耗尽。那么就会出现服务雪崩。
常用的RabbitMQ命令以及安装RabbitMQ（ARM架构的CentOS虚拟机和X86架构的CentOS虚拟机）
weixin_68651384的博客
07-08 2767
Erlang（['ə:læŋ]）是⼀种通⽤的⾯向并发的编程语⾔，它由瑞典电信设备制造商爱⽴信所辖的CS-Lab开发，⽬的 是创造⼀种可以应对⼤规模并发活动的编程语⾔和运⾏环境。最初是由爱⽴信专⻔为通信应⽤设计的，⽐如控制交换机或者变换协议等，因此⾮常适合构建分布式、实时软并⾏ 计算系统。Erlang运⾏时环境是⼀个虚拟机，有点像Java的虚拟机，这样代码⼀经编译，同样可以随处运⾏。
第3节：RabbitMQ特点
qq_33324995的博客
11-19 574
RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。 AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。 1.rabbitMQ官网上说的特点是6个 （https://www.rabbitmq.com/） 1.1 异步消息 1.2 支持多种开发语言 1.3 支持分布式 1.4 企业和云就绪 1.5 ...
RabbitMQ特点
qq_40590014的博客
09-07 2241
title: RabbitMQ特点 date: 2019-09-01 07:48:15 summary: RabbitMQ特点 categories: 消息中间件 tags: [RabbitMQ,消息中间件] 初识RabbitMQ RabbitMQ是一个开源的消息代理和队列服务器,用来通过普通协议在完全不同的应用之间共享数据,RabbitMQ是使用Erlang语言来编写的,并且RabbitMQ是...
RabbitMq 基础知识.docx
05-25
以下是对RabbitMQ基础知识的详细解释： 1. **消息持久化** - 消息持久化是确保即使RabbitMQ服务重启，消息也不会丢失的关键特性。这包括交换机(exchange)、队列(queue)和消息(message)的持久化。 - 在声明交换机...
Rabbitmq基础知识
qq_41743601的博客
12-30 1517
Rabbitmq基础知识 mq的基本概念 mq的优势和劣势 应用解耦 异步提速 消峰填谷 消峰填谷 mq的劣势 常见的mq的产品 RabbitMq简介 JMS
rabbitmq基础知识说明
08-08
Broker：简单来说就是消息队列服务器实体。 Exchange：消息交换机，它指定消息按什么规则，路由到哪个队列。 Queue：消息队列载体，每个消息都会被投入到一个或多个队列。 Binding：绑定，它的作用就是把exchange和...
RabbitMQ基本特性
weixin_43345365的博客
07-15 933
1.互联网大厂为什么选择RabbitMQ? 2.RabbitMQ的高性能之道是如何做到的？ 3.什么是AMQP高级协议？ 4.AMQP核心概念是什么？ 5.RabbitMQ整体架构模型是什么样子？ 6.RabbitMQ消息是如何流转的？ 7.命令行与管控台 8.RabbitMQ消息生产与消费 9.RabbitMQ交换机详解 10.RabbitMQ队列绑定、虚拟主机、消息 RabbitMQ是一个开源的消息代理和队列服务器，用来通过普通协议在完全不同的应用之间共享数据，Rabbit..
【深入理解RabbitMQ】RabbitMQ 常用命令
王小明的专栏
02-13 825
rabbitmq-plugins enable rabbitmq_management
RabbitMQ常用命令
厚积薄发
01-20 3333
默认访问页面：http://127.0.0.1:15672 1. 启动RabbitMQ服务 service rabbitmq-server restart 2. 查看RabbitMQ服务状态 rabbitmqctl status 3. 启用web插件 rabbitmq-plugins enable rabbitmq_management 4. 重启RabbitMQ服务 service rabbitmq-server restart 5. 添加页面用户及密码 rabbitm
RabbitMq 常用命令及常见问题
菜菜程序员
09-03 5511
管理概观          rabbitmqctl 是RabbitMQ中间件的一个命令行管理工具。它通过连接一个中间件节点执行所有的动作。本地节点默认被命名为”rabbit”。可以通过这个命令前使 用”-n”标志明确的指定节点名称, 例如:  # rabbitmqctl -n rabbit@shortstop add_user tonyg changeit  这个命令指示RabbitMQ中间件在r...
rabbitmq优点
茶故
07-19 1万+
1.同步变异步 可以使用线程池解决,但是缺点很明显:要自己实现线程池,并且强耦合 大多数是使用消息队列来解决 2.低内聚高耦合:解耦----减少强依赖. 3.流量削峰---秒杀系统 通过消息队列设置请求最大值,超过阀值的抛弃或者转到错误界面. 4.rabbitmq采用信道通信。不采用tcp直接通信 1).tcp的创建和销毁开销大，创建3...
rabbitmqctl---命令详解
小乐的博客
04-24 8175
单机和普通集群的管理命令 rabbitmqctl stop [{pid_file}] # 表示stop 在RabbitMQ服务器上运行的一个Erlang 节点，可以指定某一个 *pid_file*，表示会等待这个指定的程序结束 rabbitmqctl shutdown # 表示终止RabbitMQ 服务器上的Erlang进程，如果终止失败，会返回非零数字 rabbitmqctl sto...
MQ和RabbitMQ作用特点
热门推荐
Visonws的博客
09-09 1万+
MQ的作用：  解耦：在项目启动之初是很难预测未来会遇到什么困难的，消息中间件在处理过程中插入了一个隐含的，基于数据的接口层，两边都实现这个接口，这样就允许独立的修改或者扩展两边的处理过程，只要两边遵守相同的接口约束即可。 冗余（存储）：在某些情况下处理数据的过程中会失败，消息中间件允许把数据持久化知道他们完全被处理 扩展性：消息中间件解耦了应用的过程，所以提供消息入队和处理的效率是很容易的...
rabbitmq的基础知识
最新发布
04-02
RabbitMQ是一个开源的消息中间件，它实现了高级消息队列协议（AMQP）并提供可靠的消息传递机制。以下是RabbitMQ的基础知识： 1. 消息队列：RabbitMQ通过消息队列实现了应用程序之间的异步通信。发送方将消息发送到队列，接收方从队列中获取消息进行处理。 2. 生产者和消费者：生产者是发送消息的应用程序，消费者是接收和处理消息的应用程序。 3. 队列：队列是RabbitMQ中的核心概念，它用于存储消息。生产者将消息发送到队列，消费者从队列中获取消息进行处理。 4. 交换机：交换机是消息的分发中心，它接收生产者发送的消息，并根据一定的规则将消息路由到一个或多个队列。 5. 绑定：绑定是交换机和队列之间的关联关系，它定义了消息从交换机路由到哪个队列。 6. 路由键：路由键是生产者在发送消息时指定的关键字，交换机根据路由键将消息路由到相应的队列。 7. 消费确认：消费确认是指消费者在处理完一条消息后向RabbitMQ发送确认消息，告知RabbitMQ该消息已被成功处理。 8. 持久化：RabbitMQ支持将消息和队列进行持久化，确保消息在服务器重启后不会丢失。 9. 可靠性：RabbitMQ提供了多种机制来确保消息的可靠性，如消息确认、持久化、备份等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值