Kafka生产者

Kafka生产者

1. Kafka生产者组件

2. 创建Kafka生产者

要往Kafka写入消息，首先要创建一个生产者对象，并设置一些属性。Kafka生产者有3个必选的属性。

1. bootstrap.servers
   该属性指定broker的地址清单，地址的格式为host:port。不需要包含所有的broker地址，建议至少要提供两个broker的信息。
2. key.serializer
   这个属性必须设置为一个实现了 org.apache.kafka.common.serialization
   .Serializer接口的类，生产者会使用这个类把键对象序列化成字节数组。Kafka客户端默认提供了ByteArraySerializer、StringSerializer和IntegerSerializer。
3. value.serializer
   该属性将值序列化。如果键和值都是字符串，可以使用与key.serializer一样的序列化器。

Properties kafkaProps = new Properties();
kafkaProps.put("bootstrap.servers","broker1:9092,broker2:9092");
kafkaProps.put("key.serializer","org.apache.kafka.common,serialization.StringSerializer");
kafkaProps.put("value.serializer","org.apache.kafka.common,serialization.StringSerializer");
KafkaProducer producer = new KafkaProducer<String,String>(kafkaProps);

实例化生产者后，下面就可以发送消息了。发送消息主要有3种方式：

• 发送并忘记(fire-and-forget)
  生产者把消息发送给服务器，但并不关心它是否正常到达。
• 同步发送
  生产者使用send()方法发送消息，它会返回一个Future对象，调用get()方法进行等待，就可以知道消息是否发送成功。
• 异步发送
  生产者使用send()方法发送消息，并指定一个回调函数，服务器在返回响应时调用该函数。

3. 发送消息到Kafka

//topic,key,value
ProducerRecord<String,String> record = new ProducerRecord<String,String>("CustomerCountry","Precision Products","France");
try{
	producer.send(record);
}catch(Exception e){
	e.printStackTrace();
}

3.1 同步发送消息

//topic,key,value
ProducerRecord<String,String> record = new ProducerRecord<String,String>("CustomerCountry","Precision Products","France");
try{
	//如果服务器返回错误，get()方法会抛出异常，
	//如果没有发生错误，则返回一个RecordMetadata对象可以用它获取消息的偏移量。
	producer.send(record).get();
}catch(Exception e){
	e.printStackTrace();
}

Kafka一般会发生两类错误。

1. 可重试错误。
   这类错误可以通过重发消息来解决，比如对于连接错误，可以通过再次建立连接来解决。”无主(no leader)“错误则可以通过重新为分区选取首领来解决。
2. 无法通过重试解决错误。
   比如”消息太大“异常，对于这类错误，KafkaProducer不会进行任何重试，直接抛出异常。

3.2 异常发送消息

为了在异常发送消息的同时能够对异常情况进行处理，生产者提供了回调支持。

//为了使用回调，需要一个实现了
//org.apache.kafka.clients.producer.Callback接口的类，
//这个接口只有一个onCompletion方法。
//如果kafka返回一个错误，onCompletion方法会抛出一个非空(non null)异常。
private class DemoProducerCallback implements Callback{
	@Override
	public void onCompletion(RecordMetadata recordMetadata,Exception e){
	if(e != null){
		e.printStackTrace();
		}
	}
}
ProducerRecord<String,String> record = new ProducerRecord<String,String>("CustomerCountry","Precision Products","France");
producer.send(record,new DemoProducerCallback());

4. 生产者的配置

除了上面的介绍的3个参数，生产者还有很多可配置的参数。这里将介绍对内存使用、性能和可靠性方面对生产者影响比较大的。

1. acks
   acks参数指定了必须要有多少个分区副本收到消息，生产者才会认为消息写入是成功的。
   acks=0,生产者在成功写入之前不会等待任何来自服务器的响应。
   acks=1,只要集群的首领节点收到消息，生产者就会收到一个来自服务器的成功响应。如果消息无法到达首领节点，生产者会收到一个错误响应，为了避免丢失，生产者会重发消息。
   acks=all,只有当所有参与复制的节点全部收到消息时，生产者才会收到一个来自服务器的成功响应。这种模式最安全，但是延迟比acks=1更高。

