四、Kafka API 使用-优快云博客

本文链接：https://blog.youkuaiyun.com/lidazhou/article/details/88392999

本文介绍了Kafka的API使用，包括启动相关集群、添加POM依赖进行编程；探讨带回调函数的生产者，用于获取数据分区和偏移量信息，确保数据均匀分布；讲解了自定义分区的生产者，通过实现`CustomerPartitioner`类调整数据分配策略；最后提到了Kafka的高级消费者特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1、生产者API

①启动hadoop集群、zookeeper集群、kafka集群，接着再启动一个kafka消费者。

$ bin/kafka-console-consumer.sh --zookeeper s101:2181 --topic first             //启动Kafka消费者

②导入pom依赖：

<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>0.11.0.0</version>
</dependency>
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka_2.12</artifactId>
    <version>0.11.0.0</version>
</dependency>

③编程

package com.producer;

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

import java.util.Properties;

/**
 * @Author: Dazhou Li
 * @Description:
 * @CreateDate: 2019/1/17 0017 21:54
 */
public class CustomerProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "s101: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");

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

2、带回调函数的生产者：

作用：可知道数据的分区、偏移量等信息。

代码：

package com.producer;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Properties;

/**
 * @Author: Dazhou Li
 * @Description:
 * @CreateDate: 2019/1/17 0017 21:54
 */
public class CustomerProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "s101: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");

        KafkaProducer<String, String> producer = new KafkaProducer<String ,String>(props);
        for (int i = 0; i < 10; i++) {    //回调函数写在这里
            producer.send(new ProducerRecord<String, String>("second", String.valueOf(i)), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e==null){  //发送数据成功，可打印分区、偏移量等信息
                        System.out.println(recordMetadata.partition()+"--"+recordMetadata.offset());
                    }else {        //发送数据失败
                        System.out.println("打印失败");
                    }
                }
            });
        }
        producer.close();
    }
}

生产者生产数据，均匀的放置数据，第0个分区放置第一条数据，第1个分区放置第二条数据。。。

消费者消费时，是一个分区一个分区的读取数据，先读完一个分区，再读另一个分区。

3、自定义分区的生产者：

重新写一个类CustomerPartitioner实现partitioner类,重写里面的方法:partition、close、configure。

close()方法：关闭资源；

configure()方法:如果partition()方法中用到某些配置文件或者修改，这个方法可以读取配置文件。

在CustomerProducer.java中添加

//添加自定义分区生产者的配置
props.put("partitioner.class","com.producer.CustomerPartitioner");

package com.producer;

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

import java.util.Map;

/**
 * @Author: Dazhou Li
 * @Description:
 * @CreateDate: 2019/1/20 0020 20:48
 */
public class CustomerPartitioner implements Partitioner {

    private Map configMap=null;

    public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {
        //现在是只往0分区写
        return 0;
    }

    public void close() {

    }

    public void configure(Map<String, ?> map) {
        configMap=map;
    }
}

package com.producer;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Properties;

/**
 * @Author: Dazhou Li
 * @Description:
 * @CreateDate: 2019/1/17 0017 21:54
 */
public class CustomerProducer {
    public static void main(String[] args) {
        Properties props = new Properties();
        // Kafka服务端的主机名和端口号
        props.put("bootstrap.servers", "s101: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.producer.CustomerPartitioner");

        KafkaProducer<String, String> producer = new KafkaProducer<String ,String>(props);
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("second", String.valueOf(i)), new Callback() {
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e==null){  //发送数据成功，可打印分区、偏移量等信息
                        System.out.println(recordMetadata.partition()+"--"+recordMetadata.offset());
                    }else {        //发送数据失败
                        System.out.println("打印失败");
                    }
                }
            });
        }
        producer.close();
    }
}

4、kafka高级消费者

package com.consumer;

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * @Author: Dazhou Li
 * @Description:
 * @CreateDate: 2019/1/20 0020 21:24
 */
public class CustomConsumer {

    public static void main(String[] args) {
        Properties pros = new Properties();
        //kafka集群
        pros.put("bootstrap.servers", "s101:9092");
        //消费者组id
        pros.put("group.id", "test");
        //设置自动提交offset
        pros.put("enable.auto.commit", "true");
        //提交延时
        pros.put("auto.commit.intervals.ms", "1000");
        //key、value反序列化
        pros.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        pros.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        //创建消费者对象
        KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(pros);
        //指定topic
        consumer.subscribe(Arrays.asList("second", "first", "third"));
        while (true) {
            //获取数据
            ConsumerRecords<String, String> consumerRecords = consumer.poll(100);

            for (ConsumerRecord<String, String> record : consumerRecords) {
                System.out.println(record.topic() + "--" + record.partition() + "--" + record.value());
            }
        }

    }
}