Protobuf反射详解

所谓反射机制,就是能够在运行时知道任意类的所有属性和方法,能够调用任意对象的任意方法和属性。这种动态获取的信息以及动态调用对象方向的功能称为反射机制。

不像Jave等语言,C++本身没有反射机制,在使用C++版本Protobuf时,protobuf通过proto文件产生响应的message和service,protobuf可以通过proto文件提供反射机制,程序在运行时可以通过proto获取任意message和任意service的属性和方法,也可以在运行时调用message的属性和方法。

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、名称等

也就是说,如果能够获取到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);
}

2. 调用message的属性和方法

首先获取message的对象:

const Message* prototype = MessageFactory::generated_factory()->GetPrototype(descriptor);
if(!prototype){
    continue;
}
Message *message = prototype->New();

有了message对象,因为所有的message都是Message* 类型的,但不同的message对象的属相和方法是不一样的,所以并不能直接调用其对象和方法。

protobuf是通过Reflection来调用message的属性和方法的。message中的方法只有对各个属性的get和set,而调用message的属性其实也就是调用属性的get。调用message的某一个属性的get和set,就需要该属性的Descriptor,通过Reflection将相应的值写入到message对应的属性:

const FieldDescriptor * field_descriptor = message_descriptor->field(i);
if(field_descriptor->type() == FieldDescriptor::TYPE_INT32){
    reflection->SetInt32(message, field_descriptor, 0);
}

3.Protobuf反射使用案例

这部分主要是重复上两节的内容,进行完整示例。以下是使用的test.proto文件

package T;
message Test
{
    optional int32 id = 1;
}

3.1通过类型名字创建出类型对象

预编译好proto模式

//! 利用类型名字构造对象.
/*!
 * @Param type_name 类型名字,比如 "Test.TestMessage".
 * @Return 对象指针,new 出来的,使用者负责释放.
 */
#include <google/protobuf/descriptor.h>
#include <google/protobuf/message.h>
#include "cpp/test.pb.h" // 这是protoc给你生成的文件

int main()
{
    // 先获得类型的Descriptor .
    auto descriptor = google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName("T.Test");
    if (nullptr == descriptor)
    {
        return 0 ;
    }
    // 利用Descriptor拿到类型注册的instance. 这个是不可修改的.
    auto prototype = google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
    if ( nullptr == descriptor)
    {
        return 0 ;
    }
    // 构造一个可用的消息.
    auto message = prototype->New();
    // 只有当我们预先编译了test消息并且正确链接才能这么干.
    auto test = dynamic_cast<T::Test*>(message);
    // 直接调用message的具体接口
    // 其实这些接口是语法糖接口.所以并没有对应的反射机制来对应调用.
    // 反射机制实现了的Set/Get XXX系列接口,是属于Reflection的接口,接收Message作为参数.
    test->set_id(1);
    std::cout<<test->Utf8DebugString()<<std::endl;
    delete message ;
    return 0 ;
}

直接解析proto文件模式

#include <iostream>
#include <google/protobuf/compiler/importer.h>
#include <google/protobuf/dynamic_message.h>
int main()
{
    // 准备配置好文件系统
    google::protobuf::compiler::DiskSourceTree sourceTree;
    // 将当前路径映射为项目根目录 , project_root 仅仅是个名字,你可以你想要的合法名字.
    sourceTree.MapPath("project_root","./");
    // 配置动态编译器.
    google::protobuf::compiler::Importer importer(&sourceTree, NULL);
    // 动态编译proto源文件。 源文件在./source/proto/test.proto .
    importer.Import("project_root/source_proto/test.proto");
    // 现在可以从编译器中提取类型的描述信息.
    auto descriptor1 = importer.pool()->FindMessageTypeByName("T.Test");
    // 创建一个动态的消息工厂.
    google::protobuf::DynamicMessageFactory factory;
    // 从消息工厂中创建出一个类型原型.
    auto proto1 = factory.GetPrototype(descriptor1);
    // 构造一个可用的消息.
    auto message1= proto1->New();
    // 下面是通过反射接口给字段赋值.
    auto reflection1 = message1->GetReflection();
    auto filed1 = descriptor1->FindFieldByName("id");
    reflection1->SetInt32(message1,filed1,1);
    // 打印看看
    std::cout << message1->DebugString();
    // 删除消息.
    delete message1 ;
    return 0 ;
}

3.2 通过对象和对象的属性获取名字,修改对应属性

#include "cpp/test.pb.h"
#include <iostream>

int main()
{
    // 拿到一个对象,不在乎怎么拿到,可以是通过反射拿到。
    // 这里简单直接的创建一个.
    T::Test p_test ;
    // 拿到对象的描述包.
    auto descriptor = p_test.GetDescriptor() ;
    // 拿到对象的反射配置.
    auto reflecter = p_test.GetReflection() ;
    // 拿到属性的描述包.
    auto field = descriptor->FindFieldByName("id");
    // 设置属性的值.
    reflecter->SetInt32(&p_test , field , 5 ) ;
    // 获取属性的值.
    std::cout<<reflecter->GetInt32(p_test , field)<< std::endl ;
    return 0 ;
}

4. 处理Protobuf反射,通过协议字串动态生成协议

