首页手记 Kafka消息丢失入门：识别和解决Kafka消息丢失问题

Kafka消息丢失入门：识别和解决Kafka消息丢失问题

标签：

大数据 Hadoop Spark

概述

本文详细介绍了Kafka消息丢失的常见原因和解决方法，帮助读者理解Kafka消息丢失的问题。文章从生产者、消费者和Kafka集群三个角度分析了消息丢失的原因，并提供了相应的解决方案和示例代码。此外，还介绍了如何通过日志检查和监控工具来检测消息丢失。本文旨在为读者提供一个全面的Kafka消息丢失入门指南。Kafka消息丢失入门涵盖了从识别问题到实施解决方案的全过程。

Kafka简介与消息丢失概述

Kafka是什么

Apache Kafka 是一个高吞吐量的分布式发布订阅型消息系统，它最初由 LinkedIn 公司开发，后成为 Apache 顶级项目。Kafka 被设计为一个可扩展和持久化的消息队列系统，广泛应用于日志聚合、流处理、数据管道等场景。它具有以下特点：

高吞吐量：Kafka 可以每秒处理百万级别以上的消息，适用于需要大量数据传输的场景。
持久化：Kafka 能够将消息持久化到磁盘，从而保证消息的可靠性。
分布式：Kafka 支持多节点部署，能够实现高可用和负载均衡。
容错性：Kafka 在节点故障时仍能保持消息的可靠传输和消费。
可伸缩性：Kafka 支持水平扩展，可以根据业务需求动态调整集群规模。

什么是消息丢失

消息丢失是指消息在生产者发送到Kafka集群后，未能成功传递给消费者或在传递过程中丢失的情况。消息丢失可能会导致数据不一致、重复处理或业务逻辑错误等严重问题。消息丢失的原因可能出现在生产者端、Kafka集群内部或消费者端。

消息丢失的原因概述

消息丢失在Kafka系统中可能由多种因素造成：

生产者端的问题：如网络不稳定导致生产者无法发送消息、生产者配置错误导致消息未被正确发送等。
Kafka集群内部的问题：如Broker节点故障、磁盘损坏导致消息丢失、数据复制过程中的问题等。
消费者端的问题：如消费者处理消息失败、消费者组重新均衡导致的消息重复处理等。
配置不当：如未启用消息确认机制、设置不当的消息重试策略等。

常见消息丢失场景

生产者端消息丢失

生产者端消息丢失通常是由生产者配置错误或网络问题导致的。例如，生产者消息发送的成功确认机制设置不当、生产者在发送消息时由于网络问题未接收到确认消息等。

示例代码

以下是一个简单的生产者代码示例，展示了如何发送消息到Kafka：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

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

        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("my-topic", "key-" + i, "value-" + i));
        }

        producer.close();
    }
}

消费者端消息丢失

消费者端消息丢失通常由消费者处理失败或消费者组重新平衡导致。例如，消费者在消费消息时发生异常，导致消息未被正确处理或消费者组重新均衡时未正确处理偏移量。

示例代码

以下是一个简单的消费者代码示例，展示了如何从Kafka读取消息：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

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

消息在Kafka集群中的丢失

消息在Kafka集群中的丢失通常由集群内部问题引起，如Broker节点故障、磁盘损坏等。此外，数据复制过程中的问题也可能导致消息丢失。

示例代码

以下是一个模拟Broker节点故障的示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

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

        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("my-topic", "key-" + i, "value-" + i));
        }

        producer.close();
    }
}

如何检测消息丢失

通过日志检查

Kafka 和生产者、消费者组件通常会在日志中记录详细的错误信息。通过分析这些日志，可以发现消息丢失的线索。

示例代码

以下是一个简单的日志记录示例，展示了如何在生产者中记录日志：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

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

        for (int i = 0; i < 100; i++) {
            try {
                producer.send(new ProducerRecord<String, String>("my-topic", "key-" + i, "value-" + i));
            } catch (Exception e) {
                System.err.println("Failed to send message: " + e.getMessage());
            }
        }

        producer.close();
    }
}

