Kafka——SpringBoot整合（生产者）

最新推荐文章于 2024-06-18 22:19:56 发布
最新推荐文章于 2024-06-18 22:19:56 发布
阅读量379 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38170523/article/details/104854243
版权

目录

生产者根据不同的业户需求和性能需求，选择合适的发送方式，可以达到最大效率。
具体选择哪一种发送方式，要考虑实际的业务场景。
简单来说：
1、保存用户点击情况、不重要的日志分析等大频率储存，但不担心丢失的情况下使用异步发送
2、订单、支付信息，信息量不一定很多，但是非常重要，就需要采取同步发送或者异步带回调发送，对发送结果进行必要处理。

pom

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-streams</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka-test</artifactId>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.2</version>
        </dependency>

生产者配置文件

这里也可以在application.xxx进行参数配置，不过使用java配置文件的方式使配置更加直观，建议使用java配置
具体的参数配置可以查看以前的博客文章kafka生产者参数配置。https://www.cnblogs.com/luckyhui28/p/12001798.html

application.properties

# 指定kafka 代理地址，可以多个
kafka.bootstrap-servers=192.168.32.11:9092

javaConfig

@Configuration
public class KafkaProducerConfig {
    @Value("${kafka.bootstrap-servers}")
    private String bootstrapServers;

    /**
     * 生产者配置
     * @return
     */
    private Map<String, Object> configs() {
        Map<String, Object> props = new HashMap<>();
        // 连接地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 键的序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 重试，0为不启用重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, 1);
        // 控制批处理大小，单位为字节
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 1024000);
        return props;
    }


    @Bean
    public ProducerFactory<String, String> producerFactory() {
        DefaultKafkaProducerFactory factory = new DefaultKafkaProducerFactory<>(configs());
        return factory;
    }
    @Primary
    @Bean("producertemplate")
    public KafkaTemplate<String, String> producertemplate() {
        KafkaTemplate template = new KafkaTemplate<String, String>(producerFactory());
        return template;
    }

}

事务性javaConfig配置

@Configuration
public class KafkaTransactionalProducerConfig {

    @Value("${kafka.bootstrap-servers}")
    private String bootstrapServers;


    /**
     * 生产者配置
     * @return
     */
    private Map<String, Object> configs() {
        Map<String, Object> props = new HashMap<>();
        // 连接地址
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        // 键的序列化方式
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 值的序列化方式
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        // 重试，0为不启用重试机制
        props.put(ProducerConfig.RETRIES_CONFIG, 1);
        // 控制批处理大小，单位为字节
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 批量发送，延迟为1毫秒，启用该功能能有效减少生产者发送消息次数，从而提高并发量
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // 生产者可以使用的总内存字节来缓冲等待发送到服务器的记录
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 1024000);
        return props;
    }



    @Bean
    public ProducerFactory<String, String> transactionalProducerFactory() {
        DefaultKafkaProducerFactory factory = new DefaultKafkaProducerFactory<>(configs());
        // 开启事务
        factory.transactionCapable();
        // 用来生成Transactional.id的前缀
        factory.setTransactionIdPrefix("tran-");
        return factory;
    }


    /**
     * 事务管理器
     * @param transactionalProducerFactory
     * @return
     */
    @Bean
    public KafkaTransactionManager transactionManager(ProducerFactory transactionalProducerFactory) {
        KafkaTransactionManager manager = new KafkaTransactionManager(transactionalProducerFactory);
        return manager;
    }

    @Bean("transactionalTemplate")
    public KafkaTemplate<String, String> transactionalTemplate() {
        KafkaTemplate template = new KafkaTemplate<String, String>(transactionalProducerFactory());
        return template;
    }
}

Controller

@Controller
public class KafkaTestController {

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

    @Autowired
    @Qualifier("producertemplate")
    private KafkaTemplate<String, String> producertemplate;

    @Autowired
    @Qualifier("transactionalTemplate")
    private KafkaTemplate<String, String> transactionalTemplate;

    private Gson gson = new GsonBuilder().create();
}

异步不回调发送方式

发送既忘，只管消息发送，不论结果。多使用不重要的业务信息

    @RequestMapping("/testSendMsg1")
    @ResponseBody
    public String testSendMsg1(){ //发送既忘方式发送消息，在发送消息后并不关心消息是否正确到达。这种方法方式的性能最高，可靠性最差。
        Message message = new Message();
        message.setId(1);
        message.setMsg("testSendMsg1");
        message.setSendTime(new Date());
        logger.info("发送消息(发送既忘) ----->>>>>  message = {}", gson.toJson(message));
        producertemplate.send("hello", gson.toJson(message));
        return "testSendMsg1";
    }

