关于Protobuf的学习

最新推荐文章于 2024-07-16 15:16:09 发布
最新推荐文章于 2024-07-16 15:16:09 发布
阅读量6.8k 收藏 6
点赞数 2
分类专栏： java 文章标签： protobuf
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30643987/article/details/79024350
版权

简介

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 TypeJava Typenotes
int32int使用变长编码，在值为负数的情况下效率低，应采用sin32代替
int64long使用变长编码，在值为负数的情况下效率低，应采用sin64代替
uint32int使用变长编码
uint64long使用变长编码
sint32int使用变长编码，有符号整型，在值为负数的情况下效率高
sint64long使用变长编码，有符号整型，在值为负数的情况下效率高
fixed32int固定四个字节.如果值经常大于2^28使用fixed32会比使用uint32更高效
fixed64long固定八个字节.如果值经常大于2^56使用fixed64会比使用uint64更高效
sfixed32int有符号，固定四个字节
sfixed64long有符号，固定八个字节
boolboolean
doubledouble
stringStringstring必须一致包含UTF-8编码或者7-bit ASCII字符串
bytesByteString可以包含任意字节序列

字段类型对应二进制类型

字段类型二进制类型二进制编码值
int32,int64,uint32,uint64,sint32,sint64,bool,enumVarint(可变长度int)0
fixed64,sfixed64,doubledouble1
string,bytes,inner messages(内部嵌套),packaed repeated fields(repeated字段)Length-delimited2
groups(deprecated)Start group3
groups(deprecated)Endd group4
fixed32,sfixed32,float32bit固定长度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编码将整数重新映射到定义域，使得整数映射后的补码长度和绝对值的大小成正相关:

原始值编码后的值编码后的补码
0000000000
-1100000001
1200000010
-2300000011
3400000100
………

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&lt;int32, string&gt; mapvalues = 1;</code>
     */
    int getMapvaluesCount();
    /**
     * <code>map&lt;int32, string&gt; 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&lt;int32, string&gt; mapvalues = 1;</code>
     */
    java.util.Map<java.lang.Integer, java.lang.String>
    getMapvaluesMap();
    /**
     * <code>map&lt;int32, string&gt; mapvalues = 1;</code>
     */

    java.lang.String getMapvaluesOrDefault(
        int key,
        java.lang.String defaultValue);
    /**
     * <code>map&lt;int32, string&gt; 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
  1. 异构网络环境（Heterogeneous Network Environments）是指由不同制造商生产的计算机和系统组成的网络环境。这些计算机系统运行不同的操作系统和通信协议，想统一其计算机资源的机构通常会面临集成异种机系统的任务。一般地，每一个部门或分部已经根据操作系统、局域网拓扑结构、通信协议、应用程序、电子函件系统以及其它因素规定了自己的网络需要。企业网的目标就是使这些分散的资源可以进行互连和互操作，以便网络用户可以和其他用户一起共享文件和电子函件，或者访问企业的数据资源。 ↩
  2. 为了更好的跨语言性，google已将protobuf v2中的required删去，默认都是optional。并且也不在使用默认值及[default = * ],更多详见https://github.com/google/protobuf/blob/master/CHANGES.txt。 ↩
  3. 在知乎上看见一条关于protobuf v3中使用Map的警告：protobuf v3用了Emitter，Unity3d的il2cpp是不支持的，用Unity的留心了。 ↩
  4. field_num及为string name = 1其中1就是name的field_num。 ↩
xperdit
关注
  • 2
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Protobuf基本使用
tangjing556的博客
02-18 195
一、 安装Protobuf 去Protobuf的GitHub下载，解压。 如果你是Windows环境，则还要下载protoc.exe 把protoc.exe放在Protobuf安装目录下的src里。 二、 配置环境变量 编辑系统变量Path，添加Protoc.exe的存放目录。 三、Eclipse新建项目 我使用maven构建protobuf项目，方便引入依赖。 在项目根目录创建proto文件夹，...
protobuf学习笔记
Aajbelieve的博客
08-10 2431
protobuf官方网址：https://developers.google.com/protocol-buffers github源码：https://github.com/protocolbuffers/protobuf 1. protobuf是什么 “Protocol buffers are Google’s language-neutral, platform-neutral, extensible mechanism for serializing structured data – think
caffe 之 protobuf
slamer的专栏
01-12 1105
著作权归作者所有。 商业转载请联系作者获得授权，非商业转载请注明出处。 作者：Vinjn张静 链接：http://zhuanlan.zhihu.com/hacker-and-painter/20435591 来源：知乎 Protobuf 定义 Protobuf 是google开源的一个序列化协议，可以通过在proto文件中定义结构化类型，生成平台无关的C++、Java、Python
protobuf简介
忘忧.
07-16 3568
编写 .proto ⽂件，⽬的是为了定义结构对象（message）及属性内容。使⽤ protoc 编译器编译 .proto ⽂件，⽣成⼀系列接⼝代码，存放在新⽣成头⽂件和源⽂件中。依赖⽣成的接⼝，将编译⽣成的头⽂件包含进我们的代码中，实现对 .proto ⽂件中定义的字段进行设置和获取，和对 message 对象进行序列化和反序列化。
Google 开源技术protobuf
weixin_30847865的博客
03-07 275
1. Protobuf简介 protobuf是google提供的一个开源序列化框架，类似于XML，JSON这样的数据表示语言，其最大的特点是基于二进制，因此比传统的XML表示高效短小得多。虽然是二进制数据格式，但并没有因此变得复杂，开发人员通过按照一定的语法定义结构化的消息格式，然后送给命令行工具，工具将自动生成相关的类，可以支持php...
Protobuf数据定义
Edison Xu
10-17 4391
Protobuf消息定义 消息由至少一个字段组合而成，类似于C语言中的结构。每个字段都有一定的格式。 字段格式：限定修饰符①| 数据类型② | 字段名称③ | = | 字段编码值④ | [字段默认值⑤] ①．限定修饰符包含required\optional\repeated   Required:表示是一个必须字段，必须相对于发送方，在发送消息之前必须设置该字段的值，对于接收方，必须能够
Protobuf入门
Stefanie_ttr的博客
04-15 391
Protobuf介绍 Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，目前已经正在使用的有超过 48,162 种报文格式定义和超过 12,183 个 .proto 文件。他们用于 RPC 系统和持续数据存储系统。 Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数
protobuf中文学习文档
11-18
**protobuf中文学习文档** **一、protobuf简介** Protocol Buffers（简称protobuf）是Google开发的一种数据序列化协议，用于高效地存储和传输结构化数据。它通过定义消息格式，将数据结构转换为二进制流，相比XML...
关于Windows环境下protobuf初步学习指南.doc
最新发布
07-24
windows
protobuf source v3.21.12
04-28
通过学习protobuf源代码，你可以获得对数据序列化协议深入的理解，这将有助于你在实际开发中更有效地利用protobuf，甚至为protobuf贡献自己的代码。同时，这也是一种提升编程技能和软件设计能力的好方法。
protobuf学习
07-29
关于学习 Protocol Buffers（protobuf），您可以从以下几个方面入手： 1. 官方文档：首先，您可以查阅 Protocol Buffers 的官方文档，它提供了详细的说明、示例和教程，可以帮助您了解 protobuf 的基本概念和用法。...
protobuf-java-3.4.1.jar
10-28
( protobuf-java-3.4.1.jar ) 最新版本，可直接使用的
Google Protobuf使用
JimCal
09-12 7476
        Protobuf，全称Protocol Buffers，由Google公司开发出来且其内部广泛使用，对比其它的编解码框架，有如下几个优点：         1. 跨语言支持，如Java、C++、Python等         2. 编码后消息更小，因此，更有利于网络传输和本地存储，当然，性能也很强大         3. 不同版本协议的数据结构前向兼容        Pro...
如何使用google.protobuf.Struct？
云笔记
05-08 762
包提供了一种方式来创建和操作类型的数据。是一种灵活的数据类型，可以表示任何结构化数据。以下是如何使用structpbStructStruct注意：在从Struct读取数据时，需要进行类型断言，因为AsMap函数返回的是类型的数据。
一种自动反射消息类型的 Google Protobuf 网络传输方案
热门推荐
陈硕的Blog
04-03 8万+
这篇文章要解决的问题是：在接收到 protobuf 数据之后，如何自动创建具体的 Protobuf Message 对象，再做的反序列化。“自动”的意思是：当程序中新增一个 protobuf Message 类型时，这部分代码不需要修改，不需要自己去注册消息类型。其实，Google Protobuf 本身具有很强的反射(reflection)功能，可以根据 type name 创建具体类型的 Message 对象，我们直接利用即可。
protobuf介绍和使用
mayue_web的博客
05-29 1490
Protocol Buffers（简称为ProtoBuf）是一种用于序列化结构化数据的语言无关、平台无关、可扩展的机制。ProtoBuf是由Google开发的一种数据序列化格式，用于在不同的系统和语言之间进行数据交换。它具有以下特点：语言无关性：ProtoBuf支持多种编程语言，包括C++、Java、Python、Go等，这使得不同语言的应用程序可以使用相同的数据结构进行通信。
ProtoBuf文件生成Java对象
weixin_43406151的博客
08-24 324
ProtoBuf安装及ProtoBuf文件生成Java对象
实现自己的Protobuf Any
DoneSpeak的博客
11-01 4706
这里写自定义目录标题前言Protobuf的any: google.protobuf.Anygoogle.protobuf.Any 也是由 proto 文件定义的google.protobuf.Any 本身也是一个 GeneratedMessageV3自定义AnyDataAnyData 的编码和解析定义一个将typeUrl和Class映射的lookup工具类查找指定路径下的类及其内部类找到一个包下的...
Unity 5.x中使用Protobuf
yubo112002的专栏
11-01 1251
哎，各种坑，总算整差不多明白了，放了一个github工程，把配套的protobuf-net源码，dll和生成工具都放一起了。   注意仔细读README，如果使用mono的，直接把dll放到工程的Plugins目录下就行了，要选择.net 2.0，不能用.net 2.0 subset。   如果要使用il2cpp的，需要把协议文件与protobuf-net for Unity的dll文件一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值