Kafka客户端API

最新推荐文章于 2025-02-25 07:43:38 发布
最新推荐文章于 2025-02-25 07:43:38 发布
阅读量1.2k 收藏 5
点赞数 2
分类专栏： # Kafka 文章标签： Kafka客户端API
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42402854/article/details/124994563
版权

创建项目，引入依赖：

        <!-- 引入Kafka依赖   -->
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>2.8.1</version>
        </dependency>

针对生产者和消费者使用进行示例演示。前面了解了Kafa服务安装和基本概念，接下来直接敲代码。

一、快速入门

创建一个 Order实体类，作为消息数据发送。

public class Order {

    private Integer orderId;
    private String orderDesc;
    private Double orderAmount;
    ...
}

1、生产者

生产者需要用到的几个类：

  • KafkaProducer： 需要一个生产者对象，用来发送数据。
  • ProducerConfig： 获取所需一系列配置参数。
  • ProducerRecord： 每条消息数据都要封装成一个 ProducerRecord对象。
public class Producer {

    private final static String TOPIC_NAME = "my-test-topic";
    private final static String KAFKA_SERVERS_CLUSTER_STR = "192.168.xxx.xxx:9092";//集群用逗号分隔

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // 1.设置生产者的配置信息
        Properties props = makeProducerProperties();

        // 2.创建生产者对象。通过配置信息
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(props);

        // 3.发送消息
        for (int i = 1; i <= 2; i++) {
            //3.1 构建消息数据
            Order order = new Order(i, "订单-" + i, 1000.00);
            //3.2 将消息数据封装成 ProducerRecord 对象
            //未指定发送分区
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(TOPIC_NAME
                    , order.getOrderId().toString(), JSON.toJSONString(order));

            //3.3 同步方式发送消息
            Future<RecordMetadata> future = producer.send(producerRecord);
            RecordMetadata metadata = future.get();
            System.out.println("同步方式发送消息结果：" + "topic-" + metadata.topic() + "|partition-"
                    + metadata.partition() + "|offset-" + metadata.offset());
            
        }

        TimeUnit.SECONDS.sleep(10);//方便异步测试
        //4.关闭资源
        producer.close();
    }

    /**
     * 设置生产者配置信息
     * @return
     */
    private static Properties makeProducerProperties() {
        Properties props = new Properties();
        //指定连接的 kafka集群
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_SERVERS_CLUSTER_STR);

        //key,value的序列化：这里把 key和 value从字符串序列化为字节数组
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        return props;
    }
}

2、消费者

消费者需要用到的类：

  • KafkaConsumer： 需要创建一个消费者对象，用来消费数据。
  • ConsumerConfig： 获取所需的一系列配置参数。
  • ConsumerRecord： 每条消息数据都要封装成一个 ConsumerRecord对象。
public class Consumer {

    private final static String TOPIC_NAME = "my-test-topic";
    private final static String CONSUMER_GROUP_NAME = "myTestGroup";
    private final static String KAFKA_SERVERS_CLUSTER_STR = "192.168.xxx.xxx:9092";//集群用逗号分隔

    public static void main(String[] args) {

        // 1.设置消费者的配置信息
        Properties props = makeConsumerProperties();

        // 2.创建消费者对象。通过配置信息
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);

        // 3.消费者对象订阅主题
        // 直接订阅主题
        consumer.subscribe(Arrays.asList(TOPIC_NAME));

        //4. 获取/消费消息
        while (true) {
            /**4.1 获取消费消息
             * poll()：表示拉取消息的长轮询
             */
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));

            //4.2 处理消息
            for (ConsumerRecord<String, String> record : records) {
                // 打印consumerRecords
                System.out.printf("收到消息：partition = %d,offset = %d, key = %s, value = %s%n", record.partition(),
                        record.offset(), record.key(), record.value());
            }
        }
    }

    /**
     * 设置消费者配置信息
     * @return
     */
    private static Properties makeConsumerProperties() {
        Properties props = new Properties();
        //指定连接的 kafka集群
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_SERVERS_CLUSTER_STR);
        // 消费分组名
        props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);

        //key,value的序列化：这里把 key和 value从字符串序列化为字节数组
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        return props;
    }
}

3、测试

运行消费者和生产者，消息发送和消息消费ok。
在这里插入图片描述