以下是一个简单的日志记录示例，展示了如何在消费者中记录日志：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                try {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                } catch (Exception e) {
                    System.err.println("Failed to process message: " + e.getMessage());
                }
            }
        }
    }
}

使用监控工具监测

Kafka 自带了一些监控工具，如 Kafka 自带的 kafka-topics.sh 脚本可以用来查看主题的详细信息，包括偏移量等。此外，还有第三方工具如 Prometheus 和 Grafana 可以用来实时监控 Kafka 的状态。

示例脚本

以下是一个简单的Prometheus配置示例，展示了如何使用Prometheus监控Kafka：

# Prometheus 配置文件
scrape_configs:
  - job_name: 'kafka'
    scrape_interval: 15s
    static_configs:
      - targets: ['localhost:9308']

以下是一个简单的Grafana配置示例，展示了如何使用Grafana展示Kafka监控数据：

# Grafana 配置文件
{
  "dashboard": {
    "id": 0,
    "title": "Kafka Metrics",
    "panels": [
      {
        "title": "Kafka Broker Metrics",
        "type": "timeseries",
        "targets": [
          {
            "expr": "kafka_broker_offset_lag_max{topic=~\".*\"}",
            "interval": "1m",
            "legendFormat": "{{topic}} lag max"
          }
        ]
      }
    ]
  }
}

示例代码

以下是一个简单的Prometheus配置示例，展示了如何启动Prometheus并配置Kafka监控：

# 启动Prometheus并配置Kafka监控
prometheus --config.file=/path/to/prometheus.yml

消息计数对比

通过对比生产者发送消息数量与消费者接收到的消息数量，可以初步判断是否存在消息丢失。

示例代码

以下是一个简单的消息计数对比示例，展示了如何记录生产者发送的消息数量和消费者接收到的消息数量：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

        int messageCount = 0;
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                messageCount++;
            }
        }

        System.out.println("Total messages received: " + messageCount);
    }
}

解决消息丢失的方法

调整配置参数

通过调整 Kafka 的配置参数，可以优化消息的发送和接收过程，从而减少消息丢失的可能性。例如，可以调整生产者和消费者的配置参数，如设置更高的重试次数、增加超时时间等。

示例代码

以下是一个生产者配置参数调整的示例：

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("acks", "all"); // 确保消息被所有副本接收后才返回确认
props.put("retries", 10); // 设置重试次数
props.put("retry.backoff.ms", 1000); // 设置重试等待时间

以下是一个消费者配置参数调整的示例：

Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, "100"); // 设置每次拉取的最大消息数
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest"); // 设置偏移量重置策略

实现消息确认机制

通过实现消息确认机制，可以在消息发送和接收过程中确保消息的可靠性。例如，生产者可以在发送消息后等待确认，消费者可以在处理消息后发送确认。

示例代码

以下是一个使用消息确认机制的生产者示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("acks", "all"); // 确保消息被所有副本接收后才返回确认

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

        for (int i = 0; i < 100; i++) {
            ProducerRecord<String, String> record = new ProducerRecord<>("my-topic", "key-" + i, "value-" + i);
            producer.send(record, (metadata, exception) -> {
                if (exception != null) {
                    System.err.println("Failed to send message: " + exception.getMessage());
                } else {
                    System.out.println("Message sent successfully: " + metadata.offset());
                }
            });
        }

        producer.close();
    }
}

以下是一个使用消息确认机制的消费者示例：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                try {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                } catch (Exception e) {
                    System.err.println("Failed to process message: " + e.getMessage());
                }
            }
            consumer.commitSync(); // 手动提交偏移量
        }
    }
}

设置恰当的分区策略

通过设置恰当的分区策略，可以确保消息被正确地发送到指定的分区，减少消息丢失的可能性。例如，可以使用自定义的分区器来控制消息的分区。

示例代码

以下是一个自定义分区器的示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.internals.DefaultPartitioner;

import java.util.Properties;

public class CustomPartitionerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("partitioner.class", "com.example.CustomPartitioner"); // 使用自定义分区器

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

        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<>("my-topic", "key-" + i, "value-" + i));
        }

        producer.close();
    }
}

