关于Protobuf的学习

简介

protoBuf是google 的一种数据交换的格式，它独立于语言，独立于平台。google 提供了多种语言的实现：java、c#、c++、go 和 python，每一种实现都包含了相应语言的编译器以及库文件。由于它是一种二进制的格式，比使用 xml 进行数据交换快许多。

优点

与同类型的数据交换格式相比（诸如json，xml），由于protobuf是基于二进制数据传输格式，因此它具有高效的解析速度和更小的体积，并且由于它是直接基于.proto文件生成对应语言的数据结构，因此它的转换过程更加简单直接。同时因为protobuf实现都包含了相应语言的编译器以及库文件，它将比传统的基于一套规范解析更加精准可控，误解的概率更低。

综上优点 :

高效的解析速度

小巧的传输体积

直接上手，简单易用

解析可控，误解率低

缺点

与传统的数据交换格式相比，由于基于二进制数据传输格式，protobuf可读性为零。同时虽然protobuf强调的是跨平台性，但相较于json，xml来说，protobuf的语言覆盖率偏低，并且手动开发一个自定义protobuf的工作量也偏大。

综上缺点 :

可读性低

语言支持相对少

用途

作为一种效率和兼容性都很优秀的二进制数据传输格式，可以用于分布式应用之间的数据通信或者异构环境1，并且在传统的cs架构的环境中，protobuf也可以用作客户端服务端公用的数据交换格式。

简单上手

下面介绍在Windows下使用protobuf进行python与java互通的helloword程序

下载protobuf

由于国内google被墙，只能在github上下载下载地址

在windows下载protoc-XXX-win32.zip解压即可

配置一个.proto

//文件名test.proto
//定义包名
package test;
//protobuf的编译器版本
syntax = "proto3";

//java的包名
option java_package = "test.protobuf";
//java中主类的名称（及public修饰的类的名称）
option java_outer_classname = "MProtobuf";

message request{

//1为msg在request中的field_num，在后面会讲
string msg = 1;
string commet = 2;
}

生成对应的Java和Python文件

将刚才写好的test.proto移到解压后文件的bin目录

并在该目录下打开命令窗口。

输入：

protoc.exe --java_out=./ test.proto

在当前目录生成java文件

输入：

protoc.exe --python_out=./ test.proto

在当前目录生成python文件

在当前目录下test文件就是我们生成的java文件，点进去可见到MProtobuf.java

这就是我们在：

option java_outer_classname = "MProtobuf";

定义的outer_classname

分析生成文件结构

MProtobuf由requestOrBuilder和request构成

我们可以通过request中的newBuilder()构建一个requestOrBuilder

并通过requestOrBuilder构建一个request

在request中有writeTo方法：

public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (!getMsgBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 1, msg_);
}
if (id_ != 0) {
output.writeInt32(2, id_);
}
unknownFields.writeTo(output);
}

能方便将request写进流里

通过request中的parseFrom方法：

public static test.protobuf.HelloWorldProto.HelloWorld parseFrom(
com.google.protobuf.CodedInputStream input)
throws java.io.IOException {
return com.google.protobuf.GeneratedMessageV3
.parseWithIOException(PARSER, input);
}

能方便将流转换成request对象

编写Server.java

首先生成的MProtobuf.java是依赖于com.google.protobuf的，所有先下载它的jar包

编写Server.java:

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.google.protobuf.CodedInputStream;

import test.protobuf.MProtobuf.request;

public class Server {
public static void main(String[] args) throws IOException {

ServerSocket server = new ServerSocket(12345);

for(;;){
Socket socket = server.accept();

InputStream ism = socket.getInputStream();
CodedInputStream csm = CodedInputStream.newInstance(ism);

request req = request.parseFrom(csm);

System.out.println(req);
}
}
}

编写client.py

同样在python中依赖protobuf

pip install protobuf

在生成的test_pb2.py的文件下建立client.py

编写client.py:

import test_pb2 as tp
import socket

socket = socket.socket()

socket.connect(("127.0.0.1",12345))

req = tp.request()
req.msg = "helloworld"
req.commet = "power by protobuf"
socket.sendall(req.SerializeToString())

运行

先运行Java，在运行client.py

控制台输出：

msg: "helloworld"
commet: "power by protobuf"

运行成功

深入

字段修饰符2

