import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
private List<ConfigItem> describeResource(final ConfigResource configResource) {
    final DescribeConfigsResult result = adminClient.describeConfigs(Collections.singleton(configResource));

    final List<ConfigItem> configItems = new ArrayList<>();

    try {
        final Map<ConfigResource, Config> configMap = result.all().get();

        final Config config = configMap.get(configResource);
        for (final ConfigEntry configEntry : config.entries()) {
            // Skip sensitive entries
            if (configEntry.isSensitive()) {
                continue;
            }
            configItems.add(
                new ConfigItem(configEntry.name(), configEntry.value(), configEntry.isDefault())
            );
        }
        return configItems;
    } catch (InterruptedException | ExecutionException e) {
        // TODO Handle this
        throw new RuntimeException(e.getMessage(), e);
    }
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Return a future which succeeds only if all the config descriptions succeed.
 */
public KafkaFuture<Map<ConfigResource, Config>> all() {
    return KafkaFuture.allOf(futures.values().toArray(new KafkaFuture[0])).
            thenApply(new KafkaFuture.Function<Void, Map<ConfigResource, Config>>() {
                @Override
                public Map<ConfigResource, Config> apply(Void v) {
                    Map<ConfigResource, Config> configs = new HashMap<>(futures.size());
                    for (Map.Entry<ConfigResource, KafkaFuture<Config>> entry : futures.entrySet()) {
                        try {
                            configs.put(entry.getKey(), entry.getValue().get());
                        } catch (InterruptedException | ExecutionException e) {
                            // This should be unreachable, because allOf ensured that all the futures
                            // completed successfully.
                            throw new RuntimeException(e);
                        }
                    }
                    return configs;
                }
            });
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
private Resource configResourceToResource(ConfigResource configResource) {
    ResourceType resourceType;
    switch (configResource.type()) {
        case TOPIC:
            resourceType = ResourceType.TOPIC;
            break;
        case BROKER:
            resourceType = ResourceType.BROKER;
            break;
        default:
            throw new IllegalArgumentException("Unexpected resource type " + configResource.type());
    }
    return new Resource(resourceType, configResource.name());
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
private void init() {
  try {
    DescribeClusterResult describeClusterResult = adminClient.describeCluster();
    List<Node> nodes = new ArrayList<>(describeClusterResult.nodes().get());
    if (!nodes.isEmpty()) {
      ConfigResource resource = new ConfigResource(ConfigResource.Type.BROKER,
                                                   String.valueOf(nodes.get(0).id()));
      DescribeConfigsResult
          describeConfigsResult = adminClient.describeConfigs(Collections.singleton(resource));
      Map<ConfigResource, Config> config = describeConfigsResult.all().get();

      this.isDeleteTopicEnabled = config.get(resource)
          .entries()
          .stream()
          .anyMatch(configEntry -> configEntry.name().equalsIgnoreCase("delete.topic.enable")
                                   && configEntry.value().equalsIgnoreCase("true"));


    } else {
      log.warn("No available broker found to fetch config info.");
      throw new KsqlException("Could not fetch broker information. KSQL cannot initialize "
                              + "AdminCLient.");
    }
  } catch (InterruptedException | ExecutionException ex) {
    log.error("Failed to initialize TopicClient: {}", ex.getMessage());
    throw new KsqlException("Could not fetch broker information. KSQL cannot initialize "
                            + "AdminCLient.");
  }
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
private DescribeConfigsResult getDescribeConfigsResult() {
  DescribeConfigsResult describeConfigsResult = mock(DescribeConfigsResult.class);
  ConfigEntry configEntry = new ConfigEntry("delete.topic.enable", "true");
  Map<ConfigResource, Config> config = new HashMap<>();
  config.put(new ConfigResource(ConfigResource.Type.BROKER, "1"), new Config
      (Collections.singletonList(configEntry)));
  expect(describeConfigsResult.all()).andReturn(KafkaFuture.completedFuture(config));
  replay(describeConfigsResult);
  return describeConfigsResult;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Get the configuration for topic.
 */
public TopicConfig getTopicConfig(final String topic) {
    final ConfigResource configResource = new ConfigResource(ConfigResource.Type.TOPIC, topic);
    return new TopicConfig(describeResource(configResource));
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Get the configuration for topic.
 */
public BrokerConfig getBrokerConfig(final String brokerId) {
    final ConfigResource configResource = new ConfigResource(ConfigResource.Type.BROKER, brokerId);
    return new BrokerConfig(describeResource(configResource));
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
AlterConfigsResult(Map<ConfigResource, KafkaFuture<Void>> futures) {
    this.futures = futures;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Return a map from resources to futures which can be used to check the status of the operation on each resource.
 */
public Map<ConfigResource, KafkaFuture<Void>> values() {
    return futures;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
DescribeConfigsResult(Map<ConfigResource, KafkaFuture<Config>> futures) {
    this.futures = futures;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
public ConfigResource resource() {
    return resource;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Get the configuration for the specified resources with the default options.
 *
 * See {@link #describeConfigs(Collection, DescribeConfigsOptions)} for more details.
  *
  * This operation is supported by brokers with version 0.11.0.0 or higher.
 *
 * @param resources         The resources (topic and broker resource types are currently supported)
 * @return                  The DescribeConfigsResult
 */
public DescribeConfigsResult describeConfigs(Collection<ConfigResource> resources) {
    return describeConfigs(resources, new DescribeConfigsOptions());
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Update the configuration for the specified resources with the default options.
 *
 * See {@link #alterConfigs(Map, AlterConfigsOptions)} for more details.
 *
 * This operation is supported by brokers with version 0.11.0.0 or higher.
 *
 * @param configs         The resources with their configs (topic is the only resource type with configs that can
 *                        be updated currently)
 * @return                The AlterConfigsResult
 */
public AlterConfigsResult alterConfigs(Map<ConfigResource, Config> configs) {
    return alterConfigs(configs, new AlterConfigsOptions());
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Return a map from resources to futures which can be used to check the status of the configuration for each
 * resource.
 */
public Map<ConfigResource, KafkaFuture<Config>> values() {
    return futures;
}
 

import org.apache.kafka.common.config.ConfigResource; //导入依赖的package包/类
/**
 * Create an instance of this class with the provided parameters.
 *
 * This constructor is public to make testing of <code>AlterConfigPolicy</code> implementations easier.
 */
public RequestMetadata(ConfigResource resource, Map<String, String> configs) {
    this.resource = resource;
    this.configs = configs;
}