// 自定义分区器实现
public class CustomPartitioner extends DefaultPartitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 自定义分区逻辑
        String keyString = (String) key;
        int partitionCount = cluster.partitionCountForTopic(topic);
        return Integer.parseInt(keyString) % partitionCount;
    }
}

以下是一个标准分区器的示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

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

        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<>("my-topic", "key-" + i, "value-" + i));
        }

        producer.close();
    }
}

测试和验证方案

模拟消息丢失场景

通过模拟生产者端、消费者端和Kafka集群内部的消息丢失场景，可以验证解决方案的有效性。

示例代码

以下是一个模拟生产者端消息丢失的示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

public class KafkaProducerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

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

        for (int i = 0; i < 100; i++) {
            try {
                producer.send(new ProducerRecord<>("my-topic", "key-" + i, "value-" + i));
            } catch (Exception e) {
                System.err.println("Failed to send message: " + e.getMessage());
            }
        }

        producer.close();
    }
}

以下是一个模拟消费者端消息丢失的示例：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;

import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                try {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                } catch (Exception e) {
                    System.err.println("Failed to process message: " + e.getMessage());
                }
            }
        }
    }
}

验证解决方法的有效性

通过对比解决方案实施前后的情况，可以验证解决方案的有效性。例如，可以通过日志检查、消息计数对比等方式，确认消息丢失问题是否得到解决。

示例代码

以下是一个实施解决方案后的消息计数对比示例：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        props.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(java.util.Arrays.asList("my-topic"));

        int messageCount = 0;
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                messageCount++;
            }
        }

        System.out.println("Total messages received: " + messageCount);
    }
}

不断优化方案

通过持续优化解决方案，可以进一步提高系统的可靠性和性能。例如，可以进一步调整配置参数、优化分区策略、改进监控和日志记录等。

示例代码

以下是一个优化后的生产者代码示例，展示了如何进一步调整配置参数：

Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("acks", "all"); // 确保消息被所有副本接收后才返回确认
props.put("retries", 10); // 设置更高的重试次数
props.put("retry.backoff.ms", 1000); // 设置更长的重试等待时间

总结与建议

常见问题解答

问题：如何确保消息被正确发送？

确保生产者和Kafka集群之间的网络连接稳定。
设置生产者配置参数，如设置 acks=all 确保消息被所有副本接收后才返回确认。
使用消息确认机制，确保消息被发送成功后才继续处理。

问题：如何解决消费者端消息丢失？

设置合理的重试策略，确保消费者在处理消息失败时能够重试。
设置消息确认机制，确保消息被消费者处理成功后才提交偏移量。

问题：如何避免Kafka集群内部的消息丢失？

设置合理的副本数量，确保消息的冗余存储。
设置合理的数据复制策略，确保消息被正确复制到各个副本。
设置合理的磁盘配置，确保磁盘性能和稳定性。

持续学习资源推荐

慕课网：慕课网提供了丰富的在线课程，包括Kafka的相关教程，适合不同水平的开发者学习。

实战经验分享

问题：生产者消息发送失败如何处理？

通过日志检查生产者发送失败的原因。
通过配置调整生产者参数，如设置更高的重试次数、更长的重试等待时间。
确保生产者和Kafka集群之间的网络连接稳定。

问题：消费者处理消息失败如何处理？

通过日志检查消费者处理失败的原因。
设置合理的重试策略，确保消费者在处理消息失败时能够重试。
设置消息确认机制，确保消息被消费者处理成功后才提交偏移量。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕仙森

手记
篇

粉丝

37

获赞与收藏

103

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

Pandas 入门教程

25个小节 18499 337

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Kafka消息丢失入门：识别和解决Kafka消息丢失问题

示例代码

示例代码

示例代码

示例代码

示例脚本

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

示例代码

问题：如何确保消息被正确发送？

问题：如何解决消费者端消息丢失？

问题：如何避免Kafka集群内部的消息丢失？

问题：生产者消息发送失败如何处理？

问题：消费者处理消息失败如何处理？

阅读免费教程