注意：

  • 主题和消费组不存在时，Kafka会自动创建。
  • 关于 消费者和生产者配置参数信息，如果你不设置，Kafka都有默认值。

关于API使用和配置参数详情可查看官方文档：还是很详细的

在这里插入图片描述

二、生产者

send()方法：其实是异步执行，返回一个 Future对象。
这个生产者写一条消息的时候，先是写到某个缓冲区， 这个缓冲区里的数据还没写到broker集群里的某个分区的时候，它就返回到client了。

1、同步发送

同步方式：根据 Future对象的特点，我们也可以实现同步发送的效果，只需在调用 Future对象的 get()方法即可。

			Future<RecordMetadata> future = producer.send(producerRecord);
			RecordMetadata metadata = future.get();

2、异步发送

异步方式：带回调函数的 API，回调函数会在 producer 收到 ack 时调用 onCompletion()方法。

            producer.send(producerRecord, new Callback() {
                /**
                 * onCompletion()方法有两个参数，分别是 RecordMetadata 和 Exception，
                 * @param metadata - RecordMetadata元数据
                 * @param exception - 如果 Exception为 null，说明消息发送成功，如果 Exception不为 null，说明消息发送失败。
                 */
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception != null) {
                        System.err.println("异步方式发送消息失败：" + exception.getStackTrace());

                    }
                    if (metadata != null) {
                        System.out.println("异步方式发送消息结果：" + "topic-" + metadata.topic() + "|partition-"
                                + metadata.partition() + "|offset-" + metadata.offset());
                    }
                }
            });

3、指定分区发送

将消息数据封装成 ProducerRecord 对象时，有多种构造方法使用，比如：

  • 指定发送分区
  • 未指定发送分区
            //3.2 将消息数据封装成 ProducerRecord 对象
            //指定发送分区
            /*ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(TOPIC_NAME, 0, order.getOrderId().toString(), JSON.toJSONString(order));*/
            //未指定发送分区，具体发送的分区计算公式：hash(key)%partitionNum
            ProducerRecord<String, String> producerRecord = new ProducerRecord<String, String>(TOPIC_NAME, order.getOrderId().toString(), JSON.toJSONString(order));

4、配置参数

部分参数说明：

    private static Properties makeProducerProperties() {
        Properties props = new Properties();
        //指定连接的 kafka集群
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_SERVERS_CLUSTER_STR);

        /*
            发出消息持久化机制参数
            （1）acks=0： 表示producer不需要等待任何broker确认收到消息的回复，就可以继续发送下一条消息。性能最高，但是最容易丢消息。
            （2）acks=1： 至少要等待leader已经成功将数据写入本地log，但是不需要等待所有follower是否成功写入。就可以继续发送下一
                 条消息。这种情况下，如果follower没有成功备份数据，而此时leader又挂掉，则消息会丢失。
            （3）acks=-1或all： 需要等待 min.insync.replicas(默认为1，推荐配置大于等于2) 这个参数配置的副本个数都成功写入日志，这种策略
                会保证只要有一个备份存活就不会丢失数据。这是最强的数据保证。一般除非是金融级别，或跟钱打交道的场景才会使用这种配置。
         */
        props.put(ProducerConfig.ACKS_CONFIG, "1");
        
        /*
            发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造成消息重复发送，比如网络抖动，
            所以需要在接收者那边做好消息接收的幂等性处理
        */
        props.put(ProducerConfig.RETRIES_CONFIG, 3);        
        //重试间隔设置,单位毫秒
        props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);
        
        //设置发送消息的本地缓冲区，如果设置了该缓冲区，消息会先发送到本地缓冲区，可以提高消息发送性能，默认值是33554432，即32MB
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);        
        /*
            kafka本地线程会从缓冲区取数据，批量发送到broker，
            设置批量发送消息的大小，默认值是16384，即16kb，就是说一个batch满了16kb就发送出去
        */
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        
        /*
            默认值是0，意思就是消息必须立即被发送，但这样会影响性能
            一般设置10毫秒左右，就是说这个消息发送完后会进入本地的一个batch，如果10毫秒内，这个batch满了16kb就会随batch一起被发送出去
            如果10毫秒内，batch没满，那么也必须把消息发送出去，不能让消息的发送延迟时间太长
        */
        props.put(ProducerConfig.LINGER_MS_CONFIG, 10);

        //key,value的序列化：这里把 key和 value从字符串序列化为字节数组
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        return props;
    }

