Flink + Kafka 数据写入实战：从API调用到端到端一致性精讲

渣渣盟2026-08-19 9:07

1. 引言：为什么你的Flink写入Kafka总丢数据或重复数据？

在实时数据管道中，Apache Flink + Apache Kafka 的组合已成为事实标准。然而，很多开发者在将Flink处理后的结果数据写入Kafka时，常常面临两个灵魂拷问：

  • "我的数据到底写进去了没？会不会丢？" ------ 这是可靠性问题。
  • "Kafka里怎么有那么多重复数据？" ------ 这是一致性问题。

答案往往藏在你所使用的Kafka Sink实现以及DeliveryGuarantee（交付保证）的配置中。在Flink 1.13+版本中，社区正式推出了基于新架构的KafkaSink，它替代了经典的FlinkKafkaProducer，并原生集成了Flink的Checkpoint机制，以实现端到端的Exactly-Once语义。

本文将带你从零开始，搭建一个完整的Flink -> Kafka数据写入项目。我们不仅会手把手写代码，更会深入底层，剖析**两阶段提交协议（2PC）**是如何在Flink和Kafka之间保证数据一致性的。读完本文，你将能够：

  1. 熟练使用新旧两种Kafka Sink API。
  2. 理解AT_LEAST_ONCE和EXACTLY_ONCE的本质区别与性能取舍。
  3. 掌握生产环境中的常见配置与坑。

在动手写代码之前，我们先建立两个核心认知。

2.1. 从FlinkKafkaProducer到KafkaSink的变迁

特性 FlinkKafkaProducer (Old) KafkaSink (New)
引入版本 Flink 1.0+ Flink 1.13+
包路径 org.apache.flink.streaming.connectors.kafka org.apache.flink.connector.kafka.sink
Exactly-Once实现 基于Kafka 0.11+的事务API，需手动启用Semantic.EXACTLY_ONCE 原生整合，通过DeliveryGuarantee.EXACTLY_ONCE配置，更简洁
动态Topic路由 需自定义KeyedSerializationSchema 通过KafkaRecordSerializationSchema轻松实现
状态与容错 与Flink Checkpoint整合较松散 深度整合，是未来演进方向
官方推荐 已弃用（Deprecated），不推荐在新项目中使用 强烈推荐，是当前及未来的主流方案

结论 ：如果是新项目，请直接使用KafkaSink。如果是维护老项目，则需要了解FlinkKafkaProducer。

2.2. 端到端一致性（EOS）的底层原理：两阶段提交（2PC）

当我们将DeliveryGuarantee设置为EXACTLY_ONCE时，Flink是如何做到在发生故障时既不丢失数据也不重复数据的？这背后依赖的是一个经典的分布式共识协议------两阶段提交（Two-Phase Commit，2PC）。

整个流程紧密围绕着Flink的Checkpoint机制展开：

  1. 预提交（Pre-commit）阶段 ：
    • Flink Sink算子收到Checkpoint Barrier（屏障）后，会开启一个Kafka事务，并将之前缓冲区内的所有数据通过该事务写入Kafka，但此时**不提交（Commit）**事务。
    • Sink算子向JobManager报告，表示自己已准备好Checkpoint。
  2. Checkpoint完成 ：
    • 当所有算子都成功完成各自的Snapshot（快照）后，JobManager认为本次Checkpoint全局成功。
  3. 提交（Commit）阶段 ：
    • JobManager会向所有Sink算子发送一个通知，告知它们可以提交事务了。
    • Sink算子收到通知后，正式commit Kafka事务。此时，数据才对消费者可见。

如果第二步中任何算子失败，Checkpoint会被判定为失败。JobManager将不会触发事务提交，而是通知所有Sink算子**中止（Abort）**当前事务。Kafka会自动回滚（Rollback）这些未提交的数据。这就完美地保证了要么所有数据都成功写入（Commit），要么什么都没有写入（Abort），从而实现Exactly-Once。

注意：开启Exactly-Once会引入额外的性能开销（大约会降低15%~30%的吞吐量，具体取决于网络延迟），因为Kafka需要为每个Checkpoint周期维护一个事务。

3. 核心剖析：两种Kafka Sink实现深度对比

本节我们将深入代码，展示两种Sink的完整实现，并对比它们的配置差异。

3.1. 公共依赖与POJO定义

首先，我们需要定义数据实体类Event。为了让代码在本地IDE中可运行，这是必须的。

