首页手记消息队列源码剖析教程：初学者指南

消息队列源码剖析教程：初学者指南

标签：

架构中间件源码

概述

消息队列源码剖析教程涵盖了从开发环境搭建到核心数据结构解析的各项内容，帮助读者深入了解消息队列的工作原理。文章详细介绍了消息发送与接收的流程，以及如何进行事务处理和持久化。此外，还提供了常见问题的排查方法及性能优化策略，使读者能够更好地掌握消息队列的使用技巧。

消息队列基本概念

什么是消息队列

消息队列是一种中间件，它在发送方应用程序和接收方应用程序之间提供了一种异步的数据传输机制。通过使用消息队列，发送方可以将消息发送到队列中，而无需等待接收方的确认。接收方可以从队列中取出消息并进行处理。这种机制使得系统更加解耦，提高了系统的可扩展性和可靠性。

消息队列的作用和应用场景

解耦

消息队列的主要作用之一是解耦系统。在传统的请求-响应模式下，发送方需要等待接收方的响应，一旦接收方出现故障，整个系统都将受到影响。使用消息队列后，发送方只需要将消息发送到队列，并继续执行后续任务，而不需要等待接收方的响应，这样大大降低了系统的耦合度。

异步处理

在高并发场景下，直接进行同步调用可能会导致系统响应变慢。使用消息队列后，请求可以被异步处理，从而提高系统的响应速度和吞吐量。例如，一个电商网站在用户下单时可以将订单信息发送到消息队列，然后立即返回响应给用户，订单处理可以在后台异步进行。

削峰填谷

在面临突发流量时，直接处理这些流量可能会导致系统性能下降甚至崩溃。使用消息队列可以起到削峰填谷的作用，将突发流量平滑处理。例如，在秒杀活动中，用户请求可能瞬间激增，通过消息队列可以将这些请求缓存起来，逐步处理，避免系统过载。

数据传输

消息队列还可以用于在分布式系统之间传输数据。例如，一个系统生成的数据可以发送到消息队列，另一个系统从队列中读取这些数据进行处理或存储。这种方式大大简化了系统之间的数据传输和同步。

持久化和事务处理

消息队列通常提供消息持久化功能，保证数据不会因为系统故障而丢失。此外，消息队列还支持事务处理，确保消息的可靠传输和处理。

消息路由

在复杂的系统中，消息可能需要被发送到多个不同的目的地。消息队列支持消息路由功能，可以根据指定的规则将消息发送到不同的队列或主题，实现灵活的数据分发。

常见的消息队列类型介绍

消息队列根据不同的实现和特性可以分为多种类型。下面是一些常见的消息队列类型：

RabbitMQ

RabbitMQ 是一个广泛使用的开源消息代理实现，支持多种消息协议，包括AMQP（高级消息队列协议）。它提供了消息路由、交换机、队列和绑定等核心功能，可以灵活地实现消息的分发和消费。RabbitMQ 支持多种编程语言，具有良好的可扩展性和可靠性。

Kafka

Kafka 是由 LinkedIn 开发的一种高吞吐量的分布式流处理平台。它最初被设计为一个日志聚合系统，但后来发展成为一种通用的分布式消息系统。Kafka 以分布式、可扩展和高吞吐量著称，广泛应用于日志聚合、流处理和实时数据分析等领域。

ActiveMQ

Apache ActiveMQ 是一个流行的开源消息代理，支持多种消息协议，包括JMS（Java消息服务）。它提供了丰富的消息路由、过滤和持久化功能，支持多种传输协议和持久化存储，适用于各种规模的应用场景。

Redis

虽然 Redis 主要是一个内存中的数据存储系统，但它也提供了消息队列功能。Redis 通过发布/订阅模式实现消息队列，支持消息的即时发布和订阅。这种方式在某些场景下可以提供高效的性能。

ZeroMQ

ZeroMQ 是一个高级别、可嵌入的软件接口，提供多种消息模式，包括点对点、发布/订阅、请求/应答等。ZeroMQ 的设计目标是提供可扩展的网络通信接口，支持在不同进程和机器之间传输数据。

RocketMQ

RocketMQ 是由阿里巴巴开源的一款高性能、高可用、分布式的消息中间件。它支持多种消息模式，包括普通消息、顺序消息、定时消息、事务消息等，适用于大规模分布式系统中的消息传输和处理。

