目录
1、创建maven工程并添加jar包
创建maven工程并添加以下依赖jar包的坐标到pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>bigdata_project</artifactId>
<version>1.0-SNAPSHOT</version>
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.1.0</version>
</dependency>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-streams</artifactId>
<version>3.1.0</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.1.0</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<filters>
<filter>
<artifact>*:*</artifact>
<!-- 这里必须要填下面这段，否则报错 -->
<excludes>
<exclude>META-INF/*.SF</exclude>
<exclude>META-INF/*.DSA</exclude>
<exclude>META-INF/*.RSA</exclude>
</excludes>
</filter>
</filters>
<transformers>
<transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
<!-- 下面这里要填要运行的类，否则会报错 -->
<mainClass>cn.kafkademo.ProducerDemo1</mainClass>
</transformer>
</transformers>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>
2、生产者代码
2.1、使用生产者，生产数据
package cn.kafkademo;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/*
* 使用生产者，生产数据
*/
public class ProducerDemo1 {
public static void main(String[] args) throws InterruptedException {
/* 1、连接集群，通过配置文件的方式
* 2、发送数据-topic:order，value
*/
Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put("acks", "all");
props.put("retires", 0);
props.put("batch.size",16834);
props.put("linger.ms",1);
props.put("buffer.memory",33554432);
props.put("key.serializer", StringSerializer.class.getName());
props.put("value.serializer", StringSerializer.class.getName());
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String,String>(props);
for(int i = 0;i < 100; i++) {
// 发送数据 ,需要一个producerRecord对象,
// 最少参数 String topic,V value
kafkaProducer.send(new ProducerRecord<String, String>("order", "订单信息！"+i));
System.out.println(i);
Thread.sleep(100);
}
kafkaProducer.close();
}
}
2.2、kafka当中的数据分区
kafka生产者发送的消息，都是保存在broker当中，我们可以自定义分区规则，决定消息发送到哪个partition里面去进行保存
查看
ProducerRecord
这个类的源码，就可以看到kafka的各种不同分区策略
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);
//第四种分区策略：自定义分区策略。如果不自定义分区规则，那么会将数据使用轮询的方式均匀的发送到各个分区里面去
kafkaProducer.send(new ProducerRecord<String, String>("mypartition","mymessage"+i));自定义分区策略
package cn.kafkademo;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.PartitionInfo;
import java.util.List;
import java.util.Map;
import java.util.Random;
/*
* kafka当中的自定义数据分区
*/
public class KafkaCustomPartitionerDemo1 implements Partitioner {
@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() {
}
@Override
public void configure(Map<String, ?> map) {
}
}
在主代码中添加配置
package cn.kafkademo;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
public class KafkaCustomPartitionerDemo1Test {
public static void main(String[] args) throws InterruptedException {
/* 1、连接集群，通过配置文件的方式
* 2、发送数据-topic:order，value
*/
Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put("acks", "all");
props.put("retires", 0);
props.put("batch.size",16834);
props.put("linger.ms",1);
props.put("buffer.memory",33554432);
props.put("key.serializer", StringSerializer.class.getName());
props.put("value.serializer", StringSerializer.class.getName());
//添加分区配置
props.put("partitioner.class",KafkaCustomPartitionerDemo1.class.getName());
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String,String>(props);
for(int i = 0;i < 100; i++) {
// 发送数据 ,需要一个producerRecord对象,
// 最少参数 String topic,V value
kafkaProducer.send(new ProducerRecord<String, String>("order","0","value "+i));
System.out.println(i);
Thread.sleep(100);
}
kafkaProducer.close();
}
}
2.3、消费者代码
消费必要条件
消费者要从
kafka Cluster
进行消费数据，必要条件有以下四个
1、地址
bootstrap.servers=node01:90922、序列化
key.serializer=org.apache.kafka.common.serialization.StringSerializer
value.serializer=org.apache.kafka.common.serialization.StringSerializer3、主题（topic） 需要制定具体的某个topic（order）即可。
4、消费者组 group.id=test
2.3.1、自动提交offset
消费完成之后，自动提交offset
package cn.kafkademo;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.Arrays;
import java.util.Properties;
/**
* 消费者代码
* 1、自动提交offset
*/
public class OrderConsumerDemo1 {
public static void main(String[] args) {
// 1、连接集群
Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put("group.id", "ConsumerDemo1");
//以下两行代码 ---消费者自动提交offset值
props.put("enable.auto.commit", "true");
props.put("auto.commit.interval.ms", "1000");
props.put("key.deserializer", StringDeserializer.class.getName());
props.put("value.deserializer", StringDeserializer.class.getName());
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
// 2、发送数据 发送数据需要，订阅下要消费的topic order
kafkaConsumer.subscribe(Arrays.asList("order"));
while (true) {
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : consumerRecords) {
int partition = record.partition(); // 获取数据对应的分区号
String value = record.value(); // 对应数据值
long lastoffset = record.offset(); //对应数据的偏移量
String key = record.key();//对应数据发送的key
System.out.println("数据的key为 "+ key + " 数据的value为 " + value + " 数据的offset为 "+ lastoffset + " 数据的分区为 "+ partition);
}
}
}
}
2.3.2、手动提交offset
如果Consumer在获取数据后，需要加入处理，数据完毕后才确认offset，需要程序来控制offset的确认，关闭自动提交确认选项
package cn.kafkademo;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
/**
* 消费者代码
* 2、手动提交offset
*/
public class OrderConsumerDemo2 {
public static void main(String[] args) {
// 1、连接集群
Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put("group.id", "ConsumerDemo");
//---消费者手动提交offset值
props.put("enable.auto.commit", "false");
props.put("key.deserializer", StringDeserializer.class.getName());
props.put("value.deserializer", StringDeserializer.class.getName());
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
// 2、发送数据 发送数据需要，订阅下要消费的topic order
kafkaConsumer.subscribe(Arrays.asList("order"));
final int minBatchSize = 200;
List<ConsumerRecord<String, String>> buffer = new ArrayList<>();
while (true) {
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofMillis(100));
for (ConsumerRecord<String, String> record : consumerRecords) {
int partition = record.partition(); // 获取数据对应的分区号
String value = record.value(); // 对应数据值
long lastoffset = record.offset(); //对应数据的偏移量
String key = record.key();//对应数据发送的key
System.out.println("数据的key为 "+ key + " 数据的value为 " + value + " 数据的offset为 "+ lastoffset + " 数据的分区为 "+ partition);
//将数据添加到buffer中
buffer.add(record);
if (buffer.size() >= minBatchSize) {
kafkaConsumer.commitSync();
buffer.clear();
}
}
}
}
}
2.3.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（偏移量）时，应该 在最后处理的消息的偏移量中添加一个
2.3.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);
//不能使用subscribe 订阅模式
//使用Apache Kafka消费者组时，有一个为消费者分配对应分区partition的过程，我们可以使用"自动"subscribe和"手动"assign的方式。
//KafkaConsumer.subscribe()：为consumer自动分配partition，有内部算法保证topic-partition以最优的方式均匀分配给同group下的不同consumer。
//KafkaConsumer.assign()：为consumer手动、显示的指定需要消费的topic-partitions，不受group.id限制。
//如果两种模式都用的话会报错
//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、主题与分区订阅只能二选一
2.3.5、指定offset消费
使用 KafkaConsumer.seek 方法指定 offset消费
package cn.kafkademo;
/***
* 消费者代码
* 3、制定分区数据进行消费
*/
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;
import java.time.Duration;
import java.util.*;
public class OrderConsumerDemo3 {
public static void main(String[] args) {
// 1、连接集群
Properties props = new Properties();
props.put("bootstrap.servers", "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put("group.id", "ConsumerDemo333");
//消费者手动提交offset值
props.put("enable.auto.commit", "false");
props.put("key.deserializer", StringDeserializer.class.getName());
props.put("value.deserializer", StringDeserializer.class.getName());
KafkaConsumer<String, String> kafkaConsumer = new KafkaConsumer<String, String>(props);
//订阅消费主题
TopicPartition topicpartition = new TopicPartition("order", 0);
//kafkaConsumer.subscribe(Arrays.asList("order"));
kafkaConsumer.assign(Arrays.asList(topicpartition));
kafkaConsumer.seek(new TopicPartition("order",0), 10L);
while (true) {
//调用poll方法，获取所有的数据，包含了各个分区里面的数据都有
ConsumerRecords<String, String> consumerRecords = kafkaConsumer.poll(Duration.ofMillis(100));
//获取到一个topic里面所有的分区
Set<TopicPartition> partitions = consumerRecords.partitions();
for (TopicPartition topicPartition : partitions) {
//获取到一个分区里面的所有的数据
List<ConsumerRecord<String, String>> records = consumerRecords.records(topicPartition);
for (ConsumerRecord<String, String> record : records) {
int partition = record.partition();//获取数据对应的分区号
String value = record.value();//对应数据值
long lastoffset = record.offset();//对应数据的偏移量
String key = record.key();//对应数据发送的key
System.out.println("数据的offset为 "+ lastoffset +" 数据的key为 "+ key + " 数据的value为 " + value + " 数据的offset为 "+ lastoffset + " 数据的分区为 "+ partition);
}
//获取分区里面最后一条数据的offset的值
long offset = records.get(records.size() - 1).offset();
//提交这个partition的offset值
Map<TopicPartition, OffsetAndMetadata> topicPartitionOffsetAndMetadataMap = Collections.singletonMap(topicPartition, new OffsetAndMetadata(offset));
//处理完成一个分区里面的数据，然后提交offset
kafkaConsumer.commitSync(topicPartitionOffsetAndMetadataMap);
}
}
}
}
重复消费与数据丢失：
说明：
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中就会产生两条一样的数据，也就是数据重复
2.3.6、consumer消费者消费数据流程
流程描述
Consumer连接指定的Topic partition所在leader broker，采用pull方式从kafkalogs中获取消息。对于不同的消费模式，会将offset保存在不同的地方
官网关于high level API 以及low level API的简介
http://kafka.apache.org/0100/documentation.html#impl_consumer
高阶API（High Level API）
kafka消费者高阶API简单；隐藏Consumer与Broker细节；相关信息保存在zookeeper中。
说明：大部分的操作都已经封装好了，比如：当前消费到哪个位置下了，但是不够灵活（工作过程推荐使用）
低级API(Low Level API)
kafka消费者低级API非常灵活；需要自己负责维护连接Controller Broker。保存offset，Consumer Partition对应 关系。
说明：没有进行包装，所有的操作有用户决定，如自己的保存某一个分区下的记录，你当前消费到哪个位置。
2.4、kafka Streams API开发
需求：使用StreamAPI获取test这个topic当中的数据，然后将数据全部转为大写，写入到test2这个topic当中去
第一步：创建一个topic
node01服务器使用以下命令来常见一个topic 名称为order2
bin/kafka-topics.sh –create –partitions 3 –replication-factor 2 –topic order2 –zookeeper node01:2181,node02:2181,node03:2181
第二步：开发StreamAPI
package cn.kafkademo;
import org.apache.kafka.common.serialization.Serdes;
import org.apache.kafka.streams.KafkaStreams;
import org.apache.kafka.streams.StreamsBuilder;
import org.apache.kafka.streams.StreamsConfig;
import java.util.Properties;
public class KafkaStreamAPIDemo1 {
public static void main(String[] args) {
Properties props = new Properties();
props.put(StreamsConfig.APPLICATION_ID_CONFIG, "wordcount-application");
props.put(StreamsConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.88.3:9092,192.168.88.4:9092,192.168.88.5:9092");
props.put(StreamsConfig.DEFAULT_KEY_SERDE_CLASS_CONFIG, Serdes.String().getClass());
props.put(StreamsConfig.DEFAULT_VALUE_SERDE_CLASS_CONFIG, Serdes.String().getClass());
StreamsBuilder builder = new StreamsBuilder();
builder.stream("order").mapValues(line -> line.toString()+"添加KafkaStream处理").to("order2");
KafkaStreams streams = new KafkaStreams(builder.build(),props);
streams.start();
}
}
第三步：生产数据
node01执行以下命令，向test这个topic当中生产数据
bin/kafka-console-producer.sh –broker-list node01:9092,node02:9092,node03:9092 –topic order2
第四步：消费数据
node02执行一下命令消费order2这个topic当中的数据
bin/kafka-console-consumer.sh –from-beginning –topic order2 –zookeeper node01:2181,node02:2181,node03:2181
版权声明：本文为qq_15083919原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。