.proto 文件是 ProtoBuf 一个重要的文件，它定义了需要序列化数据的结构，用法步骤：
下载地址：https://github.com/protocolbuffers/protobuf/releases
下载的安装包：protoc-3.9.0-win32.zip、protoc-3.9.0-win64.zip
操作系统：WIN10 64位
下载的源码包：protobuf-3.9.0.zip
1、解压protoc-3.9.0-win32.zip到任意目录
2、将解压目录 <path>\protoc-3.9.0-win32\bin 配置到环境变量path下
3、在命令行下即可使用 protoc 命令编译 .proto 文件生成 C++ 对应的 .h 和 .cc 文件
在 cmd 命令行中进行：
> protoc --version #查看protoc的版本
#可以先 cd 到指定目录，然后设置为相对路径
> protoc -I=$SRC_DIR --cpp_out=$DST_DIR $SRC_DIR/xxx.proto #编译 .proto 文件
#-I：主要用于指定待编译的 .proto 消息定义文件所在的目录，即可能出现的包含文件的路径，该选项可以被同时指定多个，此处指定的路径不能为空，如果是当前目录，直接使用.，如果是子目录，直接使用子目录相对径
操作系统：WIN10 64位
编译工具：VS 2015
在 Win 上编译需要用到 CMake ：https://cmake.org/download/
Win 上编译使用流程：
1、解压源码到任意路径下 <path>\protobuf-3.9.0下
2、到官网（或国内下载站）下载 CMake，并安装
3、CMake 生成 VS 2015 工程
4、拷贝所需lib文件和protoc.exe到对应的项目中
5、 .proto文件编译生成对应的.h和.cc文件
6、引入自己的工程使用
1、编码规范
2、注释
提供以下两种注释方式：
// 单行注释
/* 多行注释 */
3、默认值
解析消息时，如果编码消息不包含特定的单数元素，则解析对象中的相应字段将设置为该字段的默认值，这些默认值是特定于类型的。
4、message定义以及编译生成 C++ 文件
package hw;
message test
{
required int32 id = 1;
required string str = 2;
optional int32 opt = 3;//可选字段
repeated string phone_num = 4;
}
protoc -I=$SRC_DIR --cpp_out=$DST_DIR $SRC_DIR/hw.test.proto
5、嵌套以及导入message
import hw.test;//用 Import 关键字引入在其他 .proto 文件中定义的消息
package addresslist;
message Person
{
//1到15范围内的字段编号需要一个字节进行编码，包括字段编号和字段类型
//16到2047范围内的字段编号占用两个字节
//应该为非常频繁出现的消息元素保留数字1到15
//要为将来可能添加的常用元素留出一些空间
required string name = 1;
required int32 id = 2;
optional string email = 3;
enum PhoneType //定义枚举的时候，我们要保证第一个枚举值必须是0，枚举值不能重复，
//除非使用 option allow_alias = true 选项来开启别名
//枚举值的范围是32-bit integer，但因为枚举值使用变长编码，
//所以不推荐使用负数作为枚举值，因为这会带来效率问题
{
MOBILE = 0;
HOME = 1;
WORK = 2;
}
message PhoneNumber //定义嵌套消息
{
required string number = 1;
optional PhoneType type = 2 [default = HOME];
}
repeated PhoneNumber phone = 4;
}
6、map映射
如果要在数据定义中创建关联映射，Protocol Buffers提供了一种方便的语法：
map< key_type, value_type> map_field = N ;
其中key_type可以是任何整数或字符串类型。
7、oneof
如果你的消息中有很多可选字段， 并且同时至多一个字段会被设置， 你可以加强这个行为，使用oneof特性节省内存。为了在.proto定义oneof字段， 你需要在名字前面加上oneof关键字
message testMessage
{
oneof test_oneof
{
string name = 4;
SubMessage sub_message = 9;
}
}
然后你可以增加oneof字段到 oneof 定义中. 你可以增加任意类型的字段。
注意Oneof特性：
8、Any（任意消息类型）
Any类型是一种不需要在.proto文件中定义就可以直接使用的消息类型，使用前import google/protobuf/any.proto文件即可。
import "google/protobuf/any.proto";
message ErrorStatus {
string message = 1;
repeated google.protobuf.Any details = 2;
}
C++使用PackFrom()和UnpackTo()方法来打包和解包Any类型消息。
// Storing an arbitrary message type in Any.
NetworkErrorDetails details = ...;
ErrorStatus status;
status.add_details()->PackFrom(details);
// Reading an arbitrary message from Any.
ErrorStatus status = ...;
for (const Any& detail : status.details())
{
if (detail.Is<NetworkErrorDetails>())
{
NetworkErrorDetails network_error;
detail.UnpackTo(&network_error);
...
processing network_error
...
}
}
9、定义服务
如果想在RPC系统中使用消息类型，就需要在.proto文件中定义RPC服务接口，然后使用编译器生成对应语言的存根。
service SearchService {
rpc Search (SearchRequest) returns (SearchResponse);
}
10、更新一个数据类型
在实际的开发中会存在这样一种应用场景，既消息格式因为某些需求的变化而不得不进行必要的升级，但是有些使用原有消息格式的应用程序暂时又不能被立刻升级，这便要求我们在升级消息格式时要遵守一定的规则，从而可以保证基于新老消息格式的新老程序同时运行。规则如下：
1、定义.proto文件
syntax = "proto2";//不定义默认是这个（有警告），也可以定义成"proto3"
option java_package = "com.demo.myproto";
//使用精简版的protobuf库，需要链接libprotobuf-lite.lib
option optimize_for = LITE_RUNTIME;//生成的可执行程序速度快，体积小，以牺牲Protocol Buffer提供的反射功能为代价
package myproto;
message HelloWorld {
required int32 id = 1;
required string str = 2;
optional int32 opt=3;
}
保存成myproto.proto文件，放到指定目录
2、生成 C++ 文件
打开 cmd 命令行，cd 到指定目录下
> protoc -I ./ --cpp_out=./ myproto.proto #在本目录下转
3、将生成的 C++ 文件加入工程中
4、附加protobuf头文件目录（protobuf源文件 src 下的 google 文件夹引入到工程，生成的 C++ 文件需要）、附加依赖库文件目录、附加依赖库文件名 libprotobuf-lite.lib、设置运行库一致
5、编写测试程序
#include <stdlib.h>
#include <stdio.h>
#include "myproto.pb.h"
#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
#include <google/protobuf/message_lite.h>
/*
message HelloWorld {
required int32 id = 1;
required string str = 2;
optional int32 opt=3;
}
*/
int main()
{
printf("My Hello World Application !\r\n");
//设置参数
myproto::HelloWorld in_msg;
in_msg.set_id(1);
in_msg.set_str("zab");
in_msg.set_opt(0);
//对消息进行编码
int nSize = in_msg.ByteSize() + 8;
char *pcData = new char[nSize];
memset(pcData, 0, nSize);
int nEncodedLen = 0;
google::protobuf::io::ArrayOutputStream array_stream(pcData, nSize);
google::protobuf::io::CodedOutputStream output_stream(&array_stream);//操作编码时的varints
//Varint 是一种紧凑的表示数字的方法
//它用一个或多个字节来表示一个数字，值越小的数字使用越少的字节数
//这能减少用来表示数字的字节数
//Varint 中的每个 byte 的最高位 bit 有特殊的含义，如果该位为 1，表示后续的 byte 也是该数字的一部分，如果该位为 0，则结束
//其他的 7 个 bit 都用来表示数字
//因此小于 128 的数字都可以用一个 byte 表示
//大于 128 的数字，会用两个字节
output_stream.WriteVarint32(in_msg.ByteSize());//写为Varint
if (in_msg.SerializeToCodedStream(&output_stream)) {
nEncodedLen = output_stream.ByteCount();
//对消息进行解码
myproto::HelloWorld out_msg;
//构造一个InputStream，返回data所指向的字节数组
//若指定了block_size，则每次调用Next()返回不超过指定大小的数据块；否则，返回整个字节数组
google::protobuf::io::CodedInputStream input_stream ((google::protobuf::uint8*)pcData, nEncodedLen);//操作解码时的varints
google::protobuf::uint32 ui_size = 0;
if (input_stream.ReadVarint32(&ui_size)) {//还原Varint
google::protobuf::io::CodedInputStream::Limit limit = input_stream.PushLimit(ui_size);//保护在长度范围内解析
if (out_msg.MergeFromCodedStream(&input_stream)) {//分割填充
// 当对报文进行解析后，以进一步判断报文是否被以正确方式读取完毕
if (input_stream.ConsumedEntireMessage()) {
input_stream.PopLimit(limit);//释放保护
printf("HelloWorld id=%d,str=%s,opt=%d.\r\n", out_msg.id(), out_msg.str().c_str(), out_msg.opt());
} else {
printf("consume msg fail!\r\n");
}
} else {
printf("merge msg stream fail!\r\n");
}
} else {
printf("read msg stream fail!\r\n");
}
} else {
printf("encode msg fail!\r\n");
}
if (NULL != pcData) {
delete[] pcData;
pcData = NULL;
}
nEncodedLen = 0;
printf("My Hello World Application End!\r\n");
system("pause");
return 0;
}
optimize_for是文件级别的选项，Protocol Buffer 定义三种优化级别SPEED、CODE_SIZE、LITE_RUNTIME，缺省情况下是SPEED。
动态编译
一般情况下，使用 Protobuf 的人们都会先写好 .proto 文件，再用 Protobuf 编译器生成目标语言所需要的源代码文件，可是在某且情况下，人们无法预先知道 .proto 文件，他们需要动态处理一些未知的 .proto 文件，比如一个通用的消息转发中间件，它不可能预知需要处理怎样的消息，这需要动态编译 .proto 文件，并使用其中的 Message。
无须编译.proto生成.pb.cc和.pb.h，需要使用protobuf中提供的两个头文件
示例
#include <iostream>
#include <string>
#include <google/protobuf/compiler/importer.h>
#include <google/protobuf/dynamic_message.h>
class MyErrorCollector: public google::protobuf::compiler::MultiFileErrorCollector
{
virtual void AddError(const std::string & filename, int line, int column, const std::string & message){
// define import error collector
printf("%s, %d, %d, %s\n", filename.c_str(), line, column, message.c_str());
}
};
int main()
{
google::protobuf::compiler::DiskSourceTree sourceTree; // source tree
sourceTree.MapPath("", "/home/szw/code/protobuf/tmp2"); // initialize source tree
MyErrorCollector errorCollector; // dynamic import error collector
google::protobuf::compiler::Importer importer(&sourceTree, &errorCollector); // importer
importer.Import("test.proto");
// find a message descriptor from message descriptor pool
const google::protobuf::Descriptor * descriptor = importer.pool()->FindMessageTypeByName("lm.helloworld");
if (!descriptor){
perror("Message is not found!");
exit(-1);
}
// create a dynamic message factory
google::protobuf::DynamicMessageFactory * factory = new google::protobuf::DynamicMessageFactory(importer.pool());
// create a const message ptr by factory method and message descriptor
const google::protobuf::Message * tmp = factory->GetPrototype(descriptor);
// create a non-const message object by const message ptr
// define import error collector
google::protobuf::Message * msg = tmp->New();
return 0;
}
其中，头文件<google/protobuf/compiler/importer.h>包含了编译器对象相关，头文件<google/protobuf/dynamic_message.h>包含了Message_Descriptor和Factory相关
类型反射
类型反射即是根据字段的名称获取到字段类型的一种机制，protobuf自身便配备了类型反射机制，需要头文件<google/protobuf/descriptor.h>与<google/protobuf/message.h>。
protobuf对于每个元素都有一个相应的descriptor，这个descriptor包含该元素的所有元信息。
动态定义proto
能不能通过程序生成protobuf文件呢？答案是可以的。FileDescriptorProto允许你动态的定义你的proto文件：
//syntax = "proto3";
//message mymsg
//{
// uint32 len = 1;
// uint32 type = 2;
//}
FileDescriptorProto file_proto;
file_proto.set_name("my.proto");
file_proto.set_syntax("proto3");
DescriptorProto *message_proto = file_proto.add_message_type();
message_proto->set_name("mymsg");
FieldDescriptorProto *field_proto = NULL;
field_proto = message_proto->add_field();
field_proto->set_name("len");
field_proto->set_type(FieldDescriptorProto::TYPE_UINT32);
field_proto->set_number(1);
field_proto->set_label(FieldDescriptorProto::LABEL_OPTIONAL);
field_proto = message_proto->add_field();
field_proto->set_name("type");
field_proto->set_type(FieldDescriptorProto::TYPE_UINT32);
field_proto->set_number(2);
DescriptorPool pool;
const FileDescriptor *file_descriptor = pool.BuildFile(file_proto);
cout << file_descriptor->DebugString();
Varint
Varint 是一种紧凑的表示数字的方法。它用一个或多个字节来表示一个数字，值越小的数字使用越少的字节数。这能减少用来表示数字的字节数。
比如对于 int32 类型的数字，一般需要 4 个 byte 来表示。但是采用 Varint，对于很小的 int32 类型的数字，则可以用 1 个 byte 来表示。当然凡事都有好的也有不好的一面，采用 Varint 表示法，大的数字则需要 5 个 byte 来表示。从统计的角度来说，一般不会所有的消息中的数字都是大数，因此大多数情况下，采用 Varint 后，可以用更少的字节数来表示数字信息。下面就详细介绍一下 Varint。
Varint 中的每个 byte 的最高位 bit 有特殊的含义，如果该位为 1，表示后续的 byte 也是该数字的一部分，如果该位为 0，则结束。其他的 7 个 bit 都用来表示数字。因此小于 128 的数字都可以用一个 byte 表示。大于 128 的数字，比如 300，会用两个字节来表示：1010 1100 0000 0010
下图演示了 Google Protocol Buffer 如何解析两个 bytes。注意到最终计算前将两个 byte 的位置相互交换过一次，这是因为 Google Protocol Buffer 字节序采用 little-endian 的方式。
消息经过序列化后会成为一个二进制数据流，该流中的数据为一系列的 Key-Value 对。如下图所示：
采用这种 Key-Pair 结构无需使用分隔符来分割不同的 Field。对于可选的 Field，如果消息中不存在该 field，那么在最终的 Message Buffer 中就没有该 field，这些特性都有助于节约消息本身的大小。
时间效率
通过protobuf序列化/反序列化的过程可以得出：protobuf是通过算法生成二进制流，序列化与反序列化不需要解析相应的节点属性和多余的描述信息，所以序列化和反序列化时间效率较高。
空间效率
xml、json是用字段名称来确定类实例中字段之间的独立性，所以序列化后的数据多了很多描述信息，增加了序列化后的字节序列的容量。Protobuf的序列化/反序列化过程可以得出：protobuf是由字段索引(fieldIndex)与数据类型(type)计算(fieldIndex<<3|type)得出的key维护字段之间的映射且只占一个字节，所以相比json与xml文件，protobuf的序列化字节没有过多的key与描述符信息，所以占用空间要小很多。
参考：
https://www.ibm.com/developerworks/cn/linux/l-cn-gpb/