protobuf 反射及应用

最新推荐文章于 2025-02-15 00:15:00 发布
最新推荐文章于 2025-02-15 00:15:00 发布
阅读量682 收藏 2
点赞数
分类专栏： c++ 后端开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39384184/article/details/118489772
版权

protobuf 反射构建 Message

Message* createMessage(const std::string& typeName)
{
  Message* message = NULL;
  const Descriptor* descriptor = DescriptorPool::generated_pool()->FindMessageTypeByName(typeName);
  if (descriptor)
  {
    const Message* prototype = MessageFactory::generated_factory()->GetPrototype(descriptor);
    if (prototype)
    {
      message = prototype->New();
    }
  }
  return message;
}

protobuf 动态加载 proto 文件

protobuf 的 proto 文件都是使用懒加载的，如果需要热加载，可以使用如下代码：

#include <google/protobuf/compiler/importer.h>
#include <google/protobuf/dynamic_message.h>

using namespace std;
using namespace ::google::protobuf;

class ErrorCollector : public compiler::MultiFileErrorCollector {
    virtual void AddError(const std::string &filename, int line, int column, const std::string &message) {
        // define import error collector
        printf("%s, %d, %d, %s\n", filename.c_str(), line, column, message.c_str());
    }
};

	compiler::DiskSourceTree sourceTree; // proto 根目录映射
    std::map<std::string, std::string> mapPathList = { // 运行目录 -> 磁盘目录
            {"", "proto"}
    };
    for (auto &path : mapPathList) {
        std::cout << "map from " << path.first << " to " << path.second << std::endl;
        sourceTree.MapPath(path.first, path.second);
    }
    compiler::Importer importer(&sourceTree, new ErrorCollector());// 加载 proto 文件
    importer.Import(FLAGS_proto_name);
    const DescriptorPool *descriptor_pool = importer.pool();// proto 文件描述符
    const DynamicMessageFactory *message_factory = new google::protobuf::DynamicMessageFactory(importer.pool()); // proto 构造器

protobuf channel 动态调用 service

  1. ::google::protobuf::RpcChannel 使用 ip 和 port 构建 channel
  2. ::google::protobuf::RpcController 接收返回的控制信息
  3. 动态构建 req 和 resp 的 message
  4. 获取 service 的 method 描述符
  5. Closure = nullptr
  virtual void CallMethod(const MethodDescriptor* method,
                          RpcController* controller, const Message* request,
                          Message* response, Closure* done) = 0;

Message 和 Json::Value 互转

using namespace std;
using namespace google::protobuf;
 
using ProtobufMsg = ::google::protobuf::Message;
using ProtobufReflection = ::google::protobuf::Reflection;
using ProtobufFieldDescriptor = ::google::protobuf::FieldDescriptor;
using ProtobufDescriptor = ::google::protobuf::Descriptor;
 
void myMessage2Json(const ProtobufMsg& message, Json::Value& json, bool enum2str = false);
void myRepeatedMessage2Json(const ProtobufMsg& message, const ProtobufFieldDescriptor* field,const ProtobufReflection* reflection, Json::Value& json, bool enum2str);
 
bool myJson2Message(const Json::Value& json, ProtobufMsg& message, bool str2enum = false);
bool myJson2RepeatedMessage(const Json::Value& json, ProtobufMsg& message, const ProtobufFieldDescriptor* field,const ProtobufReflection* reflection, bool str2enum);
 
