protobuf动态生成

原创 于 2026-07-15 15:23:59 发布 · 241 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Baidu-Rpc

当前文章被收录于：

Baidu-Rpc
21 篇文章 3 人学习
订阅专栏 查看详情 
// main.cpp - 动态序列化库 + 原生 proto 互通演示
#include <cstdint>
#include <string>
#include <vector>
#include <unordered_map>
#include <stdexcept>
#include <memory>
#include <cstring>
#include <iostream>

// ==================== 动态序列化库（C++11） ====================
namespace dynpb {

enum class WireType : uint8_t {
    VARINT = 0,
    BIT64 = 1,
    LENGTH_DELIMITED = 2,
    BIT32 = 5
};

enum class FieldType : uint8_t {
    INT32, INT64, UINT32, UINT64, BOOL,
    FLOAT, DOUBLE,
    STRING, BYTES,
    MESSAGE
};

class Descriptor;
using DescriptorPtr = std::shared_ptr<Descriptor>;

struct FieldDescriptor {
    std::string name;
    uint32_t number;
    FieldType type;
    bool repeated;
    DescriptorPtr message_type;

    FieldDescriptor() : number(0), type(FieldType::INT32), repeated(false) {}
    FieldDescriptor(const std::string& n, uint32_t num, FieldType t,
                    bool rep = false, DescriptorPtr msg = nullptr)
        : name(n), number(num), type(t), repeated(rep), message_type(std::move(msg)) {}
};

class Descriptor {
public:
    void AddField(const FieldDescriptor& fd) {
        if (fields_.count(fd.number))
            throw std::runtime_error("Duplicate field number");
        fields_[fd.number] = fd;
    }
    const FieldDescriptor* FindField(uint32_t number) const {
        auto it = fields_.find(number);
        return it != fields_.end() ? &it->second : nullptr;
    }
    const std::unordered_map<uint32_t, FieldDescriptor>& fields() const {
        return fields_;
    }
private:
    std::unordered_map<uint32_t, FieldDescriptor> fields_;
};

class DynamicMessage;

template<typename T> struct TypeMap;
template<> struct TypeMap<int32_t>  { static const FieldType type = FieldType::INT32; };
template<> struct TypeMap<int64_t>  { static const FieldType type = FieldType::INT64; };
template<> struct TypeMap<uint32_t> { static const FieldType type = FieldType::UINT32; };
template<> struct TypeMap<uint64_t> { static const FieldType type = FieldType::UINT64; };
template<> struct TypeMap<bool>     { static const FieldType type = FieldType::BOOL; };
template<> struct TypeMap<float>    { static const FieldType type = FieldType::FLOAT; };
template<> struct TypeMap<double>   { static const FieldType type = FieldType::DOUBLE; };
template<> struct TypeMap<std::string> { static const FieldType type = FieldType::STRING; };
template<> struct TypeMap<std::vector<uint8_t>> { static const FieldType type = FieldType::BYTES; };
template<> struct TypeMap<std::shared_ptr<DynamicMessage>> { static const FieldType type = FieldType::MESSAGE; };

class FieldValueBase {
public:
    virtual ~FieldValueBase() = default;
    virtual FieldType GetType() const = 0;
};

template<typename T>
class FieldValueImpl : public FieldValueBase {
public:
    explicit FieldValueImpl(T val) : value_(std::move(val)) {}
    FieldType GetType() const override { return TypeMap<T>::type; }
    T value_;
};

class DynamicMessage {
public:
    explicit DynamicMessage(DescriptorPtr descriptor) : descriptor_(std::move(descriptor)) {}

    template<typename T>
    void SetField(uint32_t number, const T& value) {
        auto* fd = GetField(number);
        CheckType<T>(fd);
        fields_[number] = std::make_shared<FieldValueImpl<T>>(value);
    }

    template<typename T>
    void AddRepeatedField(uint32_t number, const T& value) {
        auto* fd = GetField(number);
        if (!fd->repeated) throw std::runtime_error("Field is not repeated");
        CheckType<T>(fd);
        repeated_[number].push_back(std::make_shared<FieldValueImpl<T>>(value));
    }