环境依赖 (pom.xml)

xml 复制代码 
<properties>
    <flink.version>1.13.6</flink.version>
    <scala.binary.version>2.12</scala.binary.version>
    <kafka.version>2.8.0</kafka.version> 
</properties>

<dependencies>
    <!-- Flink 核心依赖 -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-clients_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- Kafka Connector 依赖（包含新旧API） -->
    <dependency>
        <groupId>org.apache.flink</groupId>
        <artifactId>flink-connector-kafka_${scala.binary.version}</artifactId>
        <version>${flink.version}</version>
    </dependency>
    
    <!-- 日志依赖 -->
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>1.7.32</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

POJO类定义 (Event.scala)

scala 复制代码 
package sink

// 定义一个简单的案例类作为数据载体
case class Event(user: String, url: String, timestamp: Long)

3.2. 方式一：使用 FlinkKafkaProducer（旧API）

尽管它已不再被推荐，但阅读和理解旧代码依然是必备技能。初始化方式如下：

scala 复制代码 
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer
import org.apache.flink.api.common.serialization.SimpleStringSchema

// 1. 创建旧版Producer
val oldProducer = new FlinkKafkaProducer[String](
  "localhost:9092",          // bootstrap.servers
  "flink-output-topic",      // 目标topic
  new SimpleStringSchema()   // 序列化器
)

// 2. 如需启用Exactly-Once语义，需要额外配置语义参数
// 注意：FlinkKafkaProducer的Semantic是构造参数，在1.13中需使用
// new FlinkKafkaProducer[String](topic, schema, properties, Semantic.EXACTLY_ONCE)
// 但更标准的做法是使用Properties对象
import org.apache.flink.streaming.connectors.kafka.FlinkKafkaProducer.Semantic
val props = new java.util.Properties()
props.setProperty("bootstrap.servers", "localhost:9092")
val oldProducerWithEOS = new FlinkKafkaProducer[String](
  "flink-output-topic",
  (value: String) => value.getBytes, // KeyedSerializationSchema
  props,
  Semantic.EXACTLY_ONCE
)

3.3. 方式二：使用 KafkaSink（新API，强烈推荐）

新API采用流式的Builder模式构建，可读性更强，配置更集中。

scala 复制代码 
import org.apache.flink.connector.kafka.sink.{KafkaRecordSerializationSchema, KafkaSink}
import org.apache.flink.connector.base.DeliveryGuarantee
import org.apache.flink.api.common.serialization.SimpleStringSchema

val kafkaSink: KafkaSink[String] = KafkaSink.builder[String]()
  .setBootstrapServers("localhost:9092")
  .setRecordSerializer(
    KafkaRecordSerializationSchema.builder[String]()
      .setTopic("flink-output-topic")
      .setValueSerializationSchema(new SimpleStringSchema())
      // .setKeySerializationSchema(...) // 如果需要设置Key，可在此配置
      .build()
  )
  .setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE) // 或 EXACTLY_ONCE
  .build()

亮点 ：当需要动态决定Topic时（例如根据数据中的user字段分流），只需在setTopic处传入一个表达式，我们将在第5节进阶思考中展示。

4. 手把手实操：完整可运行Demo

现在我们整合所有部分，写一个完整的、可直接运行的Flink任务。该任务会生成一些模拟数据，然后分别用新旧两种Sink写入Kafka（为清晰起见，我们只演示新API）。

完整主程序 (sinkToKafka.scala)

scala 复制代码 
package sink

import org.apache.flink.api.common.serialization.SimpleStringSchema
import org.apache.flink.connector.base.DeliveryGuarantee
import org.apache.flink.connector.kafka.sink.{KafkaRecordSerializationSchema, KafkaSink}
import org.apache.flink.streaming.api.scala._

