springboot集成kafka

最新推荐文章于 2024-06-02 19:29:15 发布
最新推荐文章于 2024-06-02 19:29:15 发布
阅读量665 收藏
点赞数 1
分类专栏： Java SpringBoot SpringCloud linux 文章标签： kafka spring boot java
如有问题，欢迎指正！
本文链接：https://blog.csdn.net/weixin_45247019/article/details/126555936
版权

docker-compose 安装

version: '3'
services:
  zookeeper:
    image: bitnami/zookeeper:3.8.0
    user: root
    container_name: zookeeper
    ports:
      - 2181:2181
    environment:
      # 时区
      - TZ=Asia/Shanghai
      # 允许匿名登录
      - ALLOW_ANONYMOUS_LOGIN=yes
      # zk在集群中的序号（1~255）
      - ZOO_SERVER_ID=1
      # 端口
      - ZOO_PORT_NUMBER=2181
    volumes:
      - ./zk:/bitnami/zookeeper
  kafka:
    image: bitnami/kafka:3.2.1
    user: root
    container_name: kafka
    ports:
      - 9092:9092
    environment:
      - TZ=Asia/Shanghai
      # broker id>=0
      - KAFKA_BROKER_ID=0
      # kk配置zk连接
      - KAFKA_CFG_ZOOKEEPER_CONNECT=192.168.56.100:2181
      # 允许使用PLAINTEXT协议
      - ALLOW_PLAINTEXT_LISTENER=yes
      # kk配置监听器
      - KAFKA_CFG_LISTENERS=PLAINTEXT://:9092
      # kk配置发布到zk的监听器
      - KAFKA_CFG_ADVERTISED_LISTENERS=PLAINTEXT://192.168.56.100:9092
    volumes:
      - ./kk/data:/bitnami/kafka/data
    depends_on:
      - zookeeper
  kafka-manager:
    image: sheepkiller/kafka-manager:stable
    container_name: kafka-manager
    ports:
      - 9000:9000
    environment:
      # zk地址
      - ZK_HOSTS=192.168.56.100:2181
      # 应用秘钥
      - APPLICATION_SECRET=km_secret
      # km用户名
      - KAFKA_MANAGER_USERNAME=kkm_user
      # km密码
      - KAFKA_MANAGER_PASSWORD=kkm_pwd
    depends_on:
      - kafka

使用

kafka Manager

在这里插入图片描述
填写信息
在这里插入图片描述
成功
在这里插入图片描述
go to cluster view

新建主题

在这里插入图片描述
在这里插入图片描述

查看kafka状态

查看topic情况

./bin/kafka-topics.sh --describe --bootstrap-server localhost:9092 --topic test

在这里插入图片描述

查看消息内容

./bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

在这里插入图片描述

查看消费情况

./bin/kafka-consumer-groups.sh --describe --bootstrap-server localhost:9092 --group zhTestGroup

在这里插入图片描述

SpringBoot整合

配置

在这里插入代码片
server:
  port: 8080

spring:
  application:
    name: kafka
  kafka:
    bootstrap-servers: 192.168.56.100:9092 # kafka集群信息
    producer: # 生产者配置
      retries: 3 # 设置大于0的值，则客户端会将发送失败的记录重新发送  # 重试次数
      batch-size: 16384 #16K
      buffer-memory: 33554432 #32M
      # 应答级别
      # acks=0 把消息发送到kafka就认为发送成功
      # acks=1 把消息发送到kafka leader分区，并且写入磁盘就认为发送成功
      # acks=all 把消息发送到kafka leader分区，并且leader分区的副本follower对消息进行了同步就任务发送成功
      acks: 1
      # 指定消息key和消息体的编解码方式
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
#      # 批量处理的最大大小 单位 byte
#      batch-size: 4096
#      # 发送延时,当生产端积累的消息达到batch-size或接收到消息linger.ms后,生产者就会将消息提交给kafka
#      buffer-memory: 33554432
#      # 客户端ID
#      client-id: hello-kafka
#      # 消息压缩：none、lz4、gzip、snappy，默认为 none。
#      compression-type: gzip


    consumer:
      group-id: zhTestGroup # 消费者组
      enable-auto-commit: false # 关闭自动提交
        # 当kafka中没有初始offset或offset超出范围时将自动重置offset
        # earliest:重置为分区中最小的offset
      # latest:重置为分区中最新的offset(消费分区中新产生的数据)
      # none:只要有一个分区不存在已提交的offset,就抛出异常
      auto-offset-reset: earliest # 当各分区下有已提交的offset时，从提交的offset开始消费；无提交的offset时，从头开始消费
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
#      # 自动提交的频率 单位 ms
#      auto-commit-interval: 1000
#      # 批量消费最大数量
#      max-poll-records: 100

    listener:
      # 当每一条记录被消费者监听器（ListenerConsumer）处理之后提交
      # RECORD
      # 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后提交
      # BATCH
      # 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
      # TIME
      # 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
      # COUNT
      # TIME |　COUNT　有一个条件满足时提交
      # COUNT_TIME
      # 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
      # MANUAL
      # 手动调用Acknowledgment.acknowledge()后立即提交，一般使用这种
      # MANUAL_IMMEDIATE
      ack-mode: manual_immediate

