Kafka 11：与springboot整合

最新推荐文章于 2025-06-28 09:20:06 发布
原创 最新推荐文章于 2025-06-28 09:20:06 发布 · 286 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #kafka

本文详细介绍了如何在Spring Boot应用中集成Apache Kafka，包括创建主题、配置生产者和消费者、实现自动与手动提交监听器，以及通过RESTful API发送消息。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.创建主题test（测试自动提交）与testAck（测试手动提交）

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

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2.新建一个空的springboot工程，引入jar包

在这里插入图片描述

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>kafka-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>kafka-springboot</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>2.5.0.RELEASE</version>
        </dependency>
    </dependencies>

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

</project>

3.在配置文件application.properties中添加配置信息

#============== kafka ===================
kafka.consumer.zookeeper.connect=192.168.42.111:2181
kafka.consumer.servers=192.168.42.111:9092
kafka.consumer.enable.auto.commit=true
kafka.consumer.session.timeout=6000
kafka.consumer.auto.commit.interval=100
kafka.consumer.auto.offset.reset=latest
kafka.consumer.topic=test
kafka.consumer.group.id=test
kafka.consumer.concurrency=10

kafka.producer.servers=192.168.42.111:9092
kafka.producer.retries=0
kafka.producer.batch.size=4096
kafka.producer.linger=1
kafka.producer.buffer.memory=40960

4.创建生产者配置类KafkaProducerConfig

package com.example.kafkaspringboot.config;

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 org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

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

@Configuration
@EnableKafka
public class KafkaProducerConfig {
    @Value("${kafka.producer.servers}")
    private String servers;
    @Value("${kafka.producer.retries}")
    private int retries;
    @Value("${kafka.producer.batch.size}")
    private int batchSize;
    @Value("${kafka.producer.linger}")
    private int linger;
    @Value("${kafka.producer.buffer.memory}")
    private int bufferMemory;

    //参数设置
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        //服务地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        //失败重试次数
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        //批量发送数量
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        //延时时间，延时时间到达之后，批量发送数量没达到也会发送消息
        props.put(ProducerConfig.LINGER_MS_CONFIG, linger);
        //缓冲区的大小
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        //序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    //生产者工厂
    public ProducerFactory<String, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs());
    }

    //生产者template
    @Bean
    public KafkaTemplate<String, String> kafkaTemplate() {
        KafkaTemplate kafkaTemplate = new KafkaTemplate(producerFactory());
        return kafkaTemplate;
    }

}

5.创建消费者配置类KafkaConsumerConfig

package com.example.kafkaspringboot.config;

import com.example.kafkaspringboot.service.MyListener;
import com.example.kafkaspringboot.service.MyListenerAck;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.listener.ContainerProperties;

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

@Configuration
@EnableKafka
public class KafkaConsumerConfig {
    @Value("${kafka.consumer.servers}")
    private String servers;
    @Value("${kafka.consumer.enable.auto.commit}")
    private boolean enableAutoCommit;
    @Value("${kafka.consumer.session.timeout}")
    private String sessionTimeout;
    @Value("${kafka.consumer.auto.commit.interval}")
    private String autoCommitInterval;
    @Value("${kafka.consumer.group.id}")
    private String groupId;
    @Value("${kafka.consumer.auto.offset.reset}")
    private String autoOffsetReset;
    @Value("${kafka.consumer.concurrency}")
    private int concurrency;

    //自动确认参数设置
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        //服务地址
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        //自动提交
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        //自动提交间隔
        propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        //超时时间
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
        //设置反序列化
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //群组id
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        //自动从最新的开始消费
        propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return propsMap;
    }

    //消费者工厂
    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
    }
    //注入自动提交监听器
    @Bean("listener")
    public MyListener myListener() {
        return new MyListener();
    }

    //用于扩展监听器，使用时在@KafkaListener(containerFactory="bean的名字")即可
    @Bean("factory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        //指定消费者
        factory.setConsumerFactory(consumerFactory());
        //设置并发量
        factory.setConcurrency(concurrency);
        //设置拉取等待时间
        factory.getContainerProperties().setPollTimeout(1500);
        return factory;
    }

    //手动确认参数设置
    public Map<String, Object> consumerConfigsAck() {
        Map<String, Object> propsMap = new HashMap<>();
        //服务地址
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        //关闭自动提交，设为手动提交
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, false);
        //反序列化
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        //群组id
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        return propsMap;
    }

    public ConsumerFactory<String, String> consumerFactoryAck() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigsAck());
    }

    //注入手动提交监听器
    @Bean("listenerAck")
    public MyListenerAck listenerAck() {
        return new MyListenerAck();
    }

    //用于扩展监听器，使用时在@KafkaListener(containerFactory="bean的名字")即可
    @Bean("factoryAck")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactoryAck() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        //指定消费者
        factory.setConsumerFactory(consumerFactoryAck());
        //设置并发量
        factory.setConcurrency(concurrency);
        //设置拉取等待时间
        factory.getContainerProperties().setPollTimeout(1500);
        //设置手动确认
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL_IMMEDIATE);
        return factory;
    }

}

