Kafka 入门到实战：从安装配置到消息生产消费全流程

原创于 2025-12-12 15:36:46 发布 · 323 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#kafka #分布式 #java

Java 进阶同时被 2 个专栏收录

69 篇文章

订阅专栏

Kafka

4 篇文章

订阅专栏

在分布式系统中，消息队列是实现系统解耦、异步通信和流量削峰的核心组件，而 Apache Kafka 凭借其高吞吐量、高可靠性、可扩展性等优势，成为当前最主流的消息中间件之一。无论是日志收集、实时数据处理，还是微服务间通信，Kafka 都扮演着至关重要的角色。本文将从 Kafka 的核心概念出发，手把手带大家完成从环境搭建、配置优化到消息生产消费的全流程实战，帮助新手快速上手 Kafka。

一、Kafka 核心概念速览

在开始实操前，我们需要先理清 Kafka 的核心术语，这是理解后续操作的基础。Kafka 的架构相对简洁，主要包含以下核心组件：

1. 生产者（Producer）

消息的发送者，负责将业务数据封装成消息并发送到 Kafka 集群。生产者可以通过配置确认机制（ACK）来保证消息的可靠性，同时支持批量发送以提高吞吐量。

2. 消费者（Consumer）

消息的接收者，从 Kafka 集群中拉取消息并进行业务处理。消费者通常以**消费者组（Consumer Group）**的形式工作，同一消费者组内的消费者共同消费一个主题的消息，避免重复消费；不同消费者组则可以独立消费同一主题的消息。

3. 主题（Topic）

消息的分类容器，生产者将消息发送到指定主题，消费者从指定主题拉取消息。主题是逻辑上的概念，物理上会被划分为多个分区（Partition），分区是 Kafka 实现高吞吐量和并行处理的核心。

4. 分区（Partition）

每个主题可以包含多个分区，分区内的消息按发送顺序存储为有序的日志（Log），并以偏移量（Offset）标记消息的位置。分区的数量决定了主题的并行处理能力，通常建议根据业务吞吐量设置合理的分区数（如与消费者组内的消费者数量匹配）。

5. 副本（Replica）

为保证分区的高可用性，Kafka 会为每个分区创建多个副本。副本分为首领副本（Leader）和跟随者副本（Follower），生产者和消费者仅与首领副本交互，跟随者副本负责同步首领副本的数据，当首领副本故障时，跟随者副本会通过选举机制成为新的首领。

6. 集群（Cluster）

由多个 Kafka 服务器（Broker）组成，每个 Broker 是一个独立的服务节点，负责存储分区数据和处理客户端请求。集群通过 ZooKeeper（旧版本）或 KRaft（新版本）进行元数据管理、首领选举和负载均衡。

核心逻辑总结：生产者将消息发送到 Topic 的 Partition，消费者组从 Partition 拉取消息，Partition 的副本机制保证高可用，集群通过协调组件实现分布式管理。

二、Kafka 环境搭建与配置（Linux 系统）

Kafka 运行依赖 Java 环境，因此首先需要安装 JDK，推荐使用 JDK 11 及以上版本。本文以 Kafka 3.6.0 版本（支持 KRaft 模式，无需依赖 ZooKeeper）为例进行讲解。

1. 安装前准备：配置 Java 环境

下载 JDK：从 Oracle 官网或 OpenJDK 官网下载 JDK 11，例如openjdk-11-jdk_x64_linux.tar.gz。
解压并配置环境变量：
`# 解压到指定目录
tar -zxvf openjdk-11-jdk_x64_linux.tar.gz -C /usr/local/

配置环境变量（编辑 /etc/profile 文件）

echo “export JAVA_HOME=/usr/local/openjdk-11” >> /etc/profile
echo “export PATH=$JAVA_HOME/bin:$PATH” >> /etc/profile

生效环境变量

source /etc/profile

验证安装

java -version`

2. 安装并配置 Kafka

下载 Kafka：从 Kafka 官网（https://kafka.apache.org/downloads）下载二进制包，例如 kafka_2.13-3.6.0.tgz（2.13 是 Scala 版本，3.6.0 是 Kafka 版本）。
解压 Kafka：
tar -zxvf kafka_2.13-3.6.0.tgz -C /usr/local/ cd /usr/local/kafka_2.13-3.6.0
配置 KRaft 模式（重点）：
Kafka 3.0+ 推荐使用 KRaft 模式替代 ZooKeeper，简化集群部署。核心配置文件为 config/kraft/server.properties，关键配置项如下：`# 节点唯一 ID（集群中每个 Broker 需不同，取值范围 0-2147483647）
node.id=1

监听地址（PLAINTEXT 为无加密协议，端口默认 9092）

listeners=PLAINTEXT://:9092

广告地址（客户端实际连接的地址，若为远程访问需配置服务器 IP）

advertised.listeners=PLAINTEXT://192.168.1.100:9092

日志存储目录（分区数据和元数据的存储路径）

log.dirs=/usr/local/kafka_2.13-3.6.0/logs

集群 ID（需先通过命令生成）

cluster.id=abc12345-xxxx-xxxx-xxxx-xxxxxxxxx

分区副本数（默认 1，生产环境建议设置 2-3 保证高可用）

default.replication.factor=2

主题默认分区数（默认 1，根据业务吞吐量调整）

num.partitions=3`

