Muduo + ProtoBuffer的使用

 

一. 消息识别

为了达到消息识别的目的，首先需要定义消息格式：

 

 len : 消息长度

 namelen : 消息类型名长度

 messageName : 消息类型名

 protoBufData : 消息体数据

 checkSum : 校验和 (这里使用 adler32 算法)

 注意：使用ProtoBuffer进行传输是不需要消息的版本号的，因为ProtoBuffer支持optional字段，可以通过增加或减少optional字段来实现不同版本的消息，而且不会引起解析错误。

二. 消息解析

当处理端收到消息后，应该怎样处理了，注意处理端收到的字节流很可能不能构成一个完整的消息，也可能构成多个消息

       对数据的解码在ProtobufCodec类中，onMessage函数就是处理原始字节流的，parse函数从原始字节流中提取出消息

1. 1. 
      
2. void ProtobufCodec::onMessage(const TcpConnectionPtr& conn,
3. Buffer* buf,
4. Timestamp receiveTime)
5. {
6. while (buf->readableBytes() >= kMinMessageLen + kHeaderLen)
7. {
8. // 1. 获取消息长度 (头四个字节)
9. const int32_t len = buf->peekInt32();
10. if (len > kMaxMessageLen || len < kMinMessageLen)
11. {
12. errorCallback_(conn, buf, receiveTime, kInvalidLength);
13. break;
14. }
15. else if (buf->readableBytes() >= implicit_cast<size_t>(len + kHeaderLen))
16. {
17. ErrorCode errorCode = kNoError;
18. // 2. parse生成具体消息
19. MessagePtr message = parse(buf->peek()+kHeaderLen, len, &errorCode);
20. if (errorCode == kNoError && message)
21. {
22. // 3. 调用消息处理函数
23. messageCallback_(conn, message, receiveTime);
24. // 4. 从缓冲区中删除已处理的消息字节数据
25. buf->retrieve(kHeaderLen+len);
26. }
27. else
28. {
29. errorCallback_(conn, buf, receiveTime, errorCode);
30. break;
31. }
32. }
33. else
34. {
35. break;
36. }
37. }
38. }
    1. 
       
       
39. MessagePtr ProtobufCodec::parse(const char* buf, int len, ErrorCode* error)
40. {
41. MessagePtr message;
42. 
    
43. // check sum
44. // 1. 检查校验和
45. int32_t expectedCheckSum = asInt32(buf + len - kHeaderLen);
46. int32_t checkSum = static_cast<int32_t>(
47. ::adler32(1,
48. reinterpret_cast<const Bytef*>(buf),
49. static_cast<int>(len - kHeaderLen)));
50. if (checkSum == expectedCheckSum)
51. {
52. // get message type name
53. // 2. 获取消息类型名长度
54. int32_t nameLen = asInt32(buf);
55. if (nameLen >= 2 && nameLen <= len - 2*kHeaderLen)
56. {
57. // 3. 获取消息类型名
58. std::string typeName(buf + kHeaderLen, buf + kHeaderLen + nameLen - 1);
59. // create message object
60. // 4. 根据消息类型名创建一个消息
61. message.reset(createMessage(typeName));
62. if (message)
63. {
64. // parse from buffer
65. const char* data = buf + kHeaderLen + nameLen;
66. int32_t dataLen = len - nameLen - 2*kHeaderLen;
67. // 5. 从原始字节流中反序列化出消息数据
68. if (message->ParseFromArray(data, dataLen))
69. {
70. *error = kNoError;
71. }
72. else
73. {
74. *error = kParseError;
75. }
76. }
77. else
78. {
79. *error = kUnknownMessageType;
80. }
81. }
82. else
83. {
84. *error = kInvalidNameLen;
85. }
86. }
87. else
88. {
89. *error = kCheckSumError;
90. }
91. 
    
92. return message;
93. }
    1. 
       

这里很重要的一点就是如何根据消息类型名创建一个消息，createMessage完成这个功能

1. 1. 
      
