3.2kafka基础配置，整合springboot

最新推荐文章于 2024-05-12 22:09:41 发布
最新推荐文章于 2024-05-12 22:09:41 发布
阅读量516 收藏 1
点赞数
分类专栏： 消息队列 SpringBoot 消息队列基础，及其操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c_royi/article/details/86690788
版权

kafka基础配置

github网址：https://github.com/Plumblumpb/messageQueue-.git
kafka基础（可以先看）：https://blog.csdn.net/c_royi/article/details/86648910

 项目

maven文件

<dependency>
   <groupId>org.apache.kafka</groupId>
   <artifactId>kafka_2.12</artifactId>
   <version>2.0.1</version>
</dependency>
<dependency>
   <groupId>org.apache.kafka</groupId>
   <artifactId>kafka-clients</artifactId>
   <version>2.0.1</version>
</dependency>

生产者

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Properties;

/**
 * @Auther: cpb
 * @Date: 2019/1/25 17:20
 * @Description:
 */
public class Producer {
    static Logger log = LoggerFactory.getLogger(Producer.class);
    private static final String TOPIC = "test_topic";
    private static final String BROKER_LIST = "localhost:9092";
    private static KafkaProducer<String,String> producer = null;
    /*
    初始化生产者
     */
    static {
        Properties configs = initConfig();
        producer = new KafkaProducer<String, String>(configs);
    }
    /*
    初始化配置
     */
    private static Properties initConfig(){
        //        配置项在ProductConfig类中查看
        Properties properties = new Properties();
        //配置ip和端口
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        //配置key的序列化方式。
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //配置value的序列化方式
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        return properties;
    }

    public static void main(String[] args) throws InterruptedException {
        //消息实体
        ProducerRecord<String , String> record = null;
        for (int i = 0; i < 10; i++) {
//            配置topic
            record = new ProducerRecord<String, String>(TOPIC, "value"+(int)(10*(Math.random())));
            //发送消息
            producer.send(record, new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (null != e){
                        log.info("send error" + e.getMessage());
                    }else {
                        System.out.println(String.format("测试：offset:%s,partition:%s",recordMetadata.offset(),recordMetadata.partition()));
                    }
                }
            });
        }
        producer.close();
    }
}

消费者1

import org.apache.kafka.clients.consumer.ConsumerConfig;
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.common.serialization.StringDeserializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.time.Duration;
import java.util.Arrays;
import java.util.Properties;

/**
 * @Auther: cpb
 * @Date: 2019/1/25 17:29
 * @Description:
 */
public class Consumer1 {
    static Logger log = LoggerFactory.getLogger(Producer.class);

    private static final String TOPIC = "test_topic";
    private static final String BROKER_LIST = "localhost:9092";
    private static KafkaConsumer<String,String> consumer = null;

    static {
        Properties configs = initConfig();
        consumer = new KafkaConsumer<String, String>(configs);
    }

    private static Properties initConfig(){
//        配置项在ConsumerConfig类中查看
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        //group_id用于分组，每组只有一个consumer获取到消息，用于做负载均衡，group内部开多少个consumer来消费完全取决于数据量和业务的实时性
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"1");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        return properties;
    }


    public static void main(String[] args) {
        consumer.subscribe(Arrays.asList(TOPIC));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(10));
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record);
            }
        }
    }
}

消费者2

public class Consumer {


    static Logger log = LoggerFactory.getLogger(Producer.class);

    private static final String TOPIC = "test_topic";
    private static final String BROKER_LIST = "localhost:9092";
    private static KafkaConsumer<String,String> consumer = null;

    static {
        Properties configs = initConfig();
        consumer = new KafkaConsumer<String, String>(configs);
    }

    private static Properties initConfig(){
//        配置项在ConsumerConfig类中查看
        Properties properties = new Properties();
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,BROKER_LIST);
        //group_id用于分组，每组只有一个consumer获取到消息，用于做负载均衡，group内部开多少个consumer来消费完全取决于数据量和业务的实时性
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"0");
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.setProperty(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        properties.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");
        return properties;
    }


    public static void main(String[] args) {
        consumer.subscribe(Arrays.asList(TOPIC));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(10));
            for (ConsumerRecord<String, String> record : records) {
                System.out.println(record);
            }
        }
    }


}

kafka整合springboot

maven文件

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.4.RELEASE</version>
        <relativePath/> <!-- lookup parent from JMS -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.kafka</groupId>
            <artifactId>spring-kafka</artifactId>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka_2.12</artifactId>
            <version>2.0.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.0.1</version>
        </dependency>
    </dependencies>

application.properties文件

#============== kafka ===================
kafka.consumer.zookeeper.connect=localhost:2181
kafka.consumer.servers=localhost:9092
kafka.consumer.enable.auto.commit=true
kafka.consumer.session.timeout=6000
kafka.consumer.auto.commit.interval=100
kafka.consumer.auto.offset.reset=latest
kafka.consumer.topic=test
kafka.consumer.group.id=test
kafka.consumer.concurrency=10

