kafka 序列化器，分区器，拦截器，消息累加器

拦截器

生产者拦截器

自定义生产者拦截器

前提了解：

整个kafka生产者客户端由两条线程协调运行。

这两条线程分别为主线程和sender线程（发送线程）

主线程的作用就是：由KafkaProducer创建消息，然后通过可能的拦截器，序列化器，分区器的作用之后缓存到消息累加器

send线程的作用就是：负责将消息累加器中的消息发送到kafka中。

拦截器

拦截器是在kafka0.10.0.0版本中就已经引入的一个功能，kafka一共有两种拦截器。生产者拦截器和消费者拦截器。

生产者拦截器

生产者拦截器可以用来在消息发送前做一些准备工作，比如按照某个规则过滤不符合要求的消息，修改消息的内容等，也可以用来在发送回调逻辑前做一些定制化的需求。

当然生产者拦截器的使用也很方便，主要是自定义实现org.apache.kafka.clients.producer.ProducerInterceptor接口。

ProducerInterceptor接口中包含3个方法：

//producer会在消息序列化器，分区器之前调用拦截器的onSend()方法来对消息进行定制化操作。
 public ProducerRecord<K, V> onSend(ProducerRecord<K, V> record);

//producer会在消息被应答之前或者发送失败时调用生产者的 onAcknowledgement（）方法
 //不过该方法运行在Producerde I/O线程中，所以方法中的实现代码逻辑越简单越好，否则会影响消息的发送速度
 public void onAcknowledgement(RecordMetadata metadata, Exception exception);

//用于在关闭拦截器时执行一些资源的清理工作
 public void close();

自定义生产者拦截器

import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.util.Map;

/**
 * 生产者拦截器
 */
public class ProducerInterceptorPrefix implements ProducerInterceptor<String, String> {

    private volatile long sendSuccess = 0;
    private volatile long sendFailure = 0;
    //定制化数据
    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> producerRecord) {
        final String mpdofoeddValue = "preFix" + producerRecord.value();

        return new ProducerRecord<String, String>(
                producerRecord.topic(),
                producerRecord.partition(),
                producerRecord.timestamp(),
                producerRecord.key(),
                mpdofoeddValue,
                producerRecord.headers());
    }
    //消息被应答前发送失败时会调用
    @Override
    public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
            if(e == null ){
                sendSuccess ++;
            }else{
                sendFailure ++;
            }
    }
    @Override
    public void close() {
        final double successRatio = (double)sendSuccess / (sendSuccess + sendFailure);
        System.out.println("发送成功率 = " + String.format("%f",successRatio* 100) + "%");
    }
    @Override
    public void configure(Map<String, ?> map) { }
}

实现自定义的ProducerInterceptorPrefix之后，需要在producer的配置参数中指定拦截器。示例：

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * kafka生产
 */
public class KafkaProducerFastStart {

    public static final String brokerList = "127.0.0.1:9092";
    public static final String topic = "topic-demo";

    public static void main(String args[]) {

        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, brokerList);    //集群地址
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); // 16K   batch.size
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432); // 32M   buffer.memory
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());//KEY序列化方式
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());//value序列化方式
        properties.put(ProducerConfig.ACKS_CONFIG, "1");
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);//retries
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);//linger.ms
        properties.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, ProducerInterceptorPrefix.class.getName());//  interceptor.classes  拦截器

        //配置生产者客户端参数并创建KafkaProducer实例
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);
        //构建需要发送得消息
        ProducerRecord<String, String> data = new ProducerRecord<String, String>(topic, "key", "value");
        try {
            producer.send(data);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            producer.close();
        }
    }
}

当然，拦截器不仅仅可以指定一个。还可以指定多个形成拦截链，拦截链会按照interceptor.classes 参数配置的拦截器的顺序来一一执行。每个拦截器之间用逗号隔开。

properties.put(
      ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, 
      ProducerInterceptorPrefix.class.getName() + "," + ProducerInterceptorPrefix2.class.getName());//  interceptor.classes  拦截器

序列化器

生产者需要用序列化器将对象转换成字节数组才能通过网络发送给kafka.当然消费者需要用对应的反序列化器将kafka的字节数组转换为相应的对象。

kafka客户端自带的序列化器有：

DoubleSerializer ，ByteArraySerializer ，ByteBufferSerializer，

BytesSerializer , IntegerSerializer , LongSerializer ，StringSerializer

当然，如果这几种序列化器都无法满足应用需求，我们可以选择如 Avro,JSON,Thrift,Protobuf等，或者使用自定义类型的序列化器来实现。

图中 Company 为自定义的对象。

import org.apache.kafka.common.serialization.Serializer;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.Map;

/**
生产端序列化器
 */
public class CustomizeSerializer implements Serializer<Company> {
    @Override
    public void configure(Map<String, ?> map, boolean b) { }
    @Override
    public byte[] serialize(String topic, Company company) {

        if (company == null) {
            return null;
        }
        byte[] name, address;
        try {
            if (company.getName() != null) {
                name = company.getName().getBytes("UTF-8");
            } else {
                name = new byte[0];
            }
            if (company.getAddress() != null) {
                address = company.getAddress().getBytes("UTF-8");
            } else {
                address = new byte[0];
            }
            ByteBuffer buffer = ByteBuffer.allocate(4 + 4 + name.length + address.length);
            buffer.putInt(name.length);
            buffer.put(name);
            buffer.putInt(address.length);
            buffer.put(address);
            return buffer.array();
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return new byte[0];
    }
    @Override
    public void close() {
    }
}

kafkaProducer配置

properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,CustomizeSerializer.class.getName());

