Protobuf通信协议详解

Protobuf（全称是Protocol Buffers）是一种跨平台、语言无关、可扩展的序列化结构数据的方法，可用于网络通信数据交换及存储。

在序列化结构化数据的机制中，Protobuf是灵活、高效、自动化的，相对常见的XML、JSON，描述同样的信息，Protobuf序列化后数据量更小、序列化/反序列化速度更快、更简单。

一旦定义了要处理的数据的数据结构之后，就可以利用Protobuf的代码生成工具生成相关的代码。只需使用 Protobuf 对数据结构进行一次描述，即可利用各种不同语言（proto3支持C++, Java, Python, Go, Ruby, Objective-C, C#）或从各种不同流中对你的结构化数据轻松读写。

定义proto文件

syntax = "proto2";
option java_outer_classname = "MsgProtos";

enum MsgEnum {
  Code1 = 1;
  Code2 = 2;
  Code3 = 3;
}

message Msg {
  required string f1 = 1;
  optional string f2 = 2;
  repeated string f3 = 3;
  optional int32 f4 = 4;
  optional int64 f5 = 5;
  optional bytes f6 = 6;
  optional bool f7 = 7;
  optional uint32 f8 = 8;
  optional uint64 f9 = 9;
  optional SubMsg f10 = 10;
  optional MsgEnum f11 = 11;
}

message SubMsg {
  required string f1 = 1;
}

以上述几种类型展开分析一下protobuf的编码过程。
包括：required、optional、repeated、基本类型、SubMsg、enum等情况。

    public static void main(String[] args) throws Exception {
        MsgProtos.Msg msg = MsgProtos.Msg.newBuilder()
                .setF1("test1")
                .setF2("test2")
                .addF3("test3")
                .setF4(4)
                .setF5(5L)
                .setF6(ByteString.copyFrom("test4".getBytes()))
                .setF7(true)
                //uint32
                .setF8(8)
                //uint64
                .setF9(9L)
                .setF10(MsgProtos.SubMsg.newBuilder()
                        .setF1("test5")
                        .build())
                .setF11(MsgProtos.MsgEnum.Code1)
                .build();
        byte[] bytes = msg.toByteArray();
    }

调用toByteArray后，protobuf通过自动生成的代码开始序列化数据，定义一个byte[]并创建CodedOutputStream用来写数据。
所有的数据类型都通过writeTo为入口写入。不同的数据类型通过不同的序列化方法写入。

  @Override
  public byte[] toByteArray() {
    try {
      final byte[] result = new byte[getSerializedSize()];
      final CodedOutputStream output = CodedOutputStream.newInstance(result);
      writeTo(output);
      output.checkNoSpaceLeft();
      return result;
    } catch (IOException e) {
      throw new RuntimeException(getSerializingExceptionMessage("byte array"), e);
    }
  }

    public void writeTo(com.google.protobuf.CodedOutputStream output)
                        throws java.io.IOException {
      if (((bitField0_ & 0x00000001) == 0x00000001)) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 1, f1_);
      }
      if (((bitField0_ & 0x00000002) == 0x00000002)) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 2, f2_);
      }
      for (int i = 0; i < f3_.size(); i++) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 3, f3_.getRaw(i));
      }
      if (((bitField0_ & 0x00000004) == 0x00000004)) {
        output.writeInt32(4, f4_);
      }
      if (((bitField0_ & 0x00000008) == 0x00000008)) {
        output.writeInt64(5, f5_);
      }
      if (((bitField0_ & 0x00000010) == 0x00000010)) {
        output.writeBytes(6, f6_);
      }
      if (((bitField0_ & 0x00000020) == 0x00000020)) {
        output.writeBool(7, f7_);
      }
      if (((bitField0_ & 0x00000040) == 0x00000040)) {
        output.writeUInt32(8, f8_);
      }
      if (((bitField0_ & 0x00000080) == 0x00000080)) {
        output.writeUInt64(9, f9_);
      }
      if (((bitField0_ & 0x00000100) == 0x00000100)) {
        output.writeMessage(10, getF10());
      }
      if (((bitField0_ & 0x00000200) == 0x00000200)) {
        output.writeEnum(11, f11_);
      }
      unknownFields.writeTo(output);
    }

writeString(output, 1, f1_)

以writeString(output, 1, f1_)为例，1为字段序号，f1_为字段的值。

    @Override
    public final void writeString(final int fieldNumber, final String value) throws IOException {
      writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
      writeStringNoTag(value);
    }

    @Override
    public final void writeTag(final int fieldNumber, final int wireType) throws IOException {
      writeUInt32NoTag(WireFormat.makeTag(fieldNumber, wireType));
    }

	static final int TAG_TYPE_BITS = 3;

    static int makeTag(final int fieldNumber, final int wireType) {
    	return (fieldNumber << TAG_TYPE_BITS) | wireType;
  	}

字符串的写入分两部分，tag和value。tag由fieldNumber和wireType组成。
将fieldNumber向左位移3位，挪出来的3位存放wireType。

      ↓高位存放fieldNumber
0b00001010

