KAFKA-03-kafka基本API使用

已于 2022-08-11 09:58:58 修改
阅读量643 收藏 1
点赞数 2
分类专栏： # kafka 文章标签： kafka java 分布式
于 2022-05-10 14:29:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694906/article/details/124686322
版权

文章目录

1:topic操作api

1：pom.xml导包

 <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.2.0</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/log4j/log4j -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.25</version>
        </dependency>

2：创建topic

//配置连接参数
        Properties props = new Properties();
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        //可以用ip，前提是kafka服务器中server.properties中配置advertised.listeners=PLAINTEXT://192.168.138.128:9092
//        properties.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.138.128:9092");

        KafkaAdminClient adminClient= (KafkaAdminClient) KafkaAdminClient.create(props);
//创建Topics
        List<NewTopic> newTopics = Arrays.asList(new NewTopic("topic02", 2, (short) 3));

3：查看topic列表

//配置连接参数
        Properties props = new Properties();
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        //可以用ip，前提是kafka服务器中server.properties中配置advertised.listeners=PLAINTEXT://192.168.138.128:9092
//        properties.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.138.128:9092");

        KafkaAdminClient adminClient= (KafkaAdminClient) KafkaAdminClient.create(props);
//查询topics
        KafkaFuture<Set<String>> nameFutures = adminClient.listTopics().names();
        //加上get后就会同步
        for (String name : nameFutures.get()) {
            System.out.println(name);
        }

4：查看topic详情

//配置连接参数
        Properties props = new Properties();
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        //可以用ip，前提是kafka服务器中server.properties中配置advertised.listeners=PLAINTEXT://192.168.138.128:9092
//        properties.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.138.128:9092");

        KafkaAdminClient adminClient= (KafkaAdminClient) KafkaAdminClient.create(props);
 //查看Topic详情
        DescribeTopicsResult describeTopics =
                adminClient.describeTopics(Arrays.asList("topic01"));
        Map<String, TopicDescription> tdm = describeTopics.all().get();
        for (Map.Entry<String, TopicDescription> entry : tdm.entrySet()) {
            System.out.println(entry.getKey()+"\t"+entry.getValue());
        }

5：删除topic

//配置连接参数
        Properties props = new Properties();
        props.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "CentOSA:9092,CentOSB:9092,CentOSC:9092");
        //可以用ip，前提是kafka服务器中server.properties中配置advertised.listeners=PLAINTEXT://192.168.138.128:9092
//        properties.put(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.138.128:9092");

        KafkaAdminClient adminClient= (KafkaAdminClient) KafkaAdminClient.create(props);
//删除Topic
       // adminClient.deleteTopics(Arrays.asList("topic02"));

2：生产者和消费者

1：生产者

在这里插入图片描述

1：普通异步发送


public static void main(String[] args) throws InterruptedException {
        //1.创建链接参数
        Properties props=new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        //序列化key
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        //序列化value
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());

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

        //3.封账消息队列
        for(Integer i=0;i< 10;i++){
            Thread.sleep(100);
            ProducerRecord<String, String> record = new ProducerRecord<>("topic03", "key" + i, "value" + i);
            producer.send(record);
        }

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

2：带回调函数的异步发送

