Kafka学习 -- Producer源码分析
Producer客户端代码，它将数据写入到ByteBuffer中，然后再通过JAVA NIO发送到kafka的Server端。 这两天详细跟着Producer的代码，将它的发送过程整理了一下，加深对kafka的理解。
1. Producer的初始化
producer = new Producer<String, String>(new ProducerConfig(props));
初始化的大量的工作都是在此构造函数中完成。 查看源码
|
1
2
3
|
// 客户端代码会创建kafka.javaapi.producer.Producer， 而此porducer在初始化的时候，
// 创建kafka.producer.Produce
def
this
(config
:
ProducerConfig)
=
this
(
new
kafka.producer.Producer[K,V](config))
|
调用kafka.producer.Producer()此构造函数。 可以查看一下它的源码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
class
Producer[K,V](
val
config
:
ProducerConfig,
private
val
eventHandler
:
EventHandler[K,V])
// only for unit testing
extends
Logging {
private
val
queue
=
new
LinkedBlockingQueue[KeyedMessage[K,V]](config.queueBufferingMaxMessages)
private
var
producerSendThread
:
ProducerSendThread[K,V]
=
null
config.producerType
match
{
case
"sync"
=
>
case
"async"
=
>
sync
=
false
//创建一个send线程，并启动它
producerSendThread
=
new
ProducerSendThread[K,V](
"ProducerSendThread-"
+ config.clientId,
queue,
eventHandler,
config.queueBufferingMaxMs,
config.batchNumMessages,
config.clientId)
producerSendThread.start()
}
//创建实际的handler 对象，后面调用send，实际上就是调用DefaultEventHandler的handle方法
def
this
(config
:
ProducerConfig)
=
this
(config,
new
DefaultEventHandler[K,V](config,
Utils.createObject[Partitioner](config.partitionerClass, config.props),
Utils.createObject[Encoder[V]](config.serializerClass, config.props),
Utils.createObject[Encoder[K]](config.keySerializerClass, config.props),
new
ProducerPool(config)))
}
|
从上面可以看到，主要的两个对象为 ProducerSendThread与DefaultEventHandler，下面分别对于这两个对象进行解析。
但是在我们常见的默认的例子中，是不会走thread线程的
2. 初始化之后，客户端会调用代码：
producer.send(new KeyedMessage<Integer, String>(topic, messageStr));
将消息发送出去,至此，需要客户端编写的代码就完成了。 看一下send的代码
|
1
2
3
4
5
6
7
8
9
10
11
12
|
def
send(messages
:
KeyedMessage[K,V]*) {
lock synchronized {
if
(hasShutdown.get)
throw
new
ProducerClosedException
recordStats(messages)
sync
match
{
//此处会进行选择，默认的情况下，为true，也就是走handle流程
case
true
=
> eventHandler.handle(messages)
case
false
=
> asyncSend(messages)
}
}
}
|
3. 调用Handler会调用到 ProducerSendThread中的processEvents()
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
|
class
ProducerSendThread[K,V](... ... )
extends
Thread(threadName)
with
Logging
with
KafkaMetricsGroup {
... ....
//在此send线程中，主体动作是调用processEvents
private
def
processEvents() {
... ...
// drain the queue until you get a shutdown command
//从queue队列中取出一个消息。用户在使用producer.send()时，消息将会被放入到queue队列中
Stream.continually(queue.poll(scala.math.max(
0
, (lastSend + queueTime) - SystemTime.milliseconds), TimeUnit.MILLISECONDS))
.takeWhile(item
=
>
if
(item !
=
null
) item ne shutdownCommand
else
true
).foreach {
... ...
if
(currentQueueItem !
=
null
) {
//将取出来的消息赋给event
events +
=
currentQueueItem
}
... ....
// send the last batch of events
//调用tryToHandle来处理这个消息
tryToHandle(events)
}
def
tryToHandle(events
:
Seq[KeyedMessage[K,V]]) {
... ...
//调用DefaultEventHandler中的handle函数来处理消息
handler.handle(events)
... ...
}
}
|
从上面代码中，可以看到，producer的消息，会首先放入到一个
BlockingQueue
队列中，sendThread线程会不断轮询这个队列，从队列中取出消息，然后调用DefaultEventHandler：：hanle进行处理。
2. DefaultEventHandler::handle
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
def
handle(events
:
Seq[KeyedMessage[K,V]]) {
//将该消息序列化
val
serializedData
=
serialize(events)
... ...
//然后会根据传入的broker信息、topic信息，去取最新的该topic的metadata信息
//此处还不是太清楚
Utils.swallowError(brokerPartitionInfo.updateInfo(topicMetadataToRefresh.toSet, correlationId.getAndIncrement))
... ...
//开始发送消息了
outstandingProduceRequests
=
dispatchSerializedData(outstandingProduceRequests)
... ...
}
|
3. 开始调用
dispatchSerializedData()发送消息。
|
1
2
3
4
5
6
7
8
|
private
def
dispatchSerializedData(messages
:
Seq[KeyedMessage[K,Message]])
:
Seq[KeyedMessage[K, Message]]
=
{
... ....
//此处就开始发送消息了。
//很奇怪的是，使用debug模式调式，总是跳过它。加上日志可以看清楚
val
failedTopicPartitions
=
send(brokerid, messageSetPerBroker)
... ...
}
|
4. 正式调用send将消息发送出去
|
1
2
3
4
5
6
7
8
9
|
private
def
send(brokerId
:
Int, messagesPerTopic
:
collection.mutable.Map[TopicAndPartition, ByteBufferMessageSet])
=
{
... ...
//首先根据brokerId，找到对应的producer句柄，这个producerPool是事先初始化好的
val
syncProducer
=
producerPool.getProducer(brokerId)
... ...
//找到后，开始调用send命令
val
response
=
syncProducer.send(producerRequest)
... ...
}
|
对于这个procerPool.getProducer就是从一个HashMap中找到key值为brokerId的producer， 并用这个producer将这个消息发送出去
5. TCP连接的发送消息
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
private
def
doSend(request
:
RequestOrResponse, readResponse
:
Boolean
=
true
)
:
Receive
=
{
lock synchronized {
//首先校验消息是否合法
verifyRequest(request)
//获取与broken的连接。如我的broker 0是hadoop221:9092，客户端就会与9092这个端口连接
//只有在首次的时候会连接,连接后，会持有此连
getOrMakeConnection()
var
response
:
Receive
=
null
try
{
//将消息通过tcp连接发送过去
blockingChannel.send(request)
if
(readResponse)
//收到回复消息
response
=
blockingChannel.receive()
}
... ...
}
|
在整个发送过程中，会创建两条连接一个是writeChannel，一个是readChannel，在connect()，我们可以很清楚的看到
|
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
def
connect()
=
lock synchronized {
if
(!connected) {
try
{
channel
=
SocketChannel.open()
//阻塞式连接
channel.configureBlocking(
true
)
channel.socket.setSoTimeout(readTimeoutMs)
channel.socket.setKeepAlive(
true
)
channel.socket.setTcpNoDelay(
true
)
channel.socket.connect(
new
InetSocketAddress(host, port), connectTimeoutMs)
//writeChannel 用于写数据
writeChannel
=
channel
//而readChannel是获取inputstream流
readChannel
=
Channels.newChannel(channel.socket().getInputStream)
connected
=
true
... ...
}
}
|
6. 数据通过NIO发送出去
|
1
2
3
4
5
6
7
|
def send(request: RequestOrResponse):Int = {
.. ...
//在send的时候，会创建一个ByteBufferSend对易用
val send =
new
BoundedByteBufferSend(request)
send.writeCompletely(writeChannel)
}
|
此处我们需要看一下这个ByteBuffer的写入数据的格式：
|
1
2
3
4
5
6
7
8
9
|
def
this
(request: RequestOrResponse) = {
//初始化bytebuffer的大小
this
(request.sizeInBytes + (
if
(request.requestId != None)
2
else
0
))
request.requestId match {
case
Some(requestId) =>
//写入requestId，其值val ProduceKey: Short = 0，也就是第一个值就是requestId
buffer.putShort(requestId)
case
None =>
}
|
后面系统会根据这个requesId的值调用相应的handler去处理