关于RabbitMQ面试题汇总

逃离我推掉我的手 2024-05-06 09:51 9阅读 0赞

### 什么是消息队列？消息队列有什么用？ ###

消息队列是一种在应用程序之间传递消息的通信机制。它是一种典型的生产者-消费者模型，其中生产者负责生成消息并将其发送到队列中，而消费者则从队列中获取消息并进行处理。消息队列的主要目的是解耦生产者和消费者，使它们可以独立地进行工作，从而提高系统的可扩展性、可靠性和灵活性。它可以用于以下几个方面：

1.  **解耦系统组件**：通过引入消息队列，系统中的不同组件可以通过消息进行通信，而无需直接依赖于彼此的实现细节。这样可以使系统更加灵活，降低组件之间的耦合度
2.  **异步处理**：消息队列可以使生产者和消费者之间的通信变为异步的，生产者无需等待消费者处理消息就可以继续执行其他任务。这可以提高系统的响应速度和吞吐量
3.  **削峰填谷**：消息队列可以作为一个缓冲区，帮助平衡生产者和消费者之间的速度差异。当生产者产生的消息量超过消费者处理的能力时，消息队列可以暂时存储消息，防止系统因消息堆积而崩溃
4.  **可靠性传输**：消息队列通常提供可靠性传输的机制，确保消息在传输过程中不会丢失或损坏。这对于需要确保数据完整性和可靠性的系统非常重要
5.  **实现分布式系统**：消息队列可以用于构建分布式系统，通过在不同节点之间传递消息来实现协作和通信。这对于构建大规模、高可用性的分布式系统非常有用

### 消息队列有几种实现方式？它们有什么区别？ ###

**常见的消息队列：**

1.  **ActiveMQ**
    
    1.  ActiveMQ是基于Java Message Service (JMS) 规范的开源消息队列软件，它使用了传统的基于队列（Queue）和发布-订阅（Topic）模式
    2.  ActiveMQ支持多种通信协议，包括OpenWire、STOMP、AMQP等。它具有广泛的语言支持，适用于Java和其他语言的开发
    3.  ActiveMQ具有较高的可靠性和稳定性，但在处理大规模高并发消息时性能可能有所局限
    4.  它支持多种消息传递模式，包括点对点和发布/订阅模式。ActiveMQ具有较高的可靠性、可扩展性和性能，并提供了丰富的功能，如消息持久化、事务支持等
2.  **RabbitMQ**
    
    1.  RabbitMQ是一个基于AMQP（Advanced Message Queuing Protocol）的开源消息队列系统，它实现了高级的队列功能，并提供了可靠消息传输的保证
    2.  RabbitMQ支持多种编程语言和通信协议，以及灵活的消息路由和可靠的消息确认机制
    3.  RabbitMQ提供了丰富的插件机制，使得它可以与其他系统集成，如Spring、Celery等
    4.  RabbitMQ适用于大规模高并发消息处理，并具有较好的性能和可靠性
    5.  RabbitMQ是一个可靠、灵活且易于使用的开源消息队列软件
    6.  它实现了高级消息队列协议 (AMQP)，支持多种编程语言，并提供了丰富的功能和工具
    7.  RabbitMQ具有高可靠性、可扩展性和灵活性，并提供了多种消息传递模式和高级特性，如消息持久化、消息路由和消息确认机制等
3.  **RocketMQ**
    
    1.  RocketMQ是阿里巴巴开源的分布式消息队列系统，它采用了基于主题（Topic）的消息模型，支持包括顺序消息、事务消息等在内的多种特性
    2.  RocketMQ具有高吞吐量、低延迟和高可靠性的优势，并能够处理大规模的消息流
    3.  它适用于高性能、高可靠性的消息通信场景，如分布式事务、日志收集和流式数据处理等
    4.  RocketMQ采用了基于主题的发布/订阅模式，支持消息顺序传递和事务消息，并具有强大的可扩展性和灵活的架构设计
