首页手记 MQ底层原理资料详解：新手入门指南

MQ底层原理资料详解：新手入门指南

标签：

中间件

本文深入探讨了MQ消息队列的基础概念、工作流程及常见类型，提供了丰富的MQ底层原理资料，包括消息传输机制、存储机制和可靠性保障等，同时介绍了MQ的容错与扩展性设计以及性能优化技巧。

MQ基础概念解析

什么是MQ

消息队列（Message Queue，简称MQ）是一种先进先出（FIFO）的数据结构，它用于在分布式系统中传递和存储消息。MQ允许应用程序异步通信，这意味着发送者不需要等待接收者的响应就可以继续执行其他任务。消息队列通常用于解耦应用程序组件、负载均衡、任务分发和异步处理等场景。

MQ的主要功能和用途

MQ的主要功能包括：

解耦：MQ可以将不同组件之间的依赖关系解耦，使各个组件独立运行，提高系统的灵活性和可维护性。
负载均衡：消息队列可以将请求分发到多个处理节点，实现负载均衡，提高系统的处理能力和稳定性。
异步处理：发送消息的组件可以立即返回，而不需要等待接收者处理完消息，从而提高响应速度。
削峰填谷：在高并发场景下，MQ可以缓存一部分消息，防止瞬时请求量过大导致系统崩溃。

MQ的典型用途包括：

日志收集：将日志信息发送到消息队列，再由专门的日志处理服务进行集中处理。
事件通知：通过消息队列实现各个服务之间的事件通知。
任务调度：将任务放入消息队列，再由专门的任务调度服务处理。
系统解耦：通过消息队列将不同系统模块解耦，提高系统的灵活性。

以下是通过RabbitMQ实现日志收集的代码实例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class LogProducer {
    private final static String QUEUE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(QUEUE_NAME, "fanout");
        String message = "Log message: Hello World!";
        channel.basicPublish(QUEUE_NAME, "", null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");
        connection.close();
    }
}

MQ的常见类型介绍

MQ的常见类型包括：

Kafka：一种高吞吐量的分布式流处理平台，常用于日志收集、网站活动跟踪和聚合等实时数据处理场景。
RabbitMQ：一个成熟的AMQP（高级消息队列协议）实现，支持多种消息模式，包括工作队列、发布/订阅等。
ActiveMQ：基于Java的开源消息中间件，支持多种传输协议，如JMS、Stomp等。
RocketMQ：阿里云开源的消息队列，支持分布式事务、消息轨迹查询等功能，常用于大规模分布式系统中。
RabbitMQ和Kafka对比：RabbitMQ侧重于消息的可靠传递和灵活的消息路由，适用于一般的消息传递场景；而Kafka侧重于高吞吐量和持久化，适合于日志收集和流处理场景。

MQ工作流程概述

发送消息的基本流程

发送消息的基本流程包括以下几个步骤：

创建连接：发送者首先需要创建一个到MQ服务器的连接。
创建会话：在连接基础上创建一个会话，用于控制消息的生产和消费。
创建生产者：会话下创建一个生产者，用于发送消息。
创建消息对象：创建一个包含消息内容的消息对象。
发送消息：将消息通过生产者发送到MQ服务器。
关闭连接：发送完毕后关闭连接，释放资源。

以下是使用RabbitMQ发送消息的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class Producer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");
        channel.close();
        connection.close();
    }
}

消息的传输机制

消息的传输机制包括以下几个方面：

消息路由：消息队列通常使用某种路由机制将消息发送到合适的队列或主题。
消息确认：发送方需要确认消息是否成功发送，接收方需要确认消息是否成功接收。
消息传递模式：包括发布/订阅模式和点对点模式等。

发布/订阅模式

发布/订阅模式中，消息发送者（发布者）将消息发布到一个主题（topic），多个消息接收者（订阅者）可以订阅该主题，接收到消息后进行处理。

以下是使用RabbitMQ实现发布/订阅模式的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class EmitLog {
    private final static String EXCHANGE_NAME = "logs";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        String message = "Hello World!";
        channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "'");
        connection.close();
    }
}

点对点模式

点对点模式中，消息发送者将消息发送到特定的队列中，接收者从指定队列中接收消息。

以下是使用RabbitMQ实现点对点模式的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP;

public class Consumer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String receivedMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + receivedMessage + "'");
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

消息的接收流程

消息的接收流程包括以下几个步骤：

创建连接：接收者首先需要创建一个到MQ服务器的连接。
创建会话：在连接基础上创建一个会话，用于控制消息的生产和消费。
创建消费者：会话下创建一个消费者，用于接收消息。
接收消息：接收者从消息队列中接收消息。
处理消息：对接收到的消息进行处理。
确认消息：确认消息已被成功处理。
关闭连接：处理完毕后关闭连接，释放资源。

以下是使用RabbitMQ接收消息的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP;

public class Consumer {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String receivedMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + receivedMessage + "'");
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

MQ消息队列的存储机制

数据存储方式介绍

