中间件框架学习笔记（1）Kafka

Kafka是什么

kafka是高吞吐，分布式、基于发布/订阅的消息系统。

Broker是什么

Broker 是 Kafka 集群中的一个节点或服务器，负责存储和管理主题的分区（Partition），并处理生产者和消费者的读写请求

主要职责：

1. 消息存储

   • 每个主题分为多个分区，分区的消息数据被存储在不同的 Broker 上
   • Broker 使用高效的日志文件存储方式进行持久化，确保消息的可靠性

2. 消息的生产和消费

   • 生产者（Producer）将消息发送到某个主题，Broker 接收消息并存储到对应的分区。
   • 消费者（Consumer）从 Broker 拉取消息，Broker 按消费者的偏移量提供数据。

3. 分区和副本管理

   • 每个分区的主副本（Leader）由一个 Broker 管理，其他 Broker 管理该分区的副本
   • Broker 协同处理分区的复制、同步和主副本选举，保证数据高可用性

4. 协调和负载均衡

   • Broker 与 ZooKeeper 或 Kafka 集群的控制器协作，协调分区的分配，确保负载均衡
   • 在集群中动态调整分区或节点之间的负载。

Kafka Broker 的核心特性

1. 分布式架构
2. 分区的主从机制
3. 动态扩展
4. 持久化与高效的读写

Broker与其他组件的关系

1. 生产者：

   • 生产者通过分区键或分区器，将消息发送到特定的分区。Broker 接收并存储消息。

2. 消费者：

   • 消费者通过偏移量，从 Broker 中拉取消息。Broker 记录偏移量，确保消费的一致性。

3. ZooKeeper（Kafka 早期版本）：

   • 管理 Broker 的元数据和状态信息，比如分区副本的位置。
   • Broker 会定期向 ZooKeeper 报告状态信息。
   • Kafka 新版本（2.8+）移除了对 ZooKeeper 的依赖，使用 Kafka 自身的 Raft 协议管理元数据。

Producer是什么

Producer（生产者）是用于向 Kafka 集群的 Topic 发送消息的组件或角色。生产者通常是业务系统的一部分，用于将系统中的数据或事件传递到 Kafka 中供其他系统消费。

Producer主要作用与特点

1. 数据发送

   • Producer负责将数据写入到Kafka的某个Topic中
   • Producer会按照分区策略将消息分配到指定的Partiton

2. 可扩展性

   • kafka的Producer是分布式的，可以部署多个实例以提高吞吐量

3. 可靠性

   • Producer可以配置消息的可靠性级别（acks参数），确保被成功写入Kafka集群

4. 灵活性

   • Producer支持发送同步或者异步消息

Producer的核心功能

1. 消息发送机制

   • Producer会根据配置选择将消息发送到哪个分区。分区的选择方式包括：

     • 指定分区：由开发者指定消息的目标分区
     • 基于Key的分区；通过消息的Key计算目标分区（默认使用Hash函数）
     • 轮询分区：如果没有指定分区或Key，Kafka以轮询的方式分配分区

2. 序列化

   • 在发送消息之前，Producer会将数据对象序列化为字节数组（byte[]），以便 Kafka 存储和传输
   • kafka也提供了默认的序列化器，也可以自定义实现

3. 重试机制：

   • 如果发送消息失败（如网络故障或Kafka暂时不可用），Producer会根据配置进行自动重试

4. 支持批量发送

   • Producer 支持将多条消息批量发送到 Kafka，减少网络开销并提高吞吐量

5. 压缩

   • 支持对消息进行压缩（如 gzip、snappy 等），进一步优化传输性能

Producer的配置参数

