我們先建立一個topic，然後啟動生產者和消費者，進行訊息通訊，然後在使用Kafka API程式設計的方式實現，筆者使用的ZK和Kafka都是單節點，你也可以使用叢集方式。

啟動Zookeeper

zkServer.sh start

啟動Kafka

kafka-server-start.sh $KAFKA_HOME/config/server.properties

建立topic

kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic kafka_api
 

檢視topic詳細資訊

[[email protected] ~]$ kafka-topics.sh --describe --zookeeper localhost:2181 --topic kafka_api
Topic:kafka_api PartitionCount:1    ReplicationFactor:1 Configs:
    Topic: kafka_api    Partition: 0    Leader: 0   Replicas: 0 Isr: 0

啟動生產者和消費者，測試訊息通訊

# 生產者
kafka-console-producer.sh
 
 --broker-list localhost:9092 --topic kafka_api

# 消費者
kafka-console-consumer.sh --zookeeper localhost:2181 --topic kafka_api

Java API 程式設計實現

1.建立maven專案，pom.xml中引入kafka依賴

<dependencies>
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId
 
>kafka_2.11</artifactId>
        <version>0.11.0.0</version>
    </dependency>
</dependencies>

2.建立KafkaProperties類，配置Kafka相關屬性

package com.bigdata.kafka;

/**
 * Kafka 相關屬性配置類
 */
public interface KafkaProperties {

    // zookeeper連線，與server.properties中的zookeeper.connect屬性一致，多個用逗號隔開，例如：zk01:2181,zk02:2181
    public static final String ZK = "Master:2181";

    // 如果是多個blocker，用逗號分隔即可，例如：kafka01::9092,kafka02:9093
    public static final String BLOCK_LIST = "Master:9092";

    // 主題
    public static final String TOPIC = "kafka_api";
}

3.Kafka Producer API 開發

生產者API中常用的類如下
Producer：生產者
ProducerConfig：生產者對應的配置
KeyedMessage：封裝的訊息物件

建立KafkaProducer類，程式碼如下

package com.bigdata.kafka;

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

import java.util.Properties;

/**
 * Kafka 生產者
 */
public class KafkaProducer extends Thread {

    private String topic;

    private Producer<Integer, String> producer;

    public KafkaProducer(String topic) {
        this.topic = topic;

        Properties properties = new Properties();
        properties.put("metadata.broker.list", KafkaProperties.BLOCK_LIST);
        properties.put("serializer.class", "kafka.serializer.StringEncoder");

        producer = new Producer<Integer, String>(new ProducerConfig(properties));
    }

    @Override
    public void run() {
        int messageNo = 1;

        while(true) {
            String message = "message_" + messageNo;

            System.out.println("Send：" + message);

            producer.send(new KeyedMessage<Integer, String>(topic, message));

            messageNo ++;

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        new KafkaProducer(KafkaProperties.TOPIC).start();
    }
}

執行上述程式碼，在控制檯中使用命令啟動一個消費者，觀察控制檯是否能接收到訊息

4.Kafka Consumer API 開發

消費者API中常用的類如下
Consumer：消費者
ConsumerConnector：消費者聯結器
ConsumerConfig：消費者對應的配置
KafkaStream：資料流

建立KafkaConsumer類，程式碼如下

package com.bigdata.kafka;

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

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

/**
 * Kafuka 消費者
 */
public class KafkaConsumer extends Thread{

    private String topic;

    public KafkaConsumer(String topic) {
        this.topic = topic;
    }

    private ConsumerConnector createConsumer() {
        Properties properties = new Properties();
        properties.setProperty("zookeeper.connect", KafkaProperties.ZK);
        properties.setProperty("group.id", "testGroup");

        return Consumer.createJavaConsumerConnector(new ConsumerConfig(properties));
    }

    @Override
    public void run() {
        // 建立Consumer
        ConsumerConnector consumer = createConsumer();

        Map<String, Integer> topicCountMap = new HashMap<String, Integer>();
        topicCountMap.put(topic, 1);

        Map<String, List<KafkaStream<byte[], byte[]>>> messageStreams = consumer.createMessageStreams(topicCountMap);

        // 獲取每次接受到的資料
        KafkaStream<byte[], byte[]> stream = messageStreams.get(topic).get(0);

        ConsumerIterator<byte[], byte[]> iterator = stream.iterator();

        // 不停地從stream中讀取最新接收到的資料
        while(iterator.hasNext()){
            String message = String.valueOf(iterator.next().message());

            System.out.println("message：" + message);
        }
    }

    public static void main(String[] args) {
        new KafkaConsumer(KafkaProperties.TOPIC).start();
    }
}

執行生產者及消費者程式碼，觀察控制檯

生產者控制檯（部分結果）：

Send：message_5
Send：message_6
Send：message_7
Send：message_8
Send：message_9
Send：message_10

消費者控制檯（部分結果）：只接收最新的資料

message：message_7
message：message_8
message：message_9
message：message_10