KafKa生产者-分区
生产者（producer）采用推（push）模式将消息发布到broker，每条消息都被追加（append）到分区（patition）中，属于顺序写磁盘（顺序写磁盘效率比随机写内存要高，保障kafka吞吐率）。消息发送时都被发送到一个topic，其本质就是一个目录，而topic是由一些Partition Logs(分区日志)组成，其组织结构如下图所示：
可以看出，每个Partition中的消息都是有序的，生产的消息被不断追加到Partition log上，其中的每一个消息都被赋予了一个唯一的offset值。每个分区内部也独立地维护了一个从0开始的offset值，offset只保证区内有序，即生产顺序和消费顺序一致。
1、分区的原因
（1）方便在集群中扩展，每个Partition可以通过调整以适应它所在的机器，而一个topic又可以有多个Partition组成，因此整个集群就可以适应任意大小的数据了；
（2）可以提高并发度，因为可以以Partition为单位读写了。
2、分区的方式
生产者向broker发送数据，需要将要发送的数据封装成一个ProducerRecord对象，ProducerRecord这个类含有多个重载的构造方法，每一种构造方法都有不同的参数，也就代表了不同的分区方法。
通过观察源码发现，这几种构造方法最终执行的都是上图的第一个构造方法，只不过在各自方法内部调用时，自身没有包含的参数在调用第一个构造方法的时候都设置为了null，这些重载的含有不同参数的构造方法调用第一个方法，第一个方法会根据传进来的参数值为成员变量赋值，没有值的则赋值为null，我们来看一下第一个构造方法的源码：
public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value, Iterable<Header> headers) { if (topic == null) throw new IllegalArgumentException("Topic cannot be null."); if (timestamp != null && timestamp < 0) throw new IllegalArgumentException( String.format("Invalid timestamp: %d. Timestamp should always be non-negative or null.", timestamp)); if (partition != null && partition < 0) throw new IllegalArgumentException( String.format("Invalid partition: %d. Partition number should always be non-negative or null.", partition)); this.topic = topic; this.partition = partition; this.key = key; this.value = value; this.timestamp = timestamp; this.headers = new RecordHeaders(headers); }
由代码可知，该方法对ProducerRecord对象做一个初始化的处理，将各个参数赋值给对应的成员变量，其中有的成员变量可能会被赋值为null。这些信息既有消息的的元数据，也有实际要发布的数据。会通过一个生产者对象，调用send方法发送。下面是KafkaProducer的send方法的源码：
send方法是通过异步的方式将record发送到主题的，其最终调用的也是第二个send方法
/** * Asynchronously send a record to a topic. Equivalent to <code>send(record, null)</code>. * See {@link #send(ProducerRecord, Callback)} for details. */ @Override public Future<RecordMetadata> send(ProducerRecord<K, V> record) { return send(record, null); } …… @Override public Future<RecordMetadata> send(ProducerRecord<K, V> record, Callback callback) { // intercept the record, which can be potentially modified; this method does not throw exceptions ProducerRecord<K, V> interceptedRecord = this.interceptors == null ? record : this.interceptors.onSend(record); return doSend(interceptedRecord, callback); }
观察第二个send方法发现，它会先判断是否有拦截器对象，如果没有就直接返回doSend方法的返回值，如果有拦截器对象则会去执行拦截器对象的onSend方法。这里继续观察探索doSend方法，这个方法是异步发送消息的主题的具体实现：
可看出该方法会依次将key和value进行序列化操作，然后计算一下分区，然后根据record的主题和partition函数返回的分区构建一个TopicPartition对象，最终这个对象会和时间戳信息、序列化之后的key、value等信息一起追加到accumulator这个线程共享变量中，等待sender线程将accumulator中的消息发送给broker
private Future<RecordMetadata> doSend(ProducerRecord<K, V> record, Callback callback) { TopicPartition tp = null; try { …… byte[] serializedKey; try { serializedKey = keySerializer.serialize(record.topic(), record.headers(), record.key()); } catch (ClassCastException cce) { throw new SerializationException("Can't convert key of class " + record.key().getClass().getName() + " to class " + producerConfig.getClass(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG).getName() + " specified in key.serializer"); } byte[] serializedValue; try { serializedValue = valueSerializer.serialize(record.topic(), record.headers(), record.value()); } catch (ClassCastException cce) { throw new SerializationException("Can't convert value of class " + record.value().getClass().getName() + " to class " + producerConfig.getClass(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG).getName() + " specified in value.serializer"); } int partition = partition(record, serializedKey, serializedValue, cluster); tp = new TopicPartition(record.topic(), partition); setReadOnly(record.headers()); Header[] headers = record.headers().toArray(); int serializedSize = AbstractRecords.estimateSizeInBytesUpperBound(apiVersions.maxUsableProduceMagic(), compressionType, serializedKey, serializedValue, headers); ensureValidRecordSize(serializedSize); long timestamp = record.timestamp() == null ? time.milliseconds() : record.timestamp(); log.trace("Sending record {} with callback {} to topic {} partition {}", record, callback, record.topic(), partition); // producer callback will make sure to call both 'callback' and interceptor callback Callback interceptCallback = this.interceptors == null ? callback : new InterceptorCallback<>(callback, this.interceptors, tp); if (transactionManager != null && transactionManager.isTransactional()) transactionManager.maybeAddPartitionToTransaction(tp); RecordAccumulator.RecordAppendResult result = accumulator.append(tp, timestamp, serializedKey, serializedValue, headers, interceptCallback, remainingWaitMs); if (result.batchIsFull || result.newBatchCreated) { log.trace("Waking up the sender since topic {} partition {} is either full or getting a new batch", record.topic(), partition); this.sender.wakeup(); } return result.future; // handling exceptions and record the errors; // for API exceptions return them in the future, // for other exceptions throw directly } catch(){ …… } }
进一步分析partition函数，这个函数用于计算给定的record的分区，如果record的分区给定了，那么就直接返回给定的分区值，如果没有则会调用已经配置好的分区类去计算分区。
private int partition(ProducerRecord<K, V> record, byte[] serializedKey, byte[] serializedValue, Cluster cluster) { Integer partition = record.partition(); return partition != null ? partition : partitioner.partition( record.topic(), record.key(), serializedKey, record.value(), serializedValue, cluster); }
直接进一步分析分区类是如何计算分区的，源码如下：
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) { int nextValue = nextValue(topic); List<PartitionInfo> availablePartitions = cluster.availablePartitionsForTopic(topic); if (availablePartitions.size() > 0) { int part = Utils.toPositive(nextValue) % availablePartitions.size(); return availablePartitions.get(part).partition(); } else { // no partitions are available, give a non-available partition return Utils.toPositive(nextValue) % numPartitions; } } else { // hash the keyBytes to choose a partition return Utils.toPositive(Utils.murmur2(keyBytes)) % numPartitions; } }
可以看出，计算分区的规则如下：
（1）给定分区值的时候，直接将指明的分区值作为partition值；
（2）没有指明partition值，但是有key，则会将key的hash值与主题的分区数进行取模运算，得到partition值；
（3）既没有partition值，也没有key，则在第一次调用时随机生成一个整数（后面每次调用在这个整数上自增），将这个值与 topic 可用的 partition 总数取余得到 partition 值，也就是常说的 round-robin 算法。
需要说明的是，Kafka的Producer发送消息采用的是异步发送的方式。在消息发送的过程中，涉及到了两个线程 main线程和Sender线程 ，以及一个线程共享变量 RecordAccumulator。main线程将消息发送给 RecordAccumulator，Sender线程不断从RecordAccumulator中拉取消息发送到 Kafka broker。
这也就对应了上面为何会将主题、分区、头信息、时间戳添加到RecordAccumulator变量。