6.创建自动提交监听器MyListener

package com.example.kafkaspringboot.service;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
/**
 * 自动提交监听器
 */
public class MyListener {

    protected final Logger logger = LoggerFactory.getLogger(MyListener.class);

    @KafkaListener(topics = {"test"}, containerFactory = "factory")
    public void listener(ConsumerRecord<?, ?> record) {
        logger.info("收到消息的key：" + record.key());
        logger.info("收到消息的value：" + record.value());
    }
}

7.创建手动提交监听器MyListenerAck

package com.example.kafkaspringboot.service;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
/**
 * 手动提交监听器
 */
public class MyListenerAck {

    protected final Logger logger = LoggerFactory.getLogger(MyListenerAck.class);

    @KafkaListener(topics = {"testAck"}, containerFactory = "factoryAck")
    public void listener(ConsumerRecord<?, ?> record, Acknowledgment acknowledgment) {
        try {
            logger.info("手动确认收到消息的key：" + record.key());
            logger.info("手动确认收到消息的value：" + record.value());
        } finally {
            logger.info("消息确认！");
            acknowledgment.acknowledge();
        }
    }
}

8.创建KafkaController

package com.example.kafkaspringboot.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/kafka")
public class KafkaController {
    protected final Logger logger = LoggerFactory.getLogger(this.getClass());
    @Autowired
    private KafkaTemplate kafkaTemplate;

    //自动提交
    @RequestMapping("/send")
    public String send(@RequestParam(required = false) String key, @RequestParam(required = false) String value) {
        try {
            logger.info("kafka的消息：{}", value);
            kafkaTemplate.send("test", key, value);
            return "发送成功！";
        } catch (Exception e) {
            logger.info("发送异常：{}", e);
            return "发送失败！";
        }
    }

    //手动提交
    @RequestMapping("/sendAck")
    public String sendAck(@RequestParam(required = false) String key, @RequestParam(required = false) String value) {
        try {
            logger.info("kafka的消息：{}", value);
            kafkaTemplate.send("testAck", key, value);
            return "发送成功！";
        } catch (Exception e) {
            logger.info("发送异常：{}", e);
            return "发送失败！";
        }
    }
}

9.启动程序

在这里插入图片描述

10.请求手动提交接口，“http://localhost:8080/kafka/sendAck?key=Fisher&value=fakfaAck”，并查看打印

在这里插入图片描述
在这里插入图片描述

11.请求自动提交接口，“http://localhost:8080/kafka/send?key=Fisher&value=queue”，并查看打印

在这里插入图片描述
在这里插入图片描述