//带回调函数的异步发送
    public void test() throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();
        // 2. 给 kafka 配置对象添加配置信息
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "hadoop102:9092");
        // key,value 序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
                StringSerializer.class.getName());

        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
                StringSerializer.class.getName());
        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new
                KafkaProducer<String, String>(properties);
        // 4. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            // 添加回调
            kafkaProducer.send(new ProducerRecord<>("first",
                    "atguigu " + i), new Callback() {

                // 该方法在 Producer 收到 ack 时调用，为异步调用
                @Override
                public void onCompletion(RecordMetadata metadata,
                                         Exception exception) {
                    if (exception == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println(" 主题： " +
                                metadata.topic() + "->" + "分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
            // 延迟一会会看到数据发往不同分区
            Thread.sleep(2);
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }

3:同步发送

//同步发送
    public void test1() throws ExecutionException, InterruptedException {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();
        // 2. 给 kafka 配置对象添加配置信息

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092 ");
        // key,value 序列化（必须）：key.serializer，value.serializer
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
        // 4. 调用 send 方法,发送消息
        for (int i = 0; i < 10; i++) {
            // 异步发送 默认
            // kafkaProducer.send(new   ProducerRecord<> ("first", "kafka" + i));
            // 同步发送
            kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i)).get();
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }

4:prop参数名称 描述

  • bootstrap.servers 生产者连接集群所需的 broker 地 址 清 单 。 例 如hadoop102:9092,hadoop103:9092,hadoop104:9092，可以设置 1 个或者多个，中间用逗号隔开。注意这里并非需要所有的 broker 地址，因为生产者从给定的 broker里查找到其他 broker 信息。
  • key.serializer 和 value.serializer 指定发送消息的 key 和 value 的序列化类型。一定要写全类名。
  • buffer.memory RecordAccumulator 缓冲区总大小，默认 32m。
  • batch.size 缓冲区一批数据最大值，默认 16k。适当增加该值，可以提高吞吐量，但是如果该值设置太大，会导致数据传输延迟增加。
  • linger.ms 如果数据迟迟未达到 batch.size，sender 等待 linger.time之后就会发送数据。单位 ms，默认值是 0ms，表示没有延迟。生产环境建议该值大小为 5-100ms 之间。
  • acks 0：生产者发送过来的数据，不需要等数据落盘应答。
  • 1：生产者发送过来的数据，Leader 收到数据后应答。
  • -1（all）：生产者发送过来的数据，Leader+和 isr 队列里面的所有节点收齐数据后应答。默认值是-1，-1 和all 是等价的。
  • max.in.flight.requests.per.connection 允许最多没有返回 ack 的次数，默认为 5，开启幂等性
    要保证该值是 1-5 的数字。
  • retries 当消息发送出现错误的时候，系统会重发消息。retries表示重试次数。默认是 int 最大值，2147483647。如果设置了重试，还想保证消息的有序性，需要设置MAX_IN_FLIGHT_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候，其他的消息可能发送成功了。
  • retry.backoff.ms 两次重试之间的时间间隔，默认是 100ms。
  • enable.idempotence 是否开启幂等性，默认 true，开启幂等性。
  • compression.type 生产者发送的所有数据的压缩方式。默认是 none，也
    就是不压缩。支持压缩类型：none、gzip、snappy、lz4 和 zstd。

2：消费者

在这里插入图片描述

1:消费者组初始化流程

在这里插入图片描述
在这里插入图片描述

2：参数名称 描述

  • bootstrap.servers 向 Kafka 集群建立初始连接用到的 host/port 列表。
    *key.deserializer 和value.deserializer指定接收消息的 key 和 value 的反序列化类型。一定要写全
    类名。
  • group.id 标记消费者所属的消费者组。
  • enable.auto.commit 默认值为 true，消费者会自动周期性地向服务器提交偏移量。
  • auto.commit.interval.ms 如果设置了 enable.auto.commit 的值为 true， 则该值定义了消费者偏移量向 Kafka 提交的频率，默认 5s。
  • auto.offset.reset 当 Kafka 中没有初始偏移量或当前偏移量在服务器中不存在（如，数据被删除了），该如何处理？ earliest：自动重置偏移量到最早的偏移量。 latest：默认，自动重置偏移量为最
    新的偏移量。 none：如果消费组原来的（previous）偏移量不存在，则向消费者抛异常。 anything：向消费者抛异常。
  • offsets.topic.num.partitions __consumer_offsets 的分区数，默认是 50 个分区。
  • heartbeat.interval.ms Kafka 消费者和 coordinator 之间的心跳时间，默认 3s。该条目的值必须小于 session.timeout.ms ，也不应该高于session.timeout.ms 的 1/3。
  • session.timeout.ms Kafka 消费者和 coordinator 之间连接超时时间，默认 45s。超过该值，该消费者被移除，消费者组执行再平衡。
  • max.poll.interval.ms 消费者处理消息的最大时长，默认是 5 分钟。超过该值，该
    消费者被移除，消费者组执行再平衡。
  • fetch.min.bytes 默认 1 个字节。消费者获取服务器端一批消息最小的字节
    数。
  • fetch.max.wait.ms 默认 500ms。如果没有从服务器端获取到一批数据的最小字
    节数。该时间到，仍然会返回数据。
  • fetch.max.bytes 默认 Default: 52428800（50 m）。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值（50m）仍然可以拉取回来这批数据，因此，这不是一个绝对最大值。一批次的大小受 message.max.bytes （broker config）or max.message.bytes （topic config）影响。
  • max.poll.records 一次 poll 拉取数据返回消息的最大条数，默认是 500 条。

3:订阅主题

在这里插入图片描述

public static void main(String[] args) {
        //1.创建Kafka链接参数
        Properties props=new Properties();
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"group01");

        //2.创建Topic消费者
        KafkaConsumer<String,String> consumer=new KafkaConsumer<String, String>(props);
        //3.订阅topic开头的消息队列
        //这里可以传正则还可以直接传list
        consumer.subscribe(Pattern.compile("^topic.*$"));

        while (true){
            ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
            Iterator<ConsumerRecord<String, String>> recordIterator = consumerRecords.iterator();
            while (recordIterator.hasNext()){
                ConsumerRecord<String, String> record = recordIterator.next();
                String key = record.key();
                String value = record.value();
                long offset = record.offset();
                int partition = record.partition();
                System.out.println("key:"+key+",value:"+value+",partition:"+partition+",offset:"+offset);
            }
        }
    }

4：订阅分区

在这里插入图片描述

public void test(){
        Properties properties = new Properties();

        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
        // 配置序列化 必须
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());

        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                StringDeserializer.class.getName());
        // 配置消费者组（必须），名字可以任意起
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        KafkaConsumer<String, String> kafkaConsumer = new
                KafkaConsumer<>(properties);
        // 消费某个主题的某个分区数据
        ArrayList<TopicPartition> topicPartitions = new ArrayList<>();
        topicPartitions.add(new TopicPartition("first", 0));
        kafkaConsumer.assign(topicPartitions);
        while (true){
            ConsumerRecords<String, String> consumerRecords =
                    kafkaConsumer.poll(Duration.ofSeconds(1));
            for (ConsumerRecord<String, String> consumerRecord :
                    consumerRecords) {
                System.out.println(consumerRecord);
            }
        }
    }