    std::string Serialize() const;
    bool ParseFromArray(const void* data, size_t size);

    DescriptorPtr descriptor() const { return descriptor_; }

private:
    DescriptorPtr descriptor_;
    std::unordered_map<uint32_t, std::shared_ptr<FieldValueBase>> fields_;
    std::unordered_map<uint32_t, std::vector<std::shared_ptr<FieldValueBase>>> repeated_;

    const FieldDescriptor* GetField(uint32_t number) const {
        auto* fd = descriptor_->FindField(number);
        if (!fd) throw std::runtime_error("Unknown field number");
        return fd;
    }

    template<typename T> void CheckType(const FieldDescriptor* fd) const {
        if (fd->type != TypeMap<T>::type)
            throw std::runtime_error("Type mismatch for field " + fd->name);
    }

    void WriteVarint(uint64_t value, std::string& out) const {
        while (value >= 0x80) { out.push_back((value & 0x7F) | 0x80); value >>= 7; }
        out.push_back(value & 0x7F);
    }

    void WriteString(const std::string& s, std::string& out) const {
        WriteVarint(s.size(), out);
        out.append(s);
    }

    void WriteBytes(const std::vector<uint8_t>& b, std::string& out) const {
        WriteVarint(b.size(), out);
        out.append(reinterpret_cast<const char*>(b.data()), b.size());
    }

    void WriteField(uint32_t number, WireType wt, const std::string& payload, std::string& out) const {
        uint64_t tag = (static_cast<uint64_t>(number) << 3) | static_cast<uint8_t>(wt);
        WriteVarint(tag, out);
        out.append(payload);
    }

