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

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

3)创建 first topic

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

选项说明:

--topic 定义 topic 名

--replication-factor 定义副本数

--partitions 定义分区数

4)查看 first 主题的详情

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

5)修改分区数(注意:分区数只能增加,不能减少)

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

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

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

7)删除 topic(学生自己演示)

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

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

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

2)发送消息

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

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

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

2)消费消息

(1)消费 first 主题中的数据。

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

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

[atguigu@hadoop102 kafka]$ bin/kafka-console-consumer.sh --
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)导入依赖

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

(3)创建包名:com.atguigu.kafka.producer

(4)编写不带回调函数的 API 代码

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
public class CustomProducer {
 public static void main(String[] args) throws 
InterruptedException {
 // 1. 创建 kafka 生产者的配置对象
 Properties properties = new Properties();
 // 2. 给 kafka 配置对象添加配置信息:bootstrap.servers
 properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
"hadoop102:9092");
 
 // key,value 序列化(必须):key.serializer,value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
"org.apache.kafka.common.serialization.StringSerializer");
 
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, 
"org.apache.kafka.common.serialization.StringSerializer");
 // 3. 创建 kafka 生产者对象
 KafkaProducer<String, String> kafkaProducer = new 
KafkaProducer<String, String>(properties);
 // 4. 调用 send 方法,发送消息
 for (int i = 0; i < 5; i++) {
 kafkaProducer.send(new 
ProducerRecord<>("first","atguigu " + i));
 }
 // 5. 关闭资源
 kafkaProducer.close();
 }
} 

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

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

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

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

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

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

package com.atguigu.kafka.producer; 
 
import org.apache.kafka.clients.producer.*; import java.util.Properties; 
 
public class CustomProducerCallback { 
 
    public 	static 	void 	main(String[] 	args) 	throws 
InterruptedException { 
 
        // 1. 创建kafka生产者的配置对象 
        Properties properties = new Properties(); 
 
        // 2. 给kafka配置对象添加配置信息 
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092"); 
 
        // key,value序列化(必须):key.serializer,value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
StringSerializer.class.getName()); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
 
        // 3. 创建kafka生产者对象 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
 
        // 4. 调用send方法,发送消息 
        for (int i = 0; i < 5; i++) { 
 
            // 添加回调             kafkaProducer.send(new 	ProducerRecord<>("first", "atguigu " + i), new Callback() {  
                // 该方法在Producer收到ack时调用,为异步调用 
                @Override 
                public void onCompletion(RecordMetadata metadata, Exception exception) { 
                     if (exception == null) { 
                        // 没有异常,输出信息到控制台 
                        System.out.println(" 主 题 : " + 
metadata.topic() + "->"  + "分区:" + metadata.partition()); 
                    } else { 
                        // 出现异常打印                         exception.printStackTrace(); 
                    } 
                } 
            }); 
 
            // 延迟一会会看到数据发往不同分区 
            Thread.sleep(2); 
        } 
 
        // 5. 关闭资源 
        kafkaProducer.close(); 
    } 
} 

测试:

①在 hadoop102 上开启 Kafka 消费者。

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

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

[atguigu@hadoop102 kafka]$  bin/kafka-console-consumer.sh -bootstrap-server hadoop102:9092 --topic first 
 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()方法即可

package com.atguigu.kafka.producer; 
 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; 
import java.util.concurrent.ExecutionException; 
 
public class CustomProducerSync { 
 
    public 	static 	void 	main(String[] 	args) 	throws
InterruptedException, ExecutionException { 
 
        // 1. 创建kafka生产者的配置对象 
        Properties properties = new Properties(); 
 
        // 2. 给kafka配置对象添加配置信息 
   properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092");  
        // key,value序列化(必须):key.serializer,value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
StringSerializer.class.getName()); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
 
        // 3. 创建kafka生产者对象 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);  
        // 4. 调用send方法,发送消息 
        for (int i = 0; i < 10; i++) { 
 
            // 异步发送 默认 
//            kafkaProducer.send(new 
ProducerRecord<>("first","kafka" + i)); 
            // 同步发送 
            kafkaProducer.send(new 
ProducerRecord<>("first","kafka" + i)).get(); 
 
        } 
 
        // 5. 关闭资源         kafkaProducer.close(); 
    } 
} 

3.4 生产者分区

3.4.1 分区好处

(4)便于合理使用存储资源:每个Partition在一个Broker上存储,可以把海量的数据按照分区切割成一块一块数据存储在多台Broker里。合理控制分区的任务,可以实现载均衡的效果。

2)提高并行度,生产者可以以分区为单位发送数据,消费者可以以分区为单位进行消费数据

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

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

package com.atguigu.kafka.producer; 
 
import org.apache.kafka.clients.producer.*; 
 
import java.util.Properties; 
 
public class CustomProducerCallbackPartitions { 
 