参数	说明	默认值
bootstrap.servers	Kafka 集群的地址列表，Producer 用于连接 Kafka。	无(必须配置)
key.serializer	指定Key的序列化器	无(必须配置）
value.serializer	指定value的序列化器	无(必须配置）
acks	确认机制：0（不确认）、1（Leader确认）、all（所有副本确认）	1
retries	发送失败时的重试次数	0
batch.size	批量发送的最大消息字节数	16KB
linger.ms	消息发送的延迟时间	0
compression.type	消息压缩类型（none、gzip、snappy、lz4	none

Producer的工作流程

1. 初始化连接

   • 生产者通过 bootstrap.servers 参数连接到 Kafka 集群

2. 消息序列化

   • 将消息的 key 和 value 序列化为字节数组

3. 分区选择

   • 根据分区策略（如 key 或轮询）决定消息要写入的分区

4. 发送消息

   • Producer 将消息发送到 Kafka 中指定 Partition 的 Leader 副本

5. 确认接收

   • Producer 根据 acks 设置等待 Kafka 的确认

6. 重试机制

   • 如果消息发送失败，Producer 会尝试重试（重试次数由 retries 决定）。

Producer的示例代码

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) {
        // 配置 Producer 参数
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); // Kafka 集群地址
        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", 3);

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

        // 发送消息
        for (int i = 0; i < 10; i++) {
            String key = "key" + i;
            String value = "message" + i;
            ProducerRecord<String, String> record = new ProducerRecord<>("my-topic", key, value);
            producer.send(record, (metadata, exception) -> {
                if (exception == null) {
                    System.out.println("Message sent to partition " + metadata.partition() +
                                       ", offset " + metadata.offset());
                } else {
                    exception.printStackTrace();
                }
            });
        }

        // 关闭 Producer
        producer.close();
    }
}

Consumer是什么

Consumer（消费者） 是用于从 Kafka 集群中 Topic 读取消息的组件或角色。Consumer 通常与 Producer 配合使用，形成完整的数据流动模型。它可以是一个单独的服务或应用，用于处理 Kafka 中的消息。

Consumer的特点和作用

1. 消息消费

   • Consumer 从 Kafka 的 Partition 中顺序读取消息，保证消息的处理顺序性

2. 分组消息

   • 多个 Consumer 可以组成一个 Consumer Group，通过分组机制实现负载均衡

3. 自动提交位移

   • Consumer 可以自动或手动管理位移（offset），确保消息不会重复消费或丢失

4. 灵活性

   • Consumer 支持同步和异步消息处理模式

Consumer的核心功能

1. 分组消费机制：

   • kafka通过Consumer Group来分配消息任务：

     • 同一组的多个Consumer实例会共享消费一个Topic的消息，每个分区只能被一个Consumer实例消费
     • 不同组的Consumer可以独立消费相同的Topic数据

2. 消费位移管理

   • 位移（Offset）是在消息分区中的唯一标识。

   • Consumer会跟踪每个分区的位移，决定从哪个开始消费

     • 自动提交：周期性的将位移提交给Kafka
     • 手动提交：由应用程序明确指定提交的时机

3. 负载均衡

   • Kafka 自动将 Topic 的分区分配给 Consumer Group 中的实例
   • 当 Consumer 实例数量变化时，Kafka 会重新平衡分区分配

4. 可靠性：

   • Consumer 可以通过手动提交位移，确保消息不会丢失。
   • 在消费失败时，Consumer 可以重新读取位移，重新处理消息。

Consumer的工作流程

1. 订阅Topic：

   • Consumer指定要订阅的Topic

2. 分配分区

   • Kafka根据分区分配的策略，将分区分配给Consumer Group中的Consumer

3. 读取消息：

   • Consumer 按顺序从分区读取消息

4. 处理消息

   • 应用程序处理消息内容

5. 提交位移

   • 自动或手动提交位移，更新已消费的消息位置。

Consumer的配置参数

参数	说明	默认值
bootstrap.servers	kafka集群地址	无（必须配置）｜
group.id	Consumer Group 的 ID，决定多个 Consumer 是否属于同一组。	无
key.serializer	消息key的反序列化器	无(必须配置)
value.serializer	消息value的反序列化器	无(必须配置)
auto.offset.reset	消费者启动时的位移策略（earliest、latest）。	latest
enable.auto.commit	是否启用自动提交位移。	true
session.timeout.ms	消费者的会话超时时间，超过此时间认为消费者失效。	10000

Consumer的示例代码

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

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

