首页手记手写mq：从零开始的简单教程

手写mq：从零开始的简单教程

标签：

中间件

概述

本文详细介绍了手写MQ的基础步骤，包括设计数据结构、创建消息发送与接收接口以及实现线程安全和持久化的消息队列。手写mq不仅涉及消息实体和消息队列的定义，还包括通过Socket通信实现消息的发送和接收。通过这些步骤，可以构建一个高效、可靠的MQ系统。

MQ简介与基本概念

什么是MQ

消息队列（Message Queue，简称MQ）是一种中间件，用于在不同系统组件之间传递消息。它提供了一种异步通信的解决方案，能够帮助系统解耦并且提高系统的可扩展性与稳定性。通过消息队列，生产者可以将消息发布到消息队列中，而消费者可以从消息队列中获取并处理消息。

MQ的作用和应用场景

作用

MQ的主要作用包括：

解耦：使系统之间松耦合，提高系统的灵活性和可维护性。
异步：通过异步通信机制，提高系统的响应速度和并发处理能力。
削峰填谷：在高并发场景下，通过消息队列存储消息，降低系统峰值压力。
可靠传输：提供消息的可靠传输机制，确保消息不会丢失或重复。
负载均衡：通过消息队列，可以实现分布式系统的负载均衡。
数据持久化：支持消息的持久化，保证消息不丢失。

场景应用

MQ在以下场景中有着广泛的应用：

电商平台：处理订单、支付、物流通知等业务流程。
即时通讯：实现聊天消息的异步传输和处理。
日志处理：收集和处理系统日志。
流处理：用于实时数据流的处理，如实时分析和预测。
系统间集成：实现不同系统之间的集成和数据交换。
分布式系统：在分布式环境中实现不同服务之间的通信。
监控系统：用于收集和处理监控数据。

通过以上作用和应用场景，我们可以看出MQ在现代分布式系统中的重要性。

准备工作

开发环境搭建

为了实现MQ，需要搭建一个基本的开发环境，主要包括以下几个步骤：

选择编程语言：这里我们选择使用Java语言，因为它在分布式系统开发中有广泛的应用，并有大量的开源库支持。
安装Java环境：确保已安装Java开发工具包（JDK）。
创建项目：可以在本地创建一个Java项目，或者使用IDE（如IntelliJ IDEA或Eclipse）来创建项目。
添加依赖库：如果使用第三方库，可以通过Maven或Gradle配置项目依赖。例如，在Maven中，可以在pom.xml文件中添加依赖项。

<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>2.8.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.5.4</version>
    </dependency>
    <dependency>
        <groupId>org.apache.activemq</groupId>
        <artifactId>activemq-client</artifactId>
        <version>5.15.13</version>
    </dependency>
</dependencies>

以上配置中，我们添加了Kafka客户端库、Spring Boot Web启动库和ActiveMQ客户端库，这些库在实现MQ时非常有用。

在IDE（如IntelliJ IDEA或Eclipse）中导入这些依赖时，可以使用以下步骤：

打开项目。
右键点击pom.xml文件，选择Maven -> Reload Project。
如果IDE检测到新的依赖，会自动导入并配置。

必要工具介绍

以下是开发MQ时需要的一些关键工具：

IDE（集成开发环境）：如IntelliJ IDEA或Eclipse。
JDK：Java开发工具包，确保已正确安装。
Maven或Gradle：用于依赖管理和构建工具。
版本控制系统（VCS）：如Git，用于版本控制和协作开发。
单元测试框架：如JUnit。
日志框架：如SLF4J和Logback。

这些工具可以帮助我们更高效地开发、测试和管理MQ应用。

手写MQ的基础步骤

设计数据结构

在实现MQ之前，需要设计合适的数据结构来存储消息。数据结构的设计应该是简洁且高效的，以便于后续的实现和维护。

消息实体

首先，定义一个Message类来表示消息实体。Message类应该包含消息的基本信息，如消息内容、发送者、接收者、发送时间等。

public class Message {
    private String content;
    private String sender;
    private String receiver;
    private long sendTime;

    public Message(String content, String sender, String receiver) {
        this.content = content;
        this.sender = sender;
        this.receiver = receiver;
        this.sendTime = System.currentTimeMillis();
    }

    public String getContent() {
        return content;
    }

    public String getSender() {
        return sender;
    }

