图解 Kafka 源码之 NetworkClient 网络通信组件架构设计（下篇）

/**
 * Choose the node with the fewest outstanding requests which is at least eligible for connection. This method will
 * prefer a node with an existing connection, but will potentially choose a node for which we don't yet have a
 * connection if all existing connections are in use. If no connection exists, this method will prefer a node
 * with least recent connection attempts. This method will never choose a node for which there is no
 * existing connection and from which we have disconnected within the reconnect backoff period, or an active
 * connection which is being throttled.
 *
 * @return The node with the fewest in-flight requests.
 */
 @Override
 public Node leastLoadedNode(long now){
        // 从元数据中获取所有的节点
        List<Node> nodes = this.metadataUpdater.fetchNodes();
        if (nodes.isEmpty())
            throw new IllegalStateException("There are no nodes in the Kafka cluster");
        int inflight = Integer.MAX_VALUE;

        Node foundConnecting = null;
        Node foundCanConnect = null;
        Node foundReady = null;

        int offset = this.randOffset.nextInt(nodes.size());
        for (int i = 0; i < nodes.size(); i++) {
            int idx = (offset + i) % nodes.size();
            Node node = nodes.get(idx);
            // 节点是否可以发送请求
            if (canSendRequest(node.idString(), now)) {
                // 获取节点的队列大小
                int currInflight = this.inFlightRequests.count(node.idString());
                // 如果为 0 则返回该节点，负载最小 
                if (currInflight == 0) {
                    // if we find an established connection with no in-flight requests we can stop right away
                    log.trace("Found least loaded node {} connected with no in-flight requests", node);
                    return node;
                } else if (currInflight < inflight) { // 如果队列大小小于最大值
                    // otherwise if this is the best we have found so far, record that
                    inflight = currInflight;
                    foundReady = node;
                }
            } else if (connectionStates.isPreparingConnection(node.idString())) {
                foundConnecting = node;
            } else if (canConnect(node, now)) {
                if (foundCanConnect == null ||
                        this.connectionStates.lastConnectAttemptMs(foundCanConnect.idString()) >
                                this.connectionStates.lastConnectAttemptMs(node.idString())) {
                    foundCanConnect = node;
                }
            } else {
                log.trace("Removing node {} from least loaded node selection since it is neither ready " +
                        "for sending or connecting", node);
            }
        }

        // We prefer established connections if possible. Otherwise, we will wait for connections
        // which are being established before connecting to new nodes.
        if (foundReady != null) {
            log.trace("Found least loaded node {} with {} inflight requests", foundReady, inflight);
            return foundReady;
        } else if (foundConnecting != null) {
            log.trace("Found least loaded connecting node {}", foundConnecting);
            return foundConnecting;
        } else if (foundCanConnect != null) {
            log.trace("Found least loaded node {} with no active connection", foundCanConnect);
            return foundCanConnect;
        } else {
            log.trace("Least loaded node selection failed to find an available node");
            return null;
        }
 }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.

/**
 * The set of requests which have been sent or are being sent but haven't yet received a response
 * 用来缓存已经发送出去或者正在发送但均还没有收到响应的  ClientRequest 请求集合
 */
