4、Kafka API实战

最新推荐文章于 2024-09-06 10:37:30 发布
最新推荐文章于 2024-09-06 10:37:30 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： Kafka入坑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZJ__ZFH/article/details/86578151
版权

环境准备

  1. 启动zookeeper集群和kafka集群，在kafka集群中打开一个消费者
    [hadoop@hadoop-100 kafka]$ zkservers start
    [hadoop@hadoop-100 kafka]$ zkservers status
    [hadoop@hadoop-100 kafka]$ mykafka start
    [hadoop@hadoop-100 kafka]$ myjps
    [hadoop@hadoop-100 kafka]$ bin/kafka-console-consumer.sh --zookeeper hadoop-100:2181 --topic first
  2. 导入pom依赖
<dependencies>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
        <version>0.11.0.0</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka -->
    <dependency>
        <groupId>org.apache.kafka</groupId>
        <artifactId>kafka_2.12</artifactId>
        <version>0.11.0.0</version>
    </dependency>
</dependencies>

Kafka生产者Java API

创建生产者（过时的API）

package com.zj.producer;

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;
import java.util.List;
import java.util.Properties;

public class OldProducer {
    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("metadata.broker.list", "hadoop-100:9092");
        properties.put("request.required.acks", "1");
        properties.put("serializer.class", "kafka.serializer.StringEncoder");
        Producer<Integer, String> producer = new Producer<>(new ProducerConfig(properties));
        KeyedMessage<Integer, String> message = new KeyedMessage<Integer, String>("first","hello api");
        producer.send(message);
    }
}

创建生产者（新API）

package com.zj.producer;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;

public class NewProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "hadoop-100:9092");
        // 等待所有副本节点的应答
        props.put("acks", "all");
        // 消息发送最大尝试次数
        props.put("retries", 0);
        // 一批消息处理大小
        props.put("batch.size", 16384);
        // 请求延时
        props.put("linger.ms", 1);
        // 发送缓存区内存大小
        props.put("buffer.memory", 33554432);
        // key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value序列化
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("first", Integer.toString(i), Integer.toString(i)));
        }
        producer.close();
    }
}

创建生产者带回调函数（新API）

package com.zj.producer;

import org.apache.kafka.clients.producer.*;
import java.util.Properties;

public class NewProducerWithCallBack {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "hadoop-100:9092");
        // 等待所有副本节点的应答
        props.put("acks", "all");
        // 消息发送最大尝试次数
        props.put("retries", 0);
        // 一批消息处理大小
        props.put("batch.size", 1);
        // 请求延时
        props.put("linger.ms", 1);
        // 发送缓存区内存大小
        props.put("buffer.memory", 33554432);
        // key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value序列化
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String, String> producer = new KafkaProducer<>(props);
        for (int i = 0; i < 100; i++) {
            producer.send(new ProducerRecord<String, String>("second", Integer.toString(i), "hello" + Integer.toString(i)), new Callback() {

                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if(metadata != null) {
                        System.out.println(metadata.partition() + "," + metadata.offset());
                    }
                }
            });
        }
        producer.close();
    }
}

自定义分区生产者

需求，将所有数据存储到topic的第0号分区上
定义一个类实现Partitioner接口，重写里面的方法（过时API）

package com.zj.producer.partition;

import kafka.producer.Partitioner;
import kafka.utils.VerifiableProperties;

public class OldApiMyPartition implements Partitioner {

    public OldApiMyPartition(VerifiableProperties props) {
    }

    @Override
    public int partition(Object key, int numPartitions) {
        return 0;
    }
}

自定义分区（新API）

package com.zj.producer.partition;

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

import java.util.Map;

public class NewApiMyPartition implements Partitioner {

    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        return 0;
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {

    }
}

在代码中调用，新API

package com.zj.producer;

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

import java.util.Properties;

