开源库：jcon-cpp

说明

jcon-cpp 是一个用于 C++ 的 JSON-RPC 库，它允许开发者通过 JSON-RPC 协议进行进程间通信（IPC）。JSON-RPC 是一种轻量级的远程过程调用协议，基于 JSON 格式数据进行通信。基于MIT协议，最新代码基于Qt6实现。可通过Tcp和WebSocket实现RPC。

调整源码以适配Qt5

修改json_rpc_server.cpp的doCall函数实现，将QMetaType return_type = QMetaType::fromName(return_type_name)改为int return_type = QMetaType::type(return_type_name)
修改json_rpc_websocket.cpp的setupSocket函数实现，将void (QWebSocket::*errorPtr)(QAbstractSocket::SocketError) = &QWebSocket::errorOccurred;修改为void (QWebSocket::*errorPtr)(QAbstractSocket::SocketError) = &QWebSocket::error;

创建基于TCP的RPC服务器

示例代码

复制代码

jcon::JsonRpcServer* startServer(QObject* parent, SocketType socket_type = SocketType::tcp, bool allow_notifications = false)
{
    jcon::JsonRpcServer* rpc_server;
    if (socket_type == SocketType::tcp) {
        qDebug() << "Starting TCP server";
        rpc_server = new jcon::JsonRpcTcpServer(parent);
    } else {
        qDebug() << "Starting WebSocket server";
        rpc_server = new jcon::JsonRpcWebSocketServer(parent);
    }

    if (allow_notifications)
        rpc_server->enableSendNotification(true);

    auto service1 = new ExampleService;
    auto service2 = new NotificationService;

    rpc_server->registerServices({ service1, service2 });
    rpc_server->listen(6002);
    return rpc_server;
}

auto server = startServer(nullptr, SocketType::tcp);
//do something 
delete server;

说明

rpc_server->enableSendNotification(true)，用于设置RPC服务器是否可以主动推送消息给客户端

ExampleService、NotificationService都是QObject子类，通过元对象系统来定义、存储、调用相关接口，所以接口前需要定义成Q_INVOKABLE

复制代码

#pragma once
#include <QObject>

class ExampleService : public QObject
{
    Q_OBJECT

public:
    ExampleService();
    virtual ~ExampleService();

    Q_INVOKABLE int getRandomInt(int limit);
    Q_INVOKABLE QString printMessage(const QString& msg);
    Q_INVOKABLE void printNotification(const QString& msg);
    Q_INVOKABLE void namedParams(QString& msg, int answer);
};

rpc_server->registerServices，将接口服务类注册到RPC服务器中，有两种方式：注册普通服务、注册命名空间服务。

复制代码

//注册普通服务
//m_services结构为QMap<QObject*, QString>，此时key存储的是QObject接口类，value为空
void JsonRpcServer::registerServices(const QObjectList& services)
{
    m_services.clear();

    for (auto s : services) {
        m_services[s] = "";
    }
    m_ns_separator = "";
}

//调用
auto service1 = new ExampleService;
auto service2 = new NotificationService;
rpc_server->registerServices({ service1, service2 });

//注册命名空间服务
//m_services结构为QMap<QObject*, QString>，此时key存储的是QObject接口类，value为对应服务的命名空间字符串
//ns_separator是一个用于分隔命名空间和方法名的字符串，默认为 /
void JsonRpcServer::registerServices(const ServiceMap& services,
                                     const QString& ns_separator)
{
    m_services = services;
    m_ns_separator = ns_separator;
}

//调用
auto service1 = new ExampleService;
auto service2 = new OtherService;
auto service3 = new NotificationService;
rpc_server->registerServices(
{
	{ service1, "ex/myFirstNamespace" },
	{ service2, "ex/myOtherNamespace" },
	{ service3, "ex/myNotificationNamespace" }
}, "/");

rpc_server->listen(6002)监听某端口，JsonRpcServer有两个子类：JsonRpcTcpServer、JsonRpcWebSocketServer，JsonRpcTcpServer实际就是实现了一个QTcpServer监听端口、客户端连接时创建Socket对象、Socket有请求时通过元对象系统找到对应的函数执行并返回结果