    void WriteFieldValue(FieldType type, const FieldValueBase& val, std::string& payload) const;
    static bool IsZeroFieldValue(FieldType type, const FieldValueBase& val);
    bool ReadVarint(const uint8_t*& ptr, const uint8_t* end, uint64_t& out) const;
    bool SkipField(WireType wt, const uint8_t*& ptr, const uint8_t* end) const;
    std::shared_ptr<FieldValueBase> ReadFieldValue(FieldType type, WireType wt,
                                                   const uint8_t*& ptr, const uint8_t* end,
                                                   const DescriptorPtr& msg_desc) const;
    static WireType GetWireType(FieldType type);
};

// 实现部分
inline void DynamicMessage::WriteFieldValue(FieldType type, const FieldValueBase& val, std::string& payload) const {
    switch (type) {
        case FieldType::INT32: {
            auto& v = static_cast<const FieldValueImpl<int32_t>&>(val);
            WriteVarint(static_cast<uint64_t>(v.value_), payload); break;
        }
        case FieldType::INT64: {
            auto& v = static_cast<const FieldValueImpl<int64_t>&>(val);
            WriteVarint(static_cast<uint64_t>(v.value_), payload); break;
        }
        case FieldType::UINT32: {
            auto& v = static_cast<const FieldValueImpl<uint32_t>&>(val);
            WriteVarint(v.value_, payload); break;
        }
        case FieldType::UINT64: {
            auto& v = static_cast<const FieldValueImpl<uint64_t>&>(val);
            WriteVarint(v.value_, payload); break;
        }
        case FieldType::BOOL: {
            auto& v = static_cast<const FieldValueImpl<bool>&>(val);
            WriteVarint(v.value_ ? 1 : 0, payload); break;
        }
        case FieldType::FLOAT: {
            auto& v = static_cast<const FieldValueImpl<float>&>(val);
            uint32_t raw; std::memcpy(&raw, &v.value_, sizeof(raw));
            payload.append(reinterpret_cast<const char*>(&raw), sizeof(raw)); break;
        }
        case FieldType::DOUBLE: {
            auto& v = static_cast<const FieldValueImpl<double>&>(val);
            uint64_t raw; std::memcpy(&raw, &v.value_, sizeof(raw));
            payload.append(reinterpret_cast<const char*>(&raw), sizeof(raw)); break;
        }
        case FieldType::STRING: {
            auto& v = static_cast<const FieldValueImpl<std::string>&>(val);
            WriteString(v.value_, payload); break;
        }
        case FieldType::BYTES: {
            auto& v = static_cast<const FieldValueImpl<std::vector<uint8_t>>&>(val);
            WriteBytes(v.value_, payload); break;
        }
        case FieldType::MESSAGE: {
            auto& v = static_cast<const FieldValueImpl<std::shared_ptr<DynamicMessage>>&>(val);
            std::string nested = v.value_->Serialize();
            WriteString(nested, payload); break;
        }
    }
}

inline bool DynamicMessage::IsZeroFieldValue(FieldType type, const FieldValueBase& val) {
    switch (type) {
        case FieldType::INT32:  return static_cast<const FieldValueImpl<int32_t>&>(val).value_ == 0;
        case FieldType::INT64:  return static_cast<const FieldValueImpl<int64_t>&>(val).value_ == 0;
        case FieldType::UINT32: return static_cast<const FieldValueImpl<uint32_t>&>(val).value_ == 0;
        case FieldType::UINT64: return static_cast<const FieldValueImpl<uint64_t>&>(val).value_ == 0;
        case FieldType::BOOL:   return !static_cast<const FieldValueImpl<bool>&>(val).value_;
        case FieldType::FLOAT:  return static_cast<const FieldValueImpl<float>&>(val).value_ == 0.0f;
        case FieldType::DOUBLE: return static_cast<const FieldValueImpl<double>&>(val).value_ == 0.0;
        case FieldType::STRING: return static_cast<const FieldValueImpl<std::string>&>(val).value_.empty();
        case FieldType::BYTES:  return static_cast<const FieldValueImpl<std::vector<uint8_t>>&>(val).value_.empty();
        default: return false;
    }
}

inline std::string DynamicMessage::Serialize() const {
    std::string out;
    for (const auto& pair : descriptor_->fields()) {
        uint32_t number = pair.first;
        const FieldDescriptor& fd = pair.second;
        if (fd.repeated) {
            auto it = repeated_.find(number);
            if (it == repeated_.end()) continue;
            for (const auto& val_ptr : it->second) {
                std::string payload;
                WriteFieldValue(fd.type, *val_ptr, payload);
                WriteField(number, GetWireType(fd.type), payload, out);
            }
        } else {
            auto it = fields_.find(number);
            if (it == fields_.end()) continue;
            if (IsZeroFieldValue(fd.type, *it->second)) continue;
            std::string payload;
            WriteFieldValue(fd.type, *it->second, payload);
            WriteField(number, GetWireType(fd.type), payload, out);
        }
    }
    return out;
}

inline bool DynamicMessage::ReadVarint(const uint8_t*& ptr, const uint8_t* end, uint64_t& out) const {
    out = 0;
    int shift = 0;
    while (ptr < end) {
        uint8_t byte = *ptr++;
        out |= static_cast<uint64_t>(byte & 0x7F) << shift;
        if (!(byte & 0x80)) return true;
        shift += 7;
    }
    return false;
}

inline bool DynamicMessage::SkipField(WireType wt, const uint8_t*& ptr, const uint8_t* end) const {
    switch (wt) {
        case WireType::VARINT: while (ptr < end && (*ptr & 0x80)) ptr++; if (ptr < end) ptr++; return true;
        case WireType::BIT64: ptr += 8; return ptr <= end;
        case WireType::BIT32: ptr += 4; return ptr <= end;
        case WireType::LENGTH_DELIMITED: {
            uint64_t len; if (!ReadVarint(ptr, end, len)) return false;
            ptr += len; return ptr <= end;
        }
    }
    return false;
}

inline std::shared_ptr<FieldValueBase> DynamicMessage::ReadFieldValue(
        FieldType type, WireType wt, const uint8_t*& ptr, const uint8_t* end,
        const DescriptorPtr& msg_desc) const {
    switch (type) {
        case FieldType::INT32: { uint64_t v; if(!ReadVarint(ptr,end,v)) return nullptr; return std::make_shared<FieldValueImpl<int32_t>>((int32_t)v); }
        case FieldType::INT64: { uint64_t v; if(!ReadVarint(ptr,end,v)) return nullptr; return std::make_shared<FieldValueImpl<int64_t>>((int64_t)v); }
        case FieldType::UINT32:{ uint64_t v; if(!ReadVarint(ptr,end,v)) return nullptr; return std::make_shared<FieldValueImpl<uint32_t>>((uint32_t)v); }
        case FieldType::UINT64:{ uint64_t v; if(!ReadVarint(ptr,end,v)) return nullptr; return std::make_shared<FieldValueImpl<uint64_t>>(v); }
        case FieldType::BOOL:  { uint64_t v; if(!ReadVarint(ptr,end,v)) return nullptr; return std::make_shared<FieldValueImpl<bool>>(v!=0); }
        case FieldType::FLOAT: { if(ptr+4>end) return nullptr; float v; memcpy(&v,ptr,4); ptr+=4; return std::make_shared<FieldValueImpl<float>>(v); }
        case FieldType::DOUBLE:{ if(ptr+8>end) return nullptr; double v; memcpy(&v,ptr,8); ptr+=8; return std::make_shared<FieldValueImpl<double>>(v); }
        case FieldType::STRING:{ uint64_t len; if(!ReadVarint(ptr,end,len)) return nullptr; if(ptr+len>end) return nullptr;
                                 std::string s((const char*)ptr,len); ptr+=len; return std::make_shared<FieldValueImpl<std::string>>(std::move(s)); }
        case FieldType::BYTES: { uint64_t len; if(!ReadVarint(ptr,end,len)) return nullptr; if(ptr+len>end) return nullptr;
                                 std::vector<uint8_t> bytes(ptr,ptr+len); ptr+=len; return std::make_shared<FieldValueImpl<std::vector<uint8_t>>>(std::move(bytes)); }
        case FieldType::MESSAGE:{ uint64_t len; if(!ReadVarint(ptr,end,len)) return nullptr; if(ptr+len>end) return nullptr;
                                  auto child = std::make_shared<DynamicMessage>(msg_desc);
                                  if(!child->ParseFromArray(ptr,len)) return nullptr;
                                  ptr+=len; return std::make_shared<FieldValueImpl<std::shared_ptr<DynamicMessage>>>(child); }
        default: return nullptr;
    }
}

inline WireType DynamicMessage::GetWireType(FieldType type) {
    switch (type) {
        case FieldType::INT32: case FieldType::INT64: case FieldType::UINT32:
        case FieldType::UINT64: case FieldType::BOOL: return WireType::VARINT;
        case FieldType::FLOAT: return WireType::BIT32;
        case FieldType::DOUBLE: return WireType::BIT64;
        default: return WireType::LENGTH_DELIMITED;
    }
}

inline bool DynamicMessage::ParseFromArray(const void* data, size_t size) {
    const uint8_t* ptr = static_cast<const uint8_t*>(data);
    const uint8_t* end = ptr + size;
    while (ptr < end) {
        uint64_t tag; if (!ReadVarint(ptr, end, tag)) return false;
        uint32_t field_number = tag >> 3;
        WireType wire_type = static_cast<WireType>(tag & 0x07);
        const FieldDescriptor* fd = descriptor_->FindField(field_number);
        if (!fd) { if (!SkipField(wire_type, ptr, end)) return false; continue; }
        auto value = ReadFieldValue(fd->type, wire_type, ptr, end, fd->message_type);
        if (!value) return false;
        if (fd->repeated) repeated_[field_number].push_back(std::move(value));
        else fields_[field_number] = std::move(value);
    }
    return true;
}

} // namespace dynpb