2. buffer.memory
   该参数用来设置生产者内存缓冲区的大小，生产者用它缓冲要发送到服务器的消息。如果应用程序发送消息的速度超过发送到服务器的速度，会导致生产者空间不足。这个时候，send()方法调用要么被阻塞，要么抛出异常，取决于如何设置block.on.buffer.full参数(在0.9.0.0版本里被替换为max.block.ms，表示在抛出异常之前可以阻塞一段时间)。

3. compression.type
   默认情况下，消息发送时不会被压缩。该参数可以设置为snappy，gzip或lz4，它指定了消息被发送给broker之前使用哪一种压缩算法进行压缩。

4. retries
   retries参数的值决定了生产者可以重发消息的次数，如果达到这个次数，生产者会放弃重试并返回错误。生产者会在每次重试之间等待100ms，不过可以通过retry.backoff.ms参数来改变这个时间间隔。

5. batch.size
   当有多个消息需要被发送到同一个分区时，生产者会把它们放到同一个批次里。该参数指定了一个批次可以使用的内存大小，按照字节数计算(而不是消息个数)。当批次被填满，批次里的所有消息会被发送出去。不过生产者并不一定都会等到批次被填满才发送，半满的批次，甚至只包含一个消息的批次也有可能被发送。所以就算把批次大小设置得很大，也不会造成延迟，只是会占用更多的内存。

6. linger.ms
   该参数指定了生产者在发送批次之前等待更多消息加入批次的时间。KafkaProducer会在批次填满或linger.ms达到上限时把批次发送出去。默认情况下，只要有可用的线程，生产者就会把消息发送出去，就算批次里只有一个消息。

7. client.id
   该参数可以是任意的字符串，服务器会用它来识别消息的来源，还可以用在日志和配额指标里。

8. max.in.flight.requests.per.connection
   该参数指定了生产者在收到服务器响应之前可以发送多少个消息。

9. timeout.ms、request.timeout.ms和metadata.fetch.timeout.ms
   request.timeout.ms指定了生产者在发送数据时等待服务器返回响应的时间，metadata.fetch.timeout.ms指定了生产者在获取元数据(比如目标分区的首领是谁)时等待服务器返回响应的时间。timeouts.ms指定了broker等待同步副本返回消息确认的时间，与acks的配置相匹配----如果在指定时间内没有收到同步副本的确认，那么broker就会返回一个错误。

10. max.block.ms
    该参数指定了在调用send()方法或使用partitionsFor()方法获取元数据时生产者的阻塞时间。当生产者的发送缓冲区已满，或者没有可用的元数据时，这些方法就会阻塞。在阻塞时间达到max.block.ms时，生产者会抛出超时异常。

11. max.request.size
    该参数用于控制生产者发送的请求大小。它可以指能发送的单个消息的最大值，也可以指单个请求里所有消息总的大小。

12. receive.buffer.bytes和send.buffer.bytes
    这两个参数分别指定了TCP socket接收和发送数据包的缓冲区大小。如果它们被设为-1，就使用操作系统的默认值。如果生产者或消费者与broker处于不同的数据中心，那么可以适当增大这些值，因为跨数据中心的网络一般都有比较高的延迟和比较低的带宽。

顺序保证
Kafka可以保证同一个分区里的消息是有序的。也就是说，如果生产者按照一定的顺序发送消息，broker就会按照这个顺序把它们写入分区，消费者也会按照同样的顺序读取它们。

5. 序列化器

5.1 自定义序列化器

如果发送到Kafka的对象不是简单的字符串或整数，那么可以使用序列化框架来创建消息记录，如Avro、Thrift或Protobuf，或者使用自定义序列化器。

5.2 使用Avro序列化

Avro数据通过与语言无关的schema来定义。schema通过JSON来描述，数据被序列化成二进制文件或JSON文件，不过一般会使用二进制文件。Avro在读写文件时需要用到schema，schema一般会被内嵌在数据文件里。
Avro有一个特性，当负责写消息的应用程序使用了新的schema，负责读消息的应用程序可以继续处理消息而无需做任何改动，这个特性使得它特别适合用在像Kafka这样的消息系统上。

