安装kafka到window上,编写kafka java客户端连接kafka

最近想测试一下kafka的性能，折腾了大半天才把kafka安装到window上。下文提供安装的整个过程，绝对是可用的完整的，同时提供完整的kafka java客户端代码，用于与kafka沟通。在这里必须吐槽一下，网上大部分关于如何把kafka安装到window上的文章，要么不完整，要么kafka客户端代码是错误的或者不是基于0.8版本的。但是必须提醒一下，这篇文章只是介绍了其中的一种安装方法，可能不是最简洁的。

1、软件准备

• kafka_2.9.1-0.8.2.1.tgz，需要到kafka官网下载。
• sbt-0.13.9.msi，需要到sbt官网下载下载。
• git bash 网上大把，我用的是Git-1.9.4-preview20140611.exe
• Eclipse
• Maven
• Java 7

2、kafka环境设置

2.1  切换到kafka目录

先解压kafka_2.9.1-0.8.2.1.tgz，例如解压到D:\sam.lin\software\kafka\kafka_2.9.1-0.8.2.1。使用git bash，切换到kafka目录下。例如：

kafka需要的一些组件可以使用sbt update命令得到，如下：

2.2 sbt update

敲打回车键后，会出现一个错误信息，"sbt: No such file or directory"，这个时候你需要安装sbt，下载网址我在上面的【软件准备】中已经提供了。本文下载的是sbt-0.13.9.msi这个版本。

sbt update命令会开始下载组件，如果是第一次安装，这个过程比较漫长，耐心等待吧。

当出现[success]字样时，说明安装组件成功了。

2.3 sbt package

如下图：

当出现[success]字样时，说明命令执行成功了。

2.4 sbt sbt-dependency

如下图：

当出现[info] org.scala-sbt:sbt:0.13.8，说明命令执行成功了。

到此，kafka环境搭建完毕。接下来需要搭建zookeeper.

3、zookeeper环境设置

注意，安装zookeeper的时候，在window上使用shell来安装是没法成功的，至少我尝试很多次都没成功。其实kafka已经为我们提供了在window安装zookeeper的bat脚本了，这些脚本存放在kafka安装目录中的bin/window上，如下：

注意在这里不能使用git bash了，原因是git bash执行bat文件时，会报语法错误。我们换成window的cmd命令行。

3.1 修改zookeeper和kafka的配置文件

  1) 修改config目录下的server.properties文件，修改

log.dirs=/D/sam.lin/software/kafka/kafka_2.9.1-0.8.2.1/kafka-logs

  2) 修改config目录下的log4j.properties文件,修改

log4j.appender.kafkaAppender.File=/D/sam.lin/software/kafka/kafka_2.9.1-0.8.2.1/logs/server.log

  3) 修改config目录下的zookeeper.properties文件，加入或者修改

dataDir=/D/sam.lin/software/kafka/kafka_2.9.1-0.8.2.1/data/zookeeper

3.2 使用window cmd命令行界面，切换到/bin/window目录

3.3 启动zookeeper

命令：zookeeper-server-start.bat ../../config/zookeeper.properties

启动成功后，不要关闭这个cmd命令行界面，因为关闭它，zookeeper进程就停了。

4、启动kafka broker

命令：kafka-server-start.bat ../../config/server.properties

启动成功后，不要关闭这个cmd命令行界面，因为关闭它，kafka进程就停了。

5、创建topic

命令：kafka-run-class.bat kafka.admin.TopicCommand --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic hellotest

这个命令创建了名字为"hellotest"的topic。

6、发送消息

    

命令：kafka-console-producer.bat --broker-list localhost:9092 --topic hellotest

注意这里的hellotest就是刚才创建的topic。这个命令执行后，可以直接在命令行后面输入你要发的消息。

后面的samsamsam就我输入的，往hellotest这个topic发送的消息。下面我们创建消费者来消费消息。

7、接收消息

命令：kafka-console-consumer.bat --zookeeper localhost:2181 --topic hellotest --from-beginning

同样的，必须指定到hellotest这个topic消费消息，我在生产者的cmd命令行界面中输入samsamsam后，消息者cmd命令行界面立刻接收到了。