public class KafkaConsumerExample {
    public static void main(String[] args) {
        // 配置 Consumer 参数
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "test-group"); // Consumer Group ID
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("enable.auto.commit", "true");
        props.put("auto.offset.reset", "earliest");

        // 创建 KafkaConsumer
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);

        // 订阅 Topic
        consumer.subscribe(Collections.singletonList("my-topic"));

        // 持续拉取消息
        try {
            while (true) {
                ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(100));
                for (ConsumerRecord<String, String> record : records) {
                    System.out.printf("Partition: %d, Offset: %d, Key: %s, Value: %s%n",
                            record.partition(), record.offset(), record.key(), record.value());
                }
            }
        } finally {
            consumer.close();
        }
    }
}

Consumer的优势

1. 高吞吐

   • 支持批量拉取数据，减少网络开销

2. 灵活性

   • 消费者可以控制消息的处理速度和顺序

3. 可靠性

   • 提供位移管理机制，确保消息消费的可靠性

4. 分布式扩展

   • 支持通过Consumer Group实现负载均衡

Topic是什么？

Topic 是一种逻辑上的消息分类标识，可以理解为消息的 主题 或 类别。生产者（Producer）将消息发布到指定的 Topic，而消费者（Consumer）从特定的 Topic 中订阅并消费消息。

Topic的核心功能

1. 分类管理：

   • 将不同类型的消息分配到不同的 Topic，例如订单、支付、日志等业务可以分别使用不同的 Topic。

2. 高效存储：

   • 通过分区和副本机制，Topic 数据可以分布存储在多个 Kafka Broker 上，提高可靠性和可扩展性。

3. 灵活消费：

   • 支持多种消费模型（点对点、发布订阅）。
   • 消费者可以选择从某个时间点开始消费消息。

Kafka 中的 Topic 是如何存储的？

1. 分区存储：

   • Topic 是分区化的，每个分区独立存储在磁盘上。
   • 每个分区对应一个 日志文件（append-only log）。

2. 副本机制：

   • 为了保证可靠性，每个分区有多副本（Replica）。
   • Kafka 会将副本分布在不同的 Broker 上，防止单点故障。

3. 分区内消息的顺序：

   • 消息在分区内是按生产的顺序存储的，因此 Kafka 能够提供分区内的顺序消费保证。

什么是Partition？

Partition（分区） 是 Topic（主题）的基本存储单元，也是 Kafka 实现高吞吐量和分布式架构的核心概念。每个 Topic 可以划分为一个或多个 Partition，数据最终存储在分区中。

Partition 的分配策略

当生产者将消息发送到 Kafka 时，会根据分区策略决定消息发送到哪个 Partition。常见的分配方式包括：

1. 随机分配（Round-Robin）：

   • 如果没有指定分区，Kafka 默认采用随机分配的方式将消息分配到可用的 Partition 中。

2. 按键分配（Key-based Partitioning）：

   • 如果消息中包含 Key，Kafka 会对 Key 进行哈希运算，并根据哈希值将消息分配到对应的 Partition。
   • 优势：相同 Key 的消息总是被分配到同一个 Partition，从而保证分区内的消息顺序。

3. 指定分区（Explicit Partitioning）：

   • 生产者可以在发送消息时直接指定目标 Partition。

Partition 的存储结构

1. 日志文件：

   • 每个 Partition 是一个日志文件的集合，分段存储（Segment）。
   • 每个日志段文件包含多个消息，每个消息都有唯一的偏移量。

2. 索引文件：

   • Kafka 为每个 Partition 创建了索引文件，用于快速定位特定消息。

3. 存储路径：

   • Partition 的数据存储在磁盘上，路径为：<Kafka数据目录>/<Topic名>-<分区号>/

Partition 数量的选择需综合考虑：

1. 消费者的并发数：分区数 >= 消费者线程数。
2. 数据量：更多的分区可以分布存储更多数据。
3. 网络带宽：过多分区可能导致网络开销增加。

什么是Replica

副本（Replica） 是分区（Partition）的冗余备份，用于保证数据的高可用性和可靠性。每个分区可以有一个或多个副本，这些副本分布在不同的 Broker 上。

副本的角色

