Kafka系列第三篇！10 分鐘學會如何在 Spring Boot 程序中使用 Kafka 作爲消息隊列?

Step1:創建項目

直接通過Spring 官方提供的 Spring Initializr 創建或者直接使用 IDEA 創建皆可。

Step2: 配置 Kafka

通過 application.yml 配置文件配置 Kafka 基本信息

server:
  port: 9090

spring:
  kafka:
    consumer:
      bootstrap-servers: localhost:9092
      # 配置消費者消息offset是否自動重置(消費者重連會能夠接收最開始的消息)
      auto-offset-reset: earliest
    producer:
      bootstrap-servers: localhost:9092
      # 發送的對象信息變爲json格式
      value-serializer: org.springframework.kafka.support.serializer.JsonSerializer
kafka:
  topic:
    my-topic: my-topic
    my-topic2: my-topic2

Kafka 額外配置類：

package cn.javaguide.springbootkafka01sendobjects.config;

import org.apache.kafka.clients.admin.NewTopic;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.support.converter.RecordMessageConverter;
import org.springframework.kafka.support.converter.StringJsonMessageConverter;

@Configuration
public class KafkaConfig {

    @Value("${kafka.topic.my-topic}")
    String myTopic;
    @Value("${kafka.topic.my-topic2}")
    String myTopic2;

    /**
     * JSON消息轉換器
     */
    @Bean
    public RecordMessageConverter jsonConverter() {
        return new StringJsonMessageConverter();
    }

    /**
     * 通過注入一個 NewTopic 類型的 Bean 來創建 topic，如果 topic 已存在，則會忽略。
     */
    @Bean
    public NewTopic myTopic() {
        return new NewTopic(myTopic, 2, (short) 1);
    }

    @Bean
    public NewTopic myTopic2() {
        return new NewTopic(myTopic2, 1, (short) 1);
    }
}

當我們到了這一步之後，你就可以試着運行項目了，運行成功後你會發現 Spring Boot 會爲你創建兩個topic:

my-topic: partition 數爲 2, replica 數爲 1
my-topic2:partition 數爲 1, replica 數爲 1

“
通過上一節說的：kafka-topics --describe --zookeeper zoo1:2181 命令查看或者直接通過IDEA 提供的 Kafka 可視化管理插件-Kafkalytic 來查看
”

Step3:創建要發送的消息實體類

package cn.javaguide.springbootkafka01sendobjects.entity;

public class Book {
    private Long id;
    private String name;

    public Book() {
    }

    public Book(Long id, String name) {
        this.id = id;
        this.name = name;
    }

    省略 getter/setter以及 toString方法
}

Step4:創建發送消息的生產者

“
這一步內容比較長，會一步一步優化生產者的代碼。
”

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;

@Service
public class BookProducerService {

    private static final Logger logger = LoggerFactory.getLogger(BookProducerService.class);

    private final KafkaTemplate<String, Object> kafkaTemplate;

    public BookProducerService(KafkaTemplate<String, Object> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void sendMessage(String topic, Object o) {
        kafkaTemplate.send(topic, o);
    }
}

我們使用Kafka 提供的 KafkaTemplate 調用 send()方法出入要發往的topic和消息內容即可很方便的完成消息的發送:

  kafkaTemplate.send(topic, o);

如果我們想要知道消息發送的結果的話，sendMessage方法這樣寫：

