Protobuf源码解析-序列化后体积为何如此小

protobuf为Google研发的用于数据序列化的工具，github.com/protocolbuf…

Protobuf 快速使用

1. 编写IDL(Interface Definition Language)文件, user.proto

syntax = "proto3";
option go_package = "/proto/gen/model";

message User {
  int64 id = 1;
  string user_name = 2;
  repeated Role roles = 3;
  int64 create_time = 4;
  int64 update_time = 5;
}

message Role {
  int64 id = 1;
  string name = 2;
  string sign = 3;
}

这里使用用户和角色举例，message可以理解为struct（字段后面的数字有用吗，用在何处呢，将在后续揭晓）repeated关键可以理解为slice: []*Role

1. 安装protoc-gen-go

protobuf.dev/getting-sta…

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

1. 使用protoc命令生成代码

protoc -I=proto --go_out=../ proto/user.proto

1. 使用生成的结构体

go get github.com/protocolbuffers/protobuf-go
go mod tidy

	user := &model.User{
		Id:         1,
		UserName:   "tom",
		CreateTime: time.Now().Unix(),
		UpdateTime: time.Now().Unix(),
	}
	user.Roles = []*model.Role{
		{Id: 1, Name: "超级管理员", Sign: "super"},
		{Id: 2, Name: "管理员", Sign: "admin"},
	}

	fmt.Printf("%+v\n", user)
	// 序列化
	data, err := proto.Marshal(user)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Printf("marshal data len :%d\n", len(data))

	// 反序列化
	user2 := &model.User{}
	err = proto.Unmarshal(data, user2)
	if err != nil {
		t.Fatal(err)
	}

	fmt.Printf("%+v\n", user2)

log输出

id:1  user_name:"tom"  roles:{id:1  name:"超级管理员"  sign:"super"}  roles:{id:2  name:"管理员"  sign:"admin"}  create_time:1717054504  update_time:1717054504
marshal data len :69
id:1  user_name:"tom"  roles:{id:1  name:"超级管理员"  sign:"super"}  roles:{id:2  name:"管理员"  sign:"admin"}  create_time:1717054504  update_time:1717054504
--- PASS: Test1 (0.00s)
PASS

序列化对比

这里对JSON、XML、Protobuf这三种进行对比XML序列化工具使用了Go内置的"encoding/xml" ， JSON为"encoding/json"

• xml marshal -> utf8 string

<user><id>1</id><user_name>tom</user_name><roles><id>1</id><role_name>超级管理员</role_name><role_sign>super</role_sign></roles><roles><id>2</id><role_name>管理员</role_name><role_sign>admin</role_sign></roles><create_time>1717056371</create_time><update_time>1717056371</update_time></user>

• json marshal -> utf8 string

{"id":1,"user_name":"tom","roles":[{"id":1,"name":"超级管理员","sign":"super"},{"id":2,"name":"管理员","sign":"admin"}],"create_time":1717056717,"update_time":1717056717}

• protobuf marshal -> hex string

08011203746f6d1a1a0801120fe8b685e7baa7e7aea1e79086e591981a0573757065721a1408021209e7aea1e79086e591981a0561646d696e20d0eae0b20628d0eae0b206

说明：可以看到Protobuf在序列化和反序列化处理速度方面有优势之外体积还是最小的

序列化源码解析

如何明确的表达数据，例如 user_name = "tom", 在xml中使用_<user_name>tom</user_name>，在json中使用"user_name":"tom"_，很清晰，数据属性名为user_name值为tom，而在Protobuf中只用极少字节就可以表示数据属性并且在反序列化时还能准确的还原到结构体中，这个值叫wiretag，大致思路：只需要搞定wiretag和data是怎么转换的就大致知道序列化细节了

计算wiretag

包含两部分内容：字段num和字段类型

• 字段num就是我们编写.proto文件时每个字段后面的数字，例如

message User {
  int64 id = 1;
  string user_name = 2;
  repeated Role roles = 3;
  int64 create_time = 4;
  int64 update_time = 5;
}

• 字段类型在protobuf中有定义和映射

//....
type kind int8 
type Type int8
//...

