Kafka生产者拦截器的使用

拦截器定义

package thread;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.kafka.clients.producer.ProducerInterceptor;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.clients.producer.RecordMetadata;

import java.io.IOException;
import java.util.Map;

public class MyKafkaInterceptor implements ProducerInterceptor {
// 每条消息发送之前，都会调用该方法,因此我们可以拦截要发送的消息，修改其状态
    @Override
    public ProducerRecord onSend(ProducerRecord record) {
        String jsonStr = "{\"topic\":\""+ record.topic() +"\"," +
                "\"value\":\""+record.value()+"\"}";
        System.out.println(jsonStr);
        KFKBean kfkBean = new KFKBean();
        try {
             kfkBean = mapper.readValue(jsonStr, KFKBean.class);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new ProducerRecord(record.topic(),
                record.key(),
                kfkBean.toString());
    }

// 每条消息发送完后，无论成功还是失败，都会调用该方法,所以在此方法里面不应当做非常耗时的操作，以免影响效率
    @Override
    public void onAcknowledgement(RecordMetadata metadata, Exception exception) {

    }

    @Override
    public void close() {

    }

    private ObjectMapper mapper;
   /**
     * 该方法在初始化KafkaProducer的时候，通过反射实例化Interceptor的时候，调用此方法
     * 所以有些只需初始化一次的资源，应当放在该方法中完成初始化
     *  public <T> List<T> getConfiguredInstances(List<String> classNames, Class<T> t, Map<String, Object> configOverrides) {
     *      '''
     *      '''
     *       if (o instanceof Configurable)
     *                 ((Configurable) o).configure(configPairs);
     *       ....
     *  }
     *
     *
     * @param configs
     */
    @Override
    public void configure(Map<String, ?> configs) {
        mapper = new ObjectMapper();
        for (Map.Entry cfg : configs.entrySet()) {
            System.out.println(cfg.getKey() + " = " + cfg.getValue());
        }
    }
}

KFKBean定义

package thread;

public class KFKBean {
    private String topic;
    private String value;

    public String getTopic() {
        return topic;
    }

    public String getValue() {
        return value;
    }

    public void setTopic(String topic) {
        this.topic = topic;
    }

    public void setValue(String value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "KFKBean{" +
                "topic='" + topic + '\'' +
                ", value='" + value + '\'' +
                '}';
    }
}

 

发送消息的拦截

  public static Properties buildKafkaProperties(String kafka_broker_list){
        Properties props = new Properties();
        //设置生产者拦截器, 传入的是拦截器的全类限定名，可以推断，拦截器是通过反射完成实例化的
        List<String> interceptors = new ArrayList<>();
        interceptors.add("thread.MyKafkaInterceptor");
        props.put(ProducerConfig.INTERCEPTOR_CLASSES_CONFIG,interceptors);

        props.put("bootstrap.servers", kafka_broker_list);
        props.put("acks", "all"); //是否成功的标准
        props.put("retries", "3"); //重试次数
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        return props;
    }


 public static void main(String[] args){

       Properties props = buildKafkaProperties(XG_KAFKA_BROKER_LIST);
       KafkaProducer producer = new KafkaProducer<String, String>(props);


        String to_topic = "liu-text-20200507";

        String record = "message record"+System.currentTimeMillis();
        producer.send(new ProducerRecord<String, String>(to_topic,
                String.valueOf(System.currentTimeMillis()),
                record));

        producer.close();



    }

kafka查看发送消息内容

[bigdataservice@hadoop001 ~]$ kafka-console-consumer --topic liu-text-20200507 --bootstrap-server kafka01:9092 --from-beginning  
KFKBean{topic='liu-text-20200507', value='message record1602210981895'}
KFKBean{topic='liu-text-20200507', value='message record1602212731947'}