2、java调用kafka api

已于 2024-08-13 08:54:12 修改
阅读量5.2w 收藏 5
点赞数 1
分类专栏： # kafka专栏 文章标签： kafka java 分布式 大数据 数据分析
于 2023-05-09 16:07:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenwewi520feng/article/details/130577664
版权

Apache Kafka系列文章

1、kafka（2.12-3.0.0）介绍、部署及验证、基准测试
2、java调用kafka api
3、kafka重要概念介紹及示例
4、kafka分区、副本介绍及示例
5、kafka监控工具Kafka-Eagle介绍及使用

文章目录

本分介绍java调用kafka api。
本文前置条件是kafka环境搭建好。
本分五部分，即简单的写数据到kafka、从topic中消费数据、异步回调、读写kafka中复杂数据类型和读取历史数据。

一、生产消息到Kafka中

将1-100的数字消息写入到Kafka中。

1、POM依赖

导入Maven Kafka POM依赖

        <!-- kafka客户端工具 -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.4.1</version>
        </dependency>

        <!-- 工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-io</artifactId>
            <version>1.3.2</version>
        </dependency>

2、开发步骤

  1. 创建用于连接Kafka的Properties配置
  2. 创建一个生产者对象KafkaProducer
  3. 调用send发送1-100消息到指定Topic test，并获取返回值Future，该对象封装了返回值
  4. 再调用一个Future.get()方法等待响应
  5. 关闭生产者

3、代码

import java.util.Properties;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;


public class KafkaProducerTest {
    public static void main(String[] args) {
//            1. 创建用于连接Kafka的Properties配置
//            2. 创建一个生产者对象KafkaProducer
//            3. 调用send发送1-100消息到指定Topic test，并获取返回值Future，该对象封装了返回值
//            4. 再调用一个Future.get()方法等待响应
//            5. 关闭生产者
        // 1. 创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        props.put("bootstrap.servers", "server1:9092");
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 2. 创建一个生产者对象KafkaProducer
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);

        // 3. 调用send发送1-100消息到指定Topic test
        for (int i = 0; i < 100; ++i) {
            try {
                // 获取返回值Future，该对象封装了返回值
                Future<RecordMetadata> future = producer.send(new ProducerRecord<String, String>("test", null, i + ""));
                // 调用一个Future.get()方法等待响应
                future.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

        // 5. 关闭生产者
        producer.close();

    }
}

4、验证

通过客户端查看写入的内容
在这里插入图片描述

二、从Kafka的topic中消费消息

从 test topic中，将消息都消费，并将记录的offset、key、value打印出来

1、开发步骤

  1. 创建Kafka消费者配置
  2. 创建Kafka消费者
  3. 订阅要消费的主题
  4. 使用一个while循环，不断从Kafka的topic中拉取消息
  5. 将将记录（record）的offset、key、value都打印出来

2、代码


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

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;


public class KafkaConsumerTest {

    /**
     * @param args
     * @throws InterruptedException 
     */
    public static void main(String[] args) throws InterruptedException {
//        1.    创建Kafka消费者配置
//        2.    创建Kafka消费者
//        3.    订阅要消费的主题
//        4.    使用一个while循环，不断从Kafka的topic中拉取消息
//        5.    将将记录（record）的offset、key、value都打印出来

        // 1.创建Kafka消费者配置
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "server1:9092,server2:9092,server3:9092");
        // 消费者组（可以使用消费者组将若干个消费者组织到一起），共同消费Kafka中topic的数据
        // 每一个消费者需要指定一个消费者组，如果消费者的组名是一样的，表示这几个消费者是一个组中的
        props.setProperty("group.id", "test");
        // 自动提交offset
        props.setProperty("enable.auto.commit", "true");
        // 自动提交offset的时间间隔
        props.setProperty("auto.commit.interval.ms", "1000");
        // 拉取的key、value数据的
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        // 2.创建Kafka消费者
        KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<>(props);