var wireTypes = map[protoreflect.Kind]protowire.Type{
	protoreflect.BoolKind:     protowire.VarintType,
	protoreflect.EnumKind:     protowire.VarintType,
	protoreflect.Int32Kind:    protowire.VarintType,
	protoreflect.Sint32Kind:   protowire.VarintType,
	protoreflect.Uint32Kind:   protowire.VarintType,
	protoreflect.Int64Kind:    protowire.VarintType,
	protoreflect.Sint64Kind:   protowire.VarintType,
	protoreflect.Uint64Kind:   protowire.VarintType,
	protoreflect.Sfixed32Kind: protowire.Fixed32Type,
	protoreflect.Fixed32Kind:  protowire.Fixed32Type,
	protoreflect.FloatKind:    protowire.Fixed32Type,
	protoreflect.Sfixed64Kind: protowire.Fixed64Type,
	protoreflect.Fixed64Kind:  protowire.Fixed64Type,
	protoreflect.DoubleKind:   protowire.Fixed64Type,
	protoreflect.StringKind:   protowire.BytesType,
	protoreflect.BytesKind:    protowire.BytesType,
	protoreflect.MessageKind:  protowire.BytesType,
	protoreflect.GroupKind:    protowire.StartGroupType,
}

位于：/internal/impl/codec_gen.go

计算wiretag

// num为字段类型，typ为protowire
func EncodeTag(num Number, typ Type) uint64 {
	return uint64(num)<<3 | uint64(typ&7)
}

位于：/encoding/protowire/wire.go 510可以简单理解为 wiretag = num + type

计算数据

在proto.go文件中定义了protobuf支持的所有类型

const (
	BoolKind     Kind = 8
	EnumKind     Kind = 14
	Int32Kind    Kind = 5
	Sint32Kind   Kind = 17
	Uint32Kind   Kind = 13
	Int64Kind    Kind = 3
	Sint64Kind   Kind = 18
	Uint64Kind   Kind = 4
	Sfixed32Kind Kind = 15
	Fixed32Kind  Kind = 7
	FloatKind    Kind = 2
	Sfixed64Kind Kind = 16
	Fixed64Kind  Kind = 6
	DoubleKind   Kind = 1
	StringKind   Kind = 9
	BytesKind    Kind = 12
	MessageKind  Kind = 11
	GroupKind    Kind = 10
)

位于：/reflect/protoreflect/proto.go

在codec_tables.go中定义了每种类型的数据处理方法

func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) 
...
		switch fd.Kind() {
		case protoreflect.BoolKind:
			if ft.Kind() == reflect.Bool {
				return nil, coderBoolNoZero
			}
		case protoreflect.EnumKind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderEnumNoZero
			}
		case protoreflect.Int32Kind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderInt32NoZero
			}
...
		case protoreflect.Sfixed64Kind:
			if ft.Kind() == reflect.Int64 {
				return nil, coderSfixed64NoZero
			}
		case protoreflect.Fixed64Kind:
			if ft.Kind() == reflect.Uint64 {
				return nil, coderFixed64NoZero
			}
...

位于：/internal/impl/codec_tables.go

我们以int64类型为例，看下源码部分

// internal/impl/codec_gen.go
// 定义了int64类型数据的序列化和反序列化等处理方法
var coderInt64NoZero = pointerCoderFuncs{
	size:      sizeInt64NoZero,
	marshal:   appendInt64NoZero,
	unmarshal: consumeInt64,
	merge:     mergeInt64NoZero,
}

// internal/impl/codec_gen.go
// 这里定义了int64类型数据的序列化方式
func appendInt64NoZero(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
	v := *p.Int64()
	if v == 0 {
		return b, nil
	}
	b = protowire.AppendVarint(b, f.wiretag)
	b = protowire.AppendVarint(b, uint64(v))
	return b, nil
}