3：自定义分区

1：系统默认分区策略

生产者在发送消息时，可以将消息发往不同的分区，我们系统默认的分区策略（DefaultPartitioner。）如下：

2：自定义分区策略

我们如果有需求，也可以自定义分区策略

1：分区策略默认实现Partitioner

package com.kafka.partitioner;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.utils.Utils;

import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

public class UserDefinePartitioner  implements Partitioner {
    private AtomicInteger atomicInteger=new AtomicInteger(0);
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        int numPartitions = cluster.partitionsForTopic(topic).size();
        if(keyBytes==null || keyBytes.length==0){
            return atomicInteger.addAndGet(1) & Integer.MAX_VALUE% numPartitions;
        } else {
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    @Override
    public void close() {
        System.out.println("close");
    }

    @Override
    public void configure(Map<String, ?> configs) {
        System.out.println("configure");
    }
}

2:使用自定义分区策略

package com.kafka.partitioner;

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.common.serialization.StringSerializer;

import java.util.Properties;

public class KafkaProducerDemo {
    public static void main(String[] args) {
        //1.创建链接参数
        Properties props=new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
        props.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,UserDefinePartitioner.class.getName());

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

        //3.封账消息队列
        for(Integer i=0;i< 10;i++){
            ProducerRecord<String, String> record = new ProducerRecord<>("topic01",  "value" + i);
            producer.send(record);
        }

        producer.close();
    }
}

4:序列化（重要）

因为kafka也是二进制安全的，即只接受二级制数据。所以我们传入的key和value都需要序列化

1：系统默认的序列化器

系统默认对所有基本类型都进行了序列化
在这里插入图片描述
以及反序列化器
在这里插入图片描述

2：自定义序列化

1：自定义序列化器

package com.kafka.serializer;

import org.apache.commons.lang3.SerializationUtils;
import org.apache.kafka.common.serialization.Serializer;

import java.io.Serializable;
import java.util.Map;

public class ObjectSerializer implements Serializer<Object> {

    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

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

