ProtoBuf-反射原理与使用

最新推荐文章于 2024-02-22 21:08:43 发布
最新推荐文章于 2024-02-22 21:08:43 发布
阅读量3.4k 收藏 27
点赞数 11
分类专栏： 远程调用RPC 文章标签： c++ protobuf 反射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h2517956473/article/details/117387877
版权

文章目录

前言

所谓反射机制，就是能够在运行时知道任意类的所有属性和方法，能够调用任意对象的任意方法和属性。这种动态获取的信息以及动态调用对象方向的功能称为反射机制。
如果用一句话来总结反射实现的关键，可概括为获取系统元信息。

元信息：即系统自描述信息，用于描述系统本身。举例来讲，即系统有哪些类？类中有哪些字段、哪些方法？字段属于什么类型、方法又有怎样的参数和返回值？…

不像Jave，python等语言，C++本身没有反射机制，但使用protobuf时，通过proto文件产生响应的message和service，可以提供反射机制，运行时可以通过proto获取任意message和任意service的属性和方法，并调用、修改和设置。

相关应用场景

Protobuf是一种常见的数据序列化方式，常常用于后台微服务之间传递数据。
在处理ProtoBuf Message数据时，经常需要根据一个输入的字符串，读取Message中对应属性的取值，并修改取值。；或者给定一个ProtoBuf对象，如何自动遍历该对象的所有字段，将其转换为json格式，或者在Bigtable中根据pb对象的字段自动写填写列名和对应的value。

在写代码时，经常会遇到一些丑陋的、圈复杂度较高、较难维护的关于 PB 的使用代码：

  1. 对字段的必填校验硬编码在代码中：如果需要变更校验规则，则需要修改代码
  2. 一个字段一个 if 校验，复杂度较高：对传进来的字段每个字段都进行多种规则校验，例如长度，XSS，正则校验等。
  3. 想要获取 PB 中所有的非空字段，形成一个 map<string,string>，需要大量的 if 判断和重复代码；
  4. 在后台服务间传递数据，由于模块由不同的人开发，导致相同字段的命名不一样，从一个 PB 中挑选一部分内容到另外一个 PB 中，需要大量的 GET 和 SET 代码。

以上都痛点可以通过反射机制解决。

一、ProtoBuf 反射原理概述

  1. 通过Message获取单个字段的FieldDescriptor
  2. 通过Message获取其Reflection
  3. 通过Reflection来操作FieldDescriptor，从而动态获取或修改单个字段

1、获取message和service的属性和方法

protobuf通过Descriptor获取任意message或service的属性和方法，Descriptor主要包括了一下几种类型：

描述符方法
FileDescriptor获取Proto文件中的Descriptor和ServiceDescriptor
Descriptor获取类message属性和方法，包括FieldDescriptor和EnumDescriptor
FieldDescriptor获取message中各个字段的类型、标签、名称等
EnumDescriptor获取Enum中的各个字段名称、值等
ServiceDescriptor获取service中的MethodDescriptor
MethodDescriptor获取各个RPC中的request、response、名称等

在类 Descriptor 中 可以获取自身信息的函数

const std::string & name() const; // 获取message自身名字
int field_count() const; // 获取该message中有多少字段
const FileDescriptor* file() const; // The .proto file in which this message type was defined. Never nullptr.

在类 Descriptor 中，可以通过如下方法获取类 FieldDescriptor：

const FieldDescriptor* field(int index) const; // 根据定义顺序索引获取，即从0开始到最大定义的条目
const FieldDescriptor* FindFieldByNumber(int number) const; // 根据定义的message里面的顺序值获取（option string name=3，3即为number）
const FieldDescriptor* FindFieldByName(const string& name) const; // 根据field name获取

也就是说，如果能够获取到proto文件的FileDescriptor，就能获取proto文件中的所有的内容。那么如何获取proto文件的FileDescriptor呢？protobuf提供多种方法。

