项目---网络通信组件JsonRpc

running thunderbolt2025-10-09 13:58

C++网络编程项目实践 --- JsonRpc

一、项目简介

（一）项目介绍

本项目是一个基于 muduo 网络库 开发的 高性能 RPC 分布式框架，采用 C++17 编写，支持 服务注册与发现、异步调用、发布订阅、负载均衡 等功能，适用于构建高并发、可扩展的分布式系统。

  • RPC 调用：客户端调用远程服务端已经注册的方法。
  • 服务注册：服务端启动时向注册中心注册自己提供的方法。
  • 服务发现：客户端根据方法名从注册中心获取服务提供者地址。
  • 发布订阅：客户端订阅主题，服务端发布消息，客户端实时接收。

（二）项目模块

层级 模块名称 文件 功能简介
抽象层 BaseMessage abstract.hpp 定义所有消息的抽象接口
抽象层 BaseConnection abstract.hpp 抽象 TCP 连接，屏蔽底层实现
抽象层 BaseProtocol abstract.hpp 抽象协议处理，支持序列化与反序列化
抽象层 BaseServer / BaseClient abstract.hpp 抽象服务端与客户端接口
具象层 MuduoConnection net.hpp 基于 muduo 的 TCP 连接实现
具象层 LvProtocol net.hpp 自定义 LV 协议实现
具象层 MuduoServer / MuduoClient net.hpp 基于 muduo 的服务端与客户端实现
具象层 JsonMessage message.hpp JSON 消息基类，支持序列化/反序列化
具象层 RpcRequest / RpcResponse message.hpp RPC 请求与响应消息
具象层 ServiceRequest / ServiceResponse message.hpp 服务注册与发现消息
具象层 TopicRequest / TopicResponse message.hpp 发布订阅消息
业务层 RpcCaller rpc_caller.hpp 客户端调用器，支持同步/异步/回调
业务层 RpcClient rpc_client.hpp 客户端封装，支持服务发现与连接池
业务层 RpcServer rpc_server.hpp 服务端封装，支持方法注册与监听
业务层 RegisterServer / RegisterClient rpc_register.hpp 服务注册中心与客户端
业务层 DiscoverClient rpc_client.hpp 服务发现客户端
业务层 TopicServer / TopicClient rpc_topic.hpp 发布订阅系统服务端与客户端
业务层 RpcRouter rpc_router.hpp 服务端方法路由与参数校验
业务层 Dispatcher dispatcher.hpp 消息分发器，按类型分发消息
业务层 Requestor rpc_requestor.hpp 请求管理器，管理异步请求生命周期

（三）项目技术栈
语言 C++17
网络库 muduo
序列化 jsoncpp
构建工具 Makefile
平台 Linux

二、项目构建基础

（一）JsonCpp库

1、定义

JsonCpp是采用完全独立于编程语言的格式来存储数据。

cpp 复制代码 
// C 代码表⽰
char *name = "xx";
int age = 18;
float score[3] = {88.5, 99, 58};

//Json 表⽰
{
 "姓名" : "xx",
 "年龄" : 18,
 "成绩" : [88.5, 99, 58],
 "爱好" ：{
 "书籍" : "西游记",
 "运动" : "打篮球"
 }
}

2、存储方式

Json 的数据类型包括对象，数组，字符串，数字等。

  • 对象：使⽤花括号 {} 括起来的表⽰⼀个对象
  • 数组：使⽤中括号 [] 括起来的表⽰⼀个数组
  • 字符串：使⽤常规双引号 "" 括起来的表⽰⼀个字符串
  • 数字：包括整形和浮点型，直接使⽤

3、库的接口

Json数据类型类的接口实现：

cpp 复制代码 
class Json::Value{
 Value &operator=(const Value &other); //Value重载了[]和=，因此所有的赋值和获取
数据都可以通过
 Value& operator[](const std::string& key);//简单的⽅式完成 val["name"] = 
"xx";
 Value& operator[](const char* key);
 Value removeMember(const char* key);//移除元素
 const Value& operator[](ArrayIndex index) const; //val["score"][0]
 Value& append(const Value& value);//添加数组元素val["score"].append(88); 
 ArrayIndex size() const;//获取数组元素个数 val["score"].size();
 std::string asString() const;//转string string name = 
val["name"].asString();
 const char* asCString() const;//转char* char *name = 
val["name"].asCString();
 Int asInt() const;//转int int age = val["age"].asInt();
 float asFloat() const;//转float float weight = val["weight"].asFloat();
 bool asBool() const;//转 bool bool ok = val["ok"].asBool();
};

Json序列化接口实现：

cpp 复制代码 
class JSON_API StreamWriter {
 virtual int write(Value const& root, std::ostream* sout) = 0;
}
class JSON_API StreamWriterBuilder : public StreamWriter::Factory {
 virtual StreamWriter* newStreamWriter() const;
}

Json反序列化接口实现：

cpp 复制代码 
class JSON_API CharReader {
 virtual bool parse(char const* beginDoc, char const* endDoc, 
 Value* root, std::string* errs) = 0;
}
class JSON_API CharReaderBuilder : public CharReader::Factory {
 virtual CharReader* newCharReader() const;
 }

4、样例实现