// ==================== 原生 protobuf 头文件 ====================
// 假设已经用 protoc 生成了 user.pb.h，这里直接包含
#include "user.pb.h"

// ==================== 主函数 ====================
int main() {
    // ========== 1. 动态序列化 ==========
    auto userDesc = std::make_shared<dynpb::Descriptor>();
    userDesc->AddField(dynpb::FieldDescriptor("user_id",   1, dynpb::FieldType::INT64));
    userDesc->AddField(dynpb::FieldDescriptor("age",       2, dynpb::FieldType::INT32));
    userDesc->AddField(dynpb::FieldDescriptor("embedding", 3, dynpb::FieldType::FLOAT, true)); // repeated

    dynpb::DynamicMessage msg(userDesc);
    msg.SetField<int64_t>(1, 12345678901234);
    msg.SetField<int32_t>(2, 30);
    msg.AddRepeatedField<float>(3, 0.1f);
    msg.AddRepeatedField<float>(3, 0.2f);
    msg.AddRepeatedField<float>(3, 0.3f);

    std::string data = msg.Serialize();
    std::cout << "动态库序列化大小: " << data.size() << " 字节\n";

    // ========== 2. 原生 Proto 反序列化 ==========
    UserFeature parsed;
    if (!parsed.ParseFromString(data)) {
        std::cerr << "原生 Proto 解析失败\n";
        return 1;
    }

    // ========== 3. 打印验证 ==========
    std::cout << "--- 原生 Proto 解析结果 ---\n";
    std::cout << "user_id   = " << parsed.user_id() << "\n";
    std::cout << "age       = " << parsed.age() << "\n";
    std::cout << "embedding: ";
    for (int i = 0; i < parsed.embedding_size(); ++i) {
        std::cout << parsed.embedding(i) << " ";
    }
    std::cout << "\n";

    // ========== 4. 反向测试（原生序列化 -> 动态解析） ==========
    UserFeature reverse;
    reverse.set_user_id(999);
    reverse.set_age(25);
    reverse.add_embedding(1.0f);
    reverse.add_embedding(2.0f);
    std::string raw = reverse.SerializeAsString();

    dynpb::DynamicMessage dynMsg(userDesc);
    if (dynMsg.ParseFromArray(raw.data(), raw.size())) {
        // 动态库没有直接GetField<int64_t>？我们之前删除了GetField，这里简单验证就略过打印
        // 但为了完整性，可以补充一下GetField（这里就不展示了）
        std::cout << "\n反向解析成功（原生->动态），字节数: " << raw.size() << "\n";
    } else {
        std::cerr << "反向解析失败\n";
    }

    return 0;
}
syntax = "proto2";

