一：生产者
1.1 引入pom坐标
这个版本最好还是与自己的版本一致，否则可能会出现一些不必要的错误
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>2.4.1</version>
</dependency>
1.2 生产者的基本实现
package com.qf.kafka.spring.boot.demo;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.protocol.types.Field;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
public class MyEasyProducer {
private final static String TOPIC_NAME = "my-replicated-topic";
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1.设置参数
Properties props = new Properties();
props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.156.131:9092,192.168.156.131:9093,192.168.156.131:9094");
//把发送的key从字符串序列化为字节数组
props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//把发送消息value从字符串序列化为字节数组
props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//2.创建生产消息的客户端，传入参数
//设置producer
Producer<String,String> producer = new KafkaProducer<String, String>(props);
//3.创建消息
// key:作用是决定了往哪个分区上发，value:具体要发送的消息内容
ProducerRecord<String ,String> producerRecord = new ProducerRecord<>(TOPIC_NAME,"aykey" ," hell.okafka");
//4.发送消息,得到消息发送的元数据并输出
RecordMetadata metadata = producer.send(producerRecord).get();
System.out.println("同步方式发送消息结果:" +"topic-" + metadata.topic() + "| partition-"
+metadata.partition()+ "| offsetl" +metadata.offset());
}
}
运行结果：
- 如果将producer的key更换后，partition也是会发生变化的，最后往那个partition里面发，是根据key去计算得到的。如下所示：
1.3 发送消息到指定分区上
//3.创建消息
// key:作用是决定了往哪个分区上发，value:具体要发送的消息内容
//0：这个参数的位置就是指定分区去发送消息
ProducerRecord<String ,String> producerRecord = new ProducerRecord<>(TOPIC_NAME,0,"mykeyValue" ," hell okKafka");
1.4 未指定分区
未指定分区，则会通过业务key的hash运算，算出消息往哪个分区上发
未指定发送分区，具体发送的分区计算公式: hash(key)%partitionNum
源码：
之前已经测试过了
//3.创建消息
// key:作用是决定了往哪个分区上发，value:具体要发送的消息内容
ProducerRecord<String ,String> producerRecord = new ProducerRecord<>(TOPIC_NAME,"mykeyValue" ," hell okKafka");
1.5 生产者同步发送消息
一条消息，发送到消费者，没有返回任何的内容（ACK），对于生产者来说，这条消息是还没有完成发送，这时候就会阻塞，等待一段时间，具体的时间是想要看配置里面的内容。默认配置是3秒，阻塞到3s的时间，如果还没有收到消息,会进行重试。重试的次数3次。三次过后就会报错，异常
//同步发送
try {
//等待消息发送成功的同步阻塞方法
RecordMetadata metadata = producer.send(producerRecord).get();
//======阻塞=======
System.out.println("同步方式发送消息结果:" +"topic-" + metadata.topic() + "| partition-"
+metadata.partition()+ "| offset - " +metadata.offset());
}catch (InterruptedException e){
e.printStackTrace();
//下面的是伪代码
//1.记录日志预警系统+1
//2.设置时间间隔1s同步的方式再次发送，如果还不行日志预警人工介入
Thread.sleep(1000) ;
try {
//等待消息发送成功的同步阻塞方法
RecordMetadata metadata = producer.send(producerRecord).get();
}catch (Exception e1){
//人工介入
}
}catch (ExecutionException e){
e.printStackTrace();
}
为了防止消息丢失，所以同步用的多一点
1.6 生产者异步发送消息
与同步发送的区别是不需要消费者返回信息（ACK）；
异步发送，生产者发送完消息后就可以执行之后的业务，broker在收到消息后异步调用生产者提供的callback回调方法。
//异步回调方式发送消息
producer.send(producerRecord, new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e != null){
System.out.println("发送消息失败："+e.getStackTrace());
}
if (recordMetadata != null){
System.out.println("同步方式发送消息结果:" +"topic-" + recordMetadata.topic() + "| partition-"
+recordMetadata.partition()+ "| offset - " +recordMetadata.offset());
}
}
});
1.7 生产者端ack的配置
在同步发送的前提下，生产者在获得集群返回的ack之前会一直阻塞。那么集群什么时候返回ack呢?此时ack有3个配置。
对于ack来说，会有三个参数配置:
- ack = 0；消息发过去，kafka不需要broker收到消息，就立即返回ack给生产者,
最容易丢消息的，效率最高 - ack=1（默认）；消息发过去，多副本之间的leader已经收到消息，并把消息写入到本地的log中，才会返回ack给生产者；
性能和安全性是最均衡的 - ack=-1/all；消息发过去，想要等待里面的默认配置min.insync.replicas=2(默认为1，推荐配置大于等于2)这个参数配置的副本个数都成功写入日志，只要有一个备份存活就不会丢失数据。这是最强的数据保证。一般除非是金融级别,或跟钱打交道的场景才会使用这种配置。这种策略会保证，
最安全，性能最差，此时就需要leader和一个follower同步完后，才会返回ack给生产者(此时集群中有2个broker已完成数据的接收)。
java代码
props.put(ProducerConfig.ACKS_CONFIG,"1");
1.8 重试间隔设置
如果没有收到ack，就开启重试
发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造成消息重复发送，比如网络抖动，所以需要在接收者那边做好消息接收的幂等性处理
//重试次数是3次
props. put(ProducerConfig.RETRIES_CONFIG,3);
//重试间隔设置300ms
props.put(ProducerConfig.RETY_BACKOFF_MS_CONFIG,300);
1.9 发送消息缓冲区机制
//设置发送消息的本地缓冲区，如果设置了该缓冲区，消息会先发送到本地缓冲区，可以提高消息发送性能，默认值是33554432，即32MB
kafka默认会创建一个消息缓冲区，用来存放要发送的消息，缓冲区是32m
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG，33554432);
kafka本地线程会从缓冲区取数据,批量发送到broker，设置批量发送消息的大小，默认值是16384，即16kb，就是说一个batch满了16kb就发送出去
kafka本地线程会去缓冲区中一次拉16k的数据，发送到broker
props.put(ProducerConfig.BATCH_SIZE_CONFIG，16384);
默认值是6，意思就是消息必须立即被发送，但这样会影响性能
一般设置10毫秒左右，就是说这个消息发送完后会进入本地的一个batch，如果10毫秒内，这个batch满了16kb就会随batch一起被发送出去
如果10毫秒内，batch没满，那么也必须把消息发送出去，不能让消息的发送延迟时间太长
如果线程拉不到16k的数据，间隔10ms也会将已拉到的数据发到broker
props.put(ProducerConfig.LINGER_MS_CONFIG，10);
二：消费者
2.1 消费者的基本实现
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.Arrays;
import java.util.Properties;
public class MyEasyConsumer {
private final static String TOPIC_NAME = "my-replicated-topic";
private final static String CONSUMER_GROUP_NAME = "testGroup";
public static void main(String[] args) {
//1.设置参数
Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.156.131:9092,192.168.156.131:9093,192.168.156.131:9094");
//消费分组名
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<String, String> consumer = new KafkaConsumer<String, String>(props);
//消费者订阅主题列表
consumer.subscribe(Arrays.asList(TOPIC_NAME));
while (true){
/*
poll() API是拉取消息的长轮询
*/
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
// System.out.println(records.partitions());
for (ConsumerRecord<String, String> record : records) {
System.out.printf ( "收到消息: partition = %d,offset = %d，key = %s, value =%s%n",record.partition(),
record.offset(), record.key(), record.value());
}
}
}
}
2.2 自动和手动提交（offset）
2.2.0 提交的内容
消费者无论是自动提交还是手动提交，都需要把所属的消费组+消费的某个主题+消费的某个分区及消费的偏移量，这样的信息提交到集群的_consumer_offsets主题里面。
2.2.1 自动提交
消息被poll，拉取到后，消费者会自动马上的将offset发送到_consumer_offsets这50个分区里面
//是否自动提交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的下一个位置开始消费消息。之前未被消费的消息就丢失掉了。
2.2.2 手动提交
在消息消费完之后，再将offset进行提交
//需要把自动提交的配置改成false
props.put (ConsumerConfig.ENABLE_AUTo_COMMIT_CONFIG,"false");
手动提交又分成了两种:
- 手动同步提交：在消费完消息后调用同步提交的方法，当集群返回ack前一直阻塞，返回ack后表示提交成功，执行之后的逻辑
- 手动异步提交：在消息消费完后提交，不需要等到集群ack，直接执行之后的逻辑，可以设置一个回调方法，供集群调用
2.2.2.1 手动同步提交
while (true){
/*
poll() API是拉取消息的长轮询
*/
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
// System.out.println(records.partitions());
for (ConsumerRecord<String, String> record : records) {
System.out.printf ( "收到消息: partition = %d,offset = %d，key = %s, value =%s%n",record.partition(),
record.offset(), record.key(), record.value());
}
//所有的消息已消费完
if (records.count() > 0){//有消息
//手动同步提交offset，当前线程会阻塞直到offset提交成功
//一般使用同步提交，因为提交之后一般也没有什么逻辑代码了
consumer.commitAsync();//=======阻塞===提交成功
}
}
2.2.2.2 手动异步提交
while (true){
/*
poll() API是拉取消息的长轮询
*/
ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));
// System.out.println(records.partitions());
for (ConsumerRecord<String, String> record : records) {
System.out.printf ( "收到消息: partition = %d,offset = %d，key = %s, value =%s%n",record.partition(),
record.offset(), record.key(), record.value());
}
//所有的消息已消费完
if (records.count() > 0){//有消息
//手动同步提交offset，当前线程会阻塞直到offset提交成功
//一般使用同步提交，因为提交之后一般也没有什么逻辑代码了
// consumer.commitAsync();//=======阻塞===提交成功
//手动异步提交offset，当前线程提交offset不会阻塞，可以继续处理后面的程序逻辑
consumer.commitAsync(new OffsetCommitCallback() {
@Override
public void onComplete(Map<TopicPartition, OffsetAndMetadata> map, Exception e) {
if (e != null){
System.err.println("Commit failed for " +map);
System.err.println( "Commit failed exception: " + e.getStackTrace());
}
}
});
}
}
2.3 消费者poll消息(长轮询poll消息)
长轮询poll消息：
-
消费者建立了与broker之间的长连接，开始poll消息。
-
默认一次poll500条消息
可以根踞消费速度的快慢来设置，因为如果两次poll的时间如果超出了30s的时间间隔， kafka会认为其消费能力过弱，将其踢出消费组。将分区分配给其他消费者。
默认情况下，消费者一次会poll500条消息。//一次poll最大拉取消息的条数。可以根据消费速度的快慢来设置 props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG,500) ;如果两次poll的时间如果超出了30s的时间间隔，kαfka会认为其消费能力过弱，将其踢出消费组。将分区分配给其他消费者。
//如果两次poll的时间如果超出了30s的时间间隔，kαfka会认为其消费能力过弱，将其踢出消费组。将分区分配给其他消费者。 props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG，30 * 1000); -
如果每隔1s内没有poll到任何消息，则继续去poll消息，循环往复，直到poll到消息。如果超出了1s，则此次长轮询结束。
代码中设置了长轮询的时间是1000毫秒ConsumerRecords<String,String> records m consumer.poll(Duration.ofMillis(1000));
上面步骤的意义为：
- 如果一次poll到500条，就直接执行for循环
- 如果这一次没有poll到500条。且时间在1秒内，那么长轮询继续poll，要么到500条，要么到1s
- 如果多次poll都没达到500条，且1秒时间到了，那么直接执行for循环
- 如果两次poll的间隔超过30s，集群会认为该消费者的消费能力过弱，该消费者被踢出消费组，触发rebalance机制，rebalance机制会造成性能开销。可以通过设置这个参数，让一次poll的消息条数少一点
props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG，30 * 1000);
2.4 消费者的健康状态检查（心跳）
消费者每隔1s向kafka集群发送心跳，集群发现如果有超过10s没有续约的消费者，将被踢出消费组，触发该消费组的rebalance机制，将该分区交给消费组里的其他消费者进行消费。
//consomer给broker发送心跳的间隔时间为1秒
props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG,1000) ;
//kafkα如果超过10秒没有收到消费者的心跳，则会把消费者踢出消费组，进行rebalance，把分区分配给其他消费者。
props.put(ConsumerConfig.SESSION_TIHEOUT_MS_CONFI6，10 * 1080) ;
2.5 指定分区消费
//指定主题的0号分区消费
consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));
2.6 消息回溯消费（从头消费）
//指定主题的0号分区消费
consumer.assign(Arrays.asList (new TopicPartition(TOPIC_NAME,0)));
//从该主题的0号分区的头开始消费（第一个位置）
consumer.seekToBeginning(Arrays.asList(new TopicPartition(TOPIC_NAME，0)));
2.7 指定offset消费
//指定主题的0号分区消费
consumer.assign(Arrays.asList (new TopicPartition(TOPIC_NAME，0)));
// 从该主题的0号分区的10偏移量开始消费
consumer.seek (new TopicPartition (TOPIC_NAME，0)，10);
2.8 从指定时间点消费
根据时间，去所有的partition中确定该时间对应的offset，然后去所有的partition中找到该
offset之后的消息开始消费。
例如：有两个partition
流程：确定号时间以后，先将时间传到一个partition里面，分别得到两个partition里面的对应时间的offset值是在那个位置（值），接下来的消费就按之前从两个partition得到的位置开始消费（所有partition都要去消费）
List<PartitionInfo> topicPartitions = consumer.partitionsFor(TOPIC_NAME);
//从1⼩时前开始消费
long fetchDataTime = new Date().getTime() - 1000 * 60 * 60;
Map<TopicPartition, Long> map = new HashMap<>();
for (PartitionInfo par : topicPartitions) {
map.put(new TopicPartition(TOPIC_NAME, par.partition()), fetchDataTime);
}
Map<TopicPartition, OffsetAndTimestamp> parMap = consumer.offsetsForTimes(map);
for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry : parMap.entrySet()) {
TopicPartition key = entry.getKey();
OffsetAndTimestamp value = entry.getValue();
if (key == null || value == null) continue;
Long offset = value.offset();
System.out.println("partition-" + key.partition() + "|offset-" + offset);
System.out.println();
//根据消费⾥1 List<PartitionInfo> topicPartitions = consumer.partitionsFor(TOPIC_NAME);
//根据消费⾥的timestamp确定offset
if (value != null) {
consumer.assign(Arrays.asList(key));
consumer.seek(key, offset);
}
}
2.9 新消费组的消费偏移量
当消费主题的是一个新的消费组，或者指定offset的消费方式， offset不存在，那么应该如何消费
- latest(默认）:只消费自己启动之后发送到主题的消息
- earliest:第一次从头开始消费，以后按照消费offset记录继续消费，这个需要区别于 consumer.seekToBeginning(每次都从头开始消费)
新消费组中的消费者在启动以后，默认会从当前分区的最后⼀条消息的offset+1开始消费（消费新消息）。
可以通过以下的设置，让新的消费者第⼀次从头开始消费。之后开始消费新消 息（最后消费的位置的偏移量+1）
- Latest: 默认的 ， 消费新消息
- earliest：第⼀次从头开始消费。之后开始消费新消息（最后消费的位置的偏移量+1）
props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
780
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
