【2024】kafka原生以及配合springboot的使用（Kafka-3）

已于 2024-04-25 09:53:57 修改
阅读量1.5k 收藏 11
点赞数 28
分类专栏： 中间件 kafka 文章标签： kafka spring boot 大数据 中间件 java
于 2024-04-02 21:26:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52315708/article/details/137247961
版权

💻目录

前言

本文主要是介绍通过使用原生代码方式和结合springboot分别如何更好的去使用理解kafka

如果需要看理论或者安装kafka可以看我前面两篇内容
🍅kafka使用和安装

一、依赖

主要分为springboot和原生代码的依赖，还有hutool工具包

<dependencies>

		<dependency>
			<groupId>cn.hutool</groupId>
			<artifactId>hutool-all</artifactId>
			<version>5.8.20</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
<!--	springbootkafka-->
		<dependency>
			<groupId>org.springframework.kafka</groupId>
			<artifactId>spring-kafka</artifactId>
		</dependency>
		<!--	springmvc原生kafka-->
		<dependency>
			<groupId>org.apache.kafka</groupId>
			<artifactId>kafka-clients</artifactId>
			<version>2.4.1</version>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
</dependencies>

二、原生使用kafka

构建项目就不做过多说了，普通maven项目就行，重点在于方法API的使用。

1、发送消息

发送消息流程

  1. 首先是先创建一个Properties对象用于传递配置参数
  2. 然后通过props.put()方法添加需要添加的配置
    • 添加连接kafka地址和设置序列化是必须的，后面的有默认的，可以根据情况设置
  3. 创建一个KafkaProducer连接客户端
  4. 创建ProducerRecord发送记录类，发送消息就是通过这个类进行发送
  5. 发送时可以选择同步或者异步进行发送

import lombok.extern.slf4j.Slf4j;
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.clients.producer.RecordMetadata;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

/**
 * @projectName: kafka-mode
 * @package: com.zheng.kafkamode.kafka
 * @className: MyProducer
 * 消息的发送者---简单发送
 * @version: 1.0
 */
@Slf4j
public class MyProducer {

    private final static String TOPIC_NAME = "my-replicated-topic";


    public static void main(String[] args) throws ExecutionException, InterruptedException {
        Properties props = new Properties();
//        设置参数
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"10.211.55.6:9092");
//        设置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

        配置ACK
//        props.put(ProducerConfig.ACKS_CONFIG,"1");
        失败重试次数，3次
//        props.put(ProducerConfig.RETRIES_CONFIG,3);
//
        失败重试时间间隔，300毫秒后重试
//        props.put(ProducerConfig.RECONNECT_BACKOFF_MS_CONFIG,300);

//          kafka消息缓冲区大小，用来存放要发送到消息，缓冲区是32m，
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
//          本地线程，一次性从缓冲区拉取的数据大小，16k
        props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
//          如果线程拉取不到16k，间隔10ms也会将缓冲区的数据发送到kafka
        props.put(ProducerConfig.LINGER_MS_CONFIG,10);


//        连接客户端
        KafkaProducer<String, String> producer = new KafkaProducer<>(props);
        //        发送的消息记录器(topic,partition(指定发到哪个),key（用于计算发到哪个partition）,value)
//          默认partition数量和Broker创建的数量一致
        ProducerRecord<String, String> producerRecord = new ProducerRecord<>(TOPIC_NAME, 0,"my-keyValue3", "hello");

//        同步
        send(producer,producerRecord);
//        异步
        asyncSend(producer,producerRecord);
    }

    /**
     * @param producer: 客户端对象
     * @return void
     * 同步发送
     * @date 2024/3/22 17:09
     */
    private static void send(KafkaProducer<String, String> producer,ProducerRecord<String, String> producerRecord) throws InterruptedException, ExecutionException {

//          等待发送成功的阻塞方法
        RecordMetadata metadata = producer.send(producerRecord).get();

        log.info("同步发送消息"+ "topic-"+metadata.topic()+"====partition："+metadata.partition()
        +"=====offset："+metadata.offset());
    }

    /**
     * @param producer: 客户端对象
     * @return void
     * 异步发送
     * @date 2024/3/22 17:09
     */
    private static void asyncSend(KafkaProducer<String, String> producer,ProducerRecord<String, String> producerRecord) throws InterruptedException {

        int sum = 5;
        CountDownLatch countDownLatch = new CountDownLatch(sum);

        for (int i = 0; i < sum; i++) {



            ProducerRecord<String, String> producerRecord1 = new ProducerRecord<>(TOPIC_NAME, "my-keyValue"+i, "zhangsan"+i);

            //        异步发送消息
            producer.send(producerRecord1,(metadata, exception) -> {


                log.info("异步发送消息"+ "topic-"+metadata.topic()+"====partition："+metadata.partition()
                        +"=====offset："+metadata.offset());

                countDownLatch.countDown();
            });
        }

        countDownLatch.await(5, TimeUnit.SECONDS);



    }
}

