Kafka自定义拦截器链

拦截器一：为消息添加指定前缀

package com.aura.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 panghu
 * @description  自定义拦截器 为消息加前缀
 * @create 2021-02-27-22:45
 */
public class MyInterceptor implements ProducerInterceptor<String, String>{
    
    
    private String prefix;

    /**
     * send数据时调用
     * @param producerRecord
     * @return
     */
    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> producerRecord) {
    
    
        return new ProducerRecord<String, String>(
                producerRecord.topic(),
                producerRecord.partition(),
                producerRecord.timestamp(),
                producerRecord.key(),
                // 为每条消息前面加上时间戳
                //System.currentTimeMillis() + producerRecord.value(),
                // 为每条消息添加指定前缀
                prefix + producerRecord.value(),
                producerRecord.headers()
        );
    }

    /**
     * 接收到ack时调用
     * @param recordMetadata
     * @param e
     */
    @Override
    public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
    
    

    }

    /**
     * Producer关闭时调用
     */
    @Override
    public void close() {
    
    

    }

    /**
     * 配置参数
     * @param map
     */
    @Override
    public void configure(Map<String, ?> map) {
    
    
        prefix = (String) map.get("prefix");
    }
}

拦截器二：统计消息发送成功和失败的数量

package com.aura.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 panghu
 * @description 自定义拦截器，统计消息发送成功和失败数量
 * @create 2021-02-27-22:51
 */
public class CounterInterceptor implements ProducerInterceptor<String, String> {
    
    
    private int success;
    private int failed;

    @Override
    public ProducerRecord<String, String> onSend(ProducerRecord<String, String> producerRecord) {
    
    
        return producerRecord;
    }

    /**
     * 收到ack后统计数量
     *
     * @param recordMetadata
     * @param e
     */
    @Override
    public void onAcknowledgement(RecordMetadata recordMetadata, Exception e) {
    
    
        if (e == null) {
    
    
            success++;
        } else {
    
    
            failed++;
        }
    }

    /**
     * producer关闭时调用
     */
    @Override
    public void close() {
    
    
        System.out.println("成功了" + success + "条");
        System.out.println("失败了" + failed + "条");
    }

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

    }
}

生产者

package com.aura.interceptor;

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

import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.Future;

/**
 * @author panghu
 * @description
 * @create 2021-02-27-22:54
 */
public class ProducerWithInterceptor {
    
    
    public static void main(String[] args) {
    
    
        // 1.创建KafkaProducer实例
        List<String> interceptors = new ArrayList<>();
        interceptors.add("com.aura.interceptor.MyInterceptor");
        interceptors.add("com.aura.interceptor.CounterInterceptor");

        Properties prop = new Properties();
        prop.setProperty("bootstrap.servers", "hadoop01:9092,hadoop02:9092,hadoop03:9092");
        prop.setProperty("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        prop.setProperty("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        prop.setProperty("acks", "all");
        // 配置拦截器
        prop.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG, interceptors);
        // 指定消息前缀
        prop.setProperty("prefix", "log-");

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

        // 2.发送数据
        for (int i = 0; i < 20; i++) {
    
    
            Future<RecordMetadata> future = producer.send(
                    // 将数据封装到ProducerRecord中
                    new ProducerRecord<String, String>("first", Integer.toString(i), "first" + i),
                    // 异步发送，回调函数
                    new Callback() {
    
    
                        @Override
                        public void onCompletion(RecordMetadata recordMetadata, Exception e) {
    
    
                            if (e == null) {
    
    
                                System.out.println(recordMetadata.toString());
                                System.out.println();
                            }
                        }
                    }
            );

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