阅读本文大约需要 30 分钟。

大家好，我是 华仔, 又跟大家见面了。

在上一篇中，主要带大家深度剖析了「Kafka 对多路复用器 Selector」的封装全过程，今天我们主要对 Kafka 网络层收发流程进行总结下，本系列总共分为3篇，这是下篇，主要剖析最后一个问题：

  1. 针对 Java NIO 的 SocketChannel，kafka 是如何封装统一的传输层来实现最基础的网络连接以及读写操作的？
  2. 剖析 KafkaChannel 是如何对传输层、读写 buffer 操作进行封装的？
  3. 剖析工业级 NIO 实战：如何基于位运算来控制事件的监听以及拆包、粘包是如何实现的？
  4. 剖析 Kafka 是如何封装 Selector 多路复用器的？
  5. 剖析 Kafka 封装的 Selector 是如何初始化并与 Broker 进行连接以及网络读写的？
  6. 剖析 Kafka 网络发送消息和接收响应的整个过程是怎样的？

认真读完这篇文章，我相信你会对 Kafka 网络层源码有更加深刻的理解。

图解 Kafka 网络层源码实现机制之收发消息全过程 - 图1

这篇文章干货很多，希望你可以耐心读完。

01 总体概述

通过场景驱动的方式，在网络请求封装和监听好后，我们来看看消息是如何进行网络收发的，都需要做哪些工作。

  1. 发送消息流程剖析
    • 消息预发送
    • 消息真正发送
  1. 接收响应流程剖析
    • 读取响应结果
    • 解析响应信息
    • 处理回调

为了方便大家理解，所有的源码只保留骨干。

02 发送消息流程剖析

02.1 消息预发送

这部分涉及的东西比较多，此处就简单的说明下，后续会有专门篇章进行剖析。

客户端先准备要发送的消息，流程如下：

  1. Sender 子线程会从 RecordAccumulator 缓冲区拉取要发送的消息集合，抽取到的数据会存放到下面几个地方：
    • 发送时会放入 inFlightRequests 集合和 KafkaChannel 的 send 对象，其中 inFlightRequests 后续篇章再进行剖析，这里简单说明下，该集合用来存储和操作待发送消息的缓存区，当请求准备网络发送时，会把请求从队头放入队列；当接收到响应后，会把请求从队尾删除。
    • 待发送完成后会放入 completedRequests 集合。
  1. 对已经过期的数据进行处理。
  2. 封装客户端请求 ClientRequest，把 ClientRequest 类对象发送给 NetworkClient，它主要有以下2个工作要做：
    • 根据 ClientRequest 类对象构造 InFlightRequest 类对象。
    • 根据 ClientRequest 类对象构造 NetworkSend 类对象，并放入到 KafkaChannel 的缓存里。
  1. 此时消息预发送结束。

接下来我们依次看下Selector 和 KafkaChannel 类的具体源码实现。

图解 Kafka 网络层源码实现机制之收发消息全过程 - 图2

02.1.1 请求数据暂存内存中

::: block-1
github 源码地址如下：

https://github.com/apache/kafka/blob/2.7/clients/src/main/java/org/apache/kafka/common/network/Selector.java

https://github.com/apache/kafka/blob/2.7/clients/src/main/java/org/apache/kafka/common/network/KafkaChannel.java
:::

  1. /**
  2.  * 消息预发送
  3.  */
  4. public void send(Send send) {
  5.     // 1. 从服务端获取 connectionId
  6.     String connectionId = send.destination();
  7.     // 2. 从数据包中获取对应连接
  8.     KafkaChannel channel = openOrClosingChannelOrFail(connectionId);
  9.     // 3. 如果关闭连接集合中存在该连接
  10.     if (closingChannels.containsKey(connectionId)) {
  11.         // 把 connectionId 放入 failedSends 集合里
  12.         this.failedSends.add(connectionId);
  13.     } else {
  14.         try {
  15.             // 4. 暂存数据预发送，并没有真正的发送,一次只能发送一个
  16.             channel.setSend(send);
  17.         } catch (Exception e) {
  18.             // 5. 更新 KafkaChannel 的状态为发送失败  
  19.             channel.state(ChannelState.FAILED_SEND);
  20.             // 6. 把 connectionId 放入 failedSends 集合里
  21.             this.failedSends.add(connectionId);
  22.             // 7. 关闭连接
  23.             close(channel, CloseMode.DISCARD_NO_NOTIFY);
  24.             ...
  25.         }
  26.     }
  27. }

