springboot集成Kafka的基本使用

最新推荐文章于 2022-09-17 17:08:30 发布
最新推荐文章于 2022-09-17 17:08:30 发布
阅读量371 收藏
点赞数
分类专栏： java高阶相关技术 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42707397/article/details/112799791
版权

springboot集成Kafka

1、windows安装Kafka

windows安装Kafka

2、添加依赖

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

3、添加配置

在application.yml里,根据需求具体修改，都有注释

spring:
	kafka:
	    bootstrap-servers: localhost:9092
	    producer:
	      # 发生错误后，消息重发的次数。
	      retries: 0
	      #当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。
	      batch-size: 16384
	      # 设置生产者内存缓冲区的大小。
	      buffer-memory: 33554432
	      # 键的序列化方式
	      key-serializer: org.apache.kafka.common.serialization.StringSerializer
	      # 值的序列化方式
	      value-serializer: org.apache.kafka.common.serialization.StringSerializer
	      # acks=0 ： 生产者在成功写入消息之前不会等待任何来自服务器的响应。
	      # acks=1 ： 只要集群的首领节点收到消息，生产者就会收到一个来自服务器成功响应。
	      # acks=all ：只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。
	      acks: 1
	    consumer:
	      # 自动提交的时间间隔 在spring boot 2.X 版本中这里采用的是值的类型为Duration 需要符合特定的格式，如1S,1M,2H,5D
	      auto-commit-interval: 1S
	      # 该属性指定了消费者在读取一个没有偏移量的分区或者偏移量无效的情况下该作何处理：
	      # latest（默认值）在偏移量无效的情况下，消费者将从最新的记录开始读取数据（在消费者启动之后生成的记录）
	      # earliest ：在偏移量无效的情况下，消费者将从起始位置读取分区的记录
	      auto-offset-reset: earliest
	      # 是否自动提交偏移量，默认值是true,为了避免出现重复数据和数据丢失，可以把它设置为false,然后手动提交偏移量
	      enable-auto-commit: false
	      # 键的反序列化方式
	      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
	      # 值的反序列化方式
	      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
	    listener:
	      # 在侦听器容器中运行的线程数。
	      concurrency: 5
	      #listner负责ack，每调用一次，就立即commit
	      ack-mode: manual_immediate
	      missing-topics-fatal: false

4、编写Kafka工具

package org.springxxx.modules.xxx.kafka;

import java.sql.SQLException;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springblade.modules.datatrans.service.IProtocolService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Component;

@Component
public class KafkaMountTask {

	@Autowired
	IProtocolService iProtocolService;

	@Autowired
	private KafkaTemplate<String, Object> kafkaTemplate;

	// 消费监听生产方。
	@KafkaListener(groupId = "group", topics = { "produce5.2" })
	public void onMessageTestProduce(ConsumerRecord<?, ?> record) throws SQLException {
		// 消费的哪个topic、partition的消息,打印出消息内容
		System.out.println("简单消费：" + record.topic() + "-" + record.partition() + "-" + record.value());
		// 调用协议中方法
		iProtocolService.mountTaskProduce(record.value().toString());
	}

	// 发送消息给订阅方。
	public void sendMessageTestOrder(String msg) {
		kafkaTemplate.send("order5.2", msg);
	}
}

5、测试使用

package org.springblade.modules.datatrans.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springblade.common.constant.CustomAppConstant;
import org.springblade.core.boot.ctrl.BladeController;
import org.springblade.core.launch.constant.AppConstant;
import org.springblade.core.tool.api.R;
import org.springblade.modules.datatrans.dto.ProtocolDTO;
import org.springblade.modules.datatrans.dto.ProtocolPageDTO;
import org.springblade.modules.datatrans.entity.Protocol;
import org.springblade.modules.datatrans.service.IProtocolService;
import org.springblade.modules.datatrans.vo.CountProtocolVO;
import org.springblade.modules.datatrans.vo.ProtocolPageVO;
import org.springblade.modules.datatrans.vo.ProtocolVO;
import org.springblade.modules.system.vo.PageVO;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;

/**
 * 前端控制器
 */
@RestController
@RequestMapping("/protocol")
@Api(value = "接口", tags = "接口")
public class ProtocolController{

	Logger logger = LoggerFactory.getLogger(ProtocolController.class);

	private final IProtocolService protocolService;

	@Autowired
	public ProtocolController(IProtocolService protocolService) {
		this.protocolService = protocolService;
	}

	@Autowired
	private KafkaTemplate<String, Object> kafkaTemplate;

