经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 大数据/云/AI » Apache Kafka » 查看文章
Kafka的系统架构和API开发
来源：cnblogs　　作者：_泡泡　　时间：2023/6/9 8:43:10　　对本文有异议

系统架构

主题topic和分区partition

  • topic
    Kafka中存储数据的逻辑分类；你可以理解为数据库中“表”的概念；比如，将app端日志、微信小程序端日志、业务库订单表数据分别放入不同的topic
  • partition分区（提升kafka吞吐量）
    topic中数据的具体管理单元；
  • 每个partition由一个kafka broker服务器管理；
  • 每个topic 可以划分为多个partition，分布到多个broker上管理；
  • 每个partition都可以有多个副本；保证数据安全
    分区对于 kafka 集群的好处是：实现topic数据的负载均衡。提高写入、读出的并发度，提高吞吐量。
  • 分区副本replica
    每个topic的每个partition都可以配置多个副本（replica），以提高数据的可靠性；
    每个partition的所有副本中，必有一个leader副本，其他的就是follower副本（observer副本）；follower定期找leader同步最新的数据；对外提供服务只有leader；
  • 分区follower
    partition replica中的一个角色，它通过心跳通信不断从leader中拉取、复制数据（只负责备份）。
    如果leader所在节点宕机，follower中会选举出新的leader；
  • 消息偏移量offset
    partition内部每条消息都会被分配一个递增id（offset）；通过offset可以快速定位到消息的存储位置；
    kafka 只保证按一个partition中的消息的顺序，不保证一个 topic的整体（多个partition 间）的顺序。
    哪一个topic的哪一个分区的哪一个偏移量,数据只能追加,不能被修改
    image

自我推导设计：

  • kafka是用来存数据的；
  • 现实世界数据有分类，所以存储系统也应有数据分类管理功能，如mysql的表；kafka有topic；
  • 如一个topic的数据全部交给一台server存储和管理, 则读写吞吐量有限, 所以, 一个topic的数据应该可以分成多个部分（partition）分别交给多台server存储和管理；
  • 如一台server宕机，这台server负责的partition将不可用，所以，一个partition应有多个副本；
  • 一个partition有多个副本，则副本间的数据一致性难以保证，因此要有一个leader统领读写；
  • 一个leader万一挂掉，则该partition又不可用，因此还要有leader的动态选举机制；
  • 集群有哪些topic，topic有哪几个分区，server在线情况，等等元信息和状态信息需要在集群内部及客户端之间共享，则引入了zookeeper；
  • 客户端在读取数据时，往往需要知道自己所读取到的位置，因而要引入消息偏移量维护机制；

broker服务器
一台 kafka服务器就是一个broker。一个kafka集群由多个 broker 组成。
生产者producer
消息生产者，就是向kafka broker发消息的客户端。

消费者consumer

  • consumer ：消费者，从kafka broker 取消息的客户端。
  • consumer group：消费组，单个或多个consumer可以组成一个消费组。消费组是用来实现消息的广播（发给所有的 consumer）和单播（发给任意一个 consumer）的手段。

消费者可以对消费到的消息位置（消息偏移量）进行记录；
老版本是记录在zookeeper中；新版本是记录在kafka中一个内置的topic中（__consumer_offsets)

数据存储结构
在Kafka根目录下的config/server.properties文件中指定log.dirs=存储日志文件的目录
物理存储目录结构: __consumer_offset
存储目录 名称规范: topic名称-分区号
生产者生产的消息会不断追加到log文件末尾，为防止log文件过大导致数据定位效率低下，Kafka采取了分片和索引机制

  1. 每个partition的数据将分为多个segment存储
  2. 每个segment对应两个文件：“.index"文件和“.log"文件。index和log文件以当前segment的第一条消息的offset命名。

index索引文件中的数据为： 消息offset -> log文件中该消息的物理偏移量位置；
Kafka 中的索引文件以 稀疏索引(sparse index) 的方式构造消息的索引，它并不保证每个消息在索引文件中都有对应的索引；每当写入一定量（由 broker 端参数 log.index.interval.bytes 指定，默认值为 4096 ，即 4KB ）的消息时，偏移量索引文件和时间戳索引文件分别增加一个偏移量索引项和时间戳索引项，增大或减小 log.index.interval.bytes的值，对应地可以缩小或增加索引项的密度；

查询指定偏移量时，使用二分查找法来快速定位偏移量的位置。

消息message存储结构
在客户端编程代码中，消息的封装类有两种：ProducerRecord、ConsumerRecord；
简单来说，kafka中的每个massage由一对key-value构成；
Kafka中的message格式经历了3个版本的变化了：v0 、 v1 、 v2
image