从源码中可以看到调用了 KafkaChannel 类的 setSend() 方法。

  1. public void setSend(Send send) {
  2.   if (this.send != null)
  3.       throw new IllegalStateException("Attempt to begin a send operation with prior send operation still in progress, connection id is " + id);
  4.   // 设置要发送消息的字段
  5.   this.send = send;
  6.   // 调用传输层增加写事件
  7.   this.transportLayer.addInterestOps(SelectionKey.OP_WRITE);
  8. }
  10. // PlaintextTransportLayer 类方法
  11. @Override
  12. public void addInterestOps(int ops) {
  13.     //通过 key.interestOps() | ops 来添加事件
  14.     key.interestOps(key.interestOps() | ops);
  15. }

该方法主要用来预发送，即在发送网络请求前，将需要发送的ByteBuffer 数据保存到 KafkaChannel 的 send 中，然后调用传输层方法增加对这个 channel 上「OP_WRITE」事件的关注，同时还保留了「OP_READ」事件，此时该 Channel 是同时可以进行读写的。当真正执行发送的时候，会先从 send 中读取数据。

02.2 消息真正发送

Sender 子线程会调用 Selector 的 「poll」方法把请求真正发送出去。

02.2.1 poll()

  1. @Override
  2. public void poll(long timeout) throws IOException {
  3.     ...
  4.     // 调用nioSelector.select线程阻塞等待I/O事件并设置阻塞时间，等待I/O事件就绪发生，然后返回已经监控到了多少准备就绪的事件
  5.     int numReadyKeys = select(timeout);
  6.     // 监听到事件发生或立即连接集合不为空或存在缓存数据
  7.     if (numReadyKeys > 0 || !immediatelyConnectedKeys.isEmpty() || dataInBuffers) {
  8.         // 在SSL连接才可能会存在缓存数据
  9.         if (dataInBuffers) {
  10.             // 处理事件
  11.             pollSelectionKeys(toPoll, false, endSelect);
  12.         }
  13.         // 处理监听到的准备就绪事件
  14.         pollSelectionKeys(readyKeys, false, endSelect);
  15.         // 处理立即连接集合
  16.         pollSelectionKeys(immediatelyConnectedKeys, true, endSelect);
  17.     } else {
  18.         ...
  19.     }
  20.     ...
  21. }

该方法就干了一件事，即收集准备就绪事件，并针对事件进行网络操作，通过上述简化代码可以看出是调用了 「pollSelectionKeys」 方法，真正读写操作在该方法中，我们来看看：

02.2.2 pollSelectionKeys()

  1. void pollSelectionKeys(Set<SelectionKey> selectionKeys,boolean isImmediatelyConnected,long currentTimeNanos) {
  2.     //1. 循环调用当前监听到的事件(原顺序或者洗牌后顺序)
  3.     for (SelectionKey key : determineHandlingOrder(selectionKeys)) {
  4.         // 2. 之前创建连接，把kafkachanel注册到key上，这里就是获取对应的 channel
  5.         KafkaChannel channel = channel(key);
  6.         ...
  7.         // 3. 获取节点id
  8.         String nodeId = channel.id();
  9.         ...
  10.         try {
  11.             ...
  12.             // 4. 读事件是否准备就绪了
  13.             if (channel.ready() && (key.isReadable() || channel.hasBytesBuffered()) && !hasCompletedReceive(channel) && !explicitlyMutedChannels.contains(channel)) {
  14.                 // 尝试处理读事件
  15.                 attemptRead(channel);
  16.         }
  17.         ...
  18.         try {
  19.            // 5. 尝试处理写事件
  20.            attemptWrite(key, channel, nowNanos);
  21.         } catch (Exception e) {
  22.             sendFailed = true;
  23.             throw e;
  24.         }
  25.     } catch (Exception e) {
  26.         ...
  27.     } finally {
  28.        ....
  29.     }
  30.   }
  31. }

