C / C++ / 系统课时

注册服务并分发远程方法

注册服务并分发远程方法

本节把 RPC 服务端从“收到一段请求”推进到“准确调用某个远程方法”。最终会得到一个最小可运行的注册表:启动时注册服务与方法,请求到达后按名称查找处理函数,统一返回成功结果或明确错误。

学习目标

  • 设计服务名、方法名到处理函数的注册表。
  • 按 RPC 请求中的路由信息完成查找、调用与结果封装。
  • 正确处理重复注册、方法不存在和处理函数异常。

注册表解决的核心问题

RPC 服务端不能在网络层写一长串 if/else 判断方法名。更稳妥的做法,是在启动阶段把“服务名 + 方法名”绑定到一个可调用对象;运行阶段只负责查表和执行。这样网络收包、业务实现和路由规则彼此解耦。

RPC 方法注册与分发流程

注册表本质上保存的是“稳定名字到可执行函数”的映射。外部请求只携带路由信息,不直接知道 C++ 函数地址,因此服务端必须承担这层解析与绑定。

建立可调用的注册表

下面用两层 unordered_map 保存服务与方法。处理函数统一接收 RpcRequest、返回 RpcResponse,这样所有远程方法都能经过同一套分发入口。

cpp
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <unordered_map>

struct RpcRequest {
    std::string service;
    std::string method;
    std::string payload;
};

struct RpcResponse {
    bool ok;
    std::string payload;
    std::string error;
};

class RpcServer {
public:
    using Handler = std::function<RpcResponse(const RpcRequest&)>;

    bool registerMethod(const std::string& service,
                        const std::string& method,
                        Handler handler) {
        auto& methods = registry_[service];
        // 重复注册通常意味着启动配置错误,直接拒绝比静默覆盖更安全。
        if (methods.contains(method)) {
            return false;
        }
        methods.emplace(method, std::move(handler));
        return true;
    }

    RpcResponse dispatch(const RpcRequest& request) const {
        auto serviceIt = registry_.find(request.service);
        if (serviceIt == registry_.end()) {
            return {false, "", "SERVICE_NOT_FOUND"};
        }

        auto methodIt = serviceIt->second.find(request.method);
        if (methodIt == serviceIt->second.end()) {
            return {false, "", "METHOD_NOT_FOUND"};
        }

        try {
            // 网络层只负责找到并调用统一签名的 Handler。
            return methodIt->second(request);
        } catch (const std::exception&) {
            return {false, "", "INTERNAL_ERROR"};
        }
    }

private:
    std::unordered_map<std::string,
        std::unordered_map<std::string, Handler>> registry_;
};

int main() {
    RpcServer server;

    bool first = server.registerMethod(
        "UserService",
        "GetName",
        [](const RpcRequest& request) -> RpcResponse {
            if (request.payload != "42") {
                throw std::runtime_error("unknown user");
            }
            return {true, "Alice", ""};
        });

    bool duplicate = server.registerMethod(
        "UserService",
        "GetName",
        [](const RpcRequest&) -> RpcResponse {
            return {true, "Bob", ""};
        });

    RpcResponse ok = server.dispatch({"UserService", "GetName", "42"});
    RpcResponse missing = server.dispatch({"UserService", "Delete", "42"});

    std::cout << "first register: " << (first ? "ok" : "rejected") << '\\n';
    std::cout << "duplicate register: " << (duplicate ? "ok" : "rejected") << '\\n';
    std::cout << "call result: " << (ok.ok ? ok.payload : ok.error) << '\\n';
    std::cout << "missing result: "
              << (missing.ok ? missing.payload : missing.error) << '\\n';
}

预期输出:

text
first register: ok
duplicate register: rejected
call result: Alice
missing result: METHOD_NOT_FOUND

示例使用了 C++20 的 contains。如果项目仍是 C++17,可改成 methods.find(method) != methods.end(),注册与分发思路不变。

从请求到响应的分发顺序

一次远程调用进入服务端后,建议固定按以下顺序处理:

  1. 网络层完成帧解码,得到包含 service、method 和负载的请求对象。
  2. 分发器先查服务,再查方法;任一层不存在都立即返回确定的错误码。
  3. 命中后调用注册的 Handler,不让业务函数直接接触连接对象或收包缓冲区。
  4. 把业务返回值统一封装为 RpcResponse,再交给协议层编码并发送。

这种顺序让“找不到方法”和“业务执行失败”成为两类不同问题,日志、监控和客户端重试策略都会更清楚。

处理注册与调用边界

方法查找失败属于路由错误,应返回稳定的机器可识别错误码;处理函数抛异常则属于执行错误,应在 RPC 边界统一转换,避免异常穿过网络线程。真实项目还应给每个请求附带 requestId,方便把分发日志和调用链串起来。

如果后续接入 Protobuf,注册表无需改变职责:它仍然只决定“应该调用哪个方法”,而请求负载的反序列化可以放在具体 Handler 或生成的适配层中。这样路由与消息格式保持独立,协议升级时不会牵动整个服务注册机制。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

注册服务并分发远程方法

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通