4.  **Kafka**
    
    1.  Kafka是由Apache软件基金会开发的分布式流处理平台和消息队列系统，一个开源的分布式流处理平台，用于构建高可靠性的实时数据管道和流式处理应用程序
    2.  Kafka具有高吞吐量、持久化和可扩展性，并支持实时流处理和大规模数据处理。它适用于构建实时流处理应用程序，并提供了丰富的功能和工具来处理大规模的数据流
    3.  Kafka使用基于发布-订阅（Topic）的消息模型，支持高并发的写入和读取操作。它适用于实时数据流处理、协同过滤、日志收集和批处理等场景。Kafka具有高性能和可靠性，并能够处理大规模的消息流

ActiveMQ、RabbitMQ、RocketMQ、Kafka是常用的消息队列中间件，能够实现异步消息的发送和接收

**区别：**

1.  **消息传递模型**
    
    1.  ActiveMQ：基于JMS（Java Message Service）标准，支持点对点和发布/订阅模式
    2.  RabbitMQ：支持AMQP（Advanced Message Queuing Protocol）协议，可以实现广泛的消息传递模式
    3.  RocketMQ：类似于Kafka，支持高吞吐量的分布式消息传递
    4.  Kafka：支持多个生产者和消费者的发布/订阅模式，通过高吞吐量和持久化日志来保证消息的可靠传递
2.  **消息持久化**
    
    1.  ActiveMQ：支持持久化消息，可以将消息保存到磁盘上，确保消息不会丢失
    2.  RabbitMQ：默认情况下，消息是持久化的，可以将消息保存到磁盘上或者通过镜像队列复制到其他节点
    3.  RocketMQ：支持消息的持久化，可以将消息保存到磁盘上，确保消息不会丢失
    4.  Kafka：通过持久化日志来保证消息的可靠传递，消息被写入磁盘并且可以进行复制，可以进行高效的消息重放
3.  **消息顺序性**
    
    1.  ActiveMQ：可以保证消息的顺序性，在同一个队列中，消息将按照发送的顺序进行处理
    2.  RabbitMQ：可以通过设置队列的顺序属性来保证消息的顺序性
    3.  RocketMQ：可以在消息生产者端保证消息的顺序性，将相关的消息发送到同一个队列中进行处理
    4.  Kafka：在分区内保证消息的顺序性，但是对于整个主题的消息顺序无法保证
4.  **可靠性**
    
    1.  ActiveMQ：支持可靠性消息传递，可以进行事务支持和消息确认机制
    2.  RabbitMQ：支持可靠性消息传递，可以进行消息确认机制和持久化
    3.  RocketMQ：支持可靠性消息传递，可以通过同步或异步方式发送消息，并支持消息的重试和拉取机制
    4.  Kafka：通过分区和复制机制来保证消息的可靠传递，具有较高的可靠性
5.  **生态系统和社区支持**
    
    1.  ActiveMQ：拥有较大的用户群体和活跃的社区支持
    2.  RabbitMQ：拥有丰富的插件和可扩展性，有大量的开源社区支持
    3.  RocketMQ：阿里巴巴开源的项目，拥有较大的用户群体和活跃的社区支持
    4.  Kafka：被广泛应用于大数据处理和实时流处理领域，拥有庞大的生态系统和活跃的社区支持

总体来说，这些消息队列中间件各有特点，选择适合自己需求的消息队列是根据具体应用场景和需求来决定的。

### 如何使用Java程序实现一个简单的消息队列？ ###

生产者代码：