Kafka 的副本机制包括以下两种角色：

1. Leader 副本：

   • 每个分区的所有读写操作只能由它的 Leader 副本负责。
   • Leader 副本是分区的主副本，由 Kafka 的控制器动态分配。

2. Follower 副本：

   • 其他非 Leader 副本称为 Follower 副本。
   • Follower 副本从 Leader 副本同步数据，保持与 Leader 数据一致。
   • 如果 Leader 副本发生故障，Kafka 会选举一个同步完成的 Follower 副本作为新的 Leader。

副本的同步

Kafka 中，Follower 副本会通过拉取（Pull）机制从 Leader 副本同步数据：

• Follower 副本周期性地向 Leader 副本请求未同步的数据。
• 如果 Follower 副本长期未能同步数据，它会被认为是离线副本，Kafka 将不再将其视为可用副本。

ISR（In-Sync Replica）

• ISR 是指与 Leader 保持同步的副本集合。
• 只有 ISR 中的副本才有资格在 Leader 副本失效时被选为新的 Leader。
• Kafka Broker 定期检查 ISR 集合，并动态调整。

副本的机制与流程

1. 数据写入：

   • 生产者将消息发送到分区的 Leader 副本，Leader 负责将消息写入本地存储。
   • 同时，Follower 副本从 Leader 拉取消息并同步数据。

2. 数据读取：

   • 消费者只能从 Leader 副本读取数据。

3. Leader 切换：

   • 如果 Leader 副本发生故障，Kafka 会从 ISR 集合中选举一个 Follower 副本作为新的 Leader，保证服务不中断。

副本的重要参数

1. replication.factor：

   • 副本因子，表示每个分区的副本数量。
   • 推荐值为 3，实现 Leader 和两个 Follower 副本的冗余。

2. min.insync.replicas：

   • 表示写操作成功需要至少同步的副本数量。
   • 如果低于该数量，Kafka 会拒绝写入操作。

什么是Record？

Record 是生产者发送给 Kafka 的一条消息，也是 Kafka 消息存储的基本单元。可以将 Record 理解为 Kafka 数据传输的核心载体。每个 Record 包含了一条消息的数据和相关的元信息，用于实现高效的消息队列服务。

Kafka Record 的组成

1. Key（键）：
   • 可选字段。
   • 用于对消息进行分区（Partition）。生产者可以根据 Key 的哈希值决定消息写入哪个分区。
   • 如果未设置 Key，消息会随机分配到分区（或使用轮询策略）。
2. Value（值）：
   • 必填字段。
   • 消息的具体内容，例如 JSON、字符串或序列化后的二进制数据。
3. Topic（主题）：
   • 记录所属的主题，用于组织和分类消息。
4. Partition（分区）：
   • 记录写入的目标分区。
   • 由 Kafka 根据 Key 或分区策略决定。
5. Offset（偏移量）：
   • 消息在分区中的唯一标识（位于分区日志中的位置）。
   • Offset 由 Kafka 自动分配，用于标记消费的进度。
6. Timestamp（时间戳）：
   • 可选字段。
   • 记录消息的发送时间或写入时间，取决于生产者配置的时间戳类型。
7. Headers（头信息）：
   • 可选字段。
   • 用于存储一些额外的元数据（例如，标签、标识符等），便于扩展和处理。

Kafka的关键三个功能

1. 消息队列功能（消息持久化和传递）

kafka提供强大的消息订阅功能，支持发布（Producer）和订阅（Consumer）模型。 消息在kafka中以主题（Topic）为单位进行分类和组织。

关键点：

• 消息存储：

  • Kafka会将接受的消息持久化到磁盘，并通过日志分区实现高效的顺序写入于读取
  • 消息不会因为消费而被立刻清除，消费者可以根据偏移量（Offset）自行决定合适读取

• 消息传递模式

  • 点对点：特定消费者从特定分区读取消息
  • 发布/订阅 ：多个消费者订阅同一个主题，彼此互不干扰

• 优点

  • 高效存储和传递大量数据。
  • 消息处理的可靠性和可重试性。

2. 分布式日志存储（事件流）