【微服务】springboot整合kafka-stream使用详解
congge
12-24 1万+
kafka stream使用详解
Kafka【七】SpringBoot整合kafka实践
小小默：进无止境
09-04 735
这里SpringBoot为3.0.5，jdk为17，kafka-clients为3.6.1
Spring Boot 中整合 Kafka
qq_43197840的博客
09-20 1700
通过以上步骤，我们成功地在 Spring Boot 中整合了 Kafka，并实现了消息的生产和消费。Spring Kafka 提供了简单易用的 API，使得我们可以轻松地与 Kafka 进行交互。你可以根据实际需求进一步扩展和优化这个示例。在 Kafka 中，消费者消费消息失败后是否重新入队（重回队列）取决于消费者的配置和处理逻辑。Kafka 本身并没有直接提供“消费失败重回队列”的功能，但可以通过一些策略来实现类似的效果。
Spring Boot 集成 Kafka
Casual_Lei的博客
07-25 2170
Spring Boot 与 Kafka 的集成使得消息队列的使用变得更加简单和高效。通过上述步骤，你可以轻松地配置 Kafka、实现生产者和消费者，并利用 Spring Boot 提供的强大功能来处理消息流。了解 Kafka 的高级特性（如事务和异步处理）能够帮助你更好地满足业务需求，确保系统的高可用性和数据一致性。
【Kafka】SpringBoot整合Kafka详细介绍及代码示例
分享学习
06-13 6073
Apache Kafka是一个分布式流处理平台。它最初由LinkedIn开发，后来成为Apache软件基金会的一部分，并在开源社区中得到了广泛应用。Kafka的核心概念包括Producer、Consumer、Broker、Topic、Partition和Offset。Producer：生产者，负责将数据发送到Kafka集群。Consumer：消费者，从Kafka集群中读取数据。Broker：Kafka服务器实例，Kafka集群通常由多个Broker组成。Topic：主题，数据按主题进行分类。
SpringBoot整合kafka
06-14
SpringBoot整合kafka代码，两个工程 一个消费者 一个生产者，利用定时任务。很简洁代码。欢迎大家下载哦。可参考这篇文章代码哦。https://blog.csdn.net/weixin_39984161/article/details/91986809
SpringBoot-整合Kafka
BAOZEBING的博客
04-20 280
Kafka Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。该项目的目标是为处理实时数据提供一个统一、高吞吐、低延迟的平台。其持久化层本质上是一个“按照分布式事务日志架构的大规模发布/订阅消息队列”，[3]这使它作为企业级基础设施来处理流式数据非常有价值。此外，Kafka可以通过Kafka Connect连接到外部系统（用于数据输入/输出），并提供了Kafka Streams一个Java流式处理库。 Kafka存储的消息来自任意多被称为“生产者”（Producer
【SpringBoot高级】SpringBoot与Kafka深度整合：从入门到企业级实战
最新发布
2401_86224057的博客
06-28 508
通过这篇全面的技术博客，我们详细探讨了SpringBoot与Kafka的集成，从基础概念到高级特性，再到实际应用场景和最佳实践。希望这篇内容能够帮助开发者构建高效、可靠的基于Kafka的消息系统，并在实际项目中取得成功。随着技术的不断发展，SpringBoot和Kafka的集成将会变得更加强大和易用，值得我们持续关注和学习。
Kafka架构知识&springboot整合实战
m0_71332765的博客
06-10 664
有两种主要的消息传递模式：点对点传递模式、发布-订阅模式。 ⼤部分的消息系统选⽤发布-订阅模式。Kafka就是⼀种发布-订阅模式。 消息分推拉两种模式。 ①生产者发送信息（信息包含主题，key，值），发布到特定主题， ②由broker接收，提交至磁盘，通过轮询方式（也可以其他自定义方式，比如key的散列值）进行分区 ③消费者根据订阅主题消费信息，（通过消息偏移量判断是否已读） Kafka只有消息的拉取，没有推送，可以通过轮询实现消息的推送
springboot集成kafka0.10.0.1并发送邮件项目
07-11
springboot集成kafka0.10.0.1 实现监听topic 接收消息发送到指定邮箱里，并往topic中发送消息的一个小项目。
springboot集成kafka进行消息发布和订阅jar
05-22
java程序实现springboot集成kafka进行消息发布和订阅并打包，可直接进行linux主机应用。支持动态修改kafka集群配置，和监听主题；支持动态指向jdk版本。
Spring Boot集成Kafka：最佳实践与详细指南
热门推荐
勤劳的小琪
05-17 1万+
本文详细介绍了如何在Spring Boot项目中集成Kafka，并通过最佳实践和代码示例来指导你。通过合理配置Kafka、使用KafkaTemplate发送消息、使用@KafkaListener接收消息以及处理错误和监控，你可以轻松地构建高效、可靠的消息处理系统。希望本文对你有所帮助！
Kafka 入门和 Spring Boot 集成
蒋先生
06-05 984
Kafka 入门和 Spring Boot 集成 Kafka 入门和 Spring Boot 集成 概述 应用场景 基本概念 基本结构 和Spring Boot 集成 集成概述 集成环境 kafka 环境搭建 Spring Boot 和 Spring for Apache Kafka 集成步骤 最后 概述 kafka 是一个高性能的消息队列，也是一个分布式流处理平...
SpringBoot整合Kafka
ITBOY_ITBOX博客
10-11 1149
使用注解@KafkaListener定义当前方法监听Kafka中指定topic的消息，接收到的消息封装在对象ConsumerRecord中，获取数据从ConsumerRecord对象中获取即可。运行bin目录下的windows目录下的kafka-server-start命令即可启动kafka服务器，默认对外服务端口9092。Kafka提供有一套测试服务器功能的测试程序，运行bin目录下的windows目录下的命令即可使用。：使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息。
Kafka和SpringBoot整合实现消息发送与消费
chuangdi4123的博客
07-09 493
kafka和zookeeper集群前边写过了。如果遇到kakfa说没有连接记得把kafka下logs日志都删除了，重新启动kafka集群再启动springboot服务 zookeeper https://my.oschina.net/u/3730149/blog/3071737 kafka ...
Spring Boot整合Kafka
q1372302825的博客
03-01 3935
Kafka作为一款分布式流处理平台，具有高吞吐量、持久性、容错性等特点，适用于构建大规模的实时数据管道。Spring Boot作为快速开发框架，提供了简化开发和部署的能力，使得与Kafka的整合变得更加容易。通过将Spring Boot与Kafka进行整合，具有以下优势异步消息处理：Kafka可以作为消息队列，实现异步消息的生产和消费，提高系统的吞吐量和响应速度。解耦和扩展性：消息队列的引入可以解耦不同系统或模块之间的依赖关系，提高系统的灵活性和可维护性。数据流处理。
Springboot整合Kafka
Wangyu的博客
08-08 896
Springboot整合Kafka
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fisher3652

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值