9.Kafka拦截器

拦截器原理

Producer 拦截器(interceptor)是在 Kafka 0.10 版本被引入的，主要用于实现 clients 端的定制化控制逻辑。
对于 producer 而言，interceptor 使得用户在消息发送前以及 producer 回调逻辑前有机会对消息做一些定制化需求，比如修改消息等。同时，producer 允许用户指定多个 interceptor按序作用于同一条消息从而形成一个拦截链(interceptor chain)。
Intercetpor 的实现接口是org.apache.kafka.clients.producer.ProducerInterceptor，其定义的方法包括：

1. configure(configs)
   获取配置信息和初始化数据时调用。
2. onSend(ProducerRecord)
   该方法封装进 KafkaProducer.send 方法中，即它运行在用户主线程中。Producer 确保在消息被序列化以及计算分区前调用该方法。用户可以在该方法中对消息做任何操作，但最好保证不要修改消息所属的 topic 和分区，否则会影响目标分区的计算。
3. onAcknowledgement(RecordMetadata, Exception)
   该方法会在消息从 RecordAccumulator 成功发送到 Kafka Broker 之后，或者在发送过程中失败时调用，并且通常都是在 producer 回调逻辑触发之前。onAcknowledgement 运行在producer 的 IO 线程中，因此不要在该方法中放入很重的逻辑，否则会拖慢 producer 的消息发送效率。
4. close
   关闭 interceptor，主要用于执行一些资源清理工作。

如前所述，interceptor 可能被运行在多个线程中，因此在具体实现时用户需要自行确保线程安全。另外倘若指定了多个 interceptor，则 producer 将按照指定顺序调用它们，并仅仅是捕获每个 interceptor 可能抛出的异常记录到错误日志中而非在向上传递。这在使用过程中要特别留意。

拦截器案例

需求：实现一个简单的双 interceptor 组成的拦截链。第一个 interceptor （TimerInterceptor）会在消息发送前将时间戳信息加到消息 value 的最前部；第二个 interceptor （CounterInterceptor）会在消息发送后更新成功发送消息数或失败发送消息。

TimerInterceptor：

package com.huazai.kafka.example.interceptor;

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;

/**
 * @author pyh
 * @date 2021/8/23 23:25
 */
public class TimerInterceptor implements ProducerInterceptor {
    @Override
    public void configure(Map<String, ?> configs) {

    }

    /**
     * 在消息被序列化以及计算分区前调用该方法
     *
     * @param record
     * @return
     */
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        // 1.获取原来的消息
        Object value = record.value();
        // 2.加工消息
        return new ProducerRecord<String, Object>(record.topic(), record.partition(),
                record.key() + "", System.currentTimeMillis() + "," + value);
    }

    /**
     * RecordAccumulator 成功发送到 Kafka Broker 之后，或者在发送过程中失败时调用
     *
     * @param metadata
     * @param exception
     */
    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }

    @Override
    public void close() {

    }
}

CounterInterceptor：

package com.huazai.kafka.example.interceptor;

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;

/**
 * @author pyh
 * @date 2021/8/23 23:25
 */
public class CounterInterceptor implements ProducerInterceptor {
    // 成功发送消息数量
    int successCount;
    // 消息发送失败数量
    int errorCount;

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

    }

    /**
     * 在消息被序列化以及计算分区前调用该方法
     *
     * @param record
     * @return
     */
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        // 不处理则将原本的消息返回，
        return record;
    }

    /**
     * RecordAccumulator 成功发送到 Kafka Broker 之后，或者在发送过程中失败时调用
     *
     * @param metadata
     * @param exception
     */
    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {
        // metadata不为空，则表示消息发送成功
        if (metadata != null) {
            successCount++;
        } else {
            errorCount++;
        }
    }

    @Override
    public void close() {
        System.out.println("successCount：" + successCount);
        System.out.println("errorCount：" + errorCount);
    }
}

ProducerInterceptorTest：

package com.huazai.kafka.example.interceptor;

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

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;

/**
 * @author pyh
 * @date 2021/8/23 23:49
 */
public class ProducerInterceptorTest {
    private final static String TOPIC = "test_topic";

    private final static Integer COUNT = 100;

    public static void main(String[] args) throws Exception {
        Properties properties = new Properties();
        // kafka连接地址，多个地址用“,”隔开
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.64.132:9092,192.168.64.132:9093,192.168.64.132:9094");
        // 应答策略，all相当于-1
        properties.put(ProducerConfig.ACKS_CONFIG, "all");
        // 重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);
        // 每个分区未发送消息总字节大小（单位：字节），超过设置的值就会提交数据到服务端
        properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        // 如果数据迟迟未达到 batch.size，sender 等待 linger.time 之后就会发送数据。
        properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        // RecordAccumulator 缓冲区大小
        properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
        // 序列化key所用到的类
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        // 序列化value所用到的类
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        // 指定自定义拦截器
        List<String> interceptors = new ArrayList<>();
        interceptors.add("com.huazai.kafka.example.interceptor.TimerInterceptor");
        interceptors.add("com.huazai.kafka.example.interceptor.CounterInterceptor");
        properties.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
        KafkaProducer<String, String> producer = new KafkaProducer<String, String>(properties);

        CountDownLatch countDownLatch = new CountDownLatch(COUNT);
        for (int i = 0; i < COUNT; i++) {
            producer.send(new ProducerRecord<>(TOPIC, "", "test_topic " + UUID.randomUUID() + "-" + String.valueOf(i)), new Callback() {
                @Override
                public void onCompletion(RecordMetadata recordMetadata, Exception e) {
                    if (e == null) {
                        System.out.println("消息所在分区：" + recordMetadata.partition() + "，偏移量：" + recordMetadata.offset());
                    }
                    // 回调一遍倒数一遍，直至循环完才让主线程继续往下走
                    countDownLatch.countDown();

                }
            });
        }
        // 由于kafka是异步发送的，需要等到发送回调完成之后才能让程序结束，否则程序提前结束会导致发送失败。
        countDownLatch.await();
        System.out.println("发送完毕！");
        // 一定要关闭 producer，这样才会调用 interceptor 的 close 方法
        producer.close();

    }
}

启动程序，控制台输出结果如下：

消费者消费到的消息情况如下：