三、消费者

1、自动提交

默认就是自动提交，也可以通过配置参数修改值：

        // 是否自动提交offset，默认就是true，推荐使用手动提交
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        // 自动提交offset的间隔时间
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");

2、手动提交

虽然自动提交 offset 十分简便，但由于其是基于时间提交的，开发人员难以把握 offset 提交的时机。因此 Kafka 提供了手动提交 offset 的 API。

手动提交 offset 的方法有两种：

  • commitSync（同步提交）
  • commitAsync（异步提交）

两者的相同点是：都会将本次拉取的一批数据最高的偏移量提交。
不同点是：commitSync 阻塞当前线程，一直到提交成功，并且会自动失败重试；而 commitAsync 则没有失败重试机制，故有可能提交失败。

操作如下：

首先，关闭自动提交配置参数：

//关闭自动提交,即手动提交 
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");

然后，我们手动提交消费消息：

            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(1000));

            //4.2 处理消息
            if (records.count() > 0) {
                // 手动同步提交offset，当前线程会阻塞直到offset提交成功
                // 一般使用同步提交，因为提交之后一般也没有什么逻辑代码了
                //consumer.commitSync();

                // 手动异步提交offset，当前线程提交offset不会阻塞，可以继续处理后面的程序逻辑
                consumer.commitAsync(new OffsetCommitCallback() {
                    @Override
                    public void onComplete(Map<TopicPartition, OffsetAndMetadata> offsets, Exception exception) {
                        if (exception != null) {
                            System.err.println("Commit failed for " + offsets);
                            System.err.println("Commit failed exception: " + exception.getStackTrace());
                        }
                    }
                });
            }

2.1 数据漏消费和重复消费分析：

无论是同步提交还是异步提交 offset，都有可能会造成数据漏消费或重复消费。

  • 先提交 offset 后消费，有可能造成数据的漏消费；
  • 先消费后提交 offset，有可能造成数据的重复消费。

3、消费者订阅主题

消费者对象订阅主题有多种方式：

  • 直接订阅主题
  • 指定分区订阅
  • 消息回溯消费订阅
  • 指定offset消费
  • 从指定时间点开始消费等等
        // 3.消费者对象订阅主题
        // 直接订阅主题
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        // 消费指定分区
        //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> topicPartitions = consumer.partitionsFor(TOPIC_NAME);
        //从1小时前开始消费
        long fetchDataTime = new Date().getTime() - 1000 * 60 * 60;
        Map<TopicPartition, Long> map = new HashMap<>();
        for (PartitionInfo par : topicPartitions) {
            map.put(new TopicPartition(TOPIC_NAME, par.partition()), fetchDataTime);
        }
        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();
            //根据消费里的timestamp确定offset
            if (value != null) {
                consumer.assign(Arrays.asList(key));
                consumer.seek(key, offset);
            }
        }*/

注意：消息回溯消费订阅，每次都会从头消费。理解它与 ConsumerConfig.AUTO_OFFSET_RESET_CONFIG = "earliest" 配置参数的区别。

4、配置参数

部分参数说明：

    private static Properties makeConsumerProperties() {
        Properties props = new Properties();
        //指定连接的 kafka集群
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, KAFKA_SERVERS_CLUSTER_STR);
        // 消费分组名
        props.put(ConsumerConfig.GROUP_ID_CONFIG, CONSUMER_GROUP_NAME);

       /* // 是否自动提交offset，默认就是true，推荐使用手动提交
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        // 自动提交offset的间隔时间
        props.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");*/
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");

        /*
            当消费主题的是一个新的消费组，或者指定offset的消费方式，offset不存在，那么应该如何消费
            latest(默认) ：只消费自己启动之后发送到主题的消息
            earliest：第一次从头开始消费，以后按照消费offset记录继续消费，这个需要区别于consumer.seekToBeginning(每次都从头开始消费)
        */
        //props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG, "earliest");

        /*
            consumer给broker发送心跳的间隔时间，broker接收到心跳，如果此时有rebalance发生会通过心跳响应将
            rebalance方案下发给consumer，这个时间可以稍微短一点
		*/
        props.put(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG, 1000);
        /*
            服务端broker多久感知不到一个consumer心跳就认为他故障了，会将其踢出消费组，
            对应的Partition也会被重新分配给其他consumer，默认是10秒
        */
        props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, 10 * 1000);

        //一次poll最大拉取消息的条数，如果消费者处理速度很快，可以设置大点，如果处理速度一般，可以设置小点
        props.put(ConsumerConfig.MAX_POLL_RECORDS_CONFIG, 50);
        /*
            如果两次poll操作间隔超过了这个时间，broker就会认为这个consumer处理能力太弱，
            会将其踢出消费组，将分区分配给别的consumer消费
        */
        props.put(ConsumerConfig.MAX_POLL_INTERVAL_MS_CONFIG, 30 * 1000);

        //key,value的序列化：这里把 key和 value从字符串序列化为字节数组
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        return props;
    }

