首页手记 Kafka重复消费教程：新手入门指南

Kafka重复消费教程：新手入门指南

标签：

大数据 Hadoop Spark

概述

本文详细介绍了如何避免Kafka消息重复消费的问题，包括生产者和消费者端重复发送及消费消息的原因和解决方法。文中还提供了Java和Python的示例代码，帮助读者更好地理解和实现避免重复消费的策略。此外，文章还讨论了系统故障导致消息重复的情况及其应对措施。本文将带你深入了解Kafka重复消费教程，帮助你有效避免消息重复消费。

Kafka简介与安装

Kafka是什么

Kafka是一款由Apache开源组织开发的消息发布订阅系统，广泛应用于日志收集、聚合和传输等场景。它由LinkedIn公司开源，并最终成为Apache顶级项目。Kafka具有高吞吐量、持久化、分布式、可分区和可复制等特性。

安装Kafka环境

为了运行Kafka，需要安装Java环境。以下是安装步骤：

下载JDK

首先，访问JDK官网（https://www.oracle.com/java/technologies/javase-downloads.html）或者使用OpenJDK版本，下载适用于你的操作系统的JDK安装包。
安装JDK

按照安装向导完成JDK的安装。安装完成后，需要将JDK的bin目录添加到环境变量中。
下载Kafka

访问Apache Kafka的下载页面（https://kafka.apache.org/downloads），下载合适的Kafka版本。
解压Kafka

使用命令行工具解压下载的Kafka压缩包，例如：
```
tar -xzf kafka_2.13-3.1.0.tgz
cd kafka_2.13-3.1.0
```

启动Kafka服务器

启动Zookeeper

Kafka依赖于Zookeeper，因此需要启动Zookeeper服务。在Kafka目录下，找到bin目录，运行以下命令启动Zookeeper：
```
./bin/zookeeper-server-start.sh ./config/zookeeper.properties
```
启动Kafka服务器

启动Kafka服务器，可以在同一个bin目录下，运行以下命令：
```
./bin/kafka-server-start.sh ./config/server.properties
```

创建主题

创建一个名为test的主题：

./bin/kafka-topics.sh --create --topic test --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1

检查主题

检查是否成功创建了主题：

./bin/kafka-topics.sh --list --bootstrap-server localhost:9092

启动生产者

在命令行窗口中，启动Kafka生产者：

./bin/kafka-console-producer.sh --topic test --bootstrap-server localhost:9092

启动消费者

在另一个命令行窗口中，启动Kafka消费者：

./bin/kafka-console-consumer.sh --topic test --from-beginning --bootstrap-server localhost:9092

Kafka核心概念

主题（Topic）

主题是Kafka中消息的基本分类单元。每个主题都由一组消息的有序序列组成，这些消息根据时间顺序发布到主题中。每条消息都有一个唯一的ID，称为偏移量（Offset），用于标识消息在分区中的位置。

消息（Message）

消息是Kafka中数据的基本单元。它可以是任何类型的数据，例如文本、JSON或二进制数据。消息在生产者发送到Kafka集群后，会被分配到特定的主题中。

生产者（Producer）

生产者负责将消息发送到Kafka集群中指定的主题。生产者可以是任何可以生成消息的应用程序或服务。生产者通常会将数据序列化为字节流，并将其发送到Kafka代理（Broker）。

消费者（Consumer）

消费者从Kafka集群中拉取消息。消费者可以订阅一个或多个主题，并从这些主题中获取消息。消费者通常会将接收到的消息解序列化，并处理这些消息。Kafka支持多种消费者组（Consumer Group），每个组中的消费者可以并行地处理消息，从而实现负载均衡。

分区（Partition）

分区是Kafka主题中的一个逻辑单元。一个主题可以被划分为多个分区，每个分区可以存储大量的消息。分区为消息提供了顺序保证，并允许Kafka在多个消费者之间进行负载均衡。

副本（Replica）

副本是Kafka用来确保消息持久性的一种机制。每个主题分区可以有多个副本，其中一个副本是领导者（Leader），负责处理所有读写请求。其他副本是跟随者（Follower），它们从领导者那里同步数据，以实现数据冗余和容错。

