🎉🚀最近面试消息的顺序性:Message Key 和 Message Queue Selector!

卡白2024-06-06 18:55

🎉🚀 最近面试提问

一般为了高性能，会配置多个Partition，比如8个Partition，16个Partition，为了保证有序消息，应该如何设计消息的投递，具体原理是什么，请分别说一下rocketmq和kafka的实现。

高可用、高性能下的有序消息设计 🚀

在实现高可用和高性能的消息系统时，通常会配置多个 Partition。要在这种情况下保证消息的顺序性，我们需要合理设计消息的投递策略。下面分别介绍 RocketMQ 和 Kafka 的实现原理和具体设计方法。

在投递的环节，通过使用消息键（Message Key）来对消息进行分类，确保同一个业务ID的消息进入同一个队列或分区，从而保证消息的顺序性。

原理详解 🚀

消息投递和分类

在 Kafka 和 RocketMQ 中，消息投递和分类的过程如下：

  1. 消息键（Message Key）：

    • 生产者在发送消息时，会为每条消息指定一个消息键（如订单ID、用户ID等）。
    • 消息键用于标识消息的业务ID，确保相同业务ID的消息被分类到同一个队列或分区。

  2. 分区选择：

    • 根据消息键进行分区选择。Kafka 和 RocketMQ 都会对消息键进行哈希计算，并根据分区数量取模，确定消息应该发送到哪个分区。
    • 这样可以确保具有相同消息键的消息总是被发送到同一个分区，从而保证这些消息的顺序性。

RocketMQ 实现原理和设计方法 🌟

1. 消息投递到特定的 Queue（Partition）

在 RocketMQ 中，每个 Topic 可以有多个 Queue（Partition）。为了保证消息的顺序性，我们可以使用 Message Queue Selector 来将消息投递到特定的 Queue。

生产者端实现：

生产者可以使用 MessageQueueSelector 接口，根据消息的业务ID（如订单ID）选择 Queue（Partition）。这样，具有相同业务ID的消息将始终发送到同一个 Queue，从而保证顺序性。

示例代码：

java 复制代码 
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.List;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("OrderProducerGroup");
        producer.start();

        String topic = "OrderTopic";
        String[] tags = new String[] {"TagA", "TagB", "TagC"};
        for (int i = 0; i < 100; i++) {
            int orderId = i % 10; // 业务ID，例如订单ID
            Message msg = new Message(topic, tags[i % tags.length], "KEY" + i,
                ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Integer id = (Integer) arg;
                    int index = id % mqs.size(); // 确定消息发送到哪个队列
                    return mqs.get(index);
                }
            }, orderId); // 使用业务ID进行队列选择
            System.out.printf("%s%n", sendResult);
        }
        producer.shutdown();
    }
}

消费者端实现：

在消费者端，使用顺序消息监听器 MessageListenerOrderly 来消费消息，确保同一时间只有一个线程在处理同一个 Queue 中的消息。

java 复制代码 
import org.apache.rocketmq.client.consumer.DefaultMQPushConsumer;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyContext;
import org.apache.rocketmq.client.consumer.listener.ConsumeOrderlyStatus;
import org.apache.rocketmq.client.consumer.listener.MessageListenerOrderly;
import org.apache.rocketmq.common.message.MessageExt;

import java.util.List;

public class OrderConsumer {
    public static void main(String[] args) throws Exception {
        DefaultMQPushConsumer consumer = new DefaultMQPushConsumer("OrderConsumerGroup");
        consumer.setNamesrvAddr("127.0.0.1:9876");
        consumer.subscribe("OrderTopic", "TagA || TagB || TagC");

        consumer.registerMessageListener(new MessageListenerOrderly() {
            @Override
            public ConsumeOrderlyStatus consumeMessage(List<MessageExt> msgs, ConsumeOrderlyContext context) {
                for (MessageExt msg : msgs) {
                    // 处理消息
                    System.out.printf("%s Receive New Messages: %s %n", Thread.currentThread().getName(), new String(msg.getBody()));
                }
                return ConsumeOrderlyStatus.SUCCESS;
            }
        });

        consumer.start();
        System.out.printf("Consumer Started.%n");
    }
}

Kafka 实现原理和设计方法 🌟

1. 消息投递到特定的 Partition

在 Kafka 中，每个 Topic 也可以有多个 Partition。为了保证消息的顺序性，我们可以使用消息键（Message Key）来决定消息投递到哪个 Partition。这样，具有相同消息键的消息将始终发送到同一个 Partition，从而保证顺序性。

生产者端实现：

生产者在发送消息时，可以指定消息键（如订单ID）。Kafka 使用消息键进行分区选择，确保具有相同消息键的消息总是被发送到同一个 Partition。

示例代码：

java 复制代码 
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.Future;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        String topic = "OrderTopic";
        for (int i = 0; i < 100; i++) {
            String orderId = "order" + (i % 10); // 业务ID，例如订单ID
            String value = "Order data " + i;
            ProducerRecord<String, String> record = new ProducerRecord<>(topic, orderId, value);
            Future<RecordMetadata> future = producer.send(record);
            RecordMetadata metadata = future.get();
            System.out.printf("Sent message with key %s to partition %d with offset %d%n", orderId, metadata.partition(), metadata.offset());
        }

        producer.close();
    }
}

