SpringBoot整合Kafka的實戰用法大全

xuxh120發表於2021-12-05

本文是SpringBoot+Kafka的實戰講解，如果對kafka的架構原理還不瞭解的讀者，建議先看一下《大白話kafka架構原理》、《秒懂kafka HA（高可用）》兩篇文章。

一、環境準備

1、在專案中連線kafka

因為是外網，首先要開放kafka配置檔案中的如下配置（其中IP為公網IP），

advertised.listeners=PLAINTEXT://112.126.74.249:9092

2、建立Topic

在開始前我們先建立兩個topic：topic1、topic2，其分割槽和副本數都設定為2，用來測試，

[root@iZ2zegzlkedbo3e64vkbefZ ~]#  cd /usr/local/kafka-cluster/kafka1/bin/
[root@iZ2zegzlkedbo3e64vkbefZ bin]# ./kafka-topics.sh --create --zookeeper 172.17.80.219:2181 --replication-factor 2 --partitions 2 --topic topic1
Created topic topic1.
[root@iZ2zegzlkedbo3e64vkbefZ bin]# ./kafka-topics.sh --create --zookeeper 172.17.80.219:2181 --replication-factor 2 --partitions 2 --topic topic2
Created topic topic2.

當然我們也可以不手動建立topic，在執行程式碼kafkaTemplate.send("topic1", normalMessage)傳送訊息時，kafka會幫我們自動完成topic的建立工作，但這種情況下建立的topic預設只有一個分割槽，分割槽也沒有副本。所以，我們可以在專案中新建一個配置類專門用來初始化topic，如下，

@Configuration
public class KafkaInitialConfiguration {
    // 建立一個名為testtopic的Topic並設定分割槽數為8，分割槽副本數為2
    @Bean
    public NewTopic initialTopic() {
        return new NewTopic("testtopic",8, (short) 2 );
    }

    // 如果要修改分割槽數，只需修改配置值重啟專案即可
    // 修改分割槽數並不會導致資料的丟失，但是分割槽數只能增大不能減小
    @Bean
    public NewTopic updateTopic() {
        return new NewTopic("testtopic",10, (short) 2 );
    }
}

3、新建SpringBoot專案

① 引入pom依賴

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

② application.propertise配置（本文用到的配置項這裡全列了出來）

###########【Kafka叢集】###########
spring.kafka.bootstrap-servers=112.126.74.249:9092,112.126.74.249:9093
###########【初始化生產者配置】###########
# 重試次數
spring.kafka.producer.retries=0
# 應答級別:多少個分割槽副本備份完成時向生產者傳送ack確認(可選0、1、all/-1)
spring.kafka.producer.acks=1
# 批量大小
spring.kafka.producer.batch-size=16384
# 提交延時
spring.kafka.producer.properties.linger.ms=0
# 當生產端積累的訊息達到batch-size或接收到訊息linger.ms後,生產者就會將訊息提交給kafka
# linger.ms為0表示每接收到一條訊息就提交給kafka,這時候batch-size其實就沒用了

# 生產端緩衝區大小
spring.kafka.producer.buffer-memory = 33554432
# Kafka提供的序列化和反序列化類
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
# 自定義分割槽器
# spring.kafka.producer.properties.partitioner.class=com.felix.kafka.producer.CustomizePartitioner

###########【初始化消費者配置】###########
# 預設的消費組ID
spring.kafka.consumer.properties.group.id=defaultConsumerGroup
# 是否自動提交offset
spring.kafka.consumer.enable-auto-commit=true
# 提交offset延時(接收到訊息後多久提交offset)
spring.kafka.consumer.auto.commit.interval.ms=1000
# 當kafka中沒有初始offset或offset超出範圍時將自動重置offset
# earliest:重置為分割槽中最小的offset;
# latest:重置為分割槽中最新的offset(消費分割槽中新產生的資料);
# none:只要有一個分割槽不存在已提交的offset,就丟擲異常;
spring.kafka.consumer.auto-offset-reset=latest
# 消費會話超時時間(超過這個時間consumer沒有傳送心跳,就會觸發rebalance操作)
spring.kafka.consumer.properties.session.timeout.ms=120000
# 消費請求超時時間
spring.kafka.consumer.properties.request.timeout.ms=180000
# Kafka提供的序列化和反序列化類
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer
# 消費端監聽的topic不存在時，專案啟動會報錯(關掉)
spring.kafka.listener.missing-topics-fatal=false
# 設定批量消費
# spring.kafka.listener.type=batch
# 批量消費每次最多消費多少條訊息
# spring.kafka.consumer.max-poll-records=50