消息队列的存储方式主要有以下几种：

内存存储：将消息暂存于内存中，速度快但不持久化。
文件存储：将消息持久化到文件系统中，速度较慢但更可靠。
数据库存储：将消息存储在数据库中，可以提供更高级的查询和管理功能。

以下是使用RabbitMQ实现内存和文件存储的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class Producer {
    private final static String QUEUE_NAME = "memoryQueue";
    private final static String QUEUE_NAME_PERSISTENT = "persistentQueue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        // 创建非持久化队列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "' to memory queue");

        // 创建持久化队列
        channel.queueDeclare(QUEUE_NAME_PERSISTENT, true, false, false, null);
        channel.basicPublish("", QUEUE_NAME_PERSISTENT, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "' to persistent queue");

        channel.close();
        connection.close();
    }
}

数据持久化与非持久化区别

数据持久化与非持久化的主要区别在于：

持久化数据：消息队列会将消息持久化到磁盘上，即使服务器宕机也能保证消息不丢失。
非持久化数据：消息队列不会将消息持久化到磁盘上，一旦服务器宕机消息会丢失。

持久化数据提供了更好的可靠性，但会增加存储成本和读写速度。非持久化数据则速度快、成本低，但可靠性较差。

存储优化策略

存储优化策略包括以下几个方面：

压缩存储：对消息进行压缩存储，减少存储空间占用。
分片存储：将大型消息拆分成多个小段分别存储。
缓存机制：利用缓存机制减少磁盘IO操作。
清理策略：设置合理的过期时间，及时清理过期消息。
分布式存储：将消息分散存储在多个节点上，提高存储容量和可靠性。

以下是使用RabbitMQ实现压缩存储的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;

public class ProducerWithCompression {
    private final static String QUEUE_NAME = "compressedQueue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        byte[] compressedMessage = compressMessage(message.getBytes("UTF-8"));
        channel.basicPublish("", QUEUE_NAME, null, compressedMessage);
        System.out.println(" [x] Sent '" + message + "' as compressed message");
        channel.close();
        connection.close();
    }

    private static byte[] compressMessage(byte[] message) {
        try {
            Deflater deflater = new Deflater();
            deflater.setInput(message);
            deflater.finish();
            byte[] compressed = new byte[message.length];
            int compressedLength = deflater.deflate(compressed);
            byte[] result = new byte[compressedLength];
            System.arraycopy(compressed, 0, result, 0, compressedLength);
            return result;
        } catch (Exception e) {
            throw new RuntimeException("Error compressing message", e);
        }
    }
}

MQ消息传输的可靠性保障

传输过程中的常见问题

在消息传输过程中，常见的问题包括：

消息丢失：消息发送后未能成功传递到接收方。
消息重复：消息可能在传输过程中被多次发送。
消息顺序错误：消息的顺序可能在传输过程中被打乱。
消息延迟：消息在传输过程中延迟到达接收方。
消息篡改：消息可能在传输过程中被篡改。

确保消息可靠性的方法

确保消息可靠性的方法有：

持久化：将消息持久化到磁盘上，确保消息不丢失。
确认机制：发送者和接收者之间通过确认机制确保消息已被正确接收。
幂等性：确保消息处理的幂等性，即使消息重复发送也不会产生重复结果。
消息顺序：通过有序队列或序列号等方式确保消息按顺序传输。
重试机制：在消息发送失败时通过重试机制重新发送消息。
消息订阅：确保消息被正确订阅，防止消息被遗漏。

以下是使用RabbitMQ确保消息可靠性的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP;

public class ConsumerWithCallback {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String receivedMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + receivedMessage + "'");
                // 回调函数示例
                handleReceivedMessage(receivedMessage);
                channel.basicAck(envelope.getDeliveryTag(), false);
            }

            private void handleReceivedMessage(String message) {
                // 处理接收到的消息，并进行异常处理
                try {
                    // 消息处理逻辑
                    System.out.println("Message processed: " + message);
                } catch (Exception e) {
                    // 记录异常日志
                    System.err.println("Error processing message: " + e.getMessage());
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

回调机制与异常处理

回调机制允许接收者在接收到消息后执行回调函数。在消息传输过程中，异常处理机制可以确保遇到错误时进行适当处理，比如记录日志、发送告警等。

以下是使用RabbitMQ实现回调机制和异常处理的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP;

public class ConsumerWithCallback {
    private final static String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,
                                       AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String receivedMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + receivedMessage + "'");
                // 回调函数示例
                handleReceivedMessage(receivedMessage);
                channel.basicAck(envelope.getDeliveryTag(), false);
            }

            private void handleReceivedMessage(String message) {
                // 处理接收到的消息，并进行异常处理
                try {
                    // 消息处理逻辑
                    System.out.println("Message processed: " + message);
                } catch (Exception e) {
                    // 记录异常日志
                    System.err.println("Error processing message: " + e.getMessage());
                }
            }
        };
        channel.basicConsume(QUEUE_NAME, false, consumer);
    }
}

