Spring Boot集成kafka 初始尝试

已于 2024-10-15 14:49:43 修改
阅读量971 收藏 20
点赞数 22
CC 4.0 BY-SA版权
文章标签： spring boot kafka java
于 2024-10-15 11:58:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TaylorSwiftRed/article/details/142941736

Kafka简介

Kafka是最初由Linkedin公司开发，是一个分布式、分区的、多副本的、多生产者、多订阅者，基于
zookeeper协调的分布式日志系统（也可以当做MQ系统），常见可以用于web/nginx日志、访问日志，
消息服务等等。
其主要应用场景是：日志收集系统和消息系统。
Kafka主要设计目标如下：
以时间复杂度为O(1)的方式提供消息持久化能力，即使对TB级以上数据也能保证常数时间的访
问性能。
高吞吐率。即使在非常廉价的商用机器上也能做到单机支持每秒100K条消息的传输。
支持Kafka Server间的消息分区，及分布式消费，同时保证每个partition内的消息顺序传输。
同时支持离线数据处理和实时数据处理。
支持在线水平扩展
消息系统有两种主要的消息传递模式：点对点传递模式、发布-订阅模式。大部分的消息系统选用发布-订阅
模式。Kafka就是一种发布-订阅模式。
对于消息中间件，消息分推拉两种模式。Kafka只有消息的拉取，没有推送，可以通过轮询实现消息
的推送。

  1. Kafka在一个或多个可以跨越多个数据中心的服务器上作为集群运行。
  2. Kafka集群中按照主题分类管理，一个主题可以有多个分区，一个分区可以有多个副本分区。
  3. 每个记录由一个键，一个值和一个时间戳组成。
    Kafka具有四个核心API：
  4. Producer API：允许应用程序将记录流发布到一个或多个Kafka主题。
  5. Consumer API：允许应用程序订阅一个或多个主题并处理为其生成的记录流。
  6. Streams API：允许应用程序充当流处理器，使用一个或多个主题的输入流，并生成一个或多
    个输出主题的输出流，从而有效地将输入流转换为输出流。
  7. Connector API：允许构建和运行将Kafka主题连接到现有应用程序或数据系统的可重用生产者
    或使用者。例如，关系数据库的连接器可能会捕获对表的所有更改。

Spring Boot集成Kafka

SpringBoot与Kafka集成相当简单，而且相关的配置也较为完善，很好上手，麻烦的在于运维配置，kafka集群的配置，通信

1.先引入相关依赖，该demo使用较新版本3.2.1，客户端使用3.6.2

   <!-- spring-kafka -->
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
            <version>3.2.1</version>
        </dependency>
        <!-- kafka-clients -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>3.6.2</version>
        </dependency>

2.编写application.yml中的配置

server:
  port: 8088

spring:
  application:
    name: xx
  datasource:
    url: jdbc:mysql://localhost:3306/xx?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      initial-size: 5
      min-idle: 5
      max-active: 20
      max-wait: 6000
  jackson:
    date-format: yyyy-MM-dd HH:mm:ss
    time-zone: GMT+8
    default-property-inclusion: non_null
  # kafuka配置
  kafka:
     # 用于建立初始连接的broker地址
    bootstrap-servers: localhost:9092
    # 生产者配置
    producer:
      # producer用到的key和value的序列化类
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
      batch-size: 16384 #  默认的批处理记录数
      buffer-memory: 33554432 # 默认的缓冲区大小  32MB的总发送缓存
    # 消费者配置
    consumer:
      # 消费者consumer用到的key和value的序列化类
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      #  consumer的消费组id
      group-id: vhr-group
      # 是否自动提交消费者偏移量
      enable-auto-commit: false
      # 每隔100ms向broker提交一次偏移量
      auto-commit-interval: 1000
      auto-offset-reset: earliest  # 果该消费者的偏移量不存在，则自动设置为最早的偏移量

3.kafka配置类

在上面的yml编写后，理论上就已经可以使用KafkaTemplate<String, Object>类注入后使用kafka了，可以不再编写配置类了，此次是为了方便读取配置使用

import com.google.common.collect.Maps;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.*;

import java.util.Map;