生产者

package com.jhj.kafka.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.kafka.core.KafkaOperations;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.KafkaHeaders;
import org.springframework.kafka.support.SendResult;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Service;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;

import javax.annotation.Resource;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

/**
 * kafka 生产服务
 *
 * @author Leo
 * @create 2020/12/31 16:06
 **/
@Slf4j
@Service
public class KafkaProducerService {
    @Resource
    private KafkaTemplate<String, String> kafkaTemplate;

    @Resource
    private KafkaTemplate<String, String> kafkaTemplateWithTransaction;

    /**
     * 发送消息（同步）
     * @param topic 主题
     * @param key 键
     * @param message 值
     */
    public void sendMessageSync(String topic, String key, String message) throws InterruptedException, ExecutionException, TimeoutException {
        //可以指定最长等待时间，也可以不指定
        kafkaTemplate.send(topic, message).get(10, TimeUnit.SECONDS);
        log.info("sendMessageSync => topic: {}, key: {}, message: {}", topic, key, message);
        //指定key，kafka根据key进行hash，决定存入哪个partition
//        kafkaTemplate.send(topic, key, message).get(10, TimeUnit.SECONDS);
        //存入指定partition
//        kafkaTemplate.send(topic, 0, key, message).get(10, TimeUnit.SECONDS);
    }

    /**
     * 发送消息并获取结果
     * @param topic
     * @param message
     * @throws ExecutionException
     * @throws InterruptedException
     */
    public void sendMessageGetResult(String topic, String key, String message) throws ExecutionException, InterruptedException {
        SendResult<String, String> result = kafkaTemplate.send(topic, message).get();
        log.info("sendMessageSync => topic: {}, key: {}, message: {}", topic, key, message);
        log.info("The partition the message was sent to: " + result.getRecordMetadata().partition());
    }

    /**
     * 发送消息（异步）
     * @param topic 主题
     * @param message 消息内容
     */
    public void sendMessageAsync(String topic, String message) {
        ListenableFuture<SendResult<String, String>> future = kafkaTemplate.send(topic, message);
        //添加回调
        future.addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                log.error("sendMessageAsync failure! topic : {}, message: {}", topic, message);
            }

            @Override
            public void onSuccess(SendResult<String, String> stringStringSendResult) {
                log.info("sendMessageAsync success! topic: {}, message: {}", topic, message);
            }
        });
    }

    /**
     * 可以将消息组装成 Message 对象和 ProducerRecord 对象发送
     * @param topic
     * @param key
     * @param message
     * @throws InterruptedException
     * @throws ExecutionException
     * @throws TimeoutException
     */
    public void testMessageBuilder(String topic, String key, String message) throws InterruptedException, ExecutionException, TimeoutException {
        // 组装消息
        Message msg = MessageBuilder.withPayload(message)
                .setHeader(KafkaHeaders.MESSAGE_KEY, key)
                .setHeader(KafkaHeaders.TOPIC, topic)
                .setHeader(KafkaHeaders.PREFIX,"kafka_")
                .build();
        //同步发送
        kafkaTemplate.send(msg).get();
        // 组装消息
//        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(topic, message);
//        kafkaTemplate.send(producerRecord).get(10, TimeUnit.SECONDS);
    }

    /**
     * 以事务方式发送消息
     * @param topic
     * @param key
     * @param message
     */
    public void sendMessageInTransaction(String topic, String key, String message) {
        kafkaTemplateWithTransaction.executeInTransaction(new KafkaOperations.OperationsCallback<String, String, Object>() {
            @Override
            public Object doInOperations(KafkaOperations<String, String> kafkaOperations) {
                kafkaOperations.send(topic, key, message);
                //出现异常将会中断事务，消息不会发送出去
                throw new RuntimeException("12");
            }
        });
    }

}

