kafka生产者

消息发送流程

kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，设计到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecourdAccumulator，Sender线程不断从RecordAccumulator中拉去消息发送到kafka broker。

相关参数：
batch.size：只有数据累积到batch.size之后，sender才会发送数据。
linger.ms：如果数据迟迟未达到batch.size，sender等待linger.ms时间之后就会发送数据。

异步发送API

1）导入依赖

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

2）编写代码
需要用到的类：
KafkaProducer：需要创建一个生产者对象，用来发送数据
ProducerConfig：获取所需的一系列配置参数
ProducerRecord：每条数据都要封装成一个ProducerRecord对象
1>不带回调函数的API

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;

/**
 * @author gm
 * @create 2020-12-10 19:40
 * 1. 创建生产者配置对象
 * 2. 添加配置信息
 * 3. 创建生产者对象
 * 4. 调用send发送消息
 * 5. 关闭资源
 */
public class CustomProducer {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息
        properties.put("bootstrap.servers","hadoop102:9092");
        
        // 批次大小 默认16K
        properties.put("batch.size", 16384);

        // 等待时间
        properties.put("linger.ms", 1);

        // RecordAccumulator缓冲区大小 默认32M
        properties.put("buffer.memory", 33554432);

        // key,value序列化
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 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));

        }

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

同步发送API

同步发送的意思是一条消息发送之后，会阻塞当前线程，直至返回ack。
由于send方法返回的是一个Future对象，根据Future对象的特点，我们也可以实现同步发送的效果，只需要在调用Future对象的get方法即可。

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;

/**
 * @author gm
 * @create 2020-12-10 19:40
 * 1. 创建生产者配置对象
 * 2. 添加配置信息
 * 3. 创建生产者对象
 * 4. 调用send发送消息
 * 5. 关闭资源
 */
public class CustomProducer {
    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息
        properties.put("bootstrap.servers","hadoop102:9092");
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        // key,value序列化(必须)
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 设置ack
        properties.put("acks", "all");

        // 重试次数
        properties.put("retries", 3);

        // 批次大小 默认16K
        properties.put("batch.size", 16384);

        // 等待时间
        properties.put("linger.ms", 1);

        // RecordAccumulator缓冲区大小 默认32M
        properties.put("buffer.memory", 33554432);


        // 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();
    }
}

分区策略

1）分区的原因
①方便在集群中扩展，每个Partition可以通过调整以适应它所在的机器，而一个topic又可以有多个Partition组成，因此整个集群就可以适应任意大小的数据了；
②可以提高兵法，因为可以以Partition为单位进行读写了。

2）分区的原则：我们需要将producer发送的数据封装成一个ProducerRecord对象。

①指明partition的情况下，直接将指明的值直接作为partition值；
②没有指明partition值但是有key的情况下，将key的hash值与topic的partition数进行取余得到partition值；
③既没有partition值有没有key值得情况下，kafka采用Sticky Partition（粘性分区器），会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch值已经满了或者已经完成，kafka再随机一个分区进行使用。

// 4. 调用send方法发送消息
        for (int i = 0; i < 10; i++) {
        // 指定发送到1号分区
            kafkaProducer.send(new ProducerRecord<>("atguigu",1,"","atguigu" + i));
            // 线程睡眠,避免全部发送到一个分区
            Thread.sleep(2);
        }

        // 4. 调用send方法发送消息
        for (int i = 0; i < 10; i++) {
            // 根据key的hash值分配分区
            kafkaProducer.send(new ProducerRecord<>("atguigu","abc","atguigu" + i));
            // 提供线程睡眠,避免发送到同一个分区
            Thread.sleep(2);
        }

分区器

1）默认的分区器：DefaultPartitioner
2）自定义的分区器：

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

import java.util.Map;

/**
 * @author gm
 * @create 2020-12-11 10:43
 * 1. 实现接口Partitioner
 * 2. 实现3个方法:partition,close,configure
 * 3. 编写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() {

    }

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

    }
}

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

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

/**
 * @author gm
 * @create 2021-01-18 9:54
 */
public class CustomProducerCallBack {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建配置对象
        Properties properties = new Properties();
        // 2. 对象添加参数
        // 2.1 添加链接
        properties.put("bootstrap.servers", "hadoop102:9092");
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");

        // 批次大小 默认16K
        properties.put("batch.size", 16384);

        // 等待时间
        properties.put("linger.ms", 2);

        // RecordAccumulator缓冲区大小 默认32M
        properties.put("buffer.memory", 33554432);

        // 必须写 key和value的序列化
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 添加自定义分区器---------------------------------------------------------+
       properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"分区器类的全类名");//|
       //-------------------------------------------------------------------------+

        // 3. 创建kafka生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        // 4. 调用send方法发送消息
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord<String,String>("first", "atguigu" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    // 判断发送成功与否
                    if (exception != null){
                        exception.printStackTrace();
                    }else {
                        System.out.println(metadata.toString());
                    }
                }
            });
        }
        // 5. 关闭连接
        kafkaProducer.close();
    }
}

数据可靠性保证

1）生产者发送数据到topic partition的可靠性保证
为保证producer发送的数据，能可靠的发送到指定的topic，topic的每个partition收到producer发送的数据后，都需要向producer发送ack（acknowledgement确认收到），如果producer收到ack，就会进行下一轮的发送，否则重新发送数据。

