kafka学习笔记三--kafka生产者

kafka有着自定义的网络协议，使用者只要遵守该协议格式，就可向kafka发送和拉取消息。老版本通过scala实现的生产者客户端已经被标记“废弃”，最新版本的通过java实现的KafkaProducer为我们实现同步/异步/发送消息，批量发送、超时重发等功能提供了便利。我们可以在Kafka clients模块的org.apache.kafka.client.producer包里找到该API的具体实现来学习。

下面我们打开examples目录下的Producer.java来学习生产者的同步和异步实现。

Producer类首先根据配置文件创建一个生产者客户端对象KafkaProducer,然后根据isAsync参数决定生产者发送消息的模式，为true为异步发送，false为同步发送。每一条消息都会被包装成一条生产者记录（ProducerRecord）,并将其通过KafkaProducer对象的send()发送给Kafka服务端集群。

KafkaProducer通过send()，实现了同步和异步的消息发送。

• 同步：调用send返回Feture,然后调用get()即可实现消息的同步发送，因为get方法在没有返回结果时候会一直阻塞，只有得到服务端的响应结果后，才可以发送下一条消息。
• 异步：通过参数Callback匿名回调类，当客户端发送完一条消息，该消息成功存储到kafka集群后，不需要关心服务端是否处理完消息，服务端会自动调用onCompletion回调方法，返回结果给生产者客户端。

public class Producer extends Thread {
    private final KafkaProducer<Integer, String> producer;
    private final String topic;
    private final Boolean isAsync;

    public Producer(String topic, Boolean isAsync) {
        Properties props = new Properties();
        //kafka服务器的主机号和端口号
        props.put("bootstrap.servers", "localhost:9092");
        //客户端ID
        props.put("client.id", "DemoProducer");
        //消息的key-value都是字节数组，为了把对象转换成字节数组，配置了key.serializer和value.serializer两个序列转换器   

        props.put("key.serializer","org.apache.kafka.common.serialization.IntegerSerializer");
        //StringSerializer用来把String对象序列化成字节数组
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //用参数构造KafkaProducer对象
        producer = new KafkaProducer<>(props);
        this.topic = topic;
        this.isAsync = isAsync;
    }

    public void run() {
        int messageNo = 1;
        while (true) {
            String messageStr = "Message_" + messageNo;
            long startTime = System.currentTimeMillis();
            if (isAsync) { // Send asynchronously（异步发送）
    //发送两个参数，第一个是包含Topic，key-value的ProducerRecord对象；第二个是CallBack对象
                producer.send(new ProducerRecord<>(topic,
                    messageNo,
                    messageStr), new DemoCallBack(startTime, messageNo, messageStr));
            } else { // Send synchronously（同步发送）
                try {
    //KafkaProducer.send()返回值类型为Future<RecordMetadata>。通过Feture,get()，可以阻塞当前进程，等待kafka服务端的ACK响应
                    producer.send(new ProducerRecord<>(topic,
                        messageNo,
                        messageStr)).get();
                    System.out.println("Sent message: (" + messageNo + ", " + messageStr + ")");
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }    
            ++messageNo;//递增消息的key
        }
    }
}
class DemoCallBack implements Callback {

    private final long startTime;//开始发送消息的时间戳
    private final int key;//key
    private final String message;//value

    public DemoCallBack(long startTime, int key, String message) {
        this.startTime = startTime;
        this.key = key;
        this.message = message;
    }
/**
    生产者成功发送消息，收到kafka服务器发来的ACK确认消息后，会调用该回调函数，
    如果生产者发送的消息元数据发送时出现异常，则metadata为null,
    如果发送过程中未出现异常，则exception为null
**/
    //RecordMetadata中包含了分区信息，offset信息等
    public void onCompletion(RecordMetadata metadata, Exception exception) {
        long elapsedTime = System.currentTimeMillis() - startTime;
        if (metadata != null) {
            System.out.println(
                "message(" + key + ", " + message + ") sent to partition(" + metadata.partition() +
                    "), " +
                    "offset(" + metadata.offset() + ") in " + elapsedTime + " ms");
        } else {
            exception.printStackTrace();
        }
    }
}