        // 3. 订阅要消费的主题
        // 指定消费者从哪个topic中拉取数据
        kafkaConsumer.subscribe(Arrays.asList("test"));

        // 4.使用一个while循环，不断从Kafka的topic中拉取消息
        while (true) {
            // Kafka的消费者一次拉取一批的数据
            ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
            // 5.将将记录（record）的offset、key、value都打印出来
            for (ConsumerRecord<String, String> consumerRecord : consumerRecords) {
                // 主题
                String topic = consumerRecord.topic();
                // offset：这条消息处于Kafka分区中的哪个位置
                long offset = consumerRecord.offset();
                // key\value
                String key = consumerRecord.key();
                String value = consumerRecord.value();

                System.out.println("topic: " + topic + " offset:" + offset + " key:" + key + " value:" + value);
            }
            Thread.sleep(1000);
        }

    }

}

运行结果
在这里插入图片描述

三、异步使用带有回调函数方法生产消息

如果我们想获取生产者消息是否成功，或者成功生产消息到Kafka中后，执行一些其他动作。此时，可以很方便地使用带有回调函数来发送消息。

1、需求

  1. 在发送消息出现异常时，能够及时打印出异常信息

  2. 在发送消息成功时，打印Kafka的topic名字、分区id、offset

2、开发步骤

  1. 创建用于连接Kafka的Properties配置
  2. 创建一个生产者对象KafkaProducer
  3. 调用send发送1-100消息到指定Topic test，并在回调方法中打印异常信息或者打印topic、分区和offset
  4. 关闭生产者

3、代码

import java.util.Properties;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;


public class KafkaProducerTest2 {
    public static void main(String[] args) {
        // 1. 创建用于连接Kafka的Properties配置
        Properties props = new Properties();
        props.put("bootstrap.servers", "server1:9092");
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        // 2. 创建一个生产者对象KafkaProducer
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);

        // 3. 调用send发送1-100消息到指定Topic test
        for (int i = 0; i < 100; ++i) {
            // 一、同步方式
            // 获取返回值Future，该对象封装了返回值
            // Future<RecordMetadata> future = producer.send(new ProducerRecord<String,
            // String>("test", null, i + ""));
            // 调用一个Future.get()方法等待响应
            // future.get();

            // 二、带回调函数异步方式
            producer.send(new ProducerRecord<String, String>("test", null, i + ""), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception != null) {
                        System.out.println("发送消息出现异常");
                    } else {
                        String topic = metadata.topic();
                        int partition = metadata.partition();
                        long offset = metadata.offset();

                        System.out.println("发送消息到Kafka中的名字为" + topic + "的主题，第" + partition + "分区，第" + offset + "条数据成功!");
                    }
                }
            });
        }

        // 5. 关闭生产者
        producer.close();
    }

}

四、kafka中发送和消费复杂类型

1、需求

1、往kafka中写入user数据
2、消费kafka中user的数据
3、kafka的topic是userinfo

2、代码

1）、创建topic

kafka-topics.sh --create --bootstrap-server server1:9092 --topic userinfo --partitions 1 --replication-factor 1

2）、创建kafka序列化和反序列化方法

kafka本身已经实现了基本类型的序列化与反序列化，复杂类型则需要自己实现。
https://kafka.apache.org/31/javadoc/org/apache/kafka/common/serialization/package-summary.html
实现序列化与反序列化，主要是以字节流的形式读取和写入数据，然后实现kafka的序列化与反序列化的方法，最后在生产者或消费者中设置key、value的序列化与反序列化的类。

示例：

  • 生产者
// key的序列化，其类型是Integer
 props.put("key.serializer", "org.apache.kafka.common.serialization.IntegerSerializer");
 
// value的序列化，其类型是Object
props.put("value.serializer", "org.kafka.objectexample.util.EncodeingKafka");
  • 消费者
// key的反序列化，其类型是Integer 
 props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.IntegerDeserializer");
