kafka教程：基礎概念、win10下安裝與配置、Java中使用kafka

一、基礎概念

Kafka是一種高吞吐量的分佈式發佈訂閱消息系統。kafka作爲一個集羣運行在一個或多個服務器上，kafka集羣存儲的消息是以topic爲類別記錄的，每個消息是由一個key，一個value和時間戳構成。對於傳統消息系統，消費者處理一條消息後，消息系統清除該條消息，如果消費者處理失敗，該條消息也消失。kafka會將所有消息存儲下來，直到它們過期（無論消息是否被消費），消費者只是讀取一個偏移量，通過偏移量獲取消息。
1、Topic（主題）：kafka將消息分門別類，每一類的消息稱之爲主題(Topic)。
2、Partition（分區）：對於每個Topic，kafka集羣都會維護一個分區log，如圖，每一個分區都是一個順序的、不可變的消息隊列，並且可以持續的添加。

3、Offset（偏移量）：分區的消息被分了一個序列號，成爲偏移量。偏移量由消費者控制。
4、kafka Cluster（kafka集羣）：已發佈的消息保存在一組服務器中，稱之爲kafka集羣。
5、Broker（代理）：集羣中每一個服務器都是一個代理。每個代理中的每個主題可以具有零個或多個分區。假設主題分區數爲M，代理數爲N：當M = N時，每個代理各自擁有一個分區；當M < N時，只有前M個代理具有一個分區，剩餘的代理將不擁有該主題的任何分區；當M > N時，每個代理之間具有一個分區或多個分區共享，由於代理之間的負載分佈不相等，不建議使用。
6、Producer（生產者）：發佈消息的對象，負責向某個Topic發送消息，生產者可以選擇自己想發送到的分區。
7、Consumer（消費者）：訂閱消息並處理髮布的對象。
8、消費組：同一組的消費者用消費組來標記自己，相當於同一組的消費者具有一個相同的標記，不同組的標記不同。
9、Leader（領導者）和Follower（追隨者）：每個分區有一個leader，零或多個follower。leader處理分區所有的讀寫請求，follower只被動的複製數據，如果leader宕機，會有一個follower被推舉爲新的leader。一臺服務器可能同時是一個分區的leader，另一個分區的follower，這樣可以平衡負載，避免所有的請求只讓集羣中的一臺或者某幾臺服務器處理。leader和follower由ZooKeeper決定。
10、消費模型：消費模型有兩種
發佈-訂閱模式：
（1）生產者定期向主題發送消息。
（2）Kafka代理存儲爲該特定主題配置的分區中的所有消息。 它確保消息在分區之間平等共享。 如果生產者發送兩個消息並且有兩個分區，Kafka將在第一分區中存儲一個消息，在第二分區中存儲第二消息。
（3）消費者訂閱特定主題。
（4）一旦消費者訂閱主題，Kafka將向消費者提供主題的當前偏移，並且還將偏移保存在Zookeeper系綜中。
（5）消費者將定期請求Kafka(如100 Ms)新消息。
（6）一旦Kafka收到來自生產者的消息，它將這些消息轉發給消費者。
（7）消費者將收到消息並進行處理。
（8）一旦消息被處理，消費者將向Kafka代理髮送確認。
（9）一旦Kafka收到確認，它將偏移更改爲新值，並在Zookeeper中更新它。 由於偏移在Zookeeper中維護，消費者可以正確地讀取下一條消息，即使在服務器暴力期間。
以上流程將重複，直到消費者停止請求。
隊列模式：
（1）生產者以固定間隔向某個主題發送消息。
（2）Kafka存儲在爲該特定主題配置的分區中的所有消息，類似於前面的方案。
（3）單個消費者訂閱特定主題，假設主題爲Topic-01，該消費者所在消費組的組ID爲Group-1。
（4）Kafka以與發佈-訂閱消息相同的方式與該消費者交互，直到相同組ID的新消費者訂閱相同主題Topic-01。注意：一條消息只有其中的一個消費者來處理。
（5）一旦新消費者到達，Kafka將其操作切換到共享模式，並在兩個消費者之間共享數據。此共享將繼續，直到用戶數達到爲該特定主題配置的分區數。
（6）一旦消費者的數量超過分區的數量，新消費者將不會接收任何進一步的消息，直到現有消費者取消訂閱任何一個消費者。出現這種情況是因爲Kafka中的每個消費者將被分配至少一個分區，並且一旦所有分區被分配給現有消費者，新消費者將必須等待。
由於Topic分區中消息只能由消費者組中的唯一一個消費者處理，所以kafka能夠保證一個分區內的消息是被按順序處理的。

二、安裝ZooKeeper

zookeeper也可以不進行下載，因爲kafka中內置了zookeeper。
1、下載安裝
官網下載鏈接，本文使用的是3.4.14版本，下載後解壓。
2、修改配置
複製zookeeper-3.4.14\conf目錄下的zoo_sample.cfg並改名爲zoo.cfg，對其zoo.cfg配置進行修改:
dataDir=C:/ZHSUN/zookeeper-3.4.14/data
3、開啓服務
cmd命令進入bin目錄，輸入命令：

zkServer.cmd

打開服務端

如果輸入命令：

zkCli.cmd

則打開客戶端

三、kafka安裝