1.1、生产者同步发送消息

同步发送收到消息后会回复一个ack

ack有三个参数配置：（默认是1）

  • cak = 0：kafka收到消息后，不需要关心消息是否成功写入到分区中，马上就返回ack，
    • 会容易丢失消息，但效率最高
  • ack = 1 ：多副本之间的leader分区已经收到消息，并把消息写入到本地log中，才会返回ack给生产者
    • 性能和安全是最均衡的
  • ack = -1/all ：里面有默认配置min.insync.replicas=2(默认为1，推荐配置大于等于2)，
    • min.insync.replicas：代表同步副本的个数（如果是1，则是只需要leader收到就可以）
    • 最安全但性能最差

生产者如果3秒没有收到回复(ack)，则会重试，如果重试3次还没成功，则抛出异常。

  • 消息丢失概率较小

在这里插入图片描述

1.2、生产者异步发送消息

异步发送不需要等待客户端回复ack

生产者发送消息后就可以做之后的业务，不需要等待broker在收到消息后异步调用生产者提供的callback。

  • 会出现消息丢失问题

    在这里插入图片描述

1.3、常用配置：

  • 基础配置
//        设置参数
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.8.62:3392");
//        设置序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
  • 发送消息配置
//        配置ACK
        props.put(ProducerConfig.ACKS_CONFIG,"1");
//        失败重试次数，3次
        props.put(ProducerConfig.RETRIES_CONFIG,3);

//        失败重试时间间隔，300毫秒后重试
        props.put(ProducerConfig.RECONNECT_BACKOFF_MS_CONFIG,300);

  • 缓冲区配置

    kafka发送消息的流程是先创建一个缓冲区，把消息先发送到缓冲区，然后再有一个本地线程，来这个缓冲区拉取数据，通过本地线程把数据从缓冲区拉取发送到kafka客户端

在这里插入图片描述

  • kafka默认会创建一个消息缓冲区，用来存放要发送到消息，缓冲区是32m，
props.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);
  • 本地线程，一次性从缓冲区拉取的数据大小，16k
props.put(ProducerConfig.BATCH_SIZE_CONFIG,16384);
  • 如果线程拉取不到16k，间隔10ms也会将缓冲区的数据发送到kafka
props.put(ProducerConfig.LINGER_MS_CONFIG,10);

2、接收消息

消费消息流程

  1. 也是首先是先创建一个Properties对象用于传递配置参数
  2. 然后在props.put()方法传递参数
  3. 在创建一个连接客户端携带上Properties。
  4. 然后通过消费者客户端去poll()消息，默认可以一次可以poll到五百条消息下来，
    • Duration.ofMillis(1000)：表示如果没poll到五百条，1000ms后也结束这次poll。然后处理poll下来的消息，在继续循环poll下一次
@Slf4j
public class MyConsumer {
    private final static String TOPIC_NAME = "my-replicated-topic";
    private final static String CONSUMER_GROUP_NAME = "testGroup";

    public static void main(String[] args) {

        Properties props = new Properties();
//        设置参数
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.8.62:3392");

//        设置消费组名
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"CONSUMER_GROUP_NAME");
//        设置序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
//          创建一个消费者的客户端
        KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
//        消费者订阅主题列表
        consumer.subscribe(Arrays.asList(TOPIC_NAME));

        while (true){
//            poll() API 是拉取消息的长轮训
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));

//            取出单个offset
            for (ConsumerRecord record : records){
                
                log.info("收到的消息：partition = {};offset = {};key = {};value = {}"
                        ,record.partition()
                        ,record.offset()
                        ,record.key()
                        ,record.value());
            }
        }
    }
}

