1. 项目概述：为什么C++开发者需要关注libjson-rpc-cpp？

如果你正在用C++开发分布式系统、微服务，或者需要让一个C++后台服务与前端、移动端、甚至另一个用不同语言写的服务进行通信，那么“如何优雅地实现远程调用”这个问题，你肯定绕不过去。自己手搓HTTP接口、定义JSON格式、处理序列化、反序列化、错误码，一套流程下来，代码又臭又长，维护起来更是噩梦。这时候，一个成熟的RPC（远程过程调用）框架就显得至关重要。今天要聊的 libjson-rpc-cpp ，就是一个在C++世界里，专注于JSON-RPC协议的轻量级、高效且易用的解决方案。

简单来说，libjson-rpc-cpp让你能用近乎调用本地函数的方式，去调用运行在另一台机器、另一个进程里的函数。它基于JSON-RPC标准协议，这意味着你的服务可以轻松地与任何同样遵循JSON-RPC标准的客户端（无论是用Python、JavaScript、Java还是Go写的）进行交互，天然具备了跨语言的能力。这个库不是那种庞大臃肿的“全家桶”，它核心专注于做好JSON-RPC协议的实现，同时提供了从代码生成到多种网络传输方式（HTTP、TCP Socket等）的完整工具链，让开发者能快速搭建起生产可用的RPC服务。对于厌倦了重复造轮子，又希望保持C++高性能特性的开发者来说，它是一个非常值得放入工具箱的选择。

2. 核心特性与架构设计解析

2.1 完整的JSON-RPC协议支持

libjson-rpc-cpp的核心价值首先体现在对JSON-RPC协议的完整支持上。它同时兼容 JSON-RPC 2.0 和 1.0 规范。对于新项目，强烈建议使用2.0版本，因为它解决了1.0中的一些模糊之处，并增加了通知（Notification）、批量请求（Batch）等实用特性。