消息队列源码环境搭建

开发环境准备

要开始消息队列的源码剖析，首先需要准备相应的开发环境。以下是一个简单的开发环境准备示例：

操作系统：Linux 或 macOS（推荐使用 Ubuntu 或 CentOS）
编译工具：GCC 或 Clang
依赖库：消息队列源码可能依赖于一些外部库，例如 Boost、ZeroMQ 等，需要确保这些库已经安装。
版本控制工具：Git 或 Mercurial，用于从版本控制系统中获取源码。
文本编辑器或IDE：如 Vim、Visual Studio Code 或 Eclipse。
调试工具：如 GDB 或 LLDB，用于调试编译后的程序。

# 示例：安装 GCC 和 Boost 库
sudo apt-get update
sudo apt-get install build-essential
sudo apt-get install libboost-all-dev

源码下载与编译

接下来，下载消息队列源码并进行编译。这里以 RabbitMQ 为例，假设已经安装了必要的依赖库。

下载源码

git clone https://github.com/rabbitmq/rabbitmq-server.git
cd rabbitmq-server

编译源码

RabbitMQ 的编译需要 Erlang/OTP 环境。确保已经安装了 Erlang。

# 安装 Erlang/OTP
sudo apt-get install erlang

# 编译 RabbitMQ
make

运行测试

编译完成后，可以运行一些简单的测试案例来验证编译是否成功。

# 运行测试
make check

运行与测试环境搭建

启动 RabbitMQ 服务

编译完成后，可以启动 RabbitMQ 服务并进行测试。

# 启动 RabbitMQ
sudo make rel/rabbitmq_server-<version>/bin/rabbitmq-server

客户端连接测试

通过客户端工具连接到 RabbitMQ 服务，验证消息的发送和接收。

# 安装 rabbitmq-cli 工具
sudo apt-get install rabbitmq-cli

# 连接到 RabbitMQ 服务并创建一个队列
rabbitmqadmin declare queue name=myqueue

# 发送消息到队列
rabbitmqadmin publish routing_key=myqueue payload="Hello World"

# 接收消息
rabbitmqadmin get queue=myqueue

客户端代码示例

这里提供一个简单的 RabbitMQ 客户端代码示例，用于发送和接收消息。

# 发送消息
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

channel.queue_declare(queue='myqueue')
channel.basic_publish(exchange='',
                      routing_key='myqueue',
                      body='Hello World!')

connection.close()

# 接收消息
import pika

connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
channel = connection.channel()

def callback(ch, method, properties, body):
    print("Received %r" % body)

channel.queue_declare(queue='myqueue')
channel.basic_consume(queue='myqueue',
                      auto_ack=True,
                      on_message_callback=callback)

channel.start_consuming()

核心数据结构解析

消息队列的核心数据结构

消息队列的实现依赖于一系列核心数据结构，包括队列、数组、链表等。这些数据结构共同构成了消息队列的基础架构。

队列

队列是消息队列中最基本的数据结构之一。队列通常用于存储待处理的消息。在实现上，队列可以是简单的数组或链表。例如，一个简单的消息队列可以使用数组来实现：

#include <vector>

class Queue {
public:
    void enqueue(int value);
    int dequeue();
    bool isEmpty() const;

private:
    std::vector<int> _data;
};

void Queue::enqueue(int value) {
    _data.push_back(value);
}

int Queue::dequeue() {
    if (isEmpty()) {
        throw std::runtime_error("Queue is empty");
    }
    int value = _data.front();
    _data.erase(_data.begin());
    return value;
}

bool Queue::isEmpty() const {
    return _data.empty();
}

消息

消息是消息队列中传输的基本单位。每个消息通常包含一个键（routing_key）、负载（payload）和其他元数据。例如：

struct Message {
    std::string routing_key;
    std::string payload;
    std::map<std::string, std::string> headers;

    void setRoutingKey(const std::string& key) {
        routing_key = key;
    }

    void setPayload(const std::string& data) {
        payload = data;
    }

    void addHeader(const std::string& key, const std::string& value) {
        headers[key] = value;
    }
};

链表

