SpringBoot集成Kafka简单应用

最新推荐文章于 2024-06-02 19:29:15 发布
最新推荐文章于 2024-06-02 19:29:15 发布
阅读量2k 收藏 5
点赞数 3
分类专栏： 消息中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/honger_hua/article/details/100160217
版权

                                SpringBoot集成Kafka简单应用

 

        windows下搭建kafaka开发环境请参考-Windows平台kafka环境的搭建

 

1：  pom文件引入kafka所需jar包

<!--kafka支持-->
<dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
    <version>1.3.5.RELEASE</version><!--$NO-MVN-MAN-VER$-->
</dependency>

 

2：配置文件application.properties加入如下配置

#kafka相关配置
spring.kafka.bootstrap-servers=127.0.0.1:9092
#设置一个默认组
spring.kafka.consumer.group-id=0
#key-value序列化反序列化
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
#每次批量发送消息的数量
spring.kafka.producer.batch-size=65536
spring.kafka.producer.buffer-memory=524288

3：创建项目启动类

package spark;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringkafkaproducerApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringkafkaproducerApplication.class, args);
    }
}

4：创建kafaka消息发送类

package spark;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

@RestController
@RequestMapping("kafka")
public class KafkaProducer {
	 private static final Logger logger = LoggerFactory.getLogger(KafkaProducer.class);
	 
	 //自定义topic
	   public static final String TOPIC_ONE="topic.one";

	@Autowired
	private KafkaTemplate<String, String> kafkaTemplate;

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

	   }
	

}

5：启动项目访问连接http://localhost:8888/kafka/send?msg=saa1111s

控制台会打出如下日志：

16:06:03.752 [http-nio-8888-exec-1] INFO  spark.KafkaProducer - 准备发送消息为：saa1111s
16:06:03.768 [http-nio-8888-exec-1] INFO  org.apache.kafka.clients.producer.ProducerConfig - ProducerConfig values: 
	acks = 1
	batch.size = 16384
	block.on.buffer.full = false
	bootstrap.servers = [192.168.100.150:9092]
	buffer.memory = 33554432
	client.id = 
	compression.type = none
	connections.max.idle.ms = 540000
	interceptor.classes = null
	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.fetch.timeout.ms = 60000
	metadata.max.age.ms = 300000
	metric.reporters = []
	metrics.num.samples = 2
	metrics.sample.window.ms = 30000
	partitioner.class = class org.apache.kafka.clients.producer.internals.DefaultPartitioner
	receive.buffer.bytes = 32768
	reconnect.backoff.ms = 50
	request.timeout.ms = 30000
	retries = 0
	retry.backoff.ms = 100
	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.mechanism = GSSAPI
	security.protocol = PLAINTEXT
	send.buffer.bytes = 131072
	ssl.cipher.suites = null
	ssl.enabled.protocols = [TLSv1.2, TLSv1.1, TLSv1]
	ssl.endpoint.identification.algorithm = null
	ssl.key.password = null
	ssl.keymanager.algorithm = SunX509
	ssl.keystore.location = null
	ssl.keystore.password = null
	ssl.keystore.type = JKS
	ssl.protocol = TLS
	ssl.provider = null
	ssl.secure.random.implementation = null
	ssl.trustmanager.algorithm = PKIX
	ssl.truststore.location = null
	ssl.truststore.password = null
	ssl.truststore.type = JKS
	timeout.ms = 30000
	value.serializer = class org.apache.kafka.common.serialization.StringSerializer

