kafak 默认的分区机制如何自定义分区机制

key值一样的消息，发送同一个partition

’partitioner’: DefaultPartitioner()

Record可以只包含Topic和消息的value，key默认是None，但是大多数应用程序会用到key，key的两个作用：

1. 作为消息的附加信息
2. 决定消息该被写到Topic的哪个partition，拥有相同key的消息会被写到同一个partition。

**第一：**如果键值为None并且使用了默认的分区器，那么记录将被随机地发送到主题内各个可用的分区上。分区器使用轮询（Round Robin）算法将消息均衡地分布到各个分区上。

注意：上面这句话对于现在是不适用的，并不是轮询的，如果用轮询，我们可以用RoundRobinPartitioner。

第二：如果键不为空，并且使用了默认的分区器，那么 Kafka 会对键进行散列（使用 Kafka 自己的散列算法），然后根据散列值把消息映射到特定的分区上。这里的关键之处在于，同一个键总是被映射到同一个分区上，所以在进行映射时，我们会使用主题所有的分区，而不仅仅是可用的分区。这也意味着，如果写人数据的分区是不可用的，那么就会发生错误，但是这种情况很少出现。

kafka也支持用户实现自己的partitioner，用户自己定义的paritioner需要实现Partitioner接口。

散列，就是同一个键分配到同一个分区上

轮询
[root@zk-kafka001 ~]# pip3 install kafka-python==1.3.5

#!/usr/bin/python
# -*- coding:utf-8 -*-

from kafka import KafkaProducer
import pickle
import time
#轮询
from kafka.partitioner import RoundRobinPartitioner
#from kafka.partitioner import Partitioner

"""
:param key:
:param all_partitions: [0,1,2]
:param available_partitions: [0,1,2]
:return:
"""

producer = KafkaProducer(bootstrap_servers=['192.168.194.150:9092','192.168.194.151:9092'],
                key_serializer=lambda m:pickle.dumps(m),
                value_serializer=lambda n:pickle.dumps(n),
                #partitioner=MinePartitioner()
                partitioner=RoundRobinPartitioner())


#class MinePartitioner(Partitioner):
#       def __call__(self, key, all_partitions=None, available_partitions=None):
                #首先我们需要反序列出来key值.
#               key_deser = pickle.loads(key)
#               print(key_deser,available_partitions,available_partitions)

#               if int(key_deser) <=500:
#                       return all_partitions[1]
#               else:
#                       return all_partitions[2]

                #if key_deser == 'kafka':
                #       return all_partitions[2]
                #pass



for i in range(500,600):
        future =  producer.send(topic='laiyaya',key='python',value=i)
        try:
                record_metadata = future.get()
                print(record_metadata.topic,record_metadata.partition,record_metadata.offset)
        except Exception as e:
                print(str(e))



producer.flush()
producer.close()

Python版本：自定义分区的方式：继承Partitioner类，重写__call__方法.

key是你发送过来的key
all_partition=None 对应的分区
available_partitions=None 你可以使用的分区

#!/usr/bin/python
# -*- coding:utf-8 -*-

from kafka import KafkaProducer
import pickle
import time
#轮询
#from kafka.partitioner import RoundRobinPartitioner
from kafka.partitioner.base import Partitioner

"""
:param key:
:param all_partitions: [0,1,2]
:param available_partitions: [0,1,2]
:return:
"""

class MinePartitioner(Partitioner):
       def __call__(self, key, all_partitions=None, available_partitions=None):
               #首先我们需要反序列出来key值.
               key_deser = pickle.loads(key)
               print(key_deser,available_partitions,available_partitions)

               if int(key_deser) <=500:
                       return all_partitions[1]
               else:
                       return all_partitions[2]

                #if key_deser == 'kafka':
                #       return all_partitions[2]
                #pass


producer = KafkaProducer(bootstrap_servers=['192.168.194.150:9092','192.168.194.151:9092'],
                key_serializer=lambda m:pickle.dumps(m),
                value_serializer=lambda n:pickle.dumps(n),
                partitioner=MinePartitioner()
                #partitioner=RoundRobinPartitioner()
                )


for i in range(0,600):
        future =  producer.send(topic='laiyaya',key=i,value=i)
        #future =  producer.send(topic='laiyaya',key='kafka',value=i)
        try:
                record_metadata = future.get()
                print(record_metadata.topic,record_metadata.partition,record_metadata.offset)
        except Exception as e:
                print(str(e))



producer.flush()
producer.close()