springboot 连接 kafka集群(kafka版本 2.13-3.4.0)

这篇具有很好参考价值的文章主要介绍了springboot 连接 kafka集群(kafka版本 2.13-3.4.0)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站。

一、环境搭建

1.1 springboot 环境

JDK 11+
Maven 3.8.x+
springboot 2.5.4 +

1.2 kafka 依赖

springboot的pom文件导入

       <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>3.4.0</version>
        </dependency>

二、 kafka 配置类

2.1 发布者

2.1.1 配置

发布者我们使用 KafkaTemplate 来进行消息发布,所以需要先对其进行一些必要的配置。

@Configuration
@EnableKafka
public class KafkaConfig {


     /***** 发布者 *****/

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

    //生产者配置
    @Bean
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.2.83:9092,192.168.2.84:9092,192.168.2.86:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    //生产者模板
    @Bean
    public KafkaTemplate<Integer, String> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }
}
2.1.2 构建发布者类

配置完发布者,下来就是发布消息,我们需要继承 ProducerListener<K, V> 接口,该接口完整信息如下:

public interface ProducerListener<K, V> {

    void onSuccess(ProducerRecord<K, V> producerRecord, RecordMetadata recordMetadata);

    void onError(ProducerRecord<K, V> producerRecord, RecordMetadata recordMetadata,
            Exception exception);

}

实现该接口的方法,我们可以获取包含发送结果(成功或失败)的异步回调,也就是可以在这个接口的实现中获取发送结果。

我们简单的实现构建一个发布者类,接收主题和发布消息参数,并打印发布结果。

@Component
public class KafkaProducer implements ProducerListener<Object,Object> {

    private static final Logger producerlog = LoggerFactory.getLogger(KafkaProducer.class);

    private final KafkaTemplate<Integer, String> kafkaTemplate;

    public KafkaProducer(KafkaTemplate<Integer, String> kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    public void producer (String msg,String topic){
        ListenableFuture<SendResult<Integer, String>> future = kafkaTemplate.send(topic,0, msg);
        future.addCallback(new KafkaSendCallback<Integer, String>() {

            @Override
            public void onSuccess(SendResult<Integer, String> result) {
                producerlog.info("发送成功 {}", result);
            }

            @Override
            public void onFailure(KafkaProducerException ex) {
                ProducerRecord<Integer, String> failed = ex.getFailedProducerRecord();
                producerlog.info("发送失败 {}",failed);
            }

        });
    }

}
2.1.3 发布消息

写一个controller类来测试我们构建的发布者类,这个类中打印接收到的消息,来确保信息接收不出问题。

@RestController
public class KafkaTestController {

    private static final Logger kafkaTestLog = LoggerFactory.getLogger(KafkaTestController.class);

    @Resource
    private KafkaProducer kafkaProducer;

    @GetMapping("/kafkaTest")
    public void kafkaTest(String msg,String topic){
        kafkaProducer.producer(msg,topic);
        kafkaTestLog.info("接收到消息 {} {}",msg,topic);
    }
}

一切准备就绪,我们启动程序利用postman来进行简单的测试。

进行消息发布:
springboot 连接 kafka集群(kafka版本 2.13-3.4.0)

发布结果:
springboot 连接 kafka集群(kafka版本 2.13-3.4.0)
可以看到消息发送成功。

我们再看看kafka消费者有没有接收到消息:

springboot 连接 kafka集群(kafka版本 2.13-3.4.0)

看以看到,kakfa的消费者也接收到了消息。

2.2 消费者

2.2.1 配置

消息的接受有多种方式,我们这里选择的是使用 @KafkaListener 注解来进行消息接收。它的使用像下面这样:

public class Listener {

    @KafkaListener(id = "foo", topics = "myTopic", clientIdPrefix = "myClientId")
    public void listen(String data) {
        ...
    }

}

看起来不是太难吧,但使用这个注解,我们需要配置底层 ConcurrentMessageListenerContainer.kafkaListenerContainerFactor。

我们在原来的kafka配置类 KafkaConfig 中,继续配置消费者,大概就像下面这样

@Configuration
@EnableKafka
public class KafkaConfig {


     /***** 发布者 *****/

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

    //生产者配置
    @Bean
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.2.83:9092,192.168.2.84:9092,192.168.2.86:9092");
           props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, IntegerSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

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

    /***** 消费者 *****/