// value的反序列化，其类型是Object
props.setProperty("value.deserializer", "org.kafka.objectexample.util.DecodeingKafka");
1、将复杂类型和字节数字相互转换
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

  
public class BeanConversion {
    /**
     * 对象转字节数组
     * 
     * @param obj
     * @return
     */
    public static byte[] ObjectToBytes(Object obj) {
        byte[] bytes = null;
        ByteArrayOutputStream bo = null;
        ObjectOutputStream oo = null;
        try {
            bo = new ByteArrayOutputStream();
            oo = new ObjectOutputStream(bo);
            oo.writeObject(obj);
            bytes = bo.toByteArray();

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bo != null) {
                    bo.close();
                }
                if (oo != null) {
                    oo.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bytes;
    }

    /**
     * 字节数组转对象
     * 
     * @param bytes
     * @return
     */
    public static Object BytesToObject(byte[] bytes) {
        Object obj = null;
        ByteArrayInputStream bi = null;
        ObjectInputStream oi = null;
        try {
            bi = new ByteArrayInputStream(bytes);
            oi = new ObjectInputStream(bi);
            obj = oi.readObject();

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (bi != null) {
                    bi.close();
                }
                if (oi != null) {
                    oi.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return obj;
    }

}
2、实现kafka的序列化接口
import org.apache.kafka.common.serialization.Serializer;

public class EncodeingKafka implements Serializer<Object> {

    @Override
    public byte[] serialize(String topic, Object data) {
        return BeanConversion.ObjectToBytes(data);
    }

}
3、实现kafka的反序列化接口

import org.apache.kafka.common.serialization.Deserializer;

public class DecodeingKafka implements Deserializer<Object> {

    @Override
    public Object deserialize(String topic, byte[] data) {
        return BeanConversion.BytesToObject(data);
    }

}

3）、生产者发送数据

import java.util.Properties;
import java.util.concurrent.Future;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

public class KafkaProducerUser {
    public final static String TOPIC_NAME = "userinfo";

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.put("bootstrap.servers", "server1:9092");
        props.put("acks", "all");
        props.put("key.serializer", "org.apache.kafka.common.serialization.IntegerSerializer");
        props.put("value.serializer", "org.kafka.objectexample.util.EncodeingKafka");

        KafkaProducer producer = new KafkaProducer<Integer, User>(props);

        for (int i = 0; i < 100; i++) {
            User u = new User();
            u.setId(i * 3);
            u.setName("name" + i);
            if (i < 20) {
                u.setAge(i + 20);
            } else {
                u.setAge(i);
            }
   
            // public ProducerRecord(String topic, K key, V value)
            ProducerRecord<Integer, User> producerRecord = new ProducerRecord<Integer, User>(TOPIC_NAME, u.getId(), u);

            // send() 方法会返回一个包含 RecordMetadata 的
            // Future对象，不过因为我们会忽略返回值，所以无法知道消息是否发送成功。如果不关心发送结果，那么可以使用这种发送方式。
            Future<RecordMetadata> future = producer.send(producerRecord);
            // send() 方住先返回一个 Future对象，然后调用 Future对象的 get() 方法等待 Kafka 响应。如果服务器返回错误，
            // get()方怯会抛出异常。如果没有发生错误，我们会得到一个
            // RecordMetadata对象，可以用它获取消息的偏移量。如果在发送数据之前或者在发送过程中发生了任何错误 ，比如 broker返回
            // 了一个不允许重发消息的异常或者已经超过了重发的次数 ，那么就会抛出异常。

            RecordMetadata rm = future.get();
            System.out.println(rm.topic() + "  分区：" + rm.partition() + "  偏移量：" + rm.offset());
        }
        producer.close();

    }

}

4）、消费者消费数据

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

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;


public class kafkaConsumerUser {

    public final static String TOPIC_NAME = "userinfo";

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "server1:9092,server2:9092,server3:9092");

        props.setProperty("group.id", TOPIC_NAME);
        // 自动提交offset
        props.setProperty("enable.auto.commit", "true");
        // 自动提交offset的时间间隔
        props.setProperty("auto.commit.interval.ms", "1000");
        // 拉取的key、value数据的
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.IntegerDeserializer");
        props.setProperty("value.deserializer", "org.kafka.objectexample.util.DecodeingKafka");

        // 2.创建Kafka消费者
        KafkaConsumer<Integer, User> kafkaConsumer = new KafkaConsumer<>(props);

        // 3. 订阅要消费的主题
        // 指定消费者从哪个topic中拉取数据
        kafkaConsumer.subscribe(Arrays.asList(TOPIC_NAME));

        // 4.使用一个while循环，不断从Kafka的topic中拉取消息
        while (true) {
            // Kafka的消费者一次拉取一批的数据
            ConsumerRecords<Integer, User> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
            // 5.将将记录（record）的offset、key、value都打印出来
            for (ConsumerRecord<Integer, User> consumerRecord : consumerRecords) {
                // 主题
                String topic = consumerRecord.topic();
                // offset：这条消息处于Kafka分区中的哪个位置
                long offset = consumerRecord.offset();
                // key\value
                Integer key = consumerRecord.key();
                User value = consumerRecord.value();

                System.out.println("topic: " + topic + " offset:" + offset + " key:" + key + " value:" + value);
            }
            Thread.sleep(1000);
        }
    }

}