kafka.producer.servers=localhost:9092
kafka.producer.retries=0
kafka.producer.batch.size=4096
kafka.producer.linger=1
kafka.producer.buffer.memory=40960

生产者配置文件config

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
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.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

import java.util.HashMap;
import java.util.Map;

/**
 * @Auther: cpb
 * @Date: 2019/1/28 09:57
 * @Description:
 */
@Configuration
@EnableKafka
public class KafkaProduceConfig {

    @Value("${kafka.producer.servers}")
    private String servers;
    @Value("${kafka.producer.retries}")
    private int retries;
    @Value("${kafka.producer.batch.size}")
    private int batchSize;
    @Value("${kafka.producer.linger}")
    private int linger;
    @Value("${kafka.producer.buffer.memory}")
    private int bufferMemory;


    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = new HashMap<>();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        props.put(ProducerConfig.LINGER_MS_CONFIG, linger);
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, bufferMemory);
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
        return props;
    }

    public ProducerFactory<String, String> producerFactory() {
        return new DefaultKafkaProducerFactory<>(producerConfigs());
    }

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

}

消费者配置文件config

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 org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.config.KafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;

import java.util.HashMap;
import java.util.Map;

/**
 * @Auther: cpb
 * @Date: 2019/1/28 10:02
 * @Description:
 */
@Configuration
@EnableKafka
public class KafkaConsumerConfig {


    @Value("${kafka.consumer.servers}")
    private String servers;
    @Value("${kafka.consumer.enable.auto.commit}")
    private boolean enableAutoCommit;
    @Value("${kafka.consumer.session.timeout}")
    private String sessionTimeout;
    @Value("${kafka.consumer.auto.commit.interval}")
    private String autoCommitInterval;
    @Value("${kafka.consumer.group.id}")
    private String groupId;
    @Value("${kafka.consumer.auto.offset.reset}")
    private String autoOffsetReset;
    @Value("${kafka.consumer.concurrency}")
    private int concurrency;
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> propsMap = new HashMap<>();
        propsMap.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, servers);
        propsMap.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, enableAutoCommit);
        propsMap.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, autoCommitInterval);
        propsMap.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, sessionTimeout);
        propsMap.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        propsMap.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        propsMap.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);
        return propsMap;
    }

    public ConsumerFactory<String, String> consumerFactory() {
        return new DefaultKafkaConsumerFactory<>(consumerConfigs());
    }

    @Bean
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaListenerContainerFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory());
        factory.setConcurrency(concurrency);
        factory.getContainerProperties().setPollTimeout(1500);
        return factory;
    }





}

生产者

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Auther: cpb
 * @Date: 2019/1/28 10:23
 * @Description:
 */
@RestController
public class ProduceController {
    @Autowired
    private KafkaTemplate kafkaTemplate;

    @GetMapping("/produce")
    public String sendMessage(){
        String message = "你好，我是produce";
        String topic = "test";
        kafkaTemplate.send(topic,message);
        return message;

    }
}

消费者

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Auther: cpb
 * @Date: 2019/1/28 13:26
 * @Description:
 */