各个字段的含义介绍如下：

  • crc：占用4个字节，主要用于校验消息的内容；
  • magic：这个占用1个字节，主要用于标识日志格式版本号，此版本的magic值为1
  • attributes：占用1个字节，这里面存储了消息压缩使用的编码以及Timestamp类型。目前Kafka 支持 gzip、snappy 以及 lz4（0.8.2引入） 三种压缩格式；[0,1,2]三位bit表示压缩类型。[3]位表示时间戳类型（0，create time；1，append time），[4,5,6,7]位保留；
  • key length：占用4个字节。主要标识 Key的内容的长度；
  • key：占用 N个字节，存储的是 key 的具体内容；
  • value length：占用4个字节。主要标识 value 的内容的长度；
  • value：value即是消息的真实内容，在 Kafka 中这个也叫做payload。

API开发

准备: 创建项目并添加依赖

  1.  <properties>
  2.         <maven.compiler.source>8</maven.compiler.source>
  3.         <maven.compiler.target>8</maven.compiler.target>
  4.     </properties>
  6.     <dependencies>
  7.         <dependency>
  8.             <groupId>org.apache.kafka</groupId>
  9.             <artifactId>kafka-clients</artifactId>
  10.             <version>2.3.1</version>
  11.         </dependency>
  12.     </dependencies>
  15.     <!-- 依赖下载国内镜像库 -->
  16.     <repositories>
  17.         <repository>
  18.             <id>nexus-aliyun</id>
  19.             <name>Nexus aliyun</name>
  20.             <layout>default</layout>
  21.             <url>http://maven.aliyun.com/nexus/content/groups/public</url>
  22.             <snapshots>
  23.                 <enabled>false</enabled>
  24.                 <updatePolicy>never</updatePolicy>
  25.             </snapshots>
  26.             <releases>
  27.                 <enabled>true</enabled>
  28.                 <updatePolicy>never</updatePolicy>
  29.             </releases>
  30.         </repository>
  31.     </repositories>
  33.     <!-- maven插件下载国内镜像库 -->
  34.     <pluginRepositories>
  35.         <pluginRepository>
  36.             <id>ali-plugin</id>
  37.             <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
  38.             <snapshots>
  39.                 <enabled>false</enabled>
  40.                 <updatePolicy>never</updatePolicy>
  41.             </snapshots>
  42.             <releases>
  43.                 <enabled>true</enabled>
  44.                 <updatePolicy>never</updatePolicy>
  45.             </releases>
  46.         </pluginRepository>
  47.     </pluginRepositories>
  50.     <build>
  51.         <plugins>
  53.             <!-- 指定编译java的插件 -->
  54.             <plugin>
  55.                 <groupId>org.apache.maven.plugins</groupId>
  56.                 <artifactId>maven-compiler-plugin</artifactId>
  57.                 <version>3.5.1</version>
  58.                 <configuration>
  59.                     <source>1.8</source>
  60.                     <target>1.8</target>
  61.                 </configuration>
  62.             </plugin>
  64.             <!-- 指定编译scala的插件 -->
  65.             <plugin>
  66.                 <groupId>net.alchim31.maven</groupId>
  67.                 <artifactId>scala-maven-plugin</artifactId>
  68.                 <version>3.2.2</version>
  69.                 <executions>
  70.                     <execution>
  71.                         <goals>
  72.                             <goal>compile</goal>
  73.                             <goal>testCompile</goal>
  74.                         </goals>
  75.                         <configuration>
  76.                             <args>
  77.                                 <arg>-dependencyfile</arg>
  78.                                 <arg>${project.build.directory}/.scala_dependencies</arg>
  79.                             </args>
  80.                         </configuration>
  81.                     </execution>
  82.                 </executions>
  83.             </plugin>
  86.             <!--  把依赖jar中的用到的类，提取到自己的jar中 -->
  87.             <plugin>
  88.                 <groupId>org.apache.maven.plugins</groupId>
  89.                 <artifactId>maven-assembly-plugin</artifactId>
  90.                 <version>2.6</version>
  91.                 <configuration>
  92.                     <archive>
  93.                         <manifest>
  94.                             <mainClass></mainClass>
  95.                         </manifest>
  96.                     </archive>
  97.                     <descriptorRefs>
  98.                         <descriptorRef>jar-with-dependencies</descriptorRef>
  99.                     </descriptorRefs>
  100.                 </configuration>
  101.                 <!--下面是为了使用 mvn package命令，如果不加则使用mvn assembly-->
  102.                 <executions>
  103.                     <execution>
  104.                         <id>make-assemble</id>
  105.                         <phase>package</phase>
  106.                         <goals>
  107.                             <goal>single</goal>
  108.                         </goals>
  109.                     </execution>
  110.                 </executions>
  111.             </plugin>
  113.         </plugins>
  115.     </build>

生产者api

一个正常的生产逻辑需要具备以下几个步骤

  1. 配置生产者参数及创建相应的生产者实例
  2. 构建待发送的消息
  3. 发送消息
  4. 关闭生产者实例

