Spring Boot 集成Kafka简单应用

已于 2023-11-29 20:18:09 修改
阅读量2.1k 收藏 4
点赞数
分类专栏： Kafka 文章标签： kafka
于 2023-05-31 22:21:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y_bccl27/article/details/130977772
版权

说明：当前kafka的版本为2.8.11，Spring Boot的版本为2.7.6。

第一步：在pom.xml中引入下述依赖

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

第二步：在yml配置文件进行如下配置

spring:
  kafka:
    # kafka服务的地址
    bootstrap-servers: 127.0.0.1:9092
    producer:
      # key-value序列化
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
    consumer:
      # 设置默认的消费者所属组id 
      group-id: 0
      # key-value反序列化  
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer

第三步：创建生产者

package com.example.demo.kafka;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
@RequestMapping("kafka")
public class KafkaProducer {

    // 自定义topic
    public static final String TOPIC_NAME="topic.one";

    @Autowired
    private KafkaTemplate<String, String> kafkaTemplate;

    @RequestMapping("send")
    public String send(@RequestParam("msg")String msg) {
        log.info("准备发送消息为：{}",msg);
        // 1.发送消息
        ListenableFuture<SendResult<String,String>> future=kafkaTemplate.send(TOPIC_NAME,msg);
        future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                // 2.发送失败的处理
                log.error("生产者 发送消息失败："+throwable.getMessage());
            }
            @Override
            public void onSuccess(SendResult<String, String> stringObjectSendResult) {
                // 3.发送成功的处理
                log.info("生产者 发送消息成功："+stringObjectSendResult.toString());
            }
        });
        return "接口调用成功";
    }
}

注意：当kafka中没有名为topic.one的主题时程序会自动创建，其实这里的主题就相当于rabbitmq中的队列。

第四步：创建消费者

package com.example.demo.kafka;

import java.util.Optional;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class KafkaConsumer {

    // 自定义topic
    public static final String TOPIC_NAME="topic.one";

    @KafkaListener(topics = TOPIC_NAME, groupId = "ONE")
    public void topic_one(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        Optional message = Optional.ofNullable(record.value());
        if (message.isPresent()) {
            Object msg = message.get();
            log.info("消费者One消费了： +++++++++++++++ Topic:" + topic + ",Record:" + record + ",Message:" + msg);
        }
    }

    @KafkaListener(topics = TOPIC_NAME, groupId = "TWO")
    public void topic_two(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        Optional message = Optional.ofNullable(record.value());
        if (message.isPresent()) {
            Object msg = message.get();
            log.info("消费者TwO消费了： +++++++++++++++ Topic:" + topic + ",Record:" + record + ",Message:" + msg);
        }
    }
}

第五步：启动项目，在postman中访问请求下述接口

http://127.0.0.1:8080/kafka/send?msg=测试数据

​

项目启动后首次调用该接口控制台会输出如下日志：