Kafka消息重复消费的原因

在使用Kafka的过程中，可能会遇到消息重复消费的问题。这通常是由以下几个原因导致的：

生产者端重复发送消息

生产者端可能因网络问题或代码逻辑错误而将相同的消息多次发送到Kafka集群。例如，当生产者尝试发送消息时，如果网络中断，生产者可能会重新发送消息，导致消息在Kafka中重复。

消费者端重复消费消息

消费者端可能因为网络问题或代码逻辑错误而重复从Kafka中拉取消息。例如，当消费者从Kafka中拉取消息时，如果网络中断，消费者可能会重新拉取消息，导致消息的重复消费。

系统故障导致消息重复

在某些情况下，如果Kafka集群或消费者所在的系统发生故障，例如网络中断、硬件故障或Kafka代理重启，可能会导致消息重复。例如，当Kafka代理重启时，它可能会重新发送之前没有被消费的消息。

如何避免消息重复消费

为了避免消息重复消费，可以采取以下几种策略：

使用唯一标识符（ID）

为每个消息分配一个唯一的标识符（ID），例如消息的偏移量或消息的唯一标识符。在消费消息时，检查消息的唯一标识符，确保每个消息只被消费一次。

实现幂等性处理

在处理消息时，确保即使消息被重复消费，也不会影响最终的结果。例如，对于插入操作，可以通过检查记录是否已存在来避免重复插入。

采用消息去重机制

使用消息去重机制来避免重复消息的处理。例如，可以使用数据库或其他持久化存储来记录已经处理过的消息的标识符，并在消费消息之前检查消息是否已经被处理过。

使用事务支持

Kafka支持事务（Transaction）功能，可以确保消息的发送和消费是原子性的。通过使用事务，可以确保消息要么完全被发送和消费，要么被彻底丢弃，从而避免消息的重复消费。

示例代码

以下示例代码展示了如何通过不同策略避免消息重复消费。

Java代码示例

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.errors.ProducerFencedException;

import java.util.Collections;
import java.util.Properties;

public class KafkaExample {

    private static final String TOPIC_NAME = "test";
    private static final String BOOTSTRAP_SERVERS = "localhost:9092";

    public static void main(String[] args) {
        // 创建生产者
        Properties producerProps = new Properties();
        producerProps.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        producerProps.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producerProps.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> producer = new KafkaProducer<>(producerProps);

        // 创建消费者
        Properties consumerProps = new Properties();
        consumerProps.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        consumerProps.put("group.id", "test-group");
        consumerProps.put("enable.auto.commit", "true");
        consumerProps.put("auto.commit.interval.ms", "1000");
        consumerProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        consumerProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps);

        // 启动生产者发送消息
        producer.send(new ProducerRecord<>(TOPIC_NAME, "key", "value"));

        // 启动消费者消费消息
        consumer.subscribe(Collections.singletonList(TOPIC_NAME));
        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());
            }
        }
    }
}

Python代码示例

from kafka import KafkaProducer, KafkaConsumer

# 创建生产者
producer = KafkaProducer(bootstrap_servers='localhost:9092',
                         value_serializer=lambda v: str(v).encode('utf-8'))

# 创建消费者
consumer = KafkaConsumer('test',
                         bootstrap_servers='localhost:9092',
                         auto_offset_reset='earliest',
                         enable_auto_commit=True,
                         group_id='test-group',
                         value_deserializer=lambda v: v.decode('utf-8'))

# 启动生产者发送消息
producer.send('test', key='key', value='value')

# 启动消费者消费消息
for message in consumer:
    print(f"offset = {message.offset}, key = {message.key}, value = {message.value}")

常见问题及解决方案

实践中遇到的问题及应对策略

生产者端重复发送消息

生产者端可能会因网络中断或代码逻辑错误而重复发送消息。为了解决这个问题，可以使用Kafka的事务功能确保消息的唯一性。例如：

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