8、使用kafka提供的java 客户端来发送和接收消息

上面提到可以使用kafka自带的命令行工具来发送消息和接收消息，下面介绍一下使用java发送和接收消息。

8.1 发送者

     

package com.kafka;

import java.util.Properties;

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;

public class Sender {

  public static void main(String[] args) {
    Properties prop = new Properties();
    prop.put("metadata.broker.list", "127.0.0.1:9092");
    prop.put("serializer.class", "kafka.serializer.StringEncoder");
    ProducerConfig producerConfig = new ProducerConfig(prop);
    Producer<String, String> producer = new<String, String> Producer(producerConfig);
    String topic = "hellotest";
    KeyedMessage<String, String> message = new<String, String> KeyedMessage(topic, "Sam Hello Test message2");
    producer.send(message);
    producer.close();
  }
}

8.2 消费者

代码一

package com.kafka;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import kafka.consumer.ConsumerConfig;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;

public class ConsumerDemo {

  private final ConsumerConnector consumer;
  private final String topic;
  private ExecutorService executor;

  public ConsumerDemo(String zookeeper, String groupid, String aTopic) {
    consumer = kafka.consumer.Consumer.createJavaConsumerConnector(ConsumerProps(zookeeper, groupid));
    this.topic = aTopic;
  }

  public void run(int threads) {
    Map<String, Integer> topicMap = new HashMap<String, Integer>();
    topicMap.put(topic, new Integer(threads));
    Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicMap);
    List<KafkaStream<byte[], byte[]>> streams = consumerMap.get(topic);

    executor = Executors.newFixedThreadPool(threads);

    int numThread = 0;

    for (final KafkaStream stream : streams) {
      executor.submit(new ConsumerDemoRun(stream, numThread));
      numThread++;
    }
  }

  private static ConsumerConfig ConsumerProps(String zookeeper, String groupid) {

    Properties properties = new Properties(); // config properties file

    properties.put("zookeeper.connect", zookeeper);
    properties.put("group.id", groupid);
    properties.put("zookeeper.session.timeout.ms", "400");
    properties.put("zookeeper.sync.time.ms", "200");
    properties.put("auto.commit.interval.ms", "1000");
    properties.put("auto.offset.reset", "smallest");

    return new ConsumerConfig(properties);
  }

  public void shutdown() {
    if (consumer != null)
      consumer.shutdown();
    if (executor != null)
      executor.shutdown();

    try {
      if (!executor.awaitTermination(5000, TimeUnit.MILLISECONDS)) {
        System.out.println("Timed out waiting for consumer threads to shut down, exiting uncleanly");
      }
    } catch (InterruptedException e) {
      System.out.println("Interrupted during shutdown, exiting uncleanly");
    }
  }

  public static void main(String[] args) {
    String zookeeper = "localhost:2181";
    String groupid = "group1";
    String topic = "hellotest";
    int threads = 1;

    ConsumerDemo test = new ConsumerDemo(zookeeper, groupid, topic);
    test.run(threads);

    try {
      Thread.sleep(10000);
    } catch (InterruptedException ie) {
    }

    test.shutdown();
  }
}

代码二

package com.kafka;

import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;

public class ConsumerDemoRun implements Runnable {
  private KafkaStream aStream;
  private int aThread;

  public ConsumerDemoRun(KafkaStream stream, int thread) {
    aStream = stream; // set stream from main read
    aThread = thread; // set thread from main read
  }

  public void run() {

    ConsumerIterator<byte[], byte[]> iterator = aStream.iterator(); // used to
                                                                    // check
                                                                    // throughout
                                                                    // the list
                                                                    // continiously

    while (iterator.hasNext()) {
      System.out.println("Thread " + aThread + ": " + new String(iterator.next().message()));
    }
    System.out.println("Shutting down Thread: " + aThread);

  }
}

要运行上面的代码，需要加入如下依赖

                 <dependency>
			<groupId>org.apache.kafka</groupId>
			<artifactId>kafka_2.9.2</artifactId>
			<version>0.8.2.1</version>
		</dependency>

总结：

在window上安装kafka还挺麻烦的，上面提供的安装方式比较繁琐，应该有更加简单的方式。目前还没找到。