C++使用ZeroMQ和MessagePack实现简单又轻量级的RPC框架

已于 2025-03-15 16:15:31 修改
阅读量674 收藏 10
点赞数 16
分类专栏： C++ 文章标签： c++ rpc zeromq messagepack
于 2025-03-15 16:13:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/yyz_1987/article/details/146280760
版权

在现代的分布式系统中，远程过程调用（RPC）是一个非常重要的机制，它允许不同的服务或组件之间的通信，就像调用本地函数一样。本文将介绍如何使用ZeroMQ和MessagePack来构建一个轻量级的RPC框架，并提供一个简单的使用示例。

ZeroMQ简介

ZeroMQ（也称为0MQ）是一个高性能的异步消息库，旨在使用标准的、对等的传输协议实现消息的发送与接收。ZeroMQ的核心是提供一个消息队列，使得消息发送和接收更加高效和可靠。ZeroMQ支持多种消息模式，如请求/响应（Request/Reply）、发布/订阅（Publish/Subscribe）等。在上述代码中，ZMQ_REP表示响应模式，用于服务器端，而ZMQ_REQ则用于客户端，发起请求并等待响应。

MessagePack简介

MessagePack是一种高效的二进制序列化库，类似于JSON，但更紧凑、更快。它使用二进制格式来表示数据，使得数据传输更加高效。MessagePack可以用于多种编程语言，包括C++，并且不需要额外的依赖，如Boost。

安装MessagePack和ZeroMQ

安装MessagePack
MessagePack的C++版本可以通过多种方式进行安装，例如使用包管理器或从源代码编译安装。以下是通过CMake安装MessagePack的方法：

  1. 下载MessagePack源码：

    git clone https://github.com/msgpack/msgpack-c.git
cd msgpack-c

  2. 创建构建目录并编译安装：

    mkdir build
cd build
cmake ..
make
sudo make install

安装ZeroMQ

下载ZeroMQ源码

可以从ZeroMQ的官方GitHub仓库下载最新的源码。使用git clone命令进行下载：

git clone https://github.com/zeromq/libzmq.git
cd libzmq
编译和安装

进入源码目录后，可以按照以下步骤进行编译和安装：

  1. 生成配置文件：使用autogen.sh脚本生成配置文件。

    ./autogen.sh

  2. 配置编译选项：使用configure脚本进行配置。可以添加各种选项来定制编译过程，例如指定安装路径等。

    ./configure

    如果需要指定安装路径（例如/usr/local），可以添加--prefix选项：

    ./configure --prefix=/usr/local

  3. 编译源码：使用make命令进行编译。

   make
  1. 安装库文件：使用make install命令安装编译好的库文件到系统中。
   sudo make install

如果需要运行在嵌入式linux上则需要交叉编译，如下：

# 下载源码
git clone https://github.com/zeromq/libzmq.git
cd libzmq

# 配置交叉编译环境（示例：ARM架构）
export CC=arm-linux-gnueabihf-gcc
export CXX=arm-linux-gnueabihf-g++

# 配置编译选项（禁用非必要功能）
./configure --host=arm-linux-gnueabihf \
            --prefix=/opt/zmq-embedded \
            --without-libsodium \      # 禁用加密
            --without-docs

# 编译并安装
make -j4 && make install
验证安装

安装完成后，可以通过编写一个简单的ZeroMQ程序来验证安装是否成功。以下是一个简单的示例程序：

服务器端代码 (server.cpp)

#include <zmq.hpp>
#include <iostream>
#include <thread>
#include <chrono>