public class KafkaTransactionExample {

    private static final String TOPIC_NAME = "test";
    private static final String BOOTSTRAP_SERVERS = "localhost:9092";

    public static void main(String[] args) {
        // 创建生产者
        Properties producerProps = new Properties();
        producerProps.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        producerProps.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        producerProps.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        KafkaProducer<String, String> producer = new KafkaProducer<>(producerProps);

        // 开始事务
        producer.initTransactions();
        producer.beginTransaction();

        // 发送消息
        producer.send(new ProducerRecord<>(TOPIC_NAME, "key", "value"));

        // 提交事务
        producer.commitTransaction();
    }
}

消费者端重复消费消息

消费者端可能会因网络中断或代码逻辑错误而重复消费消息。为了解决这个问题，可以使用幂等性处理来确保即使消息被重复消费，也不会影响最终结果。例如：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerExample {

    private static final String TOPIC_NAME = "test";
    private static final String BOOTSTRAP_SERVERS = "localhost:9092";

    public static void main(String[] args) {
        // 创建消费者
        Properties consumerProps = new Properties();
        consumerProps.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        consumerProps.put("group.id", "test-group");
        consumerProps.put("enable.auto.commit", "true");
        consumerProps.put("auto.commit.interval.ms", "1000");
        consumerProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        consumerProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps);

        // 启动消费者消费消息
        consumer.subscribe(Collections.singletonList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                // 执行幂等性处理
                if (!record.value().equals("processed")) {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                    // 处理消息
                    // 更新消息状态
                    consumer.commitSync();
                }
            }
        }
    }
}

系统故障导致消息重复

系统故障可能导致消息重复消费。为了解决这个问题，可以使用消息去重机制来确保消息不会被重复处理。例如，使用数据库来记录已处理的消息：

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collections;
import java.util.Properties;

public class KafkaMessageDeduplicationExample {

    private static final String TOPIC_NAME = "test";
    private static final String BOOTSTRAP_SERVERS = "localhost:9092";

    public static void main(String[] args) {
        // 创建消费者
        Properties consumerProps = new Properties();
        consumerProps.put("bootstrap.servers", BOOTSTRAP_SERVERS);
        consumerProps.put("group.id", "test-group");
        consumerProps.put("enable.auto.commit", "true");
        consumerProps.put("auto.commit.interval.ms", "1000");
        consumerProps.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        consumerProps.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(consumerProps);

        // 启动消费者消费消息
        consumer.subscribe(Collections.singletonList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                // 检查消息是否已被处理
                if (isMessageProcessed(record.key())) {
                    System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                    // 处理消息
                    // 更新消息状态
                    consumer.commitSync();
                }
            }
        }
    }

    private static boolean isMessageProcessed(String key) {
        // 检查消息是否已被处理
        // 使用数据库查询是否已处理
        try (Connection conn = Database.getConnection();
             PreparedStatement stmt = conn.prepareStatement("SELECT * FROM processed_messages WHERE key = ?");
             ResultSet rs = stmt.executeQuery()) {
            stmt.setString(1, key);
            if (rs.next()) {
                return true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }
}

总的来说，确保消息的唯一性和一致性是避免消息重复消费的关键。通过合理的设计和实现，可以有效避免这类问题。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

收到一只叮咚

手记
篇

粉丝

22

获赞与收藏

112

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30809 345

网络编程入门教程

20个小节 12721 239

Pandas 入门教程

25个小节 18600 342

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Kafka重复消费教程：新手入门指南

Kafka是什么

安装Kafka环境

启动Kafka服务器

主题（Topic）

消息（Message）

生产者（Producer）

消费者（Consumer）

分区（Partition）

副本（Replica）

生产者端重复发送消息

消费者端重复消费消息

系统故障导致消息重复

使用唯一标识符（ID）

实现幂等性处理

采用消息去重机制

使用事务支持

示例代码

Java代码示例

Python代码示例

实践中遇到的问题及应对策略

生产者端重复发送消息

消费者端重复消费消息

系统故障导致消息重复

阅读免费教程