消费者端实现：

消费者端按 Partition 顺序消费消息，确保同一时间只有一个线程在处理同一个 Partition 中的消息。

java 复制代码 
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class OrderConsumer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "OrderConsumerGroup");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Collections.singletonList("OrderTopic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("Consumed message with key %s from partition %d with offset %d: %s%n", record.key(), record.partition(), record.offset(), record.value());
            }
        }
    }
}

总结 🌟

RocketMQ 和 Kafka 都通过消息键（业务ID）来保证消息的顺序性：

  • RocketMQ 使用 MessageQueueSelector 接口将消息发送到特定的 Queue（Partition）。
  • Kafka 使用消息键来决定消息发送到特定的 Partition。

这两种方法都能在高可用、高性能的环境中保证消息的顺序性，同时充分利用分区（Partition）带来的并行处理能力。希望这些内容对你理解 RocketMQ 和 Kafka 的顺序消费特性有所帮助！如果有任何问题，欢迎随时交流！😊

扩容

mqs.size() 是动态获取的。在 RocketMQ 和 Kafka 中，mqs.size() 动态获取队列（Queue）或分区（Partition）的数量，这确保了当你增加或减少队列或分区数量时，代码可以自动适应新的配置，而无需修改。

动态获取队列/分区数量的实现 🚀

RocketMQ 中的实现

在 RocketMQ 中，mqs.size() 动态获取的是当前 Topic 下所有队列的数量。示例代码如下：

java 复制代码 
import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.common.message.MessageQueue;
import org.apache.rocketmq.remoting.common.RemotingHelper;

import java.util.List;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        DefaultMQProducer producer = new DefaultMQProducer("OrderProducerGroup");
        producer.start();

        String topic = "OrderTopic";
        String[] tags = new String[] {"TagA", "TagB", "TagC"};
        for (int i = 0; i < 100; i++) {
            int orderId = i % 10; // 业务ID，例如订单ID
            Message msg = new Message(topic, tags[i % tags.length], "KEY" + i,
                ("Hello RocketMQ " + i).getBytes(RemotingHelper.DEFAULT_CHARSET));
            SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
                @Override
                public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                    Integer id = (Integer) arg;
                    int index = id.hashCode() % mqs.size(); // 动态获取队列数量，支持扩容
                    return mqs.get(index);
                }
            }, orderId); // 使用业务ID进行队列选择
            System.out.printf("%s%n", sendResult);
        }
        producer.shutdown();
    }
}

在这个示例中，mqs 是 MessageQueue 的列表，mqs.size() 返回的是当前 Topic 下的队列数量。

Kafka 中的实现

在 Kafka 中，分区数量也是动态获取的。示例代码如下：

java 复制代码 
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.Future;

public class OrderProducer {
    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        String topic = "OrderTopic";
        for (int i = 0; i < 100; i++) {
            String orderId = "order" + (i % 10); // 业务ID，例如订单ID
            String value = "Order data " + i;
            ProducerRecord<String, String> record = new ProducerRecord<>(topic, orderId, value);
            Future<RecordMetadata> future = producer.send(record);
            RecordMetadata metadata = future.get();
            System.out.printf("Sent message with key %s to partition %d with offset %d%n", orderId, metadata.partition(), metadata.offset());
        }

        producer.close();
    }
}

在 Kafka 中，分区的数量是由 Kafka 集群动态管理的，生产者在发送消息时会根据消息键来确定消息的分区。

动态获取队列/分区数量的优点 🌟

  • 扩展性：无需修改代码即可扩容或缩减队列/分区数量。
  • 灵活性：自动适应新的队列/分区数量，简化运维。
  • 可靠性：确保消息按照业务ID的哈希值均匀分布到不同的队列/分区中，从而保证高性能和有序性。

总结 🌟

通过动态获取队列或分区的数量，RocketMQ 和 Kafka 可以在高可用和高性能的环境中保证消息的顺序性，同时支持扩容而无需修改代码。这种设计提高了系统的灵活性和可靠性。希望这些解释对你理解消息投递的设计有所帮助！😊

相关推荐
鱼跃鹰飞5 小时前
大厂面试真题-简单说说线程池接到新任务之后的操作流程
java·jvm·面试
程序员清风8 小时前
浅析Web实时通信技术！
java·后端·面试
测试19989 小时前
外包干了2年，快要废了。。。
自动化测试·软件测试·python·面试·职场和发展·单元测试·压力测试
mingzhi6110 小时前
渗透测试-快速获取目标中存在的漏洞(小白版)
安全·web安全·面试·职场和发展
嚣张农民10 小时前
一文简单看懂Promise实现原理
前端·javascript·面试
Liknana12 小时前
Android 网易游戏面经
android·面试
威哥爱编程15 小时前
MongoDB面试专题33道解析
数据库·mongodb·面试
程序猿进阶16 小时前
Redis 基础数据改造
java·开发语言·数据库·redis·后端·面试·架构
刘艳兵的学习博客17 小时前
刘艳兵-DBA027-在Oracle数据库，通常可以使用如下方法来得到目标SQL的执行计划，那么通过下列哪些方法得到的执行计划有可能是不准确的？
数据库·oracle·面试·database·刘艳兵
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play