Kafka-创建topic源码

一、命令创建topic

kafka-topics --create --topic quickstart-events --bootstrap-server cdh1:9092 --partitions 2 --replication-factor 2

二、kafka-topics脚本

exec $(dirname $0)/kafka-run-class.sh org.apache.kafka.tools.TopicCommand "$@"

脚本中指定了处理它的主类：TopicCommand

三、TopicCommand

public abstract class TopicCommand {
    public static void main(String... args) {
        Exit.exit(mainNoExit(args));
    }
    private static int mainNoExit(String... args) {
        try {
            execute(args);
            return 0;
        } catch (Throwable e) {
            return 1;
        }
    }
    static void execute(String... args) throws Exception {
        //解析命令行参数
        TopicCommandOptions opts = new TopicCommandOptions(args);
        //创建TopicService
        TopicService topicService = new TopicService(opts.commandConfig(), opts.bootstrapServer());
        try {
            if (opts.hasCreateOption()) {
                //这是处理topic创建的，我们主要分析它
                topicService.createTopic(opts);
            } else if (opts.hasAlterOption()) {
                //更高topic逻辑
                topicService.alterTopic(opts);
            } else if (opts.hasListOption()) {
                //获取topic
                topicService.listTopics(opts);
            } else if (opts.hasDescribeOption()) {
                //topi相关描述信息
                topicService.describeTopic(opts);
            } else if (opts.hasDeleteOption()) {
                //删除topic
                topicService.deleteTopic(opts);
            }
        }catch(...){...
        }finally {
            topicService.close();
        }
    }
    public static class TopicService implements AutoCloseable {
        public void createTopic(TopicCommandOptions opts) throws Exception {
            CommandTopicPartition topic = new CommandTopicPartition(opts);
            if (Topic.hasCollisionChars(topic.name)) {
                //由于度量名称的限制，带有句点（“.”）或下划线（“_”）的主题可能会发生冲突。为了避免问题，最好使用其中之一，但不要两者都使用
                System.out.println(".........");
            }
            createTopic(topic);
        }
       public void createTopic(CommandTopicPartition topic) throws Exception {
            if (topic.replicationFactor.filter(rf -> rf > Short.MAX_VALUE || rf < 1).isPresent()) {
                //复制因子必须介于1和“+Short.MAX_VALUE+”之间
                throw new IllegalArgumentException("...");
            }
            if (topic.partitions.filter(p -> p < 1).isPresent()) {
                //分区必须大于0
                throw new IllegalArgumentException("...");
            }
            try {
                NewTopic newTopic;
                //取决于创建 topic 时 是否指定了   replica-assignment
                if (topic.hasReplicaAssignment()) {
                    newTopic = new NewTopic(topic.name, topic.replicaAssignment);
                } else {
                    newTopic = new NewTopic(topic.name, topic.partitions, topic.replicationFactor.map(Integer::shortValue));
                }
                //给topic设置参数
                Map<String, String> configsMap = topic.configsToAdd.stringPropertyNames().stream().collect(Collectors.toMap(name -> name, name -> topic.configsToAdd.getProperty(name)));
                newTopic.configs(configsMap);
                //批量创建topic
                CreateTopicsResult createResult = adminClient.createTopics(Collections.singleton(newTopic),
                    new CreateTopicsOptions().retryOnQuotaViolation(false));
                //等待所有topic都创建成功
                createResult.all().get();
                System.out.println("Created topic " + topic.name + ".");
            } catch (ExecutionException e) {
                //......
            }
        }
    }
}

TopicCommandOptions中有对创建topic所有参数的解读，我们下面来详细看下这些参数

四、创建Topic参数

bootstrap-server

    **必选项：**连接Kafka server用

command-config

    包含要传递给Admin Client的配置的属性文件。这仅与--bootstrap-server选项一起使用，用于描述和更改broker配置

list

    列出所有可用的topic

create

    创建一个新的topic

delete

    删除一个topic

alter

    更改分区数量和副本分配，通过--alter更新现有主题的配置