	@GetMapping("/testSendToKafka")
	@ApiOperation(value = "发送消息", notes = "发送消息")
	public void testSendToKafka() {
		kafkaTemplate.send("test3",
				"{\"gradeCode\":\"等级维度编码\",\"spaceCode\":\"空间维度编码\",\"systemCode\":\"系统编码\",\"updateTypeCode\":\"更新方式编码\",\"dataTypeCode\":\"数据类型编码\",\"bussinessCode\":\"业务维度编码\",\"content\":{\"from\":[{\"serverCode\":\"node1\",\"serverIp\":\"127.0.0.1\",\"databases\":[{\"dbCode\":\"db1\",\"dbType\":\"postgreSQL\",\"url\":\"127.0.0.1:5432/xz_test\",\"usr\":\"xz_test\",\"password\":\"xz_test\",\"tables\":[{\"order\":\"1\",\"code\":\"dltb\",\"pks\":\"objectid\",\"filter\":\"dlbm like '21%'\"}]}]}],\"to\":[{\"serverCode\":\"node2\",\"serverIp\":\"192.168.19.111\",\"databases\":[{\"dbCode\":\"db2\",\"dbType\":\"postgreSQL\",\"url\":\"192.168.19.111:5432/xz_test\",\"usr\":\"xz_test\",\"password\":\"xz_test\"}]}]},\"version\":\"变化数据标识（通过数据发生变化的时间来标识）\",\"taskName\":\"任务名称\",\"taskCode\":\"任务编码\",\"source_db_address\":\"源端数据库连接地址\",\"priority\":\"优先级\",\"data_mapping\":\"数据表结构映射关系\",\"to_db_address\":\"订阅端数据库连接地址\"}")
				.addCallback(success -> {
					// 消息发送到的topic
					String topic = success.getRecordMetadata().topic();
					// 消息发送到的分区
					int partition = success.getRecordMetadata().partition();
					// 消息在分区内的offset
					long offset = success.getRecordMetadata().offset();
					System.out.println("发送消息成功:" + topic + "-" + partition + "-" + offset);
				}, failure -> {
					System.out.println("发送消息失败:" + failure.getMessage());
				});
	}
}
EricFRQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【微服务】springboot整合kafka-stream使用详解
congge
12-24 9874
kafka stream使用详解
springBoot集成Kafka
weixin_66545010的博客
07-06 6232
spring boot集成Kafka
spring boot集成kafka之spring-kafka深入探秘
chihujiang3132的博客
05-31 1114
前言 kafka是一个消息队列产品，基于Topicpartitions的设计，能达到非常高的消息发送处理性能。Spring创建了一个项目Spring-kafka，封装了Apache 的Kafka-client，用于在Spring项目里快速集成kafka。除了简单的收发消息外，Spring...
spring boot集成kafka
weixin_30355437的博客
05-02 108
（一）首先要解决kafka对外网的通道问题参考：kafka的advertised.host.name参数 外网访问配置例如对于 59.64.11.22 IP对应的broker，需要在 server.properties 配置文件里增加如下三个配置：新版配置advertised.listeners=PLAINTEXT://59.64.11.22:9092估计读者...
spring boot 集成kafka
诸葛子房的博客
05-06 155
spring boot 集成kafka 1、先解决依赖 springboot相关的依赖我们就不提了，和kafka相关的只依赖一个spring-kafka集成包 <dependency> <groupId>org.springframework.kafka</groupId> ...
SpringBoot集成kafka
qq_34553374的博客
03-26 247
创建SpringBoot项目 pom文件 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</a...
springboot集成kafka基础入门
longxianhua的博客
05-29 1219
kafka的windows安装启动请看本人另外一篇文章 kafka在windows下安装和使用入门教程 引入依赖 初始化一个springboot项目，和kafka相关的只依赖一个spring-kafka集成包,这里注意springboot的版本和kafka的版本要能对应上,我用的springboot 1.5.9 <dependency> <groupId>org.springframework.kafka</groupId>
SpringBoot集成kafka组件的使用
dance_itGirl的博客
05-31 265
1、jar包引入 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> 2、application.yml配置 spring: kafka: bootstrap-ser
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
通过以上步骤，我们就完成了Spring Boot集成Kafka的实战项目，包括生产者、消费者的实现，以及Topic的创建和指定消费分区。这个项目可以帮助开发者更好地理解和应用Kafka在实际业务场景中的用法，提升消息传递的效率...
SpringBoot集成kafka全面实战
热门推荐
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
springboot集成kafka
06-28
springboot kafka
Springboot集成Kafka实现producer和consumer的示例代码
08-27
这只是一个基本的示例，实际使用时可以根据需求进行更复杂的配置，如定制序列化器、设置回调函数、处理异常等。同时，确保 Kafka 服务和 ZooKeeper 正常运行，以便于 Spring Boot 应用程序能够顺利与 Kafka 集群交互...
Springboot 集成kafka
axibazZ的博客
09-17 5080
解释：这里定义了消费者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配置。
Springboot集成kafka
qq_32681671的博客
01-06 715
基础环境配置 1. 添加依赖 <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.8.0</version> </dependency> 2. 配置kafka连接信息 spring: #kafka kaf.
springBoot集成kafka
NothingToSay01的博客
03-18 187
在上篇成功安装和测试zk+kafka的基础上，我们集成kafka到springboot微服务中 1：依赖引入(版本对应) <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </depende...
SpringBoot集成kafka如何使用
最新发布
08-17
### 回答1： Spring Boot集成Kafka可以使用Spring Kafka库来实现。以下是步骤： 1. 添加Spring Kafka依赖 在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> <version>2.3.7.RELEASE</version> </dependency> ``` 2. 配置Kafka 在application.properties文件中添加以下配置： ```properties spring.kafka.bootstrap-servers=<kafka服务器地址> spring.kafka.consumer.group-id=<消费者组ID> ``` 3. 创建Kafka生产者 使用KafkaTemplate类创建生产者。以下是一个示例： ```java @Service public class MyKafkaProducer { @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { kafkaTemplate.send(topic, message); } } ``` 4. 创建Kafka消费者 使用@KafkaListener注解创建消费者。以下是一个示例： ```java @Service public class MyKafkaConsumer { @KafkaListener(topics = "<要消费的主题>") public void consume(String message) { // 处理消息 } } ``` 5. 发送和接收消息 使用上面创建的Kafka生产者发送消息，使用上面创建的Kafka消费者接收消息。 以上就是Spring Boot集成Kafka的基本步骤。需要注意的是，Kafka的具体使用方式和配置可能因版本而异，需要根据实际情况进行调整。 ### 回答2： Spring Boot 是一个用于简化 Spring 应用程序开发的框架，它提供了很多便捷的功能和配置，使得我们可以更容易地集成和使用 Kafka 。 首先，我们需要在 pom.xml 文件中添加 Kafka 的依赖： ```xml <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 然后，我们需要在 application.properties（或 application.yml）文件中配置 Kafka 的连接地址和其他相关属性： ```properties spring.kafka.bootstrap-servers=your-kafka-server-address spring.kafka.consumer.group-id=your-consumer-group-id 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 ``` 在代码中，我们可以使用 KafkaTemplate 类来发送消息到 Kafka 或接收 Kafka 的消息。我们可以通过注入 KafkaTemplate 对象来使用它。 例如，我们可以定义一个 Producer 类来发送消息： ```java @Service public class KafkaProducer { @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { kafkaTemplate.send(topic, message); } } ``` 我们还可以定义一个 Consumer 类来接收消息： ```java @Service public class KafkaConsumer { @KafkaListener(topics = "your-topic-name") public void receiveMessage(String message) { System.out.println("Received message: " + message); } } ``` 在这个例子中，我们通过使用 @KafkaListener 注解来指定要监听的主题，并在 receiveMessage 方法中处理接收到的消息。 通过以上步骤，我们就可以在 Spring Boot 中集成和使用 Kafka 了。我们可以使用 KafkaTemplate 发送消息，使用 @KafkaListener 注解来监听和处理消息。同时，我们还可以根据自己的需求配置更多的 Kafka 相关属性，例如设置消费者组、反序列化器等。 总之，Spring Boot 集成 Kafka 的过程主要步骤包括添加依赖、配置 Kafka 连接、编写 Producer 和 Consumer 类，通过 KafkaTemplate 发送消息，使用 @KafkaListener 注解监听并处理消息。以上就是关于如何在 Spring Boot 中集成 Kafka 的简要介绍。 ### 回答3： Spring Boot提供了对Kafka的集成支持，使得使用Kafka进行消息传递变得简单和高效。下面是使用Spring Boot集成Kafka的步骤： 1. 配置Kafka依赖：在pom.xml文件中添加Kafka的依赖项。 ``` <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 2. 配置Kafka相关属性：在application.properties文件中配置Kafka的相关属性，包括Kafka服务器地址、端口号等。 ``` spring.kafka.bootstrap-servers=localhost:9092 ``` 3. 创建Kafka生产者：使用Spring Kafka提供的KafkaTemplate类来创建一个Kafka生产者，用于发送消息到Kafka。 ```java @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendMessage(String topic, String message) { kafkaTemplate.send(topic, message); } ``` 4. 创建Kafka消费者：使用@KafkaListener注解来创建Kafka消费者，监听指定的主题，并处理接收到的消息。 ```java @KafkaListener(topics = "myTopic") public void receiveMessage(String message) { System.out.println("Received message: " + message); // 进行消息处理 } ``` 5. 启动Kafka消费者：在Spring Boot应用程序的入口类上添加@EnableKafka注解，以启用Kafka消费者。 ```java @SpringBootApplication @EnableKafka public class SpringBootKafkaApplication { public static void main(String[] args) { SpringApplication.run(SpringBootKafkaApplication.class, args); } } ``` 通过以上步骤，我们就可以在Spring Boot中集成Kafka，并使用Kafka进行消息传递了。可以根据实际需求，进行消息的发送和接收处理。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值