MQ的容错与扩展性设计

容错机制概述

容错机制包括以下几个方面：

主备切换：当主节点宕机时，备节点接管主节点的工作。
数据备份：定期对数据进行备份，防止数据丢失。
负载均衡：通过负载均衡机制确保请求能够均匀地分发到各个节点。
心跳检测：定期检测节点的运行状态，及时发现并处理异常节点。
自动恢复：当节点恢复后自动重新加入集群，并恢复原有功能。

以下是使用RabbitMQ实现主备切换的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class MainNode {
    private final static String QUEUE_NAME = "mainQueue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "' to main queue");

        channel.close();
        connection.close();
    }
}

扩展性设计思路

扩展性设计思路包括以下几个方面：

水平扩展：通过增加更多的节点来提升系统的整体吞吐量。
垂直扩展：通过增加单个节点的硬件资源来提升性能。
负载均衡：使用负载均衡器将请求分发到多个节点，提高系统的处理能力。
动态配置：允许动态调整系统的配置参数，以适应不同的负载需求。
弹性伸缩：根据实际负载情况自动调整资源，提高资源利用率。

以下是使用RabbitMQ实现负载均衡的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.QueueingConsumer;

public class LoadBalancer {
    private final static String QUEUE_NAME = "loadBalancerQueue";
    private final static String[] NODES = {"node1", "node2"};

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(NODES[0]);
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "' to load balancer queue");

        channel.close();
        connection.close();
    }
}

高可用架构介绍

高可用架构是指通过冗余设计确保系统在部分节点故障时仍能正常运行。常见的高可用架构包括：

主备模式：主节点正常工作，备节点作为备用，当主节点故障时备节点接管。
多主模式：多个主节点并行工作，共同处理请求，提高系统的处理能力和可用性。
双活模式：两个数据中心同时运行，互相作为对方的备份，确保系统的高可用性。
负载均衡模式：使用负载均衡器将请求分发到多个节点，提高系统的负载均衡能力。
分布式存储模式：将数据分散存储在多个节点上，确保数据的高可用性和可靠性。

MQ性能优化技巧

性能瓶颈分析

性能瓶颈分析包括以下几个方面：

CPU瓶颈：当CPU使用率达到100%时，系统性能会急剧下降。
内存瓶颈：当内存使用率达到上限时，系统会频繁进行磁盘交换，降低性能。
网络瓶颈：当网络带宽或网络延迟较高时，消息传输会变慢。
磁盘瓶颈：当磁盘读写速度较慢时，持久化操作会成为性能瓶颈。
队列瓶颈：当队列长度过大时，消息处理会变慢。

资源利用优化

资源利用优化包括以下几个方面：

CPU优化：通过减少不必要的进程和线程，提高CPU利用率。
内存优化：通过减少内存泄漏和垃圾回收，提高内存利用率。
磁盘优化：通过优化文件系统和磁盘调度算法，提高磁盘读写速度。
网络优化：通过优化网络传输协议和网络带宽，提高网络传输速度。
存储优化：通过压缩存储和缓存机制，减少磁盘IO操作。

以下是使用RabbitMQ实现资源优化的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;

public class ResourceOptimization {
    private final static String QUEUE_NAME = "optimizedQueue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
        System.out.println(" [x] Sent '" + message + "' to optimized queue");

        channel.close();
        connection.close();
    }
}

消息压缩与批处理

消息压缩与批处理可以提高消息传输的效率。

消息压缩：对消息进行压缩存储，减少传输的数据量。
批处理：将多个消息合并为一个批次进行处理，减少消息传输次数。

以下是使用RabbitMQ实现消息压缩的代码示例：

import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.Channel;
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;

public class ProducerWithCompression {
    private final static String QUEUE_NAME = "compressedQueue";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        String message = "Hello World!";
        byte[] compressedMessage = compressMessage(message.getBytes("UTF-8"));
        channel.basicPublish("", QUEUE_NAME, null, compressedMessage);
        System.out.println(" [x] Sent '" + message + "' as compressed message");
        channel.close();
        connection.close();
    }

    private static byte[] compressMessage(byte[] message) {
        try {
            Deflater deflater = new Deflater();
            deflater.setInput(message);
            deflater.finish();
            byte[] compressed = new byte[message.length];
            int compressedLength = deflater.deflate(compressed);
            byte[] result = new byte[compressedLength];
            System.arraycopy(compressed, 0, result, 0, compressedLength);
            return result;
        } catch (Exception e) {
            throw new RuntimeException("Error compressing message", e);
        }
    }
}

以上是消息队列MQ的入门指南，涵盖了MQ的基础概念、工作流程、存储机制、可靠性保障、容错与扩展性设计以及性能优化技巧。希望这些内容能帮助你更好地理解和使用MQ。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

噜噜哒

移动开发工程师

手记
篇

粉丝

8

获赞与收藏

25

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

MQ底层原理资料详解：新手入门指南

发布/订阅模式

点对点模式

阅读免费教程