kafka 高级应用 springboot2.1 (1)

最新推荐文章于 2024-04-17 16:52:00 发布
最新推荐文章于 2024-04-17 16:52:00 发布
阅读量426 收藏 1
点赞数 1
文章标签： java 大数据
原文链接：http://www.cnblogs.com/lshan/p/11282426.html
版权

官网：http://kafka.apache.org/21/documentation.html

依赖:

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

        

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

 

配置：KafkaConfig

package com.sea.common.config;

import java.util.Map;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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.DefaultKafkaConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;
import org.springframework.kafka.listener.ConcurrentMessageListenerContainer;
import org.springframework.kafka.listener.ContainerProperties;

import com.google.common.collect.Maps;

@Configuration
@EnableKafka
public class KafkaConfig {

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

    @Value("${spring.kafka.consumer.group-id}")
    private String groupId;

    @Value("${spring.kafka.consumer.enable-auto-commit}")
    private Boolean autoCommit;

    @Value("${spring.kafka.consumer.auto-offset-reset}")
    private String autoOffsetReset;

    @Value("${spring.kafka.consumer.max-poll-records}")
    private Integer maxPollRecords;

    @Value("${spring.kafka.producer.retries}")
    private Integer retries;

    @Value("${spring.kafka.producer.batch-size}")
    private Integer batchSize;

    @Value("${spring.kafka.producer.buffer-memory}")
    private Integer bufferMemory;



    //############################# producer 的基本配置 ################################*/
    /**
     * producer 的基本配置
     * @return
     */
    @Bean
    public Map<String, Object> producerConfigs() {
        Map<String, Object> props = Maps.newHashMap();
        props.put(ProducerConfig.ACKS_CONFIG, "0");//推荐设置为1
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ProducerConfig.RETRIES_CONFIG, retries);
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, batchSize);
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        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;
    }

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

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

    
    //############################# consumer 的基本配置 ################################*/
    /**
     * consumer基本属性配置
     * @return
     */
    @Bean
    public Map<String, Object> consumerConfigs() {
        Map<String, Object> props = Maps.newHashMap();
        props.put(ConsumerConfig.GROUP_ID_CONFIG, groupId);
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, autoCommit);
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, autoOffsetReset);// #最早未被消费的offset earliest
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, bootstrapServers);
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, maxPollRecords);//#批量消费一次最大拉取的数据量
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 180000);//#连接超时时间
        props.put(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG, 180000);
        props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 180000);//#手动提交设置与poll的心跳数,如果消息队列中没有消息，等待毫秒后，调用poll()方法。如果队列中有消息，立即消费消息，每次消费的消息的多少可以通过max.poll.records配置。
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
//        props.put(ConsumerConfig.DEFAULT_FETCH_MAX_BYTES+"",15728640); //#设置拉取数据的大小,15M
        return props;
    }
    

    /**
     * 并发数3
     */
//    @Bean //配置默认kafkaFactory
//    @ConditionalOnMissingBean(name = "kafkaBatchListener3")
//    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> kafkaBatchListener3() {
//        ConcurrentKafkaListenerContainerFactory<String, String> factory = (ConcurrentKafkaListenerContainerFactory<String, String>) batchFactory();
//        factory.setConcurrency(3);
//        return factory;
//    }
    
    /**
     * 配置为批量消费
     * @return
     */
    @Bean
    public KafkaListenerContainerFactory<?> batchFactory() {
        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(new DefaultKafkaConsumerFactory<>(consumerConfigs()));
        //设置为批量消费，每个批次数量在Kafka配置参数中设置ConsumerConfig.MAX_POLL_RECORDS_CONFIG
        factory.setBatchListener(true);
        
        //设置并发量为3
        factory.setConcurrency(3);
        // set the retry template 失败retry
//        factory.setRetryTemplate(retryTemplate());
        //设置为手动ack
        factory.getContainerProperties().setAckMode(ContainerProperties.AckMode.MANUAL);
        return factory;
    }

}

 

application.xml

### kafka configure
spring.kafka.bootstrap-servers=localhost:9092
spring.kafka.consumer.group-id=seatest//该值任意,建议使用项目名
spring.kafka.consumer.enable-auto-commit=false
spring.kafka.consumer.auto-offset-reset=earliest
spring.kafka.consumer.max-poll-records=5
spring.kafka.producer.retries=3
spring.kafka.producer.batch-size=16384
spring.kafka.producer.buffer-memory=33554432

