（1）缓冲\消峰：这时候的消息队列相当于有一个缓冲区，将请求先写入消息队列，消息队列内的请求遵循先进先出原则，从而不会因为高并发而导致系统崩溃，毕竟服务器的资源有限（场景：以前双十一，没有消息队列，在高并发时可能会系统崩溃，现在有了消息队列，会直接返回，你下单成功或者其他，然后服务器慢慢从消息队列中处理这些任务）

解耦：耦合性就是两个模块之间的依赖性，越高呢，维护成本越高，比如说就Producer和Consumer直接连接时，一个发生变化，另一个要做出比较大的调整，有了消息对接在中间，就能降低之间耦合性，也就是解耦

异步通信：

2.2消息队列的两种模式

二、kafka的基础架构

1.kafka基础架构的简介

（1）生产者：向kafka集群发送数据

（2）broker：启动的kafka集群

（3）消费者：从kafka集群消费数据

（4）zookeeper：帮助kafka实现分布式

2.kafka的详细基础架构

（1）Reducer：生产者（可能是flume、MySQL等），其实就是向kafka发送数据的

（2）Consumer：消费者（可能是MySQL、Hadoop、spark、flink），就是向kafka取数据的

（3）Consumer Group：就是消费者组，由一个或者多个consumer组成，在kafka中，消费者都是有组的，即使是在consumer创建时没有没有设置组，但是kafka会默认一个有一个组，是组直接从kafka中的leader中拉取数据，消费者组内每个消费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费；消费者组之间互不影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者

（4）Broker：kafka代理，即kafka代理服务器，一个集群由多个broker组成，一个broker可以容纳多个topic

（5）topic：主题，可以理解成队列，但是和点对点队列不同的是，不同的消费者组都可以从topic拉去相同的消息

（由此引出推模型和拉模型的区别：

推模型 push ：指定消息推送给谁，如果要给多个对象推送的话，需要推送多份。

拉模型 pull ：消息发布出去，放到某个地方，感兴趣的自己来拉。只需要推一份数据。）

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

（7）replica：每个分区都有一个或者多个副本，有一个leader和多个follower组成

（8）leader：每个分区可能有多个副本，但是这些副本中会选出一个leader，即多个副本中的“主”，producer向kafka发送数据时，和consumer拉取数据时都是和leader做交互，leader会和follower之间会同步数据，

（9）follower：多个副本中的的“从”，有了副本保证数据的安全性，如果有leader挂掉，从follower选取新的leader，所以follower肯定不能和leader在同一个服务器上

三、安装部署

1.kafka的分布式

kafka是依靠zookeeper来实现分布式的，所以再启动前需要先启动zookeeper，如下图

2.集群部署

官方下载地址：Apache Kafka

（1）安装和Hadoop等都一样，解压即可

[atguigu@hadoop102 software]$ tar -zxvf kafka_2.12-3.0.0.tgz -C /opt/module/

（2）然后修改配置文件

[atguigu@hadoop102 config]$ vim kafka/config/server.properties

红色部分修改的位置：

#broker的全局唯一编号，不能重复，只能是数字。

broker.id=0

#处理网络请求的线程数量

num.network.threads=3

#用来处理磁盘IO的线程数量

num.io.threads=8

#发送套接字的缓冲区大小

socket.send.buffer.bytes=102400

#接收套接字的缓冲区大小

socket.receive.buffer.bytes=102400

#请求套接字的缓冲区大小

socket.request.max.bytes=104857600

#kafka运行日志(数据)存放的路径，路径不需要提前创建，kafka自动帮你创建，可以配置多个磁盘路径，路径与路径之间可以用"，"分隔

log.dirs=/opt/module/kafka/datas

#topic在当前broker上的分区个数

num.partitions=1

#用来恢复和清理data下数据的线程数量

num.recovery.threads.per.data.dir=1

# 每个topic创建时的副本数，默认时1个副本

offsets.topic.replication.factor=1

#segment文件保留的最长时间，超时将被删除

log.retention.hours=168

#每个segment文件的大小，默认最大1G

log.segment.bytes=1073741824