describe

    列出给定topic的详细信息

topic

    要创建、更改、描述或删除的主题。它还接受正则表达式，但--create选项除外。将主题名称放在双引号中，并使用“\\”前缀转义正则表达式符号；例如 \"test\\.topic\"

topic-id

    仅与用于描述主题的--bootstrap-server选项一起使用

config

    正在创建的主题的主题配置覆盖。

delete-config

    要删除现有主题的主题配置覆盖

partitions

    正在创建或更改的主题的分区数量（警告：如果为具有键的主题增加分区，则分区逻辑或消息顺序将受到影响）。如果未提供用于，则为集群默认值

replication-factor

    正在创建的主题中每个分区的复制因子。如果未提供，则为群集默认值

replica-assignment

    正在创建或更改的topic的手动分区到broker分配列表

under-replicated-partitions

    如果在描述主题时设置，则仅在复制分区下显示

unavailable-partitions

    如果在描述主题时设置，则仅显示其leader不可用的分区

under-min-isr-partitions

    如果在描述主题时设置，则仅显示isr计数 < 配置的最小值的分区。

at-min-isr-partitions

    如果在描述主题时设置，则仅显示isr计数 = 配置的最小值的分区        

topics-with-overrides

    如果在描述主题时设置，则仅显示已覆盖配置的topic

if-exists

    如果在更改、删除或描述主题时设置，则仅当主题存在时才会执行该操作

if-not-exists

    如果在创建主题时设置，则仅当主题不存在时才会执行该操作。

exclude-internal

    运行list或describe命令时排除内部topic。默认情况下，内部topic将被列出

partition-size-limit-per-response

    一个DescribeTopicPartitions响应中包含的最大分区大小

五、AdminClient

从第二步的源码中看到最终将topic的创建交给了AdminClient来完成，下面我们继续往下分析

1、创建

在TopicService的构造方法中创建的AdminClient

它是Kafka的管理客户端，支持管理和检查topic、broker、配置和ACL。

AdminClient的创建用到了bootstrap.servers，它里面有连接KafkaServer的host:port列表。

bootstrap.servers配置仅用于发现群集中的broker，然后AdminClient将根据需要连接到这些broker。因此，只包括两个或三个经纪人地址就足以应对broker不可用的风险。

TopicService topicService = new TopicService(opts.commandConfig(), opts.bootstrapServer());

    public static class TopicService implements AutoCloseable {
        private final Admin adminClient;
        public TopicService(Properties commandConfig, Optional<String> bootstrapServer) {
            this.adminClient = createAdminClient(commandConfig, bootstrapServer);
        }
        private static Admin createAdminClient(Properties commandConfig, Optional<String> bootstrapServer) {
            if (bootstrapServer.isPresent()) {
                commandConfig.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServer.get());
            }
            return Admin.create(commandConfig);
        }
    }

2、交由子类KafkaAdminClient处理

public class KafkaAdminClient extends AdminClient {
    private final AdminClientRunnable runnable;
    //创建一批topic
    public CreateTopicsResult createTopics(final Collection<NewTopic> newTopics,
                                           final CreateTopicsOptions options) {
        final Map<String, KafkaFutureImpl<TopicMetadataAndConfig>> topicFutures = new HashMap<>(newTopics.size());
        final CreatableTopicCollection topics = new CreatableTopicCollection();
        for (NewTopic newTopic : newTopics) {
            //判断名字是否符合规范
            if (topicNameIsUnrepresentable(newTopic.name())) {
                KafkaFutureImpl<TopicMetadataAndConfig> future = new KafkaFutureImpl<>();
                future.completeExceptionally(new InvalidTopicException("The given topic name '" +
                    newTopic.name() + "' cannot be represented in a request."));
                topicFutures.put(newTopic.name(), future);
            } else if (!topicFutures.containsKey(newTopic.name())) {
                //topicFutures 装的是还没有创建的 topicname
                topicFutures.put(newTopic.name(), new KafkaFutureImpl<>());
                topics.add(newTopic.convertToCreatableTopic());
            }
        }
        if (!topics.isEmpty()) {
            final long now = time.milliseconds();
            final long deadline = calcDeadlineMs(now, options.timeoutMs());
            //里面封装了 ApiKeys.CREATE_TOPICS 请求
            final Call call = getCreateTopicsCall(options, topicFutures, topics,
                Collections.emptyMap(), now, deadline);
            //实现了Runnable接口
            runnable.call(call, now);
        }
        return new CreateTopicsResult(new HashMap<>(topicFutures));
    }
}

