本文详细介绍了Kafka生产者如何发送数据、数据分区策略，消费者如何自动与手动提交offset，以及如何使用Kafka Streams API进行实时数据处理。包括创建topic、流式API开发实例，以及避免数据丢失和重复消费的技巧。
文末有大量学习资源哦，免费领取。如果觉得内容不错，别忘记一键三连哦！！！
目录
1、创建maven工程并添加jar包
<dependencies>
<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-streams</artifactId>
<version>1.0.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<!-- java编译插件 -->
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.2</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
2、生产者代码
1、使用生产者，生产数据
一个用过用程序在很多情况下需要往kafka中写入很多的数据，记录用户的活动，记录度量指标，保存日志消息，记录智能家电的信息等。
多样的使用场景意味着多样的需求，是否每个消息都很重要，是否允许丢失一小部分数据，是否出现重复的数据也是可以接受的，是否有严格的延迟和吞吐量的需求
尽管生产者的api使用起来很简单，但是消息的发送还是很复杂的。
1）创建一个ProducerRecord对象，需要包括目标主题和要发送的内容，我们还可以指定键或者分区，在发送时，生产者要先把键和值对象序列化成子接数组，这样他们才可以在网络上传输
2）接下来，数据会被传给分区器，如果ProducerRecord制定了分区，那么分区器不做任何事情，直接把数据送入到指定的分区，如果没有，则会根据键的值来进行分区，后面将会讲到，接着，这条记录会被加到一个记录批次里，这个批次的所有消息会被发送到相同的主题和分区上，有一个独立的县城来负责把这些记录批次发送到相应的broker上
3）服务器收到会给以响应，如果写入成功，返回RecordMetaData对象，包含了主题，分区，以及记录在分区的偏移量，如果失败，返回错误，生产者收到错误之后，会在尝试发送，如果还错误，则返回错误信息
步骤：
1、要往kafka写入数据，首先要创建一个生产者对象，井设置一些属性，kafka有3个必选属性
| bootstrap.servers | 指定broker的地址，地址的格式为host:port清单里不需要包含所有的broker地址，生产者会从给定的broker查找其他的，不过建议至少要提供两个，以免一个宕机 |
| key.serializer | broker希望接收到的消息的键和值都是字节数组。生产者接口允许使用参数化类型，因此可以把java对象作为键和值发送给broker，不过生产者需要知道如何把这些java对象转换成字节数组。key.serializer必须被设置为实现了org.apache.kafka.common.serialization.Serializer接口的类，生产者会使用用这个类把键对象序列化成字节数组。 |
| value.serializer | 和key.serializer一样 |
| acks | acks=0，生产者在成功写入悄息之前不会等待任何来自服务器的响应，不过，因为生产者不需要等待服务器的响应，所以它可以以网络能够支持的最大速度发送消息，从而达到很高的吞吐量。 acks=1，只要集群的首领节点收到消息，生产者就会收到一个来自服务器的成功响应。如果消息无法收达首领节点（比如首领节点崩愤，新的首领还没有被选举出来），生产者会 收到错误响应，为了避免数据丢失，生产者会重发消息。 acks=all，只有所有参与复制的节点全部收到消息时，生产者才会收到来自服务器的成功响应 |
| batch:size | 当有多个消息需要被发送到同个分区时，生产者会把它们放在同一个批次里，该参数指定了一个批次可以使用的内存大小， |
| linger.ms | 该参数指定了生产者在发送批次之前等待更多消息加入批次的时间 |
2、过程
* 新建一个Properties 对象。
* 因为我们打算把键和值定义成字符串类型，所以使用内置的StringSeriaHzer。
* 在这里我们创建了一个新的生产者对象，井为键和值设置了恰当的类型，然后把Properties 对象传给它。
* 这个接口很简单， 通过配置生产者的不同属性就可以很大程度地控制它的行为。
Properties kafkaProps = new Properties();
//指定kafkabroker的节点
props.put("bootstrap.servers", "hadoop01:9092,hadoop02:9092");
//针对保存数据的确认
props.put("acks", "all");
//尝试重试的次数
props.put("retries", 0);
//按照batch发送数据
props.put("batch.size", 16384);
//消息发送的延时时间
props.put("linger.ms", 1);
//消息异步发送的存储消息的缓存
props.put("buffer.memory", 33554432);
// 指定自定义分区的类所在路径
//props.put("partitioner.class","cn.kafka.MyPartitioner");
//指定key和value的序列化类型
props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
创建kafka生产者
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(kafkaProps);
for (int i = 0; i < 1000; i++) {
// 发送数据 ,需要一个producerRecord对象,最少参数 String topic, V value
// 键和值对象的类型必须与序列化器和生产者对象相匹配。
ProducerRecord<String, String> record = new ProducerRecord<String, String>("test","hello world"+i);
//Future<RecordMetadata> send = producer.send(record);
// 这里可以调用get方法，等待kafka的响应，如果返回错误，则会抛出异常，如果没有错误，会得到RecordMetadata对象，可以用它获取消息的偏移量。
kafkaProducer.send(record);
Thread.sleep(100);
}
2、kafka当中的数据分区
kafka生产者发送的消息，都是保存在broker当中，我们可以自定义分区规则，决定消息发送到哪个partition里面去进行保存
kafka当中支持以下四种数据的分区方式：
//第一种分区策略，如果既没有指定分区号，也没有指定数据key，那么就会使用轮询的方式将数据均匀的发送到不同的分区里面去
ProducerRecord<String, String> producerRecord1 = new ProducerRecord<>("mypartition", "mymessage" + i);
kafkaProducer.send(producerRecord1);
//第二种分区策略 如果没有指定分区号，指定了数据key，通过key.hashCode % numPartitions来计算数据究竟会保存在哪一个分区里面
//注意：如果数据key，没有变化 key.hashCode % numPartitions = 固定值 所有的数据都会写入到某一个分区里面去
ProducerRecord<String, String> producerRecord2 = new ProducerRecord<>("mypartition", "mykey", "mymessage" + i);
kafkaProducer.send(producerRecord2);
//第三种分区策略：如果指定了分区号，那么就会将数据直接写入到对应的分区里面去
ProducerRecord<String, String> producerRecord3 = new ProducerRecord<>("mypartition", 0, "mykey", "mymessage" + i);
kafkaProducer.send(producerRecord3);
//第四种分区策略：自定义分区策略。如果不自定义分区规则，那么会将数据使用轮询的方式均匀的发送到各个分区里面去
props.put("partitioner.class","cn.kafka.MyPartitioner");
kafkaProducer.send(new ProducerRecord<String, String>("mypartition","mymessage"+i));
自定义分区策略
public class KafkaCustomPartitioner implements Partitioner {
@Override
public void configure(Map<String, ?> configs) {
// 什么都不用写
}
@Override
public int partition(String topic, Object arg1, byte[] keyBytes, Object arg3, byte[] arg4, Cluster cluster) {
List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
int partitionNum = partitions.size();
Random random = new Random();
int partition = random.nextInt(partitionNum);
return partition;
}
@Override
public void close() {
}
}
主代码中添加配置
@Test
public void kafkaProducer() throws Exception {
//1、准备配置文件
Properties props = new Properties();
props.put("bootstrap.servers", "node01:9092,node02:9092,node03:9092");
props.put("partitioner.class", "cn.itcast.kafka.partitioner.KafkaCustomPartitioner");
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> kafkaProducer = new KafkaProducer<String, String>(props);
for (int i=0;i<100;i++){
//3、发送数据
kafkaProducer.send(new ProducerRecord<String, String>("testpart","0","value"+i));
}
kafkaProducer.close();
}
3、消费者代码
在读取消息之前，需要先创建一个KafkaConsumer对象。创建KafkaConsumer对象与创建KafkaProducer对象非常相似一一把想要传给消费者的属性放在Properties 对象里。
消息轮询是消费者API的核心，通过一个简单的轮询向服务器请求数据。一旦消费者订阅了主题，轮询就会处理所有的细节，包括群组协调、分区再均衡、发送心跳和获取数据，
开发者只需要使用一组简单的API 来处理从分区返回的数据。
消费者的配置属性，对性能和可用性有很大的关系
| fetch.min.bytes | 指定了消费者’从服务器获取记录的最小字节数。broker在收到消费者的数据请求时，如果可用的数据量小于fetch.min.bytes指定的大小，那么它会等到有足够的可用数据时才把它返回给消费者 这样可以降低消费者和bro ke r 的工作负载 |
| fetch.max.wait.ms | 指定broker 的等待时间，默认是500ms 。如果没有大量数据流入Kafka ，消费者获取最小数据量的要求就得不到满足，最终导致500ms 的延迟。如果降低延迟，就看fetch.min.bytes和fetch.max.wait.ms谁先达到条件，谁先达到就执行谁 |
| max.partition.fetch.bytes | 服务器从每个分区里返回给消费者的最大字节数。它的默认值是lMB |
| session.timeout.ms | 消费者在被认为死亡之前可以与服务器断开连接的时间，默认是3s 。如果消费者没有在sessi.on.ti.l'leo川.1'15 指定的时间内发送心跳给群组协调器，就被认为已经死亡，协调器就会触发再均衡， |
提交偏移量
消费者往一个叫作＿consumer_offset 的特殊主题发送消息，消息里包含每个分区的偏移量。如果消费者一直处于运行状态，那么偏移量就没有什么用处。不过，如果消费者发生崩溃或者有新的消费者加入群组，就会触发再均衡，均衡之后，每个消费者可能分配到新的分区，而不是之前处理的那个。为了能够继续之前的工作，消费者需要读取每个分区最后一次提交的偏移量，然后从偏移量指定的地方继续处理。
如果提交的偏移量小于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息就会被重复处理
如果提交的偏移量大于客户端处理的最后一个消息的偏移量，那么处于两个偏移量之间的消息将会丢失
1、自动提交offset
消费完成之后，自动提交offset
// 1、连接集群，创建Properties对象
Properties props = new Properties();
props.put("bootstrap.servers", "hadoop-01:9092");
props.put("group.id", "test");
//以下两行代码 ---消费者自动提交offset值
props.put("enable.auto.commit", "true"); 默认5s
props.put("auto.commit.interval.ms", "1000");
//把字节数组转成Java 对象。
props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
// 2、创建KafkaConsumer消费者对象
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
//3、订阅下要消费的topic-order
kafkaConsumer.subscribe(Arrays.asList("order"));
// 4、遍历
//这是一个无限循环。消费者实际上是一个长期运行的应用程序，它通过持续轮询向Kafka 请求数据。
while (true){
//获取到消费的数据集合
//poll()方法返回一个记录列表。每条记录都包含了记录所属主题的信息、记录所在分区的信息、记录在分区里的偏移量，以及记录的键值对。我们一般会遍历这个列表，逐条处理这些记录，poll（）方法有一个超时参数，它指定了方法在多久之后可以返回，不管有没有可用的数据都要返回。
ConsumerRecords<String, String> records = consumer.poll(3000);
for (ConsumerRecord<String, String> record : records) {
//获取每一条记录
String topic = record.topic();
long offset = record.offset();
String value = record.value();
int partition = record.partition();
System.out.println("topic:"+topic+",partition:"+partition+",offset:"+offset+",value:"+value);
}
}
//在退出应用程序之前使用close(),方法关闭消费者，网络连接和socket也会随之关闭，并立即触发一次再均衡，而不是等待群组协调器发现它不再发送心跳井认定它已死亡
kafkaConsumer.close();
2、手动提交offset
如果Consumer在获取数据后，需要加入处理，数据完毕后才确认offset，需要程序来控制offset的确认？ 关闭自动提交确认选项
Properties props = new Properties();
props.put("bootstrap.servers", "localhost:9092");
props.put("group.id", "test");
//关闭自动提交确认选项
props.put("enable.auto.commit", "false");
props.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props); consumer.subscribe(Arrays.asList("test"));
final int minBatchSize = 200;
List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records) {
buffer.add(record);
}
if (buffer.size() >= minBatchSize) {
insertIntoDb(buffer);
// 手动提交offset值
consumer.commitSync();
buffer.clear();
}
}
3、消费完每个分区之后手动提交offset
上面的示例使用commitSync将所有已接收的记录标记为已提交。 在某些情况下，您可能希望通过明确指定偏移量 来更好地控制已提交的记录。 在下面的示例中，我们在完成处理每个分区中的记录后提交偏移量。
try {
while(running) {
ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
for (TopicPartition partition : records.partitions()) {
List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
for (ConsumerRecord<String, String> record : partitionRecords) { System.out.println(record.offset() + ": " + record.value());
}
long lastOffset = partitionRecords.get(partitionRecords.size() -1).offset();
consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
}
}
} finally { consumer.close();}
注意事项：
提交的偏移量应始终是应用程序将读取的下一条消息的偏移量。 因此，在调用commitSync（偏移量）时，应该 在最后处理的消息的偏移量中添加一个
4、指定分区数据进行消费
1、如果进程正在维护与该分区关联的某种本地状态（如本地磁盘上的键值存储），那么它应该只获取它在磁盘上 维护的分区的记录。
2、如果进程本身具有高可用性，并且如果失败则将重新启动（可能使用YARN，Mesos或AWS工具等集群管理框 架，或作为流处理框架的一部分）。 在这种情况下，Kafka不需要检测故障并重新分配分区，因为消耗过程将在另 一台机器上重新启动。
Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("group.id", "test");
props.put("enable.auto.commit", "true");
props.put("auto.commit.interval.ms", "1000");
props.put("key.deserializer",
"org.apache.kafka.common.serialization.StringDeserializer");
props.put("value.deserializer",
"org.apache.kafka.common.serialization.StringDeserializer");
KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
//consumer.subscribe(Arrays.asList("foo", "bar"));
//手动指定消费指定分区的数据---start
String topic = "foo";
TopicPartition partition0 = new TopicPartition(topic, 0);
TopicPartition partition1 = new TopicPartition(topic, 1); consumer.assign(Arrays.asList(partition0, partition1));
//手动指定消费指定分区的数据---end
while (true) {
ConsumerRecords<String, String> records = consumer.poll(100);
for (ConsumerRecord<String, String> record : records)
System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
}
注意事项：
1、要使用此模式，您只需使用要使用的分区的完整列表调用assign（Collection），而不是使用subscribe订阅 主题。
2、主题与分区订阅只能二选一
5、重复消费与数据丢失
说明：
1、已经消费的数据对于kafka来说，会将消费组里面的offset值进行修改，那什么时候进行修改了？是在数据消费 完成之后，比如在控制台打印完后自动提交；
2、提交过程：是通过kafka将offset进行移动到下个message所处的offset的位置。
3、拿到数据后，存储到hbase中或者mysql中，如果hbase或者mysql在这个时候连接不上，就会抛出异常，如果在处理数据的时候已经进行了提交，那么kafka伤的offset值已经进行了修改了，但是hbase或者mysql中没有数据，这个时候就会出现数据丢失。
4、什么时候提交offset值？在Consumer将数据处理完成之后，再来进行offset的修改提交。默认情况下offset是 自动提交，需要修改为手动提交offset值。
5、如果在处理代码中正常处理了，但是在提交offset请求的时候，没有连接到kafka或者出现了故障，那么该次修 改offset的请求是失败的，那么下次在进行读取同一个分区中的数据时，会从已经处理掉的offset值再进行处理一 次，那么在hbase中或者mysql中就会产生两条一样的数据，也就是数据重复
4、kafka Streams API开发
需求：使用StreamAPI获取test这个topic当中的数据，然后将数据全部转为大写，写入到test2这个topic当中去
第一步：创建一个topic
node01服务器使用以下命令来常见一个topic 名称为test2
cd /export/servers/kafka_2.11-1.0.0/
bin/kafka-topics.sh --create --partitions 3 --replication-factor 2 --topic test2 --zookeeper node01:2181,node02:2181,node03:2181
第二步：开发StreamAPI
public class StreamAPI {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "node01:9092");
props.put(StreamsConfig.KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
KStreamBuilder builder = new KStreamBuilder();
builder.stream("test").mapValues(line -> line.toString().toUpperCase()).to("test2");
KafkaStreams streams = new KafkaStreams(builder, props);
streams.start();
}
}
第三步：生产数据
node01执行以下命令，向test这个topic当中生产数据
bin/kafka-console-producer.sh --broker-list node01:9092,node02:9092,node03:9092 --topic test
第四步：消费数据
node02执行一下命令消费test2这个topic当中的数据
bin/kafka-console-consumer.sh --from-beginning --topic test2 --zookeeper node01:2181,node02:2181,node03:2181
给大家准备的各类书籍都在这里啦，收集不易，期待您的一键三连，后续还会更新文章哦，谢谢您的关注和点赞，您的点赞会让我有加倍动力
链接：https://pan.baidu.com/s/1MH1eiwMv_XCCbFX3hwGu7g
提取码：70uy
https://shimo.im/docs/863dvkxgWHtwcWkh/ 《书籍》
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