int main() {
    zmq::context_t context(1);
    zmq::socket_t socket(context, ZMQ_REP);
    socket.bind("tcp://*:5555");

    while (true) {
        zmq::message_t request;

        // 等待客户端请求
        socket.recv(request, zmq::recv_flags::none);

        // 处理请求
        std::cout << "Received Hello" << std::endl;

        // 发送响应
        zmq::message_t reply(5);
        memcpy(reply.data(), "World", 5);
        socket.send(reply, zmq::send_flags::none);

        std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    return 0;
}

客户端代码 (client.cpp)

#include <zmq.hpp>
#include <iostream>

int main() {
    zmq::context_t context(1);
    zmq::socket_t socket(context, ZMQ_REQ);
    socket.connect("tcp://localhost:5555");

    for (int request_nbr = 0; request_nbr != 10; request_nbr++) {
        zmq::message_t request(5);
        memcpy(request.data(), "Hello", 5);
        socket.send(request, zmq::send_flags::none);

        zmq::message_t reply;
        socket.recv(reply, zmq::recv_flags::none);

        std::cout << "Received " << reply.to_string() << std::endl;
    }

    return 0;
}
编译示例程序

使用g++编译上述两个示例程序。确保编译时链接ZeroMQ库：

g++ -o server server.cpp -lzmq
g++ -o client client.cpp -lzmq
运行示例程序

首先运行服务器端程序，然后运行客户端程序。客户端将向服务器发送请求，服务器收到请求后将返回响应。

./server
# 在另一个终端中
./client
实现简单的RPC框架

下面是一个基于ZeroMQ和MessagePack的简单RPC框架的实现示例。该框架支持注册、调用和异步调用远程方法。

定义RpcHandler类型

using RpcHandler = std::function<msgpack::object(const msgpack::object&)>;

初始化服务器和客户端

bool LightweightRPC::initServer(const std::string& serverAddress) {
    try {
        // 创建服务器套接字
        m_serverSocket = std::make_unique<zmq::socket_t>(*m_context, ZMQ_REP);
        
        // 绑定地址
        m_serverSocket->bind(serverAddress);
        
        return true;
    } catch (const zmq::error_t& e) {
        std::cerr << "ZeroMQ error: " << e.what() << std::endl;
        return false;
    }
}

bool LightweightRPC::initClient(const std::string& serverAddress) {
    try {
        // 创建客户端套接字
        m_clientSocket = std::make_unique<zmq::socket_t>(*m_context, ZMQ_REQ);
        
        // 连接到服务器
        m_clientSocket->connect(serverAddress);
        
        return true;
    } catch (const zmq::error_t& e) {
        std::cerr << "ZeroMQ error: " << e.what() << std::endl;
        return false;
    }
}

注册和调用方法

void LightweightRPC::registerMethod(const std::string& methodName, RpcHandler handler) {
    std::lock_guard<std::mutex> lock(m_methodsMutex);
    m_methods[methodName] = handler;
}

msgpack::object LightweightRPC::callMethod(const std::string& methodName, const msgpack::object& params, int timeout_ms) {
    if (!m_clientSocket) {
        throw std::runtime_error("RPC client not initialized");
    }
    
    // 序列化请求
    zmq::message_t request = serializeRequest(methodName, params);
    
    // 发送请求
    m_clientSocket->send(request, zmq::send_flags::none);
    
    // 设置接收超时
    m_clientSocket->set(zmq::sockopt::rcvtimeo, timeout_ms);
    
    // 接收响应
    zmq::message_t reply;
    auto result = m_clientSocket->recv(reply);
    
    // 反序列化响应
    return deserializeResponse(reply);
}

异步调用方法

std::future<msgpack::object> LightweightRPC::callMethodAsync(const std::string& methodName, const msgpack::object& params) {
    // 创建promise和future
    auto promise = std::make_shared<std::promise<msgpack::object>>();
    auto future = promise->get_future();
    
    // 在新线程中调用方法
    std::thread([this, methodName, params, promise]() {
        try {
            msgpack::object result = this->callMethod(methodName, params);
            promise->set_value(result);
        } catch (const std::exception& e) {
            promise->set_exception(std::make_exception_ptr(e));
        }
    }).detach();
    
    return future;
}

启动和停止服务器

void LightweightRPC::startServer(int threadCount) {
    if (!m_serverSocket) {
        throw std::runtime_error("RPC server not initialized");
    }
    
    // 启动服务器
    m_running = true;
    
    // 创建工作线程
    for (int i = 0; i < threadCount; ++i) {
        m_workerThreads.emplace_back(&LightweightRPC::workerThread, this);
    }
}

void LightweightRPC::stopServer() {
    // 停止服务器
    m_running = false;
    
    // 等待所有工作线程结束
    for (auto& thread : m_workerThreads) {
        if (thread.joinable()) {
            thread.join();
        }
    }
    
    // 清空工作线程
    m_workerThreads.clear();
}

服务器处理请求的逻辑

void LightweightRPC::handleRequest(zmq::message_t& request, zmq::message_t& reply) {
    try {
        // 反序列化请求
        auto [methodName, params] = deserializeRequest(request);
        
        // 查找方法并调用
        RpcHandler handler;
        {
            std::lock_guard<std::mutex> lock(m_methodsMutex);
            auto it = m_methods.find(methodName);
            if (it == m_methods.end()) {
                reply = serializeError("Method not found: " + methodName);
                return;
            }
            
            handler = it->second;
        }
        
        // 调用方法处理函数
        msgpack::object result = handler(params);
        
        // 序列化响应
        reply = serializeResponse(result);
    } catch (const std::exception& e) {
        reply = serializeError(std::string("RPC Error: ") + e.what());
    }
}

序列化和反序列化消息

zmq::message_t LightweightRPC::serializeRequest(const std::string& methodName, const msgpack::object& params) {
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    packer.pack_map(2);
    packer.pack("method");
    packer.pack(methodName);
    packer.pack("params");
    packer.pack(params);
    
    return zmq::message_t(sbuf.data(), sbuf.size());
}

std::pair<std::string, msgpack::object> LightweightRPC::deserializeRequest(const zmq::message_t& request) {
    msgpack::object_handle oh = msgpack::unpack(static_cast<const char*>(request.data()), request.size());
    msgpack::object obj = oh.get();
    
    std::string methodName;
    msgpack::object params;
    
    if (obj.type != msgpack::type::MAP || obj.via.map.size != 2) {
        throw std::runtime_error("Invalid RPC request format");
    }
    
    for (uint32_t i = 0; i < obj.via.map.size; ++i) {
        auto key = obj.via.map.ptr[i].key;
        auto val = obj.via.map.ptr[i].val;
        
        if (key.type == msgpack::type::STR) {
            std::string keyStr(key.via.str.ptr, key.via.str.size);
            
            if (keyStr == "method") {
                methodName = std::string(val.via.str.ptr, val.via.str.size);
            } else if (keyStr == "params") {
                params = val;
            }
        }
    }
    
    if (methodName.empty()) {
        throw std::runtime_error("Method name not found in RPC request");
    }
    
    return std::make_pair(methodName, params);
}

zmq::message_t LightweightRPC::serializeResponse(const msgpack::object& result) {
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    packer.pack_map(1);
    packer.pack("result");
    packer.pack(result);
    
    return zmq::message_t(sbuf.data(), sbuf.size());
}

msgpack::object LightweightRPC::deserializeResponse(const zmq::message_t& response) {
    msgpack::object_handle oh = msgpack::unpack(static_cast<const char*>(response.data()), response.size());
    msgpack::object obj = oh.get();
    
    if (obj.type != msgpack::type::MAP || obj.via.map.size != 1) {
        throw std::runtime_error("Invalid RPC response format");
    }
    
    auto key = obj.via.map.ptr[0].key;
    auto val = obj.via.map.ptr[0].val;
    
    if (key.type == msgpack::type::STR) {
        std::string keyStr(key.via.str.ptr, key.via.str.size);
        
        if (keyStr == "result") {
            return val;
        } else if (keyStr == "error") {
            std::string errorMsg(val.via.str.ptr, val.via.str.size);
            throw std::runtime_error(errorMsg);
        }
    }
    
    throw std::runtime_error("Invalid RPC response format");
}

zmq::message_t LightweightRPC::serializeError(const std::string& errorMessage) {
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    packer.pack_map(1);
    packer.pack("error");
    packer.pack(errorMessage);
    
    return zmq::message_t(sbuf.data(), sbuf.size());
}

使用示例

#include "lightweight_rpc.h"
#include <iostream>
#include <string>
#include <thread>
#include <chrono>

// 示例RPC方法：加法
int add(int a, int b) {
    std::cout << "RPC Server: Calculating " << a << " + " << b << std::endl;
    return a + b;
}

// 示例RPC方法：字符串连接
std::string concat(const std::string& a, const std::string& b) {
    std::cout << "RPC Server: Concatenating \"" << a << "\" and \"" << b << "\"" << std::endl;
    return a + b;
}

// 服务器示例
void runServer() {
    try {
        std::cout << "Starting RPC server..." << std::endl;
        
        // 创建RPC服务器
        hub::RpcServer server("tcp://*:5555");
        
        // 注册RPC方法
        server.registerMethod("add", add);
        server.registerMethod("concat", concat);
        
        // 启动服务器
        server.start();
        
        std::cout << "RPC server started. Press Ctrl+C to stop." << std::endl;
        
        while (true) {
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    } catch (const std::exception& e) {
        std::cerr << "Server error: " << e.what() << std::endl;
    }
}

// 客户端示例
void runClient() {
    try {
        std::cout << "Starting RPC client..." << std::endl;
        
        // 创建RPC客户端
        hub::RpcClient client("tcp://localhost:5555");
        
        // 调用加法方法
        auto result1 = client.call<int, int>("add", 2000, 10, 20);
        int sum;
        result1.convert(sum);
        std::cout << "RPC Client: 10 + 20 = " << sum << std::endl;
        
        // 调用字符串连接方法
        auto result2 = client.call<std::string, std::string>("concat", 2000, "Hello, ", "World!");
        std::string concatResult;
        result2.convert(concatResult);
        std::cout << "RPC Client: concat result = " << concatResult << std::endl;
        
        // 异步调用示例
        auto future = client.callAsync<int, int>("add", 30, 40);
        std::cout << "RPC Client: Async call made, waiting for result..." << std::endl;
        
        // 等待结果
        auto result5 = future.get();
        int asyncSum;
        result5.convert(asyncSum);
        std::cout << "RPC Client: Async result 30 + 40 = " << asyncSum << std::endl;
        
    } catch (const std::exception& e) {
        std::cerr << "Client error: " << e.what() << std::endl;
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        std::cerr << "Usage: " << argv[0] << " [server|client]" << std::endl;
        return 1;
    }
    
    std::string mode = argv[1];
    
    if (mode == "server") {
        runServer();
    } else if (mode == "client") {
        runClient();
    } else {
        std::cerr << "Invalid mode. Use 'server' or 'client'." << std::endl;
        return 1;
    }
    
    return 0;
}
完整源码
#ifndef LIGHTWEIGHT_RPC_H
#define LIGHTWEIGHT_RPC_H

#include <string>
#include <functional>
#include <unordered_map>
#include <mutex>
#include <memory>
#include <vector>
#include <future>
#include <thread>
#include <atomic>
#include <zmq.hpp>
#include <msgpack.hpp>

namespace hub {

/**
 * @brief 轻量级RPC框架，基于ZeroMQ和MessagePack
 */
class LightweightRPC {
public:
    // RPC方法处理函数类型
    using RpcHandler = std::function<msgpack::object(const msgpack::object&)>;
    
    /**
     * @brief 获取LightweightRPC的单例实例
     * 
     * @return LightweightRPC& 单例实例
     */
    static LightweightRPC& getInstance();
    
    /**
     * @brief 初始化RPC服务器
     * 
     * @param serverAddress 服务器地址，例如"tcp://*:5555"
     * @return true 如果初始化成功，false 否则
     */
    bool initServer(const std::string& serverAddress);
    
    /**
     * @brief 初始化RPC客户端
     * 
     * @param serverAddress 服务器地址，例如"tcp://localhost:5555"
     * @return true 如果初始化成功，false 否则
     */
    bool initClient(const std::string& serverAddress);
    
    /**
     * @brief 注册RPC方法
     * 
     * @param methodName 方法名
     * @param handler 处理函数
     */
    void registerMethod(const std::string& methodName, RpcHandler handler);
    
    /**
     * @brief 调用远程方法
     * 
     * @param methodName 方法名
     * @param params 参数
     * @param timeout_ms 超时时间（毫秒）
     * @return msgpack::object 返回结果
     */
    msgpack::object callMethod(const std::string& methodName, const msgpack::object& params, int timeout_ms = 1000);
    
    /**
     * @brief 异步调用远程方法
     * 
     * @param methodName 方法名
     * @param params 参数
     * @return std::future<msgpack::object> 返回结果的future
     */
    std::future<msgpack::object> callMethodAsync(const std::string& methodName, const msgpack::object& params);
    
    /**
     * @brief 启动RPC服务器
     * 
     * @param threadCount 工作线程数量
     */
    void startServer(int threadCount = 1);
    
    /**
     * @brief 停止RPC服务器
     */
    void stopServer();
    
    /**
     * @brief 关闭RPC客户端
     */
    void closeClient();

private:
    LightweightRPC();
    ~LightweightRPC();
    LightweightRPC(const LightweightRPC&) = delete;
    LightweightRPC& operator=(const LightweightRPC&) = delete;
    
    // 服务器相关
    std::unique_ptr<zmq::context_t> m_context;
    std::unique_ptr<zmq::socket_t> m_serverSocket;
    std::unique_ptr<zmq::socket_t> m_clientSocket;
    std::unordered_map<std::string, RpcHandler> m_methods;
    std::mutex m_methodsMutex;
    std::vector<std::thread> m_workerThreads;
    std::atomic<bool> m_running;
    
    // 工作线程函数
    void workerThread();
    
    // 处理RPC请求
    void handleRequest(zmq::message_t& request, zmq::message_t& reply);
    
    // 序列化RPC请求
    zmq::message_t serializeRequest(const std::string& methodName, const msgpack::object& params);
    
    // 反序列化RPC请求
    std::pair<std::string, msgpack::object> deserializeRequest(const zmq::message_t& request);
    
    // 序列化RPC响应
    zmq::message_t serializeResponse(const msgpack::object& result);
    
    // 反序列化RPC响应
    msgpack::object deserializeResponse(const zmq::message_t& response);
    
    // 序列化RPC错误
    zmq::message_t serializeError(const std::string& errorMessage);
};

// 便捷的RPC客户端类
class RpcClient {
public:
    /**
     * @brief 构造函数
     * 
     * @param serverAddress 服务器地址
     */
    RpcClient(const std::string& serverAddress);
    
    /**
     * @brief 析构函数
     */
    ~RpcClient();
    
    /**
     * @brief 调用远程方法
     * 
     * @param methodName 方法名
     * @param params 参数
     * @param timeout_ms 超时时间（毫秒）
     * @return msgpack::object 返回结果
     */
    template<typename... Args>
    msgpack::object call(const std::string& methodName, int timeout_ms = 1000, Args... args) {
        // 打包参数
        msgpack::type::tuple<Args...> params(args...);
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, params);
        msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
        msgpack::object obj = oh.get();
        
        // 调用方法
        return LightweightRPC::getInstance().callMethod(methodName, obj, timeout_ms);
    }
    
    /**
     * @brief 异步调用远程方法
     * 
     * @param methodName 方法名
     * @param params 参数
     * @return std::future<msgpack::object> 返回结果的future
     */
    template<typename... Args>
    std::future<msgpack::object> callAsync(const std::string& methodName, Args... args) {
        // 打包参数
        msgpack::type::tuple<Args...> params(args...);
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, params);
        msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
        msgpack::object obj = oh.get();
        
        // 异步调用方法
        return LightweightRPC::getInstance().callMethodAsync(methodName, obj);
    }
};

// 便捷的RPC服务器类
class RpcServer {
public:
    /**
     * @brief 构造函数
     * 
     * @param serverAddress 服务器地址
     * @param threadCount 工作线程数量
     */
    RpcServer(const std::string& serverAddress, int threadCount = 1);
    
    /**
     * @brief 析构函数
     */
    ~RpcServer();
    
    /**
     * @brief 注册RPC方法
     * 
     * @param methodName 方法名
     * @param handler 处理函数
     */
    template<typename Func>
    void registerMethod(const std::string& methodName, Func handler) {
        LightweightRPC::getInstance().registerMethod(methodName, 
            [handler](const msgpack::object& params) -> msgpack::object {
                // 调用处理函数
                return invokeHandler(handler, params);
            });
    }
    
    /**
     * @brief 启动RPC服务器
     */
    void start();
    
    /**
     * @brief 停止RPC服务器
     */
    void stop();

private:
    int m_threadCount;
    
    // 调用处理函数并返回结果
    template<typename Func, typename... Args>
    static msgpack::object invokeHandler(Func handler, const msgpack::object& params) {
        try {
            // 解包参数
            msgpack::type::tuple<Args...> args;
            params.convert(args);
            
            // 调用处理函数
            auto result = callHandlerWithTuple(handler, args);
            
            // 打包结果
            msgpack::sbuffer sbuf;
            msgpack::pack(sbuf, result);
            msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
            return oh.get();
        } catch (const std::exception& e) {
            // 处理异常
            msgpack::sbuffer sbuf;
            msgpack::pack(sbuf, std::string("RPC Error: ") + e.what());
            msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
            return oh.get();
        }
    }
    
    // 使用tuple调用处理函数
    template<typename Func, typename Tuple, std::size_t... I>
    static auto callHandlerWithTupleImpl(Func handler, Tuple&& tuple, std::index_sequence<I...>) {
        return handler(std::get<I>(std::forward<Tuple>(tuple))...);
    }
    
    template<typename Func, typename Tuple>
    static auto callHandlerWithTuple(Func handler, Tuple&& tuple) {
        constexpr auto size = std::tuple_size<typename std::decay<Tuple>::type>::value;
        return callHandlerWithTupleImpl(handler, std::forward<Tuple>(tuple), std::make_index_sequence<size>{});
    }
};

} // namespace hub