2）Topic partition存储数据的可靠性保证
①副本数据同步策略

方案	优点	缺点
半数以上完成同步，就发送ack	延迟低	选举新leader时，要容忍n台节点的故障，需要2n+1个副本
全部同步完成，才发送ack	选举新leader时，要容忍n台节点的故障，需要n+1个副本	延迟高

kafka选择了第二种方案，原因是：
Ⅰ、同样是为了容忍n台节点的故障，第一种方案需要2n+1个副本，而第二种方案只需要n+1个副本，而kafka的每个分区都有大量的数据，第一种方案会造成大量的数据冗余。
Ⅱ、虽然第二种方案的网络延迟会比较高，但网络延迟对kafka的影响较小。

②ISR
采用第二种方案之后，设想一下情景：leader收到数据，说有follower都开始同步数据，但有一个follower，因为某种故障，迟迟不能与leader进行同步，那么leader就要一直等下去，直到它完成同步，才能发送ack。要解决这个问题，引入了ISR（in-sync replica set）;
Leader维护了一个动态的in-sync replica set (ISR),意为和leader保持同步的follower集合。当ISR中的follower完成数据的同步之后，leader就会给producer发送给ack。如果follower长时间未向leader同步数据，则该follower将被剔除ISR，该时间阈值由replica.lag.time.max.ms参数设定。Leader发生故障之后，就会从ISR中选举新的leader。

③ack应答级别
对于某些不太重要的数据，对于数据的可靠性要求不是很高，能够容忍数据的少量对视，所以就没有必要等ISR中的follower全部接收成功。
所以Kafka为用户提供了三种可靠性级别，用户根据对可靠性和延迟的要求进行权衡，选择以下配置。
acks参数设置
0：这一操作提供了一个最低的延迟，partition的leader接收到消息还没有写入磁盘就已经返回ack，当leader故障时 有可能丢失数据；
1：partition的leader落盘成功后返回ack，如果在follower同步之前leader故障，那么会丢失数据；

-1（all）：partition的leader和follower全部落盘成功后才会返回ack。但是如果在follower同步完成之后，broker发送ack之前，leader发生故障，那么会造成数据重复。

3）leader和follower故障处理细节

LEO：指的是每个副本最大的offset
HW：指的是消费者能看见的最大的offset，ISR队列中的最小LEO。
①follower故障
  follower发生故障之后会被临时剔除ISR，待该follower恢复后，follower会读取本地磁盘记录的上次的HW，并将log文件高于HW的部分接去掉，从HW开始向leader进行同步。等待该follower的LEO大于等于该Partition的HW，即follower追上leader之后，就可以重新 加入ISR了。
②leader故障
  leader发生故障之后，会从ISR中选出一个新的leader，之后，为保证多个副本之间的数据一致性，琦玉的follower会先将各自的log文件高于HW的部分截掉，然后从新的leader同步数据。
注意： 这只能保证副本之间的一致性，不能保证数据不丢失或者不重复。

Excactly Once 语义

  将服务器的ack级别设置为-1，可以保证producer到Server之间不会丢失数据，即At Least Once语义。相对的，酱服务器ACK级别设置为0，可以保证生产者每条消息只会被发送一次，即At Most Once语义。
  At Least Once可以保证数据不丢失，但是不能保证数据不重复；相对的，At Most Once可以保证数据不重复，但是不能保证数据不丢失。但是，对于一些非常重要的信息，比如说交易数据，下游数据消费者要求数据既不重复也不丢失，即Exactly Once语义。在0.11版本以前的Kafka，对此是无能为力的，只能保证数据不丢失，再在下游消费者对数据做全局去重。对于多个下游应用的情况，每个都需要单独做全局去重，这就对性能造成了很大影响。
  0.11版本的Kafka，引入了一项重大特性：幂等性。所谓的幂等性就是指Producer不论向Server发送多少次重复数据，Server端都只会持久化一条。幂等性结合At Least Once语义，就构成了Kafka的Exactly Once语义。即：At Least Once + 幂等性 = Exactly Once
  要启用幂等性，只需要将Producer的参数中enable.idempotence设置为true即可。Kafka的幂等性实现其实就是将原来下游需要做的去重放在了数据上游。开启幂等性的Producer在初始化的时候会被分配一个PID，发往同一Partition的消息会附带Sequence Number。而Broker端会对<PID, Partition, SeqNumber>做缓存，当具有相同主键的消息提交时，Broker只会持久化一条。
  但是PID重启就会变化，同时不同的Partition也具有不同主键，所以幂等性无法保证跨分区跨会话的Exactly Once。

Producer事务

  0.11版本的Kafka同时引入了事务的特性，为了实现跨分区跨会话的事务，需要引入一个全局唯一的Transaction ID，并将Producer获得的PID和Transaction ID绑定。这样当Producer重启后就可以通过正在进行的Transaction ID获得原来的PID。
  为了管理Transaction，Kafka引入了一个新的组件Transaction Coordinator。Producer就是通过和Transaction Coordinator交互获得Transaction ID对应的任务状态。Transaction Coordinator还负责将事务所有写入Kafka的一个内部Topic，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以得到恢复，从而继续进行。