采用默认分区方式将消息散列的发送到各个分区当中

  1. import org.apache.kafka.clients.producer.KafkaProducer;
  2. import org.apache.kafka.clients.producer.ProducerRecord;
  4. import java.util.Properties;
  6. public class KafkaProducerDemo {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         /**
  9.          * 1.构建一个kafka的客户端
  10.          * 2.创建一些待发送的消息，构建成kafka所需要的格式
  11.          * 3.调用kafka的api去发送消息
  12.          * 4.关闭kafka生产实例
  13.          */
  14.         //1.创建kafka的对象，配置一些kafka的配置文件
  15.         //它里面有一个泛型k,v
  16.         //要发送数据的key
  17.         //要发送的数据value
  18.         //他有一个隐含之意，就是kafka发送的消息，是一个key，value类型的数据，但是不是必须得，其实只需要发送value的值就可以了
  19.         Properties pros = new Properties();
  20.         //指定kafka集群的地址
  21.         pros.setProperty("bootstrap.servers", "linux01:9092,linux02:9092,linux03:9092");
  22.         //指定key的序列化方式
  23.         pros.setProperty("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  24.         //指定value的序列化方式
  25.         pros.setProperty("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
  26.         //ack模式，取值有0，1，-1（all），all是最慢但最安全的  服务器应答生产者成功的策略
  27.         pros.put("acks", "all");
  28.         //这是kafka发送数据失败的重试次数，这个可能会造成发送数据的乱序问题
  29.         pros.setProperty("retries", "3");
  30.         //数据发送批次的大小 单位是字节
  31.         pros.setProperty("batch.size", "10000");
  32.         //一次数据发送请求所能发送的最大数据量
  33.         pros.setProperty("max.request.size", "102400");
  34.         //消息在缓冲区保留的时间，超过设置的值就会被提交到服务端
  35.         pros.put("linger.ms", 10000);
  36.         //整个Producer用到总内存的大小，如果缓冲区满了会提交数据到服务端
  37.         //buffer.memory要大于batch.size，否则会报申请内存不足的错误
  38.         pros.put("buffer.memory", 10240);
  40.         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(pros);
  41.         for (int i = 0; i < 1000; i++) {
  42.             //key value  0 --> doit32+-->+0
  43.             //key value  1 --> doit32+-->+1
  44.             //key value  2 --> doit32+-->+2
  45.             //2.创建一些待发送的消息，构建成kafka所需要的格式
  46.             ProducerRecord<String, String> record = new ProducerRecord<>("test01", i + "", "doit32-->" + i);
  47.             //3.调用kafka的api去发送消息
  48.             kafkaProducer.send(record);
  49.             Thread.sleep(100);
  50.         }
  51.         kafkaProducer.flush();
  52.         kafkaProducer.close();
  53.     }
  54. }

对于properties配置的第二种写法，相对来说不会出错，简单举例：

  1. public static void main(String[] args) {
  2.     Properties pros = new Properties();
  3.     pros.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux01:9092,linux02:9092,linux03:9092");
  4.     pros.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
  5.     pros.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
  6. }

消费者Api

一个正常的消费逻辑需要具备以下几个步骤：

  1. 配置消费者客户端参数及创建相应的消费者实例；
  2. 订阅主题topic；
  3. 拉取消息并消费；
  4. 定期向__consumer_offsets主题提交消费位移offset；
  5. 关闭消费者实例
  1. import org.apache.kafka.clients.consumer.ConsumerConfig;
  2. import org.apache.kafka.clients.consumer.ConsumerRecord;
  3. import org.apache.kafka.clients.consumer.ConsumerRecords;
  4. import org.apache.kafka.clients.consumer.KafkaConsumer;
  5. import org.apache.kafka.common.header.Header;
  6. import org.apache.kafka.common.header.Headers;
  7. import org.apache.kafka.common.record.TimestampType;
  8. import org.apache.kafka.common.serialization.StringDeserializer;
  10. import java.time.Duration;
  11. import java.util.Arrays;
  12. import java.util.Iterator;
  13. import java.util.Optional;
  14. import java.util.Properties;
  16. public class ConsumerDemo {
  17.     public static void main(String[] args) {
  18.         //1.创建kafka的消费者对象，附带着把配置文件搞定
  19.         Properties props = new Properties();
  20.         //props.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"linux01:9092,linux02:9092,linux03:9092");
  21.         //props.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  22.         //props.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  23.         // 定义kakfa 服务的地址，不需要将所有broker指定上
  24.        // props.put("bootstrap.servers", "linux01:9092,linux02:9092,linux03:9092");
  25.         // 制定consumer group
  26.         props.put("group.id", "g3");
  27.         // 是否自动提交offset  __consumer_offset   有多少分区  50 
  28.         props.put("enable.auto.commit", "true");
  29.         // 自动提交offset的时间间隔   -- 这玩意设置的大小怎么控制
  30.         props.put("auto.commit.interval.ms", "5000");  //50000   1000
  31.         // key的反序列化类
  32.         props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
  33.         // value的反序列化类
  34.         props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
  35.         // 如果没有消费偏移量记录，则自动重设为起始offset：latest, earliest, none
  36.         props.put("auto.offset.reset","earliest");
  37.         KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
  39.         //2.订阅主题(确定需要消费哪一个或者多个主题)
  40.         consumer.subscribe(Arrays.asList("test02"));
  41.         //3.开始从topic中获取数据
  42.         while (true){
  43.             ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(Integer.MAX_VALUE));
  44.             for (ConsumerRecord<String, String> record : records) {
  45.                 //这是数据所属的哪一个topic
  46.                 String topic = record.topic();
  47.                 //该条数据的偏移量
  48.                 long offset = record.offset();
  49.                 //这条数据是哪一个分区的
  50.                 int partition = record.partition();
  51.                 //这条数据记录的时间戳,但是这个时间戳有两个类型
  52.                 long timestamp = record.timestamp();
  53.                 //上面时间戳的类型，这个类型有两个，一个是CreateTime(这条数据创建的时间), LogAppendTime(这条数据往日志里面追加的时间)
  54.                 TimestampType timestampType = record.timestampType();
  55.                 //这个数据key的值
  56.                 String key = record.key();
  57.                 //这条数据value的值
  58.                 String value = record.value();
  59.                 //分区leader的纪元
  60.                 Optional<Integer> integer = record.leaderEpoch();
  61.                 //key的长度
  62.                 int keySize = record.serializedKeySize();
  63.                 //value的长度
  64.                 int valueSize = record.serializedValueSize();
  65.                 //数据的头部信息
  66.                 Headers headers = record.headers();
  67. //            for (Header header : headers) {
  68. //                String hKey = header.key();
  69. //                byte[] hValue = header.value();
  70. //                String valueString = new String(hValue);
  71. //                System.out.println("header的key值 = " + hKey + "header的value的值 = "+ valueString);
  72. //            }
  73.                 System.out.printf("topic = %s ,offset = %d, partition = %d, timestampType = %s ,timestamp = %d , key = %s , value = %s ,leader的纪元 = %d , key序列化的长度 = %d ,value 序列化的长度 = %d \r\n" ,
  74.                         topic,offset,partition,timestampType + "",timestamp,key,value,integer.get(),keySize,valueSize);
  75.             }
  76.         }
  78.         //4.关闭消费者对象
  79. //        consumer.close();
  80.     }
  81. }