2.1、关于消费者的自动提交和手动提交

在这里插入图片描述

消费者无论是自动提交还是手动提交，都需要把所属的消费组+消费的某个主题+消费的某个分区及消费的偏移量，这样的信息交给集群的_consumer_offsets主题里面。

  • 自动提交

    消费者poll消息下来以后就会自动提交offset

    //        设置自动提交offset：true=自动提交、false=手动提交。
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"true");
//        自动提交offset的时间间隔
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG,"1000");

    注意：自动提交可能会丢失消息

  • 手动提交

    需要把自动提交的配置改为false

            props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");

    手动提交分为两种：

    • 手动同步提交

      在消费完消息后调用同步方法，会阻塞等待提交成功返回ack

      
//            取出单个offset
            for (ConsumerRecord record : records){
                log.info("收到的消息：partition = {};offset = {};key = {};value = {}"
                        ,record.partition()
                        ,record.offset()
                        ,record.key()
                        ,record.value());
            }
//            所有的消息已消费完
            if (records.count()>0){ //有消息
//                手动提交offset，当前线程会阻塞直到offset提交成功
//                一般使用同步提交，因为提交之后页没什么业务逻辑
               consumer.commitSync();
            }

    • 手动异步提交

      在消息消费完后提交，不需要等到集群ack，直接执行之后的逻辑，可以设置一个回调方法，供集群调用

      
//            取出单个offset
            for (ConsumerRecord record : records){
                log.info("收到的消息：partition = {};offset = {};key = {};value = {}"
                        ,record.partition()
                        ,record.offset()
                        ,record.key()
                        ,record.value());
            }
//            所有的消息已消费完
            if (records.count()>0){ //有消息
            
//                手动异步提交,异步回调处理
                consumer.commitAsync((offsetAndMetadataMap,exception)->{
                    if (exception != null){
                        System.out.println("提交失败！失败原因："+exception.getStackTrace());
                    }
                    System.out.println("提交成功！=="+offsetAndMetadataMap);
                });

            }

2.2、长轮训poll消息

  • 默认情况下，消费者一次性会poll500条消息。
//        一下poll消费的消息数,可以根据消费消息的快慢来决定，一次性消费多少消息
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG,500);
  • 代码中设置了长轮训的时间是1000毫秒
        while (true){
//            poll() API 是拉取消息的长轮训，1000代表本次拉取1秒钟就结束
//              拉取消息到records中，
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));

//            取出单个offset进行消费
            for (ConsumerRecord record : records){
	            log.info("收到的消息"}
            }
        }

意味着:

  • 结束单次消费原因可能是：
    • 如果一次poll500条，就直接结束这次poll，去进入到for循环去消费这次poll到的消息。
    • 如果一次没有poll到500条，且时间在1秒内，那么长轮训继续poll；要么拉取到500条，要么达到1秒，才会结束拉取
    • 如果多次poll都没达到500条，且1秒时间到了，那么直接进入for循环。
  • 如果两次poll的时间间隔超过30s，集群会认为该消费者的消费能力过弱，该消费者被踢出消费组，触发rebalance机制，rebalance机制会造成性能开销。可以通过设置这个参数，让一次poll的消息条数少一点
//        如果两次poll的时间如果超过30s的时间间隔，kafka会认为其消费能力过弱，将其踢出消费组，将分区分配给其他消费者。
        props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG,30*1000);

2.3、消费者的健康状态检查

消费者每隔1s向kafka集群发送心跳，集群发现如果超过10s没有续约的消费者，将被踢出消费组，触发rebalance机制，将该分区交给消费组里的其他消费者进行消费。

//        consumer给broker发送心跳的间隔时间
        props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG,1000);
//        如果超过10s没收到消费者的心跳，则会把消费者踢出消费组，进行rebalance，把分区分配给其他消费者。
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG,10 * 1000);

2.4、指定分区和偏移量，时间消费

  • 指定分区消费

            consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));

  • 从头消费

            consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));
        consumer.seekToBeginning(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));

  • 指定offset

            consumer.assign(Arrays.asList(new TopicPartition(TOPIC_NAME,0)));
        consumer.seek(new TopicPartition(TOPIC_NAME,0),10);

  • 指定时间节点开始消费

         List<PartitionInfo> topicPartition = consumer.partitionsFor(TOPIC_NAME);