或者(参考调整)：

kafka:
  producer:
    bootstrap-servers: 10.161.11.222:6667,10.161.11.223:6667,10.161.11.224:6667
    batch-size: 16785                                   #一次最多发送数据量
    retries: 1                                          #发送失败后的重复发送次数
    buffer-memory: 33554432                             #32M批处理缓冲区
    linger: 1
  consumer:
    bootstrap-servers: 10.161.11.222:6667,10.161.11.223:6667,10.161.11.224:6667
    auto-offset-reset: latest                           #最早未被消费的offset earliest
    max-poll-records: 3100                              #批量消费一次最大拉取的数据量
    enable-auto-commit: false                           #是否开启自动提交
    auto-commit-interval: 1000                          #自动提交的间隔时间
    session-timeout: 20000                              #连接超时时间
    max-poll-interval: 15000                            #手动提交设置与poll的心跳数,如果消息队列中没有消息，等待毫秒后，调用poll()方法。如果队列中有消息，立即消费消息，每次消费的消息的多少可以通过max.poll.records配置。
    max-partition-fetch-bytes: 15728640                 #设置拉取数据的大小,15M
  listener:
    batch-listener: true                                #是否开启批量消费，true表示批量消费
    concurrencys: 3,6                                   #设置消费的线程数
    poll-timeout: 1500                                  #只限自动提交，

 

 

发送数据:

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.support.SendResult;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.util.concurrent.ListenableFuture;

@RunWith(SpringRunner.class)
@SpringBootTest
public class Producertester {

    private static Logger log = LoggerFactory.getLogger(Producertester.class);

    @Autowired
    KafkaTemplate<String, String> kafkaTemplate;
    private static String TOPIC = "sea";

    @Test
    public void testSender() throws Exception {
        /**
         * 参数1:topic 参数2: message
         */
        kafkaTemplate.send(TOPIC, "ni hao ma");

    }

    /**
     * * 带回调函数, 前提是 props.put(ProducerConfig.ACKS_CONFIG, "1");//设置为1 或者all
     * 
     * @param topic
     * @param message
     * @throws Exception
     */
    @Test
    public void testSenderwithCallBack() throws Exception {

        ListenableFuture<SendResult<String, String>> sender = kafkaTemplate.send("sea", "chifanle ");

        // 发送成功
//    SuccessCallback successCallback = result -> log.info("数据发送成功!");
        // 发送失败回调
//    FailureCallback failureCallback = ex -> log.error("数据发送失败!");
//        void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback);
        sender.addCallback(successCallback -> {
        }, failureCallback -> log.info("数据发送失败!"));
        SendResult<String, String> sendResult = sender.get();
        System.err.println(sendResult);
        // SendResult [producerRecord=ProducerRecord(topic=sea, partition=null, headers=RecordHeaders(headers = [], isReadOnly = true), key=null, value=chifanle , timestamp=null), recordMetadata=sea-0@-1]

    }

}

 

 

 

消费数据:

@Component
public class KafkaConsumer {

    /**
     * 方式二: 批量消费, 增大吞吐量
     * @param records
     * @param ack
     */

    @KafkaListener(topics = "sea", containerFactory = "batchFactory", errorHandler = "consumerAwareErrorHandler")
    public void listen(List<ConsumerRecord<String, String>> records, Acknowledgment ack){  
        System.err.println(records);
        System.err.println("&&&&&&&&&&&&&&&&&&");

        ack.acknowledge();
    }
    
    
    
    /**
     * 方式一:单条消费
     * @param record
     * @param ack
     */
   //@KafkaListener(containerFactory = "batchFactory",topics = {"topic1","topic2"})

    @KafkaListener(topics = "sea1",errorHandler = "consumerAwareErrorHandler")
    public void listen(ConsumerRecord<?,String> record,Acknowledgment ack) { 
        System.out.println(record);
　　　　  ack.acknowledge();
    }

}

 

异常处理:

 

@Component
public class KafkaErrorListener {


    @Bean
    public ConsumerAwareListenerErrorHandler consumerAwareErrorHandler() 
    {
         return new ConsumerAwareListenerErrorHandler() 
                        {
            @Override
            public Object handleError(Message<?> message, ListenerExecutionFailedException e, Consumer<?, ?> consumer) {
                  System.err.println("consumer message occur error, "+ e);
                  //doing something
                return null;
            }
        };
    }
}

 

 

 