public class ProducerWithPartition {
    public static void main(String[] args) {

        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "hadoop-102:9092");
        // 等待所有副本节点的应答
        props.put("acks", "all");
        // 消息发送最大尝试次数
        props.put("retries", 0);
        // 一批消息处理大小
        props.put("batch.size", 16384);
        // 增加服务端请求延时
        props.put("linger.ms", 1);
        // 发送缓存区内存大小
        props.put("buffer.memory", 33554432);
        // key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // value序列化
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        // 自定义分区
        props.put("partitioner.class", "com.zj.producer.partition.NewApiMyPartition");
        Producer<String, String> producer = new KafkaProducer<>(props);
        producer.send(new ProducerRecord<String, String>("second", "1", "hhh555"));
        producer.close();
    }
}

在代码中调用，旧API

package com.zj.producer;

import kafka.javaapi.producer.Producer;
import kafka.producer.KeyedMessage;
import kafka.producer.ProducerConfig;
import java.util.Properties;

public class OldApiProducerWithPartition {

    public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put("metadata.broker.list", "hadoop-100:9092");
        properties.put("request.required.acks", "1");
        properties.put("serializer.class", "kafka.serializer.StringEncoder");
        properties.put("partitioner.class", "com.zj.producer.partition.OldApiMyPartition");
        Producer<Integer, String> producer = new Producer<>(new ProducerConfig(properties));
        KeyedMessage<Integer, String> message = new KeyedMessage<Integer, String>("first","hello api");
        producer.send(message);
    }
}

Kafka消费者Java API

高级API

创建消费者（过时API）

package com.zj.consumer;

import kafka.consumer.Consumer;
import kafka.consumer.ConsumerConfig;
import kafka.consumer.ConsumerIterator;
import kafka.consumer.KafkaStream;
import kafka.javaapi.consumer.ConsumerConnector;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;

public class HighOldApiConsumer {
    public static void main(String[] args) {
        Properties properties = new Properties();

        properties.put("zookeeper.connect", "hadoop-100:2181");
        properties.put("group.id", "test1");
        properties.put("zookeeper.session.timeout.ms", "500");
        properties.put("zookeeper.sync.time.ms", "250");
        properties.put("auto.commit.interval.ms", "1000");

        // 创建消费者连接器
        ConsumerConnector consumer = Consumer.createJavaConsumerConnector(new ConsumerConfig(properties));

        HashMap<String, Integer> topicCount = new HashMap<>();
        topicCount.put("first", 1);

        Map<String, List<KafkaStream<byte[], byte[]>>> consumerMap = consumer.createMessageStreams(topicCount);

        KafkaStream<byte[], byte[]> stream = consumerMap.get("first").get(0);

        ConsumerIterator<byte[], byte[]> it = stream.iterator();

        while (it.hasNext()) {
            System.out.println(new String(it.next().message()));
        }
    }
}

低级API

实现使用低级API读取指定topic，指定partition,指定offset的数据

消费者使用低级API 的主要步骤

  1. 根据指定的分区从主题元数据中找到主副本
  2. 获取分区最新的消费进度
  3. 从主副本拉取分区的消息
  4. 识别主副本的变化，重试

方法描述
findLeader()，客户端向种子节点发送主题元数据，将副本集加入备用节点
getLastOffset()，消费者客户端发送偏移量请求，获取分区最近的偏移量
run()，消费者低级AP I拉取消息的主要方法
findNewLeader()，当分区的主副本节点发生故障，客户将要找出新的主副本

package com.zj.consumer;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
import kafka.api.PartitionOffsetRequestInfo;
import kafka.cluster.BrokerEndPoint;
import kafka.common.ErrorMapping;
import kafka.common.TopicAndPartition;
import kafka.javaapi.FetchResponse;
import kafka.javaapi.OffsetResponse;
import kafka.javaapi.PartitionMetadata;
import kafka.javaapi.TopicMetadata;
import kafka.javaapi.TopicMetadataRequest;
import kafka.javaapi.consumer.SimpleConsumer;
import kafka.message.MessageAndOffset;