该方法主要用来处理监听到的事件，包括连接事件、读写事件、以及立即完成的连接的。接下来我们看看尝试进行网络写操作，如何才能进行真正写。

02.2.3 attemptWrite()

  1. private void attemptWrite(SelectionKey key, KafkaChannel channel, long nowNanos) throws IOException {
  2.     // 此处需要满足4个条件才可以进行写操作      
  3.     if (channel.hasSend()
  4.             && channel.ready()
  5.             && key.isWritable()
  6.             && !channel.maybeBeginClientReauthentication(() -> nowNanos)) {
  7.         // 进行写操作
  8.         write(channel);
  9.     }
  10. }
  12. // channel 连接就绪
  13. public boolean ready() {
  14.     return transportLayer.ready() && authenticator.complete();
  15. }
  17. // java nio SelectionKey
  18. public final boolean isWritable() {
  19.     return (readyOps() & OP_WRITE) != 0;
  20. }

该方法主要用来尝试进行网络写操作，方法很简单，必须「同时满足4个条件」：

  1. 「channel 还有数据可以发送」即数据还未发送完成。
  2. 「channel 连接就绪」。
  3. 「写事件是可写状态」只要写缓冲区未写满会一直产生「OP_WRITE」 事件，如果不写数据或者写满时则需要取消 「OP_WRITE」 事件，防止产生不必要的资源消耗。
  4. 「客户端验证没有开启」。

当满足以上4个条件后就可以进行写操作了，接下来我们看看写操作的过程。

02.2.4 write()

  1. // 执行写操作 
  2. void write(KafkaChannel channel) throws IOException {
  3.     // 1.获取 channel 对应的节点id    
  4.     String nodeId = channel.id();
  5.     // 2. 将保存在 send 上的数据真正发送出去，但是一次不一定能发送完，会返回已经发出的字节数
  6.     long bytesSent = channel.write();
  7.     // 3. 判断是否发送完成，未完成返回null，等待下次poll继续发送
  8.     Send send = channel.maybeCompleteSend();
  9.     // 4. 说明已经发出或者发送完成
  10.     if (bytesSent > 0 || send != null) {
  11.         long currentTimeMs = time.milliseconds();
  12.         if (bytesSent > 0)
  13.             // 记录发送字节 Metrics 信息
  14.             this.sensors.recordBytesSent(nodeId, bytesSent, currentTimeMs);
  15.         // 发送完成
  16.         if (send != null) {
  17.             // 将 send 添加到 completedSends
  18.             this.completedSends.add(send);
  19.             //  记录发送完成 Metrics 信息
  20.             this.sensors.recordCompletedSend(nodeId, send.size(), currentTimeMs);
  21.         }
  22.     }
  23. }

该方法主要用来真正执行网络写操作的，大家知道在网络编程过程中，不一定一次性可以发送完成，此时就需要判断是否发送完成，如果未完成返回null，「等待下次轮询 poll() 会继续发送，并继续关注这个 channel 的写事件」，如果发送完成，「则返回 send，并取消Selector 在这个 socketchannel 上 OP_WRITE 事件的关注」。这里调用了 KafkaChannel 类的 write() 进行写操作发送，并调用 maybeCompleteSend() 判断是否发送完成，我们先来看下 write() 写操作：

