SpringBoot配置多个kafka配置

已于 2024-08-28 18:24:22 修改
阅读量360 收藏
点赞数 13
分类专栏： # Kafka 文章标签： kafka
于 2024-08-28 14:41:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bbj12345678/article/details/141640163
版权

引入依赖

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

yml配置

有几个就配置几个 ，这里只配置两个

因为我在本地启动了两个kafka，所以bootstrap-servers这里分别指向两个不同端口的kafka地址

几个属性详细解释：

acks

 #acks = 0：设置成 表示 producer 完全不理睬 leader broker 端的处理结果。此时producer 发送消息后立即开启下 条消息的发送，根本不等待 leader broker 端返回结果
#acks= all 或者－1 ：表示当发送消息时， leader broker 不仅会将消息写入本地日志，同时还会等待所有其他副本都成功写入它们各自的本地日志后，才发送响应结果给，消息安全但是吞吐量会比较低。
#acks = 1：默认的参数值。 producer 发送消息后 leader broker 仅将该消息写入本地日志，然后便发送响应结果给producer ，而无须等待其他副本写入该消息。折中方案，只要leader一直活着消息就不会丢失，同时也保证了吞吐量

auto-offset-reset:

#当kafka中没有初始offset或offset超出范围时将自动重置offset
# earliest:重置为分区中最小的offset;
# latest:重置为分区中最新的offset(消费分区中新产生的数据);
# none:只要有一个分区不存在已提交的offset,就抛出异常;

复制代码
spring:
  kafka:
    # 第一个kafka的配置
    first:
      bootstrap-servers: 127.0.0.1:9092 # 这个是kafka的地址,对应server.properties中配置的
      producer:                         # 生产者配置
        key-serializer: org.apache.kafka.common.serialization.StringSerializer  # Kafka提供的序列化和反序列化类
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
        batch-size: 16384        # 批量大小
        buffer-memory: 33554432  # 生产端缓冲区大小
        retries: 10              # 消息发送重试次数
        acks: -1                  # 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
        properties:
          linger:
            ms: 2000             # 提交延迟
      consumer:  # 消费者配置
        key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        group-id: testGroup           # 默认的消费组ID
        enable-auto-commit: true      # 是否自动提交offset 
        auto-commit-interval: 2000    # 提交offset延时(接收到消息后多久提交offset)
        max-poll-records: 500         # 单次拉取消息的最大条数,根据业务需要配置
        auto-offset-reset: latest
        properties:
          session:
            timeout:
              ms: 120000 # 消费会话超时时间（超过这个时间 consumer 没有发送心跳，就会触发 rebalance 操作）
          request:
            timeout:
              ms: 18000  # 消费请求的超时时间
    # 第二个kafka的配置
    second:
      bootstrap-servers: 127.0.0.1:9093  # 这个是kafka的地址,对应server.properties中配置的
      producer:                          # 生产者配置
        key-serializer: org.apache.kafka.common.serialization.StringSerializer  # Kafka提供的序列化和反序列化类
        value-serializer: org.apache.kafka.common.serialization.StringSerializer
        batch-size: 16384         # 批量大小
        buffer-memory: 33554432   # 生产端缓冲区大小
        retries: 10               # 消息发送重试次数
        acks: -1                   # 应答级别:多少个分区副本备份完成时向生产者发送ack确认(可选0、1、all/-1)
        properties:
          linger:
            ms: 2000              # 提交延迟
      consumer: # 消费者配置
        key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
        group-id: testGroup           # 默认的消费组ID
        enable-auto-commit: true      # 是否自动提交offset 
        auto-commit-interval: 2000    # 提交offset延时(接收到消息后多久提交offset)
        max-poll-records: 500         # 单次拉取消息的最大条数,根据业务需要配置
        auto-offset-reset: latest
        properties:
          session:
            timeout:
              ms: 120000 # 消费会话超时时间（超过这个时间 consumer 没有发送心跳，就会触发 rebalance 操作）
          request:
            timeout:
              ms: 18000  # 消费请求的超时时间

读取第一个kafka配置 

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
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.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

/**
 * 第一个kafka配置
 *
 */
@Configuration
public class FirstKafkaConfig {

    /**
     * 读取第一个kafka配置
     * Primary注解表示默认以这个为准
     *
     * @return 第一个kafka配置
     */
    @Primary
    @ConfigurationProperties(prefix = "spring.kafka.first")
    @Bean
    public KafkaProperties firstKafkaProperties() {
        return new KafkaProperties();
    }