// encoding/protowire/wire.go AppendVarint
// 这里将数据按照字节拆分顺序放到字节数组中
func AppendVarint(b []byte, v uint64) []byte {
	switch {
	case v < 1<<7:
		b = append(b, byte(v))
	case v < 1<<14:
		b = append(b,
			byte((v>>0)&0x7f|0x80),
			byte(v>>7))
	case v < 1<<21:
		b = append(b,
			byte((v>>0)&0x7f|0x80),
			byte((v>>7)&0x7f|0x80),
			byte(v>>14))
	case v < 1<<28:
		b = append(b,
			byte((v>>0)&0x7f|0x80),
			byte((v>>7)&0x7f|0x80),
			byte((v>>14)&0x7f|0x80),
...
}       

从源码中可以看出，每种类型都提前对应了处理该类型数据的方法

下面具体看下User的数据是如何处理的

proto的定义： int64 id = 1;struct赋值：user.Id = 3121

1. 通过wiretag的计算公式得到wiretag值为: 8

   8

2. 通过AppendVarint方法将值3121转为 177 24并添加到数组中（注意这里并没有记录数据长度）

   8	177	24

proto的定义： string user_name = 2;struct赋值：user.UserName = "tom"

1. 通过类型映射可以得到string的处理方法 coderStringNoZeroValidateUTF8 -> appendStringNoZeroValidateUTF8 同样的公式计算username的wiretag值为：18

   8	177	24	18

2. 将UserName的数据长度3和数据都记录下来，data string -> utf8编码

   8	177	24	18	3	116	111	109

proto的定义： repeated Role roles = 3;struct赋值： user.Roles = []*model.Role{ {Id: 1,Name: "超级管理员s",Sign: "super"}, {Id: 2,Name: "管理员",Sign: "admin"},}

1. 通过类型找到序列化处理方法为appendMessageSliceInfo

func appendMessageSliceInfo(b []byte, p pointer, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
	// 获取到roles的两个Role指针
    s := p.PointerSlice()
	var err error
    // 遍历处理Role指针对应的struct
	for _, v := range s {
        // 记录roles的wiretag 26
		b = protowire.AppendVarint(b, f.wiretag)
		siz := f.mi.sizePointer(v, opts)
        // 记录role的长度
		b = protowire.AppendVarint(b, uint64(siz))
		before := len(b)
        // 这里将role当做常规的stuct处理，marshal必经之路
		b, err = f.mi.marshalAppendPointer(b, v, opts)
		if err != nil {
			return b, err
		}
		if measuredSize := len(b) - before; siz != measuredSize {
			return nil, errors.MismatchedSizeCalculation(siz, measuredSize)
		}
	}
	return b, nil
}

位于： /internal/impl/codec_filed.go

可以看出针对slice遍历每个item的指针，记录roles的wiretag和指针的size后面就是role的常规marshal处理方式了

8	177	24	18	3	116	111	109	↴

↳	26	27	8	1	18	16	232	182	...	115	26	5	115	...	114	↴
	rolestag	role1 len	role1id tag	role1id值	role1name tag	role1name数据长度	共计16个"超级管理员s"3 * 15 + 1				role1signtag	role1signlen	"super"

↳	26	20	8	2	18	9	231	174	...	152	26	5	97	...	110
	rolestag	role2 len	role2id tag	role2id值	role2name tag	role2name数据长度	共计9个"管理员"3 * 3				role2signtag	role2signlen	"admin"

proto的定义： int64 create_time = 4; int64 update_time = 5;struct赋值：CreateTime: time.Now().Unix(),UpdateTime: time.Now().Unix(),

1. 使用int64相同的方式计算create_time和update_time

   8	177	24	18	3	116	111	109	↴

   ↳	26	27	8	1	18	16	232	182	...	115	26	5	115	...	114	↴

   ↳	26	20	8	2	18	9	231	174	...	152	26	5	97	...	110	↴

↳	32	214	237	228	178	6	40	214	237	228	178	6
	create_timetag	create_timedata					update_timetag	update_timedata

小结

编写IDL文件时制定了字段类型和num，Protobuf为每种类型都配置了编解码的处理方法，定义的字段num被用于计算wiretag，通常我们制定num时从1开始然后顺序递增，例如1,2,3,4,5 其实num可以是乱序的，在序列化时也不会按照num来排序，num只是为了标记字段，我们也可以将num设置为很大的值但这样只会增加wiretag的存储空间，针对数字的处理使用了特殊的方式所以不需要记录数据长度，这个在后续的反序列化中会涉及，字符串的处理记录了长度和数据，slice的处理为遍历每个item然后按照常规的方式序列化每个item

反序列化源码解析

在上节结束从一个实例化的struct得到了一个[]byte，反序列化就是将[]byte还原为struct实例

流程图

源码分析

通过字段类型找到mapping好的处理方法

func fieldCoder(fd protoreflect.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
	...
    case protoreflect.BoolKind:
			if ft.Kind() == reflect.Bool {
				return nil, coderBoolNoZero
			}
		case protoreflect.EnumKind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderEnumNoZero
			}
		case protoreflect.Int32Kind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderInt32NoZero
			}
		case protoreflect.Sint32Kind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderSint32NoZero
			}
		case protoreflect.Uint32Kind:
			if ft.Kind() == reflect.Uint32 {
				return nil, coderUint32NoZero
			}
		case protoreflect.Int64Kind:
			if ft.Kind() == reflect.Int64 {
				return nil, coderInt64NoZero
			}
		case protoreflect.Sint64Kind:
			if ft.Kind() == reflect.Int64 {
				return nil, coderSint64NoZero
			}
		case protoreflect.Uint64Kind:
			if ft.Kind() == reflect.Uint64 {
				return nil, coderUint64NoZero
			}
		case protoreflect.Sfixed32Kind:
			if ft.Kind() == reflect.Int32 {
				return nil, coderSfixed32NoZero
			}
		case protoreflect.Fixed32Kind:
			if ft.Kind() == reflect.Uint32 {
				return nil, coderFixed32NoZero
			}
        ...