异步带回调信息

带有回调结果，根据发送结果进行后期处理

    @RequestMapping("/testSendMsg3")
    @ResponseBody
    public String testSendMsg3(){ //异步发送，异步发送一般是在sned（）方法里指定一个CallBack的回调函数，Kafka在返回响应时调用该函数来实现异步的发送确认。
        Message message = new Message();
        message.setId(1);
        message.setMsg("testSendMsg1");
        message.setSendTime(new Date());
        logger.info("发送消息(异步发送) ----->>>>>  message = {}", gson.toJson(message));
        producertemplate.send("hello", gson.toJson(message)).addCallback(new ListenableFutureCallback<SendResult<String, String>>() {
            @Override
            public void onFailure(Throwable throwable) {
                logger.error("发送发生错误：" + throwable.getMessage());
            }

            @Override
            public void onSuccess(SendResult<String, String> stringStringSendResult) {
                logger.info("消息发送成功");
                //生产者发送的元数据信息
                ProducerRecord<String, String> producerRecord = stringStringSendResult.getProducerRecord();
                logger.info("生产者发送元信息 ：" );
                String topic = producerRecord.topic();
                logger.info("主题 ：" + topic );
                String value = producerRecord.value();
                logger.info("信息 ：" + value );
                Integer partition = producerRecord.partition();
                logger.info("分区 ：" + partition );
                String key = producerRecord.key();
                logger.info("键 ：" + key );
                Long timestamp = producerRecord.timestamp();
                logger.info("时间戳 ：" + timestamp );
                //返回结果元信息
                RecordMetadata recordMetadata = stringStringSendResult.getRecordMetadata();
                logger.info("生产者返回结果元信息 ：" );
                String topic1 = recordMetadata.topic();
                logger.info("主题 ：" + topic1 );
                int partition1 = recordMetadata.partition();
                logger.info("分区 ：" + partition1 );
                long offset = recordMetadata.offset();
                logger.info("位移 ：" + offset );
                boolean b = recordMetadata.hasOffset();
                logger.info("是否返回位移信息 ：" + b );
                long timestamp1 = recordMetadata.timestamp();
                logger.info("时间戳 ：" + timestamp1 );
                boolean b1 = recordMetadata.hasTimestamp();
                logger.info("是否返回时间戳 ：" + b1 );
                int i = recordMetadata.serializedKeySize();
                logger.info("序列化后键大小 ：" + i );
                int i1 = recordMetadata.serializedValueSize();
                logger.info("序列化后值大小 ：" + i1 );
            }
        });
        return "testSendMsg3";
    }

同步发送

阻塞式，同步发送方式发送消息，利用返回的Fature对象实现。

    @RequestMapping("/testSendMsg2")
    @ResponseBody
    public String testSendMsg2(){ //同步发送方式发送消息，利用返回的Fature对象实现。。
        Message message = new Message();
        message.setId(1);
        message.setMsg("testSendMsg2");
        message.setSendTime(new Date());
        logger.info("发送消息(同步发送) ----->>>>>  message = {}", gson.toJson(message));

        SendResult<String, String> sendResult = null;
        try {
            sendResult = producertemplate.send("hello", gson.toJson(message)).get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }


        //生产者发送的元数据信息
        ProducerRecord<String, String> producerRecord = sendResult.getProducerRecord();
        logger.info("生产者发送元信息 ：" );
        String topic = producerRecord.topic();
        logger.info("主题 ：" + topic );
        String value = producerRecord.value();
        logger.info("信息 ：" + value );
        Integer partition = producerRecord.partition();
        logger.info("分区 ：" + partition );
        String key = producerRecord.key();
        logger.info("键 ：" + key );
        Long timestamp = producerRecord.timestamp();
        logger.info("时间戳 ：" + timestamp );



        //返回结果元信息
        RecordMetadata recordMetadata = sendResult.getRecordMetadata();
        logger.info("生产者返回结果元信息 ：" );
        String topic1 = recordMetadata.topic();
        logger.info("主题 ：" + topic1 );
        int partition1 = recordMetadata.partition();
        logger.info("分区 ：" + partition1 );
        long offset = recordMetadata.offset();
        logger.info("位移 ：" + offset );
        boolean b = recordMetadata.hasOffset();
        logger.info("是否返回位移信息 ：" + b );
        long timestamp1 = recordMetadata.timestamp();
        logger.info("时间戳 ：" + timestamp1 );
        boolean b1 = recordMetadata.hasTimestamp();
        logger.info("是否返回时间戳 ：" + b1 );
        int i = recordMetadata.serializedKeySize();
        logger.info("序列化后键大小 ：" + i );
        int i1 = recordMetadata.serializedValueSize();
        logger.info("序列化后值大小 ：" + i1 );


        return "testSendMsg2";
    }