subscribe订阅主题

  1. // subscribe有如下重载方法：
  2. public void subscribe(Collection<String> topics,ConsumerRebalanceListener listener) 
  3. public void subscribe(Collection<String> topics) 
  4. public void subscribe(Pattern pattern, ConsumerRebalanceListener listener) 
  5. public void subscribe(Pattern pattern)
  6. // 1.指定集合方式订阅主题
  7. consumer.subscribe(Arrays.asList(topicl ));
  9. // 2.正则方式订阅主题
  10. // 如果消费者采用的是正则表达式的方式（subscribe(Pattern)）订阅， 在之后的过程中，如果有人又创建了新的主题，并且主题名字与正表达式相匹配，那么这个消费者就可以消费到新添加的主题中的消息。
  11. // 如果应用程序需要消费多个主题，并且可以处理不同的类型，那么这种订阅方式就很有效。
  12. // 正则表达式的方式订阅
  13. consumer.subscribe(Pattern.compile ("topic.*" ));
  15. // 利用正则表达式订阅主题，可实现动态订阅

assign订阅主题

消费者不仅可以通过 KafkaConsumer.subscribe() 方法订阅主题，还可直接订阅某些主题的指定分区；
在 KafkaConsumer 中提供了 assign() 方法来实现这些功能，此方法的具体定义如下：

  1. import org.apache.kafka.clients.consumer.ConsumerConfig;
  2. import org.apache.kafka.clients.consumer.ConsumerRecord;
  3. import org.apache.kafka.clients.consumer.ConsumerRecords;
  4. import org.apache.kafka.clients.consumer.KafkaConsumer;
  5. import org.apache.kafka.common.TopicPartition;
  6. import org.apache.kafka.common.header.Headers;
  7. import org.apache.kafka.common.record.TimestampType;
  8. import org.apache.kafka.common.serialization.StringDeserializer;
  10. import java.time.Duration;
  11. import java.util.Arrays;
  12. import java.util.Optional;
  13. import java.util.Properties;
  15. public class ConsumerDemo1 {
  16.     public static void main(String[] args) {
  17.         //1.创建kafka的消费者对象，附带着把配置文件搞定
  18.         Properties props = new Properties();
  19.         props.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"linux01:9092,linux02:9092,linux03:9092");
  20.         props.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  21.         props.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  22.         props.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"doit01");
  24.         KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
  26.         //2.订阅主题(确定需要消费哪一个或者多个主题)
  27. //        consumer.subscribe(Arrays.asList("test03"));
  29. //        consumer.poll(Duration.ofMillis(Integer.MAX_VALUE));
  30. //        //我现在想手动指定，我需要从哪边开始消费
  31. //        //如果用subscribe去订阅主题的时候，他内部会给这个消费者组来一个自动再均衡
  32. //        consumer.seek(new TopicPartition("test03",0),2);
  33.         TopicPartition tp01 = new TopicPartition("test03", 0);
  35.         //他就是手动去订阅主题和partition，有了这个就不需要再去订阅subscribe主题了，手动指定以后，他的内部就不会再来自动均衡了
  36.         consumer.assign(Arrays.asList(tp01)); // 手动订阅指定主题的指定分区的指定位置
  37.         consumer.seek(new TopicPartition("test03",0),2);
  39.         //3.开始从topic中获取数据
  40.         while (true){
  41.             ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(Integer.MAX_VALUE));
  42.             for (ConsumerRecord<String, String> record : records) {
  43.                 //这是数据所属的哪一个topic
  44.                 String topic = record.topic();
  45.                 //该条数据的偏移量
  46.                 long offset = record.offset();
  47.                 //这条数据是哪一个分区的
  48.                 int partition = record.partition();
  49.                 //这条数据记录的时间戳,但是这个时间戳有两个类型
  50.                 long timestamp = record.timestamp();
  51.                 //上面时间戳的类型，这个类型有两个，一个是CreateTime(这条数据创建的时间), LogAppendTime(这条数据往日志里面追加的时间)
  52.                 TimestampType timestampType = record.timestampType();
  53.                 //这个数据key的值
  54.                 String key = record.key();
  55.                 //这条数据value的值
  56.                 String value = record.value();
  58.                 //分区leader的纪元
  59.                 Optional<Integer> integer = record.leaderEpoch();
  60.                 //key的长度
  61.                 int keySize = record.serializedKeySize();
  62.                 //value的长度
  63.                 int valueSize = record.serializedValueSize();
  64.                 //数据的头部信息
  65.                 Headers headers = record.headers();
  66. //            for (Header header : headers) {
  67. //                String hKey = header.key();
  68. //                byte[] hValue = header.value();
  69. //                String valueString = new String(hValue);
  70. //                System.out.println("header的key值 = " + hKey + "header的value的值 = "+ valueString);
  71. //            }
  72.                 System.out.printf("topic = %s ,offset = %d, partition = %d, timestampType = %s ,timestamp = %d , key = %s , value = %s ,leader的纪元 = %d , key序列化的长度 = %d ,value 序列化的长度 = %d \r\n" ,
  73.                         topic,offset,partition,timestampType + "",timestamp,key,value,integer.get(),keySize,valueSize);
  74.             }
  75.         }
  77.         //4.关闭消费者对象
  78. //        consumer.close();
  79.     }
  80. }