位于 /internal/impl/codec_tables.go

收集好类型对应的unmarshal处理方式接下来就是调用unmarshal方法给struct赋值然后截取data数据处理剩余数据之前说到过wiretag = num + type，只要得到了wiretag就能知晓对应哪个字段以及使用哪个unmarshal方法处理数据

		var tag uint64
		if b[0] < 0x80 {
			tag = uint64(b[0])
			b = b[1:]
		} else if len(b) >= 2 && b[1] < 128 {
			tag = uint64(b[0]&0x7f) + uint64(b[1])<<7
			b = b[2:]
		} else {
			var n int
			tag, n = protowire.ConsumeVarint(b)
			if n < 0 {
				return out, errDecode
			}
			b = b[n:]
		}

由于wiretag的处理方式复用了ConsumeVarint所以一样的方式可以轻松获取到wiretag

num = protowire.Number(n)
wtyp := protowire.Type(tag & 7)
f = mi.denseCoderFields[num]

其实这里的type更多是为了做校验，通过num就能拿到之前mapping好的unmarshal方法了例如：

8	177	24	...

取wiretag后数据剩下了 177,24,18... 看下int64的unmarshal方法：

func consumeInt64(b []byte, p pointer, wtyp protowire.Type, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
	if wtyp != protowire.VarintType {
		return out, errUnknown
	}
	var v uint64
	var n int
	if len(b) >= 1 && b[0] < 0x80 {
		v = uint64(b[0])
		n = 1
	} else if len(b) >= 2 && b[1] < 128 {
		v = uint64(b[0]&0x7f) + uint64(b[1])<<7
		n = 2
	} else {
		v, n = protowire.ConsumeVarint(b)
	}
	if n < 0 {
		return out, errDecode
	}
    // 通过指针赋值
	*p.Int64() = int64(v)
	out.n = n
	return out, nil
}

位于 /internal/impl/codec_gen.go核心处理方法为ConsumeVarint

func ConsumeVarint(b []byte) (v uint64, n int) {
	var y uint64
	if len(b) <= 0 {
		return 0, errCodeTruncated
	}
	v = uint64(b[0])
	if v < 0x80 {
		return v, 1
	}
	v -= 0x80

	if len(b) <= 1 {
		return 0, errCodeTruncated
	}
	y = uint64(b[1])
    // 这里的v计算后就是字段的值
	v += y << 7
	if y < 0x80 {
		return v, 2
	}
	v -= 0x80 << 7

	if len(b) <= 2 {
		return 0, errCodeTruncated
	}
    
    ...

	if len(b) <= 5 {
		return 0, errCodeTruncated
	}
	y = uint64(b[5])
	v += y << 35
	if y < 0x80 {
		return v, 6
	}
	v -= 0x80 << 35
    ...

位于 /encoding/protowire/wire.go通过源码我们可以看到由于序列化使用的方式从左到右每位最多为0x80所以只需要检测小于0x80就知道结束位置了，这也就是为什么在序列化时没有对int64做长度的记录回到源数据，177 > 128所以需要继续检测第二位：24 < 128满足条件，检测结束：位数为2，值为3121

每次处理一个字段并去除处理过的数据直到所有字节数据被处理完成

// 遍历b直到数组无数据
for len(b) > 0 {
...
// 处理后截取字节数组留下未处理的数据
b = b[n:]
...
}

剩余数据处理方式类似，这里不再赘述

小结

通过源码可以看到用protoc生成的xx.pb.go文件在反序列化时也会用到，在生成的代码顶部也有提示不要对这部分代码，通过提前为每个类型映射unmarshal方法很容易能通过wiretag的解析找到数据解析方式，得益于Go保留的指针运算能力可以快速的为结构体赋值

摸鱼时刻

为大家推荐一款国内常见的观赏鱼 - 虾虎

小型，溪流，高氧 饲养难度：中 - 高 - 极高 - 入缸dead 成年尺寸： 5 - 9 厘米 杂食，偏肉食，好斗

真吻虾虎（子陵吻虾虎） / 国内各大水系

波氏吻虾虎 / 长江以北，浙江

褐吻虾虎 / 山东、河北、北京、东北三省

黑吻虾虎 / 长江流域中下游支流上游（浙江、江西、湖南、安徽）

李氏吻虾虎 / 长江流域以南 、湖南

颌带吻虾虎 / 江西东北部

乌岩岭吻虾虎 / 福建宁德、浙江温州、台州

周氏吻虾虎 / 粤东 / 饲养难度极高！！

丝鳍吻虾虎 / 珠江水系

南渡江吻虾虎 / 南渡江