object sinkToKafkaDemo {
  def main(args: Array[String]): Unit = {
    // 1. 创建执行环境
    val env = StreamExecutionEnvironment.getExecutionEnvironment
    // 对于演示EOS，Checkpoint间隔不宜过长
    env.enableCheckpointing(5000L) // 每5秒做一次Checkpoint
    env.setParallelism(1) // 为了便于观察，设置并行度为1

    // 2. 准备数据源：模拟实时事件流
    val dataStream: DataStream[Event] = env.fromElements(
      Event("Mary", "./home", 100L),
      Event("Sum", "./cart", 500L),
      Event("King", "./prod", 1000L),
      Event("King", "./root", 200L),
      Event("Mary", "./login", 300L) // 新增一条数据
    )

    // 3. 构建Kafka Sink (新API)
    val kafkaSink: KafkaSink[String] = KafkaSink.builder[String]()
      .setBootstrapServers("localhost:9092") // 请替换为你的Kafka地址
      .setRecordSerializer(
        KafkaRecordSerializationSchema.builder[String]()
          .setTopic("flink-test-topic") // 请确保该Topic已在Kafka中创建
          .setValueSerializationSchema(new SimpleStringSchema())
          .build()
      )
      .setDeliveryGuarantee(DeliveryGuarantee.EXACTLY_ONCE) // 演示Exactly-Once
      .build()

    // 4. 将数据转换为String并写入Kafka
    dataStream
      .map(_.toString) // Event -> String
      .sinkTo(kafkaSink)
      .name("Kafka Sink")

    // 5. 执行任务
    env.execute("Flink Kafka Sink Demo")
  }
}

4.1. 环境准备与运行步骤

  1. 启动Kafka环境 ：本地需要有Kafka集群。最简单的方案是使用docker-compose启动一个单节点Kafka。

    yaml 复制代码 
    # docker-compose.yml
version: '2'
services:
  zookeeper:
    image: wurstmeister/zookeeper:3.4.6
    ports:
      - "2181:2181"
  kafka:
    image: wurstmeister/kafka:2.13-2.8.0
    ports:
      - "9092:9092"
    environment:
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://localhost:9092
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

    在命令行执行：docker-compose up -d

  2. 创建Topic：

    bash 复制代码 
    docker exec -it <kafka-container-id> /bin/bash
cd /opt/kafka/bin
./kafka-topics.sh --create --topic flink-test-topic --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1

  3. 运行Flink任务 ：在IDE中直接运行main方法。

  4. 验证结果：启动一个Kafka消费者来查看输出。

    bash 复制代码 
    docker exec -it <kafka-container-id> /opt/kafka/bin/kafka-console-consumer.sh --topic flink-test-topic --bootstrap-server localhost:9092 --from-beginning

    你将会看到以下输出（顺序可能略有不同）：

    复制代码 
    Event(Mary,./home,100)
Event(Sum,./cart,500)
Event(King,./prod,1000)
Event(King,./root,200)
Event(Mary,./login,300)

4.2. 常见错误与调试方法

  • 错误 ：TimeoutException 或 NetworkException

    • 原因 ：无法连接到localhost:9092。可能是因为Kafka未启动，或者Docker端口映射不正确。
    • 调试 ：检查docker ps确认容器运行状态。在宿主机执行telnet localhost 9092测试网络连通性。

  • 错误 ：Topic 'flink-test-topic' does not exist

    • 原因：Flink默认不会自动创建Topic。
    • 调试 ：按照上文步骤手动创建Topic，或者修改Kafka Broker配置auto.create.topics.enable=true（生产环境不推荐）。

  • 错误 ：org.apache.kafka.common.errors.ProducerFencedException （开启EXACTLY_ONCE时出现）

    • 原因：由于之前的任务失败，一个僵死的事务未结束，导致新的生产者被隔离（Fenced）。
    • 调试：在Kafka中手动回滚或中止僵死事务。可重启Kafka Broker或等待事务超时（默认1分钟）。

5. 进阶思考：动态Topic路由与性能调优

5.1. 实现动态Topic路由

生产环境中，我们常需要根据数据内容将不同用户的数据写入不同的Topic（例如用户行为日志分流）。使用KafkaSink实现这一点非常优雅。

scala 复制代码 
val dynamicKafkaSink: KafkaSink[Event] = KafkaSink.builder[Event]()
  .setBootstrapServers("localhost:9092")
  .setRecordSerializer(
    KafkaRecordSerializationSchema.builder[Event]()
      .setTopic((element: Event, context: KafkaRecordSerializationSchema.KafkaSinkContext) => {
        // 根据用户动态决定Topic
        element.user match {
          case "Mary" => "topic-mary"
          case "King" => "topic-king"
          case _ => "topic-others"
        }
      })
      .setValueSerializationSchema(
        // 将Event序列化为JSON字符串
        new SimpleStringSchema() {
          override def serialize(element: Event): String = 
            s"""{"user":"${element.user}","url":"${element.url}","ts":${element.timestamp}}"""
        }
      )
      .build()
  )
  .setDeliveryGuarantee(DeliveryGuarantee.AT_LEAST_ONCE)
  .build()