//          key=分区：value=偏移量
        HashMap<TopicPartition, Long> map = new HashMap<>();
//        从1小时前开始消费
        long fetchDateTime = new Date().getTime() - 1000 * 60 * 60;
        for (PartitionInfo par : topicPartition){
            map.put(new TopicPartition(TOPIC_NAME, par.partition()),fetchDateTime);
        }
//        根据时间查找指定分区的偏移量
        Map<TopicPartition, OffsetAndTimestamp> parMap = consumer.offsetsForTimes(map);

        for (Map.Entry<TopicPartition, OffsetAndTimestamp> entry:parMap.entrySet()){
            TopicPartition key = entry.getKey();
            OffsetAndTimestamp value = entry.getValue();
            if (key == null || value == null) continue;

            long offset = value.offset();
            System.out.println("partition-"+key.partition()+"===offset-"+offset);
            System.out.println();
//            再通过指定offset消费
            if (value != null){
                consumer.assign(Arrays.asList(key));
                consumer.seek(key,offset);
            }
        }

2.5、新消费组的消费offset规则

新消费组的消费者在启动以后，默认会从连接后的分区的offset开始消费(消费新消息)。可以通过下面设置，让新消费者第一次从头开始消费，之后则会只消费新的消费者(最后消费的位置的偏移量+1)

  • Latest：默认的，消费新消息
  • earliest：第一次从头开始消费。之后开始消费新消息
//        新连接的消费组是否需要从头开始消费
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

三、Spring boot配置连接kafka

1、配置yml配置文件

和原生的区别是把客户端交给spring来管理，通过yml进行配置。配置的参数名字也基本上都是一样的，参数也是一样的。

spring:
  kafka:
    bootstrap-servers: 10.211.55.6:9092
#    生产者
    producer:
      retries: 3 #设置大于0的值，则客户端会将发送失败的记录重新发送
      batch-size: 16384 #一次从缓冲区拉取的大小16k
      buffer-memory: 33554432 #本地缓冲区大小32m
      acks: 1
      #      编解码规则（默认）
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer
#     消费者
    consumer:
      group-id: default-group #消费组
      enable-auto-commit: false #手动提交
      auto-offset-reset: earliest  #新消费组从头消费
      #编解码规则
      key-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      value-deserializer: org.apache.kafka.common.serialization.StringDeserializer
      max-poll-records: 500  #一次拉取五百条

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

2、配置生产者

简单创建一个Controller用来生产消息

生产消息主要是通过kafkaTemplate模版类，

@RestController
@RequestMapping("/kafka")
public class KafkaController {

    private final static String TOPIC_NAME = "my-replicated-topic";

    @Resource
    private KafkaTemplate<String ,Object> kafkaTemplate;



    @PostMapping("/test")
    public String test(@RequestBody User user){
        JSONObject jsonObject = new JSONObject(user);
        ListenableFuture<SendResult<String, Object>> send = kafkaTemplate.send(TOPIC_NAME,0,"key", jsonObject.toString());

        return "成功！";
    }

}

3、配置消费者

可以通过ConsumerRecord一条一条的接收处理或者通过ConsumerRecords批量接收处理，但我们还是得for一条一条的处理，所以一般选择第一种就好

通过KafkaListener注解，配置接收的topics，以及消费者组id，以及一些其他的消费者信息

如： listenGroupPro方法的使用

@Slf4j
@Component
public class MySpringBootConsumer {

    /**
     * @param record:
     * @param ack:
     * @return void
     * 一次性读取一条，实际上也是一次性接收500条，然后一条消息回调一次，和下面的一样
     * @date 2024/3/26 21:12
     */
    @KafkaListener(topics = "my-replicated-topic",groupId = "testGroup")
    public void listenGroup(ConsumerRecord<String,String> record, Acknowledgment ack){
        log.info("testGroup收到的消息：partition = {};offset = {};key = {};value = {}"
                ,record.partition()
                ,record.offset()
                ,record.key()
                ,record.value());

//        手动提交ack，每处理完一条消息提交一次
        ack.acknowledge();
    }