事务式发送

多用于发送多条信息，若有异常全部失败

    @RequestMapping("/testSendMsg4")
    @ResponseBody
    @Transactional
    public String testSendMsg5(){ //事务发送
        Message message = new Message();
        message.setId(1);
        message.setMsg("testSendMsg4");
        message.setSendTime(new Date());
        logger.info("发送消息(事务发送) ----->>>>>  message = {}", gson.toJson(message));
        
        transactionalTemplate.send("hello", gson.toJson(message));

        int i = 1/0;


        return "testSendMsg4";
    }
6。
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
从零搭建开发脚手架 Spring Boot集成Kafka实现生产者消费者的多种方式
2401_84009899的博客
03-31 545
我们使用。和的代码：@Bean@Bean我们可以使用这个新的来发送Greeting消息：同样，让我们修改和以正确反序列化 Greeting 消息：@Bean// …@Beanspring-kafka JSON 序列化器和反序列化器使用Jackson库，它也是 spring-kafka 项目的可选 Maven 依赖项。所以，让我们将它添加到我们的_pom.xml 中_：监听器代码：JavaConfig方式的生产者、消费者//自动位移提交。
Springboot最简单的实战介绍 整合kafka-生产者与消费者（消息推送与订阅获取）
2301_79655496的博客
04-04 777
好了，下面我们开始整合：首先，先往pom.xml文件添加Kafka的依赖，org.springframework.kafkaspring-kafka2.2.0.RELEASEorg.springframework.kafkaspring-kafka-testtest然后，接下来是配置文件（以下提供properties格式，yml格式 ，供大家随便自取），当然注释也是要好好看看的，毕竟都一字字敲的。application.properties#============== kafka ============
SpringBoot配置kafka
weixin_53150299的博客
10-06 1344
现在，我们已经完成了 Kafka 生产者和消费者的设置。我们可以使用 mvn spring-boot:run 命令启动应用程序，并使用 curl 命令发送 POST 请求到 http://localhost:8080/send 端点，以将消息发送到 Kafka。然后，我们可以在控制台上查看消费者接收到的消息。在上面的代码中，我们使用 @KafkaListener 注解声明了一个消费者方法，用于接收从 my-topic 主题中读取的消息。我们可以根据需要进行更改和扩展，以满足特定的需求。
SpringBoot项目集成kafka及常规配置_springboot集成kafka配置
最新发布
2401_85111576的博客
06-18 337
(img-R97qHqZ1-1718720384292)](img-ktLIcYDe-1718720384292)](img-auv2DYm4-1718720384293)](img-sTHIjGX3-1718720384293)]当然在这还有更多整理总结的Java进阶学习笔记和面试题未展示，其中囊括了。va进阶学习笔记和面试题未展示，其中囊括了。* 重试次数 默认值0。### 4.使用示例。
kafka springBoot 配置
weixin_41827053的博客
08-29 4420
通过这样的配置，你的 Spring Boot 应用程序将启用 Kafka 支持，你可以使用 KafkaTemplate 进行消息发送，使用 @KafkaListener 进行消息消费。但是在这种模式下，如果处理消息时发生异常，Kafka 服务器会重新发送相同的消息，可能会导致消息的重复消费。当你在 Spring Boot 应用程序的配置类上添加 @EnableKafka 注解时，它会激活 Kafka 基础设施，使你能够在应用程序中使用 Kafka 相关的组件。这样可以确保消息的准确处理，避免重复消费。
Kafka：SpringBoot配置文件基本配置
程序员无羡的博客
03-22 184
Kafka：SpringBoot配置文件基本配置
springboot整合kafka实现生产者和消费者
06-01
在本文中，我们将深入探讨如何使用Spring Boot整合Apache Kafka，以构建一个生产者和消费者的示例。Apache Kafka是一个分布式流处理平台，常被用于构建实时数据管道和流应用。Spring Boot简化了Java开发，提供了开箱...
springboot-kafka:springboot整合kafka实现消息的发送与消费学习
05-13
在Spring Boot应用中，我们需要在`application.properties`或`application.yml`中配置Kafka连接信息，包括bootstrap servers、消费者和生产者的配置项。 4. **创建Kafka生产者**： 使用Spring Boot，我们可以创建...
SpringBoot整合kafka代码简洁(测试可用)
04-17
SpringBoot简化了Kafka的配置和使用，使得开发者能够快速开发出可靠的生产者和消费者应用。以下是对标题和描述中涉及知识点的详细解释。 ### 1. SpringBoot介绍 SpringBoot是Spring框架的一个子项目，它旨在简化...
springboot整合kafka
06-23
3. **创建生产者和消费者**：在SpringBoot应用中，我们可以使用Spring的`@EnableKafka`注解开启Kafka支持。然后通过`@Component`或`@Service`创建Kafka生产者和消费者类。 ```java // 生产者 @Component public ...
【弄nèng - Kafka】应用篇（五） —— Springboot整合Kafka（事务）
司马缸砸缸了
01-08 1448
文章目录一. 简介二. @Transactional事务2.1 引入依赖2.2 Kafka配置2.2.1 生产者2.2.2 消费者2.2.3 测试三. 使用KafkaTemplate.executeInTransaction开启事务源码地址项目推荐 该篇博客实现Springboot整合kafka ,事务 更多高级用法请我的博客kafka系列 参考：https://www.jianshu.com/...
KafKa(五) ：生产者详解
风之子
04-05 583
一、kafka java客户端数据生产流程解析 图1构造一个produceRecord对象，需要要指定主题和值(value)，key和分区可以暂时不指定。 发送信息，由于信息是通过网络传输的，所以需要对传输的值进行序列化，将其变成字节码进行传输。可以进行同步发送、异步发送。 序列化器：消息要到网络上进行传播，必须进行序列化，而序列化器的作用就是如此，kafka提供了大量的序列化器，如果不满...
Kafka中生产者的基本实现
swx7410852963的博客
12-10 1226
Kafka在Java中生产者的基本实现
大数据与Kafka系列之kafka生产者各种启动参数说明
跋跋寒的博客
06-20 1万+
首先是启动一个生产者， final String kafkazk="localhost:9092"; String topic="testAPI"; Properties properties = new Properties() {{ put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, kafkazk); ...
Kafka——SpringBoot整合（消费者位移的提交）
zzhongcy的专栏
01-10 1239
kafka
Kafka实战——简单易懂的生产者消费者demo
Carson073的博客
06-04 1314
单线程版本适合本地调试，多线程版本适合做压测。
springboot 整合kafka 实现生产，消费数据
健康平安的活着的专栏
04-03 1771
一 kafka集群的启动 1.1 机器说明 192.168.152.128 master 192.168.152.129 slaver01 192.168.152.130 slaver02 1.2 查看防火墙 如果防火墙开着，则进行关闭：systemctl stopfirewalld 1.在master节点查看防火墙状态：systemctl status firewalld 可以看到：Active: inactive...
消息队列kafka（二）--与spring整合(kafkaTemplate方式)
热门推荐
panda-star的博客
11-27 2万+
一、简介 在这里介绍kafka与spring的整合，这里采用kafkaTemplate方式。 二、生产者开发步骤 1、添加maven依赖(略去spring依赖，请自行添加) org.apache.kafka kafka_2.9.2 0.8.2.1 org.apache.kafka kafka-clients 1.0.0 2、添加
spring boot2.x使用kafka消息队列(以及低版本springboot1.5x整合kafka后的问题)
新林的博客
07-30 2861
项目中经常会用到kafka作为消息中间件，有kafka记录收集日志，也有用kafka传消息异步处理业务逻辑，如果kafka处理业务逻辑，则要业务考虑是否要保证消息可靠性。记录一下springboot使用kafka的项目demo,以及配置文件如何配置
kafka整合springboot
08-30
在完成依赖导入后，你可以创建一个测试类来演示如何使用生产者发送消息。首先，你需要创建一个KafkaTemplate对象，并在测试方法中使用它来发送消息。以下是一个示例代码： ``` @SpringBootTest public class KfKTest...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值