1、下載安裝
官網下載鏈接，注意要下載二進制版本，下載後解壓。

2、修改配置
進入所安裝文件的config目錄，打開server.properties，找到並編輯:

log.dirs=C:/ZHSUN/kafka_2.12-2.5.0/kafka-logs

進入zookeeper.properties修改：

dataDir=C:/ZHSUN/kafka_2.12-2.5.0/data

3、開啓kafka內置的zookeeper
cmd命令進入kafka目錄，輸入命令：
.\bin\windows\zookeeper-server-start.bat .\config\zookeeper.properties
若出現binding to port 0.0.0.0/0.0.0.0：2181，則表示kafka內置的zookeeper啓動成功。注意：不要關閉該命令窗口。


4、啓動kafka服務
新打開cmd命令窗口，進入kafka目錄，輸入命令：
.\bin\windows\kafka-server-start.bat .\config\server.properties
打開

同樣不要關閉該命令窗口。
5、簡單測試：
（1）創建主題
新打開cmd命令窗口，進入kafka目錄，輸入命令：
.\bin\windows\kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test
創建Topic，不要關閉界面

（2）創建生產者
新命令窗口，進入kafka目錄：

.\bin\windows\kafka-console-producer.bat --broker-list localhost:9092 --topic test

（3）創建消費者
新命令窗口，進入kafka目錄：
.\bin\windows\kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test --from-beginning
（4）進行測試
生產者輸入消息，消費者就能接收到消息，若消費者界面未收到消息，按一下回車。

四、Java使用

需要保證zookeeper和kafka已啓動（參照三（3、4）），否則程序會報NullPointerException。
1、加入依賴

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>0.10.2.0</version>
</dependency>

2、配置文件
在resources目錄下創建kafka.properties

#produce
bootstrap.servers=localhost:9092
producer.type=sync
request.required.acks=1
serializer.class=kafka.serializer.DefaultEncoder
key.serializer=org.apache.kafka.common.serialization.StringSerializer
value.serializer=org.apache.kafka.common.serialization.StringSerializer
bak.partitioner.class=kafka.producer.DefaultPartitioner
bak.key.serializer=org.apache.kafka.common.serialization.StringSerializer
bak.value.serializer=org.apache.kafka.common.serialization.StringSerializer

#consume
zookeeper.connect=localhost:2181  
group.id=kafkaDemo
zookeeper.session.timeout.ms=4000  
zookeeper.sync.time.ms=200  
auto.commit.interval.ms=1000  
auto.offset.reset=earliest  
serializer.class=kafka.serializer.StringEncoder 
key.deserializer=org.apache.kafka.common.serialization.StringDeserializer
value.deserializer=org.apache.kafka.common.serialization.StringDeserializer

3、生產者代碼

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ProducerTest {
    private static Properties properties;

    /**
     * 讀取kafka配置
     */
    private static void init() {
        properties = new Properties();
        InputStream inStream = KafkaProducer.class.getClassLoader().getResourceAsStream("kafka.properties");
        try {
            properties.load(inStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public ProducerTest() {
        init();
    }

    /**
     * 生產消息併發送
     * @param topic
     * @param key
     * @param value
     */
    public void sendMessage(String topic, String key, String value) {
        // 實例化生產者
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 消息封裝
        ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(topic, key, value);
        // 發送消息
        kafkaProducer.send(producerRecord, new Callback() {
            public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                if(null != e) {
                    System.out.println("消息所在偏移量：" + recordMetadata.offset());
                    System.out.println(e.getMessage() + e);
                }
            }
        });
        // 關閉生產者
        kafkaProducer.close();
    }
}

4、消費者代碼

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.io.IOException;
import java.io.InputStream;
import java.util.Collections;
import java.util.Properties;

public class ConsumerTest {
    private static Properties properties;
    private long size = 100;
    private KafkaConsumer<String, String> kafkaConsumer;

    /**
     * 讀取kafka配置
     */
    private static void init() {
        properties = new Properties();
        InputStream inStream = KafkaConsumer.class.getClassLoader().getResourceAsStream("kafka.properties");
        try {
            properties.load(inStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public ConsumerTest() {
        init();
    }

    /**
     * 消費消息
     * @param topic
     */
    public void getMessage(String topic) {
        kafkaConsumer = new KafkaConsumer<String, String>(properties);
        // 訂閱主題
        kafkaConsumer.subscribe(Collections.singletonList(topic));
        while (true) {
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(size);
            for(ConsumerRecord<String, String> record : consumerRecords) {
                System.out.printf("offset = %d, key = %s, value = %s", record.offset(), record.key(), record.value());
                System.out.println();
            }
        }
    }

    /**
     * 關閉生產者
     */
    public void closeConsumer() {
        kafkaConsumer.close();
    }
}

5、測試代碼

public class Main
{
    public static void main( String[] args ) {
        String topic = "testTopic";

        ProducerTest producer = new ProducerTest();
        producer.sendMessage(topic, "key0", "{\"id\": \"123\", \"name\": \"張三\"}");
        producer.sendMessage(topic, "key1", "{\"id\": \"321\", \"name\": \"李四\"}");

        ConsumerTest consumer = new ConsumerTest();
        consumer.getMessage(topic);

        consumer.closeConsumer();
    }
}