分区批量消费:

@Component
public class KafkaPartitionConsumer {

/**
 * 分区消费: 此处只测试批量分区消费
 * 
 * 说明: topic "sea" 有两个分区, 分区0,1  (同一个group 中的Consumer 如果不指定分区,或者指定的分区是一样的 那么消费的数据 一模一样, 毫无意义 )
 * 下面使用两个 Consumer 分别去消费两个不同的partition 的数据, 这样一条数据,只会被一个consumer 消费
 * 
 * @param records
 * @param ack
 */
    @KafkaListener(id = "id2",groupId="sea7", containerFactory = "batchFactory",topicPartitions = { @TopicPartition(topic = "sea", partitions = { "0" }) })
//     @KafkaListener(id = "id1",groupId="sea8", containerFactory = "batchFactory",topicPartitions = { @TopicPartition(topic = "sea",partitionOffsets =  @PartitionOffset(partition = "0",initialOffset = "-1")) })
    public void listen2(List<ConsumerRecord<String, String>> records, Acknowledgment ack){
        System.err.println("方式2  方式2  方式2  方式2 方式2 方式2 方式2 方式2 ");
        System.err.println(records.get(0).value());
        ack.acknowledge();
    }
    
    
    
   
//      @KafkaListener(id = "id1",groupId="sea9", containerFactory = "batchFactory",topicPartitions = { @TopicPartition(topic = "sea", partitions = { "1" }) })
      @KafkaListener(id = "id1",groupId="sea8", containerFactory = "batchFactory",topicPartitions = { @TopicPartition(topic = "sea",partitionOffsets =  @PartitionOffset(partition = "1",initialOffset = "-1")) })
      public void listen1(List<ConsumerRecord<String, String>> records, Acknowledgment ack){
        
        System.err.println("方式一 方式一 方式一 方式一 方式一 方式一 方式一 方式一 ");
        System.out.println(records.get(0).value());
        ack.acknowledge();
    }
}

 

转载于:https://www.cnblogs.com/lshan/p/11282426.html