bool myJson2Message(const Json::Value& json, ProtobufMsg& message, bool str2enum) {
    auto descriptor = message.GetDescriptor();
    auto reflection = message.GetReflection();
    if (nullptr == descriptor || nullptr == reflection) return false;
    //取出字段数并遍历每个字段
    auto count = descriptor->field_count();
    for (auto i = 0; i < count; ++i) {
        const auto field = descriptor->field(i);
        if (nullptr == field) continue;
        if (!json.isMember(field->name())) continue;
        //如果json中有这个字段，就取出来
        auto& value = json[field->name()];
        if (value.isNull()) continue;
        //如果字段是rpt的，而且json中取到的value也是array就调用 Json2RepeatedMessage 逻辑
        if (field->is_repeated()) {
            if (!value.isArray()) {
                return false;
            } else {
                myJson2RepeatedMessage(value, message, field, reflection, str2enum);
                continue;
            }
        }
        //然后就是根据字段类型进行分别处理了
        switch (field->type()) {
            case ProtobufFieldDescriptor::TYPE_BOOL: {
                if (value.isBool())
                    reflection->SetBool(&message, field, value.asBool());
                else if (value.isIntegral())
                    reflection->SetBool(&message, field, value.asBool());
                else if (value.isString()) {
                    if (value.asString() == "true")
                        reflection->SetBool(&message, field, true);
                    else if (value.asString() == "false")
                        reflection->SetBool(&message, field, false);
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_ENUM: {
                auto const* pedesc = field->enum_type();
                const ::google::protobuf::EnumValueDescriptor* pevdesc = nullptr;
 
                if (str2enum) {
                    pevdesc = pedesc->FindValueByName(value.asString());
                } else {
                    pevdesc = pedesc->FindValueByNumber(value.asInt());
                }
 
                if (nullptr != pevdesc) {
                    reflection->SetEnum(&message, field, pevdesc);
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT32:
            case ProtobufFieldDescriptor::TYPE_SINT32:
            case ProtobufFieldDescriptor::TYPE_SFIXED32: {
                if (value.isInt()) reflection->SetInt32(&message, field, value.asInt());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_UINT32:
            case ProtobufFieldDescriptor::TYPE_FIXED32: {
                if (value.isInt()) reflection->SetUInt32(&message, field, value.asUInt());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT64:
            case ProtobufFieldDescriptor::TYPE_SINT64:
            case ProtobufFieldDescriptor::TYPE_SFIXED64: {
                if (value.isInt64()) reflection->SetInt64(&message, field, value.asInt64());
            } break;
            case ProtobufFieldDescriptor::TYPE_UINT64:
            case ProtobufFieldDescriptor::TYPE_FIXED64: {
                if (value.isInt64()) reflection->SetUInt64(&message, field, value.asUInt64());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_FLOAT: {
                if (value.isNumeric()) reflection->SetFloat(&message, field, value.asFloat());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_DOUBLE: {
                if (value.isDouble()) reflection->SetDouble(&message, field, value.asDouble());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_STRING:
            case ProtobufFieldDescriptor::TYPE_BYTES: {
                if (value.isString()) reflection->SetString(&message, field, value.asString());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_MESSAGE: {
                if (value.isObject()) myJson2Message(value, *reflection->MutableMessage(&message, field));
            } break;
 
            default:
                break;
        }
    }
    return true;
}
 
bool myJson2RepeatedMessage(const Json::Value& json, ProtobufMsg& message, const ProtobufFieldDescriptor* field,
                                   const ProtobufReflection* reflection, bool str2enum) {
    int count = json.size();
    //对json数组里面的每个元素进行处理
    for (auto j = 0; j < count; ++j) {
        //根据元素的数据类型进行switch
        switch (field->type()) {
            case ProtobufFieldDescriptor::TYPE_BOOL: {
                if (json[j].isBool())
                    reflection->AddBool(&message, field, json[j].asBool());
                else if (json[j].isUInt())
                    reflection->AddBool(&message, field, json[j].asBool());
                else if (json[j].isString()) {
                    if (json[j] == "true")
                        reflection->AddBool(&message, field, true);
                    else if (json[j] == "false")
                        reflection->AddBool(&message, field, false);
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_ENUM: {
                auto const* pedesc = field->enum_type();
                const ::google::protobuf::EnumValueDescriptor* pevdesc = nullptr;
                if (str2enum) {
                    pevdesc = pedesc->FindValueByName(json[j].asString());
 
                } else {
                    pevdesc = pedesc->FindValueByNumber(json[j].asInt());
                }
                if (nullptr != pevdesc) {
                    reflection->AddEnum(&message, field, pevdesc);
                }
 
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT32:
            case ProtobufFieldDescriptor::TYPE_SINT32:
            case ProtobufFieldDescriptor::TYPE_SFIXED32: {
                if (json[j].isNumeric()) reflection->AddInt32(&message, field, json[j].asInt());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_UINT32:
            case ProtobufFieldDescriptor::TYPE_FIXED32: {
                if (json[j].isNumeric()) reflection->AddUInt32(&message, field, json[j].asUInt());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT64:
            case ProtobufFieldDescriptor::TYPE_SINT64:
            case ProtobufFieldDescriptor::TYPE_SFIXED64: {
                if (json[j].isNumeric()) reflection->AddInt64(&message, field, json[j].asInt64());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_UINT64:
            case ProtobufFieldDescriptor::TYPE_FIXED64: {
                if (json[j].isNumeric()) reflection->AddUInt64(&message, field, json[j].asUInt64());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_FLOAT: {
                if (json[j].isNumeric()) reflection->AddFloat(&message, field, json[j].asFloat());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_DOUBLE: {
                if (json[j].isNumeric()) reflection->AddDouble(&message, field, json[j].asDouble());
            } break;
 
            case ProtobufFieldDescriptor::TYPE_MESSAGE: {
                if (json[j].isObject()) myJson2Message(json[j], *reflection->AddMessage(&message, field));
            } break;
 
            case ProtobufFieldDescriptor::TYPE_STRING:
            case ProtobufFieldDescriptor::TYPE_BYTES: {
                if (json[j].isString()) reflection->AddString(&message, field, json[j].asString());
            } break;
 
            default:
                break;
        }
    }
    return true;
}
 
void myMessage2Json(const ProtobufMsg& message, Json::Value& json, bool enum2str) {
	//cout << "enter myMessage2Json" << endl;
    auto descriptor = message.GetDescriptor();
    auto reflection = message.GetReflection();
    if (nullptr == descriptor || nullptr == descriptor) return;
 
    auto count = descriptor->field_count();
    //cout << "count is " << count << endl;
    for (auto i = 0; i < count; ++i) {
        const auto field = descriptor->field(i);
        //cout << "field name is " << field->name();
        //cout << ";  filed type is " << field->type();
        //cout << ";  is_repeated " << field->is_repeated() << endl;
 
        if (field->is_repeated()) {
            if (reflection->FieldSize(message, field) > 0)
                myRepeatedMessage2Json(message, field, reflection, json[field->name()], enum2str);
 
            continue;
        }
 
        if (!reflection->HasField(message, field)) {
            continue;
        }
 
        switch (field->type()) {
            case ProtobufFieldDescriptor::TYPE_MESSAGE: {
                const ProtobufMsg& tmp_message = reflection->GetMessage(message, field);
                if (0 != tmp_message.ByteSize()) myMessage2Json(tmp_message, json[field->name()]);
            } break;
 
            case ProtobufFieldDescriptor::TYPE_BOOL:
                json[field->name()] = reflection->GetBool(message, field) ? true : false;
                break;
 
            case ProtobufFieldDescriptor::TYPE_ENUM: {
                auto* enum_value_desc = reflection->GetEnum(message, field);
                if (enum2str) {
                    json[field->name()] = enum_value_desc->name();
                } else {
                    json[field->name()] = enum_value_desc->number();
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT32:
            case ProtobufFieldDescriptor::TYPE_SINT32:
            case ProtobufFieldDescriptor::TYPE_SFIXED32:
                json[field->name()] = reflection->GetInt32(message, field);
                break;
 
            case ProtobufFieldDescriptor::TYPE_UINT32:
            case ProtobufFieldDescriptor::TYPE_FIXED32:
                json[field->name()] = reflection->GetUInt32(message, field);
                break;
 
            case ProtobufFieldDescriptor::TYPE_INT64:
            case ProtobufFieldDescriptor::TYPE_SINT64:
            case ProtobufFieldDescriptor::TYPE_SFIXED64:
                json[field->name()] = (Json::Value::Int64)reflection->GetInt64(message, field);
                break;
 
            case ProtobufFieldDescriptor::TYPE_UINT64:
            case ProtobufFieldDescriptor::TYPE_FIXED64:
                json[field->name()] = (Json::Value::UInt64)reflection->GetUInt64(message, field);
                break;
 
            case ProtobufFieldDescriptor::TYPE_FLOAT:
                json[field->name()] = reflection->GetFloat(message, field);
                break;
 
            case ProtobufFieldDescriptor::TYPE_STRING:
            case ProtobufFieldDescriptor::TYPE_BYTES:
                json[field->name()] = reflection->GetString(message, field);
                break;
 
            default:
                break;
        }
    }
}
 
void myRepeatedMessage2Json(const ProtobufMsg& message, const ProtobufFieldDescriptor* field,
                                   const ProtobufReflection* reflection, Json::Value& json, bool enum2str) {
    if (nullptr == field || nullptr == reflection) {
        myMessage2Json(message, json);
    }
 
    for (auto i = 0; i < reflection->FieldSize(message, field); ++i) {
    	//这个地方应该是处理数组
        Json::Value tmp_json;
        switch (field->type()) {
            case ProtobufFieldDescriptor::TYPE_MESSAGE: {
                const ProtobufMsg& tmp_message = reflection->GetRepeatedMessage(message, field, i);
                if (0 != tmp_message.ByteSize()) {
                    myMessage2Json(tmp_message, tmp_json);
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_BOOL:
                tmp_json = reflection->GetRepeatedBool(message, field, i) ? true : false;
                break;
 
            case ProtobufFieldDescriptor::TYPE_ENUM: {
                auto* enum_value_desc = reflection->GetRepeatedEnum(message, field, i);
                if (enum2str) {
                    tmp_json = enum_value_desc->name();
                } else {
                    tmp_json = enum_value_desc->number();
                }
            } break;
 
            case ProtobufFieldDescriptor::TYPE_INT32:
            case ProtobufFieldDescriptor::TYPE_SINT32:
            case ProtobufFieldDescriptor::TYPE_SFIXED32:
                tmp_json = reflection->GetRepeatedInt32(message, field, i);
                break;
 
            case ProtobufFieldDescriptor::TYPE_UINT32:
            case ProtobufFieldDescriptor::TYPE_FIXED32:
                tmp_json = reflection->GetRepeatedUInt32(message, field, i);
                break;
 
            case ProtobufFieldDescriptor::TYPE_INT64:
            case ProtobufFieldDescriptor::TYPE_SINT64:
            case ProtobufFieldDescriptor::TYPE_SFIXED64:
                tmp_json = (Json::Value::Int64)reflection->GetRepeatedInt64(message, field, i);
                break;
 
            case ProtobufFieldDescriptor::TYPE_UINT64:
            case ProtobufFieldDescriptor::TYPE_FIXED64:
                tmp_json = (Json::Value::UInt64)reflection->GetRepeatedUInt64(message, field, i);
                break;
 
            case ProtobufFieldDescriptor::TYPE_FLOAT:
                tmp_json = reflection->GetRepeatedFloat(message, field, i);
                break;
 
            case ProtobufFieldDescriptor::TYPE_STRING:
            case ProtobufFieldDescriptor::TYPE_BYTES:
                tmp_json = reflection->GetRepeatedString(message, field, i);
                break;
 
            default:
                break;
        }
        json.append(tmp_json);
    }
}
ProtoBuf 反射详解
01-25 2129
Protocol Buffer 简称 ProtoBuf，是用于结构化数据串行化的灵活、高效、自动的方法，又如 XML，不过它更小、更快、也更简单。你可以定义自己的数据结构，然后使用代码生成器生成的代码来读写这个数据结构。你甚至可以在无需重新部署程序的情况下更新数据结构。 本文主要介绍 protobuf 里的反射功能，使用的pb版本为2.6.1，同时为了简洁，对 repeated/extensio...
ProtoBuf-反射原理与使用
h2517956473的博客
05-30 4134
文章目录前言相关应用场景一、ProtoBuf 反射原理概述1、获取message和service的属性和方法1.1 使用protoc将proto文件生成.h和.cc文件1.2 只使用proto文件，不使用protoc进行编译1.3 非 .proto 文件 ，转换成.proto2、调用message的属性和方法2.1根据type name反射自动创建实例3、通过实例instance 的反射接口reflection对其pb字段读写获取反射Reflection接口，并且**值写入**的代码如下：线程安全二、反射.
protobuf反射
liu0808的专栏
11-19 171
java https://stackoverflow.com/questions/51981456/convert-json-to-dynamically-generated-protobuf-in-java
C++：Protobuf 动态加载 .pb 文件并发送 Message（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
02-15 596
通过本项目，我们实现了动态加载 Protobuf .pb 文件并发送消息。通过使用 Protobuf 的反射机制和 DynamicMessageFactory，我们能够根据运行时的 .proto 文件生成消息对象，设置消息字段，进行序列化，并将消息发送。
Protobuf反射（未完待续3/01）
谢白羽
03-01 573
文章目录零、文章背景一、反射的背景知识(反射消息来修改消息的某些字段)二、反射消息来传输数据需要注意的点1）长度2）类型三、过程（反射消息来传输数据的详细过程）1）根据type name自动创建Message的关键代码2）代码示例3）createMessage()返回的是动态创建的对象的指针，调用方有责任释放它，不然就会使内存泄漏。四、API介绍1）std::string Descriptor::DebugString(); // 将message转化成人可以识别出的string信息 零、文章背景 有些后台
基于Lua内置模块的Protobuf反射与数据结构转换设计源码
01-03
基于Lua内置模块的Protobuf反射与数据结构转换设计源码项目，提供了一个功能强大、跨平台兼容、易用性高的数据处理工具。它的出现，不仅丰富了Protobuf的数据处理手段，也为多种语言间的高效交互提供了新的可能，...
protobuf反射的使用说明，附完整示例代码
01-15
**protobuf反射机制详解及实战应用** protobuf（Protocol Buffers）是Google开发的一种数据序列化协议，它能够将结构化的数据序列化，可用于网络通信、数据存储等场景。protobuf的优势在于其高效、小巧且跨平台，...
golang 微服务之gRPC与Protobuf的使用
09-17
gRPC与Protobuf是现代微服务架构中常用的技术栈，尤其在Golang开发中占据着重要地位。本文将深入探讨这两个概念以及它们在实际应用中的优势。 首先，RPC（Remote Procedure Call）是一种让程序可以在分布式环境中像...
protobuf 反射
09-30
ProtoBuf反射是指通过反射机制来获取并修改ProtoBuf消息的元信息。ProtoBuf中的反射原理主要涉及以下几个方面： 1. 反射机制的背景：ProtoBuf使用反射机制来实现动态操作消息，即在不知道消息结构的情况下仍然能够...
protobuf反射详解及应用(pb/json相互转换)
热门推荐
mijichui2153的博客
12-25 1万+
关于protobuf的使用、编码原理、编码原理应用 可以分别参见以下文章。 Python 操作 protobuf 常见用法 linux环境下protobuf的安装与使用 Protobuf编码规则详解 protobuf编码原理及其在schema格式转换的应用 另外，陈硕大神的 这篇 非常值得参考。 这篇文章主要是介绍下protobuf的发射机制，主要还是加深下自己的印象。 首先解决一个问题，反射是什么？可以干什么用？ 1、反射是什么。给定一个pb对象，如何自动遍历该对象的所有字段？换句话.
protobuf反射详解
大隐隐于野
03-26 3218
本文主要介绍protobuf里的反射功能，使用的pb版本为2.6.1，同时为了简洁，对repeated/extension字段的处理方法没有说明。 最初是起源于这样一个问题： 给定一个pb对象，如何自动遍历该对象的所有字段？ 即是否有一个通用的方法可以遍历任意pb对象的所有字段，而不用关心具体对象类型。 使用场景上有很多： 比如json格式字符串的相互转换，或者bigtable里根据pb对象...
protobuf 的自反射机制
JunGamer的专栏
12-29 1020
1月1日完成
ProtoBuf（Google Protocol Buffers）—— 反射原理以及反射具体流程介绍
JMW1407的博客
07-09 7060
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-Reflection类
Felix/XuWei的博客
06-01 3660
类Reflection 接口类，提供方法来动态访问/修改message中的field的接口类。调用Message::GetReflection()获得messge对应的reflection。 这个类没有放到Message类中，是从效率角度考虑的。因为绝大多数message的实现共用同一套Reflection（GeneratedMessageReflection），并且一个Message所有的o...
ProtoBuf 中的反射机制
花括号的博客
03-17 3457
我们先看一下JAVA反射的概念： 主要是指程序可以访问，检测和修改它本身状态或行为的一种能力，并能根据自身行为的状态和结果，调整或修改应用所描述行为的状态和相关的语义。 反射是Java中一种强大的工具，能够使我们很方便的创建灵活的代码，这些代码可以再运行时装配，无需在组件之间进行源代码链接。但是反射使用不当会成本很高！ 说的很学术，看的也有点晕。 说白了就是，在运行时根据类的名字(字符串
protobuf的反射机制
weixin_30699463的博客
08-16 319
反射机制 java在运行状态时，能够知道任意类的所有属性和方法，都能够调用任意对象的任意方法和属性。这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。 C++本身没有反射机制。protobuf通过proto文件生成相应的message和service，protobuf也通过proto文件提供反射机制，程序在运行时可以通过proto获取任意message和任意servic...
google protobuf 消息反射
Only Me
03-02 969
Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，他们用于 RPC 系统和持续数据存储系统。 Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值