    @Override
    public void close() {
        System.out.println("close");
    }
}

2:自定义反序列化器

package com.kafka.serializer;

import org.apache.commons.lang3.SerializationUtils;
import org.apache.kafka.common.serialization.Deserializer;

import java.util.Map;

public class ObjectDeserializer implements Deserializer<Object> {
    @Override
    public void configure(Map<String, ?> configs, boolean isKey) {
        System.out.println("configure");
    }

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

    @Override
    public void close() {
        System.out.println("close");
    }
}

3:使用序列化器

package com.kafka.serializer;

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.common.serialization.StringSerializer;

import java.util.Date;
import java.util.Properties;

public class KafkaProducerDemo {
    public static void main(String[] args) {
        //1.创建链接参数
        Properties props=new Properties();
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"CentOSA:9092,CentOSB:9092,CentOSC:9092");
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,ObjectSerializer.class.getName());

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

        //3.封账消息队列
        for(Integer i=0;i< 10;i++){
            ProducerRecord<String, User> record = new ProducerRecord<>("topic01", "key"+i,new User(i,"user"+i,new Date()));
            producer.send(record);
        }

        producer.close();
    }
}

5：拦截器（不重要）

拦截器可以对发送的消息进行处理，也可以对返回的消息ack等进行处理
1：自定义拦截器

package com.kafka.interceptors;

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

import java.util.Map;