链表是一种灵活的数据结构，适用于需要动态增删节点的场景。在消息队列中，链表可以用于实现消息的分发和存储。下面是一个简单的链表实现：

#include <string>

struct ListNode {
    Message* message;
    ListNode* next;

    ListNode(Message* msg) : message(msg), next(nullptr) {}
};

class LinkedListQueue {
public:
    void enqueue(Message* message);
    Message* dequeue();
    bool isEmpty() const;

private:
    ListNode* _head;
    ListNode* _tail;
};

void LinkedListQueue::enqueue(Message* message) {
    ListNode* node = new ListNode(message);
    if (_tail) {
        _tail->next = node;
        _tail = node;
    } else {
        _head = _tail = node;
    }
}

Message* LinkedListQueue::dequeue() {
    if (_head == nullptr) {
        return nullptr;
    }

    Message* message = _head->message;
    ListNode* temp = _head;
    _head = _head->next;
    if (_head == nullptr) {
        _tail = nullptr;
    }
    delete temp;
    return message;
}

bool LinkedListQueue::isEmpty() const {
    return _head == nullptr;
}

交换机与绑定

在消息队列中，交换机（Exchange）用于将消息路由到指定的队列。绑定（Binding）则定义了队列与交换机之间的关系。下面是一个简单的交换机和绑定的实现：

class Exchange {
public:
    void bindQueue(const std::string& queueName, const std::string& routingKey);
    void routeMessage(const std::string& routingKey, const Message& message);

private:
    std::map<std::string, std::vector<std::string>> _bindings;
};

void Exchange::bindQueue(const std::string& queueName, const std::string& routingKey) {
    _bindings[routingKey].push_back(queueName);
}

void Exchange::routeMessage(const std::string& routingKey, const Message& message) {
    auto it = _bindings.find(routingKey);
    if (it != _bindings.end()) {
        for (const auto& queueName : it->second) {
            // Route message to the queue
        }
    }
}

数据结构的作用与使用场景

队列的作用

队列用于存储待处理的消息，保证消息的有序处理。队列通常用于缓存消息，避免因接收方处理速度过慢导致消息丢失。

消息的作用

消息是消息队列中的基本传输单元，包含需要传输的内容及其元数据。消息可以携带额外的元数据，如优先级、过期时间等。

链表的作用

链表用于实现灵活的消息存储和分发。链表可以动态增加或删除节点，适用于需要高效插入和删除操作的场景。

交换机与绑定的作用

交换机和绑定用于实现消息的路由和分发。交换机根据消息的键将消息路由到特定的队列，绑定定义了队列与交换机之间的关系。

数据结构示例代码讲解

下面是对一些数据结构示例代码的详细讲解。

队列

队列的实现使用了 std::vector，这是一个动态数组，可以方便地在末尾插入和删除元素。enqueue 方法将新消息添加到队列末尾，dequeue 方法从队列头部移除并返回消息。isEmpty 方法用于检查队列是否为空。

void Queue::enqueue(int value) {
    _data.push_back(value); // 将新消息添加到队列末尾
}

int Queue::dequeue() {
    if (isEmpty()) {
        throw std::runtime_error("Queue is empty"); // 如果队列为空，抛出异常
    }
    int value = _data.front(); // 获取队列头部的消息
    _data.erase(_data.begin()); // 移除队列头部的消息
    return value;
}

bool Queue::isEmpty() const {
    return _data.empty(); // 检查队列是否为空
}

链表

链表的实现使用了 ListNode 结构体，每个节点包含一个指向下一个节点的指针，以及存储的消息。enqueue 方法将新消息添加到链表尾部，dequeue 方法从链表头部移除并返回消息。

void LinkedListQueue::enqueue(Message* message) {
    ListNode* node = new ListNode(message); // 创建一个新的链表节点
    if (_tail) {
        _tail->next = node; // 将新节点连接到当前链表尾部
        _tail = node; // 更新链表尾部指针
    } else {
        _head = _tail = node; // 初始化链表头部和尾部指针
    }
}

Message* LinkedListQueue::dequeue() {
    if (_head == nullptr) {
        return nullptr; // 如果链表为空，返回 nullptr
    }

    Message* message = _head->message; // 获取链表头部的消息
    ListNode* temp = _head; // 保存链表头部节点
    _head = _head->next; // 更新链表头部指针
    if (_head == nullptr) {
        _tail = nullptr; // 如果链表为空，更新链表尾部指针
    }
    delete temp; // 删除旧的链表头部节点
    return message; // 返回链表头部的消息
}