    public String getReceiver() {
        return receiver;
    }

    public long getSendTime() {
        return sendTime;
    }
}

消息队列

消息队列通常是一个有序的集合，用于存储消息。消息队列可以使用链表或数组实现。这里我们使用链表实现，因为链表更易于扩展和管理。

public class MessageQueue {
    private Node head;
    private Node tail;

    public MessageQueue() {
        head = tail = null;
    }

    public void enqueue(Message message) {
        Node newNode = new Node(message);
        if (head == null) {
            head = tail = newNode;
        } else {
            tail.setNext(newNode);
            tail = newNode;
        }
    }

    public Message dequeue() {
        if (head == null) {
            return null;
        }
        Message message = head.getMessage();
        head = head.getNext();
        if (head == null) {
            tail = null;
        }
        return message;
    }

    private static class Node {
        private Message message;
        private Node next;

        public Node(Message message) {
            this.message = message;
            this.next = null;
        }

        public Message getMessage() {
            return message;
        }

        public void setMessage(Message message) {
            this.message = message;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
}

以上定义了一个Message类和一个基于链表的消息队列MessageQueue。MessageQueue提供了enqueue（入队）和dequeue（出队）方法来添加和移除消息。

创建消息发送与接收接口

为了实现消息的发送和接收，需要定义相应的接口。这些接口可以使用工厂模式或者直接定义具体实现类来实现。

消息发送接口

定义一个MessageSender接口，用于发送消息。具体实现类可以实现该接口，提供具体的发送逻辑。

public interface MessageSender {
    void sendMessage(Message message);
}

消息接收接口

定义一个MessageReceiver接口，用于接收消息。同样地，具体实现类可以实现该接口，提供具体的接收逻辑。

public interface MessageReceiver {
    void receiveMessage(Message message);
}

这两个接口是消息传递的基础，后续的实现将基于这些接口。

消息发送与接收实现

public class SocketMessageSender implements MessageSender {
    private Socket socket;