#endif // LIGHTWEIGHT_RPC_H 

#include "lightweight_rpc.h"
#include <iostream>
#include <chrono>

namespace hub {

// 单例实例
LightweightRPC& LightweightRPC::getInstance() {
    static LightweightRPC instance;
    return instance;
}

LightweightRPC::LightweightRPC() : m_running(false) {
    // 创建ZeroMQ上下文
    m_context = std::make_unique<zmq::context_t>(1);
}

LightweightRPC::~LightweightRPC() {
    // 停止服务器
    stopServer();
    
    // 关闭客户端
    closeClient();
}

bool LightweightRPC::initServer(const std::string& serverAddress) {
    try {
        // 创建服务器套接字
        m_serverSocket = std::make_unique<zmq::socket_t>(*m_context, ZMQ_REP);
        
        // 绑定地址
        m_serverSocket->bind(serverAddress);
        
        return true;
    } catch (const zmq::error_t& e) {
        std::cerr << "ZeroMQ error: " << e.what() << std::endl;
        return false;
    }
}

bool LightweightRPC::initClient(const std::string& serverAddress) {
    try {
        // 创建客户端套接字
        m_clientSocket = std::make_unique<zmq::socket_t>(*m_context, ZMQ_REQ);
        
        // 连接到服务器
        m_clientSocket->connect(serverAddress);
        
        return true;
    } catch (const zmq::error_t& e) {
        std::cerr << "ZeroMQ error: " << e.what() << std::endl;
        return false;
    }
}

void LightweightRPC::registerMethod(const std::string& methodName, RpcHandler handler) {
    std::lock_guard<std::mutex> lock(m_methodsMutex);
    m_methods[methodName] = handler;
}

msgpack::object LightweightRPC::callMethod(const std::string& methodName, const msgpack::object& params, int timeout_ms) {
    if (!m_clientSocket) {
        throw std::runtime_error("RPC client not initialized");
    }
    
    try {
        // 序列化请求
        zmq::message_t request = serializeRequest(methodName, params);
        
        // 发送请求
        m_clientSocket->send(request, zmq::send_flags::none);
        
        // 设置接收超时
        m_clientSocket->set(zmq::sockopt::rcvtimeo, timeout_ms);
        
        // 接收响应
        zmq::message_t reply;
        auto result = m_clientSocket->recv(reply);
        
        if (!result.has_value() || result.value() == 0) {
            throw std::runtime_error("RPC call timeout");
        }
        
        // 反序列化响应
        return deserializeResponse(reply);
    } catch (const std::exception& e) {
        std::cerr << "RPC call error: " << e.what() << std::endl;
        
        // 返回错误
        msgpack::sbuffer sbuf;
        msgpack::pack(sbuf, std::string("RPC Error: ") + e.what());
        msgpack::object_handle oh = msgpack::unpack(sbuf.data(), sbuf.size());
        return oh.get();
    }
}

std::future<msgpack::object> LightweightRPC::callMethodAsync(const std::string& methodName, const msgpack::object& params) {
    // 创建promise和future
    auto promise = std::make_shared<std::promise<msgpack::object>>();
    auto future = promise->get_future();
    
    // 在新线程中调用方法
    std::thread([this, methodName, params, promise]() {
        try {
            // 调用方法
            msgpack::object result = this->callMethod(methodName, params);
            
            // 设置结果
            promise->set_value(result);
        } catch (const std::exception& e) {
            // 设置异常
            promise->set_exception(std::make_exception_ptr(e));
        }
    }).detach();
    
    return future;
}

void LightweightRPC::startServer(int threadCount) {
    if (!m_serverSocket) {
        throw std::runtime_error("RPC server not initialized");
    }
    
    // 停止现有的服务器
    stopServer();
    
    // 启动服务器
    m_running = true;
    
    // 创建工作线程
    for (int i = 0; i < threadCount; ++i) {
        m_workerThreads.emplace_back(&LightweightRPC::workerThread, this);
    }
}

void LightweightRPC::stopServer() {
    // 停止服务器
    m_running = false;
    
    // 等待所有工作线程结束
    for (auto& thread : m_workerThreads) {
        if (thread.joinable()) {
            thread.join();
        }
    }
    
    // 清空工作线程
    m_workerThreads.clear();
}

void LightweightRPC::closeClient() {
    // 关闭客户端套接字
    m_clientSocket.reset();
}

void LightweightRPC::workerThread() {
    while (m_running) {
        try {
            // 接收请求
            zmq::message_t request;
            auto result = m_serverSocket->recv(request, zmq::recv_flags::dontwait);
            
            if (result.has_value() && result.value() > 0) {
                // 处理请求
                zmq::message_t reply;
                handleRequest(request, reply);
                
                // 发送响应
                m_serverSocket->send(reply, zmq::send_flags::none);
            } else {
                // 没有请求，休眠一段时间
                std::this_thread::sleep_for(std::chrono::milliseconds(10));
            }
        } catch (const std::exception& e) {
            std::cerr << "RPC server error: " << e.what() << std::endl;
        }
    }
}

void LightweightRPC::handleRequest(zmq::message_t& request, zmq::message_t& reply) {
    try {
        // 反序列化请求
        auto [methodName, params] = deserializeRequest(request);
        
        // 查找方法处理函数
        RpcHandler handler;
        {
            std::lock_guard<std::mutex> lock(m_methodsMutex);
            auto it = m_methods.find(methodName);
            if (it == m_methods.end()) {
                // 方法不存在
                reply = serializeError("Method not found: " + methodName);
                return;
            }
            
            handler = it->second;
        }
        
        // 调用方法处理函数
        msgpack::object result = handler(params);
        
        // 序列化响应
        reply = serializeResponse(result);
    } catch (const std::exception& e) {
        // 处理异常
        reply = serializeError(std::string("RPC Error: ") + e.what());
    }
}

zmq::message_t LightweightRPC::serializeRequest(const std::string& methodName, const msgpack::object& params) {
    // 创建请求对象
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    // 打包方法名和参数
    packer.pack_map(2);
    packer.pack("method");
    packer.pack(methodName);
    packer.pack("params");
    packer.pack(params);
    
    // 创建ZeroMQ消息
    return zmq::message_t(sbuf.data(), sbuf.size());
}

std::pair<std::string, msgpack::object> LightweightRPC::deserializeRequest(const zmq::message_t& request) {
    // 解包请求
    msgpack::object_handle oh = msgpack::unpack(static_cast<const char*>(request.data()), request.size());
    msgpack::object obj = oh.get();
    
    // 提取方法名和参数
    std::string methodName;
    msgpack::object params;
    
    if (obj.type != msgpack::type::MAP || obj.via.map.size != 2) {
        throw std::runtime_error("Invalid RPC request format");
    }
    
    for (uint32_t i = 0; i < obj.via.map.size; ++i) {
        auto key = obj.via.map.ptr[i].key;
        auto val = obj.via.map.ptr[i].val;
        
        if (key.type == msgpack::type::STR) {
            std::string keyStr(key.via.str.ptr, key.via.str.size);
            
            if (keyStr == "method") {
                if (val.type != msgpack::type::STR) {
                    throw std::runtime_error("Method name must be a string");
                }
                
                methodName = std::string(val.via.str.ptr, val.via.str.size);
            } else if (keyStr == "params") {
                params = val;
            }
        }
    }
    
    if (methodName.empty()) {
        throw std::runtime_error("Method name not found in RPC request");
    }
    
    return std::make_pair(methodName, params);
}

zmq::message_t LightweightRPC::serializeResponse(const msgpack::object& result) {
    // 创建响应对象
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    // 打包结果
    packer.pack_map(1);
    packer.pack("result");
    packer.pack(result);
    
    // 创建ZeroMQ消息
    return zmq::message_t(sbuf.data(), sbuf.size());
}

msgpack::object LightweightRPC::deserializeResponse(const zmq::message_t& response) {
    // 解包响应
    msgpack::object_handle oh = msgpack::unpack(static_cast<const char*>(response.data()), response.size());
    msgpack::object obj = oh.get();
    
    // 提取结果
    if (obj.type != msgpack::type::MAP || obj.via.map.size != 1) {
        throw std::runtime_error("Invalid RPC response format");
    }
    
    auto key = obj.via.map.ptr[0].key;
    auto val = obj.via.map.ptr[0].val;
    
    if (key.type == msgpack::type::STR) {
        std::string keyStr(key.via.str.ptr, key.via.str.size);
        
        if (keyStr == "result") {
            return val;
        } else if (keyStr == "error") {
            if (val.type == msgpack::type::STR) {
                std::string errorMsg(val.via.str.ptr, val.via.str.size);
                throw std::runtime_error(errorMsg);
            } else {
                throw std::runtime_error("Unknown RPC error");
            }
        }
    }
    
    throw std::runtime_error("Invalid RPC response format");
}

zmq::message_t LightweightRPC::serializeError(const std::string& errorMessage) {
    // 创建错误对象
    msgpack::sbuffer sbuf;
    msgpack::packer<msgpack::sbuffer> packer(sbuf);
    
    // 打包错误
    packer.pack_map(1);
    packer.pack("error");
    packer.pack(errorMessage);
    
    // 创建ZeroMQ消息
    return zmq::message_t(sbuf.data(), sbuf.size());
}

// RpcClient实现
RpcClient::RpcClient(const std::string& serverAddress) {
    if (!LightweightRPC::getInstance().initClient(serverAddress)) {
        throw std::runtime_error("Failed to initialize RPC client");
    }
}

RpcClient::~RpcClient() {
    LightweightRPC::getInstance().closeClient();
}

// RpcServer实现
RpcServer::RpcServer(const std::string& serverAddress, int threadCount) : m_threadCount(threadCount) {
    if (!LightweightRPC::getInstance().initServer(serverAddress)) {
        throw std::runtime_error("Failed to initialize RPC server");
    }
}

RpcServer::~RpcServer() {
    stop();
}

void RpcServer::start() {
    LightweightRPC::getInstance().startServer(m_threadCount);
}

void RpcServer::stop() {
    LightweightRPC::getInstance().stopServer();
}

} // namespace hub
总结