从这里我们看到，这里会用一个线程向broker发送ApiKeys.CREATE_TOPICS 请求。下面我们来看broker端怎么处理topics的创建请求的。按照我们之前的经验，要去看KafkaApis中对应ApiKeys.CREATE_TOPICS的处理逻辑

class KafkaApis(...）{
      request.header.apiKey match {
        //....
        case ApiKeys.CREATE_TOPICS => maybeForwardToController(request, handleCreateTopicsRequest)
        case ApiKeys.DELETE_TOPICS => maybeForwardToController(request, handleDeleteTopicsRequest)
        case ApiKeys.CREATE_ACLS => maybeForwardToController(request, handleCreateAcls)
        case ApiKeys.DELETE_ACLS => maybeForwardToController(request, handleDeleteAcls)
        case ApiKeys.CREATE_PARTITIONS => maybeForwardToController(request, handleCreatePartitionsRequest)
        case ApiKeys.ELECT_LEADERS => maybeForwardToController(request, handleElectLeaders)
        //.....
      }
}

六、CREATE_TOPICS的处理逻辑

从KafkaApi中我们看到很多请求都调用了maybeForwardToController()方法来处理，但是传入的参数不同，从名称上我们可以猜测这些请求可能交由Controller来处理，回想下《Kafka-Controller角色需要做什么？》中当一个broker当选为Controller时第一件事就是注册监听器，去监听broker改变、topic改变、topic删除、isr改变等，并分别准备好了响应的处理逻辑。因此这里只要让topic发生改变就可以自动触发让Controller处理了。下面看下handleCreateTopicsRequest()中都做了什么？

1、获取ZooKeeper

val zkSupport = metadataSupport.requireZkOrThrow(KafkaApis.shouldAlwaysForward(request))

2、判断集群当下是否有Controller

如果集群当下没有Controller，直接向客户端返回Errors.NOT_CONTROLLER错误。我们按照集群当下有Controller继续分析。

    if (!zkSupport.controller.isActive) {
      //如果没有contorller，直接向客户端发送响应信息（集群当下没有controller），且这个时候时创建不了topic的，
      createTopicsRequest.data.topics.forEach { topic =>
        results.add(new CreatableTopicResult().setName(topic.name)
          .setErrorCode(Errors.NOT_CONTROLLER.code))
      }
      sendResponseCallback(results)
    } else {
      //正常逻辑
    }

3、检查topic名称

集群元数据topic是一个具有不同实现的内部topic。不应允许用户创建同名的topic。

          if (topicNames.contains(Topic.CLUSTER_METADATA_TOPIC_NAME)) {
            //拒绝创建内部主题  __cluster_metadata
            info(s"Rejecting creation of internal topic ${Topic.CLUSTER_METADATA_TOPIC_NAME}")
          }
          topicNames.diff(Set(Topic.CLUSTER_METADATA_TOPIC_NAME))

4、调用ZkAdminManager创建topic

      zkSupport.adminManager.createTopics(
        createTopicsRequest.data.timeoutMs,
        createTopicsRequest.data.validateOnly,
        toCreate,
        authorizedForDescribeConfigs,
        controllerMutationQuota,
        handleCreateTopicsResults)
    }

1、循环校验每个topic是否符合规则

1、topic是否已经存在

2、topic是否为null

3、numPartitions或replicationFactor和replicasAssignments都已设置。两者不能同时使用