反序列化器

import org.apache.kafka.common.errors.SerializationException;
import org.apache.kafka.common.serialization.Deserializer;

import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.util.Map;

/**
 * 反序列化器
 */
public class CustomizeDeserializer implements Deserializer<Company> {
    @Override
    public void configure(Map<String, ?> map, boolean b) { }

    @Override
    public Company deserialize(String topic, byte[] data) {
        if(data == null ){
            return null;
        }
        if(data.length < 8 ){
            throw new SerializationException("Size of data received  by DemoDeserializer is shorter than expected !");
        }
         ByteBuffer buffer = ByteBuffer.wrap(data);
        int nameLen,addressLen;
        String name, address;

        nameLen = buffer.getInt();
        final byte[] nameBytes = new byte[nameLen];
        buffer.get(nameBytes);

        addressLen = buffer.getInt();
        byte[] addressBytes = new byte[addressLen];
        buffer.get(addressBytes);

        try{
            name = new String(nameBytes,"UTF-8");
            address = new String(addressBytes,"UTF-8");
        }catch (UnsupportedEncodingException e){
            throw new SerializationException("Error occur when deserializing");
        }
        return new Company(name,address);
    }
    @Override
    public void close() { }
}

消费者指定反序列化器


properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,CustomizeDeserializer.class.getName());

分区器

消息通过send()方法发送broker的过程中，有可能会经过拦截器，序列化器，之后，就会需要确定消息要发往的分区。如果ProducerRecord中指定了partition字段，那么就不需要分区器的作用。因为partition代表的就是索要发往的分区号。

kafka提供的默认分区器是org.apache.kafka.clients.producer.internals.DefaultPartitioner.它实现了org.apache.kafka.clients.producer.Partitioner接口，这个接口定义了2个方法：

//用来计算分区号。
 @params topic 分区
 @params key  消息的key
 @params keyBytes 序列化后的消息key
 @params value 消息值
 @params valueBytes 序列化后的值
 @params cluster 集群的元数据信息
 public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster);
 
 public void close();

当然Pratitioner接口还有一个父接口：org.apache.kafka.common.Configurable。该接口中只有一个方法:

//用来获取配置信息及初始化数据
  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;
        }
    }

可以看到：如果key不为null,那么默认分区器会对key进行哈希（采用MurmurHash2算法）得到的哈希值来计算分区号。

接下来我们可以自定义我们自己的分区器

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;

import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 分区器
 */
public class Dempartitioner implements Partitioner {

    private final AtomicInteger counter = new AtomicInteger(0); //原子操作类AtomicInteger
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object valye, byte[] valueBytes, Cluster cluster) {
         List<PartitionInfo> partitionInfos = cluster.partitionsForTopic(topic);
         int numPartitions = partitionInfos.size();
        if(null == keyBytes){
            return counter.getAndIncrement() % numPartitions;
        }else{
            return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions;
        }
    }
    @Override
    public void close() {}
    @Override
    public void configure(Map<String, ?> map) { }
}

指定分区器的配置

properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,Dempartitioner.class.getName());//partitioner.class

消息累加器

RecordAccumulator也叫消息累加器，主要用来缓存消息以便Sender线程可以批量发送，进而减少网络传输的资源消耗来提升性能。是在客户端开辟出的一块内存区域。

 this.accumulator = new RecordAccumulator(logContext, 
                                         config.getInt("batch.size"),
                                         this.totalMemorySize,
                                         this.compressionType, 
                                         config.getLong("linger.ms"),
                                         retryBackoffMs, 
                                         this.metrics, 
                                         this.time,
                                         this.apiVersions, 
                                         this.transactionManager);

参数buffer.memory，默认为33554432B，及32MB. 指定RecordAccumulator缓存的大小

如果生产者发送消息的速度超过发送到服务器的速度，则会导致生产者空间不足。这个时候producer的send方法要么被阻塞，要么抛出异常。这个取决于参数max.block.ms的配置，此参数默认值为60000，及60秒。

RecordAccumulator的内部为每个分区都维护了一个双端队列。队列中的具体内容就是ProducerBatch(消息批次).即Deque<ProducerBatch>.

通俗来讲，ProducerBatch为一个消息批次，可以将较小的ProducerRecord拼凑成一个较大的ProducerBatch.来减少网络请求次数提高吞吐量。

当然ProducerRecord即为我们的消息。

每次有消息要写入到累加器中的时候，会先去寻找对应的双端队列，从队列的尾部获取一个ProducerBatch, 事先会判断消息的大小，如果大小在被写入的Producerbatch批次范围内，则写入。如果没找到ProducerBatch或者消息大小大于被写入的批次范围无法写入的时候，就会新建一个ProducerBatch,根据参数batch.size来创建batch大小。如果消息大于batch.size的大小，就以评估的大小创建ProducerBatch.

消息写入缓存时，追加到双端队列的尾部Sender线程读取消息时，从双端队列的头部读取。注意ProducerBatch中可以包含很多个ProducerRecord（消息）。

在RecordAccumulator的内部还有一个BufferPool，主要来实现ButeBuffer的复用。不过BufferPool只针对特定大小的ByteBuffer进行管理。超过大小是不会进入BufferPool的。可以通过参数batch.size来指定。默认为16384B.

当每条消息流入消息累加器，会先寻找每个分区中的ProducerBatch双端队列。如果找不到，会判断消息的大小，如果小于batch.size。则用batch.size的大小来创建ProducerBatch.

sender线程会从RecordAccumulator中获取缓存的消息之后，进一步将消息封装成<Node,Request>的形式，通过KafkaClient进行IO操作。