package com.rabbitmq.one;
    
    import com.rabbitmq.client.Channel;
    import com.rabbitmq.client.Connection;
    import com.rabbitmq.client.ConnectionFactory;
    
    import java.io.IOException;
    import java.nio.charset.StandardCharsets;
    import java.util.concurrent.TimeoutException;
    
    /**
     * 生产者：发消息
     */
    
    public class Produce {
        public static final String QUEUE_NAME="hello";
    
        public static void main(String[] args) throws IOException, TimeoutException {
            //创建工厂
            ConnectionFactory factory = new ConnectionFactory();
            //工厂IP连接rabbitmq
            factory.setHost("118.31.6.132");
            //用户名
            factory.setUsername("admin");
            //密码
            factory.setPassword("123");
            //创建连接
            Connection connection = factory.newConnection();
            //获取信道
            Channel channel = connection.createChannel();
            /*
             *生成一个队列
             * 1.队列名称
             * 2.队列里面的信息是否持久化（磁盘）默认情况时在内存
             * 3.该队列是否只供一个消费者进行消费 是否消费共享 true是允许
             * 4.是否自动删除 最后一个消费者断开连接之后 该队列是否自动删除 true自动删除 false不自动删除
             * 5.其他参数 延迟消息等
             */
            channel.queueDeclare(QUEUE_NAME,false,false,false,null);
            //发消息
            String message = "hello world";
            /**
             * 发送一个消息
             * 1.发送到那个交换机
             * 2.路由的KEY值是哪个 本次是队列的名称
             * 3.其他参数信息
             * 4.发送消息的消息体
             */
            channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
            System.out.println("消息发送完毕！");
        }
    }

消费者代码：

package com.rabbitmq.one;
    
    import com.rabbitmq.client.*;
    
    import java.io.IOException;
    import java.util.Collections;
    import java.util.concurrent.TimeoutException;
    
    /**
     * 消费者
     */
    public class Consume {
        //队列名称
        public static final String QUEUE_NAME = "hello";
        //接受消息
        public static void main(String[] args) throws IOException, TimeoutException {
            //创建连接工厂
            ConnectionFactory factory = new ConnectionFactory();
            factory.setHost("118.31.6.132");
            factory.setUsername("admin");
            factory.setPassword("123");
            Connection connection = factory.newConnection();
            Channel channel = connection.createChannel();
            //声明 接受消息
            DeliverCallback deliverCallback = (consumerTag,message)->{
                System.out.println(new String(message.getBody()));
            };
            //取消消息的回调
            CancelCallback cancelCallback = consumerTag->{
                System.out.println("消息消费被中断");
            };
             /**
             * 消费者信息
             * 1.消费哪个队列
             * 2.消费成功之后是否要自动应答 true自动应答 false手动应答
             * 3.消费者微车才能更改消费的回调
             * 4.消费者取消消费回调
             */
            channel.basicConsume(QUEUE_NAME,true, deliverCallback,cancelCallback);
        }
    }

### RabbitMQ、Kafka和RocketMQ有什么区别？ ###

RabbitMQ、Kafka和RocketMQ是三种不同的消息队列中间件，它们在设计理念、特性和适用场景上有所不同：

1.  **RabbitMQ**：
    
     *  设计理念：RabbitMQ是基于AMQP（Advanced Message Queuing Protocol）的消息队列系统，旨在提供高可靠性、可靠消息传输的保证以及灵活的消息路由和可靠的消息确认机制
     *  特点：RabbitMQ提供了丰富的插件机制，使得它可以与其他系统集成，并提供了可靠的消息传输保证。它适用于需要强调可靠性、灵活性和易用性的场景
     *  适用场景：RabbitMQ适用于大多数的企业应用场景，如异步任务处理、日志收集、消息通知等
2.  **Kafka**：
    
     *  设计理念：Kafka是由Apache软件基金会开发的分布式流处理平台和消息队列系统，旨在构建实时数据管道和流式处理应用程序
     *  特点：Kafka具有高吞吐量、持久化和可扩展性，并支持实时流处理和大规模数据处理。它适用于构建实时流处理应用程序，并提供了丰富的功能和工具来处理大规模的数据流
     *  适用场景：Kafka适用于需要处理大规模数据流、实时数据分析、事件驱动架构等场景