message UserFeature {
  optional int64 user_id = 1;
  optional int32 age = 2;
  repeated float embedding = 3;
}

g++ -std=c++11 -o test_dyn_proto main.cpp user.pb.cc -lprotobuf

 protoc --cpp_out=. user.proto

从“用户自定义 Proto 并编译”迁移到“统一配置、动态序列化”，核心需求是：在运行时根据Schema（字段名、类型、编号）直接进行二进制序列化与反序列化，无需生成代码和重新编译。

下面给出一个完整的 C++ 实现方案。它模仿 Protobuf 的 wire format，但完全动态化，用户只需通过配置文件（或代码）描述特征组结构，即可创建消息、读写字段、序列化成紧凑二进制或从二进制恢复。

设计思路

  1. Schema 描述

    • FieldType 枚举支持 INT32, INT64, FLOAT, DOUBLE, STRING, BYTES, BOOL, MESSAGE。

    • FieldDescriptor 记录字段名、编号、类型、是否 repeated、若为嵌套消息则持有子 Descriptor。

    • Descriptor 管理一个 map<字段编号, FieldDescriptor>，用于按编号快速查找。

  2. 动态消息

    • DynamicMessage 内部用 std::variant 存储单值或 std::vector（repeated），提供类型安全的 Set/Get 方法。

    • 字段读写通过字段编号进行。

  3. 序列化/反序列化

    • 采用 Protobuf 的 wire format：每个字段写入 tag = (field_number << 3) | wire_type，然后写入值。

    • Varint 编码整数、布尔；定长编码 float/double；Length-delimited 编码 string/bytes/嵌套消息。

    • 反序列化时根据 tag 找到 FieldDescriptor，递归解析。未知字段自动跳过，保证向前兼容。

这种设计将序列化逻辑完全移入平台库，用户只需提供 Schema 配置（例如从 JSON/XML 加载），不用再碰 .proto 文件。