final class InFlightRequests {
    // 每个连接最大执行中的请求数
    private final int maxInFlightRequestsPerConnection;
    // 节点 Node 至客户端请求双端队列 Deque<NetworkClient.InFlightRequest> 的映射集合，key为 NodeId, value 是请求队列
    private final Map<String, Deque<NetworkClient.InFlightRequest>> requests = new HashMap<>();
    /** Thread safe total number of in flight requests. */
    // 线程安全的 inFlightRequestCount 
    private final AtomicInteger inFlightRequestCount = new AtomicInteger(0);
    // 设置每个连接最大执行中的请求数
    public InFlightRequests(int maxInFlightRequestsPerConnection){
        this.maxInFlightRequestsPerConnection = maxInFlightRequestsPerConnection;
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.

/**
 * Can we send more requests to this node?
 * @param node Node in question
 * @return true iff we have no requests still being sent to the given node
 * 判断该连接是否还能发送请求
*/
public boolean canSendMore(String node){
        // 获取节点对应的双端队列
        Deque<NetworkClient.InFlightRequest> queue = requests.get(node);
        // 判断条件 队列为空 || (队首已经发送完成 && 队列中没有堆积更多的请求)
        return queue == null || queue.isEmpty() ||
               (queue.peekFirst().send.completed() && queue.size() < this.maxInFlightRequestsPerConnection);
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

/**
 * Add the given request to the queue for the connection it was directed to
 * 将请求添加到队列首部
*/
public void add(NetworkClient.InFlightRequest request){
        // 这个请求要发送到哪个 Broker 节点上
        String destination = request.destination;
        // 从 requests 集合中根据给定请求的目标 Node 节点获取对应 Deque<ClientRequest> 双端队列 reqs
        Deque<NetworkClient.InFlightRequest> reqs = this.requests.get(destination);
        // 如果双端队列reqs为null
        if (reqs == null) {
            // 构造一个双端队列 ArrayDeque 类型的 reqs
            reqs = new ArrayDeque<>();
            // 将请求目标 Node 节点至 reqs 的映射关系添加到 requests 集合
            this.requests.put(destination, reqs);
        }
        // 将请求 request 添加到 reqs 队首
        reqs.addFirst(request);
        // 增加计数
        inFlightRequestCount.incrementAndGet();
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.

/**
 * Get the oldest request (the one that will be completed next) for the given node
 * 取出该连接对应的队列中最老的请求
 */
 public NetworkClient.InFlightRequest completeNext(String node){
     // 根据给定 Node 节点获取客户端请求双端队列 reqs，并从队尾出队
     NetworkClient.InFlightRequest inFlightRequest = requestQueue(node).pollLast();
     // 递减计数器
     inFlightRequestCount.decrementAndGet();
     return inFlightRequest;
 }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

/**
 * Get the last request we sent to the given node (but don't remove it from the queue)
 * @param node The node id
 */
 public NetworkClient.InFlightRequest lastSent(String node){
     return requestQueue(node).peekFirst();
 }
1.
2.
3.
4.
5.
6.
7.

/**
  * Complete the last request that was sent to a particular node.
  * @param node The node the request was sent to
  * @return The request
  * 取出该连接对应的队列中最新的请求
  */
 public NetworkClient.InFlightRequest completeLastSent(String node){
        // 根据给定 Node 节点获取客户端请求双端队列 reqs，并从队首出队
        NetworkClient.InFlightRequest inFlightRequest = requestQueue(node).pollFirst();
        // 递减计数器
        inFlightRequestCount.decrementAndGet();
        return inFlightRequest;
 }
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

static class InFlightRequest {
     //  请求头
     final RequestHeader header;
     // 这个请求要发送到哪个 Broker 节点上
     final String destination;
     // 回调函数
     final RequestCompletionHandler callback;
     // 是否需要进行响应
     final boolean expectResponse;
     // 请求体
     final AbstractRequest request;
     // 发送前是否需要验证连接状态
     final boolean isInternalRequest; // used to flag requests which are initiated internally by NetworkClient
     // 请求的序列化数据
     final Send send;
     // 发送时间
     final long sendTimeMs;
     // 请求的创建时间，即 ClientRequest 的创建时间
     final long createdTimeMs;
     // 请求超时时间
     final long requestTimeoutMs;
     .....
    /**
     * 收到响应，回调的时候据响应内容生成 ClientResponse
     */
    public ClientResponse completed(AbstractResponse response, long timeMs){
        return new ClientResponse(header, callback, destination, createdTimeMs, timeMs,
                    false, null, null, response);
    }
    
    /**
     * 当连接突然断开，也会生成 ClientResponse。
     */
    public ClientResponse disconnected(long timeMs, AuthenticationException authenticationException){
       return new ClientResponse(header, callback, destination, createdTimeMs, timeMs,
                    true, null, authenticationException, null);
    }
}
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.