消费者

package com.jhj.kafka.service;

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.Service;

import java.util.List;

/**
 * kafka 消费服务
 *
 * @author Leo
 * @create 2020/12/31 16:06
 **/
@Slf4j
@Service
public class KafkaConsumerService {

    /**
     * 消费单条消息,topics 可以监听多个topic，如：topics = {"topic1", "topic2"}
     * @param message 消息
     */
    @KafkaListener(id = "consumerSingle", topics = "kafka-test-topic")
    public void consumerSingle(String message,Acknowledgment ack) {
        log.info("consumerSingle ====> message: {}", message);
        ack.acknowledge();
    }


/*    @KafkaListener(id = "consumerBatch", topicPartitions = {
            @TopicPartition(topic = "hello-batch1", partitions = "0"),
            @TopicPartition(topic = "hello-batch2", partitionOffsets = @PartitionOffset(partition = "2", initialOffset = "4"))
    })*/
    /**
     * 批量消费消息
     * @param messages
     */
    @KafkaListener(id = "consumerBatch", topics = "test-batch")
    public void consumerBatch(List<ConsumerRecord<String, String>> messages) {
        log.info("consumerBatch =====> messageSize: {}", messages.size());
        log.info(messages.toString());
    }

    /**
     * 指定消费异常处理器
     * @param message
     */
    @KafkaListener(id = "consumerException", topics = "kafka-test-topic", errorHandler = "consumerAwareListenerErrorHandler")
    public void consumerException(String message) {
        throw new RuntimeException("consumer exception");
    }

    /**
     * 验证ConsumerInterceptor
     * @param message
     */
    @KafkaListener(id = "interceptor", topics = "consumer-interceptor")
    public void consumerInterceptor(String message) {
        log.info("consumerInterceptor ====> message: {}", message);
    }



    //kafka的监听器，topic为"zhTest"，消费者组为"zhTestGroup"
    @KafkaListener(topics = "test", groupId = "zhTestGroup")
    public void listenZhugeGroup(ConsumerRecord<String, String> record, Acknowledgment ack) {
        String value = record.value();
        System.out.println(value);
        System.out.println(record);
        //手动提交offset
        ack.acknowledge();
    }
}

测试项目

https://gitee.com/jhj159/kafka.git

作者声明