required
对于required的字段而言，字段初值是必须要提供的，否则字段的便是未初始化的

对于修饰符为required的字段，序列化的时候必须给予初始化,否则程序运行会异常

optional
对于optional的字段而言，如果未进行初始化，那么一个默认值将赋予该字段编号

也可以指定默认值,如下示例所示.

optional string name = 1[default = "ssochi"]

repeated
对于repeated的字段而言，该字段可以重复多个，即每个编码单元可能有多个该字段

在高级语言里面，我们可以通过数组来实现，而在proto定义文件中可以使用repeated来修饰，从而达到相同目的。当然，出现0次也是包含在内的。

字段类型

.proto Type	Java Type	notes
int32	int	使用变长编码，在值为负数的情况下效率低，应采用sin32代替
int64	long	使用变长编码，在值为负数的情况下效率低，应采用sin64代替
uint32	int	使用变长编码
uint64	long	使用变长编码
sint32	int	使用变长编码，有符号整型，在值为负数的情况下效率高
sint64	long	使用变长编码，有符号整型，在值为负数的情况下效率高
fixed32	int	固定四个字节.如果值经常大于2^28使用fixed32会比使用uint32更高效
fixed64	long	固定八个字节.如果值经常大于2^56使用fixed64会比使用uint64更高效
sfixed32	int	有符号，固定四个字节
sfixed64	long	有符号，固定八个字节
bool	boolean
double	double
string	String	string必须一致包含UTF-8编码或者7-bit ASCII字符串
bytes	ByteString	可以包含任意字节序列

字段类型对应二进制类型

字段类型	二进制类型	二进制编码值
int32,int64,uint32,uint64,sint32,sint64,bool,enum	Varint(可变长度int)	0
fixed64,sfixed64,double	double	1
string,bytes,inner messages(内部嵌套),packaed repeated fields(repeated字段)	Length-delimited	2
groups(deprecated)	Start group	3
groups(deprecated)	Endd group	4
fixed32,sfixed32,float	32bit固定长度	5

field_num

每个消息的字段都有一个唯一的数字标签,这些标签用来表示你的字段在二进制消息(message binary format)中处的位置。并且一旦指定标签号，在使用过程中是不可以更改的,标记这些标签号在1-15的范围内每个字段需要使用1个字节用来编码这一个字节包括字段所在的位置和字段的类型。标签号在16-2047需要使用2个字节来编码。所以你最好将1-15的标签号为频繁使用到的字段所保留。如果将来可能会添加一些频繁使用到的元素，记得留下一些1-15标签号。

最小可指定的标签号为1，最大的标签号为2^29 - 1或者536870911。不能使用19000-19999的标签号这些标签号是为protobuf内部实现所保留的，如果你在.proto文件内使用了这些标签号Protobuf编译器将会报错！

结构

消息

protobuf中使用message定义一个消息，在同一个包内能直接引用，在不同包内则需要先import

message request{
string msg = 1;
string commet = 2;
}

枚举

enum PhoneType //枚举消息类型
{
MOBILE = 0; //proto3版本中，首成员必须为0，成员不应有相同的值
HOME = 1;
WORK = 2;
}

Map

protobuf v2是不支持Map数据结构的，官方给出的不就方法是通过如下代码代替Map:

message MapFieldEntry {
key_type key = 1;
value_type value = 2;
}

repeated MapFieldEntry map_field = N;

官方给出的解释是：The map syntax is equivalent to the following on the wire, so protocol buffers implementations that do not support maps can still handle your data

在protobuf v3 的较新版本已经支持Map3，可以通过如下代码申明Map

map<string, string> values= 1;

嵌套

message定义中可以嵌套定义message,enum

嵌套定义的单元外部可见，引用路径由外到内逐层引用

扩展字段

protobuf通过extension解决数据结构之间的不能派生的问题，以此来达到减少重复工作量和便于维护代码的目的。

message BaseDataType{
extensions 100 to max;   //标识此字段可扩展，此处可指定扩展字段的ID有效范围，to max表示字段范围至最大值
optional string field1 = 1;
optional string field2 = 2;
}

message ExtendDataType{
extend BaseDataType{
optional ExtendDataType extendData = 100;
optional int32  extendValue = 101;
}
optional string extendField1 = 1;
optional string extendField2= 2;
}

编码

