Kafka 中的大消息处理策略与 C# 实现

using System;
using System.Text;
using System.Threading.Tasks;
using Confluent.Kafka;

public class KafkaProducer
{
    private const string Topic = "large-messages";
    private const int MaxMessageSize = 1024 * 1024; // 1MB，可以根据实际情况调整

    public async Task SendLargeMessageAsync(string largeMessage)
    {
        var producerConfig = new ProducerConfig { BootstrapServers = "localhost:9092" }; // 配置Kafka服务器地址
        using var producer = new ProducerBuilder<string, string>(producerConfig).Build();

        int chunkSize = MaxMessageSize - 100; // 留出一些空间用于消息头和分块信息
        byte[] largeMessageBytes = Encoding.UTF8.GetBytes(largeMessage);
        int totalChunks = (int)Math.Ceiling((double)largeMessageBytes.Length / chunkSize);

        for (int i = 0; i < totalChunks; i++)
        {
            int startIndex = i * chunkSize;
            int endIndex = Math.Min(startIndex + chunkSize, largeMessageBytes.Length);
            byte[] chunk = new byte[endIndex - startIndex];
            Array.Copy(largeMessageBytes, startIndex, chunk, 0, chunk.Length);
            string chunkMessage = Encoding.UTF8.GetString(chunk);
            string key = $"Chunk-{i+1}-{totalChunks}"; // 用于在接收端重组消息

            await producer.ProduceAsync(Topic, new Message<string, string> { Key = key, Value = chunkMessage });
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Confluent.Kafka;

public class KafkaConsumer
{
    private const string Topic = "large-messages";
    private const string GroupId = "large-message-consumer-group";

    public async Task ConsumeLargeMessagesAsync()
    {
        var consumerConfig = new ConsumerConfig
        {
            BootstrapServers = "localhost:9092", // 配置Kafka服务器地址
            GroupId = GroupId,
            AutoOffsetReset = AutoOffsetReset.Earliest // 从最早的消息开始消费
        };
        using var consumer = new ConsumerBuilder<string, string>(consumerConfig).Build();
        consumer.Subscribe(Topic);

        var chunks = new Dictionary<string, StringBuilder>(); // 用于存储和组装消息块

        while (true) // 持续消费消息，直到程序被终止或遇到错误
        {
            try
            {
                var result = consumer.Consume(); // 消费下一条消息
                string key = result.Key; // 获取消息块的关键信息（如：Chunk-1-3）
                string chunk = result.Value; // 获取消息块内容

                if (!chunks.ContainsKey(key.Split('-')[1])) // 如果这是新消息的第一个块，则创建一个新的StringBuilder来存储它
                {
                    chunks[key.Split('-')[1]] = new StringBuilder(chunk);
                }
                else // 否则，将块追加到现有的StringBuilder中
                {
                    chunks[key.Split('-')[1]].Append(chunk);
                }

                // 检查是否已接收完整个大消息的所有块
                if (IsCompleteMessage(key, chunks))
                {
                    string largeMessage = chunks[key.Split('-')[1]].ToString(); // 组装完整的大消息
                    Console.WriteLine($"Received large message: {largeMessage}"); // 处理大消息（此处仅为打印输出）
                    chunks.Remove(key.Split('-')[1]); // 清理已处理完的消息块数据，以节省内存空间
                }
            }
            catch (ConsumeException e) // 处理消费过程中可能发生的异常（如网络问题、Kafka服务器故障等）
            {
                Console.WriteLine($"Error occurred: {e.Error.Reason}");
            }
        }
    }

    private bool IsCompleteMessage(string key, Dictionary<string, StringBuilder> chunks) // 检查是否已接收完整个大消息的所有块
    {
        string[] keyParts = key.Split('-'); // 解析关键信息（如：Chunk-1-3）以获取总块数（如：3）和当前块号（如：1）等信息。这里假设关键信息的格式为“Chunk-<当前块号>-<总块数>”。在实际应用中，你可能需要根据实际情况调整此解析逻辑。同时，为了简化示例代码，这里省略了对解析结果的有效性检查（如确保当前块号在有效范围内等）。在实际应用中，你应该添加这些检查以确保代码的健壮性。另外，“<”和“>”符号仅用于说明格式，并非实际出现在关键信息中。在实际应用中，你应该使用合适的分隔符（如“-”）来分割关键信息中的各个部分。最后，请注意在实际应用中处理可能出现的异常情况（如关键信息格式不正确等）。如果关键信息的格式与示例中的不同，请相应地调整解析逻辑。同时也要注意处理可能出现的异常情况以确保代码的健壮性。 
        int totalChunks = int.Parse(keyParts[2]); // 获取总块数（假设关键信息的最后一个部分是总块数）在实际应用中，请确保关键信息的格式与你的解析逻辑相匹配，并处理可能出现的异常情况（如解析失败等）。另外，“<”和“>”符号并非实际出现在关键信息中，而是用于说明格式。你应该使用合适的分隔符来分割关键信息中的各个部分。如果关键信息的格式与示例中的不同，请相应地调整解析逻辑。同时也要注意在实际应用中处理可能出现的异常情况以确保代码的健壮性。此外，在解析完关键信息后，你可以通过比较已接收的消息块数量与总块数来判断是否已接收完整个大消息的所有块。具体实现方式可能因你的应用场景和需求而有所不同。例如，你可以使用一个字典来存储每个大消息的已接收块，并在每次接收到新块时更新字典中的信息。当某个大消息的所有块都已接收完毕时，你可以从字典中移除该消息的相关数据，并进行后续处理（如重新组装消息、触发回调函数等）。在实现这一功能时，请注意线程安全和内存管理方面的问题以确保程序的稳定性和性能。 
        return chunks.Count == totalChunks; // 如果已接收的消息块数量等于总块数，则表示已接收完整个大消息的所有块。注意，这里假设每个块都会被正确接收且不会重复接收。在实际应用中，你可能需要添加额外的逻辑来处理丢包、重传等情况以确保数据的完整性和一致性。同时，也要注意优化内存使用以避免内存泄漏或溢出等问题。另外，“==”运算符用于比较两个值是否相等。在这里，它用于比较已接收的消息块数量（即字典中的键值对数量）与总块数是否相等。如果相等，则表示已接收完整个大消息的所有块；否则，表示还有未接收的块需要继续等待。 
    }
}