kafka包含5个核心的API接口定义:
简单的理解,kafka Producer 就是向kafka写入数据的应用程序,接下来实现一个最简单的 Producer 生产者程序。
<dependency>
<groupId>org.apache.kafkagroupId>
<artifactId>kafka-clientsartifactId>
<version>3.3.1version>
dependency>
public class SimpleProducer {
public static void main(String[] args) {
String topicName = "simple_topic";
Properties props = new Properties();
//指定kafka 服务器连接地址
props.put("bootstrap.servers", "localhost:9092");
// ack 机制
props.put("acks", "all");
// 发送失败 重试次数
props.put("retries", 0);
// 消息发送延迟时间 默认为0 表示消息立即发送,单位为毫秒
props.put("linger.ms", 1);
// 序列化方式
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
Producer<String, String> producer = new KafkaProducer<>(props);
for(int i = 0; i < 10; i++) {
producer.send(new ProducerRecord<>(topicName,
Integer.toString(i), "message : " + i));
}
System.out.println("Message sent successfully");
producer.close();
}
}
$ ./bin/kafka-topics.sh --create --topic simple_topic --bootstrap-server localhost:9092
# 启动kafka自带的消费者脚本
$ ./bin/kafka-console-consumer.sh --topic simple_topic --bootstrap-server localhost:9092
首先,启动生产者代码,消费者控制台输出如下
Kafka提供了一种同步发送方法,用于向主题发送记录。让我们使用这个方法向我们之前创建的Kafka主题发送一些消息id和消息。
for(int i = 0; i < 10; i++) {
try {
ProducerRecord<String, String> record = new ProducerRecord<>(topicName,
Integer.toString(i), "message : " + i);
Future<RecordMetadata> send = producer.send(record);
//同步等待 发送结果
RecordMetadata metadata = send.get();
System.out.println(String.format("sent record(key=%s value=%s) 分区数: %d, 偏移量: %d, 时间戳: %d",
record.key(),
record.value(),
metadata.partition(),
metadata.offset(),
metadata.timestamp()
));
}catch (Exception e){
e.printStackTrace();
}
}
Kafka提供了一种异步发送方法,用于向主题发送记录。生产者发送成功后,自动调用回调方法输出消息的元数据,这里的最大区别是使用lambda表达式来定义回调。
for(int i = 0; i < 10; i++) {
ProducerRecord<String, String> record = new ProducerRecord<>(topicName,
Integer.toString(i), "message : " + i);
// 发送成功 执行callback回调函数
producer.send(record, (metadata, exception) -> {
if (metadata != null) {
System.out.println(String.format("sent record(key=%s value=%s) 分区数: %d, 偏移量: %d, 时间戳: %d",
record.key(),record.value(),
metadata.partition(), metadata.offset(),metadata.timestamp()
));
}
});
}
//等待回调执行完毕
TimeUnit.SECONDS.sleep(1);
默认情况下,kafka会尽快的发送message至Broker,这对于消息有时效性的场景非常的有效,但是却降低了kafka的吞吐量,原因是每次发送数据都需要进行一次网络传输。如果允许一定时间的延迟(通常情况下,是毫秒级别),且消息吞吐量非常大的场景,可以采用批量发送方式。
kafka批处理机制允许Kafka提高吞吐量,同时保持非常低的延迟。批处理具有更高的压缩比,因此具有更好的磁盘和网络效率。对开发这而言,kafka的批量发送机制,并不需要更改任何业务代码,主要由两个生成器设置控制:linger.ms和batch.size。
如下图所示,生产者允许等待指定的时间,将等待时间内的消息 M0 - M100 一次性发送到服务端。这里有两种情况
batch.size
Producer生产者的最重要的参数之一,对于调优producer吞吐量和延迟性指标有非常重要的作用。producer将发往同一分区的消息封装到一个batch中,当batch中的消息数量,满足指定的 大小时 ,producer 会发送batch中的所有消息。
但是,考虑一个极端的场景,由于消息迟迟不能满足 batch.size的大小,导致消息不能发送到服务端,那么消息就会出现延迟,甚至是丢失的风险,此时 linger.ms参数派上用场
linger.ms
该参数是控制消息延迟发送行为,默认为0,表示立即发送数据,并不关心 batch 是否已满。上面提到的极端情况,可以允许指定消息延迟发送时间,单位是毫秒,时间到达,不管batch是否满足,立即发送。
实际上该参数是系统吞吐量和延迟时间之间的权衡。
kafka是一个分布式流处理系统,当kafka集群部署时,如上图所示,一个topic可能存在N个分区。那么producer生产者将如何选择对应的分区进行数据发送呢?
kafka提供了分区策略以及默认的分区方式供用户使用,分区策略的核心接口定义:
public interface Partitioner extends Configurable, Closeable {
/**
* 根据指定记录 计算分区
*/
int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster);
/**
* 分区关闭时 调用该方法
*/
void close();
@Deprecated
default void onNewBatch(String topic, Cluster cluster, int prevPartition) {
}
}
在3.3.1的版本中,提供了三个分区方法,其中两个已经过期,不建议使用,RoundRobin轮训算法分区策略的核心代码如下
public class RoundRobinPartitioner implements Partitioner {
private final ConcurrentMap<String, AtomicInteger> topicCounterMap = new ConcurrentHashMap<>();
@Override
public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
// 获取集群分区数
List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
int numPartitions = partitions.size();
//根据topic 累加
int nextValue = nextValue(topic);
List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
if (!availablePartitions.isEmpty()) {
// 累加值取模 计算分区数
int part = Utils.toPositive(nextValue) % availablePartitions.size();
return availablePartitions.get(part).partition();
} else {
return Utils.toPositive(nextValue) % numPartitions;
}
}
private int nextValue(String topic) {
AtomicInteger counter = topicCounterMap.computeIfAbsent(topic, k -> new AtomicInteger(0));
return counter.getAndIncrement();
}
//...
}
轮训策略效果如下图