02.2.6 KafkaChannel.write()

  1. public long write() throws IOException {
  2.     // 判断 send 是否为空，如果为空表示已经发送完毕了
  3.     if (send == null)
  4.         return 0;
  6.     midWrite = true;
  7.     // 调用ByteBufferSend.writeTo把数据真正发送出去
  8.     return send.writeTo(transportLayer);
  9. }

该方法主要用来把保存在 send 上的数据真正发送出去，调用ByteBufferSend.writeTo 把数据真正发送出去，我们来看看 wirteTo() 方法：

  1. @Override
  2. // 将字节流数据写入到channel中
  3. public long writeTo(GatheringByteChannel channel) throws IOException {
  4.     // 1.调用nio底层write方法把buffers写入传输层返回写入的字节数
  5.     long written = channel.write(buffers);
  6.     if (written < 0)
  7.         throw new EOFException("Wrote negative bytes to channel. This shouldn't happen.");
  8.     // 2.计算还剩多少字节没有写入传输层
  9.     remaining -= written;
  10.     // 每次发送 都检查是否
  11.     pending = TransportLayers.hasPendingWrites(channel);
  12.     return written;
  13. }

该方法主要用来把 buffers 数组写入到 SocketChannel里，因为在网络编程中，写一次不一定可以完全把数据都写成功，所以调用java nio 底层 channel.write(buffers) 方法会返回「已经写入成功多少字节」的返回值，这样调用一次后就知道已经写入多少字节了。

当调用 write() 以及一系列底层方法进行写操作后，会返回已经发出的字节数，如果这次没有发送完毕则返回 null，「等待下次轮询 poll 继续发送网络写操作，并继续关注这个 channel 的写事件」，所以需要判断下本次是否发送完毕了，我们来看看：

02.2.7 maybeCompleteSend()

  1. // 可能完成发送
  2. public Send maybeCompleteSend() {
  3.     // send 不为空且已经发送完毕
  4.     if (send != null && send.completed()) {
  5.         midWrite = false;
  6.         // 当写数据完毕后，取消传输层对 OP_WRITE 事件的监听，完成一次写操作
  7.         transportLayer.removeInterestOps(SelectionKey.OP_WRITE);
  8.         // 将 send 赋值给结果集 result
  9.         Send result = send;
  10.         // 此时读完后将 send 清空，以便下次写
  11.         send = null;
  12.         // 最后返回结果集 result，完成一次写操作
  13.         return result;
  14.     }
  15.     return null;
  16. }
  18. // PlaintextTransportLayer 类方法
  19. @Override
  20. public void removeInterestOps(int ops) {
  21.     // 通过 key.interestOps() & ~ops 来删除事件
  22.     key.interestOps(key.interestOps() & ~ops);
  23. }
  25. // ByteBufferSend
  26. @Override
  27. public boolean completed() {
  28.     return remaining <= 0 && !pending;
  29. }

该方法主要用来判断是否写数据完毕了，而判断的写数据完毕的条件是buffer 中 remaining 没有剩余且 pending 为 false。如果发送完成，把发送完成的请求添加到发送完成的集合 completedSends 里。

待消息请求发送完成后，又做了哪些工作呢？这里涉及到 NetworkClient 类的相关知识，这里简单说明下，后续再剖析：

::: block-1
github 源码地址如下：

https://github.com/apache/kafka/blob/2.7/clients/src/main/java/org/apache/kafka/clients/NetworkClient.java
:::

  1. private void handleCompletedSends(List<ClientResponse> responses, long now) {
  2.     // if no response is expected then when the send is completed, return it
  3.     // 上面发送完成将 send 添加到 completedSends 集合，然后遍历这个集合
  4.     for (Send send : this.selector.completedSends())     {
  5.         // 获取 inFlightRequests 集合发往对应 Broker 的最后一个请求元素
  6.         InFlightRequest request = this.inFlightRequests.lastSent(send.destination());
  7.         // 判断是否期望进行响应
  8.         if (!request.expectResponse) {
  9.             // 如果不期望进行响应就删除inFlightRequests集合发往对应 Broker 请求队列的第一个元素
  10.             this.inFlightRequests.completeLastSent(send.destination());
  11.             // 把请求添加到 responses 集合里
  12.             responses.add(request.completed(null, now));
  13.         }
  14.     }
  15. }