    //容器监听工厂
    @Bean
    KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<Integer, String>>
    kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<Integer, String> factory =
                new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(3);
        factory.getContainerProperties().setPollTimeout(3000);
        return factory;
    }

    //消费者工厂
    @Bean
    public ConsumerFactory<Integer, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
    }

    //消费者配置
    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.2.83:9092,192.168.2.84:9092,192.168.2.86:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, IntegerDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ErrorHandlingDeserializer.KEY_DESERIALIZER_CLASS, JsonDeserializer.class);
        props.put(ErrorHandlingDeserializer.VALUE_DESERIALIZER_CLASS, JsonDeserializer.class.getName());
        props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);
        return props;
    }
}

注意,要设置容器属性必须使用getContainerProperties()工厂方法。它用作注入容器的实际属性的模板

2.2.2 构建消费者类

配置好后,我们就可以使用这个注解了。这个注解的使用有多种方式:

1、用它来覆盖容器工厂的concurrency和属性

@KafkaListener(id = "myListener", topics = "myTopic",
        autoStartup = "${listen.auto.start:true}", concurrency = "${listen.concurrency:3}")
public void listen(String data) {
    ...
}

2、可以使用显式主题和分区(以及可选的初始偏移量)

@KafkaListener(id = "thing2", topicPartitions =
        { @TopicPartition(topic = "topic1", partitions = { "0", "1" }),
          @TopicPartition(topic = "topic2", partitions = "0",
             partitionOffsets = @PartitionOffset(partition = "1", initialOffset = "100"))
        })
public void listen(ConsumerRecord<?, ?> record) {
    ...
}


3、将初始偏移应用于所有已分配的分区

@KafkaListener(id = "thing3", topicPartitions =
        { @TopicPartition(topic = "topic1", partitions = { "0", "1" },
             partitionOffsets = @PartitionOffset(partition = "*", initialOffset = "0"))
        })
public void listen(ConsumerRecord<?, ?> record) {
    ...
}


4、指定以逗号分隔的分区列表或分区范围

@KafkaListener(id = "pp", autoStartup = "false",
        topicPartitions = @TopicPartition(topic = "topic1",
                partitions = "0-5, 7, 10-15"))
public void process(String in) {
    ...
}


5、可以向侦听器提供Acknowledgment

@KafkaListener(id = "cat", topics = "myTopic",
          containerFactory = "kafkaManualAckListenerContainerFactory")
public void listen(String data, Acknowledgment ack) {
    ...
    ack.acknowledge();
}


6、添加标头

@KafkaListener(id = "list", topics = "myTopic", containerFactory = "batchFactory")
public void listen(List<String> list,
        @Header(KafkaHeaders.RECEIVED_KEY) List<Integer> keys,
        @Header(KafkaHeaders.RECEIVED_PARTITION) List<Integer> partitions,
        @Header(KafkaHeaders.RECEIVED_TOPIC) List<String> topics,
        @Header(KafkaHeaders.OFFSET) List<Long> offsets) {
    ...
}


我们这里写一个简单的,只用它来接受指定主题的数据:

@Component
public class KafkaConsumer {

    private static final Logger consumerlog = LoggerFactory.getLogger(KafkaConsumer.class);

    @KafkaListener(topicPartitions  = @TopicPartition(topic = "kafka-topic-test",
            partitions = "0"))
    public void consumer (String data){
        consumerlog.info("消费者接收数据 {}",data);
    }
}

这里解释一下,因为我们进行了手动分配主题/分区,所以 注解中group.id 可以为空。若要指定group.id请在消费者配置中加上props.put(ConsumerConfig.GROUP_ID_CONFIG, “bzt001”); 或在 @TopicPartition 注解后加上 groupId = “组id”

2.2.3 进行消息消费

继续使用postman调用我们写好的发布者发布消息,观察控制台的消费者类是否有相关日志出现。
springboot 连接 kafka集群(kafka版本 2.13-3.4.0)文章来源地址https://www.toymoban.com/news/detail-510149.html