public class LowerConsumer {
    private List<String> mReplicaBrokers = new ArrayList<>();

    public LowerConsumer() {
        mReplicaBrokers = new ArrayList<>();
    }

    public static void main(String args[]) {
        LowerConsumer lowerConsumer = new LowerConsumer();
        // 最大读取消息数量
        long maxReads = Long.parseLong("3");
        // 要订阅的topic
        String topic = "first";
        // 要查找的分区
        int partition = Integer.parseInt("0");
        // broker节点的ip
        List<String> seeds = new ArrayList<>();
        seeds.add("192.168.114.100");
        seeds.add("192.168.114.101");
        seeds.add("192.168.114.102");
        // 端口
        int port = Integer.parseInt("9092");
        try {
            lowerConsumer.run(maxReads, topic, partition, seeds, port);
        } catch (Exception e) {
            System.out.println("Oops:" + e);
            e.printStackTrace();
        }
    }

    public void run(long aMaxReads, String aTopic, int aPartition, List<String> aSeedBrokers, int aPort) throws Exception {
        // 获取指定Topic partition的元数据
        PartitionMetadata metadata = findLeader(aSeedBrokers, aPort, aTopic, aPartition);
        if (metadata == null) {
            System.out.println("Can't find metadata for Topic and Partition. Exiting");
            return;
        }
        if (metadata.leader() == null) {
            System.out.println("Can't find Leader for Topic and Partition. Exiting");
            return;
        }
        String leadBroker = metadata.leader().host();
        String clientName = "Client_" + aTopic + "_" + aPartition;

        SimpleConsumer consumer = new SimpleConsumer(leadBroker, aPort, 100000, 64 * 1024, clientName);
        long readOffset = getLastOffset(consumer, aTopic, aPartition, kafka.api.OffsetRequest.EarliestTime(), clientName);
        int numErrors = 0;
        while (aMaxReads > 0) {
            if (consumer == null) {
                consumer = new SimpleConsumer(leadBroker, aPort, 100000, 64 * 1024, clientName);
            }
            FetchRequest req = new FetchRequestBuilder().clientId(clientName).addFetch(aTopic, aPartition, readOffset, 100000).build();
            FetchResponse fetchResponse = consumer.fetch(req);

            if (fetchResponse.hasError()) {
                numErrors++;
                // Something went wrong!
                short code = fetchResponse.errorCode(aTopic, aPartition);
                System.out.println("Error fetching data from the Broker:" + leadBroker + " Reason: " + code);
                if (numErrors > 5) {
                    break;
                }
                if (code == ErrorMapping.OffsetOutOfRangeCode()) {
                    // We asked for an invalid offset. For simple case ask for
                    // the last element to reset
                    readOffset = getLastOffset(consumer, aTopic, aPartition, kafka.api.OffsetRequest.LatestTime(), clientName);
                    continue;
                }
                consumer.close();
                consumer = null;
                leadBroker = findNewLeader(leadBroker, aTopic, aPartition, aPort);
                continue;
            }
            numErrors = 0;

            long numRead = 0;
            for (MessageAndOffset messageAndOffset : fetchResponse.messageSet(aTopic, aPartition)) {
                long currentOffset = messageAndOffset.offset();
                if (currentOffset < readOffset) {
                    System.out.println("Found an old offset: " + currentOffset + " Expecting: " + readOffset);
                    continue;
                }
                readOffset = messageAndOffset.nextOffset();
                ByteBuffer payload = messageAndOffset.message().payload();

                byte[] bytes = new byte[payload.limit()];
                payload.get(bytes);
                System.out.println(String.valueOf(messageAndOffset.offset()) + ": " + new String(bytes, "UTF-8"));
                numRead++;
                aMaxReads--;
            }

            if (numRead == 0) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ie) {
                }
            }
        }
        if (consumer != null)
            consumer.close();
    }

    public static long getLastOffset(SimpleConsumer consumer, String topic, int partition, long whichTime, String clientName) {
        TopicAndPartition topicAndPartition = new TopicAndPartition(topic, partition);
        Map<TopicAndPartition, PartitionOffsetRequestInfo> requestInfo = new HashMap<TopicAndPartition, PartitionOffsetRequestInfo>();
        requestInfo.put(topicAndPartition, new PartitionOffsetRequestInfo(whichTime, 1));
        kafka.javaapi.OffsetRequest request = new kafka.javaapi.OffsetRequest(requestInfo, kafka.api.OffsetRequest.CurrentVersion(), clientName);
        OffsetResponse response = consumer.getOffsetsBefore(request);

        if (response.hasError()) {
            System.out.println("Error fetching data Offset Data the Broker. Reason: " + response.errorCode(topic, partition));
            return 0;
        }
        long[] offsets = response.offsets(topic, partition);
        return offsets[0];
    }


    private String findNewLeader(String a_oldLeader, String aTopic, int aPartition, int aPort) throws Exception {
        for (int i = 0; i < 3; i++) {
            boolean goToSleep = false;
            PartitionMetadata metadata = findLeader(mReplicaBrokers, aPort, aTopic, aPartition);
            if (metadata == null) {
                goToSleep = true;
            } else if (metadata.leader() == null) {
                goToSleep = true;
            } else if (a_oldLeader.equalsIgnoreCase(metadata.leader().host()) && i == 0) {
                // first time through if the leader hasn't changed give
                // ZooKeeper a second to recover
                // second time, assume the broker did recover before failover,
                // or it was a non-Broker issue
                //
                goToSleep = true;
            } else {
                return metadata.leader().host();
            }
            if (goToSleep) {
                Thread.sleep(1000);
            }
        }
        System.out.println("Unable to find new leader after Broker failure. Exiting");
        throw new Exception("Unable to find new leader after Broker failure. Exiting");
    }

    private PartitionMetadata findLeader(List<String> aSeedBrokers, int aPort, String aTopic, int aPartition) {
        PartitionMetadata returnMetaData = null;
        loop:
        for (String seed : aSeedBrokers) {
            SimpleConsumer consumer = null;
            try {
                consumer = new SimpleConsumer(seed, aPort, 100000, 64 * 1024, "leaderLookup");
                List<String> topics = Collections.singletonList(aTopic);
                TopicMetadataRequest req = new TopicMetadataRequest(topics);
                kafka.javaapi.TopicMetadataResponse resp = consumer.send(req);

                List<TopicMetadata> metaData = resp.topicsMetadata();
                for (TopicMetadata item : metaData) {
                    for (PartitionMetadata part : item.partitionsMetadata()) {
                        if (part.partitionId() == aPartition) {
                            returnMetaData = part;
                            break loop;
                        }
                    }
                }
            } catch (Exception e) {
                System.out.println("Error communicating with Broker [" + seed + "] to find Leader for [" + aTopic + ", " + aPartition + "] Reason: " + e);
            } finally {
                if (consumer != null) {
                    consumer.close();
                }
            }
        }
        if (returnMetaData != null) {
            mReplicaBrokers.clear();
            for (BrokerEndPoint replica : returnMetaData.replicas()) {
                mReplicaBrokers.add(replica.host());
            }
        }
        return returnMetaData;
    }
}
ZFH__ZJ
关注
专栏目录
Kafka API实战
悦分享
09-05 265
消息队列内部实现原理：（1）点对点模式（一对一，消费者主动拉取数据，消息收到后消息清除）点对点模型通常是一个基于拉取或者轮询的消息传送模型，这种模型从队列中请求信息，而不是将消息推送到客户端。这个模型的特点是发送到队列的消息被一个且只有一个接收者接收处理，即使有多个消息监听者也是如此。（2）发布/订阅模式（一对多，数据生产后，推送给所有订阅者）发布订阅模型则是一个基于推送的消息传送模型。
从小白的角度讲解kafka并使用java、python_API实战
热门推荐
weixin_43178406的博客
04-29 5万+
1. 什么是kafka 1.1 基本概述 1.2 深度讲解 2. kafka的安全机制 3. python_API 3.1 作为生产者连接kafka并发送数据
官宣：教父级讲师李明加入尚硅谷
尚硅谷铁杆粉丝的博客
01-17 5599
今天，2019年1月15日，教育培训行业又有大事件发生——教父级讲师、职场导师：李明，正式加入尚硅谷！随着李明老师的到来，尚硅谷师资团队更加星光璀璨：佟刚、韩顺平、李明、宋红康、周阳……你知道的技术大牛，均已在尚硅谷亲执教鞭。风云际会，大咖面授，堪称学子们难得的机遇。 李明，昵称“明哥”，久负盛名的Linux/LAMP技术大牛、教父级讲师、职场导师。国内早期的UNIX/Linux从业者，中国UN...
大数据Hadoop之——Kafka API介绍与实战操作
匠人精神，持之以恒！
06-25 891
Kafka包括五个核心api：Java 客户端接口文档：https://kafka.apache.org/32/javadoc/index.html?org/apache/kafka/clients/producer/KafkaProducer.html 非 Java 客户端接口文档：https://cwiki.apache.org/confluence/display/KAFKA/Clients使用java kafka需引入依赖： slf4j-api、slf4j-log4j12、log4j三者之间的关系如
Kafka之 API实战
libotao的博客
11-03 129
Kafka之 API实战 一、环境准备 　　1)启动zk和kafka集群，在kafka集群中打开一个消费者 [hadoop1 kafka]$ bin/kafka-console-consumer.sh \ --zookeeper hadoop1:2181 --topic first 　　2)导入pom依赖 <dependency> <groupId>org...
四、Kafka API 实战
weixin_30552635的博客
09-19 182
四 Kafka API 实战 　　4.1 环境准备 　　　　　　　　1）在 eclipse 中创建一个 java 工程 　　　　　　　　2）在工程的根目录创建一个 lib 文件夹 　　　　　　　　3）解压 kafka 安装包，将安装包 libs 目录下的 jar 包拷贝到工程的 lib 目录下，并 build path。 　　　　　　　　 4）启动 zk 和 kafka...
Kafka管理员API实战指南
最新发布
m0_62153576的博客
09-06 479
通过以上示例，我们可以看到 Kafka Admin API 提供了一种强大的方式来管理和操作 Kafka 集群。无论是查看配置、列出主题还是创建新主题，Admin API 都提供了简洁的接口来实现这些功能。在实际的开发和运维工作中，合理利用这些 API 可以大大提高我们的工作效率。
Kafka 实战指南——Kafka API 实战
dwjf321的博客
03-02 255
文章目录1. 环境准备2. 生产者 Java API3. 自定义分区4. Kafka 消费者 Java API 1. 环境准备 创建 maven 工程，添加依赖： <dependency> <groupId>org.apache.kafka</groupId> <artifactId>kafka-clients</artifactId> <version>2.1.0</version> </de
kafka java实战_kafka实战
weixin_42406647的博客
02-25 1424
1. kafka介绍1.1. 主要功能根据官网的介绍，ApacheKafka®是一个分布式流媒体平台，它主要有3种功能：1：It lets you publish and subscribe to streams of records.发布和订阅消息流，这个功能类似于消息队列，这也是kafka归类为消息队列框架的原因2：It lets you store streams o...
第11单元 KafkaApi实战1
08-08
本单元主要聚焦于Kafka API的实战，包括Kafka生产者、消费者API的使用，以及Kafka消息的生产和消费过程分析。 ### 1. Kafka生产者 Java API Kafka生产者API允许开发者将消息发布到主题（Topic）。Spring框架提供了...
kafka实战pdf
05-07
4. **生产者API**：学习如何使用Java或Scala等语言的Kafka生产者API，发送消息到Kafka主题，包括批量生产和异步生产等模式。 5. **消费者API**：研究消费者端的编程，理解消费者组的概念，以及如何进行并行消费和...
图解 Kafka 之实战指南.7z
12-22
Kafka还提供了流处理功能，通过Kafka Streams和Kafka Connect等API，可以构建复杂的实时数据处理管道。Kafka Connect允许用户轻松地将外部系统（如数据库、日志文件等）与Kafka连接，实现数据的导入导出。 在实战...
2、Kafka集群部署
ZJ__ZFH的博客
11-13 1428
环境准备 集群规划 hadoop-100 hadoop-101 hadoop-102 zookeeper zookeeper zookeeper kafka kafka kafka 下载jar包 下载地址 http://kafka.apache.org/ kafka下载1.png 如上图，点download kafka下载...
7、Kafka 扩展
ZJ__ZFH的博客
11-15 1345
Kafka与Flume比较 flume，cloudera公司研发 适合多个生产者； 适合下游数据消费者不多的情况； 适合数据安全性要求不高的操作； 适合与Hadoop生态圈对接的操作。 kafka，linkedin公司研发 适合数据下游消费众多的情况； 适合数据安全性要求较高的操作，支持replication。 因此常用的一种模型是： 线上数据 --&gt; flume --&gt; kafka...
1、Kafka概述
ZJ__ZFH的博客
11-13 1329
消息队列 消息队列实现原理.png 点对点模式（一对一，消费者主动拉取数据，消息收到后消息清除） 点对点模型通常是一个基于拉取或者轮询的消息传送模型，这种模型从队列中请求信息，而不是将消息推送到客户端。这个模型的特点是发送到队列的消息被一个且只有一个接收者接收处理，即使有多个消息监听者也是如此 发布/订阅模式（一对多，数据生产后，推送给所有订阅者） 发布订阅模型则是一个基于推送的消息...
3、Kafka工作流程分析
ZJ__ZFH的博客
11-14 1328
Kafka生产过程分析 写入方式 producer采用推（push）模式将消息发布到broker，每条消息都被追加（append）到分区（patition）中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障kafka吞吐率） 分区（Partition） 消息发送时都被发送到一个topic，其本质就是一个目录，而topic是由一些Partition Logs(分区日志)组成，其组织结构...
5、Kafka producer拦截器(interceptor)
ZJ__ZFH的博客
11-15 1306
拦截器原理 Producer拦截器(interceptor)是在Kafka 0.10版本被引入的，主要用于实现clients端的定制化控制逻辑。 对于producer而言，interceptor使得用户在消息发送前以及producer回调逻辑前有机会对消息做一些定制化需求，比如修改消息等。同时，producer允许用户指定多个interceptor按序作用于同一条消息从而形成一个拦截链(inte...
6、Kafka Streams
ZJ__ZFH的博客
11-15 1252
Kafka Streams Kafka Streams。Apache Kafka开源项目的一个组成部分。是一个功能强大，易于使用的库。用于在Kafka上构建高可分布式、拓展性，容错的应用程序 Kafka Streams特点 功能强大 高扩展性，弹性，容错 轻量级 无需专门的集群 一个库，而不是框架 完全集成 100%的Kafka 0.10.0版本兼容 易于集成到现有的应用程序 ...
Java调用Kafka API详解与实战教程
4. **处理复杂数据类型**：在生产者和消费者场景下，Kafka可以处理各种复杂的Java对象，包括序列化和反序列化。这里会介绍如何正确地序列化和反序列化数据，以适应Kafka对数据的特定要求。 5. **读取历史数据和监控...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值