源码分析 Kafka 消息发送流程(文末附流程图)

erthrerg

于 2024-04-22 09:48:40 发布

阅读量390

点赞数 3

分类专栏：程序员文章标签： kafka 流程图分布式

本文链接：https://blog.csdn.net/erthrerg/article/details/138062029

版权

程序员专栏收录该内容

267 篇文章 0 订阅

订阅专栏

String topic

消息所属的主题。

Integer partition

消息所在主题的队列数，可以人为指定，如果指定了 key 的话，会使用 key 的 hashCode 与队列总数进行取模来选择分区，如果前面两者都未指定，则会轮询主题下的所有分区。

Headers headers

该消息的额外属性对，与消息体分开存储.

K key

消息键，如果指定该值，则会使用该值的 hashcode 与队列数进行取模来选择分区。

V value

消息体。

Long timestamp

消息时间戳，根据 topic 的配置信息 message.timestamp.type 的值来赋予不同的值。

CreateTime

发送客户端发送消息时的时间戳。

LogAppendTime

消息在 broker 追加时的时间戳。

其中Headers是一系列的 key-value 键值对。

在了解 ProducerRecord 后我们开始来探讨 Kafka 的消息发送流程。

2、Kafka 消息追加流程

KafkaProducer 的 send 方法，并不会直接向 broker 发送消息，kafka 将消息发送异步化，即分解成两个步骤，send 方法的职责是将消息追加到内存中(分区的缓存队列中)，然后会由专门的 Send 线程异步将缓存中的消息批量发送到 Kafka Broker 中。

消息追加入口为 KafkaProducer#send

public Future send(ProducerRecord<K, V> record, Callback callback) {

// intercept the record, which can be potentially modified; this method does not throw exceptions

ProducerRecord<K, V> interceptedRecord = this.interceptors.onSend(record); // @1

return doSend(interceptedRecord, callback); // @2

}

代码@1：首先执行消息发送拦截器，拦截器通过 interceptor.classes 指定，类型为 List< String >，每一个元素为拦截器的全类路径限定名。

代码@2：执行 doSend 方法，后续我们需要留意一下 Callback 的调用时机。

接下来我们来看 doSend 方法。

2.1 doSend

KafkaProducer#doSend

ClusterAndWaitTime clusterAndWaitTime;

try {

clusterAndWaitTime = waitOnMetadata(record.topic(), record.partition(), maxBlockTimeMs);

} catch (KafkaException e) {

if (metadata.isClosed())

throw new KafkaException(“Producer closed while send in progress”, e);

throw e;

}

long remainingWaitMs = Math.max(0, maxBlockTimeMs - clusterAndWaitTime.waitedOnMetadataMs);

Step1：获取 topic 的分区列表，如果本地没有该topic的分区信息，则需要向远端 broker 获取，该方法会返回拉取元数据所耗费的时间。在消息发送时的最大等待时间时会扣除该部分损耗的时间。

温馨提示：本文不打算对该方法进行深入学习，后续会有专门的文章来分析 Kafka 元数据的同步机制，类似于专门介绍 RocketMQ 的 Nameserver 类似。

KafkaProducer#doSend

byte[] serializedKey;

try {

serializedKey = keySerializer.serialize(record.topic(), record.headers(), record.key());

} catch (ClassCastException cce) {

throw new SerializationException("Can’t convert key of class " + record.key().getClass().getName() +

" to class " + producerConfig.getClass(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG).getName() +

" specified in key.serializer", cce);

}

Step2：序列化 key。注意：序列化方法虽然有传入 topic、Headers 这两个属性，但参与序列化的只是 key 。

KafkaProducer#doSend

byte[] serializedValue;

try {

serializedValue = valueSerializer.serialize(record.topic(), record.headers(), record.value());

} catch (ClassCastException cce) {

throw new SerializationException("Can’t convert value of class " + record.value().getClass().getName() +

" to class " + producerConfig.getClass(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG).getName() +

" specified in value.serializer", cce);

}

Step3：对消息体内容进行序列化。

KafkaProducer#doSend

int partition = partition(record, serializedKey, serializedValue, cluster);

tp = new TopicPartition(record.topic(), partition);

Step4：根据分区负载算法计算本次消息发送该发往的分区。其默认实现类为 DefaultPartitioner，路由算法如下：

如果指定了 key ，则使用 key 的 hashcode 与分区数取模。
如果未指定 key，则轮询所有的分区。

KafkaProducer#doSend

setReadOnly(record.headers());

Header[] headers = record.headers().toArray();

Step5：如果是消息头信息(RecordHeaders)，则设置为只读。

KafkaProducer#doSend

int serializedSize = AbstractRecords.estimateSizeInBytesUpperBound(apiVersions.maxUsableProduceMagic(),

compressionType, serializedKey, serializedValue, headers);

ensureValidRecordSize(serializedSize);

Step5：根据使用的版本号，按照消息协议来计算消息的长度，并是否超过指定长度，如果超过则抛出异常。

KafkaProducer#doSend

long timestamp = record.timestamp() == null ? time.milliseconds() : record.timestamp();

log.trace(“Sending record {} with callback {} to topic {} partition {}”, record, callback, record.topic(), partition);

Callback interceptCallback = new InterceptorCallback<>(callback, this.interceptors, tp);

Step6：先初始化消息时间戳，并对传入的 Callable(回调函数) 加入到拦截器链中。

KafkaProducer#doSend

if (transactionManager != null && transactionManager.isTransactional())

transactionManager.maybeAddPartitionToTransaction(tp);

Step7：如果事务处理器不为空，执行事务管理相关的，本节不考虑事务消息相关的实现细节，后续估计会有对应的文章进行解析。

KafkaProducer#doSend

RecordAccumulator.RecordAppendResult result = accumulator.append(tp, timestamp, serializedKey, serializedValue, headers, interceptCallback, remainingWaitMs);

if (result.batchIsFull || result.newBatchCreated) {

log.trace(“Waking up the sender since topic {} partition {} is either full or getting a new batch”, record.topic(), partition);

this.sender.wakeup();

}

return result.future;

Step8：将消息追加到缓存区，这将是本文重点需要探讨的。如果当前缓存区已写满或创建了一个新的缓存区，则唤醒 Sender(消息发送线程)，将缓存区中的消息发送到 broker 服务器，最终返回 future。这里是经典的 Future 设计模式，从这里也能得知，doSend 方法执行完成后，此时消息还不一定成功发送到 broker。

KafkaProducer#doSend

} catch (ApiException e) {

log.debug(“Exception occurred during message send:”, e);

if (callback != null)

callback.onCompletion(null, e);

this.errors.record();