google protobuf 反射的例子

最新推荐文章于 2022-11-07 11:51:08 发布
最新推荐文章于 2022-11-07 11:51:08 发布
阅读量393 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxm342698145/article/details/83931027
版权

反射就是可以知道一个对象自身的数据属性，例如有哪些字段，字段的值，函数等等。
下面的代码展示了protobuf 对象反射的例子。将一个对象按照反射的字段顺序序列化到string，然后反序列化到对象。最后调用反射打印其字段值，可以看到对象能够还原。

proto文件为（暂时不支持数组）：

package tutorial;

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
  }

  optional PhoneNumber phone = 4;
  
}

 

#include <string>
#include <map>
#include <iostream>
#include <stdio.h>
#include "person.pb.h"
using namespace tutorial;
using namespace google::protobuf;
using std::cout;
using std::endl;
using std::string;


void serialize_message(const Message& message, std::string* serialized_string) {
    const Descriptor* descriptor = message.GetDescriptor();
    const Reflection* reflection = message.GetReflection();

    for (int i = 0; i < descriptor->field_count(); ++i) {
        const 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()) {
#define CASE_FIELD_TYPE(cpptype, method, valuetype)\
                case 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(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 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 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;
                }
                case 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 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;
                }
            }
        }
    }
}

void parse_message(const string& serialized_string, Message* message) {
    const Descriptor* descriptor = message->GetDescriptor();
    const Reflection* reflection = message->GetReflection();
    map<string, const FieldDescriptor*> field_map;

    for (int i = 0; i < descriptor->field_count(); ++i) {
        const FieldDescriptor* field = descriptor->field(i);
        field_map[field->name()] = field;
    }

    const 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);
        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);
        string value = serialized_string.substr(pos, value_size);
        pos += value_size;

        map<string, const 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()) {
#define CASE_FIELD_TYPE(cpptype, method, valuetype)\
            case FieldDescriptor::CPPTYPE_##cpptype: {\
                reflection->Set##method(\
                        message,\
                        field,\
                        *(reinterpret_cast<const valuetype*>(value.c_str())));\
                cout << field->name() << "\t" << *(reinterpret_cast<const valuetype*>(value.c_str())) << 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 FieldDescriptor::CPPTYPE_ENUM: {
                const EnumValueDescriptor* enum_value_descriptor =
                    field->enum_type()->FindValueByNumber(*(reinterpret_cast<const int*>(value.c_str())));
                reflection->SetEnum(message, field, enum_value_descriptor);
                cout << field->name() << "\t" << *(reinterpret_cast<const int*>(value.c_str())) << endl;
                break;
            }
            case FieldDescriptor::CPPTYPE_STRING: {
                reflection->SetString(message, field, value);
                cout << field->name() << "\t" << value << endl;
                break;
            }
            case FieldDescriptor::CPPTYPE_MESSAGE: {
                Message* submessage = reflection->MutableMessage(message, field);
                parse_message(value, submessage);
                break;
            }
            default: {
                break;
            }
        }
    }
}


void print_field(const Message& message)
{
    const Descriptor* descriptor = message.GetDescriptor();
    const Reflection* reflection = message.GetReflection();

    for (int i = 0; i < descriptor->field_count(); ++i) {
        const FieldDescriptor* field = descriptor->field(i);
        bool has_field = reflection->HasField(message, field);
        assert(!field->is_repeated());
            
        switch (field->cpp_type()) {
#define CASE_FIELD_TYPE(cpptype, method, valuetype)\
            case FieldDescriptor::CPPTYPE_##cpptype:{\
                valuetype value = reflection->Get##method(message, field);\
                if (has_field) {\
                    cout << field->name() << " : " << value << ", type : " << #valuetype << "\n";\
                }  else  {\
                    cout << field->name() << " : " << "None" << ", type : " << #valuetype << "\n";\
                }\
                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 FieldDescriptor::CPPTYPE_ENUM: {
                int value = reflection->GetEnum(message, field)->number();
                if (has_field)  {
                    cout << field->name() << " : " << value << ", type : " << "enum \n";    
                }
                else  {
                    cout << field->name() << " : " << "None" << ", type : " << "enum \n";
                }
                break;
            }
            case FieldDescriptor::CPPTYPE_STRING: {
                string value = reflection->GetString(message, field);
                if (has_field)  {
                    cout << field->name() << " : " << value << ", type : " << "string \n";  
                }
                else  {
                    cout << field->name() << " : " << "None" << ", type : " << "string \n";
                }
                
                break;
            }
            case FieldDescriptor::CPPTYPE_MESSAGE: {
                const Message& submessage = reflection->GetMessage(message, field);
                print_field(submessage);
                break;
            }
        }
    }
}