3.  **RocketMQ**：
    
     *  设计理念：RocketMQ是阿里巴巴开源的分布式消息队列系统，旨在提供高吞吐量、低延迟和高可靠性的消息通信
     *  特点：RocketMQ采用了基于主题的消息模型，支持多种特性如顺序消息、事务消息等，并具有强大的可扩展性和灵活的架构设计
     *  适用场景：RocketMQ适用于高性能、高可靠性的消息通信场景，如分布式事务、日志收集和流式数据处理等

总的来说，RabbitMQ侧重于可靠性、灵活性和易用性，适用于大多数企业应用场景；Kafka侧重于处理大规模数据流、实时流处理和事件驱动架构；RocketMQ侧重于高吞吐量、低延迟和高可靠性的消息通信。选择合适的消息队列中间件取决于具体的需求和应用场景

### RabbitMQ有几种消息类型？ ###

![06e59fd592224a84862fc27d04d1b04a.png][]

RabbitMQ主要提供了以下几种消息类型：

1.  **简单模式（Simple）**：生产者发送消息到队列，消费者从队列获取消息
2.  **工作模式（Work）**：与简单模式类似，但它允许多个消费者同时从一个队列获取消息
3.  **发布/订阅模式（Publish/Subscribe）**：生产者将消息发送到交换机（Exchange），多个队列可以绑定到这个交换机，从而实现一个消息被多个消费者获取
4.  **路由模式（Routing）**：生产者将消息和一个路由键（Routing Key）一起发送到交换机，只有队列的绑定键（Binding Key）与路由键完全匹配，才会接收到消息
5.  **通配符模式（Topics）**：它是路由模式的升级版，它允许在绑定键和路由键之间进行模糊匹配

这些类型的选择取决于你的具体需求，例如，你是否需要一个消息被多个消费者接收，或者你是否需要根据某种条件来过滤消息等等

### RabbitMQ是如何组成的？它有哪些重要的组件？ ###

RabbitMQ主要由以下几个重要组件组成：

1.  **Broker**：这是消息代理，主要负责接收、存储和转发消息
2.  **Exchanges**：交换器，它的主要作用是根据一定的规则匹配消息和队列
3.  **Queues**：队列，这是存储消息的地方
4.  **Bindings**：绑定，它是连接交换器和队列的规则
5.  **Producers**：生产者，它的主要作用是发送消息到交换器

这些组件共同工作，使得RabbitMQ能够提供强大的消息队列功能

### RabbitMQ如何保证消息的可靠性的？ ###

RabbitMQ通过以下几种方式来保证消息的可靠性：

1.  **开启事务或者开启confirm模式**：这两种方式都可以保证消息不丢失。事务模式会在消息发送过程中加锁，确保消息的可靠性，但是性能较低。而confirm模式则是在消息发送后，Broker会给生产者一个确认应答，告知消息已经正确到达，这种方式性能较高
2.  **开启RabbitMQ持久化**：RabbitMQ提供了持久化功能，包括交换机、队列、消息的持久化。这样即使RabbitMQ服务重启，消息也不会丢失
3.  **关闭RabbitMQ自动ack，改成手动确认**：这样可以防止消费者在处理消息过程中出现异常导致消息丢失的情况。当消费者收到消息并处理完成后，会给Broker发送一个ack应答，Broker收到应答后才会删除这条消息。如果Broker没有收到应答，那么这条消息会被重新投递给其他消费者

### RabbitMQ能保证消息的顺序性吗？怎么保证消息的顺序性？ ###

RabbitMQ可以保证消息的顺序性，主要通过以下方式实现：

1.  **创建多个队列**：每个消费者固定消费一个队列的消息，这样就可以保证每个消费者处理的消息是有序的
2.  **生产者发送消息时，同一个订单号的消息发送到同一个队列中**：由于同一个队列的消息是一定会保证有序的，那么同一个订单号的消息就只会被一个消费者顺序消费

这样，RabbitMQ就可以保证消息的顺序性了。但需要注意的是，这种方式需要在生产者端进行一定的控制，以确保同一个订单号的消息被发送到同一个队列中。同时，消费者端也需要进行相应的处理，以确保消息的顺序消费

### RabbitMQ如何保证幂等性？ ###