//旧的schema
{
	"namespace":"customerManagement.avro",
	"type":"record",
	"name":"Customer",
	"fields":[
	{"name":"id","type":"int"},
	{"name":"name","type":"string"}
	{"name":"faxNumber","type":["null","string","default":"null"]}
	]
}
//新的schema
{
	"namespace":"customerManagement.avro",
	"type":"record",
	"name":"Customer",
	"fields":[
	{"name":"id","type":"int"},
	{"name":"name","type":"string"}
	{"name":"email","type":["null","string","default":"null"]}
	]
}
//在应用程序升级之前，他们会调用类似getName()，getId()和getFaxNumber()方法。
//如果碰到一个使新schema构建的消息，getName()和getId()方法仍然能够正常返回，
//但getFaxNumber()方法会返回null，因为消息里不包含传真号码。

Avro的好处就是：当我们修改了消息的schema，但并没有更新所有负责读取数据的应用程序，而这样仍然不会出现异常或阻断型错误，也不需要对现有数据进行大幅度更新。
不过这里有以下两个需要注意的地方。

• 用于写入数据和读取数据的schema必须是相互兼容的。Avro文档提到了一些兼容性原则。
• 反序列化器需要用于写入数据的schema，即使它可能与用于读取数据的schema不一样。Avro数据文件里就包含了用于写入数据的schema。

5.4 在Kafka里使用Avro

在Kafka中，遵循通用的结构模式并使用”schema注册表“。把所有写入数据需要用到的schema都保存在注册表里，然后在记录里引用schema的标识符。负责读取数据的应用程序使用标识符从注册表里拉取schema来反序列化记录。序列化和反序列化分别负责处理schema的注册和拉取。

Properties props = new Properties();
props.put("bootstrap.servers","localhost:9092");
//使用Avro的KafkaAvroSerializer来序列化对象。
props.put("key.serializer","io.confluent.kafka.serializers.KafkaAvroSerializer");
props.put("value.serializer","io.confluent.kafka.serializers.KafkaAvroSerializer");
//schema.registry.url指向schema的存储位置。
props.put("schema.registry.url",schemaUrl);

String topic = "customerContacts";

KafkaProducer<String,Customer> producer = new KafkaProducer<String,Customer>(props);

while(true){
	Customer customer = CustomerGenerator.getNext();
	System.out.println("Generated customer "+customer.toString());
	ProducerRecord<String,Customer> record = new ProducerRecord<String,Customer>(topic,customer.getId(),customer);
	producer.send(record);
}

如果选择使用一般的Avro对象而非生成的Avro对象，这个时候只需提供schema。

6. 分区

键有两个用途：可以作为消息的附加信息，也可以用来决定消息该被写到主题的哪个分区。拥有相同键的消息将被写到同一个分区。也就是如果一个进程只从一个主题的分区读取数据，那么具有相同键的所有记录都会被该进程读取。

//键不为null
ProducerRecord<String,String> record = new ProducerRecord<String,String>("CustomerCountry","Precision Products","France");
//键为null
ProducerRecord<String,String> record = new ProducerRecord<String,String>("CustomerCountry","France");
//如果键为null，并且使用了默认的分区器，那么记录将被随机地发送到主题内各个可用的分区上。
//分区器使用轮询(Round Robin)算法将消息均衡地分布到各个分区上。
//如果键不为空，并且使用了默认的分区器，那么Kafka会对键进行散列(使用Kafka自己的散列算法)，然后根据散列值把消息映射到特定的分区上。
//只有在不改变主题分区数量的情况下，键和分区之间的映射才能保持不变。

实现自定义分区策略

public class BananaPartitioner implements Partitioner{
	public void configure(Map<String,?> configs){}
	
	public int partition(String topic,Object key,byte[] KeyBytes,Object value, byte[] valueBytes, Cluster cluster){}
	
	public void close(){}
}
//Partitioner接口包含了configure、partition和close这3个方法。