1.1 使用protoc将proto文件生成.h和.cc文件

这种方法直接根据生成的类来获取响应的FileDescriptor，比如现在有test.proto文件，那么可以通过DescriptorPool::generated_pool()获取到其FileDescriptor

const FileDescriptor* fileDescriptor = DescriptorPool::generated_pool()->FindFileByName(file);

并且对于任意的message和service都可以根据其名称，通过DescriptorPool对应的Descriptor和ServiceDescriptor

1.2 只使用proto文件，不使用protoc进行编译

这种情况需要手动解析proto文件，再获取FileDescriptor。protobuf提供了响应的解析器compiler，通过compoiler可以方便的获取proto文件的FileDescriptor

const FileDescriptor* GetFileDescriptorFromProtoFile(const std::string &protoRoot, const std::string &protoFile){
    compiler::DeskSourceTree sourceTree;
    sourceTree.MapPath("", protoRoot);
    FileErrorCollector errorCollector;
    compiler::Importer importer(&sourceTree, &errorCollector);
    return importer.Import(protoFile);
}

1.3 非 .proto 文件 ，转换成.proto

  1. 可以从远程读取，如将数据与数据元信息一同进行 protobuf 编码并传输：
message Req {
  optional string proto_file = 1;
  optional string data = 2;
}
  1. 从 Json 或其它格式数据中转换而来

无论 .proto 文件来源于何处，我们都需要对其做进一步的处理和注册，将其解析成内存对象，并构建其与实例的映射，同时也要计算每个字段的内存偏移。可总结出如下步骤：

  1. 提供 .proto （范指 ProtoBuf Message 语法描述的元信息）
  2. 解析 .proto 构建 FileDescriptor、FieldDescriptor 等，即 .proto 对应的内存模型（对象）
  3. 之后每创建一个实例，就将其存到实例工厂相应的实例池中
  4. 将 Descriptor 和 instance 的映射维护到表中备查
  5. 通过 Descriptor 可查到相应的 instance，又由于了解 instance 中字段类型（FieldDescriptor），所以知道字段的内存偏移，那么就可以访问或修改字段的值

2、调用message的属性和方法

如下是通过字符串type_name调用message的属性和方法的流程图；
Person是自定义的pb类型，继承自Message. MessageLite作为Message基类，更加轻量级一些。
通过Descriptor能获得所需消息的Message* 指针。Message class 定义了 New() 虚函数，用来返回本对象的一份新实体，具体流程如下：

  1. 通过 DescriptorPool 的 FindMessageTypeByName 获得了元信息 Descriptor。
  2. 根据 MessageFactory 实例工厂和Descriptor获得了Message的默认实例Message*指针 default instance
  3. 通过new()构造一个可用的消息对象

2.1根据type name反射自动创建实例

通过字符串"person" 创建新的 person message对象。线程安全

 // 先获得类型的Descriptor .
auto descriptor = google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName("Person");
//利用Descriptor拿到类型注册的instance. 这个是不可修改的.
auto prototype = google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
 // 构造一个可用的消息.
auto instance = prototype->New(); //创建新的 person message对象。

第一步我们通过 DescriptorPool 的 FindMessageTypeByName 获得了元信息 Descriptor。

DescriptorPool 为元信息池，对外提供了诸如 FindServiceByName、 FindMessageTypeByName 等各类接口以便外部查询所需的Service或者Message元信息。当 DescriptorPool 不存在时需要查询的元信息时，将进一步到 DescriptorDatabase 中去查找。 DescriptorDatabase 可从 硬编码或磁盘中查询对应名称的 .proto 文件内容，解析后返回查询需要的元信息。