RabbitMQ可以通过以下方式来保证幂等性：

1.  **每个消息用一个唯一标识来区分**：消费前先判断标识有没有被消费过，若已消费则不再消费
2.  **利用数据库的乐观锁机制**：执行更新操作前先去数据库查询version，然后执行更新语句，以version作为条件
3.  **使用Redis的命令**：Redis中的set命令天然支持幂等，消息消费时，只需要用set命令来判断消息是否被消费过即可
4.  **全局唯一ID + Redis**：生产者在发送消息时，为每条消息设置一个全局唯一的messageId，消费者拿到消息后，使用setnx命令，将messageId作为key放到redis中：setnx (messageId,1)，若返回1，说明之前没有消费过，正常消费；若返回0，说明这条消息之前已消费过，抛弃

以上就是RabbitMQ保证幂等性的主要方式。但需要注意的是，这种方式需要在生产者端进行一定的控制，以确保同一个订单号的消息被发送到同一个队列中。同时，消费者端也需要进行相应的处理，以确保消息的顺序消费

### 说一下RabbitMQ中的死信队列？如何实现死信队列 ###

死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列

**消息变成死信有以下几种情况：**

1.  消息被拒绝(basic.reject / basic.nack)，并且requeue = false
2.  消息TTL过期
3.  队列达到最大长度

#### 死信的处理方式 ####

死信的产生既然不可避免，那么就需要从实际的业务角度和场景出发，对这些死信进行后续的处理，常见的处理方式大致有下面几种：

1.  丢弃，如果不是很重要，可以选择丢弃
2.  记录死信入库，然后做后续的业务分析或处理
3.  通过死信队列，由负责监听死信的应用程序进行处理

综合来看，更常用的做法是第三种，即通过死信队列，将产生的死信通过程序的配置路由到指定的死信队列，然后应用监听死信队列，对接收到的死信做后续的处理。

### 什么是延迟队列？它的使用场景有哪些？ ###

延迟队列是一种特殊的消息队列，进入该队列的消息会被延迟消费。也就是说，消息一旦入队了之后并不会立即被消费者消费，而是需要等待一段时间后才能被消费。延迟队列的使用场景非常广泛，以下是一些常见的例子

1.  **延迟消费**：例如，用户生成订单之后，需要过一段时间校验订单的支付状态，如果订单仍未支付则需要及时地关闭订单
2.  **用户活跃度检查**：例如，用户注册成功之后，需要过一段时间比如一周后校验用户的使用情况，如果发现用户活跃度较低，则发送邮件或者短信来提醒用户使用
3.  **延迟重试**：例如，消费者从队列里消费消息时失败了，但是想要延迟一段时间后自动重试

以上就是延迟队列的基本概念以及一些常见的使用场景。在实际开发过程中，根据具体的业务需求，延迟队列可以有更多的应用场景

### RabbitMQ如何实现延迟队列？ ###

RabbitMQ实现延迟队列主要有两种方式：

1.  **利用RabbitMQ的TTL（Time To Live）特性和死信队列**：消息在TTL设置的时间内没有被消费，则会成为“死信”并进入死信队列。具体步骤如下：
    
     *  声明一个普通队列，比如叫`queue_normal`
     *  声明一个死信队列，比如叫`queue_dead`
     *  为`queue_normal`设置参数`x-dead-letter-exchange`和`x-dead-letter-routing-key`，值分别为`queue_dead`的交换器和路由键
     *  当`queue_normal`中的消息变为“死信”时，这些消息会被自动路由到`queue_dead`
2.  **使用RabbitMQ的插件 `rabbitmq_delayed_message_exchange`**：这是一个官方提供的插件，可以直接用来实现延迟队列。具体步骤如下：
    
     *  下载并安装`rabbitmq_delayed_message_exchange`插件
     *  在消息发送时，设置消息的`x-delay`属性，该属性表示消息延迟的时间
     *  消息会在`x-delay`设置的时间后被投递到消费者

