Java KafkaServerStartable类代码示例

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public KafkaSourceEmbeddedKafka(Properties properties) {
  zookeeper = new KafkaSourceEmbeddedZookeeper(zkPort);
  dir = new File(System.getProperty("java.io.tmpdir"), "kafka_log-" + UUID.randomUUID());
  try {
    FileUtils.deleteDirectory(dir);
  } catch (IOException e) {
    e.printStackTrace();
  }
  Properties props = new Properties();
  props.put("zookeeper.connect",zookeeper.getConnectString());
  props.put("broker.id","1");
  props.put("host.name", "localhost");
  props.put("port", String.valueOf(serverPort));
  props.put("log.dir", dir.getAbsolutePath());
  if (properties != null) {
    props.putAll(properties);
  }
  KafkaConfig config = new KafkaConfig(props);
  kafkaServer = new KafkaServerStartable(config);
  kafkaServer.startup();
  initProducer();
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
private void startKafkaServers() throws IOException {
    for (int i = 0; i < numberOfKafkaBrokers; i++) {
        int port = BASE_KAFKA_PORT + i;
        File logDir = folder.newFolder("kafka-local-" + i);

        Properties properties = new Properties();
        properties.setProperty("zookeeper.connect", String.format("%s:%s", LOCALHOST, ZOOKEEPER_PORT));
        properties.setProperty("broker.id", String.valueOf(i + 1));
        properties.setProperty("host.name", LOCALHOST);
        properties.setProperty("port", Integer.toString(port));
        properties.setProperty("log.dir", logDir.getAbsolutePath());
        properties.setProperty("log.flush.interval.messages", String.valueOf(1));

        KafkaServerStartable broker = startBroker(properties);
        brokers.add(broker);
    }
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
private void startKafkaServers() throws IOException {
    for (int i = 0; i < numberOfKafkaBrokers; i++) {
        int port = kafkaPort + i;
        File logDir = folder.mkSubDir(String.format("kafka-local-%s-%s", kafkaPort, i));

        Properties properties = new Properties();
        properties.setProperty(KafkaConfig.ZkConnectProp(), String.format("%s:%s", LOCALHOST, zookeeperPort));
        properties.setProperty(KafkaConfig.BrokerIdProp(), String.valueOf(i + 1));
        properties.setProperty(KafkaConfig.ListenersProp(), String.format("PLAINTEXT://%s:%s", LOCALHOST, port));
        properties.setProperty(KafkaConfig.LogDirProp(), logDir.getAbsolutePath());
        properties.setProperty(KafkaConfig.LogFlushIntervalMessagesProp(), String.valueOf(1));
        properties.setProperty(KafkaConfig.LogFlushIntervalMsProp(), String.valueOf(Long.MAX_VALUE));
        properties.setProperty(KafkaConfig.ControlledShutdownEnableProp(), String.valueOf(false));
        properties.setProperty(KafkaConfig.DeleteTopicEnableProp(), String.valueOf(true));
        properties.setProperty(KafkaConfig.NumPartitionsProp(), String.valueOf(numberOfKafkaBrokers));

        KafkaServerStartable broker = startBroker(properties);
        brokers.add(broker);
    }
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
private void startKafkaServers() throws IOException {
    for (int i = 0; i < numberOfKafkaBrokers; i++) {
        int port = kafkaPort + i;
        File logDir = folder.newFolder(String.format("kafka-local-%s-%s", kafkaPort, i));

        Properties properties = new Properties();
        properties.setProperty("zookeeper.connect", String.format("%s:%s", LOCALHOST, zookeeperPort));
        properties.setProperty("broker.id", String.valueOf(i + 1));
        properties.setProperty("host.name", LOCALHOST);
        properties.setProperty("port", Integer.toString(port));
        properties.setProperty("log.dir", logDir.getAbsolutePath());
        properties.setProperty("log.flush.interval.messages", String.valueOf(1));
        properties.setProperty("log.retention.ms", String.valueOf(Long.MAX_VALUE));
        properties.setProperty("controlled.shutdown.enable", String.valueOf(false));
        properties.setProperty("delete.topic.enable", String.valueOf(true));
        properties.setProperty("num.partitions", String.valueOf(numberOfKafkaBrokers));

        KafkaServerStartable broker = startBroker(properties);
        brokers.add(broker);
    }
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
/**
 * Starts the Kafka broker.
 *
 * @throws IOException if an error occurs during initialization
 */
public synchronized void start() throws IOException {
  log.info("Starting Kafka broker on port {}", port);

  logsDir = Files.createTempDirectory(LocalKafkaBroker.class.getSimpleName());
  logsDir.toFile().deleteOnExit();

  kafkaServer = new KafkaServerStartable(new KafkaConfig(ConfigUtils.keyValueToProperties(
      "broker.id", TEST_BROKER_ID,
      "log.dirs", logsDir.toAbsolutePath(),
      "listeners", "PLAINTEXT://:" + port,
      "zookeeper.connect", "localhost:" + zkPort,
      // Above are for Kafka 0.8; following are for 0.9+
      "message.max.bytes", 1 << 26,
      "replica.fetch.max.bytes", 1 << 26
  ), false));
  kafkaServer.startup();
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public static KafkaServerStartable startServer(final int port, final int brokerId,
    final String zkStr, final Properties configuration) {
  // Create the ZK nodes for Kafka, if needed
  int indexOfFirstSlash = zkStr.indexOf('/');
  if (indexOfFirstSlash != -1) {
    String bareZkUrl = zkStr.substring(0, indexOfFirstSlash);
    String zkNodePath = zkStr.substring(indexOfFirstSlash);
    ZkClient client = new ZkClient(bareZkUrl);
    client.createPersistent(zkNodePath, true);
    client.close();
  }

  File logDir = new File("/tmp/kafka-" + Double.toHexString(Math.random()));
  logDir.mkdirs();

  configureKafkaPort(configuration, port);
  configureZkConnectionString(configuration, zkStr);
  configureBrokerId(configuration, brokerId);
  configureKafkaLogDirectory(configuration, logDir);
  KafkaConfig config = new KafkaConfig(configuration);

  KafkaServerStartable serverStartable = new KafkaServerStartable(config);
  serverStartable.startup();

  return serverStartable;
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
private void startKafka() throws InterruptedException {
    startInNewThread(() -> {
        try {
            String kafkaConfig = TestServerManager.class.getClassLoader().getResource("server.properties").getPath();
            logger.debug("Starting Kafka server using config:" + kafkaConfig);
            String[] kafkaArgs = {kafkaConfig};
            Properties serverProps = Kafka.getPropsFromArgs(kafkaArgs);
            KafkaServerStartable kafkaServerStartable = KafkaServerStartable.fromProps(serverProps);
            Runtime.getRuntime().addShutdownHook(new Thread() {
                public void run() {
                    kafkaServerStartable.shutdown();
                }
            });
            kafkaServerStartable.startup();
        } catch (RuntimeException ex) {
            logger.error("Failed to start kafka", ex);
            throw ex;
        }
    }, "Kafka").join();
    logger.debug("Kafka started.");
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public void startup() {
  for (int i = 0; i < ports.size(); i++) {
    Integer port = ports.get(i);
    File logDir = TestUtils.constructTempDir("kafka-local");

    Properties properties = new Properties();
    properties.putAll(baseProperties);
    properties.setProperty("zookeeper.connect", zkConnection);
    properties.setProperty("broker.id", String.valueOf(i + 1));
    properties.setProperty("advertised.host.name", "127.0.0.1");
    properties.setProperty("host.name", "127.0.0.1");
    properties.setProperty("advertised.port", Integer.toString(port));
    properties.setProperty("port", Integer.toString(port));
    properties.setProperty("log.dirs", logDir.getAbsolutePath());
    properties.setProperty("offsets.topic.num.partitions", "1");
    properties.setProperty("offsets.topic.replication.factor", "1");
    properties.setProperty("log.flush.interval.messages", String.valueOf(1));

    KafkaServerStartable broker = startBroker(properties);

    brokers.add(broker);
    logDirs.add(logDir);
  }
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public static KafkaServerStartable startServer(final int port, final int brokerId, final String zkStr,
    final Properties configuration) {
  // Create the ZK nodes for Kafka, if needed
  int indexOfFirstSlash = zkStr.indexOf('/');
  if (indexOfFirstSlash != -1) {
    String bareZkUrl = zkStr.substring(0, indexOfFirstSlash);
    String zkNodePath = zkStr.substring(indexOfFirstSlash);
    ZkClient client = new ZkClient(bareZkUrl);
    client.createPersistent(zkNodePath, true);
    client.close();
  }

  File logDir = new File("/tmp/kafka-" + Double.toHexString(Math.random()));
  logDir.mkdirs();

  configureKafkaPort(configuration, port);
  configureZkConnectionString(configuration, zkStr);
  configureBrokerId(configuration, brokerId);
  configureKafkaLogDirectory(configuration, logDir);
  KafkaConfig config = new KafkaConfig(configuration);

  KafkaServerStartable serverStartable = new KafkaServerStartable(config);
  serverStartable.startup();

  return serverStartable;
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public void startKafkaServer(int clusterid, int brokerid, int defaultPartitions)
{
  // before start, clean the kafka dir if it exists
  FileUtils.deleteQuietly(new File(baseDir, kafkaBaseDir));

  Properties props = new Properties();
  props.setProperty("broker.id", "" + brokerid);
  props.setProperty("log.dirs", new File(baseDir, kafkadir[clusterid][brokerid]).toString());
  props.setProperty("zookeeper.connect", "localhost:" + TEST_ZOOKEEPER_PORT[clusterid]);
  props.setProperty("port", "" + TEST_KAFKA_BROKER_PORT[clusterid][brokerid]);
  props.setProperty("default.replication.factor", "1");
  // set this to 50000 to boost the performance so most test data are in memory before flush to disk
  props.setProperty("log.flush.interval.messages", "50000");
  if (hasMultiPartition) {
    props.setProperty("num.partitions", "2");
  } else {
    props.setProperty("num.partitions", "1");
  }

  broker[clusterid][brokerid] = new KafkaServerStartable(new KafkaConfig(props));
  broker[clusterid][brokerid].startup();

}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public static KafkaServerStartable startServer(final int port, final int brokerId, final String zkStr,
    final Properties configuration) {
  // Create the ZK nodes for Kafka, if needed
  int indexOfFirstSlash = zkStr.indexOf('/');
  if (indexOfFirstSlash != -1) {
    String bareZkUrl = zkStr.substring(0, indexOfFirstSlash);
    String zkNodePath = zkStr.substring(indexOfFirstSlash);
    ZkClient client = new ZkClient(bareZkUrl);
    client.createPersistent(zkNodePath, true);
    client.close();
  }

  File logDir = new File("/tmp/kafka-" + Double.toHexString(Math.random()));
  logDir.mkdirs();

  configuration.put("port", Integer.toString(port));
  configuration.put("zookeeper.connect", zkStr);
  configuration.put("broker.id", Integer.toString(brokerId));
  configuration.put("log.dirs", logDir.getAbsolutePath());
  KafkaConfig config = new KafkaConfig(configuration);

  KafkaServerStartable serverStartable = new KafkaServerStartable(config);
  serverStartable.startup();

  return serverStartable;
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public TestKafkaServer(Properties properties) {
	String path = properties.getProperty("log.dir");
	locate = Files.createTempDir();
	File dir = new File(locate, path).getAbsoluteFile();
	properties.setProperty("log.dir", dir.getAbsolutePath());

	kafkaConfig = new KafkaConfig(properties);
	System.out.println("num.partitions =" + kafkaConfig.numPartitions());
	System.out.println("background.threads ="
			+ kafkaConfig.backgroundThreads());
	kafkaServer = new KafkaServerStartable(kafkaConfig);
	try {
		kafkaServer.startup();
	} catch (Exception e) {
		e.printStackTrace();
	}
	System.out.println("embedded kafka is up");
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
private void setupKafkaBroker() {
    try {
        // mock zookeeper
        zkTestServer = new TestingServer(2181);
        // mock kafka
        Properties props = new Properties();
        props.put("broker.id", "0");
        props.put("host.name", "localhost");
        props.put("port", "9092");
        props.put("log.dir", "/tmp/tmp_kafka_dir");
        props.put("zookeeper.connect", zkTestServer.getConnectString());
        props.put("replica.socket.timeout.ms", "1500");
        KafkaConfig config = new KafkaConfig(props);
        kafkaServer = new KafkaServerStartable(config);
        kafkaServer.startup();

        // create "sensordata" topic
        ZkClient zkClient = new ZkClient(zkTestServer.getConnectString(), 10000, 10000, ZKStringSerializer$.MODULE$);
        AdminUtils.createTopic(zkClient, "sensordata", 1, 1, new Properties());
        zkClient.close();
    } catch (Exception e) {
        log.error("Error running local Kafka broker / Zookeeper", e);
    }
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
EmbeddedKafka(EmbeddedZookeeper zookeeper, int kafkaPort) throws IOException {
  this.zookeeper = checkNotNull(zookeeper, "zookeeper is null");

  this.port = kafkaPort;
  this.kafkaDataDir = Files.createTempDir();

  Properties properties = new Properties();
  properties.setProperty("broker.id", "0");
  properties.setProperty("host.name", "localhost");
  properties.setProperty("num.partitions", "2");
  properties.setProperty("log.flush.interval.messages", "10000");
  properties.setProperty("log.flush.interval.ms", "1000");
  properties.setProperty("log.retention.minutes", "60");
  properties.setProperty("log.segment.bytes", "1048576");
  properties.setProperty("auto.create.topics.enable", "false");
  properties.setProperty("zookeeper.connection.timeout.ms", "1000000");
  properties.setProperty("port", Integer.toString(port));
  properties.setProperty("log.dirs", kafkaDataDir.getAbsolutePath());
  properties.setProperty("zookeeper.connect", zookeeper.getConnectString());

  KafkaConfig config = new KafkaConfig(properties);
  this.kafka = new KafkaServerStartable(config);
}
 

import kafka.server.KafkaServerStartable; //导入依赖的package包/类
public LocalKafkaServer() throws IOException {

		while (new File(logDir).exists()) {
			FileUtils.deleteDirectory(new File(logDir));
		}

		Properties props = new Properties();
		props.put("broker.id", nodeId);
		props.put("port", port);
		props.put("log.dir", logDir);
		props.put("zookeeper.connect", zkConnect);
		props.put("host.name", "127.0.0.1");
		KafkaConfig conf = new KafkaConfig(props);

                zkUtils = ZkUtils.apply(props.getProperty("zookeeper.connect"),
                          30000,
                          30000,
                          JaasUtils.isZkSecurityEnabled());


		server = new KafkaServerStartable(conf);
		server.startup();
	}