下面两部分是针对protobuf通讯协议的内容。下面这两个函数可以动态生成pb的message,其中ProtoMsg是pb package的名字

    inline google::protobuf::Message* CreateMessage(const std::string& msg)
    {
        google::protobuf::Message* message = NULL;
        const google::protobuf::Descriptor* descriptor = google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName("ProtoMsg." + msg);
        if (descriptor)
        {
            const google::protobuf::Message* prototype = google::protobuf::MessageFactory::generated_factory()->GetPrototype(descriptor);
            if (prototype)
            {
                message = prototype->New();
            }
        }
 
        return message;
    }
 
    inline void ReleaseMessage(google::protobuf::Message* pMsg)
    {
        if (NULL != pMsg)
        {
            pMsg->Clear();
            delete pMsg;
        }
    }

5. 通过反射将配置中的值设置进pb字段

可以通过如下方法,自动创建message并对field赋值:

    // mstrCurMsg 当前正在执行的协议
    google::protobuf::Message* pMsg = Test::CreateMessage(mstrCurMsg);
    const google::protobuf::Descriptor* pDescriptor = google::protobuf::DescriptorPool::generated_pool()->FindMessageTypeByName("ProtoMsg." + mstrCurMsg);
    assert(NULL != pDescriptor);
    
    // 这一个可以获取到反射类,然后可以将配置中值赋值进去
    const google::protobuf::Reflection* pReflection = pMsg->GetReflection();
    assert(NULL != pReflection);
 
    for (int i = 0; i < pDescriptor->field_count(); ++i)
    {
        const google::protobuf::FieldDescriptor* pFieldDescriptor = pDescriptor->field(i);
        assert(NULL != pFieldDescriptor);
 
        const std::string& strFieldName = pFieldDescriptor->name();
        
        const TestConfigModule::MsgEntry* pMsgEntry = pMsgStruct->GetMsgEntry(strFieldName);
        assert(NULL != pMsgEntry);
 
        // 读取字段类型,顺带可以做类型检查
        assert(pMsgEntry->mnType == pFieldDescriptor->type());
 
        // 设置值
        switch (pMsgEntry->mnType)
        {
        case Test::TYPE_STRING:
            pReflection->SetString(pMsg, pFieldDescriptor, pMsgEntry->mstrValue);
            break;
        // ...
        default:
            break;
        }
    }
 
    std::string strData;
    if (!pMsg->SerializeToString(&strData))
    {
        m_pLogModule->LogNormal("Test stop, cannot SerializeToString ", mstrCurMsg, __FUNCTION__, __LINE__);
        return;
    }
 
    Test::ReleaseMessage(pMsg);

6. serialize_message

serialize_message遍历提取message中各个字段以及对应的值,序列化到string中。主要思路就是通过Descriptor得到每个字段的描述符:字段名、字段的cpp类型。通过Reflection的GetX接口获取对应的value。

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

    for (int i = 0; i field_count(); ++i) {
        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()) {
#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(&wsize), sizeof(wsize));
                    serialized_string->append(field->name().c_str(), field->name().size());
                    wsize = sizeof(value);
                    serialized_string->append(reinterpret_cast(&wsize), sizeof(wsize));
                    serialized_string->append(reinterpret_cast(&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 google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
                    int value = reflection->GetEnum(message, field)->number();
                    int wsize = field->name().size();
                    //写入name占用字节数
                    serialized_string->append(reinterpret_cast(&wsize), sizeof(wsize));
                    //写入name
                    serialized_string->append(field->name().c_str(), field->name().size());
                    wsize = sizeof(value);
                    //写入value占用字节数
                    serialized_string->append(reinterpret_cast(&wsize), sizeof(wsize));
                    //写入value
                    serialized_string->append(reinterpret_cast(&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(&wsize), sizeof(wsize));
                    serialized_string->append(field->name().c_str(), field->name().size());
                    wsize = value.size();
                    serialized_string->append(reinterpret_cast(&wsize), sizeof(wsize));
                    serialized_string->append(value.c_str(), value.size());
                    break;
                }
                case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: {
                    std::string value;
                    int wsize = field->name().size();
                    serialized_string->append(reinterpret_cast(&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(&wsize), sizeof(wsize));
                    serialized_string->append(value.c_str(), value.size());
                    break;
                }
            }
        }
    }
}

7. 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) {
    const google::protobuf::Descriptor* descriptor = message->GetDescriptor();
    const google::protobuf::Reflection* reflection = message->GetReflection();
    std::map field_map;
 
    for (int i = 0; i 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.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(serialized_string.substr(pos, sizeof(int)).c_str()));
        pos += sizeof(int);
        std::string value = serialized_string.substr(pos, value_size);
        pos += value_size;
 
        std::map::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 google::protobuf::FieldDescriptor::CPPTYPE_##cpptype: {
                reflection->Set##method(
                        message,
                        field,
                        *(reinterpret_cast(value.c_str())));
                std::cout name() (value.c_str())) enum_type()->FindValueByNumber(*(reinterpret_cast(value.c_str())));
                reflection->SetEnum(message, field, enum_value_descriptor);
                std::cout name() (value.c_str())) SetString(message, field, value);
                std::cout name() MutableMessage(message, field);
                parse_message(value, submessage);
                break;
            }
            default: {
                break;
            }
        }
    }
}

只是基本介绍下,在遇到问题时候还是多求助官方文档的。

发表评论