从源码可以看出会对「completedSends」集合和「inFlightRequests」集合是一个「互相协作」的关系。

其中「completedSends」集合是指发送完成但还没有返回的请求集合，而「inFlightRequests」集合则是保存了已经发送出去但还没有收到响应结果的 Request 集合。 其中「completedSends」的元素对应着「inFlightRequests」集合对应队列的最后一个元素。

到此发送消息流程剖析完毕，至于发送完成后续工作，我们待讲解 Sender 和 NetWorkClient 的时候再详细进行剖析，接下来我们来看看接收响应流程。

03 接收响应流程剖析

在上面剖析 Selector.pollSelectionKeys() 时候，当网络读事件就绪后会调用 attemptRead() 进行尝试网络读操作，我们来看看：

03.1 读取响应结果

03.1.1 attemptRead()

  1. private void attemptRead(KafkaChannel channel) throws IOException {
  2.     // 获取 channel 对应的节点 id
  3.     String nodeId = channel.id();
  4.     // 将从传输层中读取数据到NetworkReceive对象中
  5.     long bytesReceived = channel.read();
  6.     if (bytesReceived != 0) {
  7.         ...
  8.         // 判断 NetworkReceive 对象是否已经读完了
  9.         NetworkReceive receive = channel.maybeCompleteReceive();
  10.         // 当读完后把这个 NetworkReceive 对象添加到已经接收完毕网络请求集合里
  11.         if (receive != null) {
  12.             addToCompletedReceives(channel, receive, currentTimeMs);
  13.         }
  14.     }
  15.     ...
  16. }
  18. // KafkaChannel 方法
  19. public long read() throws IOException {
  20.     if (receive == null) {
  21.         // 初始化 NetworkReceive 对象
  22.         receive = new NetworkReceive(maxReceiveSize, id, memoryPool);
  23.     }
  24.     // 尝试把 channel 的数据读到 NetworkReceive 对象中
  25.     long bytesReceived = receive(this.receive);
  26.     ...
  27.     return bytesReceived;
  28. }

该方法主要用来尝试读取数据并添加已经接收完毕的集合中。我们看到会先调用 KafkaChannel.read() 方法进行读取，然后判断是否读完了，如果没有读完，下次轮询时候接着读取，如果读完了就假如到请求读完的集合 completedReceives 中。

我们来看下是如何判断 NetworkReceive 对象是否已经读完了的：

03.1.2 maybeCompleteReceive()

  1. // 判断 NetworkReceive 对象是否已经读完了
  2. // 如果此时并没有读完一个完整的NetworkReceive对象,则下次触发读事件会继续填充整个NetworkReceive对象，
  3. // 如果读完一个完整的NetworkReceive对象则将其置空，下次触发读事件时会创建一个全新的NetworkReceive对象。
  4. public NetworkReceive maybeCompleteReceive() {
  5.   if (receive != null && receive.complete()) {
  6.       receive.payload().rewind();
  7.       NetworkReceive result = receive;
  8.       receive = null;
  9.       return result;
  10.   }
  11.   return null;
  12. }
  13. // NetworkReceive
  14. public boolean complete() {
  15.     return !size.hasRemaining() && buffer != null && !buffer.hasRemaining();
  16. }

该方法主要用来判断数据已经读取完毕了，而判断是否读完的条件是NetworkReceive 里的 buffer 是否用完，包括上面说过的表示响应消息头 size ByteBuffer 和响应消息体本身的 buffer ByteBuffer，这两个都读完才算真正读完了。