16:06:03.775 [http-nio-8888-exec-1] INFO  org.apache.kafka.clients.producer.ProducerConfig - ProducerConfig values: 
	acks = 1
	batch.size = 16384
	block.on.buffer.full = false
	bootstrap.servers = [192.168.100.150:9092]
	buffer.memory = 33554432
	client.id = producer-1
	compression.type = none
	connections.max.idle.ms = 540000
	interceptor.classes = null
	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.fetch.timeout.ms = 60000
	metadata.max.age.ms = 300000
	metric.reporters = []
	metrics.num.samples = 2
	metrics.sample.window.ms = 30000
	partitioner.class = class org.apache.kafka.clients.producer.internals.DefaultPartitioner
	receive.buffer.bytes = 32768
	reconnect.backoff.ms = 50
	request.timeout.ms = 30000
	retries = 0
	retry.backoff.ms = 100
	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.mechanism = GSSAPI
	security.protocol = PLAINTEXT
	send.buffer.bytes = 131072
	ssl.cipher.suites = null
	ssl.enabled.protocols = [TLSv1.2, TLSv1.1, TLSv1]
	ssl.endpoint.identification.algorithm = null
	ssl.key.password = null
	ssl.keymanager.algorithm = SunX509
	ssl.keystore.location = null
	ssl.keystore.password = null
	ssl.keystore.type = JKS
	ssl.protocol = TLS
	ssl.provider = null
	ssl.secure.random.implementation = null
	ssl.trustmanager.algorithm = PKIX
	ssl.truststore.location = null
	ssl.truststore.password = null
	ssl.truststore.type = JKS
	timeout.ms = 30000
	value.serializer = class org.apache.kafka.common.serialization.StringSerializer

16:06:03.798 [http-nio-8888-exec-1] INFO  org.apache.kafka.common.utils.AppInfoParser - Kafka version : 0.10.1.1
16:06:03.799 [http-nio-8888-exec-1] INFO  org.apache.kafka.common.utils.AppInfoParser - Kafka commitId : f10ef2720b03b247

此时说明程序已经成功将消息发送到kafka中名为topic.one的主题上，其实这里的主题就相当于rabbitmq中的队列。

注意：当kafka中没有名为topic.one的主题时程序会自动创建。

6：创建kakfa消费者类

  • 广播形式消费
package spark;

import java.util.Optional;

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.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Component
public class KafkaConsumer {
	  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);

	   @KafkaListener(topics = KafkaProducer.TOPIC_ONE,groupId = KafkaProducer.TOPIC_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();
	         logger.info("被"+KafkaProducer.TOPIC_ONE+"消费了： +++++++++++++++ Topic:" + topic+",Record:" + record+",Message:" + msg);
	      }
	   }
	   
	   @KafkaListener(topics = KafkaProducer.TOPIC_ONE,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();
	         logger.info("被"+KafkaProducer.TOPIC_ONE+"1111消费了： +++++++++++++++ Topic:" + topic+",Record:" + record+",Message:" + msg);
	      }
	   }
}

如上面代码所示，程序创建了两个消息消费者，每个消费者都监听来自主题topic_one的消息，唯一不同的是两个消费者分别属于不同的组别，即groupId设置不同。启动工程，访问连接http://localhost:8888/kafka/send?msg=3

 

查看程序日志如下：

17:17:30.493 [http-nio-8888-exec-9] INFO  spark.KafkaProducer - 准备发送消息为：3
17:17:30.503 [org.springframework.kafka.KafkaListenerEndpointContainer#0-0-C-1] INFO  spark.KafkaConsumer - 被topic.one消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, offset = 7, CreateTime = 1567156650493, serialized key size = -1, serialized value size = 1, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 3),Message:3
17:17:30.503 [kafka-producer-network-thread | producer-1] INFO  spark.KafkaProducer - topic.one - 生产者 发送消息成功：SendResult [producerRecord=ProducerRecord(topic=topic.one, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=3, timestamp=null), recordMetadata=topic.one-0@7]
17:17:30.503 [org.springframework.kafka.KafkaListenerEndpointContainer#1-0-C-1] INFO  spark.KafkaConsumer - 被topic.one1111消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, offset = 7, CreateTime = 1567156650493, serialized key size = -1, serialized value size = 1, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 3),Message:3

由此可见一条消息分别被两个不同的消费者消费，由此达到了广播的效果。有读者会问了，那我不需要每个消费者都读取到重复的消息该如何配置？

  • 相同消费组唯一消费模式
package spark;

import java.util.Optional;

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.KafkaHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.stereotype.Component;

@Component
public class KafkaConsumer {
	  private static final Logger logger = LoggerFactory.getLogger(KafkaConsumer.class);

	   @KafkaListener(topics = KafkaProducer.TOPIC_ONE,groupId = KafkaProducer.TOPIC_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();
	         logger.info("被"+KafkaProducer.TOPIC_ONE+"消费了： +++++++++++++++ Topic:" + topic+",Record:" + record+",Message:" + msg);
	      }
	   }
	   
	   @KafkaListener(topics = KafkaProducer.TOPIC_ONE,groupId = KafkaProducer.TOPIC_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();
	         logger.info("被"+KafkaProducer.TOPIC_ONE+"1111消费了： +++++++++++++++ Topic:" + topic+",Record:" + record+",Message:" + msg);
	      }
	   }
}

