深入Spring Boot (十三)：整合Kafka詳解

Kafka是一種高吞吐量的分佈式流處理平臺，它具有高可用、高吞吐量、速度快、易擴展等特性。本篇將介紹如何使用Spring Boot整合Kafka及使用Kafka實現簡單的消息發送和消費，主要包括以下3部分內容：

1. Kafka

2. 整合Kafka

3. 小結 

Kafka

Kafka是Apache組織下的一個分佈式流處理平臺，它具有以下三個功能特性:

• 作爲消息系統，發佈和訂閱流式的記錄，這個與消息隊列或者企業消息系統類似。

• 作爲存儲系統，儲存流式的記錄，並且有較好的容錯性。

• 作爲流處理，在流式記錄產生時就進行實時處理。

Kafka可用於構建以下兩大類別的應用:

• 構造實時流數據管道，它可以在系統或應用之間可靠地獲取數據，相當於消息隊列。

• 構建實時流式應用程序，對這些流數據進行轉換或者影，也就是流處理。

Kafka的內容比較多，這裏只簡單介紹相關基本概念，更多kafka知識請瀏覽http://kafka.apache.org/。

topic

topic直譯爲主題，在kafka中就是數據主題，是數據記錄發佈的地方，可用來區分數據、業務系統。

producer

producer就是生產者，在kafka中Producer API允許一個應用程序發佈一串流式的數據到一個或者多個topic。

consumer

consumer就是消費者，在kafka中Consumer API允許一個應用程序訂閱一個或多個topic ，並且對發佈給他們的流式數據進行處理。

Stream Processors

kafka中的Connector API允許構建並運行可重用的生產者或者消費者，將topics連接到已存在的應用程序或者數據系統，例如連接到一個關係型數據庫，捕捉表的內容變更。

整合Kafka

使用IDEA新建項目，選擇maven管理依賴和構建項目，在pom.xml中添加spring-boot-starter和spring-kafka依賴配置，項目中會使用單元測試檢查整合是否正確，所以需要添加spring-boot-starter-test依賴，pom.xml詳細內容如下。

<?xml version="1.0" encoding="UTF-8"?>	
<project xmlns="http://maven.apache.org/POM/4.0.0"	
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"	
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">	
    <modelVersion>4.0.0</modelVersion>	
    <groupId>com.kafka</groupId>	
    <artifactId>demo</artifactId>	
    <version>1.0-SNAPSHOT</version>	

	
    <parent>	
        <groupId>org.springframework.boot</groupId>	
        <artifactId>spring-boot-starter-parent</artifactId>	
        <version>2.2.0.RELEASE</version>	
    </parent>	

	
    <dependencies>	
        <dependency>	
            <groupId>org.springframework.boot</groupId>	
            <artifactId>spring-boot-starter</artifactId>	
        </dependency>	
        <dependency>	
            <groupId>org.springframework.boot</groupId>	
            <artifactId>spring-boot-starter-test</artifactId>	
            <scope>test</scope>	
        </dependency>	
        <dependency>	
            <groupId>org.springframework.kafka</groupId>	
            <artifactId>spring-kafka</artifactId>	
            <version>2.3.1.RELEASE</version>	
        </dependency>	
        <dependency>	
            <groupId>org.slf4j</groupId>	
            <artifactId>jcl-over-slf4j</artifactId>	
            <version>1.7.28</version>	
        </dependency>	
    </dependencies>	

	
    <build>	
        <plugins>	
            <plugin>	
                <groupId>org.springframework.boot</groupId>	
                <artifactId>spring-boot-maven-plugin</artifactId>	
            </plugin>	
        </plugins>	
    </build>	
</project>

在resources目錄下新增application.properties，並在其中配置生產者和消費者的相關參數，application.properties中參數會在應用啓動時被加載解析並初始化，更多生產者和消費者的參數配置請查閱官方文檔。

# kafka server的地址，如果有多個，使用逗號分割	
spring.kafka.bootstrap-servers=127.0.0.1:9092	
# 生產者發送失敗時，重試次數	
spring.kafka.producer.retries=0	
# 生產者消息key和消息value的序列化處理類	
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer	
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer	
# 默認消費者group id	
spring.kafka.consumer.group-id=testGroup	
# 消費者消息key和消息value的序列化處理類	
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer	
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