五、消费kafka topic中的历史数据

消费topic已经存在的数据。类似命令中–from-beginning 参数。

1、代码

在该服务启动前，如果topic中存在数据，是可以全部读出来，但如果topic数据部分已经被消费了，也会被读出来。

import java.time.Duration;
import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.Properties;

import org.apache.kafka.clients.consumer.ConsumerRebalanceListener;
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.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;


public class KafkaConsumerHistoryOfUser {
    public final static String TOPIC_NAME = "userinfo";

    public static void main(String[] args) throws Exception {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "server1:9092,server2:9092,server3:9092");
        props.setProperty("group.id", TOPIC_NAME);
        // 自动提交offset
        props.setProperty("enable.auto.commit", "true");
        // 自动提交offset的时间间隔
        props.setProperty("auto.commit.interval.ms", "1000");
        // 拉取的key、value数据的
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.IntegerDeserializer");
        props.setProperty("value.deserializer", "org.kafka.objectexample.util.DecodeingKafka");

        KafkaConsumer<Integer, User> kafkaConsumer = new KafkaConsumer<>(props);

        // 基于再均衡监听器，在给消费者分配分区的时候将消息偏移量跳转到起始位置
        kafkaConsumer.subscribe(Collections.singletonList(TOPIC_NAME), new ConsumerRebalanceListener() {
            @Override
            public void onPartitionsRevoked(Collection<TopicPartition> collection) {

            }

            @Override
            public void onPartitionsAssigned(Collection<TopicPartition> collection) {
                Map<TopicPartition, Long> beginningOffset = kafkaConsumer.beginningOffsets(collection);

                // 读取历史数据 --from-beginning
                for (Map.Entry<TopicPartition, Long> entry : beginningOffset.entrySet()) {
                    // 基于seek方法
                    // TopicPartition tp = entry.getKey();
                    // long offset = entry.getValue();
                    // consumer.seek(tp,offset);

                    // 基于seekToBeginning方法
                    kafkaConsumer.seekToBeginning(collection);
                }
            }
        });

        while (true) {
            // Kafka的消费者一次拉取一批的数据
            ConsumerRecords<Integer, User> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(5));
            // 5.将将记录（record）的offset、key、value都打印出来
            for (ConsumerRecord<Integer, User> consumerRecord : consumerRecords) {
                // 主题
                String topic = consumerRecord.topic();
                // offset：这条消息处于Kafka分区中的哪个位置
                long offset = consumerRecord.offset();
                // key\value
                Integer key = consumerRecord.key();
                User value = consumerRecord.value();

                System.out.println("topic: " + topic + " offset:" + offset + " key:" + key + " value:" + value);
            }
            Thread.sleep(1000);
        }

    }

}