@Configuration
@EnableKafka
public class KafkaConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;
    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;

    @Value("${spring.kafka.consumer.enable-auto-commit}")
    private boolean autoCommitEnabled;

    @Value("${spring.kafka.consumer.auto-commit-interval}")
    private int autoCommitInterval;

    @Value("${spring.kafka.consumer.auto-offset-reset}")
    private String autoOffsetReset;



    /**
     * 创建并返回一个生产者工厂实例，该工厂用于创建发送消息到Kafka主题的生产者客户端
     *
     * @return 返回一个生产者工厂实例，专门用于创建处理String键和Object值的生产者客户端
     */
    @Bean
    public ProducerFactory<String, Object> producerFactory() {
        Map<String, Object> config = Maps.newHashMapWithExpectedSize(16);
        config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return new DefaultKafkaProducerFactory<>(config);
    }

    @Bean
    public KafkaTemplate<String, Object> kafkaTemplate() {
        return new KafkaTemplate<>(producerFactory());
    }

    /**
     * 创建Kafka消费者监听器工厂
     * 该工厂用于配置和实例化Kafka消费者，以便消费Kafka主题的消息
     *
     * @return 返回一个配置了必要属性的Kafka消费者工厂实例
     */
    @Bean
    public ConsumerFactory<String, Object> kafkaConsumerListener() {
        Map<String, Object> config = this.consumerConfigs();
        return new DefaultKafkaConsumerFactory<>(config);
    }

    @Bean
    public ConcurrentKafkaListenerContainerFactory<String, Object> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(kafkaConsumerListener());
        return factory;
    }

    @Bean
    public <K, V> KafkaConsumer<K, V> kafkaConsumerConfig(@Qualifier("kafkaConsumerListener") ConsumerFactory<String, Object> consumerFactory) {
        return (KafkaConsumer<K, V>)consumerFactory.createConsumer();
    }


    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> config = Maps.newHashMapWithExpectedSize(16);
        //  用于建立初始连接的broker地址
        config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        //  consumer的消费组id
        config.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        config.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, autoCommitEnabled);
        config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return config;
    }
}

编写测试方法，查看结果

import com.common.plugin.kafuka.KafkaConfig;
import com.common.plugin.redis.RedisUtil;
import org.apache.commons.lang3.StringUtils;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;
import org.junit.jupiter.api.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.test.context.junit4.SpringRunner;

import java.time.Duration;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

@SpringBootTest(classes = VhrServerApplication.class)
@RunWith(SpringRunner.class)
class VhrServerApplicationTests {

    @Autowired
    private KafkaTemplate<String, Object> kafkaTemplate;

    @Autowired
    private KafkaConfig config;

