import kafka.admin.AdminClient; //导入依赖的package包/类
private static void ensureStreamsApplicationDown(final String kafka) {
    AdminClient adminClient = null;
    try {
        adminClient = AdminClient.createSimplePlaintext(kafka);

        final long maxWaitTime = System.currentTimeMillis() + MAX_IDLE_TIME_MS;
        while (!adminClient.describeConsumerGroup(EosTestClient.APP_ID, 10000).consumers().get().isEmpty()) {
            if (System.currentTimeMillis() > maxWaitTime) {
                throw new RuntimeException("Streams application not down after 30 seconds.");
            }
            sleep(1000);
        }
    } finally {
        if (adminClient != null) {
            adminClient.close();
        }
    }
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
/**
 * Creates and connects a new KafkaAdminClient
 * @param zkConnect The zk connect string
 * @param sessionTimeout The session timeout
 * @param connectionTimeout The connection timeout
 */
private KafkaAdminClient(final String zkConnect, final int sessionTimeout, final int connectionTimeout) {
	this.zkConnect = zkConnect;
	this.sessionTimeout = sessionTimeout;
	this.connectionTimeout = connectionTimeout;
	zkClient = new ZkClient(
			zkConnect,
			this.sessionTimeout,
			this.connectionTimeout,
		    ZKStringSerializer$.MODULE$);
	zkConnection = new ZkConnection(zkConnect, DEFAULT_SESSION_TIMEOUT);
	zkConnection.connect(this);
	zkUtils = new ZkUtils(zkClient, zkConnection, false);
	final String endPoint = findEndpoint(zkConnection);
	adminClient = endPoint==null ? null : AdminClient.createSimplePlaintext(endPoint);
	
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
public ImmutableList<KafkaConsumerInfo> getAllConsumers() {
    ImmutableList<GroupOverview> consumerGroups =
            ImmutableList.copyOf(JavaConversions.asJavaCollection(adminClient.listAllConsumerGroupsFlattened()));

    ImmutableList.Builder<KafkaConsumerInfo> consumers = ImmutableList.builder();

    consumerGroups.stream()
            .filter(groupOverview -> !groupOverview.groupId().equals(KafkaStatics.GROUP_ID))
            .forEach(consumerGroup -> {
                AdminClient.ConsumerGroupSummary consumerGroupSummary =
                        adminClient.describeConsumerGroup(consumerGroup.groupId(), Duration.ofSeconds(10).toMillis());

                if (!consumerGroupSummary.consumers().isDefined()) {
                    return;
                }

                ImmutableList<AdminClient.ConsumerSummary> consumerSummaries = ImmutableList.copyOf(
                        JavaConversions.asJavaCollection(consumerGroupSummary.consumers().get()));

                if (consumerSummaries.isEmpty()) {
                    return;
                }

                consumers.addAll(convertToKafkaConsumerInfos(consumerSummaries, consumerGroup.groupId()));
            });

    return consumers.build();
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
private ImmutableList<KafkaConsumerInfo> convertToKafkaConsumerInfos(ImmutableList<AdminClient.ConsumerSummary> consumerSummaries, String groupId) {
    return consumerSummaries.stream()
            .map(consumerSummary -> {
                ImmutableList<KafkaConsumerInfo.Assignment> assignments = JavaConversions.asJavaCollection(consumerSummary.assignment())
                        .stream()
                        .map(assignment -> new KafkaConsumerInfo.Assignment(assignment.topic(), assignment.partition()))
                        .collect(ImmutableList.toImmutableList());

                return new KafkaConsumerInfo(consumerSummary.consumerId(), consumerSummary.clientId(), assignments, groupId);
            })
            .collect(ImmutableList.toImmutableList());
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
@Before
public void cleanup() throws Exception {
    ++testNo;

    if (adminClient == null) {
        adminClient = AdminClient.createSimplePlaintext(CLUSTER.bootstrapServers());
    }

    // busy wait until cluster (ie, ConsumerGroupCoordinator) is available
    while (true) {
        Thread.sleep(50);

        try {
            TestUtils.waitForCondition(consumerGroupInactive, TIMEOUT_MULTIPLIER * CLEANUP_CONSUMER_TIMEOUT,
                    "Test consumer group active even after waiting " + (TIMEOUT_MULTIPLIER * CLEANUP_CONSUMER_TIMEOUT) + " ms.");
        } catch (final TimeoutException e) {
            continue;
        }
        break;
    }

    prepareInputData();
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
@Bean(destroyMethod = "close")
public AdminClient adminClient(CommandLineArgs commandLineArgs) {
    return AdminClient.createSimplePlaintext(commandLineArgs.kafkaServers);
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
@Bean
public KafkaUtils kafkaAdmin(ZkClient zkClient, AdminClient adminClient) {
    return new KafkaUtils(zkClient, adminClient);
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
public KafkaUtils(ZkClient zkClient, AdminClient adminClient) {
    this.zkClient = zkClient;
    this.adminClient = adminClient;
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
public KafkaConsumerCommand(String bootstrapServer) {
    this.bootstrapServer = bootstrapServer;
    Properties props = new Properties();
    props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, bootstrapServer);
    adminClient = AdminClient.create(props);
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
public int run(final String[] args, final Properties config) {
    consumerConfig.clear();
    consumerConfig.putAll(config);

    int exitCode = EXIT_CODE_SUCCESS;

    AdminClient adminClient = null;
    ZkUtils zkUtils = null;
    try {
        parseArguments(args);
        dryRun = options.has(dryRunOption);

        adminClient = AdminClient.createSimplePlaintext(options.valueOf(bootstrapServerOption));
        final String groupId = options.valueOf(applicationIdOption);


        zkUtils = ZkUtils.apply(options.valueOf(zookeeperOption),
            30000,
            30000,
            JaasUtils.isZkSecurityEnabled());

        allTopics.clear();
        allTopics.addAll(scala.collection.JavaConversions.seqAsJavaList(zkUtils.getAllTopics()));


        if (!adminClient.describeConsumerGroup(groupId, 0).consumers().get().isEmpty()) {
            throw new IllegalStateException("Consumer group '" + groupId + "' is still active. " +
                        "Make sure to stop all running application instances before running the reset tool.");
        }

        if (dryRun) {
            System.out.println("----Dry run displays the actions which will be performed when running Streams Reset Tool----");
        }
        maybeResetInputAndSeekToEndIntermediateTopicOffsets();
        maybeDeleteInternalTopics(zkUtils);

    } catch (final Throwable e) {
        exitCode = EXIT_CODE_ERROR;
        System.err.println("ERROR: " + e.getMessage());
    } finally {
        if (adminClient != null) {
            adminClient.close();
        }
        if (zkUtils != null) {
            zkUtils.close();
        }
    }

    return exitCode;
}
 

import kafka.admin.AdminClient; //导入依赖的package包/类
public KafkaConsumerCommand(String bootstrapServer) {
	this.bootstrapServer = bootstrapServer;
	Properties props = new Properties();
	props.put(CommonClientConfigs.BOOTSTRAP_SERVERS_CONFIG, bootstrapServer);
	adminClient = AdminClient.create(props);
}