Kafka： ------ Spring Boot整合Kafka 、接受数据、发送数据

最新推荐文章于 2024-09-16 11:17:20 发布
最新推荐文章于 2024-09-16 11:17:20 发布
阅读量2.8k 收藏 8
点赞数
分类专栏： Kafka 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45764675/article/details/105520527
版权

- 引入依赖

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>2.1.5.RELEASE</version>
</parent>
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.kafka</groupId>
    <artifactId>spring-kafka</artifactId>
  </dependency>
  <dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-streams</artifactId>
    <version>2.0.1</version>
  </dependency>
  <!--测试-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>

接受数据

application.properties

spring.kafka.bootstrap-servers=Centos:9092

spring.kafka.producer.retries=5
spring.kafka.producer.acks=all
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=33554432
spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer
spring.kafka.producer.properties.enable.idempotence=true
spring.kafka.producer.transaction-id-prefix=transaction-id-

spring.kafka.consumer.group-id=group1
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.enable-auto-commit=true
spring.kafka.consumer.auto-commit-interval=100
spring.kafka.consumer.properties.isolation.level=read_committed
spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer
spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer

KafkaApplicationDemo 类

package com.baizhi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KafkaApplicationDemo {
    public static void main(String[] args) {
        SpringApplication.run(KafkaApplicationDemo.class,args);
    }
}

KafkaListenerComponent 类

package com.baizhi;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.KafkaListeners;
import org.springframework.stereotype.Component;
@Component
public class KafkaListenerComponent {
    @KafkaListeners(value = {@KafkaListener(topicPattern = "topic.*")})
    public void reciveRecored(ConsumerRecord<String,String> record){
        System.out.println(record.value());
    }
}

往topic中写入数据即可以得到 如下所示:

生产者类写入topic01数据

package com.baizhi.jsy.kafkaapi;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.text.DecimalFormat;
import java.util.Properties;
public class ProductKafka {
    public static void main(String[] args) {
        //创建生产者
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"Centos:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        //优化参数
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG,1024*1024);//生产者尝试缓存记录，为每一个分区缓存一个mb的数据
        properties.put(ProducerConfig.LINGER_MS_CONFIG,500);//最多等待0.5秒.
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        for(int i=0;i<10;i++){
            DecimalFormat decimalFormat = new DecimalFormat("00");
            String format = decimalFormat.format(i);
            ProducerRecord<String, String> record = new ProducerRecord<>("topic01", "key" + format, "value" + format);
            kafkaProducer.send(record);
        }
        kafkaProducer.flush();
        kafkaProducer.close();
    }
}

在这里插入图片描述

发送数据

案例是从topic01读取数据发送到topic03

  • 入口类
package com.baizhi;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class KafkaApplicationDemo {
    public static void main(String[] args) {
        SpringApplication.run(KafkaApplicationDemo.class,args);
    }
}
  • 读取topic01类

从topic01读取数据，然后调用写好的业务方法 将读取的数据作为参数传送给业务成方法

package com.baizhi;
import com.baizhi.service.IOrderService;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.KafkaListeners;
import org.springframework.stereotype.Component;
@Component
public class KafkaListenerComponent {
    @Autowired
    IOrderService iOrderService;
    @KafkaListeners(value = {@KafkaListener(topicPattern = "topic01")})
    public void reciveRecored(ConsumerRecord<String,String> record){
        //System.out.println(record.value());
         iOrderService.saveOrder(record.key(),record.value()+"JiangSi Yu");
    }
}
  • 业务接口

参数是topic的键和值

package com.baizhi.service;
public interface IOrderService {
    public void saveOrder(String id,Object message);
}
  • 业务实现类

是将数据写入topic03的类 topic01数据作为参数传过来的

package com.baizhi.service.impl;
import com.baizhi.service.IOrderService;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
@Transactional
public class OrderService implements IOrderService {
    @Autowired
    private KafkaTemplate kafkaTemplate;