    public void sendMessage(String topic, Object o) {
        try {
            SendResult<String, Object> sendResult = kafkaTemplate.send(topic, o).get();
            if (sendResult.getRecordMetadata() != null) {
                logger.info("生產者成功發送消息到" + sendResult.getProducerRecord().topic() + "-> " + sendResult.getProducerRecord().value().toString());
            }
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

但是這種屬於同步的發送方式並不推薦，沒有利用到 Future對象的特性。

KafkaTemplate 調用 send()方法實際上返回的是ListenableFuture 對象。

send()方法源碼如下：

	@Override
	public ListenableFuture<SendResult<K, V>> send(String topic, @Nullable V data) {
		ProducerRecord<K, V> producerRecord = new ProducerRecord<>(topic, data);
		return doSend(producerRecord);
	}

ListenableFuture 是Spring提供了繼承自Future 的接口。

ListenableFuture方法源碼如下：

public interface ListenableFuture<T> extends Future<T> {
    void addCallback(ListenableFutureCallback<? super T> var1);

    void addCallback(SuccessCallback<? super T> var1, FailureCallback var2);

    default CompletableFuture<T> completable() {
        CompletableFuture<T> completable = new DelegatingCompletableFuture(this);
        this.addCallback(completable::complete, completable::completeExceptionally);
        return completable;
    }
}

繼續優化sendMessage方法

    public void sendMessage(String topic, Object o) {

        ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(topic, o);
        future.addCallback(new ListenableFutureCallback<SendResult<String, Object>>() {

            @Override
            public void onSuccess(SendResult<String, Object> sendResult) {
                logger.info("生產者成功發送消息到" + topic + "-> " + sendResult.getProducerRecord().value().toString());
            }
            @Override
            public void onFailure(Throwable throwable) {
                logger.error("生產者發送消息：{} 失敗，原因：{}", o.toString(), throwable.getMessage());
            }
        });
    }

使用lambda表達式再繼續優化：

    public void sendMessage(String topic, Object o) {

        ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(topic, o);
        future.addCallback(result -> logger.info("生產者成功發送消息到topic:{} partition:{}的消息", result.getRecordMetadata().topic(), result.getRecordMetadata().partition()),
                ex -> logger.error("生產者發送消失敗，原因：{}", ex.getMessage()));
    }

再來簡單研究一下 send(String topic, @Nullable V data) 方法。

我們使用send(String topic, @Nullable V data)方法的時候實際會new 一個ProducerRecord對象發送，

	@Override
	public ListenableFuture<SendResult<K, V>> send(String topic, @Nullable V data) {
		ProducerRecord<K, V> producerRecord = new ProducerRecord<>(topic, data);
		return doSend(producerRecord);
	}

ProducerRecord類中有多個構造方法:

   public ProducerRecord(String topic, V value) {
        this(topic, null, null, null, value, null);
    }
    public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V
        ......
    }

如果我們想在發送的時候帶上timestamp（時間戳）、key等信息的話，sendMessage()方法可以這樣寫：

    public void sendMessage(String topic, Object o) {
      // 分區編號最好爲 null，交給 kafka 自己去分配
        ProducerRecord<String, Object> producerRecord = new ProducerRecord<>(topic, null, System.currentTimeMillis(), String.valueOf(o.hashCode()), o);
      
        ListenableFuture<SendResult<String, Object>> future = kafkaTemplate.send(producerRecord);
        future.addCallback(result -> logger.info("生產者成功發送消息到topic:{} partition:{}的消息", result.getRecordMetadata().topic(), result.getRecordMetadata().partition()),
                ex -> logger.error("生產者發送消失敗，原因：{}", ex.getMessage()));
    }

Step5:創建消費消息的消費者

通過在方法上使用 @KafkaListener 註解監聽消息，當有消息的時候就會通過 poll 下來消費。

import cn.javaguide.springbootkafka01sendobjects.entity.Book;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Service;

@Service
public class BookConsumerService {

    @Value("${kafka.topic.my-topic}")
    private String myTopic;
    @Value("${kafka.topic.my-topic2}")
    private String myTopic2;
    private final Logger logger = LoggerFactory.getLogger(BookProducerService.class);
    private final ObjectMapper objectMapper = new ObjectMapper();


    @KafkaListener(topics = {"${kafka.topic.my-topic}"}, groupId = "group1")
    public void consumeMessage(ConsumerRecord<String, String> bookConsumerRecord) {
        try {
            Book book = objectMapper.readValue(bookConsumerRecord.value(), Book.class);
            logger.info("消費者消費topic:{} partition:{}的消息 -> {}", bookConsumerRecord.topic(), bookConsumerRecord.partition(), book.toString());
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
    }

    @KafkaListener(topics = {"${kafka.topic.my-topic2}"}, groupId = "group2")
    public void consumeMessage2(Book book) {
        logger.info("消費者消費{}的消息 -> {}", myTopic2, book.toString());
    }
}

Step6:創建一個 Rest Controller

import cn.javaguide.springbootkafka01sendobjects.entity.Book;
import cn.javaguide.springbootkafka01sendobjects.service.BookProducerService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.atomic.AtomicLong;

@RestController
@RequestMapping(value = "/book")
public class BookController {
    @Value("${kafka.topic.my-topic}")
    String myTopic;
    @Value("${kafka.topic.my-topic2}")
    String myTopic2;
    private final BookProducerService producer;
    private AtomicLong atomicLong = new AtomicLong();

    BookController(BookProducerService producer) {
        this.producer = producer;
    }

    @PostMapping
    public void sendMessageToKafkaTopic(@RequestParam("name") String name) {
        this.producer.sendMessage(myTopic, new Book(atomicLong.addAndGet(1), name));
        this.producer.sendMessage(myTopic2, new Book(atomicLong.addAndGet(1), name));
    }
}

Step7:測試

輸入命令：

curl -X POST -F 'name=Java' http://localhost:9090/book

控制檯打印出的效果如下：

my-topic 有2個partition（分區）當你嘗試發送多條消息的時候，你會發現消息會被比較均勻地發送到每個 partion 中。

Kafka系列第三篇！10 分鐘學會如何在 Spring Boot 程序中使用 Kafka 作爲消息隊列?

相關閱讀：

入門篇！大白話帶你認識 Kafka！

5分鐘帶你體驗一把 Kafka

Step1:創建項目

Step2: 配置 Kafka

Step3:創建要發送的消息實體類

Step4:創建發送消息的生產者

Step5:創建消費消息的消費者

Step6:創建一個 Rest Controller

Step7:測試

微信支付重複回調，java微信支付回調問題

JAVA微信支付

你應該只的Redis鎖

還在用AOP做操作日誌嗎?！

spring boot實現動態增刪啓停定時任務

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結