    public static void main(String[] args) { 
 
        // 1. 创建kafka生产者的配置对象 
        Properties properties = new Properties(); 
 
        // 2. 给kafka配置对象添加配置信息 
      
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092");  
        // key,value序列化(必须):key.serializer,value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
StringSerializer.class.getName()); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
 
        for (int i = 0; i < 5; i++) { 
            // 指定数据发送到1号分区,key为空(IDEA中ctrl + p查看参数)             kafkaProducer.send(new ProducerRecord<>("first", 
1,"","atguigu " + i), new Callback() { 
                @Override 
                public void onCompletion(RecordMetadata metadata, Exception e) { 
                    if (e == null){ 
                        System.out.println(" 主 题 : " + 
metadata.topic() + "->"  + "分区:" + metadata.partition() 
                        );                     }else { 
                        e.printStackTrace(); 
                    } 
                } 
            }); 
        } 
 
        kafkaProducer.close(); 
    } 
} 

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

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

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

package com.atguigu.kafka.producer; 
 
import org.apache.kafka.clients.producer.*; import java.util.Properties; 
 
public class CustomProducerCallback { 
 
    public static void main(String[] args) { 
 
        Properties properties = new Properties(); 
         
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092"); 
 
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
StringSerializer.class.getName()); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
 
        for (int i = 0; i < 5; i++) { 
            // 依次指定key 值为a,b,f ,数据key 的hash 值与3 个分区求余,分别发往1、2、0 
            kafkaProducer.send(new 	ProducerRecord<>("first", 
"a","atguigu " + i), new Callback() { 
                @Override                 public void onCompletion(RecordMetadata metadata, Exception e) { 
                    if (e == null){ 
                        System.out.println(" 主 题 : " + 
metadata.topic() + "->" + "分区:" + metadata.partition() 
                        );                     }else { 
                        e.printStackTrace(); 
                    } 
                } 
            }); 
        } 
         kafkaProducer.close(); 
    } 
} 

①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()方法。

    package com.atguigu.kafka.producer;

    import org.apache.kafka.clients.producer.Partitioner; import org.apache.kafka.common.Cluster;

    import java.util.Map;

    /**

      1. 实现接口Partitioner
      1. 实现3个方法:partition,close,configure
      1. 编写partition方法,返回分区号
        */
        public class MyPartitioner implements Partitioner {

      /**

    • 返回信息对应的分区

    • @param topic 主题

    • @param key 消息的key

    • @param keyBytes 消息的key序列化后的字节数组

    • @param value 消息的value

    • @param valueBytes 消息的value序列化后的字节数组

    • @param cluster 集群元数据可以查看分区信息

    • @return
      */
      @Override
      public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
      // 获取消息
      String msgValue = value.toString();

      // 创建partition         int partition; 
      
      // 判断消息是否包含atguigu 
      if (msgValue.contains("atguigu")){             partition = 0; 
      }else { 
          partition = 1; 
      } 
      
      // 返回分区号         return partition; 
      

      }

      // 关闭资源
      @Override
      public void close() {

      }

      // 配置方法
      @Override
      public void configure(Map<String, ?> configs) {

      }
      }

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

package com.atguigu.kafka.producer; 
 
import org.apache.kafka.clients.producer.*; 
 
import java.util.Properties; 
 
public class CustomProducerCallbackPartitions { 
 
    public 	static 	void 	main(String[] 
InterruptedException { 
 	args) 	throws 
        Properties properties = new Properties(); 
         
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102 :9092"); 
 
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
StringSerializer.class.getName()); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName()); 
 
        // 添加自定义分区器 
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.atgui gu.kafka.producer.MyPartitioner"); 
 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties); 
 
        for (int i = 0; i < 5; i++) { 
             
            kafkaProducer.send(new 	ProducerRecord<>("first", 
"atguigu " + i), new Callback() { 
                @Override 
                public void onCompletion(RecordMetadata metadata, Exception e) { 
                    if (e == null){ 
                        System.out.println(" 主 题 : " + 
metadata.topic() + "->" + "分区:" + metadata.partition() 
                        );                     }else { 
                        e.printStackTrace(); 
                    } 
                } 
            }); 
        } 
 
        kafkaProducer.close(); 
    } 
} 

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

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

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

package com.atguigu.kafka.producer; 
 import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; 
 
import java.util.Properties; 
 
public class CustomProducerParameters { 
 
    public 	static 	void 	main(String[] 	args) 	throws 
InterruptedException { 
 
        // 1. 创建kafka生产者的配置对象 
        Properties properties = new Properties(); 
 
        // 2. 给kafka配置对象添加配置信息:bootstrap.servers         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
"hadoop102:9092"); 
         
        // key,value序列化(必须):key.serializer,value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
"org.apache.kafka.common.serialization.StringSerializer"); 
        
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");  
        // batch.size:批次大小,默认16K 
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);  
        // linger.ms:等待时间,默认0         properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);  
        // RecordAccumulator:缓冲区大小,默认32M:buffer.memory         properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 