如果此时并没有读完一个完整的NetworkReceive对象,则下次触发读事件会继续填充整个NetworkReceive对象，如果此时读完一个完整的NetworkReceive对象则将其置空，下次触发读事件时会创建一个全新的NetworkReceive对象。

03.2 解析响应消息

等读取完一个完整响应消息后，接下来要做哪些工作呢？那就是要解析这个响应消息，我们来看看是如何实现的：

::: block-1
github 源码地址如下：

https://github.com/apache/kafka/blob/2.7/clients/src/main/java/org/apache/kafka/clients/NetworkClient.java
:::

  1. private void handleCompletedReceives(List<ClientResponse> responses, long now) {
  2.   // 当读完后把这个 NetworkReceive 对象添加到已经接收完毕网络请求集合里，然后遍历这个集合
  3.   for (NetworkReceive receive : this.selector.completedReceives()) {
  4.       // 获取发送请求的node id 
  5.       String source = receive.source();
  6.       // 从 InFlightRequest 集合取出对应的元素并删除
  7.       InFlightRequest req = inFlightRequests.completeNext(source);
  8.       // 解析该响应
  9.       Struct responseStruct = parseStructMaybeUpdateThrottleTimeMetrics(receive.payload(), req.header,
  10.           throttleTimeSensor, now);
  11.       ....
  12.       // 添加响应到响应结果集合中
  13.       responses.add(req.completed(response, now));
  14.   }
  15. }

该方法主要用来循环遍历 completedReceives 集合做一些响应处理工作，在文章开始的时候就简单说过，收到响应后会将其从「inFlightRequests」中删除掉，然后去解析这个响应：

  1. private static Struct parseStructMaybeUpdateThrottleTimeMetrics(ByteBuffer responseBuffer, RequestHeader requestHeader,Sensor throttleTimeSensor, long now) {
  2.     // 获取响应头
  3.     ResponseHeader responseHeader = ResponseHeader.parse(responseBuffer,requestHeader.apiKey().responseHeaderVersion(requestHeader.apiVersion()));
  4.     // 获取响应体
  5.     Struct responseBody = requestHeader.apiKey().parseResponse(requestHeader.apiVersion(), responseBuffer);
  6.     // 对比响应头 correlationId 和响应体的 correlationId 是否一致，否则抛异常
  7.     correlate(requestHeader, responseHeader);
  8.     ...
  9.     return responseBody;
  10. }

该方法主要用来解析响应的，并判断响应头跟响应体的 correlationId 值是否一致，否则抛异常。

此时只对响应做了解析但并没有对响应进行处理，而响应处理是通过调用回调方法进行处理的，我们来看下。

03.3 处理回调

  1. private void completeResponses(List<ClientResponse> responses) {
  2.     // 遍历响应结果集合
  3.     for (ClientResponse response : responses) {
  4.         try {
  5.             response.onComplete();
  6.         } catch (Exception e) {
  7.             log.error("Uncaught error in request completion:", e);
  8.         }
  9.     }
  10. }
  12. //ClientResponse 类
  13. public void onComplete() {
  14.     if (callback != null)
  15.         callback.onComplete(this);
  16. }

到此接收响应消息流程剖析完毕。

04 总结

这里，我们一起来总结一下这篇文章的重点。

1、带你先整体的梳理了 Kafka 网络层收发流程，主要分为「发送消息流程」和「接收响应流程」。

2、又带你分别剖析了发送消息流程和接收响应流程的源码实现细节。

源码详细分析请看上两篇：

下篇我们来深度剖析「Kafka 客户端内存缓冲池机制实现原理」，大家期待，我们下期见。

如另外欢迎加入我的技术交流群，关注本公众号并添加我个人微信，邀您进群。

图解 Kafka 网络层源码实现机制之收发消息全过程 - 图3

如果我的文章对你有所帮助，还请帮忙点赞、在看、转发一下，非常感谢！

坚持总结, 持续输出高质量文章 关注我: 华仔聊技术