（1）kafka生产者设计和组件
（1）不同的应用场景对消息有不同的需求，即是否允许消息丢失、重复、延迟以及吞吐量的要求。不同场景对Kafka生产者的API使用和配置会有直接的影响。
例子1：信用卡事务处理系统，不允许消息的重复和丢失，延迟最大500ms，对吞吐量要求较高。
例子2：保存网站的点击信息，允许少量的消息丢失和重复，延迟可以稍高（用户点击链接可以马上加载出页面即可），吞吐量取决于用户使用网站的频度。
（2）Kafka发送消息的主要步骤
消息格式：每个消息是一个ProducerRecord对象，必须指定消息所属的Topic和消息值Value，此外还可以指定消息所属的Partition以及消息的Key。
1：序列化ProducerRecord
2：如果ProducerRecord中指定了Partition，则Partitioner不做任何事情；否则，Partitioner根据消息的key得到一个Partition。这是生产者就知道向哪个Topic下的哪个Partition发送这条消息。
3：消息被添加到相应的batch中，独立的线程将这些batch发送到Broker上
4：broker收到消息会返回一个响应。如果消息成功写入Kafka，则返回RecordMetaData对象，该对象包含了Topic信息、Patition信息、消息在Partition中的Offset信息；若失败，返回一个错误
（3）Kafka的顺序保证。Kafka保证同一个partition中的消息是有序的，即如果生产者按照一定的顺序发送消息，broker就会按照这个顺序把他们写入partition，消费者也会按照相同的顺序读取他们。
例子：向账户中先存100再取出来 和 先取100再存进去是完全不同的，因此这样的场景对顺序很敏感。
如果某些场景要求消息是有序的，那么不建议把retries设置成0,。可以把max.in.flight.requests.per.connection设置成1，会严重影响生产者的吞吐量，但是可以保证严格有序。
（2）创建Kafka生产者
要往Kafka中写入消息，需要先创建一个Producer，并设置一些属性。
Properties kafkaProps = new Properties();
kafkaProps.put("bootstrap.servers", "broker1:port1, broker2:port2");
kafkaProps.put("key.serializer", "org.apache.kafka.common.StringSerializer");
kafkaProps.put("value.serializer", "org.apache.kafka.common.StringSerializer");
producer = new KafkaProducer<String, String>(kafkaProps);Kafka的生产者有如下三个必选的属性：
（1）bootstrap.servers，指定broker的地址清单
（2）key.serializer必须是一个实现org.apache.kafka.common.serialization.Serializer接口的类，将key序列化成字节数组。注意：key.serializer必须被设置，即使消息中没有指定key。
（3）value.serializer，将value序列化成字节数组
（3）发送消息到Kafka
（1）同步发送消息
ProducerRecord<String, String> record = new ProducerRecord<>("CustomCountry", "Precision Products", "France");//Topic Key Value
try{
Future future = producer.send(record);
future.get();//不关心是否发送成功，则不需要这行。
} catch(Exception e) {
e.printStackTrace();//连接错误、No Leader错误都可以通过重试解决；消息太大这类错误kafkaProducer不会进行任何重试，直接抛出异常
}（2）异步发送消息
ProducerRecord<String, String> record = new ProducerRecord<>("CustomCountry", "Precision Products", "France");//Topic Key Value
producer.send(record, new DemoProducerCallback());//发送消息时，传递一个回调对象，该回调对象必须实现org.apahce.kafka.clients.producer.Callback接口
private class DemoProducerCallback implements Callback {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e != null) {//如果Kafka返回一个错误，onCompletion方法抛出一个non null异常。
e.printStackTrace();//对异常进行一些处理，这里只是简单打印出来
}
}
}（4）生产者的配置
（1）acks
指定必须要有多少个partition副本收到消息，生产者才会认为消息的写入是成功的。
acks=0，生产者不需要等待服务器的响应，以网络能支持的最大速度发送消息，吞吐量高，但是如果broker没有收到消息，生产者是不知道的
acks=1，leader partition收到消息，生产者就会收到一个来自服务器的成功响应
acks=all，所有的partition都收到消息，生产者才会收到一个服务器的成功响应
（2）buffer.memory，
设置生产者内缓存区域的大小，生产者用它缓冲要发送到服务器的消息。
（3）compression.type，默认情况下，消息发送时不会被压缩，该参数可以设置成snappy、gzip或lz4对发送给broker的消息进行压缩，gzip占用cpu多，高压缩比，使用带宽有限。snappy则占用少cpu，带宽占用大
（4）retries，生产者从服务器收到临时性错误时，生产者重发消息的次数
（5）batch.size，发送到同一个partition的消息会被先存储在batch中，该参数指定一个batch可以使用的内存大小，单位是byte。不一定需要等到batch被填满才能发送
（6）linger.ms，生产者在发送消息前等待linger.ms，从而等待更多的消息加入到batch中。如果batch被填满或者linger.ms达到上限，就把batch中的消息发送出去
（7）client.id 该参数可以是任意字符串，服务器用来识别消息的来源，
（8）max.in.flight.requests.per.connection，生产者在收到服务器响应之前可以发送的消息个数 ，值越高，就会占用越多的内存， 也会提升存吐量，若把它设为1，可以保证消息按照发送顺序写入到服务器。及时发生了重试。
（9）request.timeout.ms
此配置设置客户端等待请求响应的最长时间，默认为30000ms=30秒，如果在这个时间内没有收到响应，客户端将重发请求，如果超过重试次数将抛异常。此配置应该比replica.lag.time.max.ms（broker配置，默认10秒）大，以减少由于生产者不必要的重试造成消息重复的可能性。
（10） max.block.ms
当发送缓冲区已满或者元数据不可用时，生产者调用send()和partitionsFor()方法会被阻塞，默认阻塞时间为60000ms=1分钟。由于使用用户自定义的序列化器和分区器造成的阻塞将不会计入此时间。
（11） max.request.size
此配置设置生产者在单个请求中能够发送的最大字节数，默认为1048576字节=1MB。例如，你可以发送单个大小为1MB的消息或者1000个大小为1KB的消息。注意，broker也有接收消息的大小限制，使用的配置是message.max.bytes=1000012字节（好奇怪的数字，约等于1MB）。
（12） receive.buffer.bytes和send.buffer.bytes
receive.buffer.bytes：读取数据时使用的TCP接收缓冲区（SO_RCVBUF）的大小，默认值为32768字节=32KB。如果设置为-1，则将使用操作系统的默认值。
send.buffer.bytes：发送数据时使用的TCP发送缓冲区（SO_SNDBUF）的大小，默认值为131072字节=128KB。如果设置为-1，则将使用操作系统的默认值。
（5）序列化器
在创建ProducerRecord时，必须指定序列化器，推荐使用序列化框架Avro、Thrift、ProtoBuf等，不推荐自己创建序列化器。
在使用 Avro 之前，需要先定义模式（schema），模式通常使用 JSON 来编写。
（1）创建一个类表示一个客户
class Custom {
private int customID;
private String customerName;
public Custom(int customID, String customerName) {
super();
this.customID = customID;
this.customerName = customerName;
}
public int getCustomID() {
return customID;
}
public String getCustomerName() {
return customerName;
}
}（2）定义schema
{
"namespace": "customerManagement.avro",
"type": "record",
"name": "Customer",
"fields":[
{
"name": "id", "type": "string"
},
{
"name": "name", "type": "string"
},
]
}(2)为这个类创建一个序列化器
public class CustomerSerializer implements Serializer<Customer> {
@Override
public void configure(Map<String, ?> configs, boolean isKey) {
// nothing to configure
}
@Override
/**
* We are serializing Customer as:
* 4 byte int representing customerId
* 4 byte int representing length of customerName
* in UTF-8 bytes (0 if name is Null)
* N bytes representing customerName in UTF-8
*/
public byte[] serialize(String topic, Customer data) {
try {
byte[] serializedName;
int stringSize;
if (data == null)
return null;
else {
if (data.getName() != null) {
serializedName = data.getName().getBytes("UTF-8");
stringSize = serializedName.length;
} else {
serializedName = new byte[0];
stringSize = 0;
}
}
ByteBuffer buffer = ByteBuffer.allocate(4 + 4 + stringSize);
buffer.putInt(data.getID());
buffer.putInt(stringSize);
buffer.put(serializedName);
return buffer.array();
} catch (Exception e) {
throw new SerializationException("Error when serializing Customer to byte[] " + e);
}
}
@Override
public void close() {
// nothing to close
}
（3）生成Avro对象发送到Kafka
Properties props = new Properties();
props.put("bootstrap", "loacalhost:9092");
props.put("key.serializer", "io.confluent.kafka.serializers.KafkaAvroSerializer");
props.put("value.serializer", "io.confluent.kafka.serializers.KafkaAvroSerializer");
props.put("schema.registry.url", schemaUrl);//schema.registry.url指向射麻的存储位置
String topic = "CustomerContacts";
Producer<String, Customer> produer = new KafkaProducer<String, Customer>(props);
//不断生成消息并发送
while (true) {
Customer customer = CustomerGenerator.getNext();
ProducerRecord<String, Customer> record = new ProducerRecord<>(topic, customer.getId(), customer);
producer.send(record);//将customer作为消息的值发送出去，KafkaAvroSerializer会处理剩下的事情
}（6）Partition
ProducerRecord可以只包含Topic和消息的value，key默认是null，但是大多数应用程序会用到key，key的两个作用：
（1）作为消息的附加信息
（2）决定消息该被写到Topic的哪个partition，拥有相同key的消息会被写到同一个partition。
如果key为空，kafka使用默认的partitioner，使用RoundRobin算法将消息均衡地分布在各个partition上；
如果key不为空，kafka使用自己实现的hash方法对key进行散列，相同的key被映射到相同的partition中。只有在不改变partition数量的前提下，key和partition的映射才能保持不变。
kafka也支持用户实现自己的partitioner，用户自己定义的paritioner需要实现Partitioner接口。
import java.util.List;
import java.util.Map;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import org.apache.kafka.common.PartitionInfo;
import org.apache.kafka.common.record.InvalidRecordException;
import org.apache.kafka.common.utils.Utils;
public class CustomerPartitioner implements Partitioner {
private Map<String, ?> configs;
@Override
public void configure(Map<String, ?> configs) {（1）
this.configs = configs;
}
@Override
public int partition(String topic, Object key, byte[] keyBytes,
Object value, byte[] valueBytes, Cluster cluster) {
List<PartitionInfo> partitions = cluster.partitionsForTopic(topic);
int numPartitions = partitions.size();
if ((keyBytes == null) || (!(key instanceof String))) {（2）
throw new InvalidRecordException("We expect all messages to have customer name as key");
}
if (((String) key).equals(configs.get("key"))) {
return numPartitions; //key总是被分配到最后一个分区
}
return (Math.abs(Utils.murmur2(keyBytes)) % (numPartitions - 1));//其他记录被三列到其他分区
}
@Override
public void close() {
// do something here
}
}
（1） partition 接口包含了configure，partition，和close 这3个方法，configure方法传递业务规则。
（2） 这里只接受字符串，不是字符串，抛出异常。