交换机与绑定

交换机使用了一个哈希表 _bindings，用于存储绑定关系。bindQueue 方法将队列名称和路由键绑定在一起，routeMessage 方法根据路由键将消息路由到相应的队列。

void Exchange::bindQueue(const std::string& queueName, const std::string& routingKey) {
    _bindings[routingKey].push_back(queueName); // 将队列名称添加到绑定关系中
}

void Exchange::routeMessage(const std::string& routingKey, const Message& message) {
    auto it = _bindings.find(routingKey); // 查找路由键对应的绑定关系
    if (it != _bindings.end()) {
        for (const auto& queueName : it->second) {
            // Route message to the queue
            // 实际实现中，这里会将消息路由到相应的队列
        }
    }
}

消息发送与接收流程

消息发送流程详解

消息发送流程包括几个关键步骤，从创建消息到将其发送到消息队列。

创建消息

首先，需要创建一个消息对象，包含消息的负载和路由键等信息。例如：

Message message;
message.setPayload("Hello World");
message.setRoutingKey("myqueue");

配置消息队列

配置消息队列，包括连接到消息代理、声明队列等。例如：

Channel channel = connection.createChannel();
channel.queueDeclare("myqueue", false, false, false, null);

发送消息

将消息发送到指定的队列。例如：

channel.basicPublish("", "myqueue", null, message.encode().getBytes());

关闭连接

发送完成后，关闭连接以释放资源。

connection.close();

消息接收流程详解

消息接收流程也包括几个关键步骤，从连接到消息队列开始，直到消息被处理为止。

连接到消息队列

建立与消息代理的连接，声明要监听的队列。例如：

Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("myqueue", false, false, false, null);

指定消费回调

定义一个消费回调函数，用于处理接收到的消息。例如：

channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
        String message = new String(payload);
        System.out.println("Received message: " + message);
    }
});

消费消息

启动消息消费，开始接收并处理消息。

channel.startConsuming();

关闭连接

在消息消费完成后，关闭连接以释放资源。

connection.close();

发送与接收流程中的关键代码解析

发送消息的代码解析

发送消息的过程包括创建消息、配置队列和实际发送这三步。下面是一个详细的代码解析：

// 创建消息
Message message;
message.setPayload("Hello World");
message.setRoutingKey("myqueue");

// 配置消息队列
Channel channel = connection.createChannel();
channel.queueDeclare("myqueue", false, false, false, null);

// 发送消息
channel.basicPublish("", "myqueue", null, message.encode().getBytes());

创建消息：首先创建一个 Message 对象，并设置其负载和路由键。
配置消息队列：通过 createChannel 方法创建一个通道（Channel），并使用 queueDeclare 方法声明队列。
发送消息：调用 basicPublish 方法发送消息。第一个参数为空，表示使用默认的交换机；第二个参数是路由键，用于确定消息发送的目标队列；第三个参数为空，表示不携带额外的属性；最后一个参数是消息的负载。

接收消息的代码解析

接收消息的过程包括连接到队列、指定消费回调和实际消费这三步。下面是一个详细的代码解析：

// 连接到消息队列
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.queueDeclare("myqueue", false, false, false, null);

// 指定消费回调
channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
        String message = new String(payload);
        System.out.println("Received message: " + message);
    }
});

// 消费消息
channel.startConsuming();

连接到消息队列：通过 newConnection 方法建立到消息代理的连接，创建通道并声明队列。
指定消费回调：使用 basicConsume 方法注册消费回调函数。回调函数会在接收到消息时被调用。
消费消息：调用 startConsuming 方法开始接收并处理消息。

消息队列的事务处理与持久化

事务处理的概念与实现

事务处理是消息队列中的一个重要概念，它确保消息的可靠传输。通过事务处理，消息的发送和接收可以被作为原子操作处理，保证消息不会因为系统故障等原因丢失或重复发送。

事务处理的实现示例

以下是一个简单的事务处理实现示例，使用 RabbitMQ 进行消息发送和接收，并确保消息的可靠传输。