    @Override
    public void saveOrder(String id, Object message) {
        //做一些业务的处理 发送出去
        kafkaTemplate.send(new ProducerRecord("topic03",id,message));
    }
}

发送给topic数据的类 如下

package com.baizhi.jsy.transaction;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.errors.ProducerFencedException;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.UUID;
public class ProductKafkaTransactionnOnly {
    public static void main(String[] args) {
        //创建生产者
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "Centos:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //优化参数
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 1024 * 1024);//生产者尝试缓存记录，为每一个分区缓存一个mb的数据
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 500);//最多等待0.5秒.
        //开启幂等性 acks必须是-1
        properties.put(ProducerConfig.ACKS_CONFIG,"-1");
        //允许超时最大时间
        properties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,5000);
        //失败尝试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        //开幂等性  精准一次写入
        properties.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);
        //开启事务
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id"+ UUID.randomUUID());
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //初始化事务
        kafkaProducer.initTransactions();
        try {
            //开启事务
            kafkaProducer.beginTransaction();
            for (int i=0;i<5;i++){
                ProducerRecord<String, String> record = new ProducerRecord<>(
                        "topic01",
                        "Transaction",
                        "Test springboot 发送数据");
                kafkaProducer.send(record);
                kafkaProducer.flush();
                if (i==3){
                    //Integer b=i/0;//写错
                }
            }
            //事务提交
            kafkaProducer.commitTransaction();
        } catch (ProducerFencedException e) {
            //终止事务
            kafkaProducer.abortTransaction();
            e.printStackTrace();
        }

        kafkaProducer.close();
    }
}

创建topic03

在这里插入图片描述

读取topic03结果

在这里插入图片描述

可以直接将读取的数据返回给其他的topic （return 即可）

适用于不想对数据进行额外处理的业务场景 直接将数据发送给某个队列

从topic02中读取数据 到topic03中

package com.baizhi;
import com.baizhi.service.IOrderService;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.annotation.KafkaListeners;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Component;
@Component
public class KafkaListenerComponent {
    @Autowired
    IOrderService iOrderService;
    @KafkaListeners(value = {@KafkaListener(topicPattern = "topic01")})
    public void reciveRecored(ConsumerRecord<String,String> record){
        //System.out.println(record.value());
         iOrderService.saveOrder(record.key(),record.value()+"JiangSi Yu");
    }

    @KafkaListeners(value = {@KafkaListener(topicPattern = "topic02")})
    @SendTo("topic03")
    public String reciveRecored002(ConsumerRecord<String,String> record){
         return record.key()+"\tfrom  topic02 to topic03\t"+record.value();
    }
}

传数据到topic02中

package com.baizhi.jsy.transaction;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.errors.ProducerFencedException;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.UUID;

public class ProductKafkaTransactionnOnly {
    public static void main(String[] args) {
        //创建生产者
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "Centos:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //优化参数
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 1024 * 1024);//生产者尝试缓存记录，为每一个分区缓存一个mb的数据
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 500);//最多等待0.5秒.

        //开启幂等性 acks必须是-1
        properties.put(ProducerConfig.ACKS_CONFIG,"-1");
        //允许超时最大时间
        properties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,5000);
        //失败尝试次数
        properties.put(ProducerConfig.RETRIES_CONFIG,3);
        //开幂等性  精准一次写入
        properties.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG,true);

        //开启事务
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,"transaction-id"+ UUID.randomUUID());

        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        //初始化事务
        kafkaProducer.initTransactions();


        try {
            //开启事务
            kafkaProducer.beginTransaction();
            for (int i=0;i<5;i++){
                ProducerRecord<String, String> record = new ProducerRecord<>(
                        "topic02",
                        "Transaction",
                        "Test springboot 发送数据");
                kafkaProducer.send(record);
                kafkaProducer.flush();
                if (i==3){
                    //Integer b=i/0;//写错
                }
            }
            //事务提交
            kafkaProducer.commitTransaction();
        } catch (ProducerFencedException e) {
            //终止事务
            kafkaProducer.abortTransaction();
            e.printStackTrace();
        }

        kafkaProducer.close();
    }
}