5.2. 性能调优三板斧

  1. 调整批量大小（Batch Size） ：KafkaSink底层使用Kafka Producer，可通过setProperty调优。增加batch.size（默认16KB）和linger.ms（默认0ms）可以显著提高吞吐量，但会增加延迟。
  2. 权衡一致性级别 ：如果业务允许少量重复（如日志收集），请使用DeliveryGuarantee.AT_LEAST_ONCE，它能提供更高的吞吐量和更低的延迟。如果业务对数据准确性要求极高（如金融交易），则必须使用EXACTLY_ONCE，并接受相应的性能损失。
  3. 合理设置Checkpoint间隔：Checkpoint间隔越短，事务提交越频繁，Kafka Broker压力越大。建议生产环境设置为30秒以上。

6. 总结：如何选择最适合你的Sink？

场景 推荐方案 交付保证 理由
新项目/绿色字段开发 KafkaSink (新API) EXACTLY_ONCE 或 AT_LEAST_ONCE 更现代、更健壮，是未来演进方向，与Flink 1.15+特性兼容性更好。
维护老项目/代码迁移过渡 FlinkKafkaProducer (旧API) EXACTLY_ONCE 或 AT_LEAST_ONCE 保持兼容性，但应逐步迁移至新API。
高吞吐、低延迟日志/监控场景 KafkaSink (新API) AT_LEAST_ONCE 容忍少量重复，换取极致性能，避免事务带来的额外开销。
核心交易/精确计费场景 KafkaSink (新API) EXACTLY_ONCE 数据准确是第一要务，通过2PC协议保证端到端的一致性，不丢不重。

Flink与Kafka的结合是实时计算领域的"神兵利器"，而正确使用Sink则是掌握这把利器的关键。希望本文不仅能帮你写出能运行的代码，更能让你理解代码背后的设计哲学。现在，就去为你的实时管道选择最合适的写入策略吧！

相关推荐
海兰1 小时前
【Kafka学习2】Apache Kafka 典型应用场景
学习·kafka·apache
heimeiyingwang2 小时前
【架构实战】消息队列选型与异步架构设计：从Kafka到RabbitMQ，一次聊透
架构·kafka·rabbitmq
lakernote20 小时前
图解 Kafka Consumer 常用 API：poll、seek、pause、wakeup 到底在控制什么？
分布式·kafka·linq
lazy H1 天前
不同的消息队列有什么区别？Kafka、RabbitMQ、RocketMQ、Pulsar、ActiveMQ 选型对比
后端·中间件·kafka·rabbitmq·rocketmq
北i1 天前
高并发请求折叠：从 Hystrix 到埋点聚批
hystrix·linq
hopsky1 天前
kafka 对发送端的容错处理
数据库·分布式·kafka
Devin~Y2 天前
从内容社区到AI智能客服：Spring Boot + Spring Cloud + Spring AI 全栈实战面试拆解
java·spring boot·redis·elasticsearch·spring cloud·kafka·mybatis
头茬韭菜3 天前
第 10 篇：「Fluss 实战案例集」—— 完整解决方案与最佳实践
c#·linq·fluss
DLYSB_4 天前
Kafka 消费倾斜死锁与 Partition 掉队：我用 Rust 写了个“数据管道物理哨兵”，比 Grafana 报警快了 18 秒
rust·kafka·grafana·报警灯
热门推荐
01国内可直接用、免费额度/永久免费的大模型API清单（含 SiliconFlow、火山、阿里、智谱、百度、Kimi、DeepSeek、DMXAPI 等）02GitHub 镜像站点032026 国产 AI 大模型横评：DeepSeek、通义千问、Kimi、文心一言、星火、豆包谁更能打？04微信历史版本含下载地址（ Windows PC | 安卓 | MAC ）及设置微信不更新05Agnes AI 免费 API 接入指南：文本、生图、生视频，一套接口全免费06历年考研数学一、数学二、数学三真题试卷及答案PDF07VSCode+CodeX扩展，无法启动08AI 编程 IDE 全景解析 2026：Agent 全面接管开发链路092026年7月AI圈大地震：GPT-5.6被政府限制、Claude入驻Slack、Anthropic自研芯片10如何新建文件夹？ 电脑新建文件夹的4种方法