int main() 
{
    string str;
	Person person;
	person.set_name("shonm");
	person.set_id(123);
	person.mutable_phone()->set_number("1380000");
	person.mutable_phone()->set_type(Person_PhoneType_WORK);
	serialize_message(person, &str);       //按照自己的方式(反射的字段)序列化

	Person person2;
	parse_message(str, &person2);          //按照自己的方式反序列化
	printf("\n\n");
	print_field(person);                   //根据反射打印字段
	
	printf("\n\n");
	print_field(person2);
}

参考：

 https://izualzhy.cn/protobuf-message-reflection

Shonm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
google protobuf 消息反射
Only Me
03-02 882
Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，他们用于 RPC 系统和持续数据存储系统。 Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式，...
Google Protobuf自动反射功能
chenglinhust的专栏
08-15 4788
Google Protobuf自动反射功能
基于protobuf反射特性的pb、json相互转换的实例程序(C++)
10-21
关于protobuf的反射特性可以参照这篇文章 https://blog.csdn.net/mijichui2153/article/details/111665192。 本资源提供了一个基于protobuf反射特性的pb结构与json相互转换的实例，该实例程序主要有两个核心函数myMessage2Json、myJson2Message。前者的作用是将pb结构转换成对应的json，后者是将json转换成对应的pb结构体。代码中也对关键处理步骤进行了注释说明，相信有了这个实例后json、pb相互转换对你来说将变得一目了然。 使用过程如果有问题可以私信博主，我看到后会第一时间解答。
protobuf反射详解
大隐隐于野
03-26 3103
本文主要介绍protobuf里的反射功能，使用的pb版本为2.6.1，同时为了简洁，对repeated/extension字段的处理方法没有说明。 最初是起源于这样一个问题： 给定一个pb对象，如何自动遍历该对象的所有字段？ 即是否有一个通用的方法可以遍历任意pb对象的所有字段，而不用关心具体对象类型。 使用场景上有很多： 比如json格式字符串的相互转换，或者bigtable里根据pb对象...
C#使用ProtoBuf
robinfoxnan的专栏
08-15 8240
1. Google ProtoBuf 经过测试，protobuf比json存储效率还是要高，即时号称最快的fastjson也没有protobuf快，这里为了使用 c#做一个客户端兼容，所以也需要使用protobuf。 2.准备工作 Visual Studio 2017 NuGet安装:Google.Protobuf、Google.Protobuf.Tools 根据协议设计并编写.proto文件 3. 使用步骤 3.1 安装Google.Protobuf和Google.Protobuf.Tools.
c#使用protobuf
GameRoad
05-21 1355
转自：https://www.cnblogs.com/Leo_wl/p/7126321.html#_labelTopgithub上相关开源项目代码：http://pan.baidu.com/s/1eSDSb5o下面演示如何将protobuf的消息体导出成C#支持的.cs类首先我们获取到如下.proto文件package hrv; option java_package = "com.******...
Protobuf的自动反射消息类型的方法
weixin_34234829的博客
02-09 326
1. 每个消息头部中带上type name，作为消息的类型标识 2. 通过type name可以找到描述符Descriptor*, FindMessageTypeByName 3. 通过描述符Descriptor*，创建一个对应type name的对象，再用消息的payload去初始化这个消息对象 4. 具现化instantiation每个对应消息的Callback，放入map中，键值就可以...
protobuf 测试例子
03-25
protobuf，全称Protocol Buffers，是Google开发的一种数据序列化协议。它允许开发者定义数据结构，然后生成能够读写这些结构的代码，适用于多种编程语言，包括C++、Java、Python等。在“protobuf 测试例子”中，我们...
google protobuf
05-14
protobuf是Google开发的一种高效、灵活的数据序列化协议，它允许开发者定义数据结构，然后将这些数据结构序列化为二进制格式，以便在网络之间或在内存中存储和传输。protobuf的全称是Protocol Buffers，它是一种语言...
protobuf例子
05-02
标题中的"protobuf例子"指的是Google开发的一种数据序列化协议缓冲区（Protocol Buffers）的示例。Protocol Buffers是一种高效、灵活且易于使用的结构化数据序列化方法，类似于XML、JSON，但更小、更快、更简单。它...
Windows环境使用google protobuf实现简单的例子
10-14
标题中的“Windows环境使用google protobuf实现简单的例子”指的是在Windows操作系统下，利用Visual Studio (VS) 2010开发环境，结合Google的Protocol Buffers（protobuf）版本2.5.0进行简单应用的教程。protobuf是...
将mysql中查询出来的数据 序列化到protobuffer消息结构体中
boshuzhang的专栏
09-17 1740
void CDBTable::fillMessageField(Gmessage &message,  MSW::CStoreResult *result ) { BOMB_IF(result==NULL, "result null", return); const Reflection * reflection = message.GetReflection(); const Descr
protobuf实战操作
不负韶华梦为马
11-02 1598
 lua调用C/C++函数发送数据 主要操作函数是lua_table_to_protobuf， static google::protobuf::Message* lua_table_to_protobuf(lua_State* L, int stackIdx, const char* msg_name){ if (!lua_istable(L, stackIdx)){ return ...
遍历protobuf数据结构
weixin_50106433的博客
11-07 913
遍历protobuf数据结构
protobuf反射详解及应用(pb/json相互转换)
热门推荐
mijichui2153的博客
12-25 1万+
关于protobuf的使用、编码原理、编码原理应用 可以分别参见以下文章。 Python 操作 protobuf 常见用法 linux环境下protobuf的安装与使用 Protobuf编码规则详解 protobuf编码原理及其在schema格式转换的应用 另外，陈硕大神的 这篇 非常值得参考。 这篇文章主要是介绍下protobuf的发射机制，主要还是加深下自己的印象。 首先解决一个问题，反射是什么？可以干什么用？ 1、反射是什么。给定一个pb对象，如何自动遍历该对象的所有字段？换句话.
ProtoBuf（Google Protocol Buffers）—— 反射原理以及反射具体流程介绍
JMW1407的博客
07-09 5910
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 反射来优化代码，拒做 PB Boy
腾讯技术工程
11-26 2381
作者：iversonluo，腾讯 WXG 应用开发工程师有些后台同学将自己称为 SQL Boy，因为负责的业务主要是对数据库进行增删改查。经常和 Proto 打交道的同学，是不是也会叫自...
protobuf 反射
最新发布
09-30
ProtoBuf反射是指通过反射机制来获取并修改ProtoBuf消息的元信息。ProtoBuf中的反射原理主要涉及以下几个方面： 1. 反射机制的背景：ProtoBuf使用反射机制来实现动态操作消息，即在不知道消息结构的情况下仍然能够对其进行操作。 2. 反射相关的类和API：ProtoBuf提供了一系列的反射相关类和API，包括google::protobuf::Message、google::protobuf::Descriptor、google::protobuf::Reflection和google::protobuf::FieldDescriptor等。 3. 反射原理过程具体解析：ProtoBuf的反射原理过程主要包括获取元信息、创建和获取实例（查表）以及实例对象的读写等步骤。 4. 反射原理具体实例介绍：ProtoBuf的反射原理具体应用在实例对象的操作中，可以通过反射机制来获取和修改消息的字段值。 参考资料中提到了获取反射对象的代码示例，可以通过message->GetReflection()或message.GetReflection()来获取google::protobuf::Reflection对象，从而进行消息的反射操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值