Varint编码规则

Varints是将一个整数序列化为一个或多个Bytes的方法,越小的整数，使用的Bytes越少
每个byte最高位(msb)是标志位,0表示是最后一个byte,1表示该字段值还有后续byte

每个byte低7位存放数值

Varints使用Little Endian(小端)字节序

编码试例:

举例: 300 的二进制为 10 0101100

第一位：1（有后续） + 0101100
第二位：0（无后续） + 0000010

最终结果： 101011000000010

可见，由于是小端字节序，值越小Varints序列化后使用的Bytes越少。

然而负数在补码的首位是1，则使用Varint序列化后，所有负数都相当于非常大的数，

这造成了负数序列化后使用的bytes增加，为了解决这个问题对于负数采用sint32或sint64。

而sint先采用Zigzag方法避免上述问题再通过Varint序列化。

Zigzag编码规则

对于sint32采用(n<<1)^(n>>31)

对于sint32采用(n<<1)^(n>>63)

其中>>操作当操作数为负数时高位补1正数时高位补1

Zigzag编码将整数重新映射到定义域，使得整数映射后的补码长度和绝对值的大小成正相关:

原始值	编码后的值	编码后的补码
0	0	00000000
-1	1	00000001
1	2	00000010
-2	3	00000011
3	4	00000100
…	…	…

length-delimited编码

string,bytes都属于length-delimited编码,length-delimited(wire_type=2)的编码方式：key+length+content

key的编码方式是统一的

length采用varints编码方式

content就是由length指定的长度的Bytes

消息编码规则

message都是以一组或多组key-value对组成,key和value分别采用不同的编码方式

序列化时，将message中所有key-value序列化成二进制字节流。反序列化时，解析出所有key-value对，

如果遇到无法识别的类型，则直接跳过。这种机制保证了旧有的编/解码在协议添加新的字段时，依旧可以正常工作

key由两部分组成，一部分是在定义消息时对字段的编号（field_num4），另一部分是字段类型（wire_type，编号最大不超过536870911.

key编码方式filed_num<<3|wire_type，编码后的二进制长度是变长的

value编码则根据字段类型进行编码.

生成代码分析

接下来我将通过protoc.exe生成的java文件,分析protobuf的编解码过程

首先我们先创建一个包含protobuf所有类型的.proto

//文件名protobufStruct.proto

//protobuf 版本
syntax = "proto3";

//java的包名
option java_package = "struct.protobuf";
//java中主类的名称（及public修饰的类的名称）
option java_outer_classname = "structs";

//基本类型
message baseStruct{

int32 int32value = 1;
int64 int64value = 2;
uint32 uint32value = 3;
uint64 uint64value = 4;
sint32 sint32value = 5;
sint64 sint64value = 6;
fixed32 fixed32value = 7;
fixed64 fixed64value = 8;
sfixed32 sfixed32value = 9;
sfixed64 sfixed64value = 10;
bool boolvalue = 11;
double doublevalue = 12;
string stringvalue = 13;
bytes bytesvalue = 14;
//枚举
enum PhoneType{
MOBILE = 0;
HOME = 1;
WORK = 2;
}

}
//复合类型
message complexStruct{
//map
map<int32, string> mapvalues= 1;
//list
repeated MapFieldEntry map_field = 2;
}
message MapFieldEntry {
int32 key = 1;
string value = 2;
}

通过执行cmd指令生成java文件

protoc.exe --java_out=./ protobufStruct.proto

我们可以看到baseStructOrBuilder:

public interface baseStructOrBuilder extends
// @@protoc_insertion_point(interface_extends:baseStruct)
com.google.protobuf.MessageOrBuilder {

/**
* <code>int32 int32value = 1;</code>
*/
int getInt32Value();

/**
* <code>int64 int64value = 2;</code>
*/
long getInt64Value();

/**
* <code>uint32 uint32value = 3;</code>
*/
int getUint32Value();

/**
* <code>uint64 uint64value = 4;</code>
*/
long getUint64Value();

/**
* <code>sint32 sint32value = 5;</code>
*/
int getSint32Value();

/**
* <code>sint64 sint64value = 6;</code>
*/
long getSint64Value();

/**
* <code>fixed32 fixed32value = 7;</code>
*/
int getFixed32Value();

/**
* <code>fixed64 fixed64value = 8;</code>
*/
long getFixed64Value();

/**
* <code>sfixed32 sfixed32value = 9;</code>
*/
int getSfixed32Value();

/**
* <code>sfixed64 sfixed64value = 10;</code>
*/
long getSfixed64Value();

/**
* <code>bool boolvalue = 11;</code>
*/
boolean getBoolvalue();

/**
* <code>double doublevalue = 12;</code>
*/
double getDoublevalue();

/**
* <code>string stringvalue = 13;</code>
*/
java.lang.String getStringvalue();
/**
* <code>string stringvalue = 13;</code>
*/
com.google.protobuf.ByteString
getStringvalueBytes();

/**
* <code>bytes bytesvalue = 14;</code>
*/
com.google.protobuf.ByteString getBytesvalue();

/**
* <code>.baseStruct.PhoneType type = 15;</code>
*/
int getTypeValue();
/**
* <code>.baseStruct.PhoneType type = 15;</code>
*/
struct.protobuf.structs.baseStruct.PhoneType getType();
}

这里java类型与protobuf的类型关系完全复合上面的字段类型表

将message序列化使用writeTo方法：

public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
if (int32Value_ != 0) {
output.writeInt32(1, int32Value_);
}
if (int64Value_ != 0L) {
output.writeInt64(2, int64Value_);
}
if (uint32Value_ != 0) {
output.writeUInt32(3, uint32Value_);
}
if (uint64Value_ != 0L) {
output.writeUInt64(4, uint64Value_);
}
if (sint32Value_ != 0) {
output.writeSInt32(5, sint32Value_);
}
if (sint64Value_ != 0L) {
output.writeSInt64(6, sint64Value_);
}
if (fixed32Value_ != 0) {
output.writeFixed32(7, fixed32Value_);
}
if (fixed64Value_ != 0L) {
output.writeFixed64(8, fixed64Value_);
}
if (sfixed32Value_ != 0) {
output.writeSFixed32(9, sfixed32Value_);
}
if (sfixed64Value_ != 0L) {
output.writeSFixed64(10, sfixed64Value_);
}
if (boolvalue_ != false) {
output.writeBool(11, boolvalue_);
}
if (doublevalue_ != 0D) {
output.writeDouble(12, doublevalue_);
}
if (!getStringvalueBytes().isEmpty()) {
com.google.protobuf.GeneratedMessageV3.writeString(output, 13, stringvalue_);
}
if (!bytesvalue_.isEmpty()) {
output.writeBytes(14, bytesvalue_);
}
if (type_ != struct.protobuf.structs.baseStruct.PhoneType.MOBILE.getNumber()) {
output.writeEnum(15, type_);
}
unknownFields.writeTo(output);
}

可以看出，当一个值为空，直接跳过这个值。如果这个值存在，则写入它的filed_num和它编码后的值，

前面讲过对于不同类型的值，有不同的编码方式，比如int32使用先Zigzag编码再Varint编码，

而string通过length-delimited编码,等。

再看看complexStruct的builder和WriteTo方法

public interface complexStructOrBuilder extends
// @@protoc_insertion_point(interface_extends:complexStruct)
com.google.protobuf.MessageOrBuilder {

/**
* <code>map<int32, string> mapvalues = 1;</code>
*/
int getMapvaluesCount();
/**
* <code>map<int32, string> mapvalues = 1;</code>
*/
boolean containsMapvalues(
int key);
/**
* Use {@link #getMapvaluesMap()} instead.
*/
@java.lang.Deprecated
java.util.Map<java.lang.Integer, java.lang.String>
getMapvalues();
/**
* <code>map<int32, string> mapvalues = 1;</code>
*/
java.util.Map<java.lang.Integer, java.lang.String>
getMapvaluesMap();
/**
* <code>map<int32, string> mapvalues = 1;</code>
*/

java.lang.String getMapvaluesOrDefault(
int key,
java.lang.String defaultValue);
/**
* <code>map<int32, string> mapvalues = 1;</code>
*/

java.lang.String getMapvaluesOrThrow(
int key);

/**
* <code>repeated .MapFieldEntry map_field = 2;</code>
*/
java.util.List<struct.protobuf.structs.MapFieldEntry>
getMapFieldList();
/**
* <code>repeated .MapFieldEntry map_field = 2;</code>
*/
struct.protobuf.structs.MapFieldEntry getMapField(int index);
/**
* <code>repeated .MapFieldEntry map_field = 2;</code>
*/
int getMapFieldCount();
/**
* <code>repeated .MapFieldEntry map_field = 2;</code>
*/
java.util.List<? extends struct.protobuf.structs.MapFieldEntryOrBuilder>
getMapFieldOrBuilderList();
/**
* <code>repeated .MapFieldEntry map_field = 2;</code>
*/
struct.protobuf.structs.MapFieldEntryOrBuilder getMapFieldOrBuilder(
int index);
}

