• Kafka(一)

    第 1 章 Kafka 概述

    1.1 定义

    Kafka传统定义：Kafka是一个分布式的基于发布/订阅模式的消息队列（Message Queue），主要应用于大数据实时处理领域。

    Kafka最 新定义 ： Kafka是 一个开源的 分 布式事件流平台 （Event Streaming Platform），被数千家公司用于高性能数据管道、流分析、数据集成和关键任务应用。

    发布/订阅：消息的发布者不会将消息直接发送给特定的订阅者，而是将发布的消息

    1.2 消息队列

    目 前企 业中比 较常 见的 消息 队列产 品主 要有 Kafka、ActiveMQ 、RabbitMQ 、 RocketMQ 等。 在大数据场景主要采用 Kafka 作为消息队列。在 JavaEE 开发中主要采用 ActiveMQ、 RabbitMQ、RocketMQ。

    1.2.1 传统消息队列的应用场景

    传统的消息队列的主要应用场景包括：缓存/消峰、解耦和异步通信。

    1.2.2 消息队列的两种模式

    1）点对点模式 • 消费者主动拉取数据，消息收到后清除消息

    2）发布/订阅模式

    可以有多个topic主题（浏览、点赞、收藏、评论等）

    消费者消费数据之后，不删除数据

     每个消费者相互独立，都可以消费到数据

    1.3 Kafka 基础架构

    （1）Producer：消息生产者，就是向 Kafka broker 发消息的客户端。

    （2）Consumer：消息消费者，向 Kafka broker 取消息的客户端。

    （3）Consumer Group（CG）：消费者组，由多个 consumer 组成。消费者组内每个消 费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费；消费者组之间互不 影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。

    （4）Broker：一台 Kafka 服务器就是一个 broker。一个集群由多个 broker 组成。一个 broker 可以容纳多个 topic。

    （5）Topic：可以理解为一个队列，生产者和消费者面向的都是一个 topic。

    （6）Partition：为了实现扩展性，一个非常大的 topic 可以分布到多个 broker（即服 务器）上，一个 topic 可以分为多个 partition，每个 partition 是一个有序的队列。

    （7）Replica：副本。一个 topic 的每个分区都有若干个副本，一个 Leader 和若干个 Follower。

    （8）Leader：每个分区多个副本的“主”，生产者发送数据的对象，以及消费者消费数 据的对象都是 Leader。

    （9）Follower：每个分区多个副本中的“从”，实时从 Leader 中同步数据，保持和 Leader 数据的同步。Leader 发生故障时，某个 Follower 会成为新的 Leader。

    第 2 章 Kafka 快速入门

    2.1 Kafka 命令行操作

    2.1.1 主题命令行操作

    1）查看操作主题命令参数

    [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh

    2）查看当前服务器中的所有 topic

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --list

    3）创建 first topic

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --create --partitions 1 --replication-factor 3 --
    3. first

    选项说明：

    --topic 定义 topic 名

    --replication-factor 定义副本数

    --partitions 定义分区数

    4）查看 first 主题的详情

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --describe --topic first

    5）修改分区数（注意：分区数只能增加，不能减少）

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --alter --topic first --partitions 3

    6）再次查看 first 主题的详情

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --describe --topic first

    7）删除 topic（学生自己演示）

    1. [atguigu@hadoop102 kafka]$ bin/kafka-topics.sh --bootstrap-server 
    2. hadoop102:9092 --delete --topic first
    2.1.2 生产者命令行操作

    1）查看操作生产者命令参数

    [atguigu@hadoop102 kafka]$ bin/kafka-console-producer.sh

    2）发送消息

    1. [atguigu@hadoop102 kafka]$ bin/kafka-console-producer.sh --
    2. bootstrap-server hadoop102:9092 --topic first
    3. >hello world
    4. >atguigu atguigu
    2.1.3 消费者命令行操作

    1）查看操作消费者命令参数

    [atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh

    2）消费消息

    （1）消费 first 主题中的数据。

    1. [atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh --
    2. bootstrap-server hadoop102:9092 --topic first

    （2）把主题中所有的数据都读取出来（包括历史数据）。

    1. [atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh --
    2. bootstrap-server hadoop102:9092 --from-beginning --topic first

    第 3 章 Kafka 生产者

    3.1 生产者消息发送流程

    3.1.1 发送原理

    在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程。在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator， Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。

    3.1.2 生产者重要参数列表

    3.2 异步发送 API

    3.2.1 普通异步发送

    1）需求：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker

    2）代码编写

    （1）创建工程 kafka

    （2）导入依赖

    1. <dependencies>
    2.  <dependency>
    3.  <groupId>org.apache.kafka</groupId>
    4.  <artifactId>kafka-clients</artifactId>
    5.  <version>3.0.0</version>
    6.  </dependency>
    7. </dependencies>

    （3）创建包名：com.atguigu.kafka.producer

    （4）编写不带回调函数的 API 代码

    1. package com.atguigu.kafka.producer;
    2. import org.apache.kafka.clients.producer.KafkaProducer;
    3. import org.apache.kafka.clients.producer.ProducerRecord;
    4. import java.util.Properties;
    5. public class CustomProducer {
    6.  public static void main(String[] args) throws 
    7. InterruptedException {
    8.  // 1. 创建 kafka 生产者的配置对象
    9.  Properties properties = new Properties();
    10.  // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
    11.  properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    12. "hadoop102:9092");
    13.  
    14.  // key,value 序列化（必须）：key.serializer，value.serializer
    15. properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    16. "org.apache.kafka.common.serialization.StringSerializer");
    17.  
    18. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, 
    19. "org.apache.kafka.common.serialization.StringSerializer");
    20.  // 3. 创建 kafka 生产者对象
    21.  KafkaProducer<String, String> kafkaProducer = new 
    22. KafkaProducer<String, String>(properties);
    23.  // 4. 调用 send 方法,发送消息
    24.  for (int i = 0; i < 5; i++) {
    25.  kafkaProducer.send(new 
    26. ProducerRecord<>("first","atguigu " + i));
    27.  }
    28.  // 5. 关闭资源
    29.  kafkaProducer.close();
    30.  }
    31. }

    测试： ①在 hadoop102 上开启 Kafka 消费者。

    1. [atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh --
    2. bootstrap-server hadoop102:9092 --topic first

    ②在 IDEA 中执行代码，观察 hadoop102 控制台中是否接收到消息。

    1. [atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh --
    2. bootstrap-server hadoop102:9092 --topic first
    3. atguigu 0
    4. atguigu 1
    5. atguigu 2
    6. atguigu 3
    7. atguigu 4
    3.2.2 带回调函数的异步发送

    回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元 数据信息（RecordMetadata）和异常信息（Exception），如果 Exception 为 null，说明消息发 送成功，如果 Exception 不为 null，说明消息发送失败。

    注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试。

    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.*; import java.util.Properties; 
    4.  
    5. public class CustomProducerCallback { 
    6.  
    7.     public 	static 	void 	main(String[] 	args) 	throws 
    8. InterruptedException { 
    9.  
    10.         // 1. 创建kafka生产者的配置对象 
    11.         Properties properties = new Properties(); 
    12.  
    13.         // 2. 给kafka配置对象添加配置信息 
    14.         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092"); 
    15.  
    16.         // key,value序列化（必须）：key.serializer，value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    17. StringSerializer.class.getName()); 
    18.         
    19. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    20.  
    21.         // 3. 创建kafka生产者对象 
    22.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    23.  
    24.         // 4. 调用send方法,发送消息 
    25.         for (int i = 0; i < 5; i++) { 
    26.  
    27.             // 添加回调             kafkaProducer.send(new 	ProducerRecord<>("first", "atguigu " + i), new Callback() {  
    28.                 // 该方法在Producer收到ack时调用，为异步调用 
    29.                 @Override 
    30.                 public void onCompletion(RecordMetadata metadata, Exception exception) { 
    31.                      if (exception == null) { 
    32.                         // 没有异常,输出信息到控制台 
    33.                         System.out.println(" 主 题 ： " + 
    34. metadata.topic() + "->"  + "分区：" + metadata.partition()); 
    35.                     } else { 
    36.                         // 出现异常打印                         exception.printStackTrace(); 
    37.                     } 
    38.                 } 
    39.             }); 
    40.  
    41.             // 延迟一会会看到数据发往不同分区 
    42.             Thread.sleep(2); 
    43.         } 
    44.  
    45.         // 5. 关闭资源 
    46.         kafkaProducer.close(); 
    47.     } 
    48. }

    测试：

    ①在 hadoop102 上开启 Kafka 消费者。

    [atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh bootstrap-server hadoop102:9092 --topic first

    ②在 IDEA 中执行代码，观察 hadoop102 控制台中是否接收到消息。  

    1. [atguigu@hadoop102 kafka]$  bin/kafka-console-consumer.sh -bootstrap-server hadoop102:9092 --topic first 
    2.  atguigu 0 atguigu 1 atguigu 2 atguigu 3 atguigu 4

     ③在 IDEA 控制台观察回调信息。 

    主题：first->分区：0 主题：first->分区：0 主题：first->分区：1 主题：first->分区：1 主题：first->分区：1

    3.3 同步发送 API

    只需在异步发送的基础上，再调用一下 get()方法即可

    1. package com.atguigu.kafka.producer; 
    2.  import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerConfig; import org.apache.kafka.clients.producer.ProducerRecord; import java.util.Properties; 
    3. import java.util.concurrent.ExecutionException; 
    4.  
    5. public class CustomProducerSync { 
    6.  
    7.     public 	static 	void 	main(String[] 	args) 	throws
    8. InterruptedException, ExecutionException { 
    9.  
    10.         // 1. 创建kafka生产者的配置对象 
    11.         Properties properties = new Properties(); 
    12.  
    13.         // 2. 给kafka配置对象添加配置信息 
    14.    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092");  
    15.         // key,value序列化（必须）：key.serializer，value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    16. StringSerializer.class.getName()); 
    17.         
    18. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    19.  
    20.         // 3. 创建kafka生产者对象 
    21.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);  
    22.         // 4. 调用send方法,发送消息 
    23.         for (int i = 0; i < 10; i++) { 
    24.  
    25.             // 异步发送 默认 
    26. //            kafkaProducer.send(new 
    27. ProducerRecord<>("first","kafka" + i)); 
    28.             // 同步发送 
    29.             kafkaProducer.send(new 
    30. ProducerRecord<>("first","kafka" + i)).get(); 
    31.  
    32.         } 
    33.  
    34.         // 5. 关闭资源         kafkaProducer.close(); 
    35.     } 
    36. }

    3.4 生产者分区

    3.4.1 分区好处

    (4)便于合理使用存储资源：每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块一块数据存储在多台Broker里。合理控制分区的任务，可以实现载均衡的效果。
    2)提高并行度,生产者可以以分区为单位发送数据,消费者可以以分区为单位进行消费数据

    3.4.2 生产者发送消息的分区策略

    案例一将数据发往指定 partition 的情况下，例如，将所有数据发往分区 1 中。

    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.*; 
    4.  
    5. import java.util.Properties; 
    6.  
    7. public class CustomProducerCallbackPartitions { 
    8.  
    9.     public static void main(String[] args) { 
    10.  
    11.         // 1. 创建kafka生产者的配置对象 
    12.         Properties properties = new Properties(); 
    13.  
    14.         // 2. 给kafka配置对象添加配置信息 
    15.       
    16. properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092");  
    17.         // key,value序列化（必须）：key.serializer，value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    18. StringSerializer.class.getName()); 
    19.         
    20. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    21.  
    22.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
    23.  
    24.         for (int i = 0; i < 5; i++) { 
    25.             // 指定数据发送到1号分区，key为空（IDEA中ctrl + p查看参数）             kafkaProducer.send(new ProducerRecord<>("first", 
    26. 1,"","atguigu " + i), new Callback() { 
    27.                 @Override 
    28.                 public void onCompletion(RecordMetadata metadata, Exception e) { 
    29.                     if (e == null){ 
    30.                         System.out.println(" 主 题 ： " + 
    31. metadata.topic() + "->"  + "分区：" + metadata.partition() 
    32.                         );                     }else { 
    33.                         e.printStackTrace(); 
    34.                     } 
    35.                 } 
    36.             }); 
    37.         } 
    38.  
    39.         kafkaProducer.close(); 
    40.     } 
    41. }

    在 IDEA 控制台观察回调信息。

    1. 主题：first->分区：1 
    2. 主题：first->分区：1 主题：first->分区：1 主题：first->分区：1 主题：first->分区：1

    案例二没有指明 partition 值但有 key 的情况下，将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。

    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.*; import java.util.Properties; 
    4.  
    5. public class CustomProducerCallback { 
    6.  
    7.     public static void main(String[] args) { 
    8.  
    9.         Properties properties = new Properties(); 
    10.          
    11. properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092"); 
    12.  
    13.         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    14. StringSerializer.class.getName()); 
    15.         
    16. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    17.  
    18.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
    19.  
    20.         for (int i = 0; i < 5; i++) { 
    21.             // 依次指定key 值为a,b,f ，数据key 的hash 值与3 个分区求余，分别发往1、2、0 
    22.             kafkaProducer.send(new 	ProducerRecord<>("first", 
    23. "a","atguigu " + i), new Callback() { 
    24.                 @Override                 public void onCompletion(RecordMetadata metadata, Exception e) { 
    25.                     if (e == null){ 
    26.                         System.out.println(" 主 题 ： " + 
    27. metadata.topic() + "->" + "分区：" + metadata.partition() 
    28.                         );                     }else { 
    29.                         e.printStackTrace(); 
    30.                     } 
    31.                 } 
    32.             }); 
    33.         } 
    34.          kafkaProducer.close(); 
    35.     } 
    36. }

    ①key="a"时，在控制台查看结果。

    主题：first->分区：1 主题：first->分区：1 主题：first->分区：1 主题：first->分区：1 主题：first->分区：1

    ②key="b"时，在控制台查看结果。

    主题：first->分区：2 主题：first->分区：2 主题：first->分区：2 主题：first->分区：2 主题：first->分区：2

    ③key="f"时，在控制台查看结果。

    主题：first->分区：0 主题：first->分区：0 主题：first->分区：0 主题：first->分区：0 主题：first->分区：0

    3.4.3 自定义分区器

     如果研发人员可以根据企业需求，自己重新实现分区器。

    1. 需求例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，不包含 atguigu，就发往 1 号分区。
    2. 实现步骤
      1. 定义类实现 Partitioner 接口。
      2. 重写 partition()方法。 
    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.Partitioner; import org.apache.kafka.common.Cluster; 
    4.  
    5. import java.util.Map; 
    6.  
    7. /** 
    8. *	1. 实现接口Partitioner 
    9. *	2. 实现3个方法:partition,close,configure 
    10. *	3. 编写partition方法,返回分区号 
    11.  */ 
    12. public class MyPartitioner implements Partitioner { 
    13.  
    14.     /** 
    15. *	返回信息对应的分区 
    16. *	@param topic         主题 
    17. *	@param key           消息的key 
    18. *	@param keyBytes      消息的key序列化后的字节数组 
    19. *	@param value         消息的value 
    20. *	@param valueBytes    消息的value序列化后的字节数组 
    21. *	@param cluster       集群元数据可以查看分区信息 
    22. *	@return 
    23.      */ 
    24.     @Override 
    25.     public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {  
    26.         // 获取消息 
    27.         String msgValue = value.toString(); 
    28.  
    29.         // 创建partition         int partition; 
    30.  
    31.         // 判断消息是否包含atguigu 
    32.         if (msgValue.contains("atguigu")){             partition = 0; 
    33.         }else { 
    34.             partition = 1; 
    35.         } 
    36.  
    37.         // 返回分区号         return partition; 
    38.     } 
    39.  
    40.     // 关闭资源 
    41.     @Override 
    42.     public void close() { 
    43.  
    44.     } 
    45.  
    46.     // 配置方法 
    47.     @Override 
    48.     public void configure(Map<String, ?> configs) { 
    49.  
    50.     } 
    51. }

    使用分区器的方法，在生产者的配置中添加分区器参数。

    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.*; 
    4.  
    5. import java.util.Properties; 
    6.  
    7. public class CustomProducerCallbackPartitions { 
    8.  
    9.     public 	static 	void 	main(String[] 
    10. InterruptedException { 
    11.  	args) 	throws 
    12.         Properties properties = new Properties(); 
    13.          
    14. properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092"); 
    15.  
    16.         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    17. StringSerializer.class.getName()); 
    18.         
    19. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    20.  
    21.         // 添加自定义分区器 
    22. properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.atgui gu.kafka.producer.MyPartitioner"); 
    23.  
    24.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
    25.  
    26.         for (int i = 0; i < 5; i++) { 
    27.              
    28.             kafkaProducer.send(new 	ProducerRecord<>("first", 
    29. "atguigu " + i), new Callback() { 
    30.                 @Override 
    31.                 public void onCompletion(RecordMetadata metadata, Exception e) { 
    32.                     if (e == null){ 
    33.                         System.out.println(" 主 题 ： " + 
    34. metadata.topic() + "->" + "分区：" + metadata.partition() 
    35.                         );                     }else { 
    36.                         e.printStackTrace(); 
    37.                     } 
    38.                 } 
    39.             }); 
    40.         } 
    41.  
    42.         kafkaProducer.close(); 
    43.     } 
    44. }

    ②在 IDEA 控制台观察回调信息

    主题：first->分区：0 主题：first->分区：0 主题：first->分区：0 主题：first->分区：0 主题：first->分区：0

    3.5 生产经验——生产者如何提高吞吐量

    1. package com.atguigu.kafka.producer; 
    2.  import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; 
    3.  
    4. import java.util.Properties; 
    5.  
    6. public class CustomProducerParameters { 
    7.  
    8.     public 	static 	void 	main(String[] 	args) 	throws 
    9. InterruptedException { 
    10.  
    11.         // 1. 创建kafka生产者的配置对象 
    12.         Properties properties = new Properties(); 
    13.  
    14.         // 2. 给kafka配置对象添加配置信息：bootstrap.servers         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    15. "hadoop102:9092"); 
    16.          
    17.         // key,value序列化（必须）：key.serializer，value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    18. "org.apache.kafka.common.serialization.StringSerializer"); 
    19.         
    20. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");  
    21.         // batch.size：批次大小，默认16K 
    22.         properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);  
    23.         // linger.ms：等待时间，默认0         properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);  
    24.         // RecordAccumulator：缓冲区大小，默认32M：buffer.memory         properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 
    25. 33554432);  
    26.         // compression.type：压缩，默认 none，可配置值 gzip、snappy、 lz4和zstd 
    27. properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");  
    28.         // 3. 创建kafka生产者对象 
    29.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    30.  
    31.         // 4. 调用send方法,发送消息 
    32.         for (int i = 0; i < 5; i++) { 
    33.  
    34.             kafkaProducer.send(new 
    35. ProducerRecord<>("first","atguigu " + i)); 
    36.  
    37.         } 
    38.  
    39.         // 5. 关闭资源 
    40.         kafkaProducer.close(); 
    41.     } 
    42. }

    3.6 生产经验——数据可靠性

    1. 回顾发送流程

    ack 应答原理

    ACK应答级别

    1. 代码配置 
    1. package com.atguigu.kafka.producer; 
    2.  import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; 
    3.  
    4. import java.util.Properties; 
    5.  
    6. public class CustomProducerAck { 
    7.  
    8.     public 	static 	void 	main(String[] 	args) 
    9. InterruptedException { 
    10.  
    11.         // 1. 创建kafka生产者的配置对象 
    12.         Properties properties = new Properties(); 
    13.  
    14.         // 2. 给kafka配置对象添加配置信息：bootstrap.servers 	throws 
    15.  
    16.         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    17. "hadoop102:9092"); 
    18.          
    19.         // key,value序列化（必须）：key.serializer，value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
    20. StringSerializer.class.getName()); 
    21.         
    22. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    23.  
    24.         // 设置acks 
    25.         properties.put(ProducerConfig.ACKS_CONFIG, "all");  
    26.         // 重试次数retries，默认是int最大值，2147483647 
    27.         properties.put(ProducerConfig.RETRIES_CONFIG, 3);  
    28.         // 3. 创建kafka生产者对象 
    29.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    30.  
    31.         // 4. 调用send方法,发送消息 
    32.         for (int i = 0; i < 5; i++) { 
    33.  
    34.             kafkaProducer.send(new 
    35. ProducerRecord<>("first","atguigu " + i)); 
    36.  
    37.         } 
    38.  
    39.         // 5. 关闭资源 
    40.         kafkaProducer.close(); 
    41.     } 
    42. }

    3.7 生产经验——数据去重

    3.7.1 数据传递语义

    至少一次（At Least Once）= ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2

    • 最多一次（At Most Once）= ACK级别设置为0

    • 总结：

    At Least Once可以保证数据不丢失，但是不能保证数据不重复；

    At Most Once可以保证数据不重复，但是不能保证数据不丢失。

    • 精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。 Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务。

    3.7.2 幂等性

    1）幂等性原理

    幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。 精确一次（Exactly Once） = 幂等性 + 至少一次（ ack=-1 + 分区副本数>=2 + ISR最小副本数量>=2） 。

    重复数据的判断标准：具有相同主键的消息提交时，Broker只会持久化一条。其 中PID是Kafka每次重启都会分配一个新的；Partition 表示分区号；Sequence Number是单调自增的。

    所以幂等性只能保证的是在单分区单会话内不重复。

    2）如何使用幂等性 开启参数 enable.idempotence 默认为 true，false 关闭。

    3.7.3 生产者事务

    1）Kafka 事务原理

    Kafka 的事务一共有如下 5 个 API

    1. // 1初始化事务 
    2. void initTransactions(); 
    3.  
    4. // 2开启事务 
    5. void beginTransaction() throws ProducerFencedException; 
    6.  
    7. // 3在事务内提交已经消费的偏移量（主要用于消费者） 
    8. void sendOffsetsToTransaction(Map offsets, 
    9.                               String 	consumerGroupId) 	throws 
    10. ProducerFencedException; 
    11.  
    12. // 4提交事务 
    13. void commitTransaction() throws ProducerFencedException; 
    14.  
    15. // 5放弃事务（类似于回滚事务的操作） 
    16. void abortTransaction() throws ProducerFencedException;
    1. 单个 Producer，使用事务保证消息的仅一次发送 
    1. package com.atguigu.kafka.producer; 
    2.  
    3. import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; 
    4.  
    5. import java.util.Properties; 
    6.  
    7. public class CustomProducerTransactions { 
    8.  
    9.     public 	static 	void 	main(String[] 	args) 	throws 
    10. InterruptedException { 
    11.  
    12.         // 1. 创建kafka生产者的配置对象 
    13.         Properties properties = new Properties(); 
    14.  
    15.         // 2. 给kafka配置对象添加配置信息 
    16.         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    17.  
    18. "hadoop102:9092"); 
    19.  
    20.         // key,value序列化 
    21.         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    22. StringSerializer.class.getName()); 
    23.         
    24. properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
    25.  
    26.         // 设置事务id（必须），事务id任意起名 
    27.         properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0"); 
    28.  
    29.         // 3. 创建kafka生产者对象 
    30.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    31.  
    32.         // 初始化事务         kafkaProducer.initTransactions(); 
    33.         // 开启事务         kafkaProducer.beginTransaction();         try { 
    34.             // 4. 调用send方法,发送消息             for (int i = 0; i < 5; i++) { 
    35.                 // 发送消息 
    36.                 kafkaProducer.send(new ProducerRecord<>("first", 
    37. "atguigu " + i)); 
    38.             } 
    39.  
    40. //            int i = 1 / 0; 
    41.  
    42.             // 提交事务             kafkaProducer.commitTransaction(); 
    43.  
    44.         } catch (Exception e) { 
    45.             // 终止事务             kafkaProducer.abortTransaction(); 
    46.         } finally {             // 5. 关闭资源 
    47.             kafkaProducer.close(); 
    48.         } 
    49.     } 
    50. }

    3.8 生产经验——数据有序

    3.9 生产经验——数据乱序

    1）kafka在1.x版本之前保证数据单分区有序，条件如下：

    max.in.flight.requests.per.connection=1（不需要考虑是否开启幂等性）。

    2）kafka在1.x及以后版本保证数据单分区有序，条件如下：

    （1）未开启幂等性 max.in.flight.requests.per.connection需要设置为1。

    （2）开启幂等性 max.in.flight.requests.per.connection需要设置小于等于5。

    原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据， 故无论如何，都可以保证最近5个request的数据都是有序的。

  • 相关阅读:
    VSCode插件开发概述
    .NET性能优化-复用StringBuilder
    【精华】拒绝国外IP海外IP访问的几种方法
    Centos7安装jdk8以及mysql5.7以及Navicat连接虚拟机mysql的出错以及解决方法(附mysql下载出错解决办法)
    SAAS堡垒机安全吗？为什么性价比那么高？
    我的小程序接口被刷爆了
    Python实战 | 使用 Python 的日志库（logging）和 pandas 库对日志数据进行分析
    数字孪生城市总体架构进一步迭代更新
    精准防疫有“利器”| 芯讯通助力数字哨兵护航复市
    hdu3549Flow Problem（最大流模板题）
  • 原文地址：https://blog.csdn.net/Pengjixuan0524/article/details/136077034