KAFKA第二课之生产者(面试重点)

生产者学习

1.1 生产者消息发送流程

在消息发送的过程中，涉及到了两个线程——main线程和Sender线程。在main线程中创建了一个双端队列RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka Broker。
生产者如何发送的？
现在Main线程中将数据进行处理，处理成IO型数据，然后调用sender进行发送
Main:
1.读取生产者配置
2.产生数据
3.过滤数据（校验什么的）
4.序列化
5.放入缓冲区 RecordAccumulator
6.发送Sender

细节：考虑的问题 1.生产者配置的读取和修改 2.数据的过滤与分区， 3.缓冲区是如何设置的，大小
4.发送（发送失败怎么样，请求区的大小）
这里注意一下，可以在缓冲区对数据进行压缩，这样就提高缓冲区的容量和发送的数据量，提高吞吐量

1.2 同步发送与异步发送

1.什么是同步和异步

同步就是，串行，一条龙异步一起运行
举例：餐馆点餐
同步：需要等服务员过来，让服务员记录，
异步：点餐APP直接点餐，交给队列，让他自己运行

2.发送的同步异步

同步：需要得到返回值
异步：发送过去不管了

3. 分区好处

啥是分区？
将一个数据块分成多个数据块
将数据分布式处理了
存储：可以分在多个机器上，也可以整多个副本。便于存储，同时提高健壮性
IO：多个数据块可以同时进行发送接收消费。生产者可以以分区为单位发送数据，消费者可以以分区为单位进行消费

4. 默认分区器

前提条件： 1.分区 2.key值
规则：

1存在，按1分区
1不存在，按2.key值对分区数取余得到的值分区
1.2都不存在随机选个分区，等这个批次发送完了，再换

3 就是粘性分区
那么粘性分区的缺点是什么？
因为缓冲区溢出的条件是，大小和时间双重判断，如果大小不够，但是时间够了，还是会发走，这样，最后导致，分区上产生数据倾斜
如何解决的？
3.3.1 Kafka去掉粘性分区的时间控制，批次只由大小判断

1.3.自定义分区器

1.思路

1.实现接口Parititoner,重写相关方法
2.修改配置将partitioner设置为默认配置

2.1 自定义分区器代码

public class MyPartitioner implements Partitioner {
    
    
    //  自定义分区器 实现partitioner接口

    // 1.分区方法
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
    
    

        // 获取消息
        String data = value.toString();
        // 创建partition 作为最后的分区标识
        int partitions;

        // 分区逻辑
        // 根据含有的字符串进行判断 判断进入哪个分区
        if (data.contains("atguigu")){
    
    
             partitions = 0;
        } else if (data.contains("shangguigu")){
    
    
            partitions = 1;
        } else {
    
    
            partitions = 2;
        }
        return partitions;
    }

    @Override
    public void close() {
    
    

    }

    @Override
    public void configure(Map<String, ?> configs) {
    
    

    }
}

2.2 主类

package com.atguigu.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class ProducerClientAsync {
    
    
    public static void main(String[] args) {
    
    
        // 0 配置对象
        Properties properties = new Properties();

        //  --指定kafka的Broker地址
        properties.setProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092,hadoop103:9092");
        //  -- 1.指定序列化器 序列化器的全限定类名
        properties.setProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.setProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());


        //.setProperty(ProducerConfig.LINGER_MS_CONFIG,"0");
        // -- 2.设置分区器
        properties.setProperty(ProducerConfig.PARTITIONER_CLASS_CONFIG,MyPartitioner.class.getName());
        // -- 3.获取客户端连接对象
        KafkaProducer<String,String> kafkaProducer= new KafkaProducer<String,String>(properties);
        //  key是主题  v是发送内容  这里注意一下
        // -- 4.发送数据
        String[] str= {
    
    "atguigu","111","atguigu","shangguigu","222"};
        for (int i =0; i < str.length; i++) {
    
    
            System.out.println(str[i]);
            try {
    
    
                kafkaProducer.send(new ProducerRecord<>("first", str[i]), new Callback() {
    
    
                    @Override
                    public void onCompletion(RecordMetadata metadata, Exception exception) {
    
    
                        if (exception == null){
    
    

                            System.out.println("主题：" + metadata.topic() + "->"  + "分区：" + metadata.partition());
                        }else {
    
    
                            // 出现异常打印
                            exception.printStackTrace();
                        }
                    }
                }).get();
            } catch (InterruptedException e) {
    
    
                throw new RuntimeException(e);
            } catch (ExecutionException e) {
    
    
                throw new RuntimeException(e);
            }
        }

        kafkaProducer.close();
    }
}

在这里插入图片描述

3.面试细节

1.如何提高生产者的吞吐量

批次大小调到16
将等待时间改成50-100ms 默认是0
压缩数据量，这样每次发送的数据就多了
加大缓冲区大小，进来的数据变多，发送也能提上去

2.生产者如何保证数据可靠性的

主要通过ack机制

1.什么是ACK机制？

根据ack值来决定Kafka集群服务端的存储应答

ack=0 最低生产者只管发送，不用接收
ack=1 中等生产者发送完需要等待Leader保存后回应，
ack=-1 最高生产者发送完需要等待所有副本保存后回应

2.分析ACK机制

性能与安全是成反比的
所以，-1虽然最安全，但是效率最低

3.如果将ACK调到-1会出现什么问题？

有可能出现数据重复发送与接收
比如，在同步的瞬间，Leader死掉，但是其他副本已经落盘，这时候，就是问题了。
因为Leader死掉了，所以会直接更换Leader，选出一个副本作为Leader，注意，这时显示没有收到内容，所以，send重新发送，这时候,每个副本上，收到的就是2份该数据了。

4.应用场景

acks=0 几乎不用
acks=1 传输普通日志，允许丢失
acks=-1 传输高可靠性数据，一般与钱有关

5.ACK=-1一定可靠么？

不一定
如果分区副本数设置为1 ，或者ISR里应答的最小副本数设置为1（默认也是1），这时候，ack=1效果相同了。
也就是说，应答一个，就能走,就没意义了
所以需要完全可靠就需要配置一下
ACK=-1 & 分区副本大于等于2 & ISR应答最小副本数量大于等于2

3. 数据去重

1.概念

至少一次：一次或者多次完全可靠
在这里插入图片描述
最多一次：直接不管回复只管发送 ack=0

至少：保证数据不丢失，但是无法保证数据不重复
最多：无法保证数据不丢失

1.如何解决数据的重复发送与接收的问题,同时保证数据的不丢失

注意，这里解决的是sender和服务端的重复发送与接收，而不是生产者本身发送多个重复消息的问题，这个要搞清楚。
一般重复问题，都是通过标识来判别，从而去重的
Kafka 0.11 引入幂等性和事务
精确一次：幂等性 +至少一次（ack=-1 & 分区副本>=2 & ISR最小副本>=2）

4.幂等性

1.概念

啥是幂等性，标识一个消息的唯一标识
<pid,partition,Seqnumber>
Pid 是会话ID，每次重新生成会话，就会重新生成PID
partition是分区标识消息是哪个分区的
Seqnumber是单调递增的标识，注意，这是每个分区独享的
这三个在一起，才是唯一标识。

2.如何使用幂等性

开启参数enable.idempotence 默认为true，false关闭。
开启开关就行