kafka API之生产者Producer

写kafka生产者前先通过命令行创建topic主题和开启消费者：

①创建topic：

bin/kafka-topics.sh --zookeeper hadoop100:2181 --create --replication-factor 1 --partitions 2 --topic first

②开启消费者：

bin/kafka-console-consumer.sh --zookeeper hadoop100:2181 --topic first

 一、最简单的生产者代码：

package tyh.Test;

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

import java.util.Properties;

public class MyProducer {
    public static void main(String[] args) {

        //1、生产者配置信息
        Properties properties = new Properties();
        //将配置信息以key，value的形式put到properties中

        //kafka集群
        properties.put("bootstrap.servers", "hadoop100:9092");

        //acks,默认所有
        properties.put("acks", "all");

        //重试次数,默认1次
        properties.put("retries", 1);

        //批次大小,默认16KB
        properties.put("batch.size", 16384);

        //等待时间,默认1ms
        properties.put("linger.ms", 1);

        //设置key的序列化
        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        //设置value的序列化
        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        //2、创建一个生产者对象
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        //3、发送数据
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("first", "tyh--" + i));
        }

        //4、关闭连接
        producer.close();
    }
}

思路：

①我们要创建的是kafka的生产者，万物皆对象，我们先new KafkaProducer

②发现KafkaProducer需要用到 Properties存储配置信息，一定要有的配置信息为：kafka集群，key、Value的序列化（注，创建KafkaProducer时需要知道key、value的类型，是什么类型的就用什么类型的序列化器）

③生产数据并发送给消费者，用到的是send方法，需要ProducerRecord对象，参数如下，在之前的博客中举例提到过

结果：

注：因为first主题有两个分区，而kafka是批量存储和消费数据的，所以是先消费一个分区再消费另一个，而数据在分区间是无序的，在分区内是有序的，而且分区分配也是按照轮询的方式分配的。

二、进阶一：存储配置信息的key很容易写错，kafka将配置文件的key封装在了一个对象中

package tyh.Test;

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

import java.util.Properties;

public class MyProducer {
    public static void main(String[] args) {

        //1、生产者配置信息
        Properties properties = new Properties();
        //将配置信息以key，value的形式put到properties中

        //kafka集群
//        properties.put("bootstrap.servers", "hadoop100:9092");
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop100:9092");


        //设置key的序列化
//        properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        //设置value的序列化
//        properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        //2、创建一个生产者对象
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        //3、发送数据
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("first", "tyh-" + i));
        }

        //4、关闭连接
        producer.close();
    }
}

①优化后可以不用记配置文件的key，而且可以通过类查看相应配置信息的说明：

如图所示，每个配置信息都是一个config和一个DOC，config存储key，DOC存储这个配置的说明

②序列化的全类名不需要记，ctrl+N（idea）搜索类，记得要找Kafka包下的，是什么类型的就搜索：类型+serializer，找到类后右键copy references复制全类名就可以了

三、进阶二：带回调函数的生产者

package tyh.Producer;

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class CallBackProducer {
    public static void main(String[] args) {

        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop100:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        for (int i = 0; i < 10; i++) {

            producer.send(new ProducerRecord<String, String>("first", "tyh---" + i), new Callback() {
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        System.out.println(metadata.partition() + "-" + metadata.offset());
                    } else {
                        exception.printStackTrace();
                    }
                }
            });
        }

        producer.close();
    }
}

结果如下： 

四、进阶三：自定义分区器 

以下是kafka提供的的默认分区器

package org.apache.kafka.clients.producer.internals;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.utils.Utils;

public class DefaultPartitioner implements Partitioner {

    private final ConcurrentMap<String, AtomicInteger> topicCounterMap = new ConcurrentHashMap<>();

    public void configure(Map<String, ?> configs) {}

    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();
        if (keyBytes == null) {
            int nextValue = nextValue(topic);
            List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);
            if (availablePartitions.size() > 0) {
                int part = Utils.toPositive(nextValue) % availablePartitions.size();
                return availablePartitions.get(part).partition();
            } else {
                // no partitions are available, give a non-available partition
                return Utils.toPositive(nextValue) % numPartitions;
            }
        } else {
            // hash the keyBytes to choose a partition
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }

    private int nextValue(String topic) {
        AtomicInteger counter = topicCounterMap.get(topic);
        if (null == counter) {
            counter = new AtomicInteger(ThreadLocalRandom.current().nextInt());
            AtomicInteger currentCounter = topicCounterMap.putIfAbsent(topic, counter);
            if (currentCounter != null) {
                counter = currentCounter;
            }
        }
        return counter.getAndIncrement();
    }

    public void close() {}

}

我们可以通过自定义分区器，继承Partition抽象类来实现自定义分区器功能，根据自己的业务逻辑重写partition方法。

我在这简单讲述一下该默认分区器的逻辑结构：

①通过topic（主机）拿到partition对象，和分区数

②若没传入key值，则得到随机数值并自增，然后通过这个随机数与活着的topic数取余得到要传入partition的值

 List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic);方法为得到活着的主机数

③若传入了key值，则得到key的hash值并于主机数取余得到要传入partition的值

最简单的一个分区器，将所有消息都传入0号分区

使用自定义分区的生产者：

package tyh.Producer;

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

import java.util.Properties;

public class PartitionProducer {
    public static void main(String[] args) {

        //生产者配置信息
        Properties properties = new Properties();

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop100:9092");

        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        //自定义Partition
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "tyh.Partitioner.MyPartitioner");

        //创建一个生产者对象
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        //生产者发送消息
        for (int i = 0; i < 10; i++) {

        }

        //关闭资源
        producer.close();
    }
}

结果：只有一个消费者得到了数据

 五、进阶四：同步发送的生产者

package tyh.Producer;

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

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class ConsumerProducer {
    public static void main(String[] args) {

        Properties properties = new Properties();

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop100:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        for (int i = 0; i < 10; i++) {
            try {
                Future<RecordMetadata> first = producer.send(new ProducerRecord<String, String>("first", "tyh" + i));
                first.get();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }

       producer.close();
    }
}

Kafka 的 Producer 发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程——main 线程和 Sender 线程，以及一个线程共享变量——RecordAccumulator。main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka broker。

同步发送的意思就是，一条消息发送之后，会阻塞当前线程，直至返回 ack。要使生产者同步发送消息，需要将主线程阻塞，直至sender线程结束，这样做可以保证kafka写入的消息是有序的。

由于 send 方法返回的是一个 Future 对象，根据 Futrue 对象的特点，我们也可以实现同步发送的效果，只需调用 Future 对象的 get 方发即可。