kafka不仅是一个消息队列，还提供分布式日志存储能力，适用于事件流和存储的处理

关键点：

• 分区（Partition）与分布式

  • 每个主题可以被划分为多个分区，分区可以分布在不同的kafka Broker上，实现水平扩展

• 顺序性：

  • 每个分区内的消息是有序的，消费者可以以顺序方式处理事件流

• 事件流保留

  • kafka支持基于时间或存储大小的日志保存策略，允许消息在一段时间内可供重复读取

优点：

• 适用于事件驱动架构，便于流式处理
• 提供了一个长期的事件存储，适合回溯和重新处理

3. 数据集成（实时流处理平台）

Kafka 通过其生态系统（如 Kafka Connect 和 Kafka Streams）提供强大的数据集成和流处理能力。

• 关键点

• Kafka Connect：

  • 提供连接器（Connectors）将数据从外部系统（数据库，文件系统）导入Kafka或者从Kafka导出到其他系统
  • 典型连接器包括JDBC、ES、EDFS

• Kafka Streams：

  • 是Kafka的流处理API，允许开发者直接在Kafka消息上执行实时的转换，聚合等流处理操作
  • 支持无状态（map，filter）和有状态（window，join）的数据处理

• Schema Registry：

  • 提供对消息格式的管理，支持 Avro、JSON Schema 等格式，保证生产者和消费者的数据一致性

优点：

• 实现了系统间的无缝集成，适合构建实时 ETL 和数据管道。
• 提供分布式流处理功能，简化实时计算。

总结：

1. 消息队列：高效可靠的消息传递和持久化存储
2. 分布式日志存储：适合事件流存储和回溯处理
3. 数据的集成和流处理：系统间数据集成和实时的流计算

kafka通常用于两大类应用

一、构建实时数据管道

具体用途：

1. 日志的收集和聚合

   • 将分布式系统的日志（如 Web 服务器日志、数据库日志）汇聚到 Kafka，再通过消费端处理或持久化到存储系统（如 HDFS、Elasticsearch）。

2. 事件驱动架构

   • Kafka可以作为事件的总线，支持服务之间通过事件进行异步通信
   • 例如：订单服务生成订单事件，库存服务消费该事件以更新库存

3. 数据分发：

   • 数据从生产者写入kafka后，可被多个消息者实时订阅和处理
   • 适用于多数据消费者的场景，例如实时分析、批处理任务和离线存储。

4. ETL数据管道：

   • Kafka配合Kafka Connect可以作为数据的实时ETL工具, 帮助系统从源系统抽取数据, 进行简单转换后加载到目标系统

二、构建实时流处理系统

Kafka 可作为实时流数据处理的核心组件，通过 Kafka Streams 等工具支持高性能的流式数据处理

具体用途：

1. 实时监控分析：

   • 数据从各种来源流入Kafka，通过流引擎处理（Kafka Stream, Flink）实时分析并生成结果
   • 例如：金融交易系统中的欺诈检测

2. 实时数据处理和聚合

   • 对流式数据进行聚合、过滤、转换等操作，例如实时计算用户行为指标、订单金额汇总

3. 处理复杂事件

   • Kafka Streams 支持对流数据进行复杂的多级处理，例如窗口化计算（Sliding Window、Tumbling Window）、状态管理和多流 Join。

4. 实时推荐系统

   • 用户点击行为流经 Kafka，实时处理后生成个性化推荐，推送到前端

优势:

• 消息顺序性和分区特性为流式处理提供了基础。
• 支持无状态和有状态的流式计算。
• 与 Kafka 的集成非常紧密，简化实时处理的开发与运维。

kafka应用场景示例

1. 日志系统：

   • 生产者：各种应用系统和服务器日志
   • Kafka：日志的统一存储和分发
   • 消费者：实时监控系统，数据存储系统（如：HDFS或S3）

2. 订单处理系统

   • 生产者：订单服务产生的订单事件。
   • Kafka：分发订单事件到库存服务，支付服务和分析服务
   • 消费着：实时更新库存，支付状态和订单状态