可以看出protobuf中的repected对应java.util.list

map对应java.util.Map

writeTo方法：

public void writeTo(com.google.protobuf.CodedOutputStream output)
throws java.io.IOException {
com.google.protobuf.GeneratedMessageV3
.serializeIntegerMapTo(
output,
internalGetMapvalues(),
MapvaluesDefaultEntryHolder.defaultEntry,
1);
for (int i = 0; i < mapField_.size(); i++) {
output.writeMessage(2, mapField_.get(i));
}
unknownFields.writeTo(output);
}

可以看出，被repected修饰的字段，这个字段中每个子项都用相同的field_num。

这样的优点是不用特殊标识就能标识一个集合字段。

但它的缺点很明显，整个protobuf只能标识一种集合类型。

也就是说map肯定转成list然后再编码的

protected static <V> void serializeIntegerMapTo(
CodedOutputStream out,
MapField<Integer, V> field,
MapEntry<Integer, V> defaultEntry,
int fieldNumber) throws IOException {
Map<Integer, V> m = field.getMap();
if (!out.isSerializationDeterministic()) {
serializeMapTo(out, m, defaultEntry, fieldNumber);
return;
}
// Sorting the unboxed keys and then look up the values during serialziation is 2x faster
// than sorting map entries with a custom comparator directly.
int[] keys = new int[m.size()];
int index = 0;
for (int k : m.keySet()) {
keys[index++] = k;
}
Arrays.sort(keys);
for (int key : keys) {
out.writeMessage(fieldNumber,
defaultEntry.newBuilderForType()
.setKey(key)
.setValue(m.get(key))
.build());
}
}
/** Serialize the map using the iteration order. */
private static <K, V> void serializeMapTo(
CodedOutputStream out,
Map<K, V> m,
MapEntry<K, V> defaultEntry,
int fieldNumber)
throws IOException {
for (Map.Entry<K, V> entry : m.entrySet()) {
out.writeMessage(fieldNumber,
defaultEntry.newBuilderForType()
.setKey(entry.getKey())
.setValue(entry.getValue())
.build());
}

通过serializeIntegerMapTo和serializeMapTo方法可知：

当Map最终是转换成list来编码的，其中map转换为list有两种顺序，

一种是按照map的迭代顺序存入list

一种是按照key的字典序

综上，我们通过分析代码理解了protobuf的编码过程，当然解码过程其实也就是把编码过程倒过来。

解码需要注意的是zigzag解码方式：

当使用支持无符号移位的语言时可以使用：

n = (n >>> 1)^(-(n & 1))

当使用像python这类不支持无符号移位的语言可以使用：

n = (n ^ (-(n & 1)) )>> 1

异构网络环境（Heterogeneous Network Environments）是指由不同制造商生产的计算机和系统组成的网络环境。这些计算机系统运行不同的操作系统和通信协议，想统一其计算机资源的机构通常会面临集成异种机系统的任务。一般地，每一个部门或分部已经根据操作系统、局域网拓扑结构、通信协议、应用程序、电子函件系统以及其它因素规定了自己的网络需要。企业网的目标就是使这些分散的资源可以进行互连和互操作，以便网络用户可以和其他用户一起共享文件和电子函件，或者访问企业的数据资源。 ↩
为了更好的跨语言性，google已将protobuf v2中的required删去，默认都是optional。并且也不在使用默认值及[default = * ],更多详见https://github.com/google/protobuf/blob/master/CHANGES.txt。 ↩
在知乎上看见一条关于protobuf v3中使用Map的警告：protobuf v3用了Emitter，Unity3d的il2cpp是不支持的，用Unity的留心了。 ↩
field_num及为

string name = 1

其中1就是name的field_num。 ↩