# 检查过期数据的时间，默认5分钟检查一次是否数据过期

log.retention.check.interval.ms=300000

#配置连接Zookeeper集群地址（在zk根目录下创建/kafka，方便管理）

zookeeper.connect=hadoop102:2181,hadoop103:2181,hadoop104:2181/kafka

编辑好之后分发，然后将broker.id修改一下

（3）配置环境变量

[atguigu@hadoop102 module]$ sudo vim /etc/profile.d/my_env.sh

增加内如如下：

#KAFKA_HOME

export KAFKA_HOME=/opt/module/kafka

export PATH=$PATH:$KAFKA_HOME/bin

配置完成后分发

为每台节点刷新环境变量：

[atguigu@hadoop102 module]$ source /etc/profile

（4）启动集群：先启动zookeeper集群，在启动kafka

（5）集群启停脚本

在/home/atguigu/bin目录下创建文件kf.sh脚本文件

[atguigu@hadoop102 bin]$ vim kf.sh

#! /bin/bashcase $1 in"start"){    for i in hadoop102 hadoop103 hadoop104    do        echo " --------启动 $i Kafka-------"        ssh $i "/opt/module/kafka/bin/kafka-server-start.sh -daemon /opt/module/kafka/config/server.properties"    done};;"stop"){    for i in hadoop102 hadoop103 hadoop104    do        echo " --------停止 $i Kafka-------"        ssh $i "/opt/module/kafka/bin/kafka-server-stop.sh "    done};;esac

四、命令操作

1.主题命令操作

查看操作主题命令参数

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

参数	描述
--bootstrap-server	连接的Kafka Broker主机名称和端口号。
--topic	操作的topic名称。
--create	创建主题。
--delete	删除主题。
--alter	修改主题。
--list	查看所有主题。
--describe	查看主题详细描述。
--partitions	设置分区数。
--replication-factor	设置分区副本。
--config	更新系统默认的配置。

（1）查看服务器中的topic

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

（2）创建first topic

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

选项说明：

--topic 定义topic名

--replication-factor 定义副本数

--partitions 定义分区数

（3）查看first主题详情

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

（4）修改分区数（分区数只能增加，不能减少）

[atguigu@hadoop102 kafka]$ kafka-topics.sh --bootstrap-server hadoop102:9092--alter --first topic --partition 5

（5）删除topic

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

2.生产者命令操作

查看操作生产者命令

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

参数	描述
--bootstrap-server	连接的Kafka Broker主机名称和端口号。
--topic	操作的topic名称。

发送消息

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

3.消费者命令操作

查看操作消费者命令

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

参数	描述
--bootstrap-server	连接的Kafka Broker主机名称和端口号。
--topic	操作的topic名称。
--from-beginning	从头开始消费。
--group	指定消费者组名称。