項目目錄結構如下圖所示。

DemoApplication.java

import org.springframework.boot.SpringApplication;	
import org.springframework.boot.autoconfigure.SpringBootApplication;	
@SpringBootApplication	
public class DemoApplication {	
    public static void main(String[] args) {	
        SpringApplication.run(DemoApplication.class, args);	
    }	
}

ProducerService.java

public interface ProducerService {	
    void send(String topic, String msg);	
}

ProducerServiceImpl.java

import com.kafka.demo.service.ProducerService;	
import org.slf4j.Logger;	
import org.slf4j.LoggerFactory;	
import org.springframework.beans.factory.annotation.Autowired;	
import org.springframework.kafka.core.KafkaTemplate;	
import org.springframework.lang.Nullable;	
import org.springframework.stereotype.Service;	
import org.springframework.util.concurrent.ListenableFuture;	
import org.springframework.util.concurrent.ListenableFutureCallback;	
@Service("ProducerService")	
public class ProducerServiceImpl implements ProducerService {	
    private Logger log = LoggerFactory.getLogger(ProducerServiceImpl.class);	
    @Autowired	
    private KafkaTemplate kafkaTemplate;	

	
    @Override	
    public void send(String topic, String msg) {	
        ListenableFuture future = kafkaTemplate.send(topic, msg);	
        future.addCallback(new ListenableFutureCallback() {	
            @Override	
            public void onFailure(Throwable throwable) {	
                log.info("send failure");	
            }	

	
            @Override	
            public void onSuccess(@Nullable Object o) {	
                log.info("send success");	
            }	
          });	
      }	
}

ConsumerService.java

public interface ConsumerService {	
    void onReceived(String msg);	
}

ConsumerServiceImpl.java

import com.kafka.demo.service.ConsumerService;	
import org.slf4j.Logger;	
import org.slf4j.LoggerFactory;	
import org.springframework.kafka.annotation.KafkaListener;	
import org.springframework.stereotype.Service;	
@Service	
public class ConsumerServiceImpl implements ConsumerService {	
    private Logger log = LoggerFactory.getLogger(ConsumerServiceImpl.class);	
    @KafkaListener(topics="test")	

	
    @Override	
    public void onReceived(String msg) {	
        log.info("receive msg=" + msg);	
    }	
}

DemoApplicationTest.java

import com.kafka.demo.service.ProducerService;	
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(classes={com.kafka.demo.DemoApplication.class})	
public class DemoApplicationTest {	

	
    @Autowired	
    private ProducerService producerService;	

	
    @Test	
    public void test(){	
        producerService.send("test", "hello world");	
    }	
}

運行單元測試之前，需要下載並啓動Kafka服務器。進入http://kafka.apache.org/downloads下載最新版本並解壓。壓縮包中Kafka腳本在Unix和Windows平臺是不同的，下面使用到的相關命令，如果在Unix平臺下請使用bin/，如果在Windows平臺下請使用bin\windows\，並且腳本擴展名分別爲.bat和.sh。因爲kafka使用zookeeper來實現動態的集羣擴展，所以要先啓動zookeeper，使用如下命令：

bin/zookeeper-server-start.sh config/zookeeper.properties

然後使用如下命令啓動kafka:

bin/kafka-server-start.sh config/server.properties

使用如下命令創建一個名爲"test"的topic:

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

上面各步驟完成後，即可執行單元測試驗證了。

小結

本文通讀下來，你會發現整合kafka很簡單，添加kafka依賴、使用KafkaTemplate、使用@KafkaListener註解就完成了，其實是SpringBoot在背後默默的做了很多工作，如果想深入瞭解這部分工作做了什麼，入口就是@SpringBootApplication註解。@SpringBootApplication是一個組合註解，它包含了@SpringBootConfiguration、

@EnableAutoConfiguration和@ComponentScan等註解，通過這三個註解實現了bean的配置和加載。深入@EnableAutoConfiguration註解源碼，你會發現加載了KafkaAutoConfiguration，在這裏加載並實例化了kafka相關的類。 

爲了更方便的技術交流，建了一個微信羣，加博主微信wind7rui，邀你進羣！

END 

如果覺得有收穫，記得關注、點贊、轉發。