    /**
     *  同步发送
     */
    @Test
    public void testKafKaSend() {
        CompletableFuture<SendResult<String, Object>> send = kafkaTemplate.send("vhr_topic_01", "test", "hello world");
        try {
            SendResult<String, Object> sendResult = send.get();
            RecordMetadata metadata = sendResult.getRecordMetadata();
            System.out.println("kafka同步发送结果：主题：" + metadata.topic() + "分区：" + metadata.partition() + "偏移量：" + metadata.offset());
        } catch (InterruptedException | ExecutionException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 异步发送，带有回调方法
     */
    @Test
    public void testKafkaAsync() {
        try (Producer<String, Object> producer = kafkaTemplate.getProducerFactory().createProducer()) {
            ProducerRecord<String, Object> record = new ProducerRecord<>("vhr_topic_01", "test", "hello world async");
            // 使用lambda表达式演示Callback，ifPresentOrElse为JDK9的新特性，项目中使用的JDK版本为Java17
            producer.send(record, (recordMetadata, e) -> Optional.ofNullable(e).ifPresentOrElse(ex -> System.out.println("发送失败"),
                    () -> System.out.println("kafka异步发送主题：" + recordMetadata.topic() + "，分区：" + recordMetadata.partition() + "，偏移量：" + recordMetadata.offset())));

            // 使用非lambda表达式演示Callback
//            producer.send(record, new Callback() {
//                @Override
//                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
//                    if (Objects.nonNull(e)) {
//                        System.out.println("发送失败");
//                    }else {
//                        System.out.println("kafka异步发送主题：" + recordMetadata.topic() + "，分区：" + recordMetadata.partition() + "，偏移量：" + recordMetadata.offset());
//                    }
//                }
//            });

        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    /**
    * kafka消息拉取测试
    **/
    @Test
    public void  testKafKaPoll(){
        try(KafkaConsumer<String, Object> consumer = new KafkaConsumer<>(config.consumerConfigs())) {
        	// 消费消息前需要先订阅主题，List.of方法是Java17新方法
            consumer.subscribe(List.of("test","vhr_topic_01"));
            ConsumerRecords<String, Object> consumerRecords = consumer.poll(Duration.ofMillis(1000L));
            StringBuilder builder = new StringBuilder();
            for (ConsumerRecord<String, Object> record : consumerRecords) {
                builder.append("看看主题：").append(record.topic()).append("\t").append("分区：").append(record.partition()).append("\t，").append("偏移量：").append(record.offset())
                        .append("\t，key：").append(record.key()).append("\t，value：").append(record.value()).append("\n\n");
            }
            String msg = builder.toString();
            if (StringUtils.isNotBlank(msg)) {
                System.out.println("kafka拉取结果："+msg);
            }
        }
    }
}

同步测试结果：
在这里插入图片描述
异步测试结果：

在这里插入图片描述
消息拉取结果：
在这里插入图片描述

其他，使用一个定时任务，拉取kafka消息

import cn.hutool.core.thread.ThreadUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.kafka.clients.consumer.Consumer;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.util.List;
import java.util.concurrent.ExecutorService;

@Service
@Slf4j
public class KafKaPolTest {

    private final KafkaConfig kafkaConfig;
    public KafKaPolTest(KafkaConfig kafkaConfig) {
        this.kafkaConfig = kafkaConfig;

    }

private  static  final   ExecutorService executor = ThreadUtil.newExecutor(10, 20);

    @Scheduled(cron = "*/60 * * * * ?")
    public void pool() {
       log.info("定时任务会运行吗？");
        executor.execute(() -> {
            System.out.println("看看线程：" + Thread.currentThread().getName());
            // 1.· 创建一个 KafkaConsumer，使用DefaultKafkaConsumerFactory方法
//            try (Consumer<String, Object> consumer = new DefaultKafkaConsumerFactory<String,Object>(kafkaConfig.consumerConfigs()).createConsumer()) {
            // 2. 使用KafkaConsumer创建一个消费者
            try (Consumer<String, Object> consumer =new KafkaConsumer<>(kafkaConfig.consumerConfigs())) {
                consumer.subscribe(List.of("test","vhr_topic_01"));
                int maxAttempts = 5; // 最多尝试 5 次
                int attempts = 0;
                while (attempts<maxAttempts) {
                    StringBuilder builder = new StringBuilder();
                    ConsumerRecords<String, Object> consumerRecords = consumer.poll(Duration.ofMillis(1000L));
                    for (ConsumerRecord<String, Object> record : consumerRecords) {
                        builder.append("看看主题：").append(record.topic()).append("\t").append("分区：").append(record.partition()).append("\t，").append("偏移量：").append(record.offset())
                                .append("\t，key：").append(record.key()).append("\t，value：").append(record.value()).append("\n\n");
                    }
                    String msg = builder.toString();
                    if (StringUtils.isNotBlank(msg)) {
                        log.info("看看消息：{}", msg);
                        break;
                    }
                    attempts++;

                }
            }
        });
    }
}

经过测试，注释KafkaConfig类里面生产者和消费者配置的代码，不影响KafkaTemplate<String, Object> 的使用，新配置的KafkaConfig类内容如下：

import com.google.common.collect.Maps;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;

import java.util.Map;

@Configuration
@EnableKafka
public class KafkaConfig {
    @Value("${spring.kafka.bootstrap-servers}")
    private String bootstrapServers;
    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;

    @Value("${spring.kafka.consumer.enable-auto-commit}")
    private boolean autoCommitEnabled;

    @Value("${spring.kafka.consumer.auto-commit-interval}")
    private int autoCommitInterval;

    @Value("${spring.kafka.consumer.auto-offset-reset}")
    private String autoOffsetReset;



    /**
     * 创建并返回一个生产者工厂实例，该工厂用于创建发送消息到Kafka主题的生产者客户端
     *
     * @return 返回一个生产者工厂实例，专门用于创建处理String键和Object值的生产者客户端
     */
//    @Bean
//    public ProducerFactory<String, Object> producerFactory() {
//        Map<String, Object> config = Maps.newHashMapWithExpectedSize(16);
//        config.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
//        config.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
//        config.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
//        return new DefaultKafkaProducerFactory<>(config);
//    }
//
//    @Bean
//    public KafkaTemplate<String, Object> kafkaTemplate() {
//        return new KafkaTemplate<>(producerFactory());
//    }
//
//    /**
//     * 创建Kafka消费者监听器工厂
//     * 该工厂用于配置和实例化Kafka消费者，以便消费Kafka主题的消息
//     *
//     * @return 返回一个配置了必要属性的Kafka消费者工厂实例
//     */
//    @Bean
//    public ConsumerFactory<String, Object> kafkaConsumerListener() {
//        Map<String, Object> config = this.consumerConfigs();
//        return new DefaultKafkaConsumerFactory<>(config);
//    }
//
//    @Bean
//    public ConcurrentKafkaListenerContainerFactory<String, Object> kafkaListenerContainerFactory() {
//        ConcurrentKafkaListenerContainerFactory<String, Object> factory = new ConcurrentKafkaListenerContainerFactory<>();
//        factory.setConsumerFactory(kafkaConsumerListener());
//        return factory;
//    }
//
//    @Bean
//    public <K, V> KafkaConsumer<K, V> kafkaConsumerConfig(@Qualifier("kafkaConsumerListener") ConsumerFactory<String, Object> consumerFactory) {
//        return (KafkaConsumer<K, V>)consumerFactory.createConsumer();
//    }


    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> config = Maps.newHashMapWithExpectedSize(16);
        config.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        config.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        config.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        config.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, autoCommitEnabled);
        config.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        config.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        config.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return config;
    }
}

测试结果如下：
在这里插入图片描述

Spring Boot如何集成Kafka？
**My Coding Family**
04-27 1181
🏆 本文精选收录于《滚雪球学SpringBoot》专栏，专为零基础学习者量身打造。从Spring基础到项目实战，手把手带你掌握核心技术，助力你快速提升，迈向职场巅峰，开启财富自由之路🚀！无论你是刚入门的小白，还是已有基础的开发者，都能在这里找到适合自己的学习路径！    🌟 关注、收藏、订阅，持续更新中！和我们一起高速成长，突破自我！💡
【项目实战】SpringBoot整合Kafka消息队列（基于KafkaTemplate和@KafkaListener实现）
本本本添哥
01-04 6678
SpringBoot整合Kafka消息队列（基于KafkaTemplate和@KafkaListener实现）
spring+kafka的KafkaTemplate使用
yzh_1346983557的博客
01-30 2918
acks = 1 这意味着leader会将记录写入其本地日志，但无需等待所有副本服务器的完全确认即可做出回应，在这种情况下，如果leader在确认记录后立即失败，但在将数据复制到所有的副本服务器之前，则记录将会丢失。#acks = all 这意味着leader将等待完整的同步副本集以确认记录，这保证了只要至少一个同步副本服务器仍然存活，记录就不会丢失，这是最强有力的保证，这相当于acks = -1的设置。默认懒加载，服务启动时不会生效，只有在第一次使用kafka生产、消费数据时才会加载生效。
springboot集成kafka基础入门
longxianhua的博客
05-29 1304
kafka的windows安装启动请看本人另外一篇文章 kafka在windows下安装和使用入门教程 引入依赖 初始化一个springboot项目，和kafka相关的只依赖一个spring-kafka集成包,这里注意springboot的版本和kafka的版本要能对应上,我用的springboot 1.5.9 <dependency> <groupId>org.springframework.kafka</groupId>
实战：用 Spring Boot 快速构建一个 Kafka 消息系统
最新发布
小健学Java的博客
04-30 1437
初步搭建好系统之后，如果你想真正用 Kafka 支撑起生产级别的业务，还需要掌握更深入的能力。Spring Kafka 也支持 Avro 集成，只需添加依赖，并在配置中指定使用 Avro 序列化器、反序列化器。而 Kafka，以其高吞吐、可扩展、可靠的特性，成为了很多项目的不二之选。Kafka 会根据 key 的 hash 值选择分区，同样 key 的消息一定落到同一个分区，从而保证顺序。这种方式能精准控制 offset 的提交时机，比如确保消息真正处理成功之后再提交，极大提升了系统的可靠性。
Springboot 配置使用 Kafka
热门推荐
friggly的博客
02-22 1万+
As we all know，当今世界最流行的消息中间件有 RabbitMq、RocketMq、Kafka，其中，应用最广泛的是 RabbitMq，RocketMq 是阿里巴巴的产品，性能超过 RabbitMq，已经经受了多年的双11考验，但是怕哪天阿里不维护了，用的人不多，Kafka 是吞吐量最大的一个，远超前两个，支持事务、可保证消息的不丢失（网上说的事务和消息可靠性不支持是说的旧版，2以后就开始支持了），对比来讲，Kafka相对于前两个，只有一个劣势，不太支持延时队列，其他方面都要优于它们。
Spring-Kafka系列(2)——SpringKafka生产者KafkaTemplate
SpringBoy的博客
06-20 7629
SpringBoot为Kafka提供了两种配置方式SpringBoot提供了配置类，且会将开头的配置项值注入的配置类中 在使用Kafka配置项时只需要将其注入即可 在spring的配置文件中配置如下： 2.2 SpringKafka生产者KafkaTemplate 2.2.1 创建一个生产者KafkaTemplate 创建流程：application.ymlKafkapropertiesProducerFactoryKafkaTemplate 2.2.2 KafkaTemplate发送消息方法 Kafka
17、Kafka ------ SpringBoot 整合 Kafka 发送 和 接收消息（使用 KafkaTemplate 发送消息 和 使用 @KafkaListener 修饰监听器来接收消息）
Java 领域技术分享
01-29 4883
SpringBoot 整合 Kafka 发送 和 接收消息（使用 KafkaTemplate 发送消息 和 使用 @KafkaListener 修饰监听器来接收消息）
springboot中的kafka的KafkaTemplate的配置类
lifengBigCat的博客
02-19 1万+
package com.lf.report.utils; import org.apache.kafka.clients.producer.ProducerConfig; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Bean; i...
Spring Boot集成Kafka：最佳实践与详细指南
m0_67391521的博客
03-10 861
本文详细介绍了如何在Spring Boot项目中集成Kafka，并通过最佳实践和代码示例来指导你。通过合理配置Kafka、使用KafkaTemplate发送消息、使用@KafkaListener接收消息以及处理错误和监控，你可以轻松地构建高效、可靠的消息处理系统。希望本文对你有所帮助！
新手入门Kafka在SpringBoot中使用
weixin_66599899的博客
11-08 142
新手入门Kafka在SpringBoot中使用
springboot整合kafka
m0_74642813的博客
06-20 4704
本教程将介绍如何在 Spring Boot 应用程序中使用 Kafka。Kafka是一个分布式的发布-订阅消息系统，它可以处理大量数据并提供高吞吐量。在本教程中，我们将使用 Spring Boot 2.7.2 和Kafka 2.8.1。
springboot 集成kafka 详细教程，看这一篇就够了
Edward的博客
07-13 6576
springboot ,kafka
使用Spring Boot轻松集成Kafka
Eddie_920的博客
05-10 1286
读完本文你会对Kafka有更加深入的了解并且在使用时遇到问题也会迎刃而解 实时处理数据并确保应用程序各部分之间实现无缝通信的重要性显而易见。在这一领域中，Apache Kafka技术备受瞩目。在本文章中，我们将探讨Kafka的基本概念、关键特性以及它如何完美融入Spring Boot生态系统。
Spring Boot 中的 KafkaTemplate 是什么，原理，如何使用
stormjun的博客
07-01 2626
Kafka 是一个流行的分布式消息系统，Spring Boot 提供了对 Kafka 的支持，我们可以使用 KafkaTemplate 来发送和接收 Kafka 中的消息。在使用 KafkaTemplate 时，我们可以使用 send 方法来发送消息，也可以使用其他方法来满足需求。在使用 KafkaTemplate 时，我们需要配置 KafkaProducer 的属性，并注意一些注意事项，如线程安全、异步发送等。对于更加复杂的场景，我们还可以使用更加灵活的配置来满足需求。
SpringBoot Kafka 整合使用
yjt520557的博客
03-19 3491
这里关键的代码为 kafkaTemplate.send()方法，message是 Kafka 里的 topic ，这个 topic 在 Java 程序中是不需要提前在 Kafka 中设置的，因为它会在发送的时候自动创建你设置的 topic， gson.toJson(message)是消息内容，1.你能看到我这篇文章证明你对与springboot和kafka都有了解了所以也不d说什么了 在这里大家...
spring-kafka整合:KafkaTemplate-kafka模板类介绍
PacosonSWJTU的博客
11-13 1万+
【README】 1，本文主要关注 KafkaTemplate的重点方法，并非全部方法； 2，KafkaTemplate 底层依赖于 DefaultKafkaProducerFactory ， 关于 DefaultKafkaProducerFactory 的介绍，refer2 spring-kafka整合:DefaultKafkaProducerFactory默认kafka生产者工厂介绍_PacosonSWJTU的博客-优快云博客【1】 类描述类描述：单例共享 Producer 实例的 Prod..
SpringBoot集成Kafka开发
Libra_97的博客
05-01 2893
SpringBoot集成Kafka开发
springboot整合kafka（结合了KafkaTemplate）
weixin_43061778的博客
08-18 385
以下是一个简单的Spring Boot整合Kafka的完整代码示例，包括生产者和消费者。这样就完成了简单的Spring Boot整合Kafka的示例。在应用程序主类中，添加Kafka配置信息，并使用。在这个示例中，生产者和消费者都订阅了名为。属性指定了Kafka集群的地址。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值