cpp 复制代码 
#include <iostream>
#include <sstream>
#include <string>
#include <memory>
#include <jsoncpp/json/json.h>

bool serialize(Json::Value &root, std::string &jsonStr)
{
    std::stringstream ss;
    Json::StreamWriterBuilder builter;
    std::unique_ptr<Json::StreamWriter> writer(builter.newStreamWriter());
    int ret = writer->write(root, &ss);
    if(ret)
    {
        std::cout << "serialize failed" << std::endl;
        return false;
    }
    jsonStr = ss.str();
    return true;
}

bool deserialize(std::string &jsonStr, Json::Value &root)
{
    Json::CharReaderBuilder builter;
    std::unique_ptr<Json::CharReader> reader(builter.newCharReader());
    std::string errs;
    int ret = reader->parse(jsonStr.c_str(), jsonStr.c_str() + jsonStr.size(), 
            &root, &errs);
    if(ret)
    {
        std::cout << "deserialize failed" << std::endl;
        return false;
    }
    return true;
}

int main()
{
    Json::Value root;
    root["name"] = "jsoncpp";
    root["age"] = 18;
    root["sex"] = "male";
    std::string jsonStr;
    serialize(root, jsonStr);
    std::cout << jsonStr << std::endl;

    Json::Value root2; 
    deserialize(jsonStr, root2);
    std::cout << root2["name"] << std::endl;
    std::cout << root2["age"] << std::endl;
    std::cout << root2["sex"] << std::endl;
    for(auto it = root2.begin(); it != root2.end(); ++it)
    {
        std::cout << it.key() << std::endl;
    }
    return 0;
}

（二）Muduo库

1、介绍

Muduo网络库简介

MuduoC++高并发TCP网络编程库，采用非阻塞IO和事件驱动架构，专为高性能网络应用设计。

核心架构

Muduo基于主从Reactor模型实现，采用"one loop per thread"线程模型。该模型的特点是每个线程只能运行一个事件循环（EventLoop），用于处理计时器和IO事件。

关键特性

每个文件描述符严格绑定到单个线程进行读写操作，确保TCP连接的线程安全性。这意味着每个TCP连接必须由特定的EventLoop实例管理，这种设计避免了多线程竞争问题。

性能优势

这种架构设计提供了高效的并发处理能力，同时保持了良好的线程隔离性，特别适合需要处理大量并发连接的网络应用场景。

2、接口实现

TcpServer实现：

cpp 复制代码 
typedef std::shared_ptr<TcpConnection> TcpConnectionPtr;
typedef std::function<void(const TcpConnectionPtr &)> ConnectionCallback;
typedef std::function<void(const TcpConnectionPtr &, Buffer *, Timestamp)> MessageCallback;
class InetAddress : public muduo::copyable
{
public:
    InetAddress(StringArg ip, uint16_t port, bool ipv6 = false);
};
class TcpServer : noncopyable
{
public:
    enum Option
    {
        kNoReusePort,
        kReusePort,
    };
    TcpServer(EventLoop *loop,
              const InetAddress &listenAddr,
              const string &nameArg,
              Option option = kNoReusePort);
    void setThreadNum(int numThreads);
    void start();
    /// 当⼀个新连接建⽴成功的时候被调⽤
    void setConnectionCallback(const ConnectionCallback &cb)
    {
        connectionCallback_ = cb;
    }
    /// 消息的业务处理回调函数---这是收到新连接消息的时候被调⽤的函数
    void setMessageCallback(const MessageCallback &cb)
    {
        messageCallback_ = cb;
    }
}

事件循环类实现：

cpp 复制代码 
class EventLoop : noncopyable
{
public:
    /// Loops forever.
    /// Must be called in the same thread as creation of the object.
    void loop();
    /// Quits loop.
    /// This is not 100% thread safe, if you call through a raw pointer,
    /// better to call through shared_ptr<EventLoop> for 100% safety.
    void quit();
    TimerId runAt(Timestamp time, TimerCallback cb);
    /// Runs callback after @c delay seconds.
    /// Safe to call from other threads.
    TimerId runAfter(double delay, TimerCallback cb);
    /// Runs callback every @c interval seconds.
    /// Safe to call from other threads.
    TimerId runEvery(double interval, TimerCallback cb);
    /// Cancels the timer.
    /// Safe to call from other threads.
    void cancel(TimerId timerId);

private:
    std::atomic<bool> quit_;
    std::unique_ptr<Poller> poller_;
    mutable MutexLock mutex_;
    std::vector<Functor> pendingFunctors_ GUARDED_BY(mutex_);
};

Tcp连接类实现：

