Kafka使用示例

最新推荐文章于 2025-05-24 19:32:58 发布
原创 最新推荐文章于 2025-05-24 19:32:58 发布 · 234 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#kafka #linq #分布式

以下是 Kafka 的生产者工具类、消费者监听及测试代码示例，封装了多种发送方式，并包含详细注释：

1. 依赖配置 (pom.xml)

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

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

    <!-- Lombok（可选，简化代码） -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>

    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

2. 配置文件 (application.yml)

spring:
  kafka:
    bootstrap-servers: localhost:909
    producer:
      retry:
        enabled: false            # 关闭自动重试
      #当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。
      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
      retry:
        enabled: false # 关闭重试机制

3. 生产者工具类 (KafkaProducerUtil)

import lombok.extern.slf4j.Slf4j;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.stereotype.Component;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

@Slf4j
@Component
public class KafkaProducerUtil {

    private final KafkaTemplate<String, String> kafkaTemplate;

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

    /**
     * 同步发送消息（阻塞等待结果）
     */
    public SendResult<String, String> sendSync(String topic, String message) {
        try {
            return kafkaTemplate.send(topic, message).get();
        } catch (Exception e) {
            log.error("同步发送消息失败 | Topic: {} | Message: {}", topic, message, e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 异步发送消息（默认无回调）
     */
    public void sendAsync(String topic, String message) {
        kafkaTemplate.send(topic, message);
        log.info("异步消息已提交 | Topic: {} | Message: {}", topic, message);
    }

    /**
     * 异步发送消息（带回调）
     */
    public void sendAsyncWithCallback(String topic, String message) {
        ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(topic, message);
        future.addCallback(new ListenableFutureCallback<>() {
            @Override
            public void onSuccess(SendResult<String, String> result) {
                log.info("异步发送成功 | Topic: {} | Partition: {} | Offset: {}",
                        topic, result.getRecordMetadata().partition(), result.getRecordMetadata().offset());
            }

            @Override
            public void onFailure(Throwable ex) {
                log.error("异步发送失败 | Topic: {} | Message: {}", topic, message, ex);
            }
        });
    }

    /**
     * 发送到指定分区（需提前知道分区数量）
     */
    public void sendToPartition(String topic, Integer partition, String key, String message) {
        kafkaTemplate.send(topic, partition, key, message);
        log.info("发送到指定分区 | Topic: {} | Partition: {} | Key: {} | Message: {}", topic, partition, key, message);
    }

    /**
     * 发送带 Key 的消息（相同 Key 进入同一分区，保证顺序性）
     */
    public void sendWithKey(String topic, String key, String message) {
        kafkaTemplate.send(topic, key, message);
        log.info("发送带 Key 的消息 | Topic: {} | Key: {} | Message: {}", topic, key, message);
    }
}

4. 消费者监听类

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.support.Acknowledgment;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class KafkaConsumer {

    // 监听普通消息（自动提交）
    @KafkaListener(topics = "SYNC_TOPIC", groupId = "sync-group")
    public void listenSyncMessage(ConsumerRecord<String, String> record) {
        log.info("[普通消息] 接收 | Topic: {} | Partition: {} | Offset: {} | Key: {} | Value: {}",
                record.topic(), record.partition(), record.offset(), record.key(), record.value());
    }

    // 监听带 Key 的消息（手动提交）
    @KafkaListener(topics = "KEY_TOPIC", groupId = "key-group")
    public void listenKeyMessage(ConsumerRecord<String, String> record, Acknowledgment ack) {
        try {
            log.info("[带 Key 消息] 接收 | Key: {} | Value: {}", record.key(), record.value());
            // 业务处理...
            ack.acknowledge(); // 手动提交偏移量
        } catch (Exception e) {
            log.error("消费失败 | Topic: {} | Message: {}", record.topic(), record.value(), e);
        }
    }

    // 监听指定分区的消息（分区 0）
    @KafkaListener(topicPartitions = @org.springframework.kafka.annotation.TopicPartition(
            topic = "PARTITION_TOPIC",
            partitions = "0"
    ), groupId = "partition-group")
    public void listenPartitionMessage(ConsumerRecord<String, String> record) {
        log.info("[指定分区消息] 接收 | Partition: {} | Value: {}", record.partition(), record.value());
    }
}

5. 测试类

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class KafkaProducerTest {

    @Autowired
    private KafkaProducerUtil kafkaProducer;

    // 同步发送测试
    @Test
    public void testSyncSend() {
        kafkaProducer.sendSync("SYNC_TOPIC", "同步测试消息");
    }

    // 异步发送测试
    @Test
    public void testAsyncSend() {
        kafkaProducer.sendAsync("ASYNC_TOPIC", "异步测试消息");
    }

    // 带回调的异步发送测试
    @Test
    public void testAsyncWithCallback() {
        kafkaProducer.sendAsyncWithCallback("CALLBACK_TOPIC", "带回调的异步消息");
        try { Thread.sleep(3000); } catch (InterruptedException e) {} // 等待回调
    }
Kafka使用案例
zq9955的博客
07-27 448
【代码】Kafka使用案例。
kafka 案例
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
05-26 1229
System . out . println("消息发送成功！");} else {System . out . println("消息发送失败：" + exception . getMessage());} } });} }System . out . println("消息发送成功！");} else {System . out . println("消息发送失败：" + exception . getMessage());} } });} }
springboot kafka集成demo
10-17
本资源是一个最新的springboot+kafka集成demo 博客地址：https://my.oschina.net/u/3642896/blog/1506378
springboot+kafka
杰神的博客
10-26 459
yml配置文件 spring: kafka: bootstrap-servers: 118.25.59.00:9092 producer: # 发生错误后，消息重发的次数。 retries: 0 #当有多个消息需要被发送到同一个分区时，生产者会把它们放在同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算。 batch-size: 16384 # 设置生产者内存缓冲区的大小。 buffer-memor
kafka之操作示例
最新发布
鲸屿的博客
05-24 1178
# kafka-console-consumer.sh --bootstrap-server 192.168.71.113:9092 --topic test_topic --from-beginning可以收到消息。#5、创建Topic，分区为2，Topic name为'kafka_demo'#3、本地启动kafka(注意下述代码，将kafka启动在9092端口)#8、安装kafka-python。#2、本地启动zookeeper。#4、进入kafka bash。#6、查看当前所有topic。
Spring Boot整合Kafka
q1372302825的博客
03-01 3898
Kafka作为一款分布式流处理平台，具有高吞吐量、持久性、容错性等特点，适用于构建大规模的实时数据管道。Spring Boot作为快速开发框架，提供了简化开发和部署的能力，使得与Kafka的整合变得更加容易。通过将Spring Boot与Kafka进行整合，具有以下优势异步消息处理：Kafka可以作为消息队列，实现异步消息的生产和消费，提高系统的吞吐量和响应速度。解耦和扩展性：消息队列的引入可以解耦不同系统或模块之间的依赖关系，提高系统的灵活性和可维护性。数据流处理。
Linux 安装 kafka
qq_42923937的博客
03-04 6997
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考Kafka是由Apache软件基金会开发的一个开源流处理平台，由Scala和Java编写。Kafka是一种高吞吐量的分布式发布订阅消息系统，它可以处理消费者规模的网站中的所有动作流数据。这种动作（网页浏览，搜索和其他用户的行动）是在现代网络上的许多社会功能的一个关键因素。这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。
example-consumer-java-kafka:示例Java Kafka使用者
04-06
示例Java Kafka使用者 这是一个Java kafka使用者的示例，该使用者使用Pact， 和Travis CI来确保其与其使用者所期望的兼容。 该项目使用Makefile来模拟一个非常简单的构建管道，分为两个阶段-测试和部署。 请参阅...
Node.js Kafka 使用示例教程与实践
克隆仓库：需要使用git命令克隆Node.js Kafka示例仓库到本地计算机。 b. 配置brokers、clientId和topic：在producer.js和consumer.js文件中，需要根据Kafka集群在系统上的实际运行位置，配置Kafka代理的地址和端口...
KafkaDemo示例
09-29
**KafkaDemo示例详解** Kafka是一种分布式流处理平台，由LinkedIn开发并贡献给了Apache软件基金会，现在已经成为大数据领域中的重要组件。它主要用于构建实时数据管道和流应用，能够处理大量的实时数据。在这个名为...
kafka示例
02-22
入门 参考文件 有关更多参考，请考虑以下部分： 导游 以下指南说明了如何具体使用某些功能： 请按照以下步骤操作： 首先，您必须从官方网站下载Apache Kafka。 请注意！ 您必须下载它的二进制版本。 如果您的操作系统是Windows，请在config目录中更改server.properties文件。 找到logs.dir并使用log.dir = C：\ app \ kafka_2.11-2.4.0 \ kafka-logs进行更改注意！！！！ 当然可以更改您的kafka版本的路径 准备好您的本地Kafka之后。 您应该分别启动zookeeper，kafka服务器。 您应该打开Powershell。 您可以按Shift +右键单击kafka目录。 请打开4个不同的Powershell端子。 首先，我们必须启动Zookeeper。 。\ bin \ windows \
SpringBoot整合kafka
06-14
SpringBoot整合kafka代码，两个工程 一个消费者 一个生产者，利用定时任务。很简洁代码。欢迎大家下载哦。可参考这篇文章代码哦。https://blog.csdn.net/weixin_39984161/article/details/91986809
springboot集成kafka
m0_56088675的博客
02-11 496
如果需要发送复杂对象，可以自定义序列化器和反序列化器。
Spring Boot 整合 Kafka 详解
Java领域优秀创作者
08-05 2556
本文详细介绍了如何在 Spring Boot 项目中整合 Apache Kafka，包括 Kafka 的配置、消息的同步和异步发送。通过理解和实践这些内容，可以帮助你更好地掌握 Spring Boot 与 Kafka 的整合与应用。希望本文对你有所帮助，如有任何疑问或建议，欢迎留言讨论。
SpringBoot 集成 Kafka
weixin_46668257的博客
03-12 5192
Kafka 也是是我们在开发过程中经常会使用的一种消息队列Kafka的核心概念包括Producer、Consumer、Broker、Topic、Partition和Offset。Producer：生产者，负责将数据发送到Kafka集群。Consumer：消费者，从Kafka集群中读取数据。Broker：Kafka服务器实例，Kafka集群通常由多个Broker组成。Topic：主题，数据按主题进行分类。Partition：分区，每个主题可以有多个分区，用于实现并行处理和提高吞吐量。
kafka 在Linux上的安装部署
m0_56341622的博客
11-09 4254
通过以上步骤，我们在 Linux 系统上成功安装和部署了 Kafka。在实际应用中，可以根据具体的业务需求进一步配置和优化 Kafka，如设置更复杂的安全机制、调整性能参数等。希望本教程对大家有所帮助，让大家能够顺利开启 Kafka 之旅。
SpringBoot集成Kafka详解
热门推荐
qq_20865839的博客
10-20 1万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。其路由机制为：1.若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；
kafka使用示例
03-25
### Kafka 使用示例代码 以下是基于提供的引用内容以及专业知识整理的 Kafka 使用示例代码。 #### 1. Kafka Producer 示例 以下是一个简单的 Kafka Producer 实现，它会向指定主题 `my_topic` 发送一条消息 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@淡 定

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值