到了这里,关于springboot 连接 kafka集群(kafka版本 2.13-3.4.0)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 2.13日学习打卡----初学RocketMQ(四)

    概述 DefaultMQProducer 类是应用发送消息使用的基类,封装一些通用的方法方便开发者在更多场景中使用。属于线程安全类,在配置并启动后可在多个线程间共享此对象。 其可以通过无参构造方法快速创建一个生产者,通过 getter/setter 方法,调整发送者的参数。主要负责消息的

    2024年02月21日
    浏览(35)
  • YUV格式的图片查看工具YUView 2.13

    YUV格式的图片查看工具YUView 2.13 参考资料:                Image to YUV (ffmpeg/ImageMagick) 这2个工具可用于音视频格式转换等处理                Image to YUV (ffmpeg/ImageMagick)_hushui的博客-CSDN博客                FFmpeg常用命令/参数                https://blog.csdn.net/weixin_3681132

    2024年02月12日
    浏览(43)
  • Java 新的生态型应用开发框架,Solon v2.2.13 发布

    Java 新的生态型应用开发框架,Solon :更快、更小、更简单。从零开始构建,有自己的标准规范与开放生态: 150多个生态插件,可以满足各种场景开发 大量的国产框架适配,可以为应用软件国产化提供更好支持,助力信创建设 相对于 Spring Boot 和 Spring Cloud 的项目: 启动快

    2023年04月25日
    浏览(45)
  • 【Kafka】Kafka3.1.1集群搭建指南KRaft版本

    目录 一、背景和描述 二、资源情况 三、技术选型 四、部署Kraft版本集群 五、配置SSL模式 六、Springboot使用SSL集成 参考资料 考虑资源安全性,需要搭建不依赖Zookeeper的kafka集群环境,并且配置SSL访问控制 Apache Kafka Raft 是一种共识协议,它的引入是为了消除 Kafka 对 ZooKeeper 的

    2024年02月03日
    浏览(42)
  • 【Kafka】Kafka3.3.1集群搭建指南KRaft版本

    目录 一、背景和描述 二、资源情况 三、技术选型 四、部署Kraft版本集群 五、配置SSL模式 六、Springboot使用SSL集成 参考资料 考虑资源安全性,需要搭建不依赖Zookeeper的kafka集群环境,并且配置SSL访问控制 Apache Kafka Raft 是一种共识协议,它的引入是为了消除 Kafka 对 ZooKeeper 的

    2024年02月05日
    浏览(55)
  • 【青龙2.13依赖安装失败修复】ERR_PNPM_REGISTRIES_MISMATCH This modules directory was created using ...

    在新版的青龙面板自带的依赖安装中总是安装失败,产看日志发现: ERR_PNPM_REGISTRIES_MISMATCH  This modules directory was created using the following registries configuration: {“default”:“https://registry.npmjs.org/”}. The current configuration is {“default”:“https://registry.npm.taobao.org/”}. To recreate the modu

    2024年02月16日
    浏览(80)
  • CentOS7中新版本自带zookeeper搭建Kafka集群

    一、zookeeper在kafka中的具体作用     它是一个分布式协调框架。很好的将消息生产、消息存储、消息消费的过程结合在一起。在典型的Kafka集群中,Kafka通过Zookeeper管理集群控制,选举leader,以及在Consumer Group发生变化时进行rebalance。Producer使用push模式将消息发布到broker,Con

    2024年02月08日
    浏览(87)
  • Kafka的历史版本对应SpringBoot版本

    截至目前(2023年),Kafka的最新版本是2.9.0,发布于2022年11月30日。Kafka的历史版本可以在Kafka官方网站的下载页面中找到。Kafka从0.8版本开始发布,经历了多个版本的迭代和升级。以下是一些比较重要的Kafka版本及其发布年份: Kafka 0.8:2013年 Kafka 0.9:2015年 Kafka 0.10:2016年 K

    2024年02月08日
    浏览(53)
  • Kafka3.0.0版本——集群部署(linux环境-centos7)

    三台服务器 服务器名称 服务器ip centos7虚拟机1 192.168.136.27 centos7虚拟机2 192.168.136.28 centos7虚拟机3 192.168.136.29 Zookeeper集群安装参考此博文链接:https://wwwxz.blog.csdn.net/article/details/129280956?spm=1001.2014.3001.5502 3.1、官网下载地址 官网下载地址:http://kafka.apache.org/downloads.html 3.2、下载

    2024年02月04日
    浏览(45)
  • springboot第44集:Kafka集群和Lua脚本

    servers :Kafka服务器的地址。这是Kafka集群的地址,生产者将使用它来发送消息。 retries :在消息发送失败时,生产者将尝试重新发送消息的次数。这个属性指定了重试次数。 batchSize :指定了生产者在发送消息之前累积的消息大小(以字节为单位)。一次性发送多个消息可以

    2024年02月07日
    浏览(43)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包