二、生產者實踐

1、簡單生產者

@RestController
public class KafkaProducer {
    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

    // 傳送訊息
    @GetMapping("/kafka/normal/{message}")
    public void sendMessage1(@PathVariable("message") String normalMessage) {
        kafkaTemplate.send("topic1", normalMessage);
    }
}

2、簡單消費

@Component
public class KafkaConsumer {
    // 消費監聽
    @KafkaListener(topics = {"topic1"})
    public void onMessage1(ConsumerRecord<?, ?> record){
        // 消費的哪個topic、partition的訊息,列印出訊息內容
        System.out.println("簡單消費："+record.topic()+"-"+record.partition()+"-"+record.value());
    }
}

上面示例建立了一個生產者，傳送訊息到topic1，消費者監聽topic1消費訊息。監聽器用@KafkaListener註解，topics表示監聽的topic，支援同時監聽多個，用英文逗號分隔。啟動專案，postman調介面觸發生產者傳送訊息，

可以看到監聽器消費成功，

3、帶回撥的生產者

kafkaTemplate提供了一個回撥方法addCallback，我們可以在回撥方法中監控訊息是否傳送成功或失敗時做補償處理，有兩種寫法，

方式一：

@GetMapping("/kafka/callbackOne/{message}")
public void sendMessage2(@PathVariable("message") String callbackMessage) {
    kafkaTemplate.send("topic1", callbackMessage).addCallback(success -> {
        // 訊息傳送到的topic
        String topic = success.getRecordMetadata().topic();
        // 訊息傳送到的分割槽
        int partition = success.getRecordMetadata().partition();
        // 訊息在分割槽內的offset
        long offset = success.getRecordMetadata().offset();
        System.out.println("傳送訊息成功:" + topic + "-" + partition + "-" + offset);
    }, failure -> {
        System.out.println("傳送訊息失敗:" + failure.getMessage());
    });
}

方式二：

@GetMapping("/kafka/callbackTwo/{message}")
public void sendMessage3(@PathVariable("message") String callbackMessage) {
    kafkaTemplate.send("topic1", callbackMessage).addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {
        @Override
        public void onFailure(Throwable ex) {
            System.out.println("傳送訊息失敗："+ex.getMessage());
        }
 
        @Override
        public void onSuccess(SendResult<String, Object> result) {
            System.out.println("傳送訊息成功：" + result.getRecordMetadata().topic() + "-"
                    + result.getRecordMetadata().partition() + "-" + result.getRecordMetadata().offset());
        }
    });
}

4、自定義分割槽器

我們知道，kafka中每個topic被劃分為多個分割槽，那麼生產者將訊息傳送到topic時，具體追加到哪個分割槽呢？這就是所謂的分割槽策略，Kafka 為我們提供了預設的分割槽策略，同時它也支援自定義分割槽策略。其路由機制為：

① 若傳送訊息時指定了分割槽（即自定義分割槽策略），則直接將訊息append到指定分割槽；

② 若傳送訊息時未指定 patition，但指定了 key（kafka允許為每條訊息設定一個key），則對key值進行hash計算，根據計算結果路由到指定分割槽，這種情況下可以保證同一個 Key 的所有訊息都進入到相同的分割槽；

③ patition 和 key 都未指定，則使用kafka預設的分割槽策略，輪詢選出一個 patition；

※ 我們來自定義一個分割槽策略，將訊息傳送到我們指定的partition，首先新建一個分割槽器類實現Partitioner介面，重寫方法，其中partition方法的返回值就表示將訊息傳送到幾號分割槽，

public class CustomizePartitioner implements Partitioner {
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        // 自定義分割槽規則(這裡假設全部發到0號分割槽)
        // ......
        return 0;
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {

    }
}

在application.propertise中配置自定義分割槽器，配置的值就是分割槽器類的全路徑名，

# 自定義分割槽器
spring.kafka.producer.properties.partitioner.class=com.felix.kafka.producer.CustomizePartitioner

如果在傳送訊息時需要建立事務，可以使用 KafkaTemplate 的 executeInTransaction 方法來宣告事務，