// 发送消息的事务处理
Channel channel = connection.createChannel();
channel.txSelect(); // 开始事务
try {
    channel.basicPublish("", "myqueue", null, message.getBytes());
    channel.txCommit(); // 提交事务
} catch (Exception e) {
    channel.txRollback(); // 回滚事务
}

// 接收消息的事务处理
channel.txSelect();
try {
    channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
            String message = new String(payload);
            System.out.println("Received message: " + message);
            channel.basicAck(deliveryTag, false); // 确认消息接收
        }
    });
    channel.txCommit(); // 提交事务
} catch (Exception e) {
    channel.txRollback(); // 回滚事务
}

持久化机制的实现

持久化是消息队列中的另一个重要特性，它确保消息在系统故障时不会丢失。持久化的实现通常涉及以下几个步骤：

设置消息为持久化：在发送消息时，设置消息的持久化标志。
设置队列为持久化：在声明队列时，设置队列为持久化。

示例代码

// 设置消息为持久化
MessageProperties properties = new MessageProperties();
properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
Message message = new Message("Hello World".getBytes(), properties);

// 设置队列为持久化
Channel channel = connection.createChannel();
channel.queueDeclare("myqueue", true, false, false, null); // true 表示队列为持久化

// 发送持久化消息
channel.basicPublish("", "myqueue", properties, message.getBody());

// 接收持久化消息
channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
    @Override
    public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
        String message = new String(payload);
        System.out.println("Received message: " + message);
    }
});

实战案例分析与源码剖析

案例分析

假设有一个电商系统，用户在下单时需要将订单信息发送到消息队列，然后在后台异步处理订单。如果在处理过程中系统出现故障，订单信息可能会丢失。通过事务处理和持久化机制，可以确保订单信息的可靠传输和处理。

源码剖析

下面是对 RabbitMQ 中事务处理和持久化机制的源码剖析。

事务处理

RabbitMQ 中的事务处理通过 txSelect, txCommit, 和 txRollback 方法实现。txSelect 方法开始一个事务，txCommit 方法提交事务，txRollback 方法回滚事务。

// 开始事务
channel.txSelect();

// 发送消息
channel.basicPublish("", "myqueue", null, message.getBytes());

// 提交事务
channel.txCommit();

持久化

RabbitMQ 支持消息持久化和队列持久化。消息持久化通过设置 MessageProperties 的 DeliveryMode 属性实现，队列持久化通过 queueDeclare 方法的参数实现。

// 设置消息为持久化
MessageProperties properties = new MessageProperties();
properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);

// 发送持久化消息
channel.basicPublish("", "myqueue", properties, message.getBytes());

// 设置队列为持久化
channel.queueDeclare("myqueue", true, false, false, null);

通过上述源码剖析，可以更好地理解事务处理和持久化的实现细节，确保消息的可靠传输和处理。

常见问题排查与优化建议

常见问题与错误排查

在使用消息队列时，可能会遇到各种问题和错误。下面是一些常见的问题及排查方法。

1. 消息丢失

现象：在发送消息后，接收方没有收到消息。

原因：

消息未设置持久化。
消息发送端和接收端之间网络不稳定。
消息队列代理出现故障。

排查方法：

确保消息设置为持久化。
检查网络连接状态。
查看消息队列代理的日志。

2. 消息重复

现象：接收方多次接收到同一个消息。

原因：

接收方未能正确确认消息接收。
消息队列代理重启时未正确回滚未确认的消息。

排查方法：

确保接收端正确确认消息。
检查消息队列代理的配置，确保消息确认机制正确。

3. 性能下降

现象：消息队列的吞吐量下降。

原因：

消息队列代理或接收端的资源限制。
网络带宽限制。

排查方法：

监控消息队列代理和接收端的资源使用情况。
测试网络带宽限制。

性能优化策略与方法

1. 调整消息队列代理的配置

示例：

# 调整 RabbitMQ 的配置
rabbitmqctl set_policy ha-all . '{"ha-mode": "all"}'

2. 升级硬件资源

示例：

# 增加服务器内存和 CPU 核心数
sudo apt-get install morememory
sudo apt-get install morecpu

3. 使用高性能的网络设备

示例：

# 更新网络硬件
sudo apt-get install betternetwork