消费主题first中的信息(从末尾开始）

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

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

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

命令行中使用的消费者，如果不写消费者组，系统会默认分配一个随机的消费者组。所以每次启动都无法消费之前的数据。添加--from-beginning 可以从头消费。

如果是同一个组的消费者，能实现断点续传的功能。添加--from-beginning 也还是断点续传的。

如果生产消费到一个不存在的主题，系统会自动帮你创建这个主题，分区和副本的个数都为1个。

五、kafka生产者模式

1.生产者消息发送流程

（1）发送原理

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

从图中的流程可以看出，生产者和kafka集群之间还有一个RecordAccumulator队列默认大小是32M，topic分区的话，producer会对应有一个分区器，数据在进入中间队列前，已经被分区器进行了分区，sender()方法在发送数据时，就直接根据分区进行拉取了，拉取时有两个参数，也就是调优参数1.batch.size ：也就是批大小，只有数据累计到batch.size后，sender才会发送数据，默认16k ；2.linger.ms ：也就是等待时间，如果数据未达到batch.size，sender等待linger.ms设置的时间就会发送数据，单位ms，默认值就是0ms，就是有了一条数据直接发（默认为0是因为kafka要接实时数仓，所以设置为0）

（2）生产者重要参数列表

参数名称	描述
bootstrap.servers	生产者连接集群所需的broker地址清单。例如hadoop102:9092,hadoop103:9092,hadoop104:9092，可以设置1个或者多个，中间用逗号隔开。注意这里并非需要所有的broker地址，因为生产者从给定的broker里查找到其他broker信息。
key.serializer和value.serializer	指定发送消息的key和value的序列化类型。一定要写全类名。
buffer.memory	RecordAccumulator缓冲区总大小，默认32m。
batch.size	缓冲区一批数据最大值，默认16k。适当增加该值，可以提高吞吐量，但是如果该值设置太大，会导致数据传输延迟增加。
linger.ms	如果数据迟迟未达到batch.size，sender等待linger.time之后就会发送数据。单位ms，默认值是0ms，表示没有延迟。生产环境建议该值大小为5-100ms之间。
acks	0：生产者发送过来的数据，不需要等数据落盘应答。 1：生产者发送过来的数据，Leader收到数据后应答。 -1（all）：生产者发送过来的数据，Leader+和isr队列里面的所有节点收齐数据后应答。默认值是-1，-1和all是等价的。
max.in.flight.requests.per.connection	允许最多没有返回ack的次数，默认为5，开启幂等性要保证该值是 1-5的数字。
retries	当消息发送出现错误的时候，系统会重发消息。retries表示重试次数。默认是int最大值，2147483647。如果设置了重试，还想保证消息的有序性，需要设置 MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候，其他的消息可能发送成功了。
retry.backoff.ms	两次重试之间的时间间隔，默认是100ms。
enable.idempotence	是否开启幂等性，默认true，开启幂等性。
compression.type	生产者发送的所有数据的压缩方式。默认是none，也就是不压缩。支持压缩类型：none、gzip、snappy、lz4和zstd。

2、异步发送API

生产者代码中有3必须，IP即连接地址、key和value的序列化器

(1)普通异步发送流程

创建maven项目

导入依赖

               org.apache.kafka          kafka-clients          3.0.0

代码编写

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;public class CustomProducer {    public static void main(String[] args) {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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 kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu"));        }        // 5. 关闭资源        kafkaProducer.close();    }}

（2）带回调函数的异步发送

回调函数是实现应答机制的函数

package com.atguigu.kafka.producer;import org.apache.kafka.clients.producer.*;import java.util.Properties;public class CustomProducerCallBack {    public static void main(String[] args) {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        // 序列化器的serialization是一个接口，找到他的实现类        // 我们一般都是使用String        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 kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu" + i),                    new Callback() {                       @Override                       public void onCompletion(RecordMetadata metadata, Exception exception) {                           //(1)消息发送成功  exception == null  接受到服务端ack消息   调用该方法                           //(2)消息发送失败  exception != null  也会调用该方法                           if (exception == null) {   System.out.println(metadata);//使用打印演示                           }else{   exception.printStackTrace();//打印异常信息                           }                       }                    });        }        // 5. 关闭资源        kafkaProducer.close();    }}

3.同步发送API

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 ExecutionException, InterruptedException {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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 kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            // 默认为异步发送            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu" + i));            // 末尾加get为同步发送            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu" + i)).get();        }        // 5. 关闭资源        kafkaProducer.close();    }}

4、生产者分区

（1）kafka分区的好处

因为不同的分区分布在不同的节点上，所以便于合理使用资源，实现负载均衡

并且在不同节点上可以提高并行度

（2）生产者发送消息的分区策略

1>指定发送到哪一个分区直接使用对应的分区号不会走分区器
2> 不写分区号需要走分区器有key 按照key进行hash之后取模分区个数
3>不写分区号需要走分区器没有key 粘性分区缓存机制
一批数据发送到随机的一个分区中，下一批数据发送到另外一个分区
如果是异步发送，数据发送的比较快 10条数据被当作一批每一次都是一个分区
如果是同步发送，发一条数据歇一会，导致每一条数据都是不同批

import org.apache.kafka.clients.producer.*;import java.util.Properties;import java.util.concurrent.ExecutionException;public class CustomProducerCallBackPartition {    public static void main(String[] args) throws ExecutionException, InterruptedException {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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 kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            // (1)指定发送到哪一个分区  直接使用对应的分区号   不会走分区器            // （2） 不写分区号  需要走分区器  有key     按照key进行hash之后取模分区个数            // （3） 不写分区号  需要走分区器  没有key   粘性分区缓存机制            //  一批数据发送到随机的一个分区中，下一批数据发送到另外一个分区            // 如果是异步发送，数据发送的比较快   10条数据被当作一批  每一次都是一个分区            // 如果是同步发送，发一条数据歇一会，导致每一条数据都是不同批            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu" + i),                    new Callback() {                       @Override                       public void onCompletion(RecordMetadata metadata, Exception exception) {                           //(1)消息发送成功  exception == null  接受到服务端ack消息   调用该方法                           //(2)消息发送失败  exception != null  也会调用该方法                           if (exception == null) {   System.out.println(metadata);                           }else{   exception.printStackTrace();                           }                       }                    }).get();        }        //Thread.sleep(20);        // 5. 关闭资源        kafkaProducer.close();    }}

（3）自定义分区器

根据业务需求，可以自定义分区器

假设需求：发送过来的数据中如果包含atguigu，就发往0号分区，不包含atguigu，就发往1号分区

mport org.apache.kafka.clients.producer.Partitioner;import org.apache.kafka.common.Cluster;import java.util.Map;// （1）实现分区器的接口public class CustomPartitioner implements Partitioner {    @Override    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {        //        String log = value.toString();        if (log.contains("atguigu")) {            return 0;        }        return 1;    }    @Override    public void close() {    }    @Override    public void configure(Map configs) {    }}

然后，调用

import org.apache.kafka.clients.producer.*;import java.util.Properties;public class CustomProducerCallBack {    public static void main(String[] args) {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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");        // 添加定义的分区器，需要自定义分区的全类名        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "com.atguigu.kafka.partitioner.CustomPartitioner");        // 3. 创建kafka生产者对象        KafkaProducer kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu" + i),                    new Callback() {                       @Override                       public void onCompletion(RecordMetadata metadata, Exception exception) {                           //(1)消息发送成功  exception == null  接受到服务端ack消息   调用该方法                           //(2)消息发送失败  exception != null  也会调用该方法                           if (exception == null) {   System.out.println(metadata);                           }else{   exception.printStackTrace();                           }                       }                    });        }        // 5. 关闭资源        kafkaProducer.close();    }}

5、生产经验

（1）生产者如和提高吞吐量

提高吞吐量，就是提高批次传输大小，还有就是效率问题

mport org.apache.kafka.clients.producer.KafkaProducer;import org.apache.kafka.clients.producer.ProducerConfig;import org.apache.kafka.clients.producer.ProducerRecord;import java.util.Properties;public class CustomProducerParameters {    public static void main(String[] args) {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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,32768);        //linger.ms 等待时长，默认是0ms,增加等待时长        properties.put(ProducerConfig.LINGER_MS_CONFIG, 5);        //双端队列大小，默认是32M，可以提高到64M        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,67108864);        //调整压缩格式，默认没有压缩        properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");        // 3. 创建kafka生产者对象        KafkaProducer kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu"));        }        // 5. 关闭资源        kafkaProducer.close();    }}

（2）数据可靠性

数据可靠性基于ack应答机制

数据完全可靠的条件：

Acks级别设置为-1，分区副本大于等于2，ISR应答的最小副本数大于等于2

副本介绍

（1）Kafka副本作用：提高数据可靠性。

（2）Kafka默认副本1个，生产环境一般配置为2个，保证数据可靠性；太多副本会增加磁盘存储空间，增加网络上数据传输，降低效率。

（3）Kafka中副本分为：Leader和Follower。Kafka生产者只会把数据发往Leader，然后Follower找Leader进行同步数据。

（4）Kafka分区中的所有副本统称为AR（Assigned Repllicas）。

AR = ISR + OSR

ISR，表示和Leader保持同步的Follower集合。如果Follower长时间未向Leader发送通信请求或同步数据，则该Follower将被踢出ISR。该时间阈值由replica.lag.time.max.ms参数设定，默认30s。Leader发生故障之后，就会从ISR中选举新的Leader。

OSR，表示Follower与Leader副本同步时，延迟过多的副本。

可靠性总结：

acks=0，生产者数据发来，kafka集群内存接受到数据就返回ack

acks=1，生产者数据发来，kafka集群中的leader落盘数据后返回ack

acks=-1，生产者数据发来，kafka集群中的所有副本落盘数据后返回ack

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;public class CustomProducerAcks {    public static void main(String[] args) {        // 1. 创建kafka生产者的配置对象        Properties properties = new Properties();        // 2. 给kafka配置对象添加配置信息：bootstrap.servers        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // key,value序列化（必须）：        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");        //设置应答机制acks,可以去3个值，0、1、all(相当与ask = -1)        properties.put(ProducerConfig.ACKS_CONFIG, "all");        //重试次数retries ,默认是int最大值，2147483647        properties.put(ProducerConfig.RETRIES_CONFIG, 3);        // 3. 创建kafka生产者对象        KafkaProducer kafkaProducer = new KafkaProducer(properties);        // 4. 调用send方法，发送消息        for (int i = 0; i < 10; i++) {            kafkaProducer.send(new ProducerRecord<>("first1", "atguigu"));        }        // 5. 关闭资源        kafkaProducer.close();    }}

副本故障处理

（3）数据去重

1>数据传递语义

2>幂等性

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

3>生产者事务

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，这样即使整个服务重启，由于事务状态得到保存，进行中的事务状态可以得到恢复，从而继续进行。

就是引入一个全局唯一且一致的id，然后将id和pid绑定，从而使producer重启后，kafka集群依然可以通过id获得原来的pid

注意：提前开启幂等性!!!

（4）数据有序

分区内有序，分区间无序

（5）数据乱序

六、kafka broker

1、kafka broker 工作流程

（1）zookeeper存储kafka的信息

启动zookeeper客户端

[atguigu@hadoop102 zookeeper-3.5.7]$ bin/zkCli.sh

通过命令查看kafka相关信息

[zk: localhost:2181(CONNECTED) 2] ls /kafka

（2）kafka broker 的总体工作流程

（1）查看/kafka/brokers/ids路径上的节点。

[zk: localhost:2181(CONNECTED) 2] ls /kafka/brokers/ids[0, 1, 2]

（2）查看/kafka/controller路径上的数据。

[zk: localhost:2181(CONNECTED) 15] get /kafka/controller{"version":1,"brokerid":0,"timestamp":"1637292471777"}

（3）查看/kafka/brokers/topics/first/partitions/0/state路径上的数据。

[zk: localhost:2181(CONNECTED) 16] get /kafka/brokers/topics/first/partitions/0/state{"controller_epoch":24,"leader":0,"version":1,"leader_epoch":18,"isr":[0,1,2]}

（4）停止hadoop104上的kafka。

[atguigu@hadoop104 kafka]$ bin/kafka-server-stop.sh

（5）再次查看/kafka/brokers/ids路径上的节点。

[zk: localhost:2181(CONNECTED) 3] ls /kafka/brokers/ids[0, 1]

（6）再次查看/kafka/controller路径上的数据。

[zk: localhost:2181(CONNECTED) 15] get /kafka/controller{"version":1,"brokerid":0,"timestamp":"1637292471777"}

（7）再次查看/kafka/brokers/topics/first/partitions/0/state路径上的数据。

[zk: localhost:2181(CONNECTED) 16] get /kafka/brokers/topics/first/partitions/0/state{"controller_epoch":24,"leader":0,"version":1,"leader_epoch":18,"isr":[0,1]}

（8）启动hadoop104上的kafka。

[atguigu@hadoop104 kafka]$ bin/kafka-server-start.sh -daemon ./config/server.properties

（9）再次观察（1）、（2）、（3）步骤中的内容。

（3）broker的重要参数

参数名称	描述
replica.lag.time.max.ms	ISR中，如果Follower长时间未向Leader发送通信请求或同步数据，则该Follower将被踢出ISR。该时间阈值，默认30s。
auto.leader.rebalance.enable	默认是true。自动Leader Partition 平衡。
leader.imbalance.per.broker.percentage	默认是10%。每个broker允许的不平衡的leader的比率。如果每个broker超过了这个值，控制器会触发leader的平衡。
leader.imbalance.check.interval.seconds	默认值300秒。检查leader负载是否平衡的间隔时间。
log.segment.bytes	Kafka中log日志是分成一块块存储的，此配置是指log日志划分成块的大小，默认值1G。
log.index.interval.bytes	默认4kb，kafka里面每当写入了4kb大小的日志（.log），然后就往index文件里面记录一个索引。
log.retention.hours	Kafka中数据保存的时间，默认7天。
log.retention.minutes	Kafka中数据保存的时间，分钟级别，默认关闭。
log.retention.ms	Kafka中数据保存的时间，毫秒级别，默认关闭。
log.retention.check.interval.ms	检查数据是否保存超时的间隔，默认是5分钟。
log.retention.bytes	默认等于-1，表示无穷大。超过设置的所有日志总大小，删除最早的segment。
log.cleanup.policy	默认是delete，表示所有数据启用删除策略；如果设置值为compact，表示所有数据启用压缩策略。
num.io.threads	默认是8。负责写磁盘的线程数。整个参数值要占总核数的50%。
num.replica.fetchers	副本拉取线程数，这个参数占总核数的50%的1/3
num.network.threads	默认是3。数据传输线程数，这个参数占总核数的50%的2/3 。
log.flush.interval.messages	强制页缓存刷写到磁盘的条数，默认是long的最大值，9223372036854775807。一般不建议修改，交给系统自己管理。
log.flush.interval.ms	每隔多久，刷数据到磁盘，默认是null。一般不建议修改，交给系统自己管理。

2、文件存储

（1）文件存储机制

查看这些文件是一些乱码信息，因为生产者上传时是有序列化，只有通过相同的反序列化后可以看到不乱码的，现在在kafka使用工具来查看，如下

[atguigu@hadoop102 first1-0]$ kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.indexDumping ./00000000000000000000.indexoffset: 0 position: 0Mismatches in :/opt/module/kafka/datas/first1-0/./00000000000000000000.index  Index offset: 0, log offset: 9

[atguigu@hadoop102 first1-0]$ kafka-run-class.sh kafka.tools.DumpLogSegments --files ./00000000000000000000.logDumping ./00000000000000000000.logStarting offset: 0baseOffset: 0 lastOffset: 9 count: 10 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 0 CreateTime: 1655729494741 size: 201 magic: 2 compresscodec: none crc: 925683915 isvalid: truebaseOffset: 10 lastOffset: 19 count: 10 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 201 CreateTime: 1655729580577 size: 201 magic: 2 compresscodec: none crc: 2811645235 isvalid: truebaseOffset: 20 lastOffset: 29 count: 10 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 402 CreateTime: 1655732822744 size: 211 magic: 2 compresscodec: none crc: 2145363516 isvalid: truebaseOffset: 30 lastOffset: 31 count: 2 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 613 CreateTime: 1655736655333 size: 89 magic: 2 compresscodec: none crc: 2438774302 isvalid: truebaseOffset: 32 lastOffset: 33 count: 2 baseSequence: -1 lastSequence: -1 producerId: -1 producerEpoch: -1 partitionLeaderEpoch: 0 isTransactional: false isControl: false position: 702 CreateTime: 1655736655349 size: 89 magic: 2 compresscodec: none crc: 3832231783 isvalid: true

说明：日志存储参数配置

参数	描述
log.segment.bytes	Kafka中log日志是分成一块块存储的，此配置是指log日志划分成块的大小，默认值1G。
log.index.interval.bytes	默认4kb，kafka里面每当写入了4kb大小的日志（.log），然后就往index文件里面记录一个索引。稀疏索引。

（2）文件清洗策略

Kafka中默认的日志保存时间为7天，可以通过调整如下参数修改保存时间。

log.retention.hours，最低优先级小时，默认7天。
log.retention.minutes，分钟。
log.retention.ms，最高优先级毫秒。
log.retention.check.interval.ms，负责设置检查周期，默认5分钟。

那么日志一旦超过了设置的时间，怎么处理呢？

Kafka中提供的日志清理策略有delete和compact两种。

1）delete日志删除：将过期数据删除

log.cleanup.policy = delete 所有数据启用删除策略

（1）基于时间：默认打开。以segment中所有记录中的最大时间戳作为该文件时间戳。

（2）基于大小：默认关闭。超过设置的所有日志总大小，删除最早的segment。

log.retention.bytes，默认等于-1，表示无穷大。

思考：如果一个segment中有一部分数据过期，一部分没有过期，怎么处理？

答案是，继续保留

2）compact日志压缩

3、高效读写数据

1）Kafka本身是分布式集群，可以采用分区技术，并行度高

2）读数据采用稀疏索引，可以快速定位要消费的数据

3）顺序写磁盘

Kafka的producer生产数据，要写入到log文件中，写的过程是一直追加到文件末端，为顺序写。官网有数据表明，同样的磁盘，顺序写能到600M/s，而随机写只有100K/s。这与磁盘的机械机构有关，顺序写之所以快，是因为其省去了大量磁头寻址的时间。

4）页缓存 + 零拷贝技术

参数	描述
log.flush.interval.messages	强制页缓存刷写到磁盘的条数，默认是long的最大值，9223372036854775807。一般不建议修改，交给系统自己管理。
log.flush.interval.ms	每隔多久，刷数据到磁盘，默认是null。一般不建议修改，交给系统自己管理。

七、kafka消费者

1、kafka消费者工作流程

什么是消费者组？

所谓消费者组就是一组消费者的集合，为什么要引入组的概念，那是因为，采用一个消费者来消费一个topic，可能会出现数据堆积的问题，上游生产数据的速度超过消费者消费的的速度的话，就会导致数据堆积，所以我们采用一个消费者组来消费topic，众人拾材火焰高，其消费能力也是倍数递增

消费者组是如何消费一个主题数据的？

1>一个topic的一个partition只能被同一个消费组内的一个消费者消费，而不能拆给多个消费者，同组的消费者之间的数据是共享的，从而就是说消费者组内的消费者的数量比topic的分区数量多的话，多的消费者就是不工作的

2>消费者组之间的消费数据是互不干扰的，就是说每个消费者组消费的数据的都是完整的数据

那么一个消费者组内的消费者越多消费能力越强的吗？

> 那么一定不是的，一个消费者只能消费一个topic的一个分区的数据，所以并不是越多越好的

> 如果要加强消费者组的消费能力，除了增加消费者数量，分区数量增加，只有这样并行度上去了才能提高消费力

> 但是为了提高消费组的消费能力，随意增加分区和消费者也是不可行的

一般来说，建议分区数和消费者数量保持一致是最好的，当消费组的消费能力不足时，是可以通过增加分区数量来提高并行度，但是尽量避免这样情况发生，因为，增加一个topic的分区数量这个时候，kafka会进行分区再均衡，在这个期间topic是不可用的，而且一个topic可能有多个消费者组在消费他的数据，增加分区数量会影响到每一个消费者组的，所以再创建topic的时候一定要考虑好分区数

1.确定去协调器coordinator：每当我们创建一个消费者组的时候，kafka会分配一个broker作为该消费组的一个coordinator，coordinator节点的选择：groupid的hash值 % __consumer_offsets的分区数量，这个是系统给的

注册消费者，并选出leader consumer，当有了coordinate，消费者将会开始往该coordinate上进行注册，第一个注册的消费者将成为消费组的leader，后续的作为follower

选出leader后，leader将会从coordinate获取分区信息，并会根据分区策略给每个consumer分配分区形成一个消费策略，并将消费策略汇报给coordinate

coordinate将每一个consumer对应的分区下发给每一个consumer，对所有的follower而言，只知道自己的分区，不知道别人的，但是leader知道所有人的分区

当发生分区再均衡的时候，leader将会重复分配过程

消费者组：

消费者重要参数

参数名称	描述
bootstrap.servers	向Kafka集群建立初始连接用到的host/port列表。
key.deserializer和value.deserializer	指定接收消息的key和value的反序列化类型。一定要写全类名。
group.id	标记消费者所属的消费者组。
enable.auto.commit	默认值为true，消费者会自动周期性地向服务器提交偏移量。
auto.commit.interval.ms	如果设置了 enable.auto.commit 的值为true，则该值定义了消费者偏移量向Kafka提交的频率，默认5s。
auto.offset.reset	当Kafka中没有初始偏移量或当前偏移量在服务器中不存在（如，数据被删除了），该如何处理？ earliest：自动重置偏移量到最早的偏移量。 latest：默认，自动重置偏移量为最新的偏移量。 none：如果消费组原来的（previous）偏移量不存在，则向消费者抛异常。 anything：向消费者抛异常。
offsets.topic.num.partitions	__consumer_offsets的分区数，默认是50个分区。
heartbeat.interval.ms	Kafka消费者和coordinator之间的心跳时间，默认3s。该条目的值必须小于 session.timeout.ms ，也不应该高于 session.timeout.ms 的1/3。
session.timeout.ms	Kafka消费者和coordinator之间连接超时时间，默认45s。超过该值，该消费者被移除，消费者组执行再平衡。
max.poll.interval.ms	消费者处理消息的最大时长，默认是5分钟。超过该值，该消费者被移除，消费者组执行再平衡。
fetch.min.bytes	默认1个字节。消费者获取服务器端一批消息最小的字节数。
fetch.max.wait.ms	默认500ms。如果没有从服务器端获取到一批数据的最小字节数。该时间到，仍然会返回数据。
fetch.max.bytes	默认Default: 52428800（50 m）。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值（50m）仍然可以拉取回来这批数据，因此，这不是一个绝对最大值。一批次的大小受message.max.bytes （broker config）or max.message.bytes （topic config）影响。
max.poll.records	一次poll拉取数据返回消息的最大条数，默认是500条。

2、消费者API

import org.apache.kafka.clients.consumer.ConsumerConfig;import org.apache.kafka.clients.consumer.ConsumerRecord;import org.apache.kafka.clients.consumer.ConsumerRecords;import org.apache.kafka.clients.consumer.KafkaConsumer;import org.apache.kafka.common.serialization.StringDeserializer;import java.time.Duration;import java.util.ArrayList;import java.util.Properties;public class CustomConsumer {    public static void main(String[] args) {        // 1. 创建消费者配置对象        Properties properties = new Properties();        // 2. 给消费者配置对象添加参数（不同于生产者，消费者有 4个必要的配置参数）        //  broker的ip地址        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");        // 配置  反序列化        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());        //配置消费者组（组名必须）        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "group1");        // 3. 创建消费者对象        KafkaConsumer consumer = new KafkaConsumer(properties);        // 注册消费主题        ArrayList topics = new ArrayList<>();        topics.add("first");        consumer.subscribe(topics);        // 4.调用方法消费数据        // 如果kafka集群没有新数据会造成空转        // 填写参数为时间，如果没有拉取数据，线程睡眠一会        while (true) {            // 设置1s中消费的一批数据            // Duration.ofSeconds(1)不会导致空转，拉取不到的时候睡眠1s            ConsumerRecords consumerRecords = consumer.poll(Duration.ofSeconds(1));            // 打印消费数据            for (ConsumerRecord consumerRecord : consumerRecords) {                System.out.println(consumerRecord.topic() + "-" + consumerRecord.partition() + "-" + consumerRecord.offset());            }        }        //5.关闭资源//        consumer.close();不使用的原因是，已关闭进程，就不会再消费数据了，进程停止就以为着JVM为断电了，不再工作    }}

来源地址：https://blog.csdn.net/sgs_sgs_sgs/article/details/125398449

免责声明：

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的，并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据，供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

kafka java 分布式 1024程序员节

阅读原文内容投诉