• 请求与响应格式 ：库自动帮你处理符合规范的JSON格式。一个典型的请求如 {"jsonrpc": "2.0", "method": "sayHello", "params": {"name": "World"}, "id": 1} ，响应如 {"jsonrpc": "2.0", "result": "Hello World", "id": 1} 。你完全不需要手动拼接或解析这些字符串。
• 错误处理 ：协议定义了标准的错误码和错误信息格式。当你的服务端方法抛出异常或处理失败时，库会自动生成如 {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found"}, "id": 1} 的响应。这为客户端提供了统一、可预测的错误处理机制。
• 通知（Notifications） ：这是JSON-RPC 2.0的一个亮点。客户端可以发送一个没有 id 字段的请求，表示不需要服务端返回响应。这常用于发送事件或日志，能减轻服务端压力。

注意 ：虽然库支持1.0，但2.0和1.0在细节上不兼容（如错误对象格式、通知的表示法）。在混合环境中使用时，务必在客户端和服务端明确约定版本，libjson-rpc-cpp在生成桩代码时会依据规范文件进行处理。

2.2 强大的桩代码生成器（Stub Generator）

这是libjson-rpc-cpp最具生产力的特性之一。你不需要手写任何序列化/反序列化代码。其工作流程体现了“契约先行”的开发理念：

1. 定义接口契约 ：你首先编写一个JSON或JSON Schema格式的规范文件（spec.json）。这个文件清晰地定义了所有可远程调用的方法（method）、它们的参数（params）名称与类型、以及返回值（returns）类型。这相当于一份API合同。
2. 一键生成 ：使用库自带的命令行工具 jsonrpcstub ，输入这个规范文件，指定为C++服务端和客户端生成代码。
3. 获得桩代码 ：工具会生成两个关键的C++头文件：
   • 抽象服务器类（如 AbstractStubServer ） ：这是一个纯虚类（接口），里面声明了你在规范文件中定义的所有方法。你的任务就是继承这个类，并实现这些纯虚函数。网络通信、协议解析、路由调用等脏活累活，库已经帮你包了。
   • 客户端桩类（如 StubClient ） ：这个类提供了与抽象服务器中声明的方法一一对应的成员函数。你实例化这个客户端对象，然后像调用本地函数一样调用这些方法（例如 client.sayHello("World") ）。客户端桩内部会负责构造JSON-RPC请求、发送网络消息、接收并解析响应、最后将结果返回给你。

这种方式极大地减少了样板代码，保证了客户端和服务端接口的一致性，从根源上避免了因手误导致的接口不匹配问题。 jsonrpcstub 还支持生成JavaScript和Python的客户端桩代码，这对于需要多语言前端（如Web前端用JS，另一个服务用Python）来调用你的C++服务场景非常有用。

2.3 灵活可插拔的传输层

libjson-rpc-cpp将协议层（JSON-RPC）与传输层（如何收发数据）进行了清晰的解耦。这意味着你可以根据实际部署环境，选择最合适的网络通信方式，而业务逻辑代码几乎不用改动。

• HTTP Server/Client (基于 libmicrohttpd 和 libcurl) ：这是最常用、最通用的方式。HTTP协议穿透性好，易于调试（直接用curl或Postman就能测试），也方便配合Nginx等负载均衡器。库内置了对这两种流行库的封装。
• TCP Socket Server/Client ：如果你追求更低延迟、更高吞吐量的内部服务间通信，TCP Socket是更好的选择。它避免了HTTP协议头的开销，通信更高效。
• Unix Domain Socket ：用于同一台机器上的进程间通信（IPC）。它比TCP loopback更快，且提供基于文件系统的权限控制，安全性更高。
• Redis Pub/Sub ：这是一个很有趣的扩展，允许通过Redis的发布/订阅机制进行RPC通信。这为基于消息队列的异步、解耦架构提供了可能。
• 文件描述符（File Descriptor） ：提供了最大的灵活性，允许你自定义任何类型的连接（如已建立的socket、管道等）作为传输通道。

在编译时，你可以通过CMake选项（如 -DHTTP_SERVER=NO , -DTCP_SOCKET_SERVER=YES ）来启用或禁用特定的传输组件，只链接你需要的库，保持最终二进制文件的精简。

2.4 跨平台与构建系统

项目使用 CMake 作为构建系统，这是现代C++项目的标配，保证了在Linux、macOS和Windows上的跨平台编译能力。从提供的资料看，它在Debian/Ubuntu、Fedora、Arch、Gentoo等主流Linux发行版以及macOS（通过Homebrew）都有现成的软件包，说明其生态和稳定性得到了社区的认可。对于Windows用户，也提供了编译好的安装包，降低了入门门槛。

3. 从零开始：一个完整的实战示例

理论说得再多，不如亲手搭一个。下面我们一步步构建一个简单的“计算器”RPC服务，包含服务端和客户端。

3.1 第一步：定义接口规范文件

首先，创建 calculator.json 文件。这份“契约”定义了我们的服务提供哪些能力。

[
    {
        "name": "add",
        "params": {"a": 0, "b": 0},
        "returns": 0
    },
    {
        "name": "subtract",
        "params": {"a": 0, "b": 0},
        "returns": 0
    },
    {
        "name": "notifyStatus",
        "params": {"status": "idle"}
    }
]

参数解析 ：

• "add" 和 "subtract" 是两个方法（method）。 params 对象定义了参数名和默认值（这里的 0 暗示了类型是数字）。 returns 定义了返回值类型（也是数字）。
• "notifyStatus" 是一个通知（notification）。它没有 returns 字段，这意味着客户端调用它时，不期望也不等待服务端的响应。这在发送“服务已启动”、“任务进度更新”这类信息时非常有用。

3.2 第二步：生成桩代码

使用 jsonrpcstub 工具，根据规范文件生成C++头文件。

# 假设工具已在PATH中（通过系统包安装或自己编译安装）
jsonrpcstub calculator.json --cpp-server=AbstractCalculatorServer --cpp-client=CalculatorClient

# 通常会生成两个文件：abstractcalculatorserver.h 和 calculatorclient.h
# 我们创建一个 gen 目录来存放它们，保持项目整洁
mkdir -p gen
mv abstractcalculatorserver.h calculatorclient.h gen/

现在，查看 gen/abstractcalculatorserver.h ，你会发现一个类似如下的类：

// ... 省略了命名空间和include
class AbstractCalculatorServer : public jsonrpc::AbstractServer<AbstractCalculatorServer>
{
    public:
        AbstractCalculatorServer(jsonrpc::AbstractServerConnector &connector);

        virtual void notifyServer() = 0; // 来自规范文件中的 notifyServer
        virtual Json::Value add(const Json::Value& a, const Json::Value& b) = 0;
        virtual Json::Value subtract(const Json::Value& a, const Json::Value& b) = 0;
        // ... 绑定代码
};

CalculatorClient 类则提供了对应的同步调用方法。

3.3 第三步：实现具体的服务端

创建 server.cpp ，继承并实现那个抽象类。

#include <jsonrpccpp/server.h>
#include <jsonrpccpp/server/connectors/httpserver.h>
#include <iostream>
#include "gen/abstractcalculatorserver.h"

using namespace jsonrpc;
using namespace std;

class ConcreteCalculatorServer : public AbstractCalculatorServer
{
public:
    ConcreteCalculatorServer(AbstractServerConnector &connector)
        : AbstractCalculatorServer(connector)
    {
        // 可以在这里做一些初始化
    }

    // 实现纯虚函数：加法
    Json::Value add(const Json::Value& a, const Json::Value& b) override
    {
        // Json::Value 可以自动转换数字类型
        int result = a.asInt() + b.asInt();
        cout << "[Server] Processing add(" << a.asInt() << ", " << b.asInt() << ") = " << result << endl;
        return result; // 自动包装为 Json::Value
    }

    // 实现纯虚函数：减法
    Json::Value subtract(const Json::Value& a, const Json::Value& b) override
    {
        int result = a.asInt() - b.asInt();
        cout << "[Server] Processing subtract(" << a.asInt() << ", " << b.asInt() << ") = " << result << endl;
        return result;
    }

    // 实现通知方法
    void notifyStatus(const Json::Value& status) override
    {
        // 通知没有返回值
        cout << "[Server] Received status notification: " << status.asString() << endl;
        // 这里可以更新内部状态，触发事件等
    }
};

int main()
{
    // 1. 创建一个HTTP服务器连接器，监听8080端口
    HttpServer httpserver(8080);

    // 2. 创建我们的具体服务器实例，并绑定连接器
    ConcreteCalculatorServer server(httpserver);

    // 3. 启动服务器，开始监听并处理请求
    cout << "Calculator JSON-RPC server started on port 8080..." << endl;
    if (server.StartListening()) {
        cout << "Server listening successfully. Press Enter to stop." << endl;
        getchar(); // 等待用户输入，阻塞主线程
        server.StopListening();
    } else {
        cerr << "Error starting server!" << endl;
        return 1;
    }
    return 0;
}

关键点解析 ：

1. 继承与实现 ： ConcreteCalculatorServer 必须实现父类中所有纯虚函数，否则无法实例化。
2. 参数类型 ：参数和返回值都是 Json::Value 类型（来自jsoncpp库）。它非常灵活，可以表示数字、字符串、数组、对象等。在方法内部，我们通过 asInt() , asString() 等方法将其转换为C++原生类型。返回时，C++内置类型或字符串可以直接赋值给 Json::Value ，它会自动转换。
3. 连接器（Connector） ：这里使用了 HttpServer 作为传输层。你可以轻松替换为 TcpSocketServer 或其他。
4. 启动与停止 ： StartListening() 会启动一个后台线程来处理入站连接和请求。主线程通常需要保持运行（例如通过事件循环或简单的阻塞调用），直到你想关闭服务。

3.4 第四步：编写客户端程序

创建 client.cpp 。

#include <jsonrpccpp/client.h>
#include <jsonrpccpp/client/connectors/httpclient.h>
#include <iostream>
#include "gen/calculatorclient.h"

using namespace jsonrpc;
using namespace std;

int main()
{
    // 1. 创建一个HTTP客户端连接器，指向服务端地址
    HttpClient httpclient("http://localhost:8080");

    // 2. 创建客户端桩对象，并绑定连接器
    CalculatorClient client(httpclient);

    try {
        // 3. 像调用本地函数一样进行远程调用
        int result_add = client.add(5, 3);
        cout << "5 + 3 = " << result_add << endl;

        int result_sub = client.subtract(10, 4);
        cout << "10 - 4 = " << result_sub << endl;

        // 4. 发送一个通知（不等待响应）
        client.notifyStatus("Client is shutting down");
        cout << "Notification sent." << endl;

    } catch (const JsonRpcException& e) {
        // 捕获并处理RPC调用过程中可能发生的异常（如网络错误、协议错误、服务端返回错误）
        cerr << "JSON-RPC Error: " << e.what() << endl;
        cerr << "Error Code: " << e.GetCode() << endl;
        cerr << "Error Message: " << e.GetMessage() << endl;
        cerr << "Error Data: " << e.GetData() << endl;
        return 1;
    } catch (const exception& e) {
        // 捕获其他标准异常
        cerr << "Standard Exception: " << e.what() << endl;
        return 1;
    }

    return 0;
}

关键点解析 ：

1. 连接器配置 ： HttpClient 需要服务端的完整URL。
2. 异常处理 ：所有RPC调用都可能失败（网络中断、服务端错误、方法不存在等）。 JsonRpcException 是库定义的主要异常类，它包含了JSON-RPC协议规定的错误码、错误信息和可选的数据。 务必进行异常处理 ，这是生产代码健壮性的基础。
3. 同步调用 ：本例展示的是同步调用，客户端会阻塞直到收到响应或超时。库也支持异步调用模式，需要更复杂的回调机制。

3.5 第五步：编译与运行

假设你的项目结构如下：

calculator_rpc/
├── calculator.json
├── gen/
│   ├── abstractcalculatorserver.h
│   └── calculatorclient.h
├── server.cpp
└── client.cpp

编译服务端 ：

g++ -std=c++11 server.cpp -ljsoncpp -lmicrohttpd -ljsonrpccpp-common -ljsonrpccpp-server -o calculator_server -I./gen

编译客户端 ：

g++ -std=c++11 client.cpp -ljsoncpp -lcurl -ljsonrpccpp-common -ljsonrpccpp-client -o calculator_client -I./gen

链接库说明 ：

• -ljsoncpp : JSON解析库，libjson-rpc-cpp依赖它处理JSON数据。
• -lmicrohttpd : 用于HTTP服务端。
• -lcurl : 用于HTTP客户端。
• -ljsonrpccpp-common : libjson-rpc-cpp的核心通用库。
• -ljsonrpccpp-server : 服务端特定功能库。
• -ljsonrpccpp-client : 客户端特定功能库。
• -I./gen : 指定桩代码头文件路径。

运行 ：

1. 在一个终端启动服务端： ./calculator_server
2. 在另一个终端运行客户端： ./calculator_client

你应该能在服务端看到方法被调用的日志，在客户端看到计算结果。

4. 高级特性与配置详解

4.1 自定义类型与复杂参数

上面的例子只用了基本类型。实际业务中，我们经常需要传递结构体或对象。JSON-RPC规范本身只定义了JSON能表示的类型（数字、字符串、布尔、数组、对象、null）。libjson-rpc-cpp通过 Json::Value 来传递这些数据。

假设我们需要一个 multiply 方法，它接受一个包含 coeff （系数）和 values （数组）的对象参数。

首先，更新规范文件 calculator.json ，添加：

{
    "name": "multiply",
    "params": {
        "input": {
            "coeff": 1.0,
            "values": [1, 2, 3]
        }
    },
    "returns": [1, 2, 3]
}

这里 params 和 returns 的类型通过默认值的结构来暗示。

重新生成桩代码后，服务端实现如下：

Json::Value multiply(const Json::Value& input) override {
    double coeff = input["coeff"].asDouble();
    const Json::Value& valuesJson = input["values"];

    Json::Value resultArray(Json::arrayValue);
    for (const auto& val : valuesJson) {
        resultArray.append(val.asDouble() * coeff);
    }
    return resultArray;
}

客户端调用：

Json::Value params;
params["coeff"] = 2.5;
params["values"].append(1);
params["values"].append(2);
params["values"].append(3);

Json::Value result = client.multiply(params);
for (const auto& val : result) {
    cout << val.asDouble() << " ";
}

实操心得 ：虽然 Json::Value 很灵活，但在复杂项目中，频繁的手动解析和构造JSON对象容易出错且代码冗长。一个常见的优化模式是，在服务端方法内部，尽快将 Json::Value 转换为一个强类型的内部数据结构（例如一个 struct Input { double coeff; std::vector<double> values; } ），在业务逻辑中使用这个结构体，最后再将结果转换回 Json::Value 。你可以编写简单的转换函数或使用更高级的序列化库（如 nlohmann/json）来辅助这一过程。

4.2 编译选项与依赖管理

通过CMake选项，你可以精细控制库的功能，避免引入不必要的依赖。

cd libjson-rpc-cpp/build
cmake .. \
    -DCOMPILE_EXAMPLES=OFF \      # 不编译例子
    -DCOMPILE_TESTS=OFF \         # 不编译测试
    -DHTTP_SERVER=ON \            # 启用HTTP服务端（需要libmicrohttpd）
    -DHTTP_CLIENT=ON \            # 启用HTTP客户端（需要libcurl）
    -DTCP_SOCKET_SERVER=ON \      # 启用TCP服务端
    -DTCP_SOCKET_CLIENT=ON \      # 启用TCP客户端
    -DUNIX_DOMAIN_SOCKET_SERVER=OFF \ # 禁用Unix Domain Socket（如果你不需要）
    -DREDIS_SERVER=OFF \          # 禁用Redis支持
    -DREDIS_CLIENT=OFF
make
sudo make install

依赖管理建议 ：

• 对于简单的客户端程序，如果只需要调用远程服务，可以只链接 -ljsonrpccpp-client 和 -ljsonrpccpp-common ，并禁用所有服务器选项编译库，这样依赖最少。
• 如果服务部署在容器内，且只需要TCP通信，可以禁用HTTP支持，减少镜像体积和潜在的攻击面。
• 使用 vcpkg 或 conan 这类C++包管理器来管理libjson-rpc-cpp及其依赖（jsoncpp, libcurl等），比手动编译安装要方便和可靠得多。

4.3 异步调用与性能考量

默认的客户端桩方法（如 client.add() ）是同步的，会阻塞当前线程直到收到响应。在高并发或延迟敏感的场景下，这可能成为瓶颈。

libjson-rpc-cpp的客户端底层支持异步调用，但需要你直接使用 Client 类而非生成的桩类，并配合回调函数。这稍微复杂一些：

#include <jsonrpccpp/client.h>
#include <future>

HttpClient httpclient("http://localhost:8080");
Client client(httpclient);

Json::Value params;
params.append(5);
params.append(3);

// 定义一个promise/future对来获取异步结果
std::promise<Json::Value> promise;
std::future<Json::Value> future = promise.get_future();

client.CallMethod("add", params, [&promise](const Json::Value& result, bool isError, const JsonRpcException& error) {
    if (!isError) {
        promise.set_value(result);
    } else {
        // 处理错误，这里简单地将异常设置到future中（需要自定义异常类型）
        // 实际应用中可能需要更复杂的错误传递机制
        promise.set_exception(std::make_exception_ptr(std::runtime_error(error.GetMessage())));
    }
});

// 在主线程做其他事情...
std::this_thread::sleep_for(std::chrono::milliseconds(100));

// 当需要结果时
try {
    Json::Value result = future.get(); // 如果未完成，会阻塞在这里
    int sum = result.asInt();
    cout << "Async result: " << sum << endl;
} catch (const std::exception& e) {
    cerr << "Async call failed: " << e.what() << endl;
}

对于服务端， HttpServer 默认使用多线程模型处理请求，每个连接在一个独立线程中。你可以通过配置 HttpServer 的构造函数参数（如线程池大小）来调整并发性能。对于极高并发的场景，可能需要评估 libmicrohttpd 的性能是否满足要求，或者考虑将libjson-rpc-cpp集成到其他高性能网络库（如asio）的事件循环中，这需要更深入的定制。

5. 常见问题、调试技巧与生产实践

5.1 编译与链接问题

这是新手最常遇到的坑。

• 问题： undefined reference to jsonrpc::...`

  • 原因 ：链接器找不到libjson-rpc-cpp的库文件。链接顺序不对或库路径未指定。
  • 解决 ：
    1. 确保你正确安装了开发包（如 libjsonrpccpp-dev ）。
    2. 编译命令中，源文件要在 -l 选项之前。确保链接了所有必需的库（ -ljsonrpccpp-server , -ljsonrpccpp-client , -ljsonrpccpp-common , -ljsoncpp , -lmicrohttpd , -lcurl 等）。
    3. 如果库安装在非标准路径，使用 -L/path/to/lib 指定库路径，使用 -I/path/to/include 指定头文件路径。
    4. 使用 pkg-config （如果支持）可以简化： g++ server.cpp `pkg-config --cflags --libs libjsonrpccpp-server` -o server 。

• 问题：CMake找不到包

  • 解决 ：如果你在自己的CMake项目中使用 find_package ，确保libjson-rpc-cpp的CMake配置文件在 CMAKE_PREFIX_PATH 中。或者直接使用 add_subdirectory 将libjson-rpc-cpp源码作为子项目引入。

5.2 运行时问题

• 问题：服务端启动失败，提示端口被占用或权限不足

  • 解决 ：检查端口（如8080）是否已被其他程序使用（ netstat -tulpn | grep 8080 ）。在Linux上，监听1024以下端口需要root权限，建议使用1024以上的端口。

• 问题：客户端调用超时或无响应

  • 排查步骤 ：
    1. 网络连通性 ：先用 curl 或 telnet 测试服务端地址和端口是否能通。 curl -X POST http://localhost:8080 -d '{"jsonrpc":"2.0","method":"sayHello","id":1}' -H "Content-Type: application/json"
    2. 服务端日志 ：确保服务端已启动并在监听。在服务端代码中加入更详细的日志，看请求是否到达。
    3. 防火墙/SELinux ：检查服务器和客户端的防火墙设置是否阻止了连接。
    4. 协议格式 ：使用Wireshark或tcpdump抓包，对比客户端发送的JSON数据是否符合规范。特别注意 Content-Type: application/json 头是否正确设置（HTTP模式下）。

• 问题： JsonRpcException 错误，如 Method not found (-32601)

  • 原因 ：客户端调用的方法名与服务端注册的方法名不匹配。
  • 解决 ：
    1. 检查规范文件中的方法名、生成桩代码时的命名、以及客户端调用时的方法名是否完全一致（大小写敏感）。
    2. 检查服务端是否正确地继承并实现了抽象类中的所有方法。
    3. 确保服务端在启动监听前，已经通过父类构造函数将方法绑定好了（通常自动完成）。

5.3 调试与监控

• 开启调试日志 ：libjson-rpc-cpp内部使用了一个简单的日志系统。可以通过设置环境变量或调用 jsonrpc::SetLogLevel 来调整日志级别，输出详细的通信过程，对调试非常有帮助。
• 使用中间件或代理 ：对于HTTP传输，可以在客户端和服务端之间放置一个反向代理（如Nginx），并开启访问日志，方便查看所有进出的请求和响应。
• 指标收集 ：考虑在服务端方法中加入性能统计，记录每个方法的调用次数、耗时、错误率等，集成到Prometheus或类似监控系统中。

5.4 安全考量

• 输入验证 ：虽然桩代码提供了类型提示，但恶意客户端可能发送任意格式的JSON。 永远不要信任客户端传入的 Json::Value 。在服务端方法内部，必须对参数进行严格的验证：检查类型（ isInt() , isObject() 等）、范围、长度等。
• 认证与授权 ：基础的libjson-rpc-cpp不提供内置的认证机制。对于HTTP传输，常见的做法是：
  • API密钥/令牌 ：在HTTP头（如 Authorization: Bearer <token> ）中传递，服务端在处理方法前先验证令牌。
  • HTTPS ：务必在生产环境使用HTTPS（ libmicrohttpd 支持TLS）来加密通信，防止窃听和中间人攻击。
  • 网络层隔离 ：将RPC服务部署在内网，通过API网关对外暴露，在网关上统一做认证、限流和审计。
• 防资源耗尽 ：对客户端发送的JSON大小进行限制，防止巨大的JSON数据导致内存耗尽。可以配置 HttpServer 的相关参数。

5.5 与现有项目集成

• 在大型项目中作为子模块 ：如果你的项目使用CMake，可以将libjson-rpc-cpp作为git子模块（git submodule）添加到你的仓库中，然后通过 add_subdirectory 引入。这样可以锁定特定的版本，保证构建的一致性。
• 封装服务接口 ：不要让你的业务逻辑类直接继承自生成的抽象服务器类。更好的做法是，让你的业务逻辑类保持纯净，然后写一个薄的“适配器”类来继承抽象服务器类，这个适配器类的职责仅仅是转换参数、调用真正的业务逻辑对象、并处理异常。这符合“依赖倒置”原则，使你的核心业务逻辑不依赖于具体的RPC框架。
• 版本化管理接口 ：当你的RPC接口需要变更时（如增加参数、修改方法名），要有明确的版本策略。一种简单的方法是在方法名中包含版本号（如 v1.add ），或者在JSON-RPC请求中增加一个额外的 apiVersion 字段。更复杂的情况可能需要维护多套桩代码和路由逻辑。

libjson-rpc-cpp是一个专注而强大的工具，它完美地解决了C++项目中实现标准、跨语言RPC通信的核心痛点。通过契约先行的桩代码生成和灵活的传输层抽象，它能显著提升开发效率，并让系统架构更加清晰。虽然它不像gRPC那样提供流式处理等高级特性，也不自带服务发现和负载均衡，但对于许多中小型项目、内部微服务、或需要与脚本语言（如Python/JS）便捷交互的C++后端来说，它的简洁、直接和MIT协议的开放性，使其成为一个极具吸引力的选择。在实际使用中，结合良好的工程实践（如输入验证、认证授权、监控日志），它能帮助你构建出稳定可靠的分布式C++应用。