源码级别的优化建议与技巧

1. 优化消息队列的核心数据结构

示例：

// 优化链表实现
class LinkedListQueue {
public:
    void enqueue(Message* message);
    Message* dequeue();
    bool isEmpty() const;

private:
    ListNode* _head;
    ListNode* _tail;
    std::mutex _lock;
};

void LinkedListQueue::enqueue(Message* message) {
    std::lock_guard<std::mutex> lock(_lock);
    ListNode* node = new ListNode(message);
    if (_tail) {
        _tail->next = node;
        _tail = node;
    } else {
        _head = _tail = node;
    }
}

Message* LinkedListQueue::dequeue() {
    std::lock_guard<std::mutex> lock(_lock);
    if (_head == nullptr) {
        return nullptr;
    }

    Message* message = _head->message;
    ListNode* temp = _head;
    _head = _head->next;
    if (_head == nullptr) {
        _tail = nullptr;
    }
    delete temp;
    return message;
}

2. 优化消息发送和接收流程

示例：

// 优化消息发送流程
void sendMessage(Channel& channel, const Message& message) {
    channel.txSelect();
    try {
        channel.basicPublish("", "myqueue", message.getProperties(), message.getBytes());
        channel.txCommit();
    } catch (Exception& e) {
        channel.txRollback();
    }
}

// 优化消息接收流程
void receiveMessage(Channel& channel) {
    channel.txSelect();
    try {
        channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
                String message = new String(payload);
                System.out.println("Received message: " + message);
                channel.basicAck(deliveryTag, false);
            }
        });
        channel.txCommit();
    } catch (Exception& e) {
        channel.txRollback();
    }
}

3. 优化消息队列代理的配置

示例：

# 优化 RabbitMQ 的配置
rabbitmqctl set_policy ha-all . '{"ha-mode": "all"}'
rabbitmqctl set_policy ack-all . '{"ha-mode": "all", "ha-sync-mode": "async"}'
rabbitmqctl set_policy persist-all . '{"ha-mode": "all", "ha-sync-mode": "async", "queue-mode": "persist"}'

4. 调整消息存储和传输的策略

示例：

// 调整消息发送策略
void sendMessage(Channel& channel, const Message& message) {
    MessageProperties properties = message.getProperties();
    properties.setDeliveryMode(MessageDeliveryMode.PERSISTENT);
    channel.basicPublish("", "myqueue", properties, message.getBytes());
}

// 调整消息接收策略
void receiveMessage(Channel& channel) {
    channel.basicConsume("myqueue", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(Channel channel, ConsumerTag consumerTag, String deliveryTag, boolean redelivered, byte[] payload, Map<String, List<QueueingConsumer.Delivery>> headers) {
            String message = new String(payload);
            System.out.println("Received message: " + message);
            channel.basicAck(deliveryTag, false);
        }
    });
}

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

烙印99

手记
篇

粉丝

92

获赞与收藏

446

关注作者，订阅最新文章

阅读免费教程

MySQL 进阶教程

32个小节 51500 963

Scrapy 入门教程

27个小节 10515 253

后端通用面试教程

41个小节 30787 345

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

消息队列源码剖析教程：初学者指南

解耦

异步处理

削峰填谷

数据传输

持久化和事务处理

消息路由

RabbitMQ

Kafka

ActiveMQ

Redis

ZeroMQ

RocketMQ

下载源码

编译源码

运行测试

启动 RabbitMQ 服务

客户端连接测试

客户端代码示例

队列

消息

链表

交换机与绑定

队列的作用

消息的作用

链表的作用

交换机与绑定的作用

队列

链表

交换机与绑定

创建消息

配置消息队列

发送消息

关闭连接

连接到消息队列

指定消费回调

消费消息

关闭连接

发送消息的代码解析

接收消息的代码解析

事务处理的实现示例

持久化机制的实现

示例代码

案例分析

源码剖析

事务处理

持久化

1. 消息丢失

2. 消息重复

3. 性能下降

1. 调整消息队列代理的配置

2. 升级硬件资源

3. 使用高性能的网络设备

1. 优化消息队列的核心数据结构

2. 优化消息发送和接收流程

3. 优化消息队列代理的配置

4. 调整消息存储和传输的策略

阅读免费教程