@RestController
public class ConsumerController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    //异步调用方法
    @KafkaListener(topics = {"test"})
    public void getMessage(ConsumerRecord<?, ?> record) {
        logger.info("kafka的key: " + record.key());
        logger.info("kafka的value: " + record.value().toString());
    }


}
plumblum
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
docker 安装kafka_5分钟带你体验一把 Kafka
weixin_39863017的博客
11-25 158
本文是 Kafka原创系列第二篇，相关阅读：入门篇！大白话带你认识 Kafka！前言毕竟是要搭建环境和简单实用，所以文中有大量的代码和配置文件。前置条件：你的电脑已经安装 Docker主要内容：使用 Docker 安装使用命令行测试消息的生产和消费消息队列功能使用zookeeper和kafka可视化管理工具Java 程序中简单使用Kafka使用 Docker 安装搭建Kafka环境单...
Springboot 配置使用 Kafka
泡泡的博客
11-01 1万+
不多BB讲原理，只教你怎么用，看了全网没有比我更详细的了，yml 配置，Config 工厂代码配置都有，batch-size、acks、offset、auto-commit、trusted-packages、poll-timeout、linger 应有尽有，批量消费、开启事务、定义批量消费数量、延时发送、失败重试、异常处理你还想要什么As we all know，当今世界最流行的消息中间件有 RabbitMq、RocketMq、Kafka，其中，应用最广泛的是RabbitMq，RocketMq。
SpringBoot集成Kafka
最新发布
兴趣是最好的老师
05-12 349
5.创建生产者控制器：KafkaProducerController。4. 创建配置类：SpringBootKafkaConfig。我没有安装kafka，后面准备在mac上安装下kafka。6.创建消费者：KafkaDataConsumer。1.创建SpringBoot项目。
SpringBoot整合Kafka
热门推荐
我的博客
04-21 1万+
前言 kafka 也作为消息中间件的一员，与其他消息中间件相比，它的优点在于拥有极高的吞吐量，ms 级的延迟，是一个高性能，分布式的系统。 源码 GitHub地址：https://github.com/intomylife/SpringBoot 环境 JDK 1.8.0 + Maven 3.0 + SpringBoot 2.0.3 ZooKeeper-3.4.5 kafk...
SpringBoot2整合kafka
胖墩的IT博客
08-06 251
这kafka是伪集群，因为虚拟机有限，zookeeper也是集群 上面一篇写了springboot2整合dubbo，原来我以为可以springboot整合dubbo和kafka呢？ 之后才发现我想错了 说一下这两个用途的一些区别 dubbo是微服务，微小的服务，如果并发量不是太高，上千万，上亿级别的或者想要返回结果的可以用dubbo kafka是消息队列，如果想提高吞吐量，不要返回结果(返回...
Kafka的历史版本对应SpringBoot版本
码灵的博客
04-17 3182
截至目前（2023年），Kafka的最新版本是2.9.0，发布于2022年11月30日。Kafka的历史版本可以在Kafka官方网站的下载页面中找到。Kafka从0.8版本开始发布，经历了多个版本的迭代和升级。每个版本都有其自己的特点和改进，Kafka用户可以根据自己的需要选择合适的版本使用。
SpringBoot整合Kafka配置类方式
01-12
SpringBoot整合Kafka配置类方式
springboot - 2.7.3版本 - （七）整合Kafka
09-30
在`springboot-kafka`目录下，可能包含了一个示例项目，你可以通过导入IDE进行编译和运行，以了解Spring Boot与Kafka集成的实践操作。 通过以上步骤，你已经掌握了如何在Spring Boot 2.7.3中集成Apache Kafka的基本...
SpringBoot整合kafka，代码简洁，自动分配分区和指定分区消费(亲测可用)
04-24
最后，对于`yq-java-kafka`这个压缩包，它可能包含了完整的SpringBoot整合Kafka的示例项目，包括生产者和消费者工程。下载后，可以通过运行这两个工程来验证自动分配分区和指定分区消费的功能是否有效。 总结，...
SpringBoot Kafka 整合使用及安装教程
08-25
本文将详细介绍 SpringBoot Kafka 的整合使用及安装教程，包括项目的创建、pom 文件的配置、Kafka 的安装和使用等。 首先，需要了解 SpringBoot 和 Kafka 的基本概念。如果不了解 SpringBoot，可以查看 DD 大佬和...
springboot整合kafka实现生产者和消费者
06-01
在本文中，我们将深入探讨如何使用Spring Boot整合Apache Kafka，以构建一个生产者和消费者的示例。Apache Kafka是一个分布式流处理平台，常被用于构建实时数据管道和流应用。Spring Boot简化了Java开发，提供了开箱...
spring boot与kafka各版本兼容版本
snail_bi的博客
09-03 6554
https://spring.io/projects/spring-kafka
SpringBoot项目集成kafka及常规配置
codeLife1993的博客
06-17 1万+
使用 spring-kafka 的api，在springboot项目中集成kafka能力，封装配置。
spring boot + kafka 简单配置
Amy的博客
07-27 2892
spring boot kafka 安装 集成
kafka springBoot 配置
weixin_41827053的博客
08-29 4333
通过这样的配置，你的 Spring Boot 应用程序将启用 Kafka 支持，你可以使用 KafkaTemplate 进行消息发送，使用 @KafkaListener 进行消息消费。但是在这种模式下，如果处理消息时发生异常，Kafka 服务器会重新发送相同的消息，可能会导致消息的重复消费。当你在 Spring Boot 应用程序的配置类上添加 @EnableKafka 注解时，它会激活 Kafka 基础设施，使你能够在应用程序中使用 Kafka 相关的组件。这样可以确保消息的准确处理，避免重复消费。
SpringBoot集成Kafka详解
qq_20865839的博客
10-20 1万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。其路由机制为：1.若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；
springboot kafka配置与使用
日常记录
11-25 3485
可以根据情况只配置生产着或消费者；每个groupId都可以完整消费指定topic的所有数据，要想重新消费所有数据可以更换groupid组
Springboot整合kafka
音乐土豆
02-21 9819
Springboot 整合kafka ，简单实现
springboot集成kafka的相关配置及自定义
weixin_41377877的博客
04-27 3483
有这样一个场景，在项目中，我们搭建了kafka集群，然而在环境中，会有各种不同的消息，有一些消息不是我们需要的，有些消息是我们需要的，这时我们可以通过过滤器来进行控制和过滤。kafka内部自己实现分区、策略等一系列的逻辑，当然这些也可以自定义，这里有需要的可以自己研究一下，我这里就不需要了。之前的文章末尾，简单的实现了springboot集成kafka，完成了简单的测试，今天我们来扩展一下相关内容。然后在消费者消费时，我遇到prefix前缀的消息时，就统一过滤掉，这不是我所需要的消息。
kafka如何整合至springboot
04-26
在Spring Boot应用程序中，可以使用@EnableKafka注释启用Kafka集成，并定义Kafka相关配置。最后，需要编写处理Kafka消息的相关代码，并将其与应用程序的业务逻辑集成。这样，就可以将Kafka整合到Spring Boot应用程序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值