wireType有一下几种

  public static final int WIRETYPE_VARINT           = 0;
  public static final int WIRETYPE_FIXED64          = 1;
  public static final int WIRETYPE_LENGTH_DELIMITED = 2;
  public static final int WIRETYPE_START_GROUP      = 3;
  public static final int WIRETYPE_END_GROUP        = 4;
  public static final int WIRETYPE_FIXED32          = 5;

字符串是WIRETYPE_LENGTH_DELIMITED。
通过编码后的tag能同时获取到字段的fieldNumber和wireType。
接下来是写字符串的数据value

    @Override
    public final void writeStringNoTag(String value) throws IOException {
      final int oldPosition = position;
      try {
        // UTF-8 byte length of the string is at least its UTF-16 code unit length (value.length()),
        // and at most 3 times of it. We take advantage of this in both branches below.
        final int maxLength = value.length() * Utf8.MAX_BYTES_PER_CHAR;
        final int maxLengthVarIntSize = computeUInt32SizeNoTag(maxLength);
        final int minLengthVarIntSize = computeUInt32SizeNoTag(value.length());
        if (minLengthVarIntSize == maxLengthVarIntSize) {
          position = oldPosition + minLengthVarIntSize;
          int newPosition = Utf8.encode(value, buffer, position, spaceLeft());
          // Since this class is stateful and tracks the position, we rewind and store the state,
          // prepend the length, then reset it back to the end of the string.
          position = oldPosition;
          int length = newPosition - oldPosition - minLengthVarIntSize;
          writeUInt32NoTag(length);
          position = newPosition;
        ......
    }

	public static int computeUInt32SizeNoTag(final int value) {
		if ((value & (~0 <<  7)) == 0) {
		  return 1;
		}
		if ((value & (~0 << 14)) == 0) {
		  return 2;
		}
		if ((value & (~0 << 21)) == 0) {
		  return 3;
		}
		if ((value & (~0 << 28)) == 0) {
		  return 4;
		}
		return 5;
  }

在计算字符串长度时做了压缩编码。
如果字符串的长度是4，那么一个字节就可以放下，就返回一个字节。
如果字符串的长度是512，那么两个字节才可以放下，就返回两个字节。
protobuf是先写入value并空出一个value.length的字节数，最后写入length。
字符串的编码格式如下

+++++++++++++++++++++
+ tag + len + value +
+++++++++++++++++++++

这是一个典型的TLV编码，不过在这基础上又做了压缩。T中同时包括字段序号和字段类型。

writeInt32(4, f4_)

    @Override
    public final void writeInt32(final int fieldNumber, final int value) throws IOException {
      writeTag(fieldNumber, WireFormat.WIRETYPE_VARINT);
      writeInt32NoTag(value);
    }

    @Override
    public final void writeInt32NoTag(int value) throws IOException {
      if (value >= 0) {
        writeUInt32NoTag(value);
      } else {
        // Must sign-extend.
        writeUInt64NoTag(value);
      }
    }

与writeString类似，不同的是int32类型没有len因为int32与string不同，它的长度是固定通过tag可以解析出是int32类型。

+++++++++++++++
+ tag + value +
+++++++++++++++

Varint编码

在int32的类型上使用了Varint编码。一种变长的编码方式。用字节表示数字值越小的数字，使用越少的字节数表示。通过减少表示数字的字节数从而进度数据的压缩。
实现方式：每个字节的最高位为1，表示后续的一个字节也是数字的一部分。如果字节的最高位为0，则表示结束。使用其它7位来表示数字。
每次从value上取出最后一个字节写入，当(value & ~0x7F) == 0为最后一个字节。（字节序：小端）

    @Override
    public final void writeUInt32NoTag(int value) throws IOException {
        long pos = ARRAY_BASE_OFFSET + position;
        while (true) {
          if ((value & ~0x7F) == 0) {
            UnsafeUtil.putByte(buffer, pos++, (byte) value);
            position++;
            return;
          } else {
            UnsafeUtil.putByte(buffer, pos++, (byte) ((value & 0x7F) | 0x80));
            position++;
            value >>>= 7;
          }
        }
    }

以int value=21534为例，正常一个int占4个字节，但Varint编码只有三个字节。

# 21534二进制
0b00000000_00011110_00101000_00000001
# Varint编码除最后一个字节其他高位为1，只用了3个字节存储
0b10011110_10101000_00000001

负数

由于原来的高1是表示负数的，现在被Varint占用那负数protobuf是怎么处理的呢？

<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
    <version>3.2.0</version>
</dependency>

网上很多分析说是使用了Zigzag编码，但基于我分析的3.2.0版本代码还不是的。

    @Override
    public final void writeInt32NoTag(int value) throws IOException {
      if (value >= 0) {
        writeUInt32NoTag(value);
      } else {
        // Must sign-extend.
        writeUInt64NoTag(value);
      }
    }

    public final void writeUInt64NoTag(long value) throws IOException {
      long pos = ARRAY_BASE_OFFSET + position;
      while (true) {
        if ((value & ~0x7FL) == 0) {
          UnsafeUtil.putByte(buffer, pos++, (byte) value);
          position++;
          return;
        } else {
          UnsafeUtil.putByte(buffer, pos++, (byte) (((int) value & 0x7F) | 0x80));
          position++;
          value >>>= 7;
        }
      }
    }

protobuf在处理int32为负数时，使用long来存储(大写的离谱)。-5在经过按字节编码后占了10个字节。

编码前
0b11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111011
编码后
0b11111011_11111111_11111111_11111111_11111111_11111111_11111111_11111111_11111111_00000001

其他类型

writeInt64、writeBytes、writeBool与上述一样。

writeMessage(10, getF10())

    @Override
    public final void writeMessage(final int fieldNumber, final MessageLite value)
        throws IOException {
      writeTag(fieldNumber, WireFormat.WIRETYPE_LENGTH_DELIMITED);
      writeMessageNoTag(value);
    }

这是写SubMsg，与string一样是wireType为WireFormat.WIRETYPE_LENGTH_DELIMITED。
不同的是value为嵌套结构，是一个TL-V(TLV)

++++++++++++++++++++++++++++++++++++++++
+     +           ++++++++++++++++++++++
+ tag + SubMsglen + tag + len + value ++
+     +           ++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++

writeEnum(11, f11_)

与writeInt32一样。

required、optional

	public Builder setF1(
	        java.lang.String value) {
	  if (value == null) {
	    throw new NullPointerException();
	  }
	  bitField0_ |= 0x00000001;
	  f1_ = value;
	  onChanged();
	  return this;
	}

	public Builder setF2(
	        java.lang.String value) {
	    if (value == null) {
	        throw new NullPointerException();
	    }
	    bitField0_ |= 0x00000002;
	    f2_ = value;
	    onChanged();
	    return this;
	}

	public MsgProtos.Msg build() {
	  MsgProtos.Msg result = buildPartial();
	  if (!result.isInitialized()) {
	    throw newUninitializedMessageException(result);
	  }
	  return result;
	}

	public boolean hasF1() {
	  return ((bitField0_ & 0x00000001) == 0x00000001);
	}

所有字段在set后都会在bitField0_中对应的位标记为1，有required修饰符的字段在build时取出判断是否set过。

repeated

      for (int i = 0; i < f3_.size(); i++) {
        com.google.protobuf.GeneratedMessageV3.writeString(output, 3, f3_.getRaw(i));
      }

repeated修饰符写入string和正常string一样，只是多了一个for循环。
同时并没有写入f3_.size()，那么protobuf这解析时是怎么知道有多少个string的呢?
其他f3的数据tag中都包含了fieldNumber=3，当列表数据取完时下一个fieldNumber=4就表示列表数据取完了。

手写一个protobuf编码

先定义简单一点的proto文件

message Test {
  optional string f1 = 1;
  optional int32 f2 = 2;
  optional bool f3 = 3;
  optional uint32 f4 = 4;
  optional uint64 f5 = 5;
  repeated string f6 = 6;
}

使用Netty中的ByteBuf编码

    public static void main(String[] args) throws Exception {
        ByteBuf buffer = Unpooled.buffer();
        
        String f1 = "test";
        byte[] buf = f1.getBytes();
        buffer.writeByte(1 << 3 | WireFormat.WIRETYPE_LENGTH_DELIMITED);
        buffer.writeByte(buf.length);
        buffer.writeBytes(buf);

        int f2 = 100000001;
        buffer.writeByte(2 << 3 | WireFormat.WIRETYPE_VARINT);
        writeInt(buffer, f2);

        boolean f3 = true;
        buffer.writeByte(3 << 3 | WireFormat.WIRETYPE_VARINT);
        buffer.writeByte(f3 ? 1 : 0);

        int f4 = 100000002;
        buffer.writeByte(4 << 3 | WireFormat.WIRETYPE_VARINT);
        writeInt(buffer, f4);

        int f5 = 100000003;
        buffer.writeByte(5 << 3 | WireFormat.WIRETYPE_VARINT);
        writeInt(buffer, f5);

        for (int i = 0; i < 10; i++) {
            String f6 = "test" + i;
            byte[] b = f6.getBytes();
            buffer.writeByte(6 << 3 | WireFormat.WIRETYPE_LENGTH_DELIMITED);
            buffer.writeByte(b.length);
            buffer.writeBytes(b);
        }
        
        byte[] out = new byte[buffer.readableBytes()];
        buffer.readBytes(out);
        MsgProtos.Test parse = MsgProtos.Test.parseFrom(out);
        System.out.println(parse);
    }

    public static void writeInt(ByteBuf byteBuf, int value) {
        while (true) {
            if ((value & ~0x7F) == 0) {
                byteBuf.writeByte(value);
                return;
            } else {
                byteBuf.writeByte((value & 0x7F) | 0x80);
                value >>>= 7;
            }
        }
    }

f1: "test"
f2: 100000001
f3: true
f4: 100000002
f5: 100000003
f6: "test0"
f6: "test1"
f6: "test2"
f6: "test3"
f6: "test4"
f6: "test5"
f6: "test6"
f6: "test7"
f6: "test8"
f6: "test9"

数据被正确解析出来了。