以上就是RabbitMQ实现延迟队列的主要方式。需要注意的是，这两种方式都需要在生产者端进行一定的控制，以确保消息的延迟投递。同时，消费者端也需要进行相应的处理，以确保消息的顺序消费

### RabbitMQ怎么保证高可用的？ ###

RabbitMQ保证高可用主要通过以下几种方式：

1.  **集群部署**：RabbitMQ可以通过搭建集群来提高其高可用性。集群中的每个节点都可以处理消息，如果某个节点出现故障，其他节点仍然可以继续处理消息
2.  **镜像队列**：RabbitMQ提供了镜像队列的功能，可以将队列的数据同步到多个节点，这样即使某个节点出现故障，其他节点上的镜像队列仍然可以提供服务
3.  **持久化**：RabbitMQ提供了持久化机制，可以将交换器、队列、消息进行持久化，这样即使RabbitMQ服务重启，消息也不会丢失
4.  **消息确认机制**：RabbitMQ提供了消息确认机制，包括生产者的confirm机制和消费者的ack机制，可以确保消息在网络环境不稳定的情况下也能正确地被发送和接收
5.  **同城双活部署架构**：RabbitMQ集群采用同城双活部署架构，依靠MQ-SDK和MQ-NameServer提供的集群寻址、故障快速切换等能力保障集群的可用性

以上就是RabbitMQ保证高可用的主要方式。需要注意的是，这些方式需要在RabbitMQ的配置和使用中进行适当的设置和操作

### Kafka为什么运行这么快？ ###

Kafka的高速运行主要归功于以下几种优化方式：

1.  **顺序写入**：Kafka中每个分区是一个有序的，不可变的消息序列，新的消息不断追加到partition的末尾，这就是顺序写。顺序写入可以提高磁盘I/O的性能，因为磁盘最喜欢顺序I/O
2.  **零拷贝技术**：Kafka在读取的时候使用了零拷贝技术，降低对文件的拷贝次数，一定程度上提升了速度
3.  **大量使用页缓存**：Kafka充分利用了操作系统的页缓存来提高I/O效率。页缓存是操作系统对数据文件的读写提供的一种缓冲技术，目的是为了减少I/O操作的次数
4.  **利用Partition实现并行处理**：每个Topic都包含一个或多个Partition，不同Partition可位于不同节点，因此可以充分利用集群优势，实现机器间的并行处理

以上就是Kafka能够快速运行的主要原因。需要注意的是，这些优化方式需要在Kafka的配置和使用中进行适当的设置和操作

### 说一下Kafka的选举流程？ ###

Kafka的选举流程主要是以下几步：

1.  **创建Leader父节点**：在Zookeeper中创建一个名为/kafka的持久节点
2.  **各客户端竞争Leader**：各客户端在/kafka下创建Leader节点，如/kafka/leader，这个节点被设置为ephemeral\_sequential类型，表示这是一个临时的顺序节点
3.  **获取所有子节点并比较**：客户端通过getChildren方法获取/kakfa/下所有子节点，然后比较其注册的节点的id和所有子节点中的id，如果其id在所有子节点中最小，则当前客户端竞选Leader成功
4.  **处理Leader故障**：如果Leader由于某些原因（如网络故障或者异常退出）与Zookeeper断开连接，那么其他broker通过watch收到控制器变更的通知，就会去尝试创建临时节点/controller，如果有一个Broker创建成功，那么其他broker就会收到创建异常通知，也就意味着集群中已经有了控制器，其他Broker只需创建watch对象即可
5.  **防止控制器脑裂**：为了解决Controller脑裂问题，ZooKeeper中还有一个与Controller有关的持久节点/controller\_epoch，存放的是一个整形值的epoch number（纪元编号，也称为隔离令牌），集群中每选举一次控制器，就会通过Zookeeper创建一个数值更大的epoch number，如果有broker收到比这个epoch数值小的数据，就会忽略消息

[06e59fd592224a84862fc27d04d1b04a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/06/9413c13e89084f46a6c54928d8d9c553.png