    /**
     * 构建第一个kafka的生产者发送template
     *
     * @param firstKafkaProperties 第一个kafka配置
     * @return 第一个kafka的生产者发送template
     */
    @Primary
    @Bean
    public KafkaTemplate<String, String> firstKafkaTemplate(
            @Autowired @Qualifier("firstKafkaProperties") KafkaProperties firstKafkaProperties) {
        return new KafkaTemplate<>(firstProducerFactory(firstKafkaProperties));
    }

    /**
     * 新建第一个kafka的生产者工厂
     *
     * @param firstKafkaProperties 第一个kafka配置
     * @return 第一个kafka的生产者工厂
     */
    private DefaultKafkaProducerFactory<String, String> firstProducerFactory(KafkaProperties firstKafkaProperties) {
        return new DefaultKafkaProducerFactory<>(firstKafkaProperties.buildProducerProperties());
    }

    /**
     * 构建第一个kafka的消费者监听容器工厂
     *
     * @param firstKafkaProperties 第一个kafka配置
     * @return 第一个kafka的消费者监听容器工厂
     */
    @Bean("firstKafkaListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>>
    firstKafkaListenerContainerFactory(@Autowired @Qualifier("firstKafkaProperties") KafkaProperties firstKafkaProperties) {
        ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(firstConsumerFactory(firstKafkaProperties));
        return factory;
    }

    /**
     * 新建第一个kafka的消费者工厂
     *
     * @param firstKafkaProperties 第一个kafka配置
     * @return 第一个kafka的消费者工厂
     */
    private ConsumerFactory<? super Integer, ? super String> firstConsumerFactory(KafkaProperties firstKafkaProperties) {
        return new DefaultKafkaConsumerFactory<>(firstKafkaProperties.buildConsumerProperties());
    }


}

读取第二个kafka配置

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.kafka.KafkaProperties;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
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.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

/**
 * 第二个kafka配置
 *
 */
@Configuration
public class SecondKafkaConfig {

    /**
     * 读取第二个kafka配置
     *
     * @return 第二个kafka配置
     */
    @ConfigurationProperties(prefix = "spring.kafka.second")
    @Bean("secondKafkaProperties")
    public KafkaProperties secondKafkaProperties() {
        return new KafkaProperties();
    }

    /**
     * 构建第二个kafka的生产者发送template
     *
     * @param secondKafkaProperties 第二个kafka配置
     * @return 第二个kafka的生产者发送template
     */
    @Bean
    public KafkaTemplate<String, String> secondKafkaTemplate(
            @Autowired @Qualifier("secondKafkaProperties") KafkaProperties secondKafkaProperties) {
        return new KafkaTemplate<>(secondProducerFactory(secondKafkaProperties));
    }

    /**
     * 新建第二个kafka的生产者工厂
     *
     * @param secondKafkaProperties 第二个kafka配置
     * @return 第二个kafka的生产者工厂
     */
    private DefaultKafkaProducerFactory<String, String> secondProducerFactory(KafkaProperties secondKafkaProperties) {
        return new DefaultKafkaProducerFactory<>(secondKafkaProperties.buildProducerProperties());
    }

    /**
     * 构建第二个kafka的消费者监听容器工厂
     *
     * @param secondKafkaProperties 第二个kafka配置
     * @return 第二个kafka的消费者监听容器工厂
     */
    @Bean("secondKafkaListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>>
    secondKafkaListenerContainerFactory(@Autowired @Qualifier("secondKafkaProperties") KafkaProperties secondKafkaProperties) {
        ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(secondConsumerFactory(secondKafkaProperties));
        return factory;
    }

    /**
     * 新建第二个kafka的消费者工厂
     *
     * @param secondKafkaProperties 第二个kafka配置
     * @return 第二个kafka的消费者工厂
     */
    private ConsumerFactory<? super Integer, ? super String> secondConsumerFactory(KafkaProperties secondKafkaProperties) {
        return new DefaultKafkaConsumerFactory<>(secondKafkaProperties.buildConsumerProperties());
    }
}

创建两个生产者

@RestController
@RequestMapping("/producer1")
@Api(tags = "kafka生产者测试1")
public class ProducerDemoController1 {

    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    /**
     * 发送消息
     *
     * @param msg
     * @return
     */
    @PostMapping("/sendMsg")
    public String sendMsg(@RequestParam(name = "msg", defaultValue = "hello kafka") String msg) {
        kafkaTemplate.send("YWZT-TOPIC-TEST", msg);
        return "消息已发送";
    }
}
@RestController
@RequestMapping("/producer2")
@Api(tags = "kafka生产者测试2")
public class ProducerDemoController2 {

