首页手记 Kafka重复消费学习：新手入门指南

Kafka重复消费学习：新手入门指南

标签：

杂七杂八

概述

本文详细介绍了Kafka的消息重复消费问题及其影响，并提供了防止重复消费的方法，如使用唯一标识符和实现幂等性消费。此外，文章还通过实战演练展示了如何在Kafka中处理重复消息，帮助读者更好地理解和应用这些方法。Kafka重复消费学习是本文的重点内容，旨在帮助开发者解决实际开发中的重复消息问题。

Kafka简介与安装

什么是Kafka

Apache Kafka 是一个开源流处理平台，由LinkedIn公司开发，后来贡献给Apache软件基金会。Kafka是一个分布式发布-订阅消息系统，也是高性能、高可用的消息中间件。它最初被设计为LinkedIn的一个活动流处理和数据管道工具，现在成为了许多公司用来构建实时数据管道和构建流应用的基础设施。

Kafka具有以下特点：

高吞吐量：能够处理每秒数以百万计的消息。
持久性：消息被持久化到磁盘，保证了数据的可靠性和系统容错性。
容错性：通过副本机制实现数据的冗余，增强系统的可靠性。
可扩展性：支持水平扩展，可以轻松地添加额外的节点来处理更多的负载。
分布式：Kafka可以部署在分布式环境中，具有较好的分布式特性。

下载与安装Kafka

环境要求

Java 8 或更高版本
Zookeeper

下载Kafka

访问Apache Kafka的官方网站，从“Download”页面下载最新版本的Kafka。这里以Kafka 2.8.0为例：

wget https://downloads.apache.org/kafka/2.8.0/kafka_2.13-2.8.0.tgz

安装Kafka

解压Kafka安装包：

tar -xzf kafka_2.13-2.8.0.tgz
cd kafka_2.13-2.8.0

启动Zookeeper：

bin/zookeeper-server-start.sh config/zookeeper.properties

默认情况下，Zookeeper将启动在端口2181。

启动Kafka服务器：

bin/kafka-server-start.sh config/server.properties

默认情况下，Kafka将在9092端口启动。

快速启动指南

创建主题

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

发送消息

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

输入一些消息，然后按回车键发送。

接收消息

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

这将显示所有已发送的消息。

Kafka核心概念

主题（Topic）

主题是Kafka中消息的类别或主题。每个生产者发送的消息都会发送到一个特定的主题中，每个消费者都可以订阅一个或多个主题来接收这些消息。例如，一个主题可能是“stock updates”，另一个主题可能是“user actions”。

创建主题

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

消息（Message）

消息是Kafka中最小的数据单元。每个消息都有一个键（key）、一个值（value）和一个时间戳。消息被发送到一个特定的主题，随后被消费者消费。

生产者（Producer）

生产者是负责发送消息到Kafka主题的客户端。生产者可以将消息批量发送到Kafka的多个分区。

生产者发送消息

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
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");

        Producer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("stock_updates", "key", "value"));
        producer.close();
    }
}

消费者（Consumer）

消费者是负责从Kafka主题订阅消息的客户端。每个消费者可以订阅一个或多个主题并消费这些主题中的消息。

消费者消费消息

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

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test");
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("stock_updates"));

        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());
            }
        }
    }
}

分区（Partition）

分区是Kafka消息的基本存储单元。每个主题可以被划分为多个分区，每个分区都是一个有序的、不可变的消息序列。分区内的消息是严格按照发送顺序进行排序的。

副本（Replica）

每个分区都有多个副本，其中一个被标记为主副本。主副本负责处理生产者发送的消息和消费者请求的消息。其余的副本是备份副本，用于故障转移和负载均衡。

Kafka消息重复问题

消息重复的原因

消息重复的原因主要有以下几个方面：

网络问题：网络延迟或不稳定可能导致消息在网络传输过程中产生重复。
消费端确认机制：如果消费端确认机制没有正确实现，可能导致消息重复。例如，消费者读取消息后如果没有等待消息被正确处理就提交偏移量。
消费者重启：消费者在处理消息时如果发生了中断（例如，重启、断电），并且在处理消息时没有提交偏移量，那么消费者在恢复时可能会重复处理之前未提交偏移量的消息。