public class UserDefineProducerInterceptor implements ProducerInterceptor {
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        ProducerRecord wrapRecord = new ProducerRecord(record.topic(), record.key(), record.value());
        wrapRecord.headers().add("user","mashibing".getBytes());
        return wrapRecord;

    }

    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        System.out.println("metadata:"+metadata+",exception:"+exception);
    }

    @Override
    public void close() {
        System.out.println("close");
    }

    @Override
    public void configure(Map<String, ?> configs) {
        System.out.println("configure");
    }
}
苍煜
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Kafka中文api使用介绍+配置
08-23
kafka中文api使用介绍+环境配置搭建，设计原理介绍，中英文对照版
五、Kafka API 接口
猿小许的博客
06-03 4971
Kafka有5个核心API： Producer API 允许应用程序发送数据流到kafka集群中的topic。 Consumer API 允许应用程序从kafka集群的topic中读取数据流。 Streams API 允许从输入topic转换数据流到输出topic。 Connect API 通过实现连接器（connector），不断地从一些源系统或应用程序中拉取数据到kafka，或从kafka提交数据到宿系统（sink system）或应用程序。 Admin API 用于管理和检查topic，br
Kafka元数据拉取流程
墨玉浮白的博客
11-28 1405
Kafka元数据拉取流程
Kafka的api总结
默主归沙的博客
02-15 519
生产者api 第一个案例 使用的一个消费者 kafka-console-consumer.sh --bootstrap-server qianfeng01:9092,qianfeng02:9092,qianfeng03:9092 --topic food 先运行idea中的生产者，然后再去集群中国运行一个消费者 查看消费者中的消息 package com.qf.kafka;import org.apache.kafka.clients.producer.KafkaProducer;import ..
kafka topic 管理api
诸葛子房的博客
09-27 197
1.使用AdminClient进行处理 2.topic 创建、删除等操作代码 pom文件 <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dep..
Kafka总结（五）：API编程详解
qq_36807862的博客
07-30 3025
Kafka总结（一）：Kafka概述 Kafka总结（二）：Kafka核心组件 Kafka总结（三）：Kafka核心流程分析 Kafka总结（四）：Kafka命令操作 Kafka总结（五）：API编程详解 Kafka总结（六）：Kafka Stream详解 Kafka总结（七）：数据采集应用 Kafka总结（八）：KafKa与ELK整合应用 Kafka总结（九）：KafKa 与Sp...
kafka-clients-2.4.1-API文档-中英对照版.zip
06-06
包含翻译后的API文档：kafka-clients-2.4.1-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.apache.kafka:kafka-clients:2.4.1； 标签：apache、kafka、clients、中英对照文档、jar包、java； 使用...
kafka-clients-2.0.0-API文档-中英对照版.zip
06-17
包含翻译后的API文档：kafka-clients-2.0.0-javadoc-API文档-中文(简体)-英语-对照版.zip； Maven坐标：org.apache.kafka:kafka-clients:2.0.0； 标签：apache、kafka、clients、中英对照文档、jar包、java； 使用...
kafka-clients-2.0.0-API文档-中文版.zip
06-26
包含翻译后的API文档：kafka-clients-2.0.0-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.kafka:kafka-clients:2.0.0； 标签：apache、kafka、clients、中文文档、jar包、java； 使用方法：解压翻译后...
kafka-clients-2.4.1-API文档-中文版.zip
06-06
包含翻译后的API文档：kafka-clients-2.4.1-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.kafka:kafka-clients:2.4.1； 标签：apache、kafka、clients、中文文档、jar包、java； 使用方法：解压翻译后...
kafka-clients-0.10.0.1-API文档-中文版.zip
04-23
包含翻译后的API文档：kafka-clients-0.10.0.1-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.apache.kafka:kafka-clients:0.10.0.1； 标签：apache、clients、kafka、jar包、java、API文档、中文版； 使用...
Kafka API详解
@小刘同学nice
06-22 2499
Producer API 消息发送流程 Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。 相关参...
Apache Kafka 入门 - Kafka API 简单用法
热门推荐
偶尔记一下 - mybatis.io
06-27 1万+
Apache Kafka 入门 Kafka的基本配置和运行 Kafka命令详细介绍 Kafka-manager的基本配置和运行 Kafka API 简单用法 Spring Boot 集成Kafka 本篇为第四篇。Kafka API 简单用法本篇会用到以下依赖：<dependency> <groupId>org.apache.kafka</groupId> <artifactId>ka
kafkaAPI使用以及常用配置介绍
嘎嘎的博客
08-14 2799
这篇文章主要介绍kafka中JAVA API的使用，这里面为了介绍配置，所以使用的是原生的javaapi操作，kafka可以与spring通过xml配置集成，或者更加简单通过spring boot引入starter，通过（AutoConfiguration）自动配置完成集成。但其实无论何种使用方式，其根本都是使用原生pai进行操作。 使用maven依赖管理，引入kafka依赖 &lt...
Kafka的常用API使用之Java教程
IT- 研究者
07-02 210
一、消息发送 1.异步发送 1）导入依赖 <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>0.11.0.0</version> </dependency> 2）编写代码 需要用到的类： KafkaProducer：需要创建一个生产者对象，用来发送数据 P
第二天：Kafka API操作
sowhat
06-28 7350
API 消息发送流程 Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。 相关参数： batch.size：只有数据积累到batch.size之后，sender才会发送数据。 linger.ms：如果数据迟迟未
【Kafka】知识点（二）Kafka API的使用
qq_42176514的博客
12-09 1000
问题1：如果在业务中，高并发的写请求特别多，应该怎么办？ 高并发的读请求多的时候，引入MQ消息队列来解决高并发的写请求问题。 一、Kafka概念：Producer、Broker、Consumer Producer
Kafka的java api 操作（一）
RJSong
03-12 2784
1、创建java的maven工程2、引入依赖   3、编写测试类package com.motoon; import kafka.admin.AdminUtils; import kafka.admin.RackAwareMode; import kafka.server.ConfigType; import kafka.utils.ZkUtils; import org.apache.kafk...
Kafka API AdminClient基本使用
余金兑人的技术角落
11-16 4257
目前 Kafka 提供了一个新的 API 工具 AdminClient。通过SpringBoot集成AdminClient可以进行kafka的管理。实现了查询、新建、删除topic、调整partition、获取lag、配置信息等常用功能。通过这些功能可以为业务人员构建一个简单的kafka管理界面。 pom <dependency> <groupId>org.springframework.kafka</groupId> <artifactId&
查看kafka-server-start.sh路径
最新发布
06-03
connect-standalone.sh kafka-broker-api-versions.sh kafka-consumer-groups.sh kafka-producer-perf-test.sh kafka-server-stop.sh kafka-verifiable-consumer.sh zookeeper-security-migration.sh ``` 其中，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

苍煜

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

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

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

打赏作者

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

抵扣说明：

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

余额充值