不难看出，DescriptorPool 和 DescriptorDatabase 通过缓存机制提高了反射运行效率。DescriptorDatabase 从磁盘中读取 .proto 内容并解析成 Descriptor 并不常用，实际上我们在使用 protoc 生成 xxx.pb.cc 和 xxx.pb.h 文件时，其中不仅仅包含了读写数据的接口，还包含了 .proto 文件内容。阅读任意一个 xxx.pb.cc 的内容，你可以看到如下类似代码

static void AddDescriptorsImpl() {
  InitDefaults();

  // .proto 内容
  static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = {
      "\n\022single_int32.proto\"\035\n\010Example1\022\021\n\010int3"
      "2Val\030\232\005 \001(\005\" \n\010Example2\022\024\n\010int32Val\030\377\377\377\377"
      "\001 \003(\005b\006proto3"
  };

  // 注册 descriptor
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
      descriptor, 93);

  // 注册 instance
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
    "single_int32.proto", &protobuf_RegisterTypes);
}

其中 descriptor 数组存储的便是 .proto 内容。这里当然不是简单的存储原始文本字符串，而是经过了 SerializeToString 序列化处理，而后将结果以 硬编码的形式保存在 xxx.pb.cc 中，真是充分利用了自己的高效编码能力。

硬编码的 .proto 元信息内容将以懒加载的方式（被调用时才触发）被 DescriptorDatabase 加载、解析，并 缓存到 DescriptorPool 中。

3、通过实例instance 的反射接口reflection对其pb字段读写

Reflection主要提供了动态读写 message对象字段的接口，对message对象的自动读写主要通过该类完成。

对每种数据类型，Reflection都提供了一个单独的接口（Get、Set）用于读写字段对应的值
例如对 int32、int64的读操作：输入参数为Message和FieldDescriptor*

  virtual int32  GetInt32 (const Message& message,const FieldDescriptor* field) const = 0;
  virtual int64  GetInt64 (const Message& message, const FieldDescriptor* field) const = 0;

特殊的，对于枚举和嵌套的message：

virtual const EnumValueDescriptor* GetEnum( const Message& message, const FieldDescriptor* field) const = 0;
virtual const Message& GetMessage(const Message& message,
                                    const FieldDescriptor* field,
                                    MessageFactory* factory = NULL) const = 0;

对于写操作也是类似的接口，例如SetInt32/SetInt64/SetEnum等

写单个字段的函数如下：

void SetInt32(Message * message, const FieldDescriptor * field, int32 value) const
 
void SetString(Message * message, const FieldDescriptor * field, std::string value) const

获取重复字段的函数如下：

int32 GetRepeatedInt32(const Message & message, const FieldDescriptor * field, int index) const

std::string GetRepeatedString(const Message & message, const FieldDescriptor * field, int index) const

const Message & GetRepeatedMessage(const Message & message, const FieldDescriptor * field, int index) const

获取反射Reflection接口，并且值写入的代码如下：线程安全

auto reflecter = instance.GetReflection();//2.1通过字符串"Person"取得的实例instance
auto field = descriptor->FindFieldByName("name"); // Person这个Message 中有name字段
reflecter->SetString(&instance, field, "小明") ; //反射来设置name字段

反射机制

二、反射 例子

1、serialize_message

serialize_message遍历提取message中所有字段以及对应的值，序列化到string中。主要思路就是：

  1. Descriptor得到每个字段的描述符FieldDescriptor：字段名、字段的cpp类型。
  2. 通过Reflection的GetXXX接口获取对应的value。

类 FieldDescriptor 介绍
类 FieldDescriptor 的作用主要是对 Message 中单个字段进行描述，包括字段名、字段属性、原始的 field 字段等。

其获取获取自身信息的函数：

const std::string & name() const; // Name of this field within the message.
const std::string & lowercase_name() const; // Same as name() except converted to lower-case.
const std::string & camelcase_name() const; // Same as name() except converted to camel-case.
CppType cpp_type() const; //C++ type of this field.

其中cpp_type()函数是来获取该字段是什么类型的，在 protobuf 中，类型的类目如下：