cpp 复制代码 
class TcpConnection : noncopyable,
                      public std::enable_shared_from_this<TcpConnection>
{
public:
    /// Constructs a TcpConnection with a connected sockfd
    ///
    /// User should not create this object.
    TcpConnection(EventLoop *loop,
                  const string &name,
                  int sockfd,
                  const InetAddress &localAddr,
                  const InetAddress &peerAddr);
    bool connected() const { return state_ == kConnected; }
    bool disconnected() const { return state_ == kDisconnected; }

    void send(string &&message); // C++11
    void send(const void *message, int len);
    void send(const StringPiece &message);
    // void send(Buffer&& message); // C++11
    void send(Buffer *message); // this one will swap data
    void shutdown();            // NOT thread safe, no simultaneous calling
    void setContext(const boost::any &context)
    {
        context_ = context;
    }
    const boost::any &getContext() const
    {
        return context_;
    }
    boost::any *getMutableContext()
    {
        return &context_;
    }
    void setConnectionCallback(const ConnectionCallback &cb)
    {
        connectionCallback_ = cb;
    }
    void setMessageCallback(const MessageCallback &cb)
    {
        messageCallback_ = cb;
    }

private:
    enum StateE
    {
        kDisconnected,
        kConnecting,
        kConnected,
        kDisconnecting
    };
    EventLoop *loop_;
    ConnectionCallback connectionCallback_;
    MessageCallback messageCallback_;
    WriteCompleteCallback writeCompleteCallback_;
    boost::any context_;
};

TcpClient实现：

cpp 复制代码 
class TcpClient : noncopyable
{
public:
    // TcpClient(EventLoop* loop);
    // TcpClient(EventLoop* loop, const string& host, uint16_t port);
    TcpClient(EventLoop *loop,
              const InetAddress &serverAddr,
              const string &nameArg);
    ~TcpClient();      // force out-line dtor, for std::unique_ptr members.
    void connect();    // 连接服务器
    void disconnect(); // 关闭连接
    void stop();
    // 获取客⼾端对应的通信连接Connection对象的接⼝，发起connect后，有可能还没有连接建⽴成
    功
        TcpConnectionPtr
        connection() const
    {
        MutexLockGuard lock(mutex_);
        return connection_;
    }
    /// 连接服务器成功时的回调函数
    void setConnectionCallback(ConnectionCallback cb)
    {
        connectionCallback_ = std::move(cb);
    }
    /// 收到服务器发送的消息时的回调函数
    void setMessageCallback(MessageCallback cb)
    {
        messageCallback_ = std::move(cb);
    }

private:
    EventLoop *loop_;
    ConnectionCallback connectionCallback_;
    MessageCallback messageCallback_;
    WriteCompleteCallback writeCompleteCallback_;
    TcpConnectionPtr connection_ GUARDED_BY(mutex_);
};
/*
需要注意的是，因为muduo库不管是服务端还是客⼾端都是异步操作，
对于客⼾端来说如果我们在连接还没有完全建⽴成功的时候发送数据，这是不被允许的。
因此我们可以使⽤内置的CountDownLatch类进⾏同步控制
*/
class CountDownLatch : noncopyable
{
public:
    explicit CountDownLatch(int count);
    void wait()
    {
        MutexLockGuard lock(mutex_);
        while (count_ > 0)
        {
            condition_.wait();
        }
    }
    void countDown()
    {
        MutexLockGuard lock(mutex_);
        --count_;
        if (count_ == 0)
        {
            condition_.notifyAll();
        }
    }
    int getCount() const;

private:
    mutable MutexLock mutex_;
    Condition condition_ GUARDED_BY(mutex_);
    int count_ GUARDED_BY(mutex_);
};

Buffer类实现：

cpp 复制代码 
class Buffer : public muduo::copyable
{
public:
    static const size_t kCheapPrepend = 8;
    static const size_t kInitialSize = 1024;
    explicit Buffer(size_t initialSize = kInitialSize)
        : buffer_(kCheapPrepend + initialSize),
          readerIndex_(kCheapPrepend),
          writerIndex_(kCheapPrepend);
void swap(Buffer &rhs)
    size_t readableBytes() const
    size_t writableBytes() const
    const char *peek() const
    const char *findEOL() const
    const char *findEOL(const char *start) const
    void retrieve(size_t len) void retrieveInt64() void retrieveInt32() void retrieveInt16() void retrieveInt8()
        string retrieveAllAsString()
            string retrieveAsString(size_t len) void append(const StringPiece &str) void append(const char * /*restrict*/ data, size_t len) void append(const void * /*restrict*/ data, size_t len) char *beginWrite()
                const char *beginWrite() const
    void hasWritten(size_t len) void appendInt64(int64_t x) void appendInt32(int32_t x) void appendInt16(int16_t x) void appendInt8(int8_t x)
        int64_t readInt64()
            int32_t readInt32()
                int16_t readInt16()
                    int8_t readInt8()
                        int64_t peekInt64() const
    int32_t peekInt32() const
    int16_t peekInt16() const
    int8_t peekInt8() const
    void prependInt64(int64_t x) void prependInt32(int32_t x) void prependInt16(int16_t x) void prependInt8(int8_t x) void prepend(const void * /*restrict*/ data, size_t len) private : std::vector<char> buffer_;
    size_t readerIndex_;
    size_t writerIndex_;
    static const char kCRLF[];
};

3、样例实践

实现一个英汉互译的小程序来使用一下Muduo库。

cpp 复制代码 
/*
    实现一个翻译服务器，客户端发送过来一个英语单词，返回一个汉语词语
*/
#include <muduo/net/TcpServer.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/TcpConnection.h>
#include <muduo/net/Buffer.h>
#include <iostream>
#include <string>
#include <unordered_map>