这个方法只接受参数partitions，用来指定需要订阅的分区集合。示例如下：

  1. consumer.assign(Arrays.asList(new TopicPartition ("tpc_1" , 0),new TopicPartition(“tpc_2”,1))) ;

subscribe与assign的区别

  • 通过subscribe()方法订阅主题具有消费者自动再均衡功能 ；

在多个消费者的情况下可以根据分区分配策略来自动分配各个消费者与分区的关系。当消费组的消费者增加或减少时，分区分配关系会自动调整，以实现消费负载均衡及故障自动转移。

  • assign() 方法订阅分区时，是不具备消费者自动均衡的功能的；

其实这一点从assign方法参数可以看出端倪，两种类型subscribe()都有ConsumerRebalanceListener类型参数的方法，而assign()方法却没有。

取消订阅

可以使用KafkaConsumer中的unsubscribe()方法采取消主题的订阅，这个方法既可以取消通过 subscribe( Collection）方式实现的订阅；
也可以取消通过subscribe(Pattem）方式实现的订阅，还可以取消通过assign( Collection）方式实现的订阅。

  1. consumer.unsubscribe();
  2. // 如果将subscribe(Collection )或assign(Collection）集合参数设置为空集合，作用与unsubscribe（）方法相同
  3. // 如下示例中三行代码的效果相同：
  4. consumer.unsubscribe();
  5. consumer.subscribe(new ArrayList<String>()) ;
  6. consumer.assign(new ArrayList<TopicPartition>());

消息的消费模式

Kafka中的消费是基于拉取模式的。
消息的消费一般有两种模式：推送模式和拉取模式。推模式是服务端主动将消息推送给消费者，而拉模式是消费者主动向服务端发起请求来拉取消息。

  1. public class ConsumerRecord<K, V> {
  2.     public static final long NO_TIMESTAMP = RecordBatch.NO_TIMESTAMP;
  3.     public static final int NULL_SIZE = -1;
  4.     public static final int NULL_CHECKSUM = -1;
  6.     private final String topic;
  7.     private final int partition;
  8.     private final long offset;
  9.     private final long timestamp;
  10.     private final TimestampType timestampType;
  11.     private final int serializedKeySize;
  12.     private final int serializedValueSize;
  13.     private final Headers headers;
  14.     private final K key;
  15.     private final V value;
  17.     private volatile Long checksum;
  18. }
  • topic partition 这两个属性分别代表消息所属主题的名称和所在分区的编号。
  • offset 表示消息在所属分区的偏移量。
  • timestamp 表示时间戳，与此对应的timestampType 表示时间戳的类型。
  • timestampType 有两种类型 CreateTime 和LogAppendTime ，分别代表消息创建的时间戳和消息追加到日志的时间戳。
  • headers 表示消息的头部内容。
  • key value 分别表示消息的键和消息的值，一般业务应用要读取的就是value ；
  • serializedKeySize、serializedValueSize分别表示key、value 经过序列化之后的大小，如果 key 为空，则 serializedKeySize 值为 -1，同样，如果value为空，则serializedValueSize 的值也会为 -1；
  • checksum 是CRC32的校验值。
  1. /**
  2.  * 订阅与消费方式2
  3.  */
  4. TopicPartition tp1 = new TopicPartition("x", 0);
  5. TopicPartition tp2 = new TopicPartition("y", 0);
  6. TopicPartition tp3 = new TopicPartition("z", 0);
  7. List<TopicPartition> tps = Arrays.asList(tp1, tp2, tp3);
  8. consumer.assign(tps);
  10. while (true) {
  11.     ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
  12.     for (TopicPartition tp : tps) {
  13.         List<ConsumerRecord<String, String>> rList = records.records(tp);
  14.         for (ConsumerRecord<String, String> r : rList) {
  15.             r.topic();
  16.             r.partition();
  17.             r.offset();
  18.             r.value();
  19.             //do something to process record.
  20.         }
  21.     }
  22. }

指定位移消费

有些时候，我们需要一种更细粒度的掌控，可以让我们从特定的位移处开始拉取消息，而 KafkaConsumer 中的seek()方法正好提供了这个功能，让我们可以追前消费或回溯消费。
seek()方法的具体定义如下：

  1. // seek都是和assign这个方法一起用 指定消费位置
  2. public void seek(TopicPartiton partition,long offset)

代码示例：

  1. public class ConsumerDemo3指定偏移量消费 {
  2.     public static void main(String[] args) {
  4.         Properties props = new Properties();
  5.         props.setProperty(ConsumerConfig.GROUP_ID_CONFIG,"g002");
  6.         props.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"doit01:9092");
  7.         props.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  8.         props.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
  9.         props.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"latest");
  10.         // 是否自动提交消费位移
  11.         props.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
  13.         // 限制一次poll拉取到的数据量的最大值
  14.         props.setProperty(ConsumerConfig.FETCH_MAX_BYTES_CONFIG,"10240000");
  15.          KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
  17.         // assign方式订阅doit27-1的两个分区
  18.         TopicPartition tp0 = new TopicPartition("doit27-1", 0);
  19.         TopicPartition tp1 = new TopicPartition("doit27-1", 1);
  20.         
  21.         consumer.assign(Arrays.asList(tp0,tp1));
  22.         // 指定分区0，从offset：800开始消费    ；  分区1，从offset：650开始消费
  23.         consumer.seek(tp0,200);
  24.         consumer.seek(tp1,250);
  26.         // 开始拉取消息
  27.         while(true){
  28.             ConsumerRecords<String, String> poll = consumer.poll(Duration.ofMillis(3000));
  29.             for (ConsumerRecord<String, String> rec : poll) {
  30.                 System.out.println(rec.partition()+","+rec.key()+","+rec.value()+","+rec.offset());
  31.             }
  32.         }
  33.     }
  34. }

自动提交消费者偏移量

Kafka中默认的消费位移的提交方式是自动提交，这个由消费者客户端参数enable.auto.commit 配置，默认值为 true 。当然这个默认的自动提交不是每消费一条消息就提交一次，而是定期提交，这个定期的周期时间由客户端参数 auto.commit.interval.ms配置，默认值为5秒，此参数生效的前提是 enable. auto.commit 参数为 true。

在默认的方式下，消费者每隔5秒会将拉取到的每个分区中最大的消息位移进行提交。自动位移提交的动作是在 poll() 方法的逻辑里完成的，在每次真正向服务端发起拉取请求之前会检查是否可以进行位移提交，如果可以，那么就会提交上一次轮询的位移。

Kafka 消费的编程逻辑中位移提交是一大难点，自动提交消费位移的方式非常简便，它免去了复杂的位移提交逻辑，让编码更简洁。但随之而来的是重复消费和消息丢失的问题。

  • 重复消费

假设刚刚提交完一次消费位移，然后拉取一批消息进行消费，在下一次自动提交消费位移之前，消费者崩溃了，那么又得从上一次位移提交的地方重新开始消费，这样便发生了重复消费的现象（对于再均衡的情况同样适用）。我们可以通过减小位移提交的时间间隔来减小重复消息的窗口大小，但这样并不能避免重复消费的发送，而且也会使位移提交更加频繁。

  • 丢失消息

按照一般思维逻辑而言，自动提交是延时提交，重复消费可以理解，那么消息丢失又是在什么情形下会发生的呢？

拉取线程不断地拉取消息并存入本地缓存，比如在BlockingQueue 中，另一个处理线程从缓存中读取消息并进行相应的逻辑处理。设目前进行到了第 y+l 次拉取，以及第m次位移提交的时候，也就是 x+6 之前的位移己经确认提交了，处理线程却还正在处理x+3的消息；此时如果处理线程发生了异常，待其恢复之后会从第m次位移提交处，也就是 x+6 的位置开始拉取消息，那么 x+3至x+6 之间的消息就没有得到相应的处理，这样便发生消息丢失的现象。

手动提交消费者偏移量（调用kafka api）

自动位移提交的方式在正常情况下不会发生消息丢失或重复消费的现象，但是在编程的世界里异常无可避免；同时，自动位移提交也无法做到精确的位移管理。在 Kafka中还提供了手动位移提交的方式，这样可以使得开发人员对消费位移的管理控制更加灵活。

很多时候并不是说拉取到消息就算消费完成，而是需要将消息写入数据库、写入本地缓存，或者是更加复杂的业务处理。在这些场景下，所有的业务处理完成才能认为消息被成功消费；

手动的提交方式可以让开发人员根据程序的逻辑在合适的时机进行位移提交。开启手动提交功能的前提是消费者客户端参数 enable.auto.commit 配置为false ，示例如下：

  1. props.put(ConsumerConf.ENABLE_AUTO_COMMIT_CONFIG, false);

手动提交可以细分为同步提交和异步提交，对应于 KafkaConsumer 中的 commitSync()和
commitAsync()两种类型的方法。
同步提交的方式
commitSync()方法的定义如下：

  1. /**
  2.  * 手动提交offset
  3.  */
  4. while (true) {
  5.     ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
  6.     for (ConsumerRecord<String, String> r : records) {
  7.         //do something to process record.
  8.     }
  9.     consumer.commitSync();
  10. }

对于采用 commitSync()的无参方法，它提交消费位移的频率和拉取批次消息、处理批次消息的频率是一样的，如果想寻求更细粒度的、更精准的提交，那么就需要使用commitSync()的另一个有参方法，具体定义如下：

  1. public void commitSync(final Map<TopicPartition，OffsetAndMetadata> offsets)

示例代码如下：

  1. while (true) {
  2.     ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
  3.     for (ConsumerRecord<String, String> r : records) {
  4.         long offset = r.offset();
  5.         //do something to process record.
  7.         TopicPartition topicPartition = new TopicPartition(r.topic(), r.partition());
  8.         consumer.commitSync(Collections.singletonMap(topicPartition,new OffsetAndMetadata(offset+1)));
  9.     }
  10. }

提交的偏移量 = 消费完的record的偏移量 + 1
因为，__consumer_offsets中记录的消费偏移量，代表的是，消费者下一次要读取的位置！！！

异步提交方式

异步提交的方式（ commitAsync（））在执行的时候消费者线程不会被阻塞；可能在提交消费位移的结果还未返回之前就开始了新一次的拉取。异步提交可以让消费者的性能得到一定的增强。 commitAsync方法有一个不同的重载方法，具体定义如下

  1. /**
  2.  * 异步提交offset
  3.  */
  4. while (true) {
  5.     ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
  6.     for (ConsumerRecord<String, String> r : records) {
  7.         long offset = r.offset();
  9.         //do something to process record.
  10.         TopicPartition topicPartition = new TopicPartition(r.topic(), r.partition());
  11.         consumer.commitSync(Collections.singletonMap(topicPartition,new OffsetAndMetadata(offset+1)));
  12.         consumer.commitAsync(Collections.singletonMap(topicPartition, new OffsetAndMetadata(offset + 1)), new OffsetCommitCallback() {
  13.      @Override
  14.      public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
  15.                 if(e == null ){
  16.                     System.out.println(map);
  17.                 }else{
  18.                     System.out.println("error commit offset");
  19.                 }
  20.             }
  21.         });
  22.     }
  23. }