    /**
     * @param records:
     * @param ack:
     * @return void
     * 一次性全部接收,指定分组和topic,和上面的区别是提交ack时机会不一样，
     * @date 2024/3/26 21:09
     */
    @KafkaListener(topics = "my-replicated-topic",groupId = "testGroup1")
    public void listenGroupS(ConsumerRecords<String,Object> records, Acknowledgment ack){
        for (ConsumerRecord<String,Object> record: records){
            log.info("testGroup1收到的消息：partition = {};offset = {};key = {};value = {}"
                    ,record.partition()
                    ,record.offset()
                    ,record.key()
                    ,record.value());
        }
//        手动提交ack，处理完records一批消息提交一次
        ack.acknowledge();
    }


    @KafkaListener(groupId = "testGroup2",topicPartitions = {
            @TopicPartition(topic = "my-replicated-topic2",partitions = {"0","1"}), //指定多个分区
            @TopicPartition(topic = "my-replicated-topic",partitions = "0",
                    partitionOffsets = @PartitionOffset(partition = "1",initialOffset = "5")) //从5号offset开始消费
    },concurrency = "3") //concurrency就是同区消费组下的消费者个数，建议小于分区总数
    public void listenGroupPro(ConsumerRecord<String,String> record, Acknowledgment ack){

        log.info("testGroup收到的消息：partition = {};offset = {};key = {};value = {};topic={}"
                ,record.partition()
                ,record.offset()
                ,record.key()
                ,record.value()
                ,record.topic());

//        手动提交ack，每处理完一条消息提交一次
        ack.acknowledge();
    }


}
方渐鸿
关注
  • 28
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot集成kafka全面实战
Felix
03-28 20万+
本文是SpringBoot+Kafka的实战讲解，如果对kafka的架构原理还不了解的读者，建议先看一下《大白话kafka架构原理》、《秒懂kafka HA（高可用）》两篇文章。 一、生产者实践 普通生产者 带回调的生产者 自定义分区器 kafka事务提交 二、消费者实践 简单消费 指定topic、partition、offset消费 ...
使用netty实现TCP长链接消息写入kafka以及kafka批量消费数据
07-20
标题"使用netty实现TCP长链接消息写入kafka以及kafka批量消费数据"揭示了这个项目的核心内容：通过Netty接收TCP长连接的数据，并将这些数据存储到Kafka中，同时利用Kafka的批量消费功能对数据进行处理。下面我们将...
springboot-kafka--消息队列
05-11
springboot集成kafka消息队列代码，可在上面进行二次开发。亲测有效，可以通过注释进行消息的接口
springboot-kafka
05-10
kafka生产者扫描任务表中数据写入kafka中，消费者根据不同的任务数据执行不同的业务逻辑
kafka安装配置及集成springboot
最新发布
qq_30166465的博客
05-13 699
启动生产者和消费者项目，浏览器输入http://127.0.0.1:8080/hello，发现消费者收到消息。浏览器输入http://127.0.0.1:8080/helloUser，发现消费者收到消息。方式二：可以把要传递的对象进行转json字符串，接收消息后再转为对象即可，这里采用这种方式。方式一：可以自定义序列化器，对象类型众多，这种方式通用性不强，这里不介绍。// 但是还是用不了eagle，不知道为啥，防火墙是已经关了。通常在监听类直接调用service方法。
SpringBoot——集成Kafka详解
吴声子夜歌的博客
08-21 2万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；若发送消息时未指定 patition，但指定了 key（kafka允许为每条消息设置一个key），则对key值进行hash计算，根据计算结果路由到指定分区，这种情况下可以保证同一个 Key 的所有消息都进入到相同的分区；
Springboot中使用kafka
热门推荐
DAMN WHERE'D YOU FIND THAT
03-23 2万+
首先说明，本人之前没用过zookeeper、kafka等，尚硅谷十几个小时的教程实在没有耐心看，现在我也不知道分区、副本之类的概念。用kafka只是听说他比RabbitMQ快，我也是昨天晚上刚使用，下文中若有讲错的地方或者我的理解与它的本质有偏差的地方请包涵。 此文背景的环境是windows，linux流程也差不多。 官网下载kafka，选择Binary downloads Apache Kafka 解压在D盘下或者什么地方，注意不要放在桌面等绝对路径太长的地方 打开conf
SpringBoot集成Kafka详解
qq_20865839的博客
10-20 1万+
我们知道，kafka中每个topic被划分为多个分区，那么生产者将消息发送到topic时，具体追加到哪个分区呢？这就是所谓的分区策略，Kafka 为我们提供了默认的分区策略，同时它也支持自定义分区策略。其路由机制为：1.若发送消息时指定了分区（即自定义分区策略），则直接将消息append到指定分区；
springboot 1.5.2 集成kafka的简单例子
08-28
SpringBoot 1.5.2 集成 Kafka 的简单例子 SpringBoot 1.5.2 版本发布...通过以上步骤，可以轻松地实现 SpringBoot 1.5.2 版本中的 Kafka 集成，使用 Spring Kafka 来发送和消费消息，提高系统的可扩展性和可靠性。
kafkaDemo.zip
02-21
本项目是一个SpringBoot的项目，关于Kafka的使用demo，包含了原生Kafka生产者消费者的创建及使用以及与Spring、Springboot结合的使用，旨在对Kafka从原生到与Spring结合的了解及使用。
springboot-ionic-backend
03-16
在Java领域，Spring Boot的核心特性包括自动配置、内嵌式Web服务器（如Tomcat或Jetty）、健康检查和Actuator监控、以及对各种第三方库的开箱即用支持，如数据访问（JPA，MyBatis）、消息处理（RabbitMQ，Kafka）和...
论坛：基于 SpringBoot + MyBatis + MySQL + Redis + Kafka + Elast.zip
02-03
这是一个基于一系列技术构建的论坛系统的设计方案，主要利用了SpringBoot、MyBatis、MySQL、Redis、Kafka和Elasticsearch等技术栈。下面将详细解释这些技术在论坛中的应用和重要性。 **SpringBoot** SpringBoot是...
Spring Boot 整合 kafka
qq_43842093的博客
04-25 4478
启动方式参考上一篇文章，
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
doxopcsdn的博客
07-01 4720
kafka是一个消息队列产品，基于Topic partitions的设计，能达到非常高的消息发送处理性能。Spring创建了一个项目Spring-kafka，封装了Apache 的Kafka-client，用于在Spring项目里快速集成kafka。除了简单的收发消息外，Spring-kafka还提供了很多高级功能，下面我们就来一一探秘这些用法。项目地址：https://github.com/spring-projects/spring-kafka。
SpringBoot项目集成kafka及常规配置
codeLife1993的博客
06-17 1万+
使用 spring-kafka 的api，在springboot项目中集成kafka能力，封装配置。
Springboot集成kafka(环境搭建+演示)|超级详细，建议收藏
SuiHao
03-03 1万+
上一期，我是带着大家入门了SpringBoot整合WebSocket，今天我再来一期kafka的零基础教学吧。不知道大家对kafka有多少了解，反正我就是从搭建开始，然后再加一个简单演示，这就算是带着大家了个门哈，剩下的我再后边慢慢出教程给大家说。/**log . info("topic.group1 消费了： Topic:" + topic + ",Message:" + msg);
springboot的kafka使用
Lemon_MY的博客
02-17 3016
springboot的kafka使用
SpringBoot 整合 Kafka
zhangyuanshuai的博客
06-03 2万+
环境 ZooKeeper、Kafka。 如果使用 docker-compose 部署 Kafka 集群，可以参考我的这篇文章 docker-compose安装Kafka集群 依赖 pom.xml 依赖文件如下：springboot 版本是 2.3.0.RELEASE 。 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <
springboot使用kafka
08-02
回答: 在Springboot中使用Kafka可以通过Springboot对Kafka的封装来实现。Springboot在Kafka的实现上做了很多的封装，使得在使用上更加方便。具体使用方法可以参考Springboot官网的文档进行了解。[1]在使用Kafka的过程中，需要注意版本兼容性的问题。主要的版本兼容体现在Springboot与Spring-Kafka之间，Spring-Kafka和Kafka-Client之间，以及Kafka-Client和Kafka服务端之间的兼容。可以参考Spring官网提供的兼容对比参照表来解决版本兼容性的问题。[2]如果需要更详细的示例和代码，可以参考Kafka官方网址和Spring-Kafka的Github地址。[3]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值