以上示例简单的介绍了几种读写kafka数据的情况。

一瓢一瓢的饮 alanchanchn
关注
专栏目录
java调用kafka接口发送数据_Java调用Kafka生产者，消费者Api及相关配置说明
weixin_33209042的博客
02-26 1541
本次的记录内容包括：1.Java调用生产者APi流程2.Kafka生产者Api的使用及说明3.Kafka消费者Api的使用及说明4.Kafka消费者自动提交Offset和手动提交Offset5.自定义生产者的拦截器，分区器那么接下来我就带大家熟悉以上Kafka的知识说明1.Java调用生产者APi流程首先上一张从网上找的简单的图，来描述一下生产者的生产流程。这里这个的图描述的不是非常精确，稍微有点...
java代码调用kafka API实现消费数据
xiweihao的博客
03-07 2680
订阅主题 轮训消费数据 同步提交当前偏移量（后面的任务会阻塞） 异步提交当前偏移量 异步回调方式提交当前偏移量 同步和异步组合提交当前偏移量 提交特定的偏移量（在处理数据的总监提交偏移量） 原子性提交当前偏移量 调用消费者api获取数据 订阅主题，可以用正则表达式匹配，下面指定以test开始的主题都会监听。 轮训消费数据（一旦消费者订阅了主题，轮...
kafka的JavaAPI操作
MannerXu的博客
07-26 658
kafka的官方网站:http://kafka.apache.org/ 1、创建maven工程并添加jar包 <dependencies> <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients --> <dependency> <groupId&gt...
Kafka的JavaAPI操作
qq_45094921的博客
02-25 342
Kafka的JavaAPI操作 官网代码参考： 生产者：生产者 消费者：消费者 生产者代码： public class Producer { public static void main(String[] args) { //创建与kakfa的连接 Properties props = new Properties(); //broker的地址 ...
Kafka-2.11学习笔记（三）JavaApi访问kafka
weixin_34166472的博客
11-19 219
鲁春利的工作笔记，好记性不如烂笔头Kafka底层是基于Scala语言实现的，但是也提供了Java的API接口。Java实现的消息生产者packagecom.lucl.kafka.simple; importjava.util.Properties; importkafka.javaapi.producer.Producer; importkafka.produce...
Kafka API调用示例
漾漾
07-22 1558
1、调用代码示例 NewTopic alterReplicaLogDirs KafkaProducer package com.kafka.demo.producer; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.kaf...
Java API方式调用Kafka各种协议的方法
08-29
Java API方式调用Kafka各种协议的方法 Java API方式调用Kafka各种协议的方法是指使用Java语言编写的应用程序调用Kafka的协议来实现各种功能，例如发送消息、获取消息、提交位移、创建topic等。Kafka自己实现了一套...
kafka安装相关文件以及java调用kafka示例项目
11-04
在这个“kafka安装相关文件以及java调用kafka示例项目”中，我们包含了几个关键组件和示例，以便于理解和实践Kafka的使用。 首先，我们有Kafka的安装包，这通常包含服务器端的二进制文件，配置文件，以及必要的脚本...
Kafka Java API使用Demo
不清不慎的博客
07-20 3664
首先导入相关pom文件依赖，这里使用的kafak0.8.1，scala是2.10.4版本，注意导入正确的版本，与你的kafka集群版本相匹配。 pom.xml： &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schem...
KAFKA的JAVA使用api
小白菜呀
10-19 5209
一：引入KAFKA的jar包 （1）maven项目 在pom.xml里面加入下面的依赖： &lt;dependency&gt; &lt;groupId&gt;org.apache.kafka&lt;/groupId&gt; &lt;artifactId&gt;kafka_2.12&lt;/artifactId&gt; &lt;version&gt;1.1.1&lt;...
Kafka消费者JavaAPI Kafka生产者JavaAPI
tmlin0227的博客
09-04 700
package cn.edu360.kafka;import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Properties;import kafka.consumer.Consumer; import kafka.consumer.ConsumerConfig; imp
[Kafka] - Kafka Java Producer代码实现
weixin_30338481的博客
02-23 165
根据业务需要可以使用Kafka提供的Java Producer API进行产生数据，并将产生的数据发送到Kafka对应Topic的对应分区中，入口类为：Producer Kafka的Producer API主要提供下列三个方法： 　　public void send(KeyedMessage<K,V> message) 发送单条数据到Kafka集群 　　public void s...
kafka消费端（0.9.1）
Curtain
04-12 1292
转自：http://orchome.com/kafka/index 特别好的一篇文章，收藏。感谢原创作者 kafka客户端从kafka集群消费消息（记录）。它会透明地处理kafka集群中服务器的故障。它获取集群内数据的分区，也和服务器进行交互，允许消费者组进行负载平衡消费。（见下文）。 消费者维持TCP连接到必要的broker来获取消息。故障导致消费者关闭使用，会泄露这些连接
Kafka 面试题
longlongqin的博客
09-25 585
此时会有问题，当消费者刚拿到这个消息准备进行真正消费的时候，突然挂掉了，消息实际上并没有被消费，但是 offset 却被自动提交了。重试机制默认最多重试10次，每次重试的时间间隔为 0，即立即进行重试。：当没有明确指定 Partition 但消息有 key 时，Kafka 会计算 key 的哈希值，然后与该Topic 的分区数量取余，得到的余数就是要放入分区的ID。表示）：生产者发送消息后，需要等待所有的同步副本（In-Sync Replicas，ISR）都成功接收到消息后，才会收到来自服务器的确认响应。
Kafka 在 Linux 下的集群配置和安装
最新发布
J老熊
09-26 508
本文详细介绍了在 Linux 环境中配置和安装 Kafka 集群的过程，包括每个配置项的说明和常见故障的排查方法。通过这些步骤，您可以轻松地构建一个可靠的 Kafka 集群，支持大规模数据流处理和实时数据传输。希望这篇文章能够帮助您顺利搭建和管理 Kafka 集群。
大厂面试真题-Kafka如何保证消息不丢失
个人专长：数据结构和算法、大数据、数据库、主流框架
09-22 875
只有当 Follower 副本与 Leader 副本的差距不大时，才会将 Follower 副本重新加入 ISR，确保消息不会丢失。在 Kafka 中，每个分区都可以配置多个副本，每个副本保存分区的完整副本，当一个副本宕机时，Kafka 会自动将副本切换到其他可用的副本上。通过以上多种机制的综合运用，Kafka能够在很大程度上保证消息不会丢失，为数据的可靠传输和存储提供有力保障。Kafka 通过多种机制来确保消息不丢失，包括副本机制、ISR（In-Sync Replicas）机制、ACK 机制等。
Kafka
qq_59677536的博客
09-26 536
kafka消息队列
二、kafka生产与消费全流程
ALLWE的博客
09-26 405
在上面的demo中，由于消息的key和value都是String类型的，就可以使用kafka.client提供的String序列化器，如果想要发送其他自定义类型的对象，可以手动编写一个序列化器和反序列化器，实现Serializer接口，将对象和byte数组互相转换即可。提交最后一次消费消息的偏移量，下一次消费就从上次提交的偏移量开始，如果一个新的消费者群组消费一个主题的消息，可以根据不同的配置来指定起始的偏移量。群组之间的消费是互不干扰的，比如群组A的消费者和群组B的消费者可以同时消费同一个分区的消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一瓢一瓢的饮 alanchanchn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值