springboot 整合 kafka 如何實現消息優先級

在 Spring Boot 中整合 Kafka 并實現消息優先級，你需要遵循以下步驟：

1. 添加依賴

在你的 pom.xml 文件中添加 Kafka 和 Spring Kafka 相關的依賴：

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

2. 配置 Kafka

在你的 application.yml 或 application.properties 文件中配置 Kafka 相關參數：

spring:
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: my-group
      auto-offset-reset: earliest
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

3. 創建消息優先級配置類

創建一個配置類，用于設置 Kafka 生產者的消息優先級屬性：

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

@Configuration
public class KafkaProducerConfig {

    @Value("${spring.kafka.producer.properties.priority.enable}")
    private boolean priorityEnable;

    @Bean
    public Map<String, Object> producerConfigs() {
        Map<String, Object> configProps = new HashMap<>();
        configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
        configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);

        if (priorityEnable) {
            configProps.put(ProducerConfig.PRIORITY_CONFIG, 1); // 設置消息優先級，數值越大優先級越高
        }

        return configProps;
    }
}

4. 創建 Kafka 生產者

創建一個 Kafka 生產者類，使用上面配置的屬性發送消息：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class KafkaProducerService {

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    public void sendMessage(String topic, String message, int priority) {
        ProducerRecord<String, String> record = new ProducerRecord<>(topic, message);
        record.headers().add("priority", String.valueOf(priority).getBytes());
        kafkaTemplate.send(record);
    }
}

5. 創建 Kafka 消費者

創建一個 Kafka 消費者類，訂閱指定主題并處理消息：

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.stereotype.Component;

import java.time.Duration;
import java.util.Collections;
import java.util.Properties;

@Component
public class KafkaConsumerService {

    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;

    @Value("${spring.kafka.consumer.auto-offset-reset}")
    private String autoOffsetReset;

    @Value("${spring.kafka.consumer.key-deserializer}")
    private String keyDeserializer;

    @Value("${spring.kafka.consumer.value-deserializer}")
    private String valueDeserializer;

    @Bean
    public ConsumerConfig consumerConfig() {
        return new ConsumerConfig(
                Collections.singletonMap(ConsumerConfig.GROUP_ID_CONFIG, groupId),
                Collections.singletonMap(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092"),
                Collections.singletonMap(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, keyDeserializer),
                Collections.singletonMap(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, valueDeserializer),
                Duration.ofMillis(3000)
        );
    }

    @KafkaListener(topics = "${spring.kafka.consumer.topic}", groupId = groupId)
    public void listen(ConsumerRecords<String, String> records) {
        records.forEach(record -> {
            // 處理消息邏輯
            System.out.println("Received message: " + record.value() + " with priority: " + record.headers().get("priority"));
        });
    }
}

現在，你已經成功整合了 Kafka 并實現了消息優先級。當你使用 KafkaProducerService 發送消息時，可以通過設置 priority 參數來指定消息優先級。消費者在處理消息時，可以從消息頭中獲取優先級信息。