enum FieldDescriptor::Type {
  TYPE_DOUBLE = = 1,
  TYPE_FLOAT = = 2,
  TYPE_INT64 = = 3,
  TYPE_UINT64 = = 4,
  TYPE_INT32 = = 5,
  TYPE_FIXED64 = = 6,
  TYPE_FIXED32 = = 7,
  TYPE_BOOL = = 8,
  TYPE_STRING = = 9,
  TYPE_GROUP = = 10,
  TYPE_MESSAGE = = 11,
  TYPE_BYTES = = 12,
  TYPE_UINT32 = = 13,
  TYPE_ENUM = = 14,
  TYPE_SFIXED32 = = 15,
  TYPE_SFIXED64 = = 16,
  TYPE_SINT32 = = 17,
  TYPE_SINT64 = = 18,
  MAX_TYPE = = 18
}

serialize_message遍历提取message中****所有字段以及对应的值代码如下：

void serialize_message(const google::protobuf::Message& message, std::string* serialized_string) {
    //获取描述Descriptor*和反射Reflection*
    const google::protobuf::Descriptor* descriptor = message.GetDescriptor();
    const google::protobuf::Reflection* reflection = message.GetReflection();
     
    //遍历消息的所有字段  
    for (int i = 0; i < descriptor->field_count(); ++i) {
        // 获得单个字段的描述FieldDescriptor*
        const google::protobuf::FieldDescriptor* field = descriptor->field(i);
        bool has_field = reflection->HasField(message, field);
        
        if (has_field) {
            //arrays not supported
            assert(!field->is_repeated());
            switch (field->cpp_type()) {
            //宏定义 CASE_FIELD_TYPE(cpptype, method, valuetype) 写case
#define CASE_FIELD_TYPE(cpptype, method, valuetype)\
                case google::protobuf::FieldDescriptor::CPPTYPE_##cpptype:{\
                    valuetype value = reflection->Get##method(message, field);\
                    int wsize = field->name().size();\
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));\
                    serialized_string->append(field->name().c_str(), field->name().size());\
                    wsize = sizeof(value);\
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));\
                    serialized_string->append(reinterpret_cast<char*>(&value), sizeof(value));\
                    break;\
                }

                // 利用宏定义 CASE_FIELD_TYPE 写所有简单数据类型的case
                CASE_FIELD_TYPE(INT32, Int32, int);
                CASE_FIELD_TYPE(UINT32, UInt32, uint32_t);
                CASE_FIELD_TYPE(FLOAT, Float, float);
                CASE_FIELD_TYPE(DOUBLE, Double, double);
                CASE_FIELD_TYPE(BOOL, Bool, bool);
                CASE_FIELD_TYPE(INT64, Int64, int64_t);
                CASE_FIELD_TYPE(UINT64, UInt64, uint64_t);
#undef CASE_FIELD_TYPE
                case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
                    int value = reflection->GetEnum(message, field)->number();
                    int wsize = field->name().size();
                    //写入name占用字节数
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    //写入name
                    serialized_string->append(field->name().c_str(), field->name().size());
                    wsize = sizeof(value);
                    //写入value占用字节数
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    //写入value
                    serialized_string->append(reinterpret_cast<char*>(&value), sizeof(value));
                    break;
                }
                case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
                    std::string value = reflection->GetString(message, field);
                    int wsize = field->name().size();
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    serialized_string->append(field->name().c_str(), field->name().size());
                    wsize = value.size();
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    serialized_string->append(value.c_str(), value.size());
                    break;
                }
                //递归 序列化 嵌套Message
                case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: {
                    std::string value;
                    int wsize = field->name().size();
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    serialized_string->append(field->name().c_str(), field->name().size());
                    const google::protobuf::Message& submessage = reflection->GetMessage(message, field);
                    serialize_message(submessage, &value);
                    wsize = value.size();
                    serialized_string->append(reinterpret_cast<char*>(&wsize), sizeof(wsize));
                    serialized_string->append(value.c_str(), value.size());
                    break;
                }
            }
        }
    }
}