发送数据结果如下

在这里插入图片描述

姜同学的学习笔记
关注
专栏目录
使用Kafka读取最新数据
CvhShell的博客
09-26 451
在实时数据处理中，经常需要从Kafka中读取最新的数据，以便进行后续的处理和分析。本文将介绍如何使用Kafka消费者API从Kafka集群中读取最新的数据，并提供相应的源代码示例。请注意，上述代码只是一个简单的示例，仅展示了从Kafka中读取最新数据的基本原理。总结起来，通过使用Kafka消费者API和适当的Kafka客户端库，我们可以轻松地从Kafka集群中读取最新的数据。然后，我们定义了Kafka集群的地址和要消费的主题名称。方法将消费者的偏移量设置为最新的位置，以便从最新的数据开始消费。
spring-boot-kafka:Spring Boot Kafka示例代码
05-02
带Kafka的样本Spring Boot 公开了一个使用json消息并发布到kafka主题中的api 要通过泊坞窗启动zookeeper和kafka，请执行以下操作： docker-compose up 生成应用程序映像 docker build --no-cache -t sample_kafka:0.0.1 . -f docker\Dockerfile 创建主题： bin/kafka-topics.sh --create --zookeeper zookeeper:2181 --replication-factor 1 --partitions 1 --topic test 要开始制作，请执行以下操作： bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test 要启动消费者： bin
Springboot集成kafka,程序重启后,让消费者跳过历史数据，只消费新产生的数据
CLanMua的博客
11-17 1888
于是研究了一番，最简单的办法是使用动态不重复的group ID，这样每次启动Kafka client在zookeeper找不到偏移量就会应用auto-offset-reset策略，如果是latest（默认）就会从最新的偏移量开始消费。项目中使用的数据不是那么重要，而数据又是生产者实时发送的，所以希望消费者重启之后，跳过历史数据，只接收并处理生产者新发送的数据。也就是说@KafkaListener参数里的groupId，在每次启动时，如果都是动态不重复的随机数，那么就会跳过历史数据，只接收新数据。
SpringBoot Kafka发送消息与接收消息实例
最新发布
wodetongnian的专栏
09-16 782
SpringBoot Kafka发送消息与接收消息
Spring Boot 中使用@KafkaListener并发批量接收消息
热门推荐
russle的专栏
07-28 13万+
kakfa是 我们在项目开发中经常使用的消息中间件。由于它的写性能非常高，因此，经常会碰到Kafka消息队列拥堵的情况。碰到这种情况时，有不能直接清理整改消息队列，因为还有别的服务正在使用该队列。因此只能额外启动一个相同名称的consumer-group来加快消息消费（经测试，如果该topic只有一个分区，实际上再启动一个新的消费者作用不到）。 具体代码在这里，欢迎加星号，fork。 官方文档......
SpringBoot通过kafka实现消息发送与接收（包括不能发送和消费kafka消息的采坑记录）
专注基础架构领域
08-31 8598
kafka采坑记录： 1、kafka服务端server.properties中的broker.id集群内需要唯一。 2、kafka config文件中listeners和advertised.listeners需要配置本机ip:9092地址，不然消费不到数据。（如:192.168.217.128:9092） 3、java代码客户端版本号需要与服务端版本号一一对应，不然...
springboot实现读kafka数据写入文件并按指定行数分割文件
zwahut的专栏
02-28 1208
1、需求描述 大致需求是这样的，kafka作为数据缓存通道，接收前端设备上传的数据，现在需要实现读取kafka的数据，再保存到文件，但是不能全部写入一个文件，会导致一个文件过大，需要按照指定行数分割文件，按行数是为了方便核对数据量，前端上传了多少数据，kafka接收了多少数据，最终写入文件多少数据。 另外需要说明传入的数据是一个复杂的json字符串，嵌套了很多内容，而且还有图片的base64字...
spring整合kafka项目生产和消费测试结果记录（一）
weixin_33862188的博客
03-19 189
使用spring+springMVC+mybatis+kafka做了两个web项目，一个是生产者，一个是消费者。 通过JMeter测试工具模拟100个用户并发访问生产者项目，发送json数据给生产者的接口，生产者将json数据发送到kafka集群， 消费者监听到kafka集群中的消息就开始消费，并将json解析成对象存到MySQL数据库。 下面是使用JMeter测试工具模拟100个并发的线程设置截...
springboot整合Kafka 推送消息
qq_14927159的博客
04-18 424
springboot整合Kafka 推送消息。
springboot+kafka实现简单的消息推送
oneTreeTallTall
04-19 3693
1springboot中文件配置 #kafka服务所在IP 可以是多个，用逗号隔开 spring.kafka.bootstrap-servers=192.168.1.26:9092 #分组设置 需在本机hosts文件中映射 spring.kafka.consumer.group-id=kafka-1 spring.kafka.consumer.auto-offset-reset=earlie...
spring boot整合spring-kafka实现发送接收消息实例代码
08-30
主要给大家介绍了关于spring-boot整合spring-kafka实现发送接收消息的相关资料，文中介绍的非常详细，对大家具有一定的参考学习价值，需要的朋友们下面跟着小编一起来看看吧。
spring-boot-starter-kafka示例程序
03-04
spring-boot-starter-kafka示例程序\n 支持springcloud1.5.4，kafka0.8.2.x\n 项目地址：https://github.com/zhyea/spring-boot-starter-kafka
kafka-spring-boot-example：Spring Boot应用程序显示与Kafka一起使用的基本配置
01-30
Spring Boot Kafka示例-实际开发人员 基本配置 该示例应用程序演示如何使用基本的Spring Boot配置将生产者设置为具有多个分区的主题以及具有三个不同使用者的使用者组。 完整的解释在The Practical Developer网站上...
spring-reactive-kafka-sse:通过Spring Boot Reactive + Kafka +服务器发送事件+ Cassandra进行流式传输
04-30
带有Spring Boot Reactive + Kafka +服务器已发送事件+ Cassandra的流。 使用服务器发送事件和Kafka的HTTP流，通过Spring Boot Reactive和Reactor Kafka实现。 此外，还使用Spring Data将数据存储在Cassandra中。 ...
spring-boot-kafka-consumer-example:Spring Boot Kafka使用者示例
05-18
带有Kafka Consumer实例的Spring Boot 本项目介绍如何将Spring Boot与Spring Kafka结合使用以使用Kafka主题中的JSON / String消息 启动Zookeeper bin/zookeeper-server-start.sh config/zookeeper.properties 启动...
Kafka连接器建立数据管道
csdn_manong1的博客
10-18 219
Kafka 连接器可以从DB存储或应用程序服务器收集数据到Topic，使数据可用于低延迟的流处理。导出作业可以将数据从Topic传输到二次存储和查询系统，或者传递到批处理系统以便进行离线分析。
第三集 Spring for Apache Kafka 接受消息
极客星云-CSDN博客
03-31 5790
我们可以接受消息通过配置一个MessageListenerContainer 和提供一个消息监听或者通过使用@KafkaListener 注解 3.1 Message Listeners 当我们使用一个消息监听容器的时候，我们必须提供一个监听来接受数据。 当前有八种支持消息监听的接口，以下是这些接口列表： public interface MessageListener<K, V> {...
springboot整合kafka
weixin_43810802的博客
04-20 577
kafka是一个流式平台，官方的定义是： A streaming platform has three key capabilities: 1，Publish and subscribe to streams of records, similar to a message queue or enterprise messaging system. 2，Store streams of reco...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值