Kafka的JavaAPI操作

FOX有爱

已于 2022-05-29 08:11:02 修改

阅读量1.2k

点赞数 1

分类专栏： Kafka 大数据文章标签： kafka maven java

于 2022-05-29 07:43:51 首次发布

本文链接：https://blog.csdn.net/qq_15083919/article/details/124993913

版权

大数据同时被 2 个专栏收录

30 篇文章 2 订阅

订阅专栏

Kafka

7 篇文章 0 订阅

订阅专栏

2.3.3、消费完每个分区之后手动提交offset

2.3.4、指定分区数据进行消费

2.3.5、指定offset消费

2.3.6、consumer消费者消费数据流程

2.4、kafka Streams API开发

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:9092

2、序列化
key.serializer=org.apache.kafka.common.serialization.StringSerializer
value.serializer=org.apache.kafka.common.serialization.StringSerializer

3、主题（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来说，会将消费组里面的oﬀset值进行修改，那什么时候进行修改了？是在数据消费完成之后，比如在控制台打印完后自动提交；

2、提交过程：是通过kafka将oﬀset进行移动到下个message所处的oﬀset的位置。

3、拿到数据后，存储到hbase中或者mysql中，如果hbase或者mysql在这个时候连接不上，就会抛出异常，如果在处理数据的时候已经进行了提交，那么kafka伤的oﬀset值已经进行了修改了，但是hbase或者mysql中没有数据，这个时候就会出现数据丢失。

4、什么时候提交oﬀset值？在Consumer将数据处理完成之后，再来进行oﬀset的修改提交。默认情况下oﬀset是自动提交，需要修改为手动提交oﬀset值。

5、如果在处理代码中正常处理了，但是在提交oﬀset请求的时候，没有连接到kafka或者出现了故障，那么该次修改oﬀset的请求是失败的，那么下次在进行读取同一个分区中的数据时，会从已经处理掉的oﬀset值再进行处理一次，那么在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

FOX有爱

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
Kafka的JavaAPI操作

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://mav.
复制链接

扫一扫