3. 实时数据分析：

   • 生产者：IoT设备发送的传感器数据
   • Kafka：存储和分发传感器数据
   • 消费者：流处理引擎执行实时分析并生成警报

Kafka的特性

1. 高吞吐和低延迟

   • 高吞吐

     • kafka的底层设计基于分区日志，使用顺序写入和零拷贝技术，在硬盘I/O性能上极为高效
     • 单个Kafka集群可以处理数百万的消息每秒

   • 低延迟

     • 在正常负载下，消息从生产到消费的延迟可以低至毫秒级

2. 持久化和可靠性

   • Kafka 的消息被持久化存储在磁盘中，确保数据不会因服务故障而丢失

   • 支持通过副本机制（Replication）增强可靠性

     • 每个分区可以配置多个副本，主副本负责读写，备份副本作为冗余
     • 主副本故障时，Kafka 自动选举新主副本，保证数据的高可用性

3. 可扩展性

   • Kafka 是一个分布式系统，可以通过水平扩展来处理增长的数据量和并发量

   • 分区机制：

     • 每个主题可以分为多个分区（Partition），生产者将消息发送到分区，消费者从分区拉取数据
     • 不同分区可以分布在不同的 Broker 节点上，从而实现负载均衡

   • 集群扩展：

     • Kafka 集群可以动态添加节点，不会中断当前服务。

4. 消息的顺序性

   • Kafka 保证分区内的消息是严格有序的：

     • 同一分区的消息按发送顺序存储和消费，确保了顺序性
     • 对需要顺序处理的任务，可以通过将相关消息定向到同一分区实现

5. 多消费者和发布订阅模式

   • Kafka 支持多消费者订阅，并实现了灵活的消费模式：

     • 点对点消费

       • 每个消费组中的消费者共同消费一个主题，每条消息只会被一个消费者处理

     • 发布-订阅模式

       • 一个主题的消息可以被多个消费者组同时消费，互不干扰

6. 消费者偏移管理

   • Kafka 支持消费进度（Offset）的自动或手动管理

     • 自动提交：Kafka 自动记录消费者的偏移，简化开发
     • 手动提交：消费者自主控制偏移提交时间，增强容错性
   • 消费者组中的每个消费者可以独立跟踪偏移，实现并行消费

7. 灵活的消息保留策略

   • 可以配置消息在磁盘上的保留时间（如 7 天）或存储空间上限
   • 对于保留期内的数据，消费者可以随时重复消费
   • 支持主题压缩存储（Log Compaction），保留每个键的最新值，删除旧版本的消息

8. 分布式流处理

   • Kafka 提供了两个内置的流处理工具，便于处理实时数据流：

     • Kafka Streams API：

       • 提供一个库来构建高性能的流处理应用程序，支持无状态和有状态的流处理。
       • 支持窗口操作、聚合、Join 等复杂操作。

     • Kafka Connect：

       • 支持从各种数据源（如数据库、文件系统）抽取数据到 Kafka，或从 Kafka 写出到目标系统。

9. 跨数据中心复制

   • Kafka 提供 MirrorMaker 工具，用于跨数据中心复制数据：

     • 支持将消息从一个 Kafka 集群同步到另一个 Kafka 集群。
     • 适合灾备、多区域同步和数据中心迁移场景。

10. 灵活的扩展生态

    • Kafka 拥有庞大的生态系统：

      • 与流行的大数据工具无缝集成：
      • Spark、Flink、Hadoop、Elasticsearch 等。

    • 社区工具和插件丰富：

      • 包括 Schema Registry、KSQL、Confluent Control Center 等。

kafka的5个核心API

1. Producer API（生产者 API）

   • 作用：用于向 Kafka 的主题（Topic）中发布消息

   • 功能：

     • 支持发送同步或者异步消息
     • 支持分区逻辑：通过分区键（Partition Key）或分区器将消息分配到特定分区
     • 支持消息确认机制（ACK）：确保消息被正确写入 Kafka。

   • 常见方法：

     • send（ProducerRecord recored)：异步发送消息。
     • flush(): 强制将所有待处理的消息发送到 Kafka
     • close()：关闭生产者实例。