生成集群 ID 并初始化集群：
`# 生成集群 ID（记录输出的 ID，配置到 server.properties 中）
./bin/kafka-storage.sh random-uuid

初始化存储目录（使用上述生成的集群 ID）

./bin/kafka-storage.sh format -t 集群ID -c config/kraft/server.properties`

3. 启动与停止 Kafka 服务

启动 Kafka：
`# 前台启动（便于查看日志，适合调试）
./bin/kafka-server-start.sh config/kraft/server.properties

后台启动（生产环境推荐）

./bin/kafka-server-start.sh -daemon config/kraft/server.properties`

停止 Kafka：
./bin/kafka-server-stop.sh
验证服务状态：通过端口监听确认 Kafka 是否启动成功（默认端口 9092）：
netstat -tuln | grep 9092

三、Kafka 核心操作：主题、生产者与消费者

Kafka 提供了命令行工具用于管理主题、测试生产消费，同时也支持通过 Java、Python 等语言的客户端进行开发。本节先讲解命令行操作，再介绍 Java 客户端的实战代码。

1. 主题管理（命令行）

主题是消息的载体，所有生产消费操作都围绕主题展开，常见操作如下：


# 1. 创建主题（指定分区数 3，副本数 2）
./bin/kafka-topics.sh --create --topic test_topic --partitions 3 --replication-factor 2 --bootstrap-server 192.168.1.100:9092

# 2. 查看所有主题
./bin/kafka-topics.sh --list --bootstrap-server 192.168.1.100:9092

# 3. 查看主题详情（分区、副本分布等）
./bin/kafka-topics.sh --describe --topic test_topic --bootstrap-server 192.168.1.100:9092

# 4. 修改主题（例如增加分区数，注意：分区数只能增加不能减少）
./bin/kafka-topics.sh --alter --topic test_topic --partitions 5 --bootstrap-server 192.168.1.100:9092

# 5. 删除主题（需确保 server.properties 中 delete.topic.enable=true）
./bin/kafka-topics.sh --delete --topic test_topic --bootstrap-server 192.168.1.100:9092

2. 命令行生产消费测试

通过 Kafka 自带的命令行工具，可以快速测试主题的生产消费功能：

启动消费者（监听 test_topic 主题）：
./bin/kafka-console-consumer.sh --topic test_topic --bootstrap-server 192.168.1.100:9092 --from-beginning参数说明：--from-beginning 表示从主题的第一条消息开始消费。
启动生产者（向 test_topic 主题发送消息）：./bin/kafka-console-producer.sh --topic test_topic --bootstrap-server 192.168.1.100:9092输入任意文本并回车，即可在消费者终端看到对应的消息，说明生产消费流程正常。

3. Java 客户端实战：生产消费消息

实际开发中，我们更多通过 Kafka 客户端 API 实现生产消费。Kafka 官方提供了 Java 客户端，以下是基于 Kafka 3.6.0 的实战代码。

步骤 1：引入依赖（Maven）


<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>3.6.0</version>
</dependency>

步骤 2：生产者代码实现（发送消息）

生产者核心配置包括集群地址、消息序列化方式、ACK 确认机制等，代码如下：


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.common.serialization.StringSerializer;
import java.util.Properties;

public class KafkaProducerDemo {
    // Kafka 集群地址
    private static final String BOOTSTRAP_SERVERS = "192.168.1.100:9092";
    // 主题名称
    private static final String TOPIC = "test_topic";

    public static void main(String[] args) {
        // 1. 配置生产者参数
        Properties props = new Properties();
        // 集群地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
        // 消息键的序列化方式（键用于分区分配，相同键的消息会发送到同一分区）
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 消息值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // ACK 确认机制（1：首领副本接收成功即返回；all：所有同步副本接收成功才返回，可靠性最高）
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        // 重试次数（消息发送失败时的重试次数）
        props.put(ProducerConfig.RETRIES_CONFIG, 3);
        // 批量发送大小（当消息达到 16KB 时批量发送）
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 批量发送延迟（10ms 内未达到批量大小也会发送）
        props.put(ProducerConfig.LINGER_MS_CONFIG, 10);

        // 2. 创建生产者实例
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);