class DictServer {
    public:
        DictServer(int port): _server(&_baseloop,
            muduo::net::InetAddress("0.0.0.0", port),
            "DictServer", muduo::net::TcpServer::kReusePort)
        {
            //设置连接事件（连接建立/管理）的回调
            _server.setConnectionCallback(std::bind(&DictServer::onConnection, this, std::placeholders::_1));
            //设置连接消息的回调
            _server.setMessageCallback(std::bind(&DictServer::onMessage, this,
                std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
        }
        void start() {
            _server.start();//先开始监听
            _baseloop.loop();//开始死循环事件监控
        }
    private:
        void onConnection(const muduo::net::TcpConnectionPtr &conn) {
            if (conn->connected()) {
                std::cout << "连接建立！\n";
            }else {
                std::cout << "连接断开！\n";
            }
        }
        void onMessage(const muduo::net::TcpConnectionPtr &conn, muduo::net::Buffer *buf, muduo::Timestamp){
            static std::unordered_map<std::string, std::string> dict_map = {
                {"hello",  "你好"},
                {"world",  "世界"},
            };
            std::string msg = buf->retrieveAllAsString();
            std::string res;
            auto it = dict_map.find(msg);
            if (it != dict_map.end()) {
                res = it->second;
            }else {
                res = "未知单词！";
            }
            conn->send(res);
        }
    private:
        muduo::net::EventLoop _baseloop;
        muduo::net::TcpServer _server;
};

int main()
{
    DictServer server(8080);
    server.start();
    return 0;
}
cpp 复制代码 
#include <muduo/net/Buffer.h>
#include <muduo/net/EventLoop.h>
#include <muduo/net/TcpConnection.h>
#include <muduo/net/TcpClient.h>
#include <muduo/base/CountDownLatch.h>
#include <muduo/net/EventLoopThread.h>
#include <string>
#include <iostream>

class DictClient
{
public:
    DictClient(const std::string sip, u_int16_t port)
        : _downlatch(1)
        , _baseloop(_loopthread.startLoop())
        , _dictclient(_baseloop, muduo::net::InetAddress(sip, port), "DictClient")
    {
        //设置连接事件（连接建立/管理）的回调
            _dictclient.setConnectionCallback(std::bind(&DictClient::_ConnectionCallback, this, std::placeholders::_1));
            //设置连接消息的回调
            _dictclient.setMessageCallback(std::bind(&DictClient::_MessageCallback, this, 
                std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
            
            //连接服务器
            _dictclient.connect();
            _downlatch.wait();
    }

    void _ConnectionCallback(const muduo::net::TcpConnectionPtr &conn)
    {
        if (conn->connected())
        {
            std::cout << "连接成功!" << std::endl;
            _conn = conn;
            _downlatch.countDown();
        }
        else
        {
            std::cout << "取消连接!" << std::endl;
        }
    }

    bool Send(const std::string &msg)
    {
        if (_conn->connected() == false)
        {
            std::cout << "连接已经断开，发送数据失败！\n";
            return false;
        }
        _conn->send(msg);
    }

    void _MessageCallback(const muduo::net::TcpConnectionPtr &conn,
                          muduo::net::Buffer *buffer, muduo::Timestamp)
    {
        std::string res = buffer->retrieveAllAsString();
        std::cout << res << std::endl;
    }

private:
    muduo::CountDownLatch _downlatch;
    muduo::net::EventLoopThread _loopthread;
    muduo::net::TcpConnectionPtr _conn; //? 引用还是复制 赋值
    muduo::net::EventLoop* _baseloop;
    muduo::net::TcpClient _dictclient;
};

int main()
{
    DictClient client("127.0.0.1", 8080);
    while(1) {
        std::string msg;
        std::cin >> msg;
        client.Send(msg);
    }
    return 0;
}

（三）C++11异步操作

std::future是C++11标准库中的⼀个模板类，它表⽰⼀个异步操作的结果。当我们在多线程编程中使⽤异步任务时，std::future可以帮助我们在需要的时候获取任务的执⾏结果。std::future的⼀个重要特性是能够阻塞当前线程，直到异步操作完成，从⽽确保我们在获取结果时不会遇到未完成的操作。

1、使⽤ std::async关联异步任务

std::async 的基本概述

std::async 是 C++ 标准库中用于异步执行任务的工具，它关联一个任务与 std::future 对象，允许在需要时获取任务的结果。

参数与启动策略

std::async 的行为由其第一个参数（std::launch 类型）决定：

  • std::launch::deferred：任务延迟执行，直到调用 future 的 get() 或 wait() 时才同步运行。
  • std::launch::async：任务立即在独立线程中异步执行。
  • std::launch::deferred | std::launch::async（默认）：由系统自动选择策略（可能异步或延迟）。
cpp 复制代码 
#include <iostream>
#include <future>
#include <chrono>
int aysnc_task()
{
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return 2;
}
int main()
{
    // 关联异步任务aysnc_task 和 futrue
    std::future<int> result_future = std::async(std::launch::async,
                                                aysnc_task);
    // 此处可执⾏其他操作, ⽆需等待
    std::cout << "hello bit!" << std::endl;
    // 获取异步任务结果
    int result = result_future.get();
    std::cout << "Result: " << result << std::endl;
    return 0;
}

2、使用std::packaged_task

std::packaged_task就是将任务和std::feature绑定在⼀起的模板，是⼀种对任务的封装。我们可以通过std::packaged_task对象获取任务相关联的std::feature对象，通过调⽤get_future()⽅法获得。
std::packaged_task的模板参数是函数签名。

cpp 复制代码 
#include <iostream>
#include <future>
#include <chrono>
int add(int num1, int num2)
{
    return num1 + num2;
}
int main()
{
    // 封装任务
    std::packaged_task<int(int, int)> task(add);
    // 此处可执⾏其他操作, ⽆需等待
    std::cout << "hello bit!" << std::endl;
    std::future<int> result_future = task.get_future();
    // 这⾥必须要让任务执⾏, 否则在get()获取future的值时会⼀直阻塞
    task(1, 2);
    // 获取异步任务结果
    int result = result_future.get();
    std::cout << "Result: " << result << std::endl;
    return 0;
}
cpp 复制代码 
#include <iostream>
#include <future>
#include <chrono>
#include <memory>
int add(int num1, int num2)
{
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return num1 + num2;
}
int main()
{
    // 封装任务
    // std::packaged_task<int(int, int)> task(add);
    // 此处可执⾏其他操作, ⽆需等待
    // std::cout << "hello bit!" << std::endl;
    // std::future<int> result_future = task.get_future();
    // 需要注意的是，task虽然重载了()运算符，但task并不是⼀个函数，
    // std::async(std::launch::async, task, 1, 2); //--错误⽤法
    // 所以导致它作为线程的⼊⼝函数时，语法上看没有问题，但是实际编译的时候会报错
    // std::thread(task, 1, 2); //---错误⽤法
    // ⽽packaged_task禁⽌了拷⻉构造，
    // 且因为每个packaged_task所封装的函数签名都有可能不同，因此也⽆法当作参数⼀样传递
    // 传引⽤不可取，毕竟任务在多线程下执⾏存在局部变量声明周期的问题，因此不能传引⽤
    // 因此想要将⼀个packaged_task进⾏异步调⽤，
    // 简单⽅法就只能是new packaged_task，封装函数传地址进⾏解引⽤调⽤了
    // ⽽类型不同的问题，在使⽤的时候可以使⽤类型推导来解决
    auto task = std::make_shared<std::packaged_task<int(int, int)>>(add);
    std::future<int> result_future = task->get_future();
    std::thread thr([task]()
                    { (*task)(1, 2); });
    thr.detach();
    // 获取异步任务结果
    int result = result_future.get();
    std::cout << "Result: " << result << std::endl;
    return 0;
}

3、使用std::promise

std::promise提供了⼀种设置值的⽅式，它可以在设置之后通过相关联的std::future对象进⾏读取。std::future可以读取⼀个异步函数的返回值了， 但是要等待就绪， ⽽std::promise就提供⼀种 ⽅式手动std::future就绪

cpp 复制代码 
#include <iostream>
#include <future>
#include <chrono>
void task(std::promise<int> result_promise)
{
    int result = 2;
    std::cout << "task result:" << result << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(3));
    result_promise.set_value(result);
}
int main()
{
    // 创建promise
    std::promise<int> result_promise;
    std::future<int> result_future = result_promise.get_future();
    // 创建⼀个新线程， 执⾏⻓时间运⾏的任务
    std::thread task_thread(task, std::move(result_promise));
    // 此处可执⾏其他操作, ⽆需等待
    std::cout << "hello bit!" << std::endl;
    // 获取异步任务结果
    int result = result_future.get();
    std::cout << "Result: " << result << std::endl;
    task_thread.join();
    return 0;
}

（四）随机数的生成和uuid

  • 1、使用机器随机数产生一个随机数种子。（不能直接以机器随机数持续生成，否则效率低下）
  • 2、使用mt19937并且以机器随机数种子生成随机数对象。（使用mt19937生成随机数效率高效）
  • 3、生成控制随机数生成范围的对象。

std::setw():设置下一个输出项的字段宽度。
std::setfill():指定当字段宽度不足时用来填充的字符。
std::hex():把输出流切换为十六进制格式（不是函数，是 manipulator）。
std::atomic<>():把变量包装成原子类型，线程访问无需额外锁。
fetch_add():原子地读取并加上指定值，返回原来的数值。

cpp 复制代码 
  class UUID
    {
    public:
        static std::string uuid()
        {
            std::stringstream ss;
            // 1、创建机器随机数对象
            std::random_device rd;
            // 2、利用机器随机数创建随机生成随机数对象
            std::mt19937 rand_generator(rd());
            // 3、生成控制随机数生成范围对象。
            std::uniform_int_distribution<int> distribution(0, 255);

            for (int i = 0; i < 8; i++)
            {
                if (i == 4 || i == 6)
                    ss << "-";
                ss << std::setw(2) << std::setfill('0') << std::hex << distribution(rand_generator);
            }
            DEBUG_LOG("%s", ss.str().c_str());
            // DEBUG_LOG("%s", "hello");
            static std::atomic<size_t> count(0);
            count.fetch_add(1);
            ss << "-";
            for (int i = 7; i >= 0; i--)
            {
                if (i == 5)
                    ss << "-";
                ss << std::setw(2) << std::setfill('0') << std::hex << ((count >> 8 * i) & 0xff);
            }
            DEBUG_LOG("%s", ss.str().c_str());

            return ss.str();
        }
    };

三、框架设计

（一）抽象层设计

1. BaseMessage

作用：所有消息的基类，定义消息 ID、类型、序列化接口

  • 提供两个成员的接口
    setId() / id()
    setType() / type()
  • 纯虚函数（虚基类不能实例化但是可以作为指向子类的指针）
    serialize() / deserialize() / check()

2、BaseBuffer

作用：抽象 TCP 连接，屏蔽底层网络库差异

  • 纯虚函数
    send()：发送消息
    shutdown()：关闭连接
    connected()：判断连接状态

3、BaseProtocol

作用：抽象协议处理，定义序列化与反序列化接口

纯虚函数：

serialize()：消息转字符串

onMessage()：字符串转消息

canProcessd()：判断缓冲区是否足够解析一条消息

4、BaseConnection

作用：抽象 TCP 连接，屏蔽底层网络库差异

纯虚函数

send()：发送消息

shutdown()：关闭连接

connected()：判断连接状态

5、BaseServer/BaseClient

作用：抽象服务端与客户端，定义生命周期与回调接口

纯虚函数

服务器：start()

客服端： connect() / shutdown() /connected()/conn()/send()

共同成员函数 ：setMessageCallback() / setConnectionCallback() / setCloseCallback()

（二）具象层设计

1、消息类

类名 基类 关键数据 核心接口（具象实现）
JsonMessage BaseMessage Json::Value _body string serialize() bool deserialize(const string &)
RpcRequest JsonMessage --- setMethod(m) / method() setParam(v) / Param() bool check()
RpcResponse JsonMessage --- setResult(v) / Result() setRCode(c) / rCode()
ServiceRequest JsonMessage --- setMethod(m) / method() setOpType(t) / opType() setHost(addr) / host() bool check()
ServiceResponse JsonMessage --- setMethod(m) / Method() setOpType(t) / Optype() setHost(vec) / host()
TopicRequest JsonMessage --- setTopicKey(k) / topicKey() setOpType(t) / opType() setMessage(msg) / message() bool check()
TopicResponse JsonMessage --- setRCode(c) / rCode()

2、MuduoBuffer

类名 基类 关键数据 核心接口（具象实现）
MuduoBuffer BaseBuffer muduo::net::Buffer *_buf size_t readAbleSize() int32_t peekInt32_t() void retrieveInt32_t() int32_t readInt32_t() string retrieveAsString(len)

3、LvProtocol

类名 基类 关键数据 核心接口（具象实现）
LvProtocol BaseProtocol size_t lenFieldsLength = 4 typeFieldsLength = 4 idFieldsLength = 4 bool canProcessd(buffer) bool onMessage(buffer, message) string serialize(message)

4、MuduoConnection

类名 基类 关键数据 核心接口（具象实现）
MuduoConnection BaseConnection muduo::net::TcpConnectionPtr _conn BaseProtocol::Ptr _protocol void send(msg) void shutdown() bool connected()

5、MuduoServer/MuduoClient

类名 基类 关键数据 核心接口（具象实现）
MuduoServer BaseServer muduo::net::TcpServer _server muduo::net::EventLoop _loop BaseProtocol::Ptr _protocol void start()
MuduoClient BaseClient muduo::net::TcpClient _client muduo::net::EventLoopThread _loopThread BaseProtocol::Ptr _protocol void connect() void shutdown() void send(msg) bool connected() BaseConnection::Ptr conn()

（三）业务层设计

1、Rpc调用端

类名 作用 关键数据 核心接口（业务级）
RpcCaller 客户端调用器：同步/异步/回调三种方式 Requestor::Ptr _requestor bool call(conn,method,params,result) 同步 bool call(conn,method,params,JsonAsyncResponse&) 异步 bool call(conn,method,params,JsonCallback) 回调
RpcClient 客户端门面：服务发现+连接池管理 DiscoverClient::Ptr _discover_client unordered_map<Address,BaseClient::Ptr> _clients bool send(method,params,result/future/cb) BaseClient::Ptr getClient(method)

2、RPC 服务端

类名 作用 关键数据 核心接口（业务级）
RpcServer 服务端门面：注册方法+监听 RpcRouter::Ptr _router RegisterClient::Ptr _register_client void registerMethod(service) void start()
RpcRouter 方法路由：参数校验+业务回调 ServiceManager _service_manager void onRpcRequest(conn,request) void registerRequest(service)

3、服务注册中心

类名 作用 关键数据 核心接口（业务级）
RegisterServer 注册中心服务器：处理注册/发现/上下线通知 PDManager::Ptr _pdmanager void start()
RegisterClient 服务注册客户端：向中心注册方法 Provider::Ptr _provider bool registorMethod(conn,host,method)
DiscoverClient 服务发现客户端：获取地址+本地缓存 Discover::Ptr _discover bool serviceDiscover(method,host)
PDManager 注册中心核心业务：Provider/Discover 生命周期管理 ProviderManager _providermanager DiscoverManager _discovermanager void onServerRequest(conn,msg) void onConnShutdown(conn)

4、发布订阅系统

类名 作用 关键数据 核心接口（业务级）
Dispatcher 消息总线：按类型分发到业务回调 unordered_map<MType,CallBack::Ptr> _callbacks template<typename T> registerCallback(type,handler) void onMessage(conn,msg)
Requestor 异步请求生命周期管理：future/callback unordered_map<string,RequestDescribe::Ptr> _request_desc bool send(conn,req,future/callback) void onResponse(conn,msg)

5、消息总线与异步调度

类名 作用 关键数据 核心接口（业务级）
Dispatcher 消息总线：按类型分发到业务回调 unordered_map<MType,CallBack::Ptr> _callbacks template<typename T> registerCallback(type,handler) void onMessage(conn,msg)
Requestor 异步请求生命周期管理：future/callback unordered_map<string,RequestDescribe::Ptr> _request_desc bool send(conn,req,future/callback) void onResponse(conn,msg)

四、项目中遇到的一些问题

（一）bind

std::bind 按值拷贝/拷贝构造函数把 Dispatcher 拷了一份，而 Dispatcher 的拷贝构造函数被删除或不可访问（典型的 std::mutex、std::atomic 等成员会导致编译器隐式删除拷贝构造），于是
std::bind(&RPC::Dispatcher::onMessage, dispatcher, ...)

编译失败；改成传指针（地址）就没有拷贝问题，所以能过。

cpp 复制代码 
    auto onMessage = std::bind(&RPC::Dispatcher::onMessage, &dispatcher, 
    std::placeholders::_1, std::placeholders::_2);
    server->setMessageCallback(onMessage);
cpp 复制代码 
    private:
        std::mutex _mutex;
        std::unordered_map<MType, CallBack::Ptr> _callbacks;

这里只需要把传值改成传指针就没有拷贝了，或者自己显示定义拷贝构造。

（二）muduo库在收发信息有网络序和主机序的转换

cpp 复制代码 
        virtual std::string serialize(const BaseMessage::Ptr &message)
        {
            int type = (int)message->type();
            std::string id = message->id();
            std::string body = message->serialize();
            // 转成网络字节序。
            int type_n = htonl(type);
            int idlen_n = htonl(id.size());
            int totallen_h = typeFieldsLength + idFieldsLength + id.size() + body.size();
            int totallen_n = htonl(totallen_h);
            // 序列化形成字符串
            std::string ret;
            ret.reserve(totallen_h + lenFieldsLength);
            ret.append((char *)&totallen_n, lenFieldsLength);
            ret.append((char *)&type_n, typeFieldsLength);
            ret.append((char *)&idlen_n, idFieldsLength);
            ret.append(id);
            ret.append(body);
            // std::cout << "type: " << type << std::endl;
            // std::cout << "id.size: " << id.size() << std::endl;
            // std::cout << "body.size(): " << body.size() << std::endl;
            // std::cout << "totallen_h" << totallen_h << std::endl;
            // ERROR_LOG("%s", id.c_str());
            // ERROR_LOG("%s", body.c_str());
            return ret;
        }
  • 这里的htonl函数会可以将主机序转化为网络序，不要用成htons这个只能转换16字节。
  • 直接使用append而不是用string构造可以减少一次构造函数的消耗。

（三）使用可变参数列表来设置工厂

使用可变参数列表设置工厂模式，这个是因为构造函数的参数数量是不确定的，使用可变参数以便于可以适合各种类型的参数。

cpp 复制代码 
    class MessageFactory
    {
    public:
        static BaseMessage::Ptr create(MType type)
        {
            switch (type)
            {
            case MType::REQ_RPC:
                return std::make_shared<RpcRequest>();
            case MType::RES_RPC:
                return std::make_shared<RpcResponse>();
            case MType::REQ_TOPIC:
                return std::make_shared<TopicRequest>();
            case MType::RES_TOPIC:
                return std::make_shared<TopicResponse>();
            case MType::REQ_SERVICE:
                return std::make_shared<ServiceRequest>();
            case MType::RES_SERVICE:
                return std::make_shared<ServiceResponse>();
            }
            return BaseMessage::Ptr();
        }
        template <typename T, typename... Args>
        static std::shared_ptr<T> create(Args &&...args)
        {
            return std::make_shared<T>(std::forward<Args>(args)...);
        }
    };

（四）可变参数编写日志宏

可变参数编写日志宏可以在写日志时控制参数的个数等，当然也可以像之前一样使用仿函数重载，简便的化可以使用下面的方法，但是可能导致线程安全的问题。

cpp 复制代码 
            template <typename T>
            LogMessage &operator<<(const T &info)
            {
                std::stringstream ssbuffer;
                ssbuffer << info;
                _loginfo += ssbuffer.str();
                return *this;
            }
cpp 复制代码 
#define LOG(levelstr, level, format, ...)                                                    \
    {                                                                                        \
        if (level >= DEFAULT_LEVEL)                                                          \
        {                                                                                    \
            time_t timestamp = time(0);                                                      \
            tm *cur_time = localtime(&timestamp);                                            \
            printf("[%d_%d_%d %d:%d:%d|%s:%d]"                                               \
                   "["                                                                       \
                   "%s"                                                                      \
                   "]"                                                                       \
                   ": " format "\n",                                                         \
                   cur_time->tm_year + 1900, cur_time->tm_mon + 1,                           \
                   cur_time->tm_mday, cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec, \
                   __FILE__, __LINE__, levelstr, ##__VA_ARGS__);                             \
        }                                                                                    \
    }

#define INFO_LOG(format, ...) LOG("INFO", _INFO, format, ##__VA_ARGS__)
#define DEBUG_LOG(format, ...) LOG("DEBUG", _DEBUG, format, ##__VA_ARGS__)
#define ERROR_LOG(format, ...) LOG("ERROR", _ERROR, format, ##__VA_ARGS__)

（五）通过给参数传入对象形成类型

我们在对每一种类型设置回调函数时，因为要设计到调用子类对象成员，我们这里不能使用基类。（当然也可以使用将智能指针指向的对象强转）。

为了使代码更加优雅，可扩展性。我们使用下面的设计思路，传入子类消息对象类型，生成一种函数类型的对象使用类进行管理，由于unordered_map不支持传入不同类型的对象，因此我们再给管理函数的类加一个基类，由于多态的原理， 我们插入unordered_map时只需要传子类对象，就可以利用切片原理同时插入。

cpp 复制代码 
#pragma once
#include "field.hpp"
#include "tool.hpp"
#include "message.hpp"
#include "net.hpp"
#include <unordered_map>
#include <mutex>

// using MessageCallback = std::function<void(const BaseConnection::Ptr &, BaseMessage::Ptr &)>;

namespace RPC
{
    class CallBack
    {
    public:
        using Ptr = std::shared_ptr<CallBack>;
        virtual void onMessage(const BaseConnection::Ptr &conn, BaseMessage::Ptr &msg) = 0;
    };

    template <class T>
    class CallBackT : public CallBack
    {
    public:
        using Ptr = std::shared_ptr<CallBackT<T>>;
        using MsgCallback =std::function<void(const BaseConnection::Ptr &, std::shared_ptr<T>& )>;

        CallBackT(MsgCallback handler) : _handler(handler) {}
        void onMessage(const BaseConnection::Ptr &conn, BaseMessage::Ptr &msg)
        {
            auto type_msg = std::dynamic_pointer_cast<T>(msg);
            _handler(conn, type_msg);
        }

    private:
        MsgCallback _handler;
    };
    class Dispatcher
    {
    public:
        using Ptr = std::shared_ptr<Dispatcher>;

        template <class T>
        void registerCallback(const MType &type, const typename CallBackT<T>::MsgCallback &handler)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            if (_callbacks.count(type))
            {
                ERROR_LOG("该回调函数已经注册过了！");
                return;
            }
            auto cb = std::make_shared<CallBackT<T>>(handler);

            _callbacks.insert({type, cb});
            DEBUG_LOG("回调函数组测成功！");
        }

        void onMessage(const BaseConnection::Ptr &conn, BaseMessage::Ptr &msg)
        {
            std::unique_lock<std::mutex> lock(_mutex);
            MType type = msg->type();
            if (_callbacks.count(type))
            {
                _callbacks[type]->onMessage(conn, msg);
                return;
            }
            ERROR_LOG("当前没有注册这个回调函数！");
        }

    private:
        std::mutex _mutex;
        std::unordered_map<MType, CallBack::Ptr> _callbacks;
    };
}

（六）Json数组的遍历

在进行服务应答时，服务器要返回发现客服端能提供服务的服务器，这时候返回的是一个Address类型的数组，因此要解读json的key_val

相关推荐
YoungLime3 小时前
DVWA靶场之十：DOM 型 XSS（DOM Based Cross Site Scripting (XSS)）
网络·安全·web安全
影子24013 小时前
Windows Server2016 服务器安装JDK，一直卡在“应用程序正在为首次使用作准备，请稍候” ，导致jdk安装失败解决方案
运维·服务器·windows·jdk
小马学嵌入式~3 小时前
堆排序原理与实现详解
开发语言·数据结构·学习·算法
青岛少儿编程-王老师3 小时前
CCF编程能力等级认证GESP—C++6级—20250927
java·c++·算法
SundayBear3 小时前
Qt 开发修炼指南：从入门到通透的实战心法
开发语言·qt·嵌入式
_OP_CHEN3 小时前
Linux 系统编程：（一）从历史演进到 XShell 远程登录实操
linux·运维·服务器·centos·unix·xshell
夜月yeyue4 小时前
STM32 Flash 访问加速器详解（ART Accelerator）
linux·单片机·嵌入式硬件·uboot·bootloard
ajassi20004 小时前
开源 C++ QT QML 开发（十）通讯--串口
c++·qt·开源
Janspran4 小时前
监控系统2 - framebuffer
c++
热门推荐
01两千字总结：Codex 国内如何安装和使用的教程，以及如何设置中文回答02GitHub 镜像站点03UV安装并设置国内源04KGG转MP3工具|非KGM文件|解密音频05DeepSeek-VL 解析：混合视觉-语言模型如何超越传统计算机视觉方法06jdk21下载、安装（Windows、Linux、macOS）07Linux下V2Ray安装配置指南08一文了解国产算子编程语言 TileLang，TileLang 对国产开源生态的影响与启示09Claude Code & 智谱GLM-4.5 环境配置指南 (Windows/macOS/Ubuntu)1046个Nano-banana 精选提示词，持续更新中