    /**
     * 第二个kafka配置需要指定下名字 
     */
    @Resource(name = "secondKafkaTemplate")
    private KafkaTemplate<String, String> secondKafkaTemplate;

    /**
     * 发送消息
     *
     * @param msg
     * @return
     */
    @PostMapping("/sendMsg")
    public String sendMsg(@RequestParam(name = "msg", defaultValue = "hello kafka") String msg) {
        secondKafkaTemplate.send("YWZT-TOPIC-TEST", msg);
        return "消息已发送";
    }
}

创建两个消费者

@Slf4j
@Component
@RequiredArgsConstructor
public class YwztExConsumer1 {

    @KafkaListener(
        containerFactory = "firstKafkaListenerContainerFactory",
        topics = {"YWZT-TOPIC-TEST"},
        groupId = "testGroup")
    public void consumer(String value) throws JsonProcessingException {
        //获取报文
        log.info("------------------------报文信息----------------：{} ......", StrUtil.sub(value, 0, 400));
    }
    
}
@Slf4j
@Component
@RequiredArgsConstructor
public class YwztExConsumer2 {

    @KafkaListener(
            containerFactory = "secondKafkaListenerContainerFactory",
            topics = {"YWZT-TOPIC-TEST"},
            groupId = "testGroup")
    public void consumer(String value) throws JsonProcessingException {
        //获取报文
        log.info("------------------------报文信息----------------：{} ......", StrUtil.sub(value, 0, 400));
    }

}
fastjson_
关注
  • 13
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot配置多Kafka中心
xiaoliu598906167的博客
06-26 9785
最近准备把SpringMVC的代码全部改成SpringBoot。SpringMvc的项目逐步切向SpringBoot，这可能是一个趋势，就连redis、dubbo、kafka这些常用并且很重要的开源框架也提供了SpringBoot的版本，微服务化越来越简单、规范。 在项目中遇到Kafka的多配置，SpringMvc下采用不同的bean的方式配置多个数据源，网上的资料虽然有很多，但是都是通过原生的...
[springboot配置Kafka] springboot配置多个kafka,包含账号密码
ai_haibin的博客
06-28 3869
springboot 配置多个kafka
SpringBoot整合kafka配置多个kafka配置
weixin_36873225的博客
07-26 530
【代码】SpringBoot整合kafka配置多个kafka配置。
Springboot 配置使用 Kafka
热门推荐
泡泡的博客
11-01 1万+
不多BB讲原理，只教你怎么用，看了全网没有比我更详细的了，yml 配置，Config 工厂代码配置都有，batch-size、acks、offset、auto-commit、trusted-packages、poll-timeout、linger 应有尽有，批量消费、开启事务、定义批量消费数量、延时发送、失败重试、异常处理你还想要什么As we all know，当今世界最流行的消息中间件有 RabbitMq、RocketMq、Kafka，其中，应用最广泛的是RabbitMq，RocketMq。
springboot配置多kafka
未知的希望，是我不灭的信仰
08-14 7805
kafka，说起这个玩意，大家应该都不陌生，不知道啥是kafka的直接去搜索 就像MySQL的使用一样，我们在用kafka的时候，也会碰到需要使用多个kafka的情况，比如我从kafkaA的一个topic里消费出数据，进行一次处理，然后我要写入到kafkaB的topic里，，从网上找了很多配置多kafka的教程，但是都不大好使，后来还是找到了，加上我自己改了点点东西，贴出来和大家分享一下~ 首先是pom文件，kafka的依赖 <dependency>
搭建大型分布式服务（四十）SpringBoot 整合多个kafka数据源-支持生产者
hanyi_的专栏
06-23 1092
本插件稳定运行上百个kafka项目，每天处理上亿级的数据的精简小插件，快速上手。< dependency > < groupId > io.github.vipjoey < artifactId > multi-kafka-starter < version > 最新版本号
Springboot配置多Kafka
qq_22313643的博客
05-14 1420
#kafka 配置 1 spring.kafka.one.bootstrap-servers=%%%% spring.kafka.one.consumer.auto-offset-reset=latest spring.kafka.one.consumer.group-id=prod_maxwell spring.kafka.one.consumer.enable-auto-commit=true spring.kafka.one.listener.concurrency=10 spring.kafka..
搭建大型分布式服务（四十一）SpringBoot 整合多个kafka数据源-支持亿级消息生产者
hanyi_的专栏
06-23 895
本插件稳定运行上百个kafka项目，每天处理上亿级的数据的精简小插件，快速上手。< dependency > < groupId > io.github.vipjoey < artifactId > multi-kafka-starter < version > 最新版本号
搭建大型分布式服务（三十七）SpringBoot 整合多个kafka数据源-取消限定符
hanyi_的专栏
04-30 1267
本插件稳定运行上百个kafka项目，每天处理上亿级的数据的精简小插件，快速上手。< dependency > < groupId > io.github.vipjoey < artifactId > multi-kafka-consumer-starter < version > 最新版本号
kafka springBoot 配置
weixin_41827053的博客
08-29 4593
通过这样的配置，你的 Spring Boot 应用程序将启用 Kafka 支持，你可以使用 KafkaTemplate 进行消息发送，使用 @KafkaListener 进行消息消费。但是在这种模式下，如果处理消息时发生异常，Kafka 服务器会重新发送相同的消息，可能会导致消息的重复消费。当你在 Spring Boot 应用程序的配置类上添加 @EnableKafka 注解时，它会激活 Kafka 基础设施，使你能够在应用程序中使用 Kafka 相关的组件。这样可以确保消息的准确处理，避免重复消费。
基于 Springboot + Redis + Kafka 的秒杀系统，乐观锁 + 缓存 + 限流 + 异步
06-14
系统的特点 高性能：秒杀涉及大量的并发读和并发写...负载均衡：利用 Nginx 等使用多个服务器并发处理请求，减少单个服务器压力 前端优化： 限流：前端答题或验证码，来分散用户的请求 禁止重复提交：限定每个用户发起
springboot配置多个kafka
10-09
在Spring Boot中配置多个Kafka可以通过在application.properties或application.yml文件中定义多个Kafka的配置，如下所示： ``` # 第一个Kafka配置 spring.kafka.producer.bootstrap-servers=localhost:9092 spring....
笔记：配置多个kafka生产者和消费者
oki
06-11 4208
当然也可以只定义生产者或者只定义消费者，按需进行，以下示例是同时定义生产者和消费者。/*** 自定义kafka配置*//** 生产者 *//** 消费者 *//** 配置文件*/// @Primary 要指定一下，不然启动会因为存在多个KafkaProperties,而导致kafka的自动装配不懂要选哪个而报错@Primary@Bean@Primary@BeanTips：1）消费者。
Docker Compose 部署 Kafka的KRaft模式 不用依赖 Zookeeper
code在飞的博客
08-27 218
从 Kafka 2.8 开始，KRaft 模式允许 Kafka 在没有 Zookeeper 的情况下运行。本文将部署单机模式。
kafka发送消息-自定义消息发送的拦截器
qq_46112274的博客
08-24 633
kafka发送消息-自定义消息发送的拦截器
浅谈Kafka（二）
快乐江小鱼的博客
08-23 773
在Kafka启动时会在所有的broker中选择一个controller，leader与follower是针对partition，而controller是针对broker的。创建主题、添加分区、修改副本数量之类的管理任务都是由controller来完成的。Kafka分区leader的选举也是由controller决定的。controller选举流程，在集群启动时每个broker都会尝试去zookeeper上注册成为controller(临时节点)。
Kafka队列：分布式系统的消息引擎
qq_56438516的博客
08-26 692
Apache Kafka是一个分布式流处理平台，最初由LinkedIn开发，后来成为Apache软件基金会的一部分。Kafka以其高性能、高吞吐量和可扩展性而闻名，广泛用于构建实时数据管道和流处理应用程序。在本文中，我们将探讨Kafka队列的基本概念、工作原理以及它在现代应用程序中的应用。
Docker 部署 Kafka 可视化 Kafka-UI
最新发布
code在飞的博客
08-27 328
本文部署的Kafka-UI 是基于Docker Compose 部署 Kafka的KRaft模式，如有需要可访问下文链接，此问略过Docker Compose 部署 Kafka的KRaft模式 不用依赖 Zookeeper此部署也适用于不是docker部署的kafka集群。
maxwell读取mysql binlog到kafka
gengjianchun的博客
08-24 298
若出现如下错误，则需要修改mysql时区为东8区。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值