        // 3. 发送消息（同步发送，便于获取发送结果；异步发送可通过回调函数处理结果）
        try {
            for (int i = 0; i < 10; i++) {
                // 构建消息（参数：主题、消息键、消息值）
                ProducerRecord<String, String&gt; record = new ProducerRecord<>(
                        TOPIC,
                        "key-" + i,
                        "Kafka message - " + i
                );
                // 同步发送消息
                producer.send(record).get();
                System.out.println("Sent message: " + i);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭生产者（释放资源）
            producer.close();
        }
    }
}

步骤 3：消费者代码实现（拉取消息）

消费者核心配置包括集群地址、消息反序列化方式、消费者组 ID、偏移量提交方式等，代码如下：


import org.apache.kafka.clients.consumer.ConsumerConfig;
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.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerDemo {
    private static final String BOOTSTRAP_SERVERS = "192.168.1.100:9092";
    private static final String TOPIC = "test_topic";
    // 消费者组 ID（同一组内消费者共同消费主题，组 ID 必须唯一）
    private static final String GROUP_ID = "test_consumer_group";

    public static void main(String[] args) {
        // 1. 配置消费者参数
        Properties props = new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, BOOTSTRAP_SERVERS);
        // 消费者组 ID
        props.put(ConsumerConfig.GROUP_ID_CONFIG, GROUP_ID);
        // 消息键的反序列化方式
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        // 消息值的反序列化方式
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        // 偏移量提交方式（true：自动提交；false：手动提交，更灵活控制消息消费可靠性）
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        // 自动提交偏移量的间隔时间（仅当自动提交开启时生效）
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, 1000);
        // 消费者启动时的偏移量位置（earliest：从最开始消费；latest：从最新消息开始消费）
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        // 2. 创建消费者实例
        KafkaConsumer&lt;String, String&gt; consumer = new KafkaConsumer<>(props);

        // 3. 订阅主题（可订阅单个或多个主题，此处订阅 test_topic）
        consumer.subscribe(Collections.singletonList(TOPIC));

        // 4. 循环拉取消息（消费者是长轮询模型，需持续拉取）
        try {
            while (true) {
                // 拉取消息（超时时间 100ms，若没有消息则返回空）
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                // 遍历处理消息
                for (ConsumerRecord<String, String> record : records) {
                    System.out.printf(
                            "Received message: topic=%s, partition=%d, offset=%d, key=%s, value=%s%n",
                            record.topic(),
                            record.partition(),
                            record.offset(),
                            record.key(),
                            record.value()
                    );
                }
                // 手动提交偏移量（确保消息处理完成后再提交，避免消息丢失）
                consumer.commitSync();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 关闭消费者（自动提交最终的偏移量）
            consumer.close();
        }
    }
}

四、常见问题与优化技巧

1. 常见问题排查

生产者无法发送消息：检查 Kafka 服务是否正常运行；确认 advertised.listeners 配置的地址是否可被生产者访问；检查主题是否存在。
消费者无法拉取消息：确认消费者组 ID 配置正确；检查 AUTO_OFFSET_RESET_CONFIG 配置（若设置为 latest，需确保有新消息发送）；检查主题权限是否允许消费。
消息重复消费：消费者手动提交偏移量时，若消息处理完成前程序崩溃，会导致偏移量未提交，重启后重复消费。解决方案：通过业务唯一 ID 实现幂等性处理，或使用 Kafka 的事务机制。
消息丢失：生产者 ACK 机制设置为 1 或 0 时，若首领副本故障可能导致消息丢失；消费者自动提交偏移量时，若消息未处理完成就提交偏移量，程序崩溃会导致消息丢失。解决方案：生产者 ACK 设为 all，消费者使用手动提交偏移量。

2. 性能优化技巧

主题优化：根据业务吞吐量设置合理的分区数（建议每个分区的吞吐量控制在 1000-5000 条/秒）；生产环境副本数设置为 2-3，平衡可用性和性能。
生产者优化：开启批量发送（调整 BATCH_SIZE_CONFIG 和 LINGER_MS_CONFIG）；使用异步发送减少等待时间；合理设置消息压缩方式（COMPRESSION_TYPE_CONFIG，推荐 gzip）。
消费者优化：消费者组内的消费者数量与主题分区数保持一致（避免资源浪费或分区分配不均）；增大拉取消息的批量大小（MAX_POLL_RECORDS_CONFIG）；避免在消费线程中执行耗时操作，可通过线程池异步处理消息。
服务器优化：选择高性能的磁盘（如 SSD）存储日志；调整 JVM 堆大小（建议 4-8G）；关闭磁盘缓存刷盘的同步机制（通过 log.flush.interval.messages 配置异步刷盘）。