2. Consumer API（消费者 API）

   • 作用：用于从 Kafka 主题中读取消息

   • 功能：

     • 支持单一消费者或消费者组消费
     • 支持手动或自动提交偏移量（Offset）
     • 提供线程安全的消费机制

   • 常见方法：

     • poll(Duration timeout): 拉取消息
     • commitSync()：同步提交当前偏移量
     • close()：关闭消费者实例

3. Stream API（流处理 API）

   • 作用：用于构建流处理应用程序，实现对实时数据流的转换、过滤、聚合和连接等操作。

   • 功能：

     • 支持无状态和有状态流处理。
     • 支持窗口操作、聚合、Join 等复杂流操作。
     • 消费 Kafka 数据流并将处理结果输出到 Kafka 或其他存储系统。

   • 常见操作：

     • map(): 对流中每条数据应用映射逻辑。
     • filter(): 筛选满足条件的流数据。
     • groupByKey(): 按键分组以进行后续聚合。
     • windowedBy(): 按时间窗口处理流数据。

4. Admin API（管理 API）

   • 作用：用于管理 Kafka 的集群、主题、分区和配置。

   • 功能：

     • 创建、修改、删除主题。
     • 查看主题、分区、消费者组等元数据。
     • 动态修改主题或集群配置。

   • 常见操作：

     • createTopics(Collection<NewTopic> newTopics)：创建新的主题。
     • describeTopics(Collection<String> topicNames)：描述指定主题的元信息。
     • deleteTopics(Collection<String> topics)：删除主题。

5. Connect API（连接器 API）

   • 作用：用于构建和运行可复用的连接器，实现数据从外部系统到 Kafka，或从 Kafka 到外部系统的高效传输。

   • 功能：

     • 提供现成的连接器插件，例如 JDBC、Elasticsearch、HDFS 等。
     • 支持流式数据管道，简化数据集成工作。
     • 可动态扩展，支持分布式运行。

   • 常见操作：

     • Source Connector：从外部系统（如数据库、文件）中采集数据到 Kafka
     • Sink Connector：将 Kafka 中的数据发送到外部系统（如 HDFS、ElasticSearch）。

解决kafka消息丢失问题

1. 消息生产端（Producer）

消息在生产端可能由于网络故障、配置不当或异常中断导致丢失。

丢失原因

• ACK 配置不当：Producer 在发送消息时没有等待 Kafka 的确认。
• 重试机制不足：网络抖动或分区不可用时，消息未能成功发送。
• Producer 异常中断：Producer 应用程序崩溃或未能完成重试。

解决方案

• 设置ACK为all
  props.put("acks", "all");
• 启用重试机制

props.put("retries", 5); // 设置重试次数
props.put("retry.backoff.ms", 100); // 每次重试的间隔时间

• 配置幂等性Producer：启用幂等性确保同一消息不会重复写入。
  props.put("enable.idempotence", true);

2. 消息传输阶段

消息在 Kafka 集群内部传输时可能因分区副本同步、节点故障等原因丢失。

丢失原因

• 未启用副本同步：副本之间数据未完成同步时发生主分区故障。
• ISR（In-Sync Replica）过少：只有少数副本是同步状态，增加了数据丢失风险。

解决方案

• 增加副本数量：
  在创建 Topic 时配置副本数，通常为 3。

kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 3 --topic test

• 配置 min.insync.replicas 参数：
  确保写操作成功需要至少 N 个副本同步。

props.put("min.insync.replicas", 2);

3. 消息消费阶段

消费端可能因消息未及时提交 Offset 或异常退出导致丢失

丢失原因

• 自动提交 Offset：消费端在处理消息之前提交 Offset，导致未处理的消息被认为已消费。
• 消费端异常中断：未提交 Offset 的消息丢失。

解决方案

• 关闭自动提交 Offset：改为手动提交 Offset，确保消息被成功处理后才提交。

  props.put("enable.auto.commit", "false");

• 分布式消费时使用协调提交：
• 通过 Consumer Group 协调，确保 Offset 状态一致。
• 使用事务消费：
• 配置消费者支持事务性读取，以确保消费和 Offset 提交的原子性。