67)消费者源码-coondinator原理刨析 -63｝0:16
68)消费者源码-consumer初始化 -64｝0:16
入口↓▲★
\kafka-0.10.1.0-nx-src\examples\src\main\java\kafka\examples\Consumer.java
java/org/apache/kafka/clients/consumer/KafkaConsumer.java
——》KafkaConsumer构造函数（）
▼
//初始化了一个核心的组件
//这个组件我们熟悉得不能在熟悉了
NetworkClient netClient = new NetworkClient(
//初始化了一个ConsumerCoordinator
this.coordinator = new ConsumerCoordinator(this.client,
//TODO Fetcher
this.fetcher = new Fetcher<>(this.client,
回到 \kafka-0.10.1.0-nx-src\examples\src\main\java\kafka\examples
——》Consumer.doWork（）
//TODO 里面会有重要代码
ConsumerRecords<Integer, String> records = consumer.poll(
——》KafkaConsumer.poll（）
//里面就是消费者去消费数据
Map<TopicPartition, List<ConsumerRecord<K, V>>> records = pollOnce(remaining);
——》 KafkaConsumer.pollOnce（）
coordinator.poll(time.milliseconds());
——》ConsumerCoordinator.poll（）
▼
//TODO 计算出来哪台服务器是coondinator服务器了
ensureCoordinatorReady();
▼
——》ConsumerCoordinator.ensureCoordinatorReady（）
//TODO
RequestFuture<Void> future = lookupCoordinator();
——》AbstractCoordinator.lookupCoordinator();
//随意找到了一台服务器
Node node = this.client.leastLoadedNode();
//TODO 发送请求
findCoordinatorFuture = sendGroupCoordinatorRequest(node);
——》AbstractCoordinator.sendGroupCoordinatorRequest（）
//发送的是GROUP_COORDINATOR的请求 Kafkaapis
return client.send(node, ApiKeys.GROUP_COORDINATOR, metadataRequest)
//TODO 对响应进行处理
compose(new GroupCoordinatorResponseHandler());
——》AbstractCoordinator.GroupCoordinatorResponseHandler.onSuccess（）
//封装出来一台服务器，coordinator服务器
AbstractCoordinator.this.coordinator = new Node(
//从响应里面解析出来 coordinator服务器的信息
Integer.MAX_VALUE - groupCoordinatorResponse.node().id(),
▲ 回到ConsumerCoordinator.poll（）
69)消费者源码-如何选举consumer leader -65｝0:10
接上回 ， 回到
——》ConsumerCoordinator.poll（）
//TODO 核心代码
ensureActiveGroup();
——》AbstractCoordinator.ensureActiveGroup（）
//TODO 发送注册请求的代码在里面
joinGroupIfNeeded();
——》AbstractCoordinator. joinGroupIfNeeded()
//再次判断是否已经确定好了哪台是coondinator服务器
ensureCoordinatorReady();
//进行注册之前准备
onJoinPrepare(generation.generationId, generation.memberId);
//TODO
RequestFuture<ByteBuffer> future = initiateJoinGroup();
——》 AbstractCoordinator.initiateJoinGroup（）
//TODO 发送一个注册的请求
joinFuture = sendJoinGroupRequest();
——》 AbstractCoordinator.sendJoinGroupRequest（）
//在发送请求
return client.send(coordinator, ApiKeys.JOIN_GROUP, request)
.compose(new JoinGroupResponseHandler());
↓ 到服务器端代码看ApiKeys.JOIN_GROUP,
src\core\src\main\scala\kafka\server\KafkaApis.scala
——》 KafkaApis类
case ApiKeys.JOIN_GROUP => handleJoinGroupRequest(request)
——》 KafkaApis.handleJoinGroupRequest （）
//TODO 处理
coordinator.handleJoinGroup(
——》 GroupCoordinator.handleJoinGroup（）
//TODO 核心代码
doJoinGroup(group, memberId, clientId, clientHost
——》 GroupCoordinator.doJoinGroup（）
case Empty | Stable =>
if (memberId == JoinGroupRequest.UNKNOWN_MEMBER_ID) {
//TODO
addMemberAndRebalance(rebalanceTimeoutMs,
——》 GroupCoordinator.addMemberAndRebalance（）
//TODO 添加自己的信息
group.add(member.memberId, member)
——》 GroupMetadata.add（）
//第一次进来的时候leaderid可定是null的
if (leaderId == null)
//我们就知道了，其实让哪个consumer作为leader consumer很简单
//就是谁先注册上来，谁就是leader consumer。
leaderId = memberId
70)消费者源码-consumer leader-如何制定分区方案 -66｝0:5
回顾上节代码
——》 AbstractCoordinator.sendJoinGroupRequest（）
//在发送请求
return client.send(coordinator, ApiKeys.JOIN_GROUP, request)
.compose(new JoinGroupResponseHandler());
↓ 继续客户端代码
——》 AbstractCoordinator.JoinGroupResponseHandler.handle（）
//TODO 我们所有的消费组里面的成员
//都会去发送joinGroup
//最终只会有一个consumer是leader
//如果发现自己是leader的consumer，那么就会调用
//这个方法，然后制定分区方案
//把分区方案发送给coondinator
onJoinLeader(joinResponse).chain(future);
——》 AbstractCoordinator.onJoinLeader（）
//TODO 这个方法就是指定分区方案的方法
Map<String, ByteBuffer> groupAssignment = performAssignment(joinResponse.leaderId(),
joinResponse.groupProtocol(),
joinResponse.members());
//TODO 发送请求
return sendSyncGroupRequest(request);
——》 AbstractCoordinator.sendSyncGroupRequest（）
//发送SYNC_GROUP请求
return client.send(coordinator, ApiKeys.SYNC_GROUP, request)
71)消费者源码-coondinator下发分区方案 -67｝0:4
接上回：
——》 AbstractCoordinator.sendSyncGroupRequest（）
//发送SYNC_GROUP请求
return client.send(coordinator, ApiKeys.SYNC_GROUP, request)
↓ 到服务器端代码看ApiKeys.SYNC_GROUP,
src\core\src\main\scala\kafka\server\KafkaApis.scala
——》 KafkaApis类
case ApiKeys.JOIN_GROUP => handleJoinGroupRequest(request)
——》 KafkaApis.handleSyncGroupRequest（）
coordinator.handleSyncGroup(
——》GroupCoordinator.handleSyncGroup（）
//TODO
case Some(group) => doSyncGroup(group,
——》GroupCoordinator.doSyncGroup（）
//TODO coondinator下发分区方案
setAndPropagateAssignment(group, assignment)
//把状态切换为Stable
group.transitionTo(Stable)
——》GroupCoordinator.setAndPropagateAssignment（）
//TODO
propagateAssignment(group, Errors.NONE)
——》GroupCoordinator.propagateAssignment（）
//调用回调函数
//这个assignment参数就是分配的分区消费方案。
//其实coondinator就是通过调用这个member的回调函数，然后完成的分区方案的下发。
member.awaitingSyncCallback(member.assignment, error.code)
72)消费者源码-consumer消费数据 -68｝0:4
回到
——》KafkaConsumer.poll（）
//里面就是消费者去消费数据
Map<TopicPartition, List<ConsumerRecord<K, V>>> records = pollOnce(remaining);
——》KafkaConsumer.pollOnce（）
▼
//coordinator确定了
coordinator.poll(time.milliseconds());
//TODO 发送网络请求
fetcher.sendFetches();
▼——》Fetcher.sendFetches();
//封装请求
for (Map.Entry<Node, FetchRequest> fetchEntry :
▲
//获取到请求的结果。
return fetcher.fetchedRecords();
——》Fetcher.fetchedRecords();
↓ 到服务器端代码看ApiKeys.FECH,
src\core\src\main\scala\kafka\server\KafkaApis.scala
——》 KafkaApis类
——》KafkaApis.handleFetchRequest（）
//1、获取leaderPartiton 2、拉取数据返回客户端
//封装出来响应
val response = FetchResponse(fetchRequest.correlationId,
//拉取数据
replicaManager.fetchMessages(
fetchRequest.maxWait.toLong,
73)消费者源码-自动提交偏移量 -69｝0:8
入口：
org/apache/kafka/clients/consumer/internals/ConsumerCoordinator.java
//配置是否进行自动提交偏移的标志位
private final boolean autoCommitEnabled;
//每隔多久提交一次偏移量信息（消费offset）
private final int autoCommitIntervalMs;
——》ConsumerCoordinator.maybeAutoCommitOffsetsNow（）
——》ConsumerCoordinator.doAutoCommitOffsetsAsync（）
//TODO
commitOffsetsAsync(subscriptions.allConsumed(), new OffsetCommitCallback() {
——》ConsumerCoordinator.commitOffsetsAsync（）
//TODO
doCommitOffsetsAsync(offsets, callback);
——》ConsumerCoordinator.doCommitOffsetsAsync（）
——》ConsumerCoordinator.sendOffsetCommitRequest（）
//封装请求
OffsetCommitRequest req = new OffsetCommitRequest(
this.groupId,
generation.generationId,
//发送请求
return client.send(coordinator, ApiKeys.OFFSET_COMMIT, req)
↓ 到服务器端代码看ApiKeys.OFFSET_COMMIT,
src\core\src\main\scala\kafka\server\KafkaApis.scala
——》 KafkaApis类
——》KafkaApis.handleOffsetCommitRequest（）
——》GroupCoordinator.handleCommitOffsets（）
——》GroupCoordinator.doCommitOffsets（）
74)消费者源码-consumer发送心跳 -70｝0:10
入口：
——》 AbstractCoordinator. 类 （）
//心跳线程
private HeartbeatThread heartbeatThread = null;
——》 AbstractCoordinator.HeartbeatThread.run()
//设置心跳的时间
heartbeat.sentHeartbeat(now);
//发送心跳的请求
sendHeartbeatRequest().addListener(new RequestFutureListener<Void>() {
——》 AbstractCoordinator.sendHeartbeatRequest（）
//封装请求
HeartbeatRequest req = new HeartbeatRequest(this.groupId, this.generation.generationId, this.generation.memberId);
//把请求发送出去
return client.send(coordinator, ApiKeys.HEARTBEAT, req)
↓ 到服务器端代码看ApiKeys.HEARTBEAT,
src\core\src\main\scala\kafka\server\KafkaApis.scala
——》 KafkaApis类 handleHeartbeatRequest（）
//TODO
coordinator.handleHeartbeat(
heartbeatRequest.groupId(),
heartbeatRequest.memberId(),
heartbeatRequest.groupGenerationId(),
sendResponseCallback)
——》GroupCoordinator. handleHeartbeat（）
case Stable =>
//TODO
completeAndScheduleNextHeartbeatExpiration(group, member)
——》GroupCoordinator.completeAndScheduleNextHeartbeatExpiration（）
// 更新对应的consumer的上一次的心跳时间
member.latestHeartbeat = time.milliseconds()
val memberKey = MemberKey(member.groupId, member.memberId)
heartbeatPurgatory.checkAndComplete(memberKey)
//时间轮机制，把往时间轮里面插入一个任务，这个任务就是用来检查心跳是否超时的。
//11:00：00 心跳 11:00：30
//去看最后30秒是否有心跳超时的。
val delayedHeartbeat = new DelayedHeartbeat(this, group, member,