通过上述步骤，我们可以构建一个简单的、基于ZeroMQ和MessagePack的RPC框架。该框架支持注册、调用和异步调用远程方法，具备较高的性能和可靠性。希望本文能帮助大家更好地理解和使用ZeroMQ与MessagePack来实现高效的分布式通信。

C/C++框架和第三方库汇总
编程与实战的博客
07-12 4718
根据读者反馈，发现此篇汇总获赞率异常的高，为了照顾一下新加入的粉丝，故重新发一遍，供粉丝查阅温习。值得学习的C语言开源项目- 1. WebbenchWebbench是一个在linux下使用...
值得推荐的C/C++框架和库（真的很强大）
编程与实战的博客
07-21 2825
值得学习的C语言开源项目- 1、WebbenchWebbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力...
C++框架学习一：朴实无华的高性能RPC框架推荐
哒宰的博客
02-17 2909
C++框架学习
C++实现轻量级RPC分布式网络通信框架
热门推荐
T_Solotov的博客
04-11 1万+
1. 项目概述 RPC是远程过程调用（Remote Procedure Call）的缩写，可以通过网络从远程服务器上请求服务（调用远端服务器上的函数并获取返回结果）。简单来说，客户端程序可以像调用本地函数一样直接调用运行在服务端的函数。 大概画了一下RPC通信框架的大致结构流程图。 1.1 ZooKeeper  ZooKeeper在这里作为服务方法的管理配置中心，负责管理服务方法提供者对外提供的服务方法。服务方法提供者提前将本端对外提供的服务方法名及自己的通信地址信息（IP:Port）注册到ZooKeep
交叉编译zeromq
路漫漫其修远兮
04-26 2179
一：查看官网，是否支持arm32位，结论为支持。 二：源码zeromq-4.1.6.tar.gz放入虚拟机并解压 1.首先要阅读的就是README，然后看一下INSTALL文件，这个文件里编译源码包的步骤。 2.基本三步走：configure，make，make install。 3../configure配置 使用./configure -h查看文档。 对于交叉编译，主要就是有三...
ZeroMQ交叉编译
sinat_35521460的博客
03-16 272
zeromq
9001.消息中间件zeroMQ
写给自己的笔记
05-25 348
消息中间件zeroMQ1 czmq交叉编译2 示例demo2.1 example1 1 czmq交叉编译 czmq的交叉编译移植参考此篇博客，比较详细 https://www.dazhuanlan.com/2019/12/10/5deee354ae256/ 1.1 下载编译依赖库libzmq git clone git://github.com/zeromq/libzmq.git cd libzmq && ./autogen.sh ./configure --host=a
zeromq应用学习(1)——编译zeromq的示例程序
u011425786的专栏
03-03 1341
前段时间和crazyhadoop聊天中，他推荐了zeromq这个开源库。所以今天开始学习一下。看了一下zeromq的在线文档，感觉确实不错，准备学习一下。 我的目的是阅读zeromq的源代码，那么首先要学会去用zeromq，所以刚开始是zeromq的应用学习，然后再开始阅读其源代码。另外，为了重新拾起以前的C++，所以在学习zeromq的过程中，主要使用C++。 今天先来编译一
轻量级 c++11 rpc
06-06
对于轻量级的 C++11 RPC，可以考虑使用 MessagePack 和 ZeroMQ 进行实现。具体步骤如下： 1. 使用 MessagePack 进行序列化和反序列化。MessagePack 是一种轻量级的二进制序列化格式，相比于 JSON 和 XML 更加高效。...
开源 多进程 框架 c++_有哪些值得推荐的c/c++开源框架与库
weixin_39611043的博客
11-29 1271
c/c++的项目也是各种各样的都有，微电子，物联网，桌面客户端，游戏，服务器开发等等。开源框架种类繁多，有哪些值得推荐的c/c++开源框架与库？零声哥总结了一下：0voice/developkit_set​github.com框架Apache C++ Standard Library : 是一系列算法，容器，迭代器和其他基本组件的集合ASL : Adobe源代码库提供了同行的评审和可移植的C++源...
嵌入式交叉编译与交叉调试
07-16
嵌入式操作系统中的交叉调试与交叉编译，适应初学者学习嵌入式操作系统的相关知识
zeromq linux ubuntu已编译好的 arm嵌入式已编译好的库
04-10
压缩包中2个库 一个是ubuntu的 一个是arm的 已编译好 直接引用就可以了 gcc terminal.c -o a.out -I /root/zeromq/include -L /root/zeromq/lib -lzmq -DZMQ_BUILD_DRAFT_API 或arm-linux-gnueabihf-gcc terminal.c -I /root/zeromq-arm/include -L /root/zeromq-arm/lib -lzmq -lstdc++
cpp-czmq一个ZeroMQ的高级绑定
08-16
czmq：一个 ZeroMQ 的高级绑定。
一些重要的C和C++开发框架和开源工具
蔷薇岛少年的博客
02-17 3116
1、值得学习的C语言开源项目1.1. WebbenchWebbench是一个在linux下使用的非常简单的网站压测工具。它使用fork()模拟多个客户端同时访问我们设定的URL，测试网站在压力下工作的性能，最多可以模拟3万个并发连接去测试网站的负载能力。Webbench使用C语言编写, 代码实在太简洁，源码加起来不到600行。 下载链接：http://home.tiscali.cz/~cz2105
linux zmq编译pgm,czmq交叉编译
weixin_35690047的博客
05-05 1017
8种机械键盘轴体对比本人程序员，要买一个写代码的键盘，请问红轴和茶轴怎么选？下载源码:git clone git://github.com/zeromq/libzmq.git生成环境cd libzmq && ./autogen.sh配置交叉编译./configure --host=arm-linux --prefix=/home/sourcelink/opt/arm-libzmq...
1、消息队列框架：ZeroMQ - 开源项目研究文章
最新发布
lzhdim的专栏
01-01 800
　　 　　ZeroMQ(简称ZMQ)是一个开源的通用消息库，它提供了一种类似于嵌入网络库的功能，但实际上更像是一个并发框架。它允许你在不同传输方式(比如进程内、进程间、TCP和多播)中通过套接字传递原子消息，支持多种消息模式如扇出、发布订阅、任务分发和请求回复，能够实现N对N的套接字连接。ZMQ的性能足够高，可以作为集群产品的通信基础，并且它的异步I/O模型支持构建可扩展的多核应用程序。此外，Z...
通讯基础 -- 嵌入式Linux ZeroMQ 使用笔记
sz66cm 学习随笔
12-12 713
ZeroMQ 是一个灵活、高效的消息库，适用于嵌入式和分布式系统。在移植过程中，需要根据目标平台配置交叉编译环境，并解决依赖库的问题。ZeroMQ（ØMQ）是一种高性能的异步消息库，广泛应用于分布式系统中的任务间通信。它提供了简单、灵活的通信抽象，适用于多种场景，如点对点通信、一对多通信等。发布-订阅适用于广播消息场景，发布者根据主题发送，订阅者接收特定主题的消息。移植完成后，编译一个简单的测试程序，验证 ZeroMQ 的功能。在目标平台上需要确保这些依赖库可用，或者也需要移植这些依赖库。
【移植】交叉编译zeroMQ与pyzmq
sishuihuahua的博客
08-15 4612
原创，转载注明出处。 一、 目的 因为项目需要，需要将pyzmq第三方包移植到arm板，这样会涉及zeromq与pyzmq两个库的交叉编译。 当然，有快捷的方法： 1. 直接使用arm板连接外网，直接安装zeromq与pyzmq，可以参考官网Guide或参考：http://blog.youkuaiyun.com/chdhust/article/details/31003005。 2. 我们这里使用的...
基于zeromq的高性能分布式RPC框架Zerorpc 性能测试
weixin_34208283的博客
07-21 874
Zeromq 是基于zeromq、gevent和 msgpack开发的分布式RPC框架zerorpc-python。这个框架简单、易用。1. 安装zeromqyum -y install zeromq yum install gcc gcc-c++ libuuid-devel python-uuid uuid wget http://download.zeromq.org/zeromq-2.1.9...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

特立独行的猫a

您的鼓励是我的创作动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值