手动提交位移（时机的选择）

  • 数据处理完成之前先提交偏移量

可能会发生漏处理的现象（数据丢失）反过来说，这种方式实现了： at most once的数据处理（传递）语义

  • 数据处理完成之后再提交偏移量

可能会发生重复处理的现象（数据重复）反过来说，这种方式实现了： at least once的数据处理（传递）语义当然，数据处理（传递）的理想语义是： exactly once（精确一次）Kafka也能做到exactly once（基于kafka的事务机制）

代码示例:

  1. import org.apache.kafka.clients.consumer.*;
  2. import org.apache.kafka.common.TopicPartition;
  3. import org.apache.kafka.common.serialization.StringDeserializer;
  5. import java.sql.*;
  6. import java.time.Duration;
  7. import java.util.Arrays;
  8. import java.util.Collection;
  9. import java.util.Properties;
  11. public class CommitOffsetByMyself {
  12.     public static void main(String[] args) throws SQLException {
  14.         //获取mysql的连接对象
  15.         Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/football", "root", "123456");
  16.         connection.setAutoCommit(false);
  17.         PreparedStatement pps = connection.prepareStatement("insert into user values (?,?,?)");
  18.         PreparedStatement pps_offset = connection.prepareStatement("insert into offset values (?,?) on duplicate key update offset = ?");
  20.         Properties props = new Properties();
  21.         props.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux01:9092,linux02:9092,linux03:9092");
  22.         props.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  23.         props.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
  24.         //设置手动提交偏移量参数，需要将自动提交给关掉
  25.         props.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
  26.         //设置从哪里开始消费
  27. //        props.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "latest");
  28.         //设置组id
  29.         props.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "group001");
  31.         KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
  32.         //订阅主题
  33.         consumer.subscribe(Arrays.asList("kafka2mysql"), new ConsumerRebalanceListener() {
  34.             @Override
  35.             public void onPartitionsRevoked(Collection<TopicPartition> collection) {
  37.             }
  39.             @Override
  40.             public void onPartitionsAssigned(Collection<TopicPartition> collection) {
  41.                 for (TopicPartition topicPartition : collection) {
  42.                     try {
  43.                         PreparedStatement get_offset = connection.prepareStatement("select offset from offset where topic_partition = ?");
  44.                         String topic = topicPartition.topic();
  45.                         int partition = topicPartition.partition();
  46.                         get_offset.setString(1, topic + "_" + partition);
  47.                         ResultSet resultSet = get_offset.executeQuery();
  48.                         if (resultSet.next()){
  49.                             int offset = resultSet.getInt(1);
  50.                             System.out.println("发生了再均衡，被分配了分区消费权，并且查到了目标分区的偏移量"+partition+" , "+offset);
  51.                             //拿到了offset后就可以定位消费了
  52.                             consumer.seek(new TopicPartition(topic, partition), offset);
  53.                         }
  54.                     } catch (SQLException e) {
  55.                         e.printStackTrace();
  56.                     }
  57.                 }
  58.             }
  59.         });
  61.         //拉去数据后写入到mysql
  62.         while (true) {
  63.             try {
  64.                 ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(Integer.MAX_VALUE));
  65.                 for (ConsumerRecord<String, String> record : records) {
  66.                     String data = record.value();
  67.                     String[] arr = data.split(",");
  68.                     String id = arr[0];
  69.                     String name = arr[1];
  70.                     String age = arr[2];
  72.                     pps.setInt(1, Integer.parseInt(id));
  73.                     pps.setString(2, name);
  74.                     pps.setInt(3, Integer.parseInt(age));
  75.                     pps.execute();
  77.                     //埋个异常，看看是不是真的是这样
  78. //                    if (Integer.parseInt(id) == 5) {
  79. //                        throw new SQLException();
  80. //                    }
  82.                     long offset = record.offset();
  83.                     int partition = record.partition();
  84.                     String topic = record.topic();
  85.                     pps_offset.setString(1, topic + "_" + partition);
  86.                     pps_offset.setInt(2, (int) offset + 1);
  87.                     pps_offset.setInt(3, (int) offset + 1);
  88.                     pps_offset.execute();
  89.                     //提交jdbc事务
  90.                     connection.commit();
  91.                 }
  92.             } catch (Exception e) {
  93.                 connection.rollback();
  94.             }
  95.         }
  96.     }
  97. }