2、确定分区分配列表

如果用户指定了列表，那么就直接用用户的，否则使用Kafka自己的分配策略（下篇博客分析）

        val assignments = if (topic.assignments.isEmpty) {
          CoreUtils.replicaToBrokerAssignmentAsScala(AdminUtils.assignReplicasToBrokers(
            brokers.asJavaCollection, resolvedNumPartitions, resolvedReplicationFactor))
        } else {
          val assignments = new mutable.HashMap[Int, Seq[Int]]
          //注意：我们不会检查replicaAssignment是否包含未知的代理——与添加分区的情况不同，这遵循TopicCommand中的现有逻辑
          topic.assignments.forEach { assignment =>
            assignments(assignment.partitionIndex) = assignment.brokerIds.asScala.map(a => a: Int)
          }
          assignments
        }

3、topics目录下创建指定的topic

//ConfigType.TOPIC : topics 目录
//topic ：要创建的topic名称
zkClient.setOrCreateEntityConfigs(ConfigType.TOPIC, topic, config)

4、topic目录下创建分区目录和对应信息

    writeTopicPartitionAssignment(topic, partitionReplicaAssignment.map { case (k, v) => k -> ReplicaAssignment(v) },isUpdate = false, usesTopicId)

5、创建对应的元数据

CreatePartitionsMetadata(topic.name, assignments.keySet)

七、Controller端处理逻辑

我们找到TopicChange对应的处理逻辑

  override def process(event: ControllerEvent): Unit = {
    try {
      event match {
        case TopicChange =>
          processTopicChange()
        //......
      }
    }
  }
  private def processTopicChange(): Unit = {
    if (!isActive) return
      //从 brokers/topics/目录下获取所有的topic
    val topics = zkClient.getAllTopicsInCluster(true)
    //从controllerContext 获取当下缓存中所有的 topic
    //两者相减获取 新增加的 topic
    val newTopics = topics -- controllerContext.allTopics
    // 获取删除的topic （既topics目录没有，但是缓存中有）
    val deletedTopics = controllerContext.allTopics.diff(topics)
    //设置新的topic到缓存
    controllerContext.setAllTopics(topics)
    //检测zk中 每个topic 目录的变化
    registerPartitionModificationsHandlers(newTopics.toSeq)
    //现在要添加分区和副本了，也就是从topic下获取 topic_id、adding_replicas、removing_replicas、partitions 信息
    val addedPartitionReplicaAssignment = zkClient.getReplicaAssignmentAndTopicIdForTopics(newTopics)
    deletedTopics.foreach(controllerContext.removeTopic)
    processTopicIds(addedPartitionReplicaAssignment)
    addedPartitionReplicaAssignment.foreach { case TopicIdReplicaAssignment(_, _, newAssignments) =>
      newAssignments.foreach { case (topicAndPartition, newReplicaAssignment) =>
        //controllerContext 的缓存中 更新分区、副本、leder信息
        controllerContext.updatePartitionFullReplicaAssignment(topicAndPartition, newReplicaAssignment)
      }
    }
    info(s"New topics: [$newTopics], deleted topics: [$deletedTopics], new partition replica assignment " +
      s"[$addedPartitionReplicaAssignment]")
    if (addedPartitionReplicaAssignment.nonEmpty) {
      val partitionAssignments = addedPartitionReplicaAssignment
        .map { case TopicIdReplicaAssignment(_, _, partitionsReplicas) => partitionsReplicas.keySet }
        .reduce((s1, s2) => s1.union(s2))
      //更高topic下的分区、副本为可用状态 OnlineReplica
      //此时 往topic 生产数据就ok了 
      onNewPartitionCreation(partitionAssignments)
    }
  }

从源码中我们可以看到，Controller这端会不断的将新的topic以及其下的topic_id、adding_replicas、removing_replicas、partitions 信息加载到缓存，并使用它们的状态机将它们更新至可用状态。并剔除掉删除的topic。始终保持，当向topic生产数据时，它这里都时最新的状态。