@GetMapping("/kafka/transaction")
public void sendMessage7(){
    // 宣告事務：後面報錯訊息不會發出去
    kafkaTemplate.executeInTransaction(operations -> {
        operations.send("topic1","test executeInTransaction");
        throw new RuntimeException("fail");
    });

    // 不宣告事務：後面報錯但前面訊息已經傳送成功了
   kafkaTemplate.send("topic1","test executeInTransaction");
   throw new RuntimeException("fail");
}

三、消費者實踐

1、指定topic、partition、offset消費

前面我們在監聽消費topic1的時候，監聽的是topic1上所有的訊息，如果我們想指定topic、指定partition、指定offset來消費呢？也很簡單，@KafkaListener註解已全部為我們提供，

/**
 * @Title 指定topic、partition、offset消費
 * @Description 同時監聽topic1和topic2，監聽topic1的0號分割槽、topic2的 "0號和1號" 分割槽，指向1號分割槽的offset初始值為8
 * @Author long.yuan
 * @Date 2020/3/22 13:38
 * @Param [record]
 * @return void
 **/
@KafkaListener(id = "consumer1",groupId = "felix-group",topicPartitions = {
        @TopicPartition(topic = "topic1", partitions = { "0" }),
        @TopicPartition(topic = "topic2", partitions = "0", partitionOffsets = @PartitionOffset(partition = "1", initialOffset = "8"))
})
public void onMessage2(ConsumerRecord<?, ?> record) {
    System.out.println("topic:"+record.topic()+"|partition:"+record.partition()+"|offset:"+record.offset()+"|value:"+record.value());
}

屬性解釋：

① id：消費者ID；

② groupId：消費組ID；

③ topics：監聽的topic，可監聽多個；

④ topicPartitions：可配置更加詳細的監聽資訊，可指定topic、parition、offset監聽。

上面onMessage2監聽的含義：監聽topic1的0號分割槽，同時監聽topic2的0號分割槽和topic2的1號分割槽裡面offset從8開始的訊息。

注意：topics和topicPartitions不能同時使用；

2、批量消費

設定application.prpertise開啟批量消費即可，

# 設定批量消費
spring.kafka.listener.type=batch
# 批量消費每次最多消費多少條訊息
spring.kafka.consumer.max-poll-records=50

接收訊息時用List來接收，監聽程式碼如下，

@KafkaListener(id = "consumer2",groupId = "felix-group", topics = "topic1")
public void onMessage3(List<ConsumerRecord<?, ?>> records) {
    System.out.println(">>>批量消費一次，records.size()="+records.size());
    for (ConsumerRecord<?, ?> record : records) {
        System.out.println(record.value());
    }
}

3、ConsumerAwareListenerErrorHandler 異常處理器

通過異常處理器，我們可以處理consumer在消費時發生的異常。

新建一個 ConsumerAwareListenerErrorHandler 型別的異常處理方法，用@Bean注入，BeanName預設就是方法名，然後我們將這個異常處理器的BeanName放到@KafkaListener註解的errorHandler屬性裡面，當監聽丟擲異常的時候，則會自動呼叫異常處理器，

// 新建一個異常處理器，用@Bean注入
@Bean
public ConsumerAwareListenerErrorHandler consumerAwareErrorHandler() {
    return (message, exception, consumer) -> {
        System.out.println("消費異常："+message.getPayload());
        return null;
    };
}

// 將這個異常處理器的BeanName放到@KafkaListener註解的errorHandler屬性裡面
@KafkaListener(topics = {"topic1"},errorHandler = "consumerAwareErrorHandler")
public void onMessage4(ConsumerRecord<?, ?> record) throws Exception {
    throw new Exception("簡單消費-模擬異常");
}

// 批量消費也一樣，異常處理器的message.getPayload()也可以拿到各條訊息的資訊
@KafkaListener(topics = "topic1",errorHandler="consumerAwareErrorHandler")
public void onMessage5(List<ConsumerRecord<?, ?>> records) throws Exception {
    System.out.println("批量消費一次...");
    throw new Exception("批量消費-模擬異常");
}

執行看一下效果，

4、訊息過濾器

訊息過濾器可以在訊息抵達consumer之前被攔截，在實際應用中，我們可以根據自己的業務邏輯，篩選出需要的資訊再交由KafkaListener處理，不需要的訊息則過濾掉。

配置訊息過濾只需要為監聽器工廠配置一個RecordFilterStrategy（訊息過濾策略），返回true的時候訊息將會被拋棄，返回false時，訊息能正常抵達監聽容器。