上述代码与前段代码唯一的区别在于，两个消费者的组别设置成了一样的。启动程序，多次访问连接http://localhost:8888/kafka/send?msg=4

查看程序日志如下：

17:33:20.426 [http-nio-8888-exec-1] INFO  org.apache.kafka.common.utils.AppInfoParser - Kafka version : 1.0.1
17:33:20.426 [http-nio-8888-exec-1] INFO  org.apache.kafka.common.utils.AppInfoParser - Kafka commitId : c0518aa65f25317e
17:33:20.468 [kafka-producer-network-thread | producer-1] INFO  spark.KafkaProducer - topic.one - 生产者 发送消息成功：SendResult [producerRecord=ProducerRecord(topic=topic.one, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=4, timestamp=null), recordMetadata=topic.one-0@8]
17:33:20.475 [org.springframework.kafka.KafkaListenerEndpointContainer#0-0-C-1] INFO  spark.KafkaConsumer - 被topic.one消费了： +++++++++++++++ Topic:topic.one,Record:ConsumerRecord(topic = topic.one, partition = 0, offset = 8, CreateTime = 1567157600446, serialized key size = -1, serialized value size = 1, headers = RecordHeaders(headers = [], isReadOnly = false), key = null, value = 4),Message:4

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

上述两种模式，读者可以根据自己项目的实际需要进行选择。

我行其野&芃芃其麦
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Springboot使用kafka(配置篇yml)
weixin_39766667的博客
01-04 1万+
springboot 配置kafak的生产者，消费者，监听器
Springboot Kafka 集成配置
qq_39725872的博客
05-19 1818
Springboot 配置使用 Kafka前言一、Linux 安装 Kafka二、构建项目三、引入依赖四、配置文件生产者yml 方式Config 方式消费者yml 方式Config 方式五、开始写代码生产者发送成功回调和异常处理消费者接收异常处理七、开始测试测试普通单条消息测试消费者异常处理测试延时消息测试批量消息测试手动控制消费者监听总结前言。
Springboot整合kafka简单使用
最新发布
m0_56353506的博客
06-02 1397
Kafka 是一个开源的分布式流处理平台，最初由 LinkedIn 开发并贡献给 Apache 软件基金会。它设计用于构建高性能、持久性、可伸缩和容错的实时数据管道和流处理应用程序。发布-订阅模型：Kafka 使用发布-订阅模型，其中消息生产者将消息发布到主题（topic），而消息消费者从主题订阅消息。这种模型可以支持多个消费者同时消费消息，并且具有良好的扩展性。主题（Topic）：主题是消息的逻辑分类，相当于一个消息队列。消息被发布到主题，并且消费者从主题订阅消息。分区（Partition）
Kafka bootstrap.servers
Carter的程序人生
06-13 1万+
Kafka bootstrap.servers
springKafka 生产者、消费者，数据发送/接收
u011196623的专栏
10-07 177
配置文件 # 指定kafka server的地址，集群配多个，中间，逗号隔开 spring.kafka.bootstrap-servers= # 配置kafka 授权认证 --开始 spring....
kafka的sasl配置
atarik@163.com
02-27 2102
1、Kafka brokers的SASL配置 在broker中选择1个或多个支持的机制启用，kafka目前支持的机制有 GSSAPI 和 PLAIN 。 添加一个JAAS文件来配置选择的 GSSAPI（Kerberos）或 PLANIN。 JAAS配置文件位置作为JVM参数传递给每个broker代理。例如: - Djava.security.auth.login....
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
通过以上步骤，我们就完成了Spring Boot集成Kafka的实战项目，包括生产者、消费者的实现，以及Topic的创建和指定消费分区。这个项目可以帮助开发者更好地理解和应用Kafka在实际业务场景中的用法，提升消息传递的效率...
springboot集成kafka简单入门案例
06-13
在本文中，我们将深入探讨如何将Kafka与Spring Boot整合，以便在Java应用程序中实现高效的消息传递。Kafka是一个分布式流处理平台，广泛用于构建实时数据管道和流应用。Spring Boot则是一个流行的Java开发框架，简化...
springboot集成kafka推送的简单例子
06-05
通过这个简单的例子，你已经掌握了如何在SpringBoot应用中集成Kafka进行消息推送的基本流程。随着对Spring和Kafka的进一步了解，你可以实现更复杂的功能，比如消息分组、幂等性消费、事务支持等。这只是一个起点，但...
SpringBoot集成kafka完整框架源码IDEA
03-26
SpringBoot集成Kafka是一个常见的Java开发任务，它允许开发者在基于Spring的应用程序中轻松地使用Apache Kafka消息系统。本文将详细解析SpringBoot如何与Kafka整合，并提供一个完整的框架源码解析。 首先，...
Springboot集成Kafka实现producer和consumer的示例代码
08-27
Spring Boot 集成 Kafka 可以帮助开发者轻松地在应用程序中实现消息生产和消费功能，利用 Kafka 的高性能和可扩展性。Kafka 是一个分布式流处理平台，它最初由 LinkedIn 开发，后来成为 Apache 软件基金会的顶级项目...
kafka集群开启SASL/Kerberos安全认证
shy_snow的专栏
06-30 2919
Kafka使用JAAS（Java认证和授权服务）进行SASL(基于网络连接的安全认证机制)配置。 通过三个步骤即可实现JAAS安全认证: (1) 配置jaas相关信息 (2) 开启SASL/Kerberos认证 (3) 通过脚本将配置信息传递给java虚拟机,这样java的JAAS服务才能根据配置进行认证和授权服务。 不论是zookeeper集群还是kafka集群都是如此。 .........
SpringBoot整合Kafka
ITBOY_ITBOX博客
10-11 958
使用注解@KafkaListener定义当前方法监听Kafka中指定topic的消息，接收到的消息封装在对象ConsumerRecord中，获取数据从ConsumerRecord对象中获取即可。运行bin目录下的windows目录下的kafka-server-start命令即可启动kafka服务器，默认对外服务端口9092。Kafka提供有一套测试服务器功能的测试程序，运行bin目录下的windows目录下的命令即可使用。：使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息。
springboot集成kafka，以及kafka集群环境搭建
不经意的博客
05-18 1556
说明： 高吞吐量、低延迟：kafka每秒可以处理几十万条消息，它的延迟最低只有几毫秒； 可扩展性：kafka集群支持热扩展； 持久性、可靠性：消息被持久化到本地磁盘，并且支持数据备份防止数据丢失； 容错性：允许集群中节点故障（若副本数量为n,则允许n-1个节点故障）； 高并发：支持数千个客户端同时读写。 使用场景： 日志收集：一个公司可以用Kafka可以收集各种服务的log，通过kafka以统一接口服务的方式开放给各种consumer； 消息系统：解耦生产者和消费者、缓...
Kafka学习
nlhkfcdxb的博客
03-23 137
③配置server.properties文件。①需要提前配置zookeeper环境。②配置环境变量，与Java类似。1、kafka集群配置。
springboot 使用 kafka
weixin_42555971的博客
06-08 2127
kafka
如何轻松在SpringBoot中正确配置并运行Kafka
学弟不想努力了
06-15 1万+
一、配置pom.xml，引入maven依赖 二、application.yml配置文件 三、消费者 四、生产者 五、调用测试启动Boot项目，使用Postman工具发送GET请求.....
SpringBoot集成kafka全面实战
热门推荐
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
springboot 集成 kafka
08-04
Spring Boot集成Kafka可以通过以下步骤实现。 首先，在Spring Boot应用程序的pom.xml文件中添加Kafka依赖项。可以使用以下依赖项： ``` <groupId>org.springframework.kafka <artifactId>spring-kafka ``` ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值