2. google::protobuf::Message* ProtobufCodec::createMessage(const std::string& typeName)
3. {
4. google::protobuf::Message* message = NULL;
5. const google::protobuf::Descriptor* descriptor =
6. google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName(typeName);
7. if (descriptor)
8. {
9. const google::protobuf::Message* prototype =
10. google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
11. if (prototype)
12. {
13. message = prototype->New();
14. }
15. }
16. return message;
17. }
    1. 
       

该函数用到的几个重要的步骤：

1. 1. 
      
2. 获取 MessageFactory 对象
   MessageFactory 类提供了一个 generated_factory() 的静态函数，此静态函数可以获取一个 MessageFactory 对象，此 MessageFactory 对象能够用来创建被编译入程序的所有的 message 对象。注意，此 Factory 是一个 Singleton，因此重复多次调用 generated_factory 函数不会创建多个 MessageFactory 对象，另外调用者也不能通过调用 delete 删除此对象。
3. 获取 DescriptorPool 对象
   通过 DescriptorPool 类的 generated_pool() 静态函数能够获取 DescriptorPool 的指针。此 DescriptorPool 中包含了被编译入程序的 message 的 descriptor。generated_pool 类似于 generated_factory 函数，可以被重复调用多次而不会创建多个 DescriptorPool 对象。
4. 获取 message descriptor
   有了 DescriptorPool 对象就可以获取到 message 的 descriptor 了。常见的一个函数是 const Descriptor * FindMessageTypeByName(const string & name) const，此函数可以通过 message 名字获取到顶层 message 的 descriptor。当然除此之外还有一些 API 可以用来获取 message discriptor，可以参考相关文档，这里就不一一详述了。
5. 获取 message prototype 并构建 message 对象
   前面已经讲述了获取 MessageFactory 对象的方法，有了 MessageFactory 对象就可以通过函数 MessageFactory::GetPrototype(const Descriptor * type) 获取 message prototype（实质上就是一个 message 对象）。通过调用 message prototype 的 New 函数则可以构造此类型的 message。
   对同一个 Descriptor 多次调用 MessageFactory::GetPrototype 函数将返回同一个对象。通过调用 prototype 的 New 函数构造的 message 对象必须在 MessageFactory 销毁前销毁。
   1. 
      

三. 消息处理

消息的处理是在函数messageCallBack_中进行，这个函数是我们在创建QueryServer时绑定的：

1. 1. 
      
2. QueryServer(EventLoop* loop,
3. const InetAddress& listenAddr)
4. : server_(loop, listenAddr, "QueryServer"),
5. dispatcher_(boost::bind(&QueryServer::onUnknownMessage, this, _1, _2, _3)),
6. 
   
7. // 将ProtobufDispatcher::onProtobufMessage 绑定到messageCallBack_上
8. codec_(boost::bind(&ProtobufDispatcher::onProtobufMessage, &dispatcher_, _1, _2, _3))
9. {
10. // 注册的消息处理函数
11. dispatcher_.registerMessageCallback<muduo::Query>(
12. boost::bind(&QueryServer::onQuery, this, _1, _2, _3));
13. dispatcher_.registerMessageCallback<muduo::Answer>(
14. boost::bind(&QueryServer::onAnswer, this, _1, _2, _3));
15. server_.setConnectionCallback(
16. boost::bind(&QueryServer::onConnection, this, _1));
17. server_.setMessageCallback(
18. boost::bind(&ProtobufCodec::onMessage, &codec_, _1, _2, _3));
19. }
    1. 
       

onProtobufMessage根据每个类型的descriptor来从一张表中查找处理函数，因为每种类型都有一个全局的Descriptor对象，它的地址不变，因此使用它来查找注册的函数

1. 1. 
      
2. void onProtobufMessage(const muduo::net::TcpConnectionPtr& conn,
3. const MessagePtr& message,
4. muduo::Timestamp receiveTime) const
5. {
6. CallbackMap::const_iterator it = callbacks_.find(message->GetDescriptor());
7. if (it != callbacks_.end())
8. {
9. it->second->onMessage(conn, message, receiveTime);
10. }
11. else
12. {
13. defaultCallback_(conn, message, receiveTime);
14. }
15. }
    1. 
       

至此，我们就实现了消息的自解析和自处理。