超簡單的Windows下Kafka的安裝部署實例 + Springboot下Kafka的兩種集成實例（生產者/消費者實例）

簡單說明什麼是kafka

Apache kafka是消息中間件的一種，我發現很多人不知道消息中間件是什麼，在開始學習之前，我這邊就先簡單的解釋一下什麼是消息中間件，只是粗略的講解，目前kafka已經可以做更多的事情。

舉個例子，生產者消費者，生產者生產雞蛋，消費者消費雞蛋，生產者生產一個雞蛋，消費者就消費一個雞蛋，假設消費者消費雞蛋的時候噎住了（系統宕機了），生產者還在生產雞蛋，那新生產的雞蛋就丟失了。再比如生產者很強勁（大交易量的情況），生產者1秒鐘生產100個雞蛋，消費者1秒鐘只能吃50個雞蛋，那要不了一會，消費者就吃不消了（消息堵塞，最終導致系統超時），消費者拒絕再吃了，”雞蛋“又丟失了，這個時候我們放個籃子在它們中間，生產出來的雞蛋都放到籃子裏，消費者去籃子裏拿雞蛋，這樣雞蛋就不會丟失了，都在籃子裏，而這個籃子就是”kafka“。
雞蛋其實就是“數據流”，系統之間的交互都是通過“數據流”來傳輸的（就是tcp、https什麼的），也稱爲報文，也叫“消息”。
消息隊列滿了，其實就是籃子滿了，”雞蛋“ 放不下了，那趕緊多放幾個籃子，其實就是kafka的擴容。
各位現在知道kafka是幹什麼的了吧，它就是那個"籃子"。

kafka名詞解釋

後面大家會看到一些關於kafka的名詞，比如topic、producer、consumer、broker，我這邊來簡單說明一下。

producer：生產者，就是它來生產“雞蛋”的。

consumer：消費者，生出的“雞蛋”它來消費。

topic：你把它理解爲標籤，生產者每生產出來一個雞蛋就貼上一個標籤（topic），消費者可不是誰生產的“雞蛋”都吃的，這樣不同的生產者生產出來的“雞蛋”，消費者就可以選擇性的“吃”了。

broker：就是籃子了。

大家一定要學會抽象的去思考，上面只是屬於業務的角度，如果從技術角度，topic標籤實際就是隊列，生產者把所有“雞蛋（消息）”都放到對應的隊列裏了，消費者到指定的隊列裏取。

作者：半獸人
鏈接：https://www.orchome.com/kafka/index
來源：OrcHome

上面是OrcHome的Kafka中文教程介紹，我覺得非常形象，比一些專業的術語要容易理解得多，適合入門學習。

一.Windows下Kafka的安裝部署實例

1.首先下載Apache Kafka

http://kafka.apache.org/downloads

注意是下面的鏈接

2.解壓壓縮包

3.然後進入到  kafka_2.12-2.3.0\bin\windows 文件夾下。並在地址欄輸入cmd回車打開命令行

PS：後面的5個命令每個都要打開一個新的cmd來執行，並且不要關閉（除了創建topic命令可以關）

4.首先啓動開zookeeper ，輸入命令：.\zookeeper-server-start.bat ..\..\config\zookeeper.properties

啓動Kafka，輸入命令： .\kafka-server-start.bat ..\..\config\server.properties

然後創建一個topic，命名爲test（這裏我已經建過了，圖就用別的topic的），輸入命令：.\kafka-topics.bat --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

然後創建一個或多個生產者，將topic設置爲test，輸入命令：.\kafka-console-producer.bat --broker-list localhost:9092 --topic test

最後創建一個或多個消費者，將topic設置爲test，輸入命令：.\kafka-console-consumer.bat --bootstrap-server localhost:9092 --topic test --from-beginning

在生存者上發送的消息，同一topic下的消費者就能接收到啦。恭喜你已經完成簡單的Kafka生產者/消費者實例。

接下來將實現兩種簡單的SpringBoot集成Kafka的生產者/消費者實例。

二.Springboot下Kafka的集成實例

首先介紹第一種，引入依賴是 org.apache.kafka 的。這種方法是kafka官方文檔上有的方法，代碼比較複雜。

先說說我先前遇到的問題，賊SB的，之前我以爲引入依賴後就不用自行啓動Kafka了，所以一直沒有啓動Kafka，導致一直不成功。事實上需要先啓動Kafka，下面的代碼只是創建消費者和生存者的實例，並不包含Kafka啓動。

zookeeper的默認端口：2181

Kafka的默認端口：9092

1.首先在 pom.xml 中引入 org.apache.kafka 的依賴

        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>1.1.0</version>
        </dependency>

這裏要注意，不同版本的依賴的Producer API 和Consumer API 實現可能稍有不同，我這裏springboot的版本是1.5.10.RELEASE，可以在官網鏈接http://kafka.apache.org/documentation/查看不同版本的API實例。

2.開始實現生產者實例

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 15:23
 */
public class MyKafkaProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); //kafka端口
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); //key值序列化配置
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); //value值序列化配置

        Producer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<>("test", "hello to MykafkaComsumer")); //topic和對應消息

        producer.close();
    }
}

運行main函數即可向名爲test的topic生產一條信息

3.開始實現消費者實例

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

import java.util.Arrays;
import java.util.Properties;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 15:48
 */
public class MyKafkaConsumer {
    public static void main(String[] args) {

        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092");
        props.put("group.id", "myGroup"); 分組名
        props.put("enable.auto.commit", "true");
        props.put("auto.commit.interval.ms", "1000");
        props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
        consumer.subscribe(Arrays.asList("test")); //這邊是消費者的topic訂閱，可訂閱多個
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(100); //循環拉取消息
            for (ConsumerRecord<String, String> record : records)
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
        }
    }
}

運行main函數即可循環監聽訂閱的topic

 

接着是第二種，要引入依賴 spring.kafka 的，這種方法代碼很簡單，通過@kafkalistener就可以進行消費者的監聽。

1.首先在 pom.xml 中引入 org.springframework.kafka 的依賴

        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>1.1.7.RELEASE</version>
        </dependency>

2.在 application.properties 文件裏添加Kafka配置

spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=myGroup

3.開始實現生產者實例

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 11:09
 */
@Service
public class KafkaProducer2 {
    @Autowired
    KafkaTemplate kafkaTemplate;

    public void sender(String topic,String value){
        kafkaTemplate.send(topic,value);
    }
}

生產者通過KafkaTemplate類來發送消息

4.開始實現消費者實例

import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

/**
 * @author ZZJ
 * @description:
 * @date 2019-10-10 11:32
 */
@Service
public class KafkaConsumer2 {
    @KafkaListener(topics = "test")
    public void consumer(String message){
        System.out.println(message);
    }
}

這裏的@KafkaListener註解能夠對topic進行監聽

5.創建一個test類，將生產者和消費者的類注入

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class KafkaProducer2Test {

    @Autowired
    private KafkaProducer2 kafkaProducer2; //注入生產者
    @Autowired
    private KafkaConsumer2 kafkaConsumer2; //注入消費者，注入後即可監聽

    @Test
    public void sender() {
        try { 
            Thread.sleep(3000); //這裏sleep保證消費者開始監聽後才發送消息
            kafkaProducer2.sender("test","8888----7777");//生產者發送消息
            Thread.sleep(80000000); //sleep方便消費者監聽
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

以上三個實例的生產者和消費者都可以互通消息，可以同時打開多個實例測試。這些是我學習完多個博客後的整合，適合入門者理解和快速實現Kafka的實例。