weixin_30894389
关注
【SpringBoot系列】Springboot使用kafka的两种方式
我是香菜
11-07 4455
KafkaProducer是Kafka-client提供的原生Java Kafka客户端发送消息的API。KafkaTemplate是Spring Kafka中提供的一个高级工具类，用于可以方便地发送消息到Kafka。它封装了KafkaProducer，提供了更多的便利方法和更高级的消息发送方式。
Spring for Apache Kafka概述和简单入门
一起学习一起进步~
09-08 562
Spring for Apache Kafka 的高级概述以及底层概念和可运行的示例代码。
Mybatis批处理
MostSnails的博客
11-14 7644
Mybatis批处理 第一种 单条SQL循环操作 1.Mapper.xml ``` <insert id="insert" parameterType="com.example.mybatisbatch.entity.OrderDetail"> insert into order_detail values (#{order.id},#{order.name},#{order.phone},#{order.expressNo},#{order.productName},#{ord
mybatis批量处理
Cowboy
12-23 1731
Mybatis技术学习，更多知识请访问https://www.itkc8.com foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。foreach元素的属性主要有 item，index，collection，open，separator，close。item表示集合中每一个元素进行迭代时的别名，index指 定一个名字，用于表示在迭代过程中，每次迭代到的位置，open...
Mybatis 批处理
热门推荐
死脑袋瓜的专栏
07-09 2万+
有的时候，我们需要一次性插入很多的数据或者一次性更新、删除很多的数据，那么为了提高效率，我们需要使用批处理来完成。以下将讨论Mybatis+Spring如何使用批处理。 首先应该知道Mybatis是Ibatis的升级版，比Ibatis性能更好，这是我采用Mybatis的原因。 Ibatis是支持批处理的： public void batchAddE
mybatis批处理
qq_41695498的博客
02-20 366
批量查询 方法一、（推介） dao接口： List<UBaseMenu> findMenuName(List<String> valueList); xml： <select id="findMenuName" resultType="java.lang.String" parameterType="java.util.List"> select menu...
SpringBoot使用Kafka详解含完整代码
02-20
本文将详细介绍如何在Spring Boot应用程序中集成并使用Kafka，包括从基础概念到高级特性的全方位解析，并通过具体的代码示例加深理解。 #### 二、Spring Boot 集成 Kafka ##### 2.1 添加依赖 在项目的`pom.xml`...
【SpringBoot 2学习笔记】《十三》SpringBoot2消息之旅，带你体验RabbitMQ和Kafka消息发送
黑白猿的琐碎日常
03-14 2万+
消息队列一般的正常业务开发中基本上不怎么涉猎，都是系统整合或特殊业务场景下才有用武之地。所以大部分程序员在工作中基本没有怎么接触。本章主要内容，就是带领大家入门体验一下消息队列的使用过程，扩展一下知识体系，方便今后有需要时根据实际的业务场景进行定制开发。为了方便，本文中使用的RabbitMQ直接使用了阿里的云服务，这个是按照发送消息的次数计费，比较便宜。Kafka服务的话，阿里云的服务比较贵，就没有再购买服务，自己在原来买的ECS服务器上安装了一下，方便进行程序的开发调试。
多线程高并发，spring整合kafka消费
m0_57700125的博客
07-13 972
为了更好的梳理相关知识，咱们先看纯手绘知识体系图 1.1 Kafka知识体系大纲 由于我手绘这些知识体系大纲是用的xmind软件，无法上传，所以都以截图的形式展示，细节处不清楚（毕竟图片形式有限） 1.2 RabbitMQ知识体系大纲 1.3 RocketMQ知识体系大纲 看完知识大纲，该刷面试了 2.1 刷刷Kafka面试 Kafka的用途有哪些？使用场景如何？ Kafka中的ISR、AR又代表什么？ISR的伸缩又指什么 Kafka中的HW、LEO、LSO、LW等分别代表什么？ Kafka中
Mybatis的批处理
12-14
在操作数据库时，经常会碰到批量插入、批量删除的情况，直接执行SQL语句还好做一点，当使用Mybatis进行批量插入、批量删除时会有一些问题。下面对使用Mybatis批量插入，批量删除进行介绍。 　　1. 批量插入 Java代码： 　　// Model: Test.java 　　@Data 　　public class Test { 　　private String x; 　　private String y; 　　private String z; 　　} 　　// Mapper: TestMapper.java 　　public void insertTestList(L
MyBatis批处理
Do_GH的博客
03-29 3086
批处理即批量处理。如果需要往数据库中插入大量数据时，再使用单条插入即插入一次调一次insert语句就会很浪费资源。所以针对于批量数据新增、删除、修改、查找的操作，mybatis提供了批处理方案 批量插入 除了可以向SQL语句中传入单一的数据类型，还可以传输一个list集合，利用foreach标签就可以循环遍历集合中的内容实现批处理，例如： Mapper XML: <insert id="batchInsert" parameterType="java.util.List"> INSERT
mybatis的批处理
最新发布
B__B_B的博客
04-17 588
需要注意的是，在使用MyBatis的批处理功能时，应该根据具体情况选择合适的方式，并合理控制批处理的大小，以避免占用过多资源或影响数据库性能。通过合理使用MyBatis的批处理功能，可以提高数据库操作的效率，减少与数据库的交互次数，从而提升系统的整体性能。在执行多个不同的SQL语句时，可以将多个SQL语句的执行转换为一次执行，减少与数据库的交互次数，提高效率。在执行多次相同的SQL语句时，可以将多次执行转换为一次执行，减少与数据库的交互次数，提高效率。
【Mybatis的批量处理】
m0_46459413的博客
03-02 1218
Mybatis的批量处理操作 1. 一般批量处理 链接: mybatis批量更新数据三种方法效率对比 2. 使用BatchExecutor进行批量处理 若方法一中的方法无法满足业务需要时，可使用Mybatis的批量处理器进行批量处理。 通过依赖注入的方式声明sqlSessionTemplate工具； @Autowired private SqlSessionTemplate sqlSessionTemplate; 先通过sqlSessionTemplate获取工厂实例，然后再获取指定执行器的sqlS
MyBatis批量处理
m0_71128291的博客
11-20 901
MyBatis批量处理
MyBatis进阶八：Mybatis批处理；（批量插入，批量删除，批量更新待写…）
小枯林的博客
05-13 2万+
fsd
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值