复制代码

/*class JsonRpcTcpServer*/

//1.JsonRpcTcpServer构造函数，处理客户端连接
m_server.connect(&m_server, &QTcpServer::newConnection, this, &JsonRpcTcpServer::newConnection);

//2.JsonRpcTcpServer::newConnection，创建相关通信对象
QTcpSocket* tcp_socket = m_server.nextPendingConnection();
auto rpc_socket = std::make_shared<JsonRpcTcpSocket>(tcp_socket);
auto endpoint = std::shared_ptr<JsonRpcEndpoint>(new JsonRpcEndpoint(rpc_socket, log(), this), [this](JsonRpcEndpoint* obj) {
	if (this->m_server.isListening()) {
		obj->deleteLater();
	} else {
		delete obj;
	}
});
connect(endpoint.get(), &JsonRpcEndpoint::jsonObjectReceived, this, &JsonRpcServer::jsonRequestReceived);

//3.JsonRpcServer::jsonRequestReceived，处理客户端请求
//request是请求数据，json格式；socket是对应的通信对象
void JsonRpcServer::jsonRequestReceived(const QJsonObject& request, QObject* socket)
{
	//校验json的key:jsonrpc
	if (request.value("jsonrpc").toString() != "2.0") {
        logError("invalid protocol tag");
        return;
	}
	//获取json的key:method
	QString method_name = request.value("method").toString();
	//获取json的key:params
	QVariant params = request.value("params").toVariant();
	//获取json的key:id
	QString request_id = request.value("id").toVariant().toString();
	
	//从存储的元对象中找到对应的函数并执行
	dispatch(method_name, params, return_value)
}

创建基于TCP的RPC客户端

示例代码

复制代码

jcon::JsonRpcClient* startClient(QObject* parent,
                                 SocketType socket_type = SocketType::tcp,
                                 bool allow_notifications = false)
{
    jcon::JsonRpcClient* rpc_client;
    if (socket_type == SocketType::tcp) {
        rpc_client = new jcon::JsonRpcTcpClient(parent);
        rpc_client->connectToServer("127.0.0.1", 6002);
    } else {
        rpc_client = new jcon::JsonRpcWebSocketClient(parent);
        // This is just to illustrate the fact that connectToServer also accepts
        // a QUrl argument.
        rpc_client->connectToServer(QUrl("ws://127.0.0.1:6002"));
    }

    if (allow_notifications)
        rpc_client->enableReceiveNotification(true);

    return rpc_client;
}

auto rpc_client = startClient(&app, SocketType::tcp);

说明

调用通知类接口，无返回，通过函数名调用

rpc_client->notification("printNotification", "hello, notification");
异步调用接口，有返回，通过函数名调用

auto req = rpc_client->callAsync("getRandomInt", 10);

req->connect(req.get(), &jcon::JsonRpcRequest::result,
[](const QVariant& result) {
qDebug() << "result of asynchronous RPC call:" << result;
});

req->connect(req.get(), &jcon::JsonRpcRequest::error,
[](int code, const QString& message) {
qDebug() << "RPC error:" << message
<< " (" << code << ")";
});
同步调用接口，有返回，通过函数名调用

auto result = rpc_client->call("getRandomInt", 100);

if (result->isSuccess()) {
qDebug() << "result of synchronous RPC call:" << result->result();
} else {
qDebug() << "RPC error:" << result->toString();
}

//call里通过事件循环等待完成
异步调用接口，参数命名化方式，有返回，通过函数名调用

//将参数存入QVariantMap，参数1是msg，参数2是answer
auto req = rpc_client->callAsyncNamedParams("namedParams",
QVariantMap{
{"msg", "hello, world"},
{"answer", 42}
});

req->connect(req.get(), &jcon::JsonRpcRequest::result,
[](const QVariant& result) {
qDebug() << "result of asynchronous RPC call:" << result;
});

req->connect(req.get(), &jcon::JsonRpcRequest::error,
[](int code, const QString& message) {
qDebug() << "RPC error:" << message
<< " (" << code << ")";
});