    public SocketMessageSender(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void sendMessage(Message message) {
        try (OutputStream outputStream = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(outputStream, true)) {
            writer.println(message.getContent());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SocketMessageReceiver implements MessageReceiver {
    private ServerSocket serverSocket;

    public SocketMessageReceiver(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    @Override
    public void receiveMessage(Message message) {
        try (Socket socket = serverSocket.accept();
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            String content = reader.readLine();
            message = new Message(content, "", "");
            // 处理接收到的消息
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码展示了如何使用Socket通信实现消息的发送和接收。

实现核心功能

消息队列的实现

在前面的设计中，我们已经实现了一个简单的链表消息队列。这里我们将进一步优化消息队列的实现，以支持更复杂的功能。

消息队列优化

线程安全：线程安全是实现消息队列时必须考虑的问题。可以通过同步机制来保证线程安全，比如使用synchronized关键字。

public class ThreadSafeMessageQueue {
    private Node head;
    private Node tail;
    private int size;

    public ThreadSafeMessageQueue() {
        head = tail = null;
        size = 0;
    }

    public synchronized void enqueue(Message message) {
        Node newNode = new Node(message);
        if (head == null) {
            head = tail = newNode;
        } else {
            tail.setNext(newNode);
            tail = newNode;
        }
        size++;
    }

    public synchronized Message dequeue() {
        if (head == null) {
            return null;
        }
        Message message = head.getMessage();
        head = head.getNext();
        if (head == null) {
            tail = null;
        }
        size--;
        return message;
    }

    public synchronized int getSize() {
        return size;
    }

    private static class Node {
        private Message message;
        private Node next;

        public Node(Message message) {
            this.message = message;
            this.next = null;
        }

        public Message getMessage() {
            return message;
        }

        public void setMessage(Message message) {
            this.message = message;
        }

        public Node getNext() {
            return next;
        }

        public void setNext(Node next) {
            this.next = next;
        }
    }
}

持久化：持久化可以保证消息不会因为系统崩溃而丢失。可以通过文件系统来实现消息的持久化存储。

public class PersistentMessageQueue {
    private List<Message> messages = new ArrayList<>();
    private File file;

    public PersistentMessageQueue(File file) {
        this.file = file;
        loadFromFile();
    }

    public void enqueue(Message message) {
        messages.add(message);
        saveToFile();
    }

    public Message dequeue() {
        if (messages.isEmpty()) {
            return null;
        }
        Message message = messages.remove(0);
        saveToFile();
        return message;
    }

    public void saveToFile() {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
            for (Message message : messages) {
                writer.write(message.getContent());
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void loadFromFile() {
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            String line;
            while ((line = reader.readLine()) != null) {
                messages.add(new Message(line, "", ""));
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码展示了如何实现线程安全的消息队列和持久化的消息队列，以及如何通过Socket通信实现消息的发送和接收。这些实现为后续的测试和优化奠定了基础。

Socket通信实现

Socket消息发送实现

public class SocketMessageSender implements MessageSender {
    private Socket socket;

    public SocketMessageSender(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void sendMessage(Message message) {
        try (OutputStream outputStream = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(outputStream, true)) {
            writer.println(message.getContent());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Socket消息接收实现

public class SocketMessageReceiver implements MessageReceiver {
    private ServerSocket serverSocket;

    public SocketMessageReceiver(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }

    @Override
    public void receiveMessage(Message message) {
        try (Socket socket = serverSocket.accept();
             BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
            String content = reader.readLine();
            message = new Message(content, "", "");
            // 处理接收到的消息
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上代码展示了如何通过Socket通信实现消息的发送和接收。

测试与调试

常见问题及解决方法

在实现MQ时，可能会遇到一些常见问题，以下是一些常见问题及其解决方法：

1. 线程安全问题

问题描述：在高并发情况下，数据可能被多个线程同时修改，导致数据不一致。
解决方法：使用同步机制，如synchronized关键字或使用ReentrantLock进行锁操作。

public synchronized void enqueue(Message message) {
    Node newNode = new Node(message);
    if (head == null) {
        head = tail = newNode;
    } else {
        tail.setNext(newNode);
        tail = newNode;
    }
}

2. 消息丢失

问题描述：由于系统崩溃或其他原因，消息可能在传输过程中丢失。
解决方法：实现消息持久化，将消息写入文件或数据库中。

public void saveToFile() {
    try (BufferedWriter writer = new BufferedWriter(new FileWriter(file))) {
        for (Message message : messages) {
            writer.write(message.getContent());
            writer.newLine();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

3. 消息重复

问题描述：在某些情况下，消息可能被重复发送或接收。
解决方法：使用消息ID进行唯一性校验，确保每条消息只处理一次。

public void receiveMessage(Message message) {
    String messageId = message.getId(); // 假设Message类中有一个get方法用于获取消息ID
    if (!processedMessages.contains(messageId)) {
        processedMessages.add(messageId);
        // 处理接收到的消息
    } else {
        // 消息重复，忽略
    }
}

4. 性能瓶颈

问题描述：在高并发场景下，MQ可能成为性能瓶颈。
解决方法：优化消息队列的实现，使用更高效的数据结构和算法，如使用数组队列或环形缓冲区。

public class ArrayMessageQueue {
    private Message[] messages;
    private int head;
    private int tail;
    private int size;

    public ArrayMessageQueue(int capacity) {
        messages = new Message[capacity];
        head = 0;
        tail = 0;
        size = 0;
    }

    public synchronized void enqueue(Message message) {
        if (size == messages.length) {
            throw new RuntimeException("Queue is full");
        }
        messages[tail] = message;
        tail = (tail + 1) % messages.length;
        size++;
    }

    public synchronized Message dequeue() {
        if (size == 0) {
            return null;
        }
        Message message = messages[head];
        messages[head] = null;
        head = (head + 1) % messages.length;
        size--;
        return message;
    }

    public synchronized int getSize() {
        return size;
    }
}

测试用例设计

设计测试用例来验证MQ的各个功能是否正常工作。测试用例包括以下几个方面：

1. 消息发送与接收

测试点1：发送一条消息，检查接收端是否能正确接收到。
- 输入：发送一条消息Message("Hello World", "Alice", "Bob")
- 期望输出：接收端能接收到并处理这条消息。

public void testSendMessage() {
    SocketMessageSender sender = new SocketMessageSender(socket);
    SocketMessageReceiver receiver = new SocketMessageReceiver(12345);
    Message message = new Message("Hello World", "Alice", "Bob");
    sender.sendMessage(message);
    Message receivedMessage = receiver.receiveMessage();
    assertEquals(message.getContent(), receivedMessage.getContent());
}

2. 消息队列操作

测试点2：向队列中添加多条消息，检查队列的大小。
- 输入：添加两条消息Message("Message 1", "Alice", "Bob")和Message("Message 2", "Alice", "Bob")
- 期望输出：队列的大小为2。

public void testQueueSize() {
    ThreadSafeMessageQueue queue = new ThreadSafeMessageQueue();
    queue.enqueue(new Message("Message 1", "Alice", "Bob"));
    queue.enqueue(new Message("Message 2", "Alice", "Bob"));
    assertEquals(2, queue.getSize());
}

3. 线程安全

测试点3：在多线程环境下添加和移除消息，检查队列的线程安全性。
- 输入：在多个线程中同时添加和移除消息
- 期望输出：队列的大小和内容保持正确。

public void testThreadSafety() {
    ThreadSafeMessageQueue queue = new ThreadSafeMessageQueue();
    ExecutorService executor = Executors.newFixedThreadPool(10);
    for (int i = 0; i < 10; i++) {
        executor.execute(() -> queue.enqueue(new Message("Message " + i, "Alice", "Bob")));
        executor.execute(() -> queue.dequeue());
    }
    executor.shutdown();
    while (!executor.isTerminated()) {
        // 等待所有线程结束
    }
    assertEquals(0, queue.getSize());
}

以上测试用例可以帮助我们验证MQ的各个功能是否正常工作，确保系统在各种场景下的稳定性和可靠性。

实际应用与优化

MQ在项目中的应用示例

在实际项目中，消息队列可以应用在多种场景和业务逻辑中，下面我们将通过一个具体的电商项目示例来展示MQ的应用。

场景描述

假设我们正在开发一个电商平台，需要实现以下功能：

用户下单后，生成订单并发送相关通知。
支付完成后，更新订单状态并发送通知。
物流信息更新后，同步到系统并发送通知。
用户评价后，更新商品评价并发送通知。

消息队列的应用

订单生成：当用户下单后，生成订单并发送一个订单生成消息给消息队列。

public void handleOrderCreation(Order order) {
    Message orderMessage = new Message("Order created: " + order.getId(), "User", "OrderService");
    messageQueue.enqueue(orderMessage);
    orderService.createOrder(order);
}

支付确认：当用户完成支付后，更新订单状态并发送一个支付确认消息给消息队列。

public void handlePaymentConfirmation(Order order) {
    Message paymentMessage = new Message("Payment confirmed: " + order.getId(), "User", "OrderService");
    messageQueue.enqueue(paymentMessage);
    orderService.updateOrderStatus(order);
}

物流更新：当物流信息更新后，同步到系统并发送一个物流更新消息给消息队列。

public void handleLogisticsUpdate(Order order) {
    Message logisticsMessage = new Message("Logistics updated: " + order.getId(), "User", "OrderService");
    messageQueue.enqueue(logisticsMessage);
    logisticsService.updateOrderLogistics(order);
}

评价更新：当用户评价后，更新商品评价并发送一个评价更新消息给消息队列。

public void handleReviewUpdate(Order order) {
    Message reviewMessage = new Message("Review updated: " + order.getId(), "User", "OrderService");
    messageQueue.enqueue(reviewMessage);
    reviewService.updateProductReview(order);
}

以上代码展示了如何在电商平台中使用消息队列进行消息传递，通过这种方式，系统可以实现异步通信，提高响应速度和并发能力。

面向对象设计

为了更好地管理消息队列，可以引入面向对象的设计模式。例如，使用工厂模式来创建消息发送和接收的实例。

public class MessageFactory {
    public static MessageSender createMessageSender() {
        return new SocketMessageSender(new Socket("localhost", 12345));
    }

    public static MessageReceiver createMessageReceiver() {
        return new SocketMessageReceiver(12345);
    }
}

这样可以更方便地管理和扩展消息队列的实现。

业务逻辑与消息队列的结合

在实际应用中，可以通过消息队列来实现业务逻辑的解耦。例如，订单服务可以专注于订单的创建和更新，而不必关心支付和物流的具体实现。通过消息队列，可以将这些异步操作解耦，提高系统的可扩展性和灵活性。

public class OrderService {
    public void createOrder(Order order) {
        // 创建订单逻辑
        messageQueue.enqueue(new Message("Order created: " + order.getId(), "OrderService", "PaymentService"));
    }

    public void updateOrderStatus(Order order) {
        // 更新订单状态逻辑
        messageQueue.enqueue(new Message("Order status updated: " + order.getId(), "OrderService", "LogisticsService"));
    }
}

以上代码展示了如何将业务逻辑与消息队列结合起来，实现业务的异步处理。

性能优化建议

在实现MQ的过程中，性能优化是提高系统效率的关键。以下是一些性能优化的建议：

1. 使用高效的队列实现

选择合适的队列实现方式可以提高性能。例如，使用环形缓冲区（Circular Buffer）可以减少内存分配和垃圾回收的开销。

public class CircularBufferQueue {
    private Message[] buffer;
    private int head;
    private int tail;
    private int size;
    private int capacity;

    public CircularBufferQueue(int capacity) {
        this.capacity = capacity;
        buffer = new Message[capacity];
        head = 0;
        tail = 0;
        size = 0;
    }

    public void enqueue(Message message) {
        if (size == capacity) {
            throw new RuntimeException("Queue is full");
        }
        buffer[tail] = message;
        tail = (tail + 1) % capacity;
        size++;
    }

    public Message dequeue() {
        if (size == 0) {
            return null;
        }
        Message message = buffer[head];
        buffer[head] = null;
        head = (head + 1) % capacity;
        size--;
        return message;
    }

    public int getSize() {
        return size;
    }
}

2. 批量处理消息

在某些情况下，可以将多个消息批量处理，减少网络传输和系统调用的次数，从而提高性能。

public void batchProcessMessages() {
    List<Message> batchMessages = new ArrayList<>();
    while (messageQueue.getSize() > 0 && batchMessages.size() < 100) {
        batchMessages.add(messageQueue.dequeue());
    }
    processBatch(batchMessages);
}

private void processBatch(List<Message> batchMessages) {
    // 批量处理消息
}

3. 使用消息压缩

对于大数据量的消息，可以使用消息压缩技术减少传输的数据量，提高传输效率。

public class CompressedMessage {
    private byte[] compressedContent;

    public CompressedMessage(String content) {
        try {
            compressedContent = compress(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public String getContent() {
        try {
            return decompress(compressedContent);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }

    private byte[] compress(String content) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        GZIPOutputStream gos = new GZIPOutputStream(baos);
        gos.write(content.getBytes());
        gos.close();
        return baos.toByteArray();
    }

    private String decompress(byte[] compressedContent) throws IOException {
        if (compressedContent == null) {
            return null;
        }
        ByteArrayInputStream bais = new ByteArrayInputStream(compressedContent);
        GZIPInputStream gzis = new GZIPInputStream(bais);
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(gzis));
        StringBuilder out = new StringBuilder();
        String line;
        while ((line = bufferedReader.readLine()) != null) {
            out.append(line);
        }
        return out.toString();
    }
}

4. 优化持久化机制

对于持久化消息队列，可以通过优化持久化机制来提高性能。例如，使用日志文件进行持久化，而不是简单地写入文件。

public void saveToLog() {
    try (BufferedWriter writer = new BufferedWriter(new FileWriter("log.txt", true))) {
        writer.write(message.getContent());
        writer.newLine();
    } catch (IOException e) {
        e.printStackTrace();
    }
}

5. 异步处理

通过异步处理消息，可以提高系统的响应速度。例如，使用线程池来异步处理消息。

public class AsyncMessageHandler implements Runnable {
    private Message message;

    public AsyncMessageHandler(Message message) {
        this.message = message;
    }

    @Override
    public void run() {
        processMessage(message);
    }

    private void processMessage(Message message) {
        // 处理消息逻辑
    }
}

public void handleMessages() {
    ExecutorService executor = Executors.newFixedThreadPool(10);
    while (true) {
        Message message = messageQueue.dequeue();
        if (message != null) {
            executor.execute(new AsyncMessageHandler(message));
        } else {
            // 没有消息时休眠
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

通过以上性能优化建议，可以提高MQ的整体性能，使其在高并发场景下表现更加优秀。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

喵喵时光机

手记
篇

粉丝

9

获赞与收藏

108

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 31416 348

网络编程入门教程

20个小节 12873 242

Pandas 入门教程

25个小节 18755 351

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空