### Spring Boot 整合
Kafka 配置教程
#### 1. 添加依赖
为了使 Spring Boot 应用程序能够与
Kafka 进行交互，需要在 `pom.xml` 文件中添加相应的 Maven 依赖项。这一步骤确保应用程序可以访问
Kafka 客户端库和其他必要的组件[^1]。
```xml
<dependency>
<groupId>org.springframework.
kafka</groupId>
<artifactId>spring-
kafka</artifactId>
</dependency>
```
#### 2. 配置
Kafka 设置
接下来，在 Spring Boot 项目的配置文件 (`application.properties` 或 `application.yml`) 中定义
Kafka 的连接参数以及其他重要的属性设置。这些配置指定了如何连接到
Kafka 集群以及消费者的行为模式[^2]。
对于 `application.properties`：
```properties
spring.
kafka.bootstrap-servers=localhost:9092
spring.
kafka.consumer.group-id=my-group
spring.
kafka.consumer.auto-offset-reset=earliest
```
而对于 `application.yml` 则如下所示：
```yaml
spring:
kafka:
bootstrap-servers: localhost:9092
consumer:
group-id: my-group
auto-offset-reset: earliest
```
以上配置允许应用通过指定地址连接至本地运行的单节点
Kafka 实例，并为消费组设定了唯一标识符；同时设置了当没有初始偏移量或当前偏移量不再存在时从最早的消息开始读取。
#### 3. 创建生产者和消费者逻辑
##### 生产者部分
- **引入库**
已经完成于第一步中的 pom.xml 修改。
- **配置类 PublicConfig.java**
此 Java 类用于提供
KafkaTemplate Bean 来发送消息给主题(topic)，并可自定义序列化器等选项[^4]。
```java
import org.apache.
kafka.clients.producer.ProducerConfig;
import org.apache.
kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.
kafka.core.Default
KafkaProducerFactory;
import org.springframework.
kafka.core.
KafkaTemplate;
import org.springframework.
kafka.core.ProducerFactory;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class PublicConfig {
@Bean
public ProducerFactory<String, String> producerFactory() {
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);
return new Default
KafkaProducerFactory<>(configProps);
}
@Bean
public
KafkaTemplate<String, String>
kafkaTemplate() {
return new
KafkaTemplate<>(producerFactory());
}
}
```
- **业务处理类 MessageProducer.java**
该类负责实际向特定的主题发布消息。
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.
kafka.core.
KafkaTemplate;
import org.springframework.stereotype.Service;
@Service
public class MessageProducer {
private final
KafkaTemplate<String, String>
kafkaTemplate;
@Autowired
public MessageProducer(
KafkaTemplate<String, String>
kafkaTemplate) {
this.
kafkaTemplate =
kafkaTemplate;
}
public void sendMessage(String topicName, String message){
System.out.println("Publishing to Topic:" +topicName+" Message:"+message);
kafkaTemplate.send(topicName,message);
}
}
```
##### 消费者部分
同样地，也需要编写对应的接收方代码来监听来自某个主题的信息流。
- **引入库**
同上。
- **配置类 PublicConfig.java (扩展)**
除了上述提到的内容外，还需要增加 ConsumerFactory 和 Concurrent
KafkaListenerContainerFactory Beans 的声明以便支持消息监听功能。
```java
import org.apache.
kafka.clients.consumer.ConsumerConfig;
import org.apache.
kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.
kafka.annotation.Enable
Kafka;
import org.springframework.
kafka.config.Concurrent
KafkaListenerContainerFactory;
import org.springframework.
kafka.core.ConsumerFactory;
import org.springframework.
kafka.core.Default
KafkaConsumerFactory;
import org.springframework.
kafka.listener.ContainerProperties.AckMode;
@Enable
Kafka
@Configuration
public class PublicConfig extends BasePublicConfig { // 假设有BasePublicConfig继承
@Bean
public ConsumerFactory<String, String> consumerFactory() {
Map<String, Object> props = new HashMap<>();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "my-group");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
return new Default
KafkaConsumerFactory<>(props);
}
@Bean
public Concurrent
KafkaListenerContainerFactory<String, String>
kafkaListenerContainerFactory() {
Concurrent
KafkaListenerContainerFactory<String, String> factory =
new Concurrent
KafkaListenerContainerFactory<>();
factory.setConsumerFactory(consumerFactory());
factory.getContainerProperties().setAckMode(AckMode.MANUAL_IMMEDIATE); // 手动确认机制
return factory;
}
}
```
- **业务类 MessageConsumer.java**
最终实现具体的消费行为，即每当有新消息到达时触发的方法体。
```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.
kafka.annotation.
KafkaListener;
import org.springframework.
kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;
@Component
public class MessageConsumer {
private static final Logger logger = LoggerFactory.getLogger(MessageConsumer.class);
@
KafkaListener(topics = "${
kafka.topic.name}", groupId = "${spring.
kafka.consumer.group-id}")
public void listen(String message, Acknowledgment acknowledgment) throws Exception {
try{
logger.info("Received Message: {}", message);
Thread.sleep(1000L); // Simulate processing time.
acknowledgment.acknowledge(); // Manually acknowledge the receipt of messages after successful processing.
} catch(Exception e){
throw new RuntimeException(e.getMessage(),e.getCause());
}
}
}
```
扫一扫
1293
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