重复消息的影响

消息重复的影响主要有以下几个方面：

数据不一致：重复的消息会导致数据处理结果的不一致性，例如，一个订单被处理多次，可能会导致库存不一致或者账单重复。
资源浪费：重复消息会增加系统资源的消耗，例如，增加数据库的写入量和存储空间的占用。
业务逻辑错误：在某些场景下，重复消息可能导致业务逻辑错误，例如，重复的转账记录可能导致账户余额错误。

识别重复消息的场景

识别重复消息的场景通常包括以下几个方面：

消费端重新处理消息：如果消费端在处理消息时发生了中断，或者消费端在处理消息时没有正确提交偏移量，那么在恢复时可能会重新处理之前未提交偏移量的消息。
消费端处理消息时发生错误：如果消费端在处理消息时发生了错误，例如，数据库连接失败，那么在恢复时可能会重新处理之前未提交偏移量的消息。
消费端确认机制不正确：如果消费端的确认机制不正确，例如，消费者在读取消息后没有等待消息被正确处理就提交偏移量，那么在恢复时可能会重新处理之前未提交偏移量的消息。

防止Kafka重复消费的方法

使用唯一标识符

使用唯一标识符是防止消息重复的一种有效方式。每个消息都具有一个唯一的标识符，这样就可以确保每个消息只被处理一次。唯一标识符通常是消息的键（key）或者其他全局唯一的标识符。

使用唯一标识符处理消息

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

public class UniqueIdConsumer {
    private Set<String> processedMessages = new HashSet<>();

    public void processMessage(ConsumerRecord<String, String> record) {
        String key = record.key();
        if (!processedMessages.contains(key)) {
            processedMessages.add(key);
            // 处理消息
        } else {
            System.out.println("Duplicate message detected, key: " + key);
        }
    }
}

实现幂等性消费

幂等性是指多次执行相同操作的结果与执行一次操作的结果相同。幂等性消费可以确保即使消息被重复发送，处理结果也不会受到影响。

实现幂等性消费

幂等性消费可以通过以下几种方式实现：

唯一标识符检查：在处理消息之前，检查消息是否已经被处理过。
数据库唯一约束：在数据库中插入一条记录时，可以使用唯一约束来防止重复插入。
幂等性ID：每个消息可以包含一个幂等性ID，确保每个消息只被处理一次。

幂等性处理示例

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

public class IdempotentConsumer {
    private Map<String, Boolean> processedMessages = new ConcurrentHashMap<>();

    public void processMessage(ConsumerRecord<String, String> record) {
        String idempotentId = record.value();
        if (!processedMessages.containsKey(idempotentId)) {
            processedMessages.put(idempotentId, true);
            // 处理消息
        } else {
            System.out.println("Duplicate message detected, idempotentId: " + idempotentId);
        }
    }
}

事务型处理数据

事务型处理数据可以确保在处理消息的过程中，如果发生失败，可以回滚到之前的状态。Kafka的事务型处理支持确保消息的原子性和一致性。

事务型处理示例

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

import java.util.Properties;

public class TransactionProducer {
    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("transaction.timeout.ms", "60000");
        props.put("enable.idempotence", "true");

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

        try {
            producer.beginTransaction();
            producer.send(new ProducerRecord<String, String>("stock_updates", "key1", "value1"));
            producer.send(new ProducerRecord<String, String>("stock_updates", "key2", "value2"));
            producer.commitTransaction();
        } catch (TransactionAttemptException e) {
            producer.abortTransaction();
        } finally {
            producer.close();
        }
    }
}

实战演练：处理重复消费

创建主题

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

生产者发送消息

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
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");

        Producer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("test_topic", "key1", "value1"));
        producer.send(new ProducerRecord<String, String>("test_topic", "key2", "value2"));
        producer.close();
    }
}

消费者消费消息

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

import java.util.Arrays;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test");
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("test_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主题。

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

import java.util.Properties;

public class DataProducer {
    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");

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

        // 发送多个消息
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("test_topic", "key" + i, "value" + i));
        }

        producer.close();
    }
}

模拟重复消息场景

为了模拟重复消息场景，可以修改生产者代码，使它重复发送相同的消息。

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

import java.util.Properties;

public class DuplicateDataProducer {
    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");

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