关于 Kafka客户端：

通过使用 Properties来创建连接 kafka server的客户端AdminClient，它是一个抽象类，只有一个 KafkaAdminClient实现类。通过客户端AdminClient ，我们可以进行 Topic的CRUD等操作。

使用比较简单，可查看参考文章，博主写的很详细。

参考文章：

– 求知若饥，虚心若愚。

kafka客户端
09-04
1/kafka是一个分布式的消息缓存系统 2/kafka集群中的服务器都叫做broker 3/kafka有两类客户端，一类叫producer（消息生产者），一类叫做consumer（消息消费者），客户端和broker服务器之间采用tcp协议连接 4/kafka中不同业务系统的消息可以通过topic进行区分，而且每一个消息topic都会被分区，以分担消息读写的负载 5/每一个分区都可以有多个副本，以防止数据的丢失 6/某一个分区中的数据如果需要更新，都必须通过该分区所有副本中的leader来更新 7/消费者可以分组，比如有两个消费者组A和B，共同消费一个topic：order_info,A和B所消费的消息不会重复 比如 order_info 中有100个消息，每个消息有一个id,编号从0-99，那么，如果A组消费0-49号，B组就消费50-99号 8/消费者在具体消费某个topic中的消息时，可以指定起始偏移量 每个partition只能同一个group中的同一个consumer消费，但多个Consumer Group可同时消费同一个partition。 n个topic可以被n个Consumer Group消费，每个Consumer Group有多个Consumer消费同一个topic Topic在逻辑上可以被认为是一个queue，每条消费都必须指定它的Topic，可以简单理解为必须指明把这条消息放进哪个queue里。为了使得Kafka的吞吐率可以线性提高，物理上把Topic分成一个或多个Partition，每个Partition在物理上对应一个文件夹，该文件夹下存储这个Partition的所有消息和索引文件。若创建topic1和topic2两个topic，且分别有13个和19个分区 Kafka的设计理念之一就是同时提供离线处理和实时处理。根据这一特性，可以使用Storm这种实时流处理系统对消息进行实时在线处理，同时使用Hadoop这种批处理系统进行离线处理，还可以同时将数据实时备份到另一个数据中心，只需要保证这三个操作所使用的Consumer属于不同的Consumer Group即可。
kafka 客户端
12-11
kafka消息队列 监控界面 内含分区选择，topic选择，消息查看发送。操作简便。直接启动jar即可。
kafka客户端API
weixin_34245082的博客
06-08 138
Kafka Producer APIsProcuder API有两种：kafka.producer.SyncProducer和kafka.producer.async.AsyncProducer.它们都实现了同一个接口：classProducer {/* 将消息发送到指定分区 */publicvoidsend(kafka.javaapi.producer.Producer...
Kafka 基础教程 — 消费者API详解
最新发布
smart_an的专栏
02-25 811
Override//不做任何配置@Overrideint id;try {@Override//不需要关闭任何资源。
Kafka 处理器客户端介绍
weixin_33889245的博客
06-01 166
【编者按】本文作者为 Bill Bejeck，主要介绍如何有效利用新的 Apache Kafka 客户端来满足数据处理需求。文章系国内 ITOM 管理平台 OneAPM 编译呈现，以下为正文。 如果你使用的系统需要传输大量数据，就算你没用过 Kafka，很有可能已经听说过它了。从较高层面来说，Kafka 是一个对错误零容忍、分布式的发布订...
apache kafka系列之客户端开发-java
李志涛的专栏
07-15 2万+
kafka客户端开发,如果进行多线程并行消费数据。
beetle:一个不太疯狂的Kafka客户端API
05-11
在与一起分发的客户端库之上，Beetle是一种更高级别的Java API。 该库的目的不是要取代这些库的使用，而是将库包装在一个更易于使用的程序包中。 系统要求 JDK7或更高版本 骇客 该项目使用因此构建和测试应与执行...
Java高级Kafka客户端API Beetle概览
资源摘要信息:"beetle:一个不太疯狂的Kafka客户端API" 1. API简介与定位 - Beetle是一个高级别的Java API，它建立在现有的Kafka客户端库之上，以提供一个更易于使用和操作的程序包。 - 该API并不是为了取代现有的...
Kafka客户端producer/consumer样例
11-23
这些示例代码将直观地展示如何使用Kafka客户端API编写生产者和消费者的程序，从而帮助开发者理解并掌握如何使用Kafka进行消息的发送和接收。 开发者通过分析和运行这些样例代码，可以学习到如何创建Kafka生产者和...
phpkafka:PHP Kafka客户端用于PHP-FPM和Swoole。 PHP Kafka客户端支持50个API，这可能是有史以来支持最多消息类型的API
05-01
PHP Kafka客户端支持50个API，这可能是有史以来支持最多消息类型的API。 实现了消息的产生和消耗。 该组件正在开发和测试中。 特征 支持所有50种API 讯息压缩 兼容PHP-FPM和Swoole 制片人 消费者 SSL协议 ...
kafka客户端管理工具
07-17
《Kafka客户端管理工具详解》 在大数据处理领域，Apache Kafka作为一个分布式流处理平台，扮演着重要的角色。而为了高效地管理和操作Kafka集群，一套强大的客户端管理工具是必不可少的。本文将深入探讨Kafka客户端...
kafka-clients API demo conusmer provider group
08-26
kafka kafka-clients 0.10.0.0 API demo conusmer provider group
kafka-clients-0.10.0.1-API文档-中文版.zip
04-23
赠送jar包：kafka-clients-0.10.0.1.jar； 赠送原API文档：kafka-clients-0.10.0.1-javadoc.jar； 赠送源代码：kafka-clients-0.10.0.1-sources.jar； 赠送Maven依赖信息文件：kafka-clients-0.10.0.1.pom； 包含翻译后的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文档、中文版； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。
漫游Kafka实战篇clientAPI
weixin_34150830的博客
06-20 106
原文地址：http://blog.csdn.net/honglei915/article/details/37697655 Kafka Producer APIs 旧版的Procuder API有两种：kafka.producer.SyncProducer和kafka.producer.async.AsyncProducer.它们都实现了同一个接口： class Produc...
kafka API详解
热门推荐
.zz的博客
06-25 2万+
1. 生产者apiProducer是Kafka三大组件中的一个，用于发送消息到kafka集群中Producer提供了丰富的配置（见后面的配置项）用于控制它的行为在编码之前先使用命令创建topic./kafka-topics.sh --create --zookeeper hadoop01,hadoop02,hadoop03:2181 --partitions 2 --replication-fac...
Kafka API (Producer and Consumer)
沐雨金鳞
07-15 330
Producer API ：消息发送 Kafka的Producer发送消息采用的是异步发送的方式。 在消息发送的过程中，涉及到了两个线程——main线程和Sender线程，以及一个线程共享变量——RecordAccumulator。 main线程将消息发送给RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。 相关参数： batch.size：只有数据积累到batch.size...
Kafka Client API 基本使用
ZHBR_F1的博客
06-19 3915
之前讲过了Kafka基本概念及原理，这次我们来看看Kafka Client的API。要使用Kafka Client的API，首先需要先部署Kafka集群，部署过程请参见官网。然后在项目中添加Kafka Client的依赖，在这里我们使用0.10.0.1版本：<dependency> <groupId>org.apache.kafka</groupId> <artifactId>kaf
kafka kafka-clients 0.10.0.0 API
泽佑兄弟 ZYbros
08-26 8838
demo 结构 package com.zybros; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.Properties; import org.apache.kafka.clients.consumer.ConsumerRecord; import
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值