Kafka快速入门
Kafka是一个分布式流处理平台，最初由LinkedIn开发，并于2011年开源。它被设计用于构建高性能、可扩展的实时数据流应用程序。以下是对Kafka的详细说明
一、基本概念
- 消息：Kafka以消息的形式传递数据，每个消息包含一个键和一个值。
- 主题（Topic）：消息按照主题进行分类和组织。每个主题可以有多个分区。
- 分区（Partition）：主题被分割成多个分区，每个分区在物理上是一个独立的日志文件。
- 生产者（Producer）：向一个或多个主题发送消息的客户端应用程序。
- 消费者（Consumer）：从一个或多个主题接收消息的客户端应用程序。
- 消费者组（Consumer Group）：一组消费者共同消费一个主题的消息，每个消息只能被一个消费者组中的一个消费者消费。
二、核心特性
- 高吞吐量：Kafka能够处理每秒数十万条消息的读写。
- 可扩展性：Kafka集群可以水平扩展，通过添加更多的机器来增加处理能力。
- 持久性：消息被持久化存储在磁盘上，保证数据不会丢失。
- 容错性：Kafka集群具备副本机制，当某个节点失败时，副本会自动接管。
- 可靠性：Kafka能够保证消息的传递顺序和一次性传递。
三、云服务器Kafka操作流程
1.安装jdk
2.使用docker安装zookeeper
ZooKeeper主要服务于分布式系统，可以用ZooKeeper来做：统一配置管理、统一命名服务、分布式锁、集群管理。 使用分布式系统就无法避免对节点管理的问题(需要实时感知节点的状态、对节点进行统一管理等等)，而由于这些问题处理起来可能相对麻烦和提高了系统的复杂性，ZooKeeper作为一个能够通用解决这些问题的中间件就应运而生了。
docker run --name some-zookeeper -dit -p 2181:2181 zookeeper
将云服务器防火墙中的2181端口放开 稍微等待15s,等待zookeeper彻底启动成功
3.使用docker安装Kafka
将云服务器防火墙中的9092端口放开 安装kafka
docker run -d --name=kafka5 \ -p 9092:9092 \
-e ALLOW_PLAINTEXT_LISTENER=yes \
-e KAFKA_CFG_ZOOKEEPER_CONNECT=这里填自己的ip地址:2181 \
-e KAFKA_BROKER_ID=2 \ -e KAFKA_NODE_ID=2 \
-e KAFKA_ENABLE_KRAFT=false \
-e KAFKA_HEAP_OPTS="-Xmx180m -Xms180m" \
-e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://这里填自己的ip地址:9092 \
-e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 \
-e BITNAMI_DEBUG=true \ bitnami/kafka
参数释义:
- e KAFKA_BROKER_ID=2 在kafka集群中，每个kafka都有一个BROKER_ID来区分自己
- e KAFKA_CFG_ZOOKEEPER_CONNECT=这里填自己的ip地址:2181 kafka 配置zookeeper的连接地址
- e KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://这里填自己的ip地址:9092 把kafka的地址端口注册给zookeeper
- e KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092 配置kafka的监听端口 (是容器内部的端口)
- e KAFKA_HEAP_OPTS=“-Xmx180m -Xms180m” 设置kafka占用的内存
4.进入Kafka容器指定目录
docker exec -it kafka5 /bin/bash
cd opt/bitnami/kafka/bin
5.创建主题
topic是什么概念？topic可以实现消息的分类，不同消费者订阅不同的topic。
执行以下命令创建名为“test”的topic，这个topic只有一个partition，并且备份因子也设置为1
./kafka-topics.sh --create --zookeeper 填自己的ip地址:2181 --replication-factor 1 --partitions 1 --topic test查看当前kafka内有哪些topic
./kafka-topics.sh --list --zookeeper 填自己的ip地址:21816.发送消息
kafka自带了一个producer命令客户端，可以从本地文件中读取内容，或者我们也可以以命令行中直接输入内容，并将这些内容以消息的形式发送到kafka集群中。在默认情况下，每一个行会被当做成一个独立的消息。使用kafka的发送消息的客户端，指定发送到的kafka服务器地址和topic.
./kafka-console-producer.sh --broker-list 填自己的ip地址:9092 --topic test7.消费消息
对于consumer，kafka同样也携带了一个命令行客户端，会将获取到内容在命令中进行输出,默认是消费最新的消息 。使用kafka的消费者消息的客户端，从指定kafka服务器的指定 topic中消费消息.
方式一：从最后一条消息的偏移量+1开始消费
./kafka-console-consumer.sh --bootstrap-server 填自己的ip地址:9092 --topic test方式二：从头开始消费
./kafka-console-consumer.sh --bootstrap-server 填自己的ip地址:9092 --from-beginning --topic test注意点 :
- 消息会被存储
- 消息是顺序存储
- 消息是有偏移量的
- 消费时可以指明偏移量进行消费
四、Kafka中的关键细节
1.消息的顺序存储
消息的发送方会把消息发送到broker中，broker会存储消息，消息是按照发送的顺序进行存储。因此消费者在消费消息时可以指明主题中消息的偏移量。默认情况下，是从最后一个消息的下一个偏移量开始消费。
2.单播消息
单播消息：一个消费组里 只会有一个消费者能消费到某一个topic中的消息。于是可以创建多个消费者，这些消费者在同一个消费组中。
./kafka-console-consumer.sh --bootstrap-server 填自己的ip地址:9092 --consumer-property group.id=testGroup --topic test3.多播消息
多播消息：一条消息被多个消费者消费,让不同的消费者处于不同消费组即可.
./kafka-console-consumer.sh --bootstrap-server 填自己的ip地址:9092 --consumer-property group.id=testGroup1 --topic test
./kafka-console-consumer.sh --bootstrap-server 填自己的ip地址:9092 --consumer-property group.id=testGroup2 --topic test4.查看消费组及其信息
# 查看当前主题下有哪些消费组
./kafka-consumer-groups.sh --bootstrap-server 填自己的ip地址:9092 --list
# 查看消费组中的具体信息：比如当前偏移量、最后一条消息的偏移量、堆积的消息数量
./kafka-consumer-groups.sh --bootstrap-server 填自己的ip地址:9092 --describe --group testGroup- Currennt-offset: 当前消费组的已消费偏移量
- Log-end-offset: 主题对应分区消息的结束偏移量(HW)
- Lag: 当前消费组未消费的消息数5.为一个主题创建多个分区
5.副本的概念
副本是对分区的备份。在集群中，不同的副本会被部署在不同的broker上。下面例子：创建 1个主题， 2 个分区、 3 个副本。
./kafka-topics.sh --create --zookeeper 填自己的ip地址:2181 --replication-factor 3 --partitions 2 --topic my-replicated-topic
通过查看主题信息，其中的关键数据：
- replicas：当前副本存在的broker节点
- leader：副本里的概念
- 每个partition都有一个broker作为leader。
- 消息发送方要把消息发给哪个broker？就看副本的leader是在哪个broker上面。副本里的leader专⻔用来接收消息。
- 接收到消息，其他follower通过poll的方式来同步数据。
- follower：leader处理所有针对这个partition的读写请求，而follower被动复制leader，不提供读写（主要是为了保证多副本数据与消费的一致性），如果leader所在的broker挂掉，那么就会进行新leader的选举，至于怎么选，在之后的controller的概念中介绍。
- isr： 可以同步的broker节点和已同步的broker节点，存放在isr集合中。
6.分区消费组消费组的细节
图中Kafka集群有两个broker，每个broker中有多个partition。一个partition只能被一个消费组里的某一个消费者消费，从而保证消费顺序。Kafka只在partition的范围内保证消息消费的局部顺序性，不能在同一个topic中的多个partition中保证总的消费顺序性。一个消费者可以消费多个partition。
消费组中消费者的数量不能比一个topic中的partition数量多,否则多出来的消费者消费不到消息.
五、Kafka的java客户端-生产者
1.引入依赖
org.apache.kafka
kafka-clients
2.4.1
2.生产者发送消息的基本实现
#### //消息的发送方
public class MyProducer {
private final static String TOPIC_NAME = "my-replicated-topic";
public static void main(String[] args) throws ExecutionException,InterruptedException {
Properties props = new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"填自己的IP地址:9092");
//把发送的key从字符串序列化为字节数组
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//把发送消息value从字符串序列化为字节数组
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
Producer producer = new KafkaProducer(props);
ProducerRecord producerRecord = new ProducerRecord(TOPIC_NAME, "key", "value");
RecordMetadata metadata = producer.send(producerRecord).get();
//=====阻塞=======
System.out.println("同步方式发送消息结果：" + "topic-" +metadata.topic() + "|partition-"+ metadata.partition() + "|offset-" +metadata.offset()); 3.发送消息到指定分区上
ProducerRecord producerRecord = new ProducerRecord(TOPIC_NAME, 0 , "key", "value"); 4.未指定分区则会通过业务key的hash运算,算出消息往哪个分区发送
//未指定发送分区，具体发送的分区计算公式：hash(key)%partitionNum
ProducerRecord producerRecord = new ProducerRecord(TOPIC_NAME, "key", "value"); 5.异步发送消息
生产者发消息,发送完不需要等待broker回复,直接执行下面的业务逻辑.可以提供callback,让broker异步的调用callback,告知生产者消息发送的结果.
//指定发送分区
ProducerRecord producerRecord = new ProducerRecord(TOPIC_NAME, 0 ,"key","value");
//异步回调方式发送消息
producer.send(producerRecord, new Callback() {
public void onCompletion(RecordMetadata metadata, Exception exception) {
if (exception != null) {
System.err.println("发送消息失败：" +
exception.getStackTrace());
}
if (metadata != null) {
System.out.println("异步方式发送消息结果：" + "topic-" +metadata.topic() + "|partition-"+ metadata.partition() + "|offset-" + metadata.offset());
}
}
}); 6.生产者ack参数配置
在同步发消息的场景下,生产者发送消息后,ack会有3种不同的选择:
- （ 1 ）acks=0： 表示producer不需要等待任何broker确认收到消息的回复，就可以继续发送下一条消息。性能最高，但是最容易丢消息。
- （ 2 ）acks=1： 至少要等待leader已经成功将数据写入本地log，但是不需要等待所有follower是否成功写入。就可以继续发送下一条消息。这种情况下，如果follower没有成功备份数据，而此时leader又挂掉，则消息会丢失。
- （ 3 ）acks=-1或all： 需要等待 min.insync.replicas(默认为 1 ，推荐配置大于等于2) 这个参数配置的副本个数都成功写入日志，这种策略会保证只要有一个备份存活就不会丢失数据。这是最强的数据保证。一般除非是金融级别，或跟钱打交道的场景才会使用这种配置。
props.put(ProducerConfig.ACKS_CONFIG, "1");细节:
- 发送会默认会重试 3 次，每次间隔100ms
- 发送的消息会先进入到本地缓冲区（32mb），kakfa会跑一个线程，该线程去缓冲区中取16k的数据，发送到kafka，如果到 10 毫秒数据没取满16k，也会发送一次。
六、Kafka的java客户端-消费者
1.消费者消费信息的基本实现
public class MyConsumer {
private final static String TOPIC_NAME = "my-replicated-topic";
private final static String CONSUMER_GROUP_NAME = "testGroup";
public static void main(String[] args) {
Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"填自己的IP地址:9092");
// 消费分组名
props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
//创建一个消费者的客户端
KafkaConsumer consumer = new KafkaConsumer(props);
// 消费者订阅主题列表
consumer.subscribe(Arrays.asList(TOPIC_NAME));
while (true) {
/*
* poll() API 是拉取消息的⻓轮询
*/
ConsumerRecords records =consumer.poll(Duration.ofMillis( 1000 ));
for (ConsumerRecord record : records) {
System.out.printf("收到消息：partition = %d,offset = %d, key =%s, value = %s%n", record.partition(),record.offset(), record.key(), record.value());
}
}
}
} 
2.自动提交offset
// 是否自动提交offset，默认就是true
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
// 自动提交offset的间隔时间
props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");消费者poll到消息后默认情况下，会自动向broker的_consumer_offsets主题提交当前主题-分区消费的偏移量。
自动提交会丢消息： 因为如果消费者还没消费完poll下来的消息就自动提交了偏移量，那么此 时消费者挂了，于是下一个消费者会从已提交的offset的下一个位置开始消费消息。之前未被消费的消息就丢失掉了。
3.手动提交offset
设置手动提交参数
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");消费完消息后手动提交
手动同步提交
if (records.count() > 0 ) {
// 手动同步提交offset，当前线程会阻塞直到offset提交成功
// 一般使用同步提交，因为提交之后一般也没有什么逻辑代码了
consumer.commitSync();
}手动异步提交
if (records.count() > 0 ) {
// 手动异步提交offset，当前线程提交offset不会阻塞，可以继续处理后面的程序逻辑
consumer.commitAsync(new OffsetCommitCallback() {
@Override
public void onComplete(Mapoffsets, Exception exception) {
if (exception != null) {
System.err.println("Commit failed for " + offsets);
System.err.println("Commit failed exception: " +exception.getStackTrace());
}
}
});
} 
重要细节:
如果你在使用手动提交偏移量的方式进行消费，并且之前已经提交过偏移量了(也就是之前的kafka的服务端的当前offset中已经有了偏移量了) ，那么下一次消费时会从已有的那次偏移量开始拉取数据, 从而造成数据的重复消费。
如果你在使用手动提交偏移量的方式进行消费，并且没有提交偏移量，则会根据消费配置 (默认的消费配置是从最新拉取, 也可以设定成从头拉取)进行拉取数据 这是因为Kafka在进行消费时会根据消费者组、分区、偏移量来判断哪些消息需要被消费，如果没有提交偏移量，那么Kafka就会认为你是一个新的消费者，新的消费者则会依据究竟是从头拉取还是从最新拉取来进行数据的消费.
七、Springboot中使用Kafka
1.引入依赖
org.springframework.kafka
spring-kafka
2.配置文件
server:
port: 8080
spring:
kafka:
bootstrap-servers: 填自己的IP地址: 9092
producer: # 生产者
retries: 3 # 设置大于 0 的值，则客户端会将发送失败的记录重新发送
batch-size: 16384
buffer-memory: 33554432
acks: 1
# 指定消息key和消息体的编解码方式
key-serializer: org.apache.kafka.common.serialization.StringSerializer
value-serializer: org.apache.kafka.common.serialization.StringSerializer
consumer:
group-id: default-group
enable-auto-commit: false
auto-offset-reset: earliest
key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
max-poll-records: 500
listener:
# 当每一条记录被消费者监听器（ListenerConsumer）处理之后提交
# RECORD
# 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后提交
# BATCH
# 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
# TIME
# 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
# COUNT
# TIME | COUNT 有一个条件满足时提交
# COUNT_TIME
# 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
# MANUAL
# 手动调用Acknowledgment.acknowledge()后立即提交，一般使用这种
# MANUAL_IMMEDIATE
ack-mode: MANUAL_IMMEDIATE
redis:
host: 填自己的IP地址3.生产者
发送消息到指定topic
@RestController
public class KafkaController {
private final static String TOPIC_NAME = "my-replicated-topic";
@Autowired
private KafkaTemplate kafkaTemplate;
@RequestMapping("/send")
public void send() {
kafkaTemplate.send(TOPIC_NAME, 0 , "key", "shao nian ge xing");
}
} 4.消费者
设置消费组，消费指定topic
@KafkaListener(topics = "my-replicated-topic",groupId = "MyGroup1")
public void listenGroup(ConsumerRecord record,Acknowledgment ack) {
String value = record.value();
System.out.println(value);
System.out.println(record);
//手动提交offset
ack.acknowledge();
} 设置消费组、多topic、指定分区、指定偏移量消费及设置消费者个数
@KafkaListener(groupId = "testGroup", topicPartitions = {
@TopicPartition(topic = "topic1", partitions = {"0", "1"}),
@TopicPartition(topic = "topic2", partitions = "0",partitionOffsets = @PartitionOffset(partition = "1",initialOffset = "100"))}
,concurrency = "3")//concurrency就是同组下的消费者个数，就是并发消费数，建议小于等于分区总数
public void listenGroup(ConsumerRecord record,Acknowledgment ack) {
String value = record.value();
System.out.println(value);
System.out.println(record);
//手动提交offset
ack.acknowledge();
} 最后安利大家看一个very wonderful 的电视剧,那就是少年歌行,特别好看...(♥∀♥)