        // 发送消息并重复发送
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("test_topic", "key" + i, "value" + i));
            if (i == 5) {
                // 重复发送第5条消息
                producer.send(new ProducerRecord<String, String>("test_topic", "key5", "value5"));
            }
        }

        producer.close();
    }
}

实现重复消息过滤机制

我们可以使用一个简单的哈希表来记录已经处理过的消息。

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

import java.util.Arrays;
import java.util.HashMap;
import java.util.Properties;

public class DuplicateMessageFilter {
    private HashMap<String, Integer> processedMessages = new HashMap<>();

    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test");
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("test_topic"));

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

通过这种方式，我们可以检测并过滤掉重复的消息。

常见问题与解答

常见错误及解决方法

生产者或消费者无法连接到Kafka：确保Kafka服务器正在运行，并且网络连接正确。
消息发送失败：检查生产者配置是否正确，例如，序列化器和键值类型是否匹配。
消费者无法读取消息：确保消费者配置中的主题名和Kafka服务器中的主题名一致，并且消费者组ID正确。

重复消息处理的注意事项

确保幂等性：幂等性处理可以确保即使消息被重复发送，处理结果也不会受到影响。
使用唯一标识符：使用唯一标识符可以确保每个消息只被处理一次。
事务型处理：事务型处理数据可以确保在处理消息的过程中，如果发生失败，可以回滚到之前的状态。

确保幂等性的示例

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

import java.util.Properties;

public class IdempotentProducer {
    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("enable.idempotence", "true");

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

        producer.send(new ProducerRecord<String, String>("stock_updates", "key1", "value1"));
        producer.send(new ProducerRecord<String, String>("stock_updates", "key1", "value1")); // 重复发送相同消息

        producer.close();
    }
}

使用唯一标识符的示例

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

public class UniqueIdConsumer {
    private Set<String> processedMessages = new HashSet<>();

    public void processMessage(ConsumerRecord<String, String> record) {
        String key = record.key();
        if (!processedMessages.contains(key)) {
            processedMessages.add(key);
            // 处理消息
        } else {
            System.out.println("Duplicate message detected, key: " + key);
        }
    }
}

事务型处理的示例

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

import java.util.Properties;

public class TransactionProducer {
    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("transaction.timeout.ms", "60000");
        props.put("enable.idempotence", "true");

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

        try {
            producer.beginTransaction();
            producer.send(new ProducerRecord<String, String>("stock_updates", "key1", "value1"));
            producer.send(new ProducerRecord<String, String>("stock_updates", "key2", "value2"));
            producer.commitTransaction();
        } catch (TransactionAttemptException e) {
            producer.abortTransaction();
        } finally {
            producer.close();
        }
    }
}

进阶资源推荐

官方文档：Apache Kafka的官方文档提供了详细的开发指南和配置说明。
在线课程：慕课网提供了多个关于Kafka的在线课程，包括基础入门和高级应用。
社区支持：加入Kafka相关的社区和论坛，可以获取更多技术支持和交流分享。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

守着一只汪

手记
篇

粉丝

11

获赞与收藏

37

关注作者，订阅最新文章

阅读免费教程

后端通用面试教程

41个小节 30787 345

网络编程入门教程

20个小节 12720 239

Pandas 入门教程

25个小节 18599 341

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Kafka重复消费学习：新手入门指南

什么是Kafka

下载与安装Kafka

环境要求

下载Kafka

安装Kafka

快速启动指南

创建主题

发送消息

接收消息

主题（Topic）

创建主题

消息（Message）

生产者（Producer）

生产者发送消息

消费者（Consumer）

消费者消费消息

分区（Partition）

副本（Replica）

消息重复的原因

重复消息的影响

识别重复消息的场景

使用唯一标识符

使用唯一标识符处理消息

实现幂等性消费

实现幂等性消费

幂等性处理示例

事务型处理数据

事务型处理示例

实战演练：处理重复消费

创建主题

生产者发送消息

消费者消费消息

生成并发送数据

模拟重复消息场景

实现重复消息过滤机制

常见错误及解决方法

重复消息处理的注意事项

确保幂等性的示例

使用唯一标识符的示例

事务型处理的示例

进阶资源推荐

阅读免费教程