如有问题，欢迎指正！
努力学习，努力爱你！
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
SpringBoot集成kafka全面实战
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
SpringBoot集成Kafka
禅与计算机程序设计艺术
01-28 984
1.背景介绍 1. 背景介绍 Apache Kafka 是一个分布式流处理平台，用于构建实时数据流管道和流处理应用程序。它允许在大规模和高吞吐量的系统中构建实时数据流管道，并为流处理应用程序提供一种可扩展的基础设施。Spring Boot 是一个用于构建新 Spring 应用程序的快速开始模板，它简化了配置，提供了一些基本的自动配置，并且可以与 Kafka 集成。 在本文中，我们将讨论如何将...
Springboot整合kafka简单使用
最新发布
m0_56353506的博客
06-02 1452
Kafka 是一个开源的分布式流处理平台，最初由 LinkedIn 开发并贡献给 Apache 软件基金会。它设计用于构建高性能、持久性、可伸缩和容错的实时数据管道和流处理应用程序。发布-订阅模型：Kafka 使用发布-订阅模型，其中消息生产者将消息发布到主题（topic），而消息消费者从主题订阅消息。这种模型可以支持多个消费者同时消费消息，并且具有良好的扩展性。主题（Topic）：主题是消息的逻辑分类，相当于一个消息队列。消息被发布到主题，并且消费者从主题订阅消息。分区（Partition）
SpringBoot整合Kafka
ITBOY_ITBOX博客
10-11 965
使用注解@KafkaListener定义当前方法监听Kafka中指定topic的消息，接收到的消息封装在对象ConsumerRecord中，获取数据从ConsumerRecord对象中获取即可。运行bin目录下的windows目录下的kafka-server-start命令即可启动kafka服务器，默认对外服务端口9092。Kafka提供有一套测试服务器功能的测试程序，运行bin目录下的windows目录下的命令即可使用。：使用消息监听器在服务器启动后，监听指定位置，当消息出现后，立即消费消息。
SpringBoot集成kafka
weixin_50143345的博客
08-07 719
新建一个 ConsumerAwareListenerErrorHandler 类型的异常处理方法，用@Bean注入，BeanName默认就是方法名，然后我们将这个异常处理器的BeanName放到@KafkaListener注解的errorHandler属性里面，当监听抛出异常的时候，则会自动调用异常处理器，在实际开发中，我们可能有这样的需求，应用A从TopicA获取到消息，经过处理后转发到TopicB，再由应用B监听处理消息，即一个应用处理完成后将该消息转发至其他应用，完成消息的转发。
springboot集成kafka实战项目，kafka生产者、消费者、创建topic，指定消费分区
01-04
通过以上步骤，我们就完成了Spring Boot集成Kafka的实战项目，包括生产者、消费者的实现，以及Topic的创建和指定消费分区。这个项目可以帮助开发者更好地理解和应用Kafka在实际业务场景中的用法，提升消息传递的效率...
springboot集成kafka推送的简单例子
06-05
通过这个简单的例子，你已经掌握了如何在SpringBoot应用中集成Kafka进行消息推送的基本流程。随着对Spring和Kafka的进一步了解，你可以实现更复杂的功能，比如消息分组、幂等性消费、事务支持等。这只是一个起点，但...
SpringBoot集成kafkaDemo
10-20
以上是SpringBoot集成Kafka的基础步骤。在实际应用中，你可能还需要考虑更多的高级特性，比如错误处理、幂等性、事务支持、消费者分组和偏移管理等。Kafka还提供了丰富的API和工具，可以满足复杂的流处理需求，如...
Springboot集成Kafka实现producer和consumer的示例代码
08-27
Spring Boot 集成 Kafka 可以帮助开发者轻松地在应用程序中实现消息生产和消费功能，利用 Kafka 的高性能和可扩展性。Kafka 是一个分布式流处理平台，它最初由 LinkedIn 开发，后来成为 Apache 软件基金会的顶级项目...
springBoot整合kafka和elasticSearch,实现批量拉取日志以及批量更新到es里
01-15
从Kafka中批量拉去数据，然后批量更新到es里。一次拉取的数量可以设置，现在是10000，轻松运转，更新到es内部也是，目标是百万日志秒处理
SpringBoot----日志框架和配置，kafka视频分析
m0_64867092的博客
12-10 1259
如何让系统中所有日志统一使用slf4j 将系统中其他的日志框架先排除出去 用中间包替换原有的日志框架 我们导入slf4j其他的实现 SpringBoot日志关系 ============================================================================= ![在这里插入图片描述](https://img-blog.csdnimg.cn/e41ba67a68be497791c0c4b7f224d4ab.png?x-oss-p.
Springboot使用kafka(配置篇yml)
热门推荐
weixin_39766667的博客
01-04 1万+
springboot 配置kafak的生产者，消费者，监听器
kafka 集成SpringBoot
m0_56017821的博客
09-25 1181
kafka 2.8.0后新特性kraft模式 kafka集成springboot
Kafka与Spring Boot等应用框架的集成及消息驱动模型
隐风的博客
10-19 1606
在本文中，我们深入探讨了Kafka与Spring Boot等应用框架的集成方式以及Kafka支持的消息驱动模型。在集成方面，我们介绍了如何在Spring Boot项目中添加Kafka依赖，并配置了相应的属性以实现应用程序与Kafka集群的通信。然后，我们详细讲解了几种常见的消息驱动模型，包括发布-订阅模型、请求-响应模型和流处理模型。通过使用Kafka Streams API，我们可以轻松实现这些模型并处理大规模的实时数据流。
Spring整合Kafka
weixin_45809829的博客
05-29 2765
Spring整合Kafka 采用Kafaka技术进行系统消息的发送，提高系统的性能 1、阻塞队列的使用 Kafaka也好还是其他的消息中间件也好都是框架，如果不使用这些框架使用BlockingQueue也可以解决消息系统的开发 理解阻塞队列对理解Kafaka很有帮助 BlockingQueue 解决线程通信的问题 阻塞的方法有put、take 生产的数据放在队列当中，当队列满的时候生产者线程就被阻塞住(什么都不做，不会消耗资源)，等待消费者线程进行消费 消费线程从队列当中拿数据进
spring-kafka整合
qq_34810124的博客
10-19 9942
springboot-kafka
springboot 集成 Kafka
11-07
SpringBoot集成Kafka可以通过引入spring-kafka依赖来实现。在yaml配置文件中配置Kafka的相关信息，然后使用@KafkaListener注解来注入消费者即可。如果一个主题要被多个消费组消费，可以配置多个消费组。在消费者中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值