@Component
public class KafkaConsumer {
    @Autowired
    ConsumerFactory consumerFactory;

    // 訊息過濾器
    @Bean
    public ConcurrentKafkaListenerContainerFactory filterContainerFactory() {
        ConcurrentKafkaListenerContainerFactory factory = new ConcurrentKafkaListenerContainerFactory();
        factory.setConsumerFactory(consumerFactory);
        // 被過濾的訊息將被丟棄
        factory.setAckDiscarded(true);
        // 訊息過濾策略
        factory.setRecordFilterStrategy(consumerRecord -> {
            if (Integer.parseInt(consumerRecord.value().toString()) % 2 == 0) {
                return false;
            }
            //返回true訊息則被過濾
            return true;
        });
        return factory;
    }

    // 訊息過濾監聽
    @KafkaListener(topics = {"topic1"},containerFactory = "filterContainerFactory")
    public void onMessage6(ConsumerRecord<?, ?> record) {
        System.out.println(record.value());
    }
}

上面實現了一個"過濾奇數、接收偶數"的過濾策略，我們向topic1傳送0-99總共100條訊息，看一下監聽器的消費情況，可以看到監聽器只消費了偶數，

5、訊息轉發

在實際開發中，我們可能有這樣的需求，應用A從TopicA獲取到訊息，經過處理後轉發到TopicB，再由應用B監聽處理訊息，即一個應用處理完成後將該訊息轉發至其他應用，完成訊息的轉發。

在SpringBoot整合Kafka實現訊息的轉發也很簡單，只需要通過一個@SendTo註解，被註解方法的return值即轉發的訊息內容，如下，

/**
 * @Title 訊息轉發
 * @Description 從topic1接收到的訊息經過處理後轉發到topic2
 * @Author long.yuan
 * @Date 2020/3/23 22:15
 * @Param [record]
 * @return void
 **/
@KafkaListener(topics = {"topic1"})
@SendTo("topic2")
public String onMessage7(ConsumerRecord<?, ?> record) {
    return record.value()+"-forward message";
}

6、定時啟動、停止監聽器

預設情況下，當消費者專案啟動的時候，監聽器就開始工作，監聽消費傳送到指定topic的訊息，那如果我們不想讓監聽器立即工作，想讓它在我們指定的時間點開始工作，或者在我們指定的時間點停止工作，該怎麼處理呢——使用KafkaListenerEndpointRegistry，下面我們就來實現：

① 禁止監聽器自啟動；

② 建立兩個定時任務，一個用來在指定時間點啟動定時器，另一個在指定時間點停止定時器；

新建一個定時任務類，用註解@EnableScheduling宣告，KafkaListenerEndpointRegistry 在SpringIO中已經被註冊為Bean，直接注入，設定禁止KafkaListener自啟動，

@EnableScheduling
@Component
public class CronTimer {

    /**
     * @KafkaListener註解所標註的方法並不會在IOC容器中被註冊為Bean，
     * 而是會被註冊在KafkaListenerEndpointRegistry中，
     * 而KafkaListenerEndpointRegistry在SpringIOC中已經被註冊為Bean
     **/
    @Autowired
    private KafkaListenerEndpointRegistry registry;

    @Autowired
    private ConsumerFactory consumerFactory;

    // 監聽器容器工廠(設定禁止KafkaListener自啟動)
    @Bean
    public ConcurrentKafkaListenerContainerFactory delayContainerFactory() {
        ConcurrentKafkaListenerContainerFactory container = new ConcurrentKafkaListenerContainerFactory();
        container.setConsumerFactory(consumerFactory);
        //禁止KafkaListener自啟動
        container.setAutoStartup(false);
        return container;
    }

    // 監聽器
    @KafkaListener(id="timingConsumer",topics = "topic1",containerFactory = "delayContainerFactory")
    public void onMessage1(ConsumerRecord<?, ?> record){
        System.out.println("消費成功："+record.topic()+"-"+record.partition()+"-"+record.value());
    }

    // 定時啟動監聽器
    @Scheduled(cron = "0 42 11 * * ? ")
    public void startListener() {
        System.out.println("啟動監聽器...");
        // "timingConsumer"是@KafkaListener註解後面設定的監聽器ID,標識這個監聽器
        if (!registry.getListenerContainer("timingConsumer").isRunning()) {
            registry.getListenerContainer("timingConsumer").start();
        }
        //registry.getListenerContainer("timingConsumer").resume();
    }