标签
#算法
使用protobuf的反射来动态生成Message并赋值
热门推荐
mvip163com的博客
07-27 1万+
前言： 公司做了个项目，使用protobuf，各功能号会不断增加，message也会一直变，我做为测试人员，需要做一个测试工具，前期可以通过mfc画图，就是画出message的各个属性对应的输入框，之后按照格式，遍历对应的message，读取输入框的数据来一个个赋值。这样一来，功能号少的时候，还没什么，多画点输入框就是了。后来，message嵌套越来越复杂，其中还夹杂着repeated的属性
protobuf java 自动反射_protobuf通过反射来赋值
weixin_29686935的博客
02-28 982
最近因为项目逻辑方面都做的差不多了，于是赶紧去做做测试工作，免得项目上线之后出问题，于是打算用配置的形式做一个类似与白盒测试工具的东西出来。因为项目使用pb来做协议通讯，所以配置的xml也是类似于pb，将pb的字段和类型配置进去，然后加上值，一个协议结构就可以了，现在只能通过修改值来做测试，后面会改动的更智能化一些，例如某个行为的次数，某个行为更随机等等。去读了一下陈硕的关于pb处理协议的反射，学...
基于JSON的Protobuf动态生成技术实战
weixin_34392511的博客
09-20 1016
Protobuf 支持消息的嵌套定义和枚举类型，这对建模复杂业务对象至关重要。在 JSON 描述中，必须准确反映这种层次结构和语义约束。动态解析器作为整个系统的第一道入口，承担着将外部描述信息转化为程序内部数据模型的关键职责。其设计必须兼顾灵活性、扩展性与类型安全性，确保能够稳定地对接多种来源的 JSON 格式 proto 定义文件。
protobuf-net 的核心能力之一动态生成代码
本博客聚焦游戏开发技巧、创业实战心得及大学热门课程干货。这里既有技术深度，也有思维广度，无论你是开发者、创业者还是高校学子，都能在这里找到适合自己的成长之路！
11-13 300
在运行时，根据你的数据类型（通常是带有特性的类），自动分析其结构，并用 Reflection.Emit 动态生成高效的序列化和反序列化方法。这种方法不是在编译时写死的，而是程序运行时自动生成的。生成的代码会被缓存，后续对同一类型的操作会直接复用，性能很高。protobuf-net 的核心能力之一就是动态生成序列化/反序列化代码，这让它既高效又易用。这种能力依赖于 .NET 的反射和 Reflection.Emit。在支持 JIT 的平台下，开发者几乎无需关心底层细节，直接用即可。
protobuf 动态 JAVA_在Java中将json转换为动态生成的protobuf
weixin_28904519的博客
03-01 823
给定以下json响应:{"id" : "123456","name" : "John Doe","email" : "john.doe@example.com"}以及以下文件:message User {string id = 1;string name = 2;string email = 3;}我希望能够动态地创建protobuf消息类(在运行时编译a.proto),以便在json响应得到字段...
protoreflect实战案例：如何快速动态生成和解析Protobuf消息
最新发布
gitblog_00302的博客
02-20 714
在Go语言开发中，Protobuf作为高效的数据交换格式被广泛应用。然而传统的Protobuf开发需要预编译`.proto`文件，这在需要动态处理未知消息结构的场景下显得不够灵活。**protoreflect**作为Go语言中强大的Protobuf反射工具包，提供了动态生成和解析Protobuf消息的完整解决方案，让开发者无需预编译即可操作任意Protobuf消息结构。 ## 为什么选择prot
protobuf反射
liu0808的专栏
11-19 223
java https://stackoverflow.com/questions/51981456/convert-json-to-dynamically-generated-protobuf-in-java
元数据编程实战_使用Emit运行时生成Protobuf编码类
ah6869的博客
04-03 207
protobuf是google的一种序列化对象的编码方式。相比xml和json的序列化方式,protobuf序列化的结果更小，而且序列化的速度也更快。本文简单介绍写如果通过Emit来在运行时动态的生成对数据对象的protebuf编码解码类。 通过本实例展示下元数据编程的能力。关于protebuf的编码原理可以参考这里http://code.google.com/intl/zh...
protobuf的静态编译及反射的使用示例
li__________的博客
01-15 1663
protobuf编译、protobuf反射运用、完整代码
brpc搭建、编译和使用
INGNIGHT的专栏
09-04 4284
前面介绍了brpc的理解，这里给出brpc官方的搭建过程，以及提供的测试用例，对brpc的使用有一个宏观的理解。 PS：这里必须再次称赞百度工程师门，brpc开源的文档非常的丰富，仅仅是看文档都受益匪浅，同时提供了各个系统，各个版本的安装编译过程，安装编译文档可以通过以下链接直接查看：https://github.com/brpc/brpc/blob/master/docs/cn/getting_started.md 这里给出本人成功安装编译的过程，供大家参考。 前期准备： brpc需要依赖三个开源库
brpc负载均衡load balance和服务发现name servicing
INGNIGHT的专栏
01-21 1306
2.2.3nsthread->Start，bthread_start_urgent创建一个协程RunThis->Run->_ns->RunNamingService。3.Channel：包含LoadBalancerWithNaming的指针_lb，new LoadBalancerWithNaming，lb->Init。1.SharedLoadBalancer（load_balancer.h）：包含LoadBalancer指针_lb。
Baidu-Rpc中Pb结构转为Json
INGNIGHT的专栏
09-28 1136
1.C++动态创建对象（类似java反射） 2.pb结构中repeated，Extension，如何将pb结构转化为string类型（baidu-rpc中有库json2pb文件，可以看源码学习一下） 3.Pb结构中Extension字段使用 4.Pb中Descriptor，Reflection如何实现动态创建对象 https://developers.google.com/protocol-
多线程模型
INGNIGHT的专栏
09-12 1051
一、什么是线程 1.在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列” 2.一切进程至少都有一个执行线 二、进程与线程 1.进程是资源竞争的基本单位 2.线程是程序执行的最小单位 3.线程共享进程数据，但也拥有自己的一部分数据 线程ID，一组寄存器，栈，errno，信号状态，优先级 三、fork和创建新线程的区别 1.当一个进程执行一个fork调用的时候，会创建出进程的一个新拷贝，新进程将拥有它自己的变量和它...
brpc学习：bvar
INGNIGHT的专栏
09-05 845
一.介绍 https://www.bookstack.cn/read/brpc-0.9.7-zh/a070abbea9bcb45d.md bvar是多线程环境下的计数器类库，方便记录和查看用户程序中的各类数值，它利用了thread local存储减少了cache bouncing，相比UbMonitor(百度内的老计数器库)几乎不会给程序增加性能开销，也快于竞争频繁的原子操作。 brpc集成了bvar，http接口下的/vars可查看所有曝光的bvar，/vars/VARNAME可查阅某个bvar，在
brpc基于延迟最大并发度限流
INGNIGHT的专栏
04-04 814
server.cppglobal.cpp。
boost::intrusive_ptr的用法
INGNIGHT的专栏
01-30 761
链接：https://www.jianshu.com/p/dd9701219b27。商业转载请联系作者获得授权，非商业转载请注明出处。作者：JasonLiThirty。
brpc profiler
INGNIGHT的专栏
05-04 671
【代码】brpc mac安装profiler。
brpc中http2 grpc协议解析
INGNIGHT的专栏
05-03 641
这个是固定长度的9字节帧头部，length是，3*8bit（3字节），type8bit，flags8bit，streamid（最高32位置，应该是个0，所以&0x8000000是0）解析完9字节帧头部，按照帧头中的type去解析，playload中的内容，假设type类型是header帧类型。playload是Header类型的帧，是hpack编码的。具体解析是Decode函数，按照hpack规则解析。先看下前4个bit为header类型帧哪种编码格式，如果是。解析frame header信息。
brpc TimerThread定时器
INGNIGHT的专栏
04-16 579
https://blog.csdn.net/guangyacyb/article/details/104067874 https://zhuanlan.zhihu.com/p/60887347 https://blog.csdn.net/baidu_41692782/article/details/109204009?utm_medium=distribute.pc_relevant.none-task-blog-baidujs_title-0&spm=1001.2101.3001.4242
braft
INGNIGHT的专栏
10-06 329
https://www.sohu.com/a/225296499_355140 https://baijiahao.baidu.com/s?id=1598642758115067753&wfr=spider&for=pc https://github.com/maemual/raft-zh_cn/blob/master/raft-zh_cn.md#1-%E4%BB%8B%E7%BB%8D
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值