消费者提交偏移量方式的总结

consumer的消费位移提交方式：

  • 全自动
    1. auto.offset.commit = true
    2. 定时提交到consumer_offsets
  • 半自动
    1. auto.offset.commit = false;
    2. 然后手动触发提交 consumer.commitSync()；
    3. 提交到consumer_offsets
  • 全手动
    1. auto.offset.commit = false;
    2. 写自己的代码去把消费位移保存到你自己的地方mysql/zk/redis/
    3. 提交到自己所涉及的存储；初始化时也需要自己去从自定义存储中查询到消费位移

原文链接：https://www.cnblogs.com/paopaoT/p/17467506.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Apache Kafka热门文章

  • Kafka监控工具汇总
  • Kraft模式下Kafka脚本的使用
  • Kafka web console安装
  • kafka_2.11-2.0.0_安装部署
  • ELK日志方案--使用Filebeat收集日志并输出到Kafka
  • Kafka相关内容总结（存储和性能）
  • 一次flume exec source采集日志到kafka因为单条日志数据非常大同步失败的踩坑带来的思考
  • Kafka使用jmxtrans+influxdb+grafana监控JMX指标
  • Micronaut 微服务中使用 Kafka
  • 什么是Kafka？

    • Apache Kafka推荐文章

  • 异源数据同步 → DataX 为什么要支持 kafka？
  • 解锁强强组合: 使用 Kafka + ClickHouse 快速搭建流数据实时处理平台(DoubleCloud 博客)
  • Kafka 线上性能调优
  • Kafka原理剖析之「位点提交」
  • Kafka 社区KIP-382中文译文（MirrorMaker2/集群复制/高可用/灾难恢复）
  • kafka源码阅读之MacBook Pro M1搭建Kafka2.7版本源码运行环境
  • Kafka干货之「零拷贝」
  • 扫盲Kafka？看这一篇就够了！
  • 从一次Kafka宕机说起（JVM hang）
  • 从Kafka中学习高性能系统如何设计

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号