    // 定時停止監聽器
    @Scheduled(cron = "0 45 11 * * ? ")
    public void shutDownListener() {
        System.out.println("關閉監聽器...");
        registry.getListenerContainer("timingConsumer").pause();
    }
}

啟動專案，觸發生產者向topic1傳送訊息，可以看到consumer沒有消費，因為這時監聽器還沒有開始工作，

11:42分監聽器啟動開始工作，消費訊息，

11：45分監聽器停止工作，

參考文件

https://mp.weixin.qq.com/s?__biz=MzU1NDA0MDQ3MA==&mid=2247483958&idx=1&sn=dffaad318b50f875eea615bc3bdcc80c
https://mp.weixin.qq.com/s?__biz=MzU1NDA0MDQ3MA==&mid=2247483965&idx=1&sn=20dd02c4bf3a11ff177906f0527a5053
https://blog.csdn.net/yuanlong122716/article/details/105160545/

SpringBoot整合kafka全面實戰
2020-10-16
Spring BootKafka
Springboot 整合 Netty 實戰
2018-10-28
Spring BootNetty
SpringBoot整合Redis實戰
2020-10-08
Spring BootRedis
Kafka 簡介 & 整合 SpringBoot
2019-03-06
KafkaSpring Boot
SpringBoot整合Kafka和Storm
2018-05-10
Spring BootKafkaORM
springboot整合kafka配置方式
2024-05-24
Spring BootKafka
SpringBoot 實戰 (十二) | 整合 thymeleaf
2019-02-25
Spring Boot
SpringBoot 實戰 (九) | 整合 Mybatis
2019-02-20
Spring BootMyBatis
教你如何搞定springboot整合kafka
2024-05-16
Spring BootKafka
SpringBoot 實戰 (十三) | 整合 MyBatis (XML 版)
2019-02-28
Spring BootMyBatisXML
實戰程式碼（一）：SpringBoot整合Quartz
2020-11-15
Spring Bootquartz
springboot整合swagger實戰（基礎版）
2021-03-26
Spring BootSwagger
HBase2實戰：HBase Flink和Kafka整合
2019-01-09
Kafka
SpringBoot 實戰 (十七) | 整合 WebSocket 實現聊天室
2019-03-05
Spring BootWeb
springboot整合整合kafka-生產者監聽器ProducerListener
2020-11-20
Spring BootKafka
SpringBoot 實戰 (十一) | 整合資料快取 Cache
2019-02-22
Spring Boot快取
SpringBoot整合RabbitMQ實戰附加死信交換機
2022-06-10
Spring BootMQ
MyBatis初級實戰之三：springboot整合druid
2021-01-19
MyBatisSpring BootUI
SpringBoot整合Kafka（生產者和消費者都是SpringBoot服務）
2020-12-02
Spring BootKafka
pandas用法大全
2018-09-08
資料採集元件：Flume基礎用法和Kafka整合
2021-03-05
元件Kafka
SpringBoot整合RabbitMQ之典型應用場景實戰二
2019-03-04
Spring BootMQ
SpringBoot整合RabbitMQ之典型應用場景實戰一
2018-10-10
Spring BootMQ
Kafka實戰(三) - Kafka的自我修養與定位
2020-01-23
Kafka
MongoDB 整合SpringBoot實踐
2019-03-23
MongoDBSpring Boot
Kafka 原理和實戰
2019-08-20
Kafka
kafka實戰教學
2018-03-26
Kafka
【FastDFS】SpringBoot整合FastDFS實戰，我只看這一篇！！
2020-09-29
ASTSpring Boot
Go字串實戰操作大全！
2023-10-09
Go字串
SpringBoot 實戰 (四) | 整合 Swagger2 構建強大的 RESTful API 文件
2019-02-19
Spring BootSwaggerRESTAPI
Flink的sink實戰之二：kafka
2021-09-09
Kafka
kafka+flume的整合
2021-09-09
Kafka
Cassandra與Kafka的整合
2020-12-30
Kafka
springboot整合jetcache實際操作
2020-10-17
Spring Boot
SpringBoot 實踐系列-整合 RocketMQ
2020-04-06
Spring BootMQ
Kafka實戰寶典：Kafka的控制器controller詳解
2020-09-21
KafkaController
實戰Kafka ACL機制
2018-06-17
Kafka
Flink-Kafka-Connector Flink結合Kafka實戰
2019-03-03
Kafka