2、parse_message

parse_message通过读取field/value，还原message对象。
主要思路跟serialize_message很像，通过Descriptor得到每个字段的描述符FieldDescriptor，通过Reflection的SetX填充message。

void parse_message(const std::string& serialized_string, google::protobuf::Message* message) {
    // 通过传入的Message* 获得 Descriptor* 和Reflection* 
    const google::protobuf::Descriptor* descriptor = message->GetDescriptor();
    const google::protobuf::Reflection* reflection = message->GetReflection();
    // 字段名字 和FieldDescriptor*字段的 映射
    std::map<std::string, const google::protobuf::FieldDescriptor*> field_map;
    
    for (int i = 0; i < descriptor->field_count(); ++i) {
        const google::protobuf::FieldDescriptor* field = descriptor->field(i);
        field_map[field->name()] = field;
    }
    const google::protobuf::FieldDescriptor* field = NULL;
    size_t pos = 0;
    //解析 字符串，填写字段值，
    while (pos < serialized_string.size()) {
        int name_size = *(reinterpret_cast<const int*>(serialized_string.substr(pos, sizeof(int)).c_str()));
        pos += sizeof(int);
        
        std::string name = serialized_string.substr(pos, name_size);
        pos += name_size;
        
        int value_size = *(reinterpret_cast<const int*>(serialized_string.substr(pos, sizeof(int)).c_str()));
        pos += sizeof(int);
   
        std::string value = serialized_string.substr(pos, value_size);
        pos += value_size;
        //通过name 从map中获取FieldDescriptor*
        std::map<std::string, const google::protobuf::FieldDescriptor*>::iterator iter =
            field_map.find(name);
        if (iter == field_map.end()) {
            fprintf(stderr, "no field found.\n");
            continue;
        } else {
            field = iter->second;
        }
        assert(!field->is_repeated());
        switch (field->cpp_type()) {
        // 利用宏定义 CASE_FIELD_TYPE 写所有简单数据类型的case
#define CASE_FIELD_TYPE(cpptype, method, valuetype)\
            case google::protobuf::FieldDescriptor::CPPTYPE_##cpptype: {\
                reflection->Set##method(\
                        message,\
                        field,\
                        *(reinterpret_cast<const valuetype*>(value.c_str())));\
                std::cout << field->name() << "\t" << *(reinterpret_cast<const valuetype*>(value.c_str())) << std::endl;\
                break;\
            }
            CASE_FIELD_TYPE(INT32, Int32, int);
            CASE_FIELD_TYPE(UINT32, UInt32, uint32_t);
            CASE_FIELD_TYPE(FLOAT, Float, float);
            CASE_FIELD_TYPE(DOUBLE, Double, double);
            CASE_FIELD_TYPE(BOOL, Bool, bool);
            CASE_FIELD_TYPE(INT64, Int64, int64_t);
            CASE_FIELD_TYPE(UINT64, UInt64, uint64_t);
#undef CASE_FIELD_TYPE

            case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
                const google::protobuf::EnumValueDescriptor* enum_value_descriptor =
                    field->enum_type()->FindValueByNumber(*(reinterpret_cast<const int*>(value.c_str())));
                reflection->SetEnum(message, field, enum_value_descriptor);
                std::cout << field->name() << "\t" << *(reinterpret_cast<const int*>(value.c_str())) << std::endl;
                break;
            }
            
            case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
                reflection->SetString(message, field, value);
                std::cout << field->name() << "\t" << value << std::endl;
                break;
            }
            //递归解析 嵌套message字符串
            case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: {
                google::protobuf::Message* submessage = reflection->MutableMessage(message, field);
                parse_message(value, submessage);
                break;
            }
            default: {
                break;
            }
        }
    }
}
末日在做什么呢
关注
  • 11
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
protobuf-cpp-3.11.4.rar
10-13
编译过程： mkdir release & cd release cmake -G "NMake Makefiles" -DCMAKE BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=../../../../install ../.. nmake nmake install 博文：【protobuf】win10 C++版编译。见内部install文件夹
protobuf反射详解
大隐隐于野
03-26 3028
本文主要介绍protobuf里的反射功能，使用的pb版本为2.6.1，同时为了简洁，对repeated/extension字段的处理方法没有说明。 最初是起源于这样一个问题： 给定一个pb对象，如何自动遍历该对象的所有字段？ 即是否有一个通用的方法可以遍历任意pb对象的所有字段，而不用关心具体对象类型。 使用场景上有很多： 比如json格式字符串的相互转换，或者bigtable里根据pb对象...
protobuf反射机制接口以及示例
最新发布
h1727370054的博客
02-22 969
明白了，你需要的是关于 Protobuf 字段描述对象（）的接口表格，这些接口提供了关于字段本身的信息。以下是一些关键的 接口：这些接口提供了字段的元数据信息，如字段的名称、类型、是否可选、是否重复等，这些信息对于理解和操作 Protobuf 消息结构至关重要。通过 ，你可以获取关于 Protobuf 消息中单个字段的详细信息。在字段级别，Protobuf 提供了一系列接口来操作各种类型的字段，例如：, : 用于操作 类型的字段。, : 用于操作 类型的字段。, : 用于操作重复字段或消息类型的字段。
protobuf-java-3.1.0.jar
06-07
protobuf-java-3.1.0.jar
google protocol buffer 编码详解（1）
dodobear的小窝窝
05-27 3296
在进行前，需要阅读下基础知识 基本知识：https://developers.google.com/protocol-buffers/docs/encoding 中文译文：http://www.wuzesheng.com/?p=1258 1. 从最简单的开始  message Info {         optional int32 m_iValue = 1; }
Protobuf-Descriptor相关类
热门推荐
Felix/XuWei的博客
06-01 1万+
类Descriptor 描述一种message类型（不是一个单独的message对象）的meta信息。构造函数是private类型，必须通过DescriptorPool（friend类）来构造。 const的成员： const FileDescriptor* file_： 描述message所在的.proto文件信息 const Descriptor* containing_type_...
protobuf反射详解及应用(pb/json相互转换)
mijichui2153的博客
12-25 9175
关于protobuf的使用、编码原理、编码原理应用 可以分别参见以下文章。 Python 操作 protobuf 常见用法 linux环境下protobuf的安装与使用 Protobuf编码规则详解 protobuf编码原理及其在schema格式转换的应用 另外，陈硕大神的 这篇 非常值得参考。 这篇文章主要是介绍下protobuf的发射机制，主要还是加深下自己的印象。 首先解决一个问题，反射是什么？可以干什么用？ 1、反射是什么。给定一个pb对象，如何自动遍历该对象的所有字段？换句话.
ProtoBuf（Google Protocol Buffers）—— 反射原理以及反射具体流程介绍
JMW1407的博客
07-09 5215
ProtoBuf—— 反射原理解析ProtoBuf—— 反射原理1、反射原理1.1、反射机制的背景1.2、定义1.3、反射原理关注的一些问题1.4、反射原理的优势和应用2、ProtoBuf反射原理——获取并改造 元信息2.1 、 .proto 文件2.2 、 反射原理过程2.3 、 反射相关的类和API2.3.1、google::protobuf::Message2.3.2、 google::protobuf::Descriptor2.3.3、 google::protobuf::Reflection2.
Protobuf反射（未完待续3/01）
谢白羽
03-01 441
文章目录零、文章背景一、反射的背景知识(反射消息来修改消息的某些字段)二、反射消息来传输数据需要注意的点1）长度2）类型三、过程（反射消息来传输数据的详细过程）1）根据type name自动创建Message的关键代码2）代码示例3）createMessage()返回的是动态创建的对象的指针，调用方有责任释放它，不然就会使内存泄漏。四、API介绍1）std::string Descriptor::DebugString(); // 将message转化成人可以识别出的string信息 零、文章背景 有些后台
ProtoBuf 反射详解
01-25 1983
Protocol Buffer 简称 ProtoBuf，是用于结构化数据串行化的灵活、高效、自动的方法，又如 XML，不过它更小、更快、也更简单。你可以定义自己的数据结构，然后使用代码生成器生成的代码来读写这个数据结构。你甚至可以在无需重新部署程序的情况下更新数据结构。 本文主要介绍 protobuf 里的反射功能，使用的pb版本为2.6.1，同时为了简洁，对 repeated/extensio...
protobuf 反射使用总结
编程猿来如此
08-03 1172
protobuf 反射使用总结
protobuf-java-3.11.4-API文档-中文版.zip
06-07
赠送jar包：protobuf-java-3.11.4.jar； 赠送原API文档：protobuf-java-3.11.4-javadoc.jar； 赠送源代码：protobuf-java-3.11.4-sources.jar； 赠送Maven依赖信息文件：protobuf-java-3.11.4.pom； 包含翻译后的API...
protobuf-jetbrains插件.rar
08-12
protobuf-jetbrains-plugin-0.13.0
protobuf-java-3.4.0.jar包
06-05
Protocol Buffers（简称protobuf）是谷歌的一项技术，用于将结构化的数据序列化、反序列化，经常用于网络传输。
protobuf -序列化
h2517956473的博客
06-04 1451
文章目录前言序列化成字符串SerializeToString和SerializeAsString区别SerializeToString和SerializePartialToString区别 前言 protobuf有 proto2 和 proto3 两个主要的并且差异很大的版本，所以在使用protobuf前要明确使用的版本。 序列化成字符串 将 message 结构对象序列化的函数有很多，即使是序列化成字符串也有多个函数可以使用，比如SerializeToString，SerializePartialToSt
序列化工具protobuf初解
h2517956473的博客
05-27 372
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例
RPC初解
h2517956473的博客
06-20 185
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、RPC？二、RPC的运行模式2.读入数据总结系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 RPC是分布式的基石，可以将各个业务代码模块隔离开来，快速迭代更改代码。 提示：以下是本篇文章正文内容，下面案例可供参考 一、RPC？ R
优先队列-完全二叉堆实现
h2517956473的博客
09-18 161
class MasPq{ public: MasPq(int _cap):cap(_cap){ q = vector<int>(cap+1,0); }; int top(){ return q[1];} void pop(){ swap(q[1],q[n]); n--; sink(1); return ; } void swim(int k){ int
protobuf-maven-plugin使用
12-07
protobuf-maven-plugin是一个Maven插件，用于将Protocol Buffers文件编译为Java类。以下是protobuf-maven-plugin的使用方法： 1.在pom.xml文件中添加以下插件配置： ```xml <build> <plugins> <plugin> <groupId>org.xolstice.maven.plugins</groupId> <artifactId>protobuf-maven-plugin</artifactId> <version>0.6.1</version> <configuration> <protocExecutable>/usr/local/bin/protoc</protocExecutable> </configuration> <executions> <execution> <goals> <goal>compile</goal> <goal>compile-custom</goal> <goal>test-compile</goal> <goal>test-compile-custom</goal> </goals> </execution> </executions> </plugin> </plugins> </build> ``` 2.在src/main/proto目录下创建.proto文件，例如： ```protobuf syntax = "proto3"; package com.example; message Person { string name = 1; int32 age = 2; } ``` 3.运行以下命令编译.proto文件： ```shell mvn protobuf:compile ``` 4.编译后的Java类将生成在target/generated-sources/protobuf/java目录下。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值