33554432);  
        // compression.type:压缩,默认 none,可配置值 gzip、snappy、 lz4和zstd 
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");  
        // 3. 创建kafka生产者对象 
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
 
        // 4. 调用send方法,发送消息 
        for (int i = 0; i < 5; i++) { 
 
            kafkaProducer.send(new 
ProducerRecord<>("first","atguigu " + i)); 
 
        } 
 
        // 5. 关闭资源 
        kafkaProducer.close(); 
    } 
}  

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

  1. 回顾发送流程

ack 应答原理

ACK应答级别

  1. 代码配置

    package com.atguigu.kafka.producer;
    import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord;

    import java.util.Properties;

    public class CustomProducerAck {

     public 	static 	void 	main(String[] 	args) 
    

    InterruptedException {

         // 1. 创建kafka生产者的配置对象 
         Properties properties = new Properties(); 
    
         // 2. 给kafka配置对象添加配置信息:bootstrap.servers 	throws 
    
         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    

    "hadoop102:9092");

         // key,value序列化(必须):key.serializer,value.serializer         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
    

    StringSerializer.class.getName());

    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

         // 设置acks 
         properties.put(ProducerConfig.ACKS_CONFIG, "all");  
         // 重试次数retries,默认是int最大值,2147483647 
         properties.put(ProducerConfig.RETRIES_CONFIG, 3);  
         // 3. 创建kafka生产者对象 
         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    
         // 4. 调用send方法,发送消息 
         for (int i = 0; i < 5; i++) { 
    
             kafkaProducer.send(new 
    

    ProducerRecord<>("first","atguigu " + i));

         } 
    
         // 5. 关闭资源 
         kafkaProducer.close(); 
     } 
    

    }

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初始化事务 
void initTransactions(); 
 
// 2开启事务 
void beginTransaction() throws ProducerFencedException; 
 
// 3在事务内提交已经消费的偏移量(主要用于消费者) 
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets, 
                              String 	consumerGroupId) 	throws 
ProducerFencedException; 
 
// 4提交事务 
void commitTransaction() throws ProducerFencedException; 
 
// 5放弃事务(类似于回滚事务的操作) 
void abortTransaction() throws ProducerFencedException; 
  1. 单个 Producer,使用事务保证消息的仅一次发送

    package com.atguigu.kafka.producer;

    import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord;

    import java.util.Properties;

    public class CustomProducerTransactions {

     public 	static 	void 	main(String[] 	args) 	throws 
    

    InterruptedException {

         // 1. 创建kafka生产者的配置对象 
         Properties properties = new Properties(); 
    
         // 2. 给kafka配置对象添加配置信息 
         properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, 
    

    "hadoop102:9092");

         // key,value序列化 
         properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, 
    

    StringSerializer.class.getName());

    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

         // 设置事务id(必须),事务id任意起名 
         properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0"); 
    
         // 3. 创建kafka生产者对象 
         KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties); 
    
         // 初始化事务         kafkaProducer.initTransactions(); 
         // 开启事务         kafkaProducer.beginTransaction();         try { 
             // 4. 调用send方法,发送消息             for (int i = 0; i < 5; i++) { 
                 // 发送消息 
                 kafkaProducer.send(new ProducerRecord<>("first", 
    

    "atguigu " + i));
    }

    // int i = 1 / 0;

             // 提交事务             kafkaProducer.commitTransaction(); 
    
         } catch (Exception e) { 
             // 终止事务             kafkaProducer.abortTransaction(); 
         } finally {             // 5. 关闭资源 
             kafkaProducer.close(); 
         } 
     } 
    

    }

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的数据都是有序的。

相关推荐
手握风云-3 分钟前
数据结构(Java版)第二期:包装类和泛型
java·开发语言·数据结构
天冬忘忧9 分钟前
Kafka 数据倾斜:原因、影响与解决方案
分布式·kafka
隔着天花板看星星13 分钟前
Kafka-Consumer理论知识
大数据·分布式·中间件·kafka
holywangle14 分钟前
解决Flink读取kafka主题数据无报错无数据打印的重大发现(问题已解决)
大数据·flink·kafka
隔着天花板看星星15 分钟前
Kafka-副本分配策略
大数据·分布式·中间件·kafka
喵叔哟23 分钟前
重构代码中引入外部方法和引入本地扩展的区别
java·开发语言·重构
尘浮生29 分钟前
Java项目实战II基于微信小程序的电影院买票选座系统(开发文档+数据库+源码)
java·开发语言·数据库·微信小程序·小程序·maven·intellij-idea
金刚猿36 分钟前
简单理解下基于 Redisson 库的分布式锁机制
分布式·分布式锁·redisson
不是二师兄的八戒1 小时前
本地 PHP 和 Java 开发环境 Docker 化与配置开机自启
java·docker·php
我一直在流浪1 小时前
Kafka - 消费者程序仅消费一半分区消息的问题
分布式·kafka