2023-05-31 22:09:50.935  INFO 20036 --- [nio-8080-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-05-31 22:09:50.935  INFO 20036 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-05-31 22:09:50.936  INFO 20036 --- [nio-8080-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 1 ms
2023-05-31 22:09:50.963  INFO 20036 --- [nio-8080-exec-1] com.example.demo.kafka.KafkaProducer     : 准备发送消息为：测试数据
2023-05-31 22:09:50.966  INFO 20036 --- [nio-8080-exec-1] o.a.k.clients.producer.ProducerConfig    : ProducerConfig values: 
	acks = -1
	batch.size = 16384
	bootstrap.servers = [127.0.0.1:9092]
	buffer.memory = 33554432
	client.dns.lookup = use_all_dns_ips
	client.id = producer-1
	compression.type = none
	connections.max.idle.ms = 540000
	delivery.timeout.ms = 120000
	enable.idempotence = true
	interceptor.classes = []
	key.serializer = class org.apache.kafka.common.serialization.StringSerializer
	linger.ms = 0
	max.block.ms = 60000
	max.in.flight.requests.per.connection = 5
	max.request.size = 1048576
	metadata.max.age.ms = 300000
	metadata.max.idle.ms = 300000
	metric.reporters = []
	metrics.num.samples = 2
	metrics.recording.level = INFO
	metrics.sample.window.ms = 30000
	partitioner.class = class org.apache.kafka.clients.producer.internals.DefaultPartitioner
	receive.buffer.bytes = 32768
	reconnect.backoff.max.ms = 1000
	reconnect.backoff.ms = 50
	request.timeout.ms = 30000
	retries = 2147483647
	retry.backoff.ms = 100
	sasl.client.callback.handler.class = null
	sasl.jaas.config = null
	sasl.kerberos.kinit.cmd = /usr/bin/kinit
	sasl.kerberos.min.time.before.relogin = 60000
	sasl.kerberos.service.name = null
	sasl.kerberos.ticket.renew.jitter = 0.05
	sasl.kerberos.ticket.renew.window.factor = 0.8
	sasl.login.callback.handler.class = null
	sasl.login.class = null
	sasl.login.connect.timeout.ms = null
	sasl.login.read.timeout.ms = null
	sasl.login.refresh.buffer.seconds = 300
	sasl.login.refresh.min.period.seconds = 60
	sasl.login.refresh.window.factor = 0.8
	sasl.login.refresh.window.jitter = 0.05
	sasl.login.retry.backoff.max.ms = 10000
	sasl.login.retry.backoff.ms = 100
	sasl.mechanism = GSSAPI
	sasl.oauthbearer.clock.skew.seconds = 30
	sasl.oauthbearer.expected.audience = null
	sasl.oauthbearer.expected.issuer = null
	sasl.oauthbearer.jwks.endpoint.refresh.ms = 3600000
	sasl.oauthbearer.jwks.endpoint.retry.backoff.max.ms = 10000
	sasl.oauthbearer.jwks.endpoint.retry.backoff.ms = 100
	sasl.oauthbearer.jwks.endpoint.url = null
	sasl.oauthbearer.scope.claim.name = scope
	sasl.oauthbearer.sub.claim.name = sub
	sasl.oauthbearer.token.endpoint.url = null
	security.protocol = PLAINTEXT
	security.providers = null
	send.buffer.bytes = 131072
	socket.connection.setup.timeout.max.ms = 30000
	socket.connection.setup.timeout.ms = 10000
	ssl.cipher.suites = null
	ssl.enabled.protocols = [TLSv1.2]
	ssl.endpoint.identification.algorithm = https
	ssl.engine.factory.class = null
	ssl.key.password = null
	ssl.keymanager.algorithm = SunX509
	ssl.keystore.certificate.chain = null
	ssl.keystore.key = null
	ssl.keystore.location = null
	ssl.keystore.password = null
	ssl.keystore.type = JKS
	ssl.protocol = TLSv1.2
	ssl.provider = null
	ssl.secure.random.implementation = null
	ssl.trustmanager.algorithm = PKIX
	ssl.truststore.certificates = null
	ssl.truststore.location = null
	ssl.truststore.password = null
	ssl.truststore.type = JKS
	transaction.timeout.ms = 60000
	transactional.id = null
	value.serializer = class org.apache.kafka.common.serialization.StringSerializer

2023-05-31 22:09:50.973  INFO 20036 --- [nio-8080-exec-1] o.a.k.clients.producer.KafkaProducer     : [Producer clientId=producer-1] Instantiated an idempotent producer.
2023-05-31 22:09:50.982  INFO 20036 --- [nio-8080-exec-1] o.a.kafka.common.utils.AppInfoParser     : Kafka version: 3.1.2
2023-05-31 22:09:50.982  INFO 20036 --- [nio-8080-exec-1] o.a.kafka.common.utils.AppInfoParser     : Kafka commitId: f8c67dc3ae0a3265
2023-05-31 22:09:50.982  INFO 20036 --- [nio-8080-exec-1] o.a.kafka.common.utils.AppInfoParser     : Kafka startTimeMs: 1685542190982
2023-05-31 22:09:50.991  INFO 20036 --- [ad | producer-1] org.apache.kafka.clients.Metadata        : [Producer clientId=producer-1] Resetting the last seen epoch of partition topic.one-0 to 0 since the associated topicId changed from null to A8Lfh0GZQ3GR6fUo-OvcAQ
2023-05-31 22:09:50.991  INFO 20036 --- [ad | producer-1] org.apache.kafka.clients.Metadata        : [Producer clientId=producer-1] Cluster ID: 0YMM4442QOyhnWsg0zfjig
2023-05-31 22:09:50.992  INFO 20036 --- [ad | producer-1] o.a.k.c.p.internals.TransactionManager   : [Producer clientId=producer-1] ProducerId set to 4 with epoch 0
2023-05-31 22:09:51.020  INFO 20036 --- [ad | producer-1] com.example.demo.kafka.KafkaProducer     : 生产者 发送消息成功：SendResult [producerRecord=ProducerRecord(topic=topic.one, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=测试数据, timestamp=null), recordMetadata=topic.one-0@7]
2023-05-31 22:09:51.025  INFO 20036 --- [ntainer#1-0-C-1] com.example.demo.kafka.KafkaConsumer     : 消费者TwO消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, leaderEpoch = 0, offset = 7, CreateTime = 1685542190992, serialized key size = -1, serialized value size = 12, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 测试数据),Message:测试数据
2023-05-31 22:09:51.025  INFO 20036 --- [ntainer#0-0-C-1] com.example.demo.kafka.KafkaConsumer     : 消费者One消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, leaderEpoch = 0, offset = 7, CreateTime = 1685542190992, serialized key size = -1, serialized value size = 12, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 测试数据),Message:测试数据

第二次调用该接口，其输出日志则比较简洁：

2023-05-31 22:11:13.130  INFO 20036 --- [nio-8080-exec-3] com.example.demo.kafka.KafkaProducer     : 准备发送消息为：测试数据
2023-05-31 22:11:13.135  INFO 20036 --- [ad | producer-1] com.example.demo.kafka.KafkaProducer     : 生产者 发送消息成功：SendResult [producerRecord=ProducerRecord(topic=topic.one, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=测试数据, timestamp=null), recordMetadata=topic.one-0@8]
2023-05-31 22:11:13.144  INFO 20036 --- [ntainer#0-0-C-1] com.example.demo.kafka.KafkaConsumer     : 消费者One消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, leaderEpoch = 0, offset = 8, CreateTime = 1685542273130, serialized key size = -1, serialized value size = 12, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 测试数据),Message:测试数据
2023-05-31 22:11:13.144  INFO 20036 --- [ntainer#1-0-C-1] com.example.demo.kafka.KafkaConsumer     : 消费者TwO消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, leaderEpoch = 0, offset = 8, CreateTime = 1685542273130, serialized key size = -1, serialized value size = 12, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 测试数据),Message:测试数据

如上面代码所示，程序创建了两个消息消费者，每个消费者都监听来自主题topic_one的消息，唯一不同的是两个消费者分别属于不同的组别，即groupId设置不同。由此可见一条消息分别被两个不同的消费者消费，由此达到了广播的效果。

如果不需要每个消费者都读取到重复的消息该如何配置？

答案：采用相同消费组唯一消费模式

package com.example.demo.kafka;

import java.util.Optional;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class KafkaConsumer {

    // 自定义topic
    public static final String TOPIC_NAME="topic.one";

    @KafkaListener(topics = TOPIC_NAME, groupId = "ONE")
    public void topic_one(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        Optional message = Optional.ofNullable(record.value());
        if (message.isPresent()) {
            Object msg = message.get();
            log.info("消费者One消费了： +++++++++++++++ Topic:" + topic + ",Record:" + record + ",Message:" + msg);
        }
    }

    @KafkaListener(topics = TOPIC_NAME, groupId = "ONE")
    public void topic_two(ConsumerRecord<?, ?> record, @Header(KafkaHeaders.RECEIVED_TOPIC) String topic) {
        Optional message = Optional.ofNullable(record.value());
        if (message.isPresent()) {
            Object msg = message.get();
            log.info("消费者TwO消费了： +++++++++++++++ Topic:" + topic + ",Record:" + record + ",Message:" + msg);
        }
    }
}

上述代码与前段代码唯一的区别在于，两个消费者的组别设置成了一样的。再次调用上述接口，查看程序日志如下：

2023-05-31 22:19:31.953  INFO 17084 --- [nio-8080-exec-5] com.example.demo.kafka.KafkaProducer     : 准备发送消息为：测试数据
2023-05-31 22:19:31.956  INFO 17084 --- [ad | producer-1] com.example.demo.kafka.KafkaProducer     : 生产者 发送消息成功：SendResult [producerRecord=ProducerRecord(topic=topic.one, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=测试数据, timestamp=null), recordMetadata=topic.one-0@11]
2023-05-31 22:19:31.957  INFO 17084 --- [ntainer#0-0-C-1] com.example.demo.kafka.KafkaConsumer     : 消费者One消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, leaderEpoch = 0, offset = 11, CreateTime = 1685542771953, serialized key size = -1, serialized value size = 12, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 测试数据),Message:测试数据

从日志可以看出无论访问多少次，只会有一个消费者消费了消息，因此达到了不重复消费的目的。 

y_bccl27
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
报错no native library is found for os.name=Mac and os.arch=aarch64
qq_42685053的博客
07-10 2618
kafka,报错信息
IDEA中运行Dinky0.7.5之KAFKA数据源调试问题解决过程
u010782920的博客
12-01 1562
IDEA中运行Dinky0.7.5之KAFKA数据源调试问题解决过程 java.lang.ClassCastException: cannot assign instance of org.apache.kafka.clients.consumer.OffsetResetStrategy to org.apache.flink.kafka.shaded.org.apache.kafka.clients.consumer.OffsetResetStrategy
SpringBoot集成Kafka之SASL_SSL
最新发布
pleaseprintf的博客
04-15 993
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。Kafka 是一个由 LinkedIn 开发的分布式消息系统，它于2011年年初开源，现在由著名的 Apache 基金会维护与开发。Kafka 使用 Scala 实现，被用作 LinkedIn 的活动流和运营数据处理的管道，现在也被诸多互联网企业广泛地用作数据流管道和消息系统， Kafka 是基于消息发布﹣订阅模式实现的消息系统。
spring boot集成kafka
08-26
压缩包中有两个集成kafka的项目，第一个是spring boot默认的集成方式kafkaTest1，第二个是springboot集成插件spring-integration-kafka来配置的
spring boot与kafka集成的简单实例
08-29
本篇文章主要介绍了spring boot与kafka集成的简单实例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Spring Boot集成Kafka的示例代码
08-27
本篇文章主要介绍了Spring Boot集成Kafka的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SpringBoot——集成Kafka详解
热门推荐
吴声子夜歌的博客
08-21 2万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；若发送消息时未指定 patition，但指定了 key（kafka允许为每条消息设置一个key），则对key值进行hash计算，根据计算结果路由到指定分区，这种情况下可以保证同一个 Key 的所有消息都进入到相同的分区；
SpringBoot集成Kafka
编码人生
12-10 6743
啦啦啦啦啦，富贵同学又开始开坑了，出了个免费的专栏，主要给大家从0基础开始用springBoot集成第三方的插件或者功能，如果这篇专栏能帮到你，一定不要忘了点一个赞哦！！欢迎大家收藏分享 第一步，导入jar包 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifac
Spring Boot 整合 kafka
qq_43842093的博客
04-25 4447
启动方式参考上一篇文章，
Kafka集成Spring初探
2301_79056298的博客
07-16 723
原文转载自首先需要搭建broker集群（本次实验搭建3台，伪集群单机部署3台），然后在Spring容器中启动生产者、消费者，与borker集群交互。
Springboot 集成kafka
axibazZ的博客
09-17 4806
解释：这里定义了消费者id为ifun-001，消费者组id为ifun-01，同时监听两个topic，ifun1和ifun2，其中监听ifun1的0号分区，ifun2的0号和1号分区，其中1号分区开始的offset为8，也就是说如果next-offset大于8就会消费，小于8不会消费。消息过滤器可以在消息抵达consumer之前被拦截，在实际应用中，我们可以根据自己的业务逻辑，筛选出需要的信息再交由KafkaListener处理，不需要的消息则过滤掉。二、修改application.yml配置。
Spring boot集成Kafka消息中间件代码实例
08-19
主要介绍了Spring boot集成Kafka消息中间件代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring boot 与kafka集成的示例代码
08-27
主要介绍了spring boot 与kafka集成的示例代码，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Springboot集成kafka(环境搭建+演示)|超级详细，建议收藏
SuiHao
03-03 1万+
上一期，我是带着大家入门了SpringBoot整合WebSocket，今天我再来一期kafka的零基础教学吧。不知道大家对kafka有多少了解，反正我就是从搭建开始，然后再加一个简单演示，这就算是带着大家了个门哈，剩下的我再后边慢慢出教程给大家说。/**log . info("topic.group1 消费了： Topic:" + topic + ",Message:" + msg);
工程师&程序员的自我修养 Episode.4 基于百度飞桨PaddlePaddle框架的女朋友情绪分析&防被打消息推荐深度学习系统
weixin_43833550的博客
03-17 1490
具体为什么想到这个题目呢。。。大概是我也想不出别的什么有趣的话题或者项目的工作了吧。 有一天，柏拉图问老师苏格拉底什么是爱情？老师就让他到理论麦田里去，摘一棵全麦田里最大最金黄的麦穗来，期间只能摘一次，并且只可向前走，不能回头。柏拉图于是按照老师说的去做了。结果他两手空空走出了田地，老师问他为什么摘不到。他说：“因为期间只能摘一次，又不能走回头路，期间即使见到最大最金黄的，因为不知前面是否有更好的，所以没有摘；走到前面时，又发觉总不及之前见到的好，原来最大最金黄的麦穗早错过了；于是我什么也没有摘。”老师说
SpringBoot整合Kafka
JohnieLi的博客
11-29 6016
前面两个章节我们把Kafka给安装起来然后使用命令演示是生产和消费的过程，以及Kafka的架构原理，接下来就是Kafka的实战使用，顺应如今企业流行的开发模式，当然要使用SpringBoot和Kafka进行整合。
Spring boot集成kafka(windows)
m0_72167535的博客
12-31 1934
Spring boot集成kafka(windows)
springBoot集成Kafka
weixin_66545010的博客
07-06 6198
spring boot集成Kafka
Spring Boot 集成 Kafka
04-07
Spring Boot可以轻松地集成Kafka，使得应用程序可以轻松地使用Kafka进行消息传递。 以下是Spring Boot集成Kafka的步骤： 1. 添加Kafka依赖 在pom.xml文件中添加以下依赖： ``` <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 2. 创建Kafka配置 在application.properties文件中添加以下配置： ``` spring.kafka.bootstrap-servers=localhost:9092 spring.kafka.consumer.group-id=my-group spring.kafka.consumer.auto-offset-reset=earliest spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer ``` 3. 创建生产者 创建一个Kafka生产者，用于将消息发送到Kafka中： ``` @Service public class KafkaProducerService { @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { kafkaTemplate.send(topic, message); } } ``` 4. 创建消费者 创建一个Kafka消费者，用于从Kafka中接收消息： ``` @Service public class KafkaConsumerService { @KafkaListener(topics = "my-topic") public void listen(String message) { System.out.println("Received message: " + message); } } ``` 5. 发送和接收消息 在应用程序中使用KafkaProducerService发送消息，使用KafkaConsumerService接收消息： ``` @Autowired private KafkaProducerService kafkaProducerService; public void sendMessage() { kafkaProducerService.sendMessage("my-topic", "Hello Kafka!"); } ``` 6. 运行应用程序 运行应用程序，发送和接收Kafka消息。 以上就是Spring Boot集成Kafka的步骤。通过使用Spring Boot和Kafka，可以轻松地构建可扩展的应用程序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值