C++ 게임 서버에서 JSON-RPC 프로토콜로 클라이언트와 통신하기

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": {
    "name": "PlayerOne",
    "level": 42,
    "score": 98765
  },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32601,
    "message": "Method not found"
  },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": {
    "name": "PlayerOne",
    "level": 42,
    "score": 98765
  },
  "id": 1
}

[
  {
    "jsonrpc": "2.0",
    "method": "getPlayerInfo",
    "params": { "playerId": 12345 },
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "method": "getLeaderboard",
    "params": { "gameMode": "ranked" },
    "id": 2
  }
]

[
  {
    "jsonrpc": "2.0",
    "result": {
      "name": "PlayerOne",
      "level": 42,
      "score": 98765
    },
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "result": [
      { "name": "PlayerTwo", "score": 120000 },
      { "name": "PlayerOne", "score": 98765 }
    ],
    "id": 2
  }
]

sudo apt install libjsonrpccpp-dev

#include <jsonrpccpp/server/connectors/httpserver.h>
#include <jsonrpccpp/server.h>
#include <json/json.h>
#include <iostream>

using namespace jsonrpc;
using namespace std;

// JSON-RPC 서버 클래스 정의
class GameServer : public AbstractServer<GameServer> {
public:
    GameServer(HttpServer &server) : AbstractServer<GameServer>(server) {
        this->bindAndAddMethod(Procedure("getPlayerInfo", PARAMS_BY_NAME, "playerId", Json::integerValue, NULL), &GameServer::getPlayerInfo);
    }

    void getPlayerInfo(const Json::Value &request, Json::Value &response) {
        int playerId = request["playerId"].asInt();
        cout << "Received request for Player ID: " << playerId << endl;

        // 가상의 플레이어 정보 반환
        response["name"] = "PlayerOne";
        response["level"] = 42;
        response["score"] = 98765;
    }
};

int main() {
    HttpServer server(8080);  // 8080 포트에서 HTTP 서버 실행
    GameServer gameServer(server);

    cout << "JSON-RPC 서버 실행 중..." << endl;
    gameServer.StartListening();

    // 서버를 종료하려면 Enter 키 입력
    getchar();
    gameServer.StopListening();
    return 0;
}

curl -X POST http://localhost:8080 -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}'

{
  "jsonrpc": "2.0",
  "result": {
    "name": "PlayerOne",
    "level": 42,
    "score": 98765
  },
  "id": 1
}

this->bindAndAddMethod(Procedure("getLeaderboard", PARAMS_BY_NAME, NULL), &GameServer::getLeaderboard);

void getLeaderboard(const Json::Value &request, Json::Value &response) {
    Json::Value players(Json::arrayValue);

    Json::Value player1;
    player1["name"] = "PlayerOne";
    player1["score"] = 98765;

    Json::Value player2;
    player2["name"] = "PlayerTwo";
    player2["score"] = 120000;

    players.append(player2);
    players.append(player1);

    response["leaderboard"] = players;
}

sudo apt install libjsonrpccpp-dev

vcpkg install json-rpc-cpp

#include <jsonrpccpp/client/connectors/httpclient.h>
#include <jsonrpccpp/client.h>
#include <json/json.h>
#include <iostream>

using namespace jsonrpc;
using namespace std;

int main() {
    // JSON-RPC 서버 주소 지정
    HttpClient httpClient("http://localhost:8080");
    Client client(httpClient, jsonrpc::JSONRPC_CLIENT_V2);

    try {
        // getPlayerInfo 요청 생성
        Json::Value params;
        params["playerId"] = 12345;

        // 서버로 요청을 전송하고 응답을 받음
        Json::Value response = client.CallMethod("getPlayerInfo", params);

        // 응답 출력
        cout << "Player Name: " << response["name"].asString() << endl;
        cout << "Level: " << response["level"].asInt() << endl;
        cout << "Score: " << response["score"].asInt() << endl;
    } catch (const JsonRpcException &e) {
        cerr << "JSON-RPC 오류 발생: " << e.GetMessage() << endl;
    }

    return 0;
}

Player Name: PlayerOne
Level: 42
Score: 98765

try {
    Json::Value batchRequests(Json::arrayValue);

    Json::Value request1;
    request1["jsonrpc"] = "2.0";
    request1["method"] = "getPlayerInfo";
    request1["params"]["playerId"] = 12345;
    request1["id"] = 1;
    batchRequests.append(request1);

    Json::Value request2;
    request2["jsonrpc"] = "2.0";
    request2["method"] = "getLeaderboard";
    request2["id"] = 2;
    batchRequests.append(request2);

    Json::Value response = client.CallMethod("batch", batchRequests);

    cout << "Batch Response: " << response.toStyledString() << endl;

} catch (const JsonRpcException &e) {
    cerr << "JSON-RPC 오류 발생: " << e.GetMessage() << endl;
}

#include <thread>

void asyncRequest(HttpClient &httpClient) {
    Client client(httpClient, jsonrpc::JSONRPC_CLIENT_V2);

    Json::Value params;
    params["playerId"] = 12345;

    try {
        Json::Value response = client.CallMethod("getPlayerInfo", params);
        cout << "[Async] Player Name: " << response["name"].asString() << endl;
    } catch (const JsonRpcException &e) {
        cerr << "[Async] 오류 발생: " << e.GetMessage() << endl;
    }
}

int main() {
    HttpClient httpClient("http://localhost:8080");

    // 별도 스레드에서 JSON-RPC 요청 실행
    thread asyncThread(asyncRequest, ref(httpClient));

    // 메인 스레드에서 다른 작업 수행
    cout << "메인 스레드는 다른 작업을 수행 중..." << endl;

    asyncThread.join();  // 비동기 스레드 종료 대기
    return 0;
}

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": {
    "name": "PlayerOne",
    "level": 42,
    "score": 98765
  },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32601,
    "message": "Method not found"
  },
  "id": 1
}

void unknownMethod(const Json::Value &request, Json::Value &response) {
    throw JsonRpcException(-32601, "Method not found");
}

#include <jsonrpccpp/server/connectors/httpserver.h>
#include <jsonrpccpp/server.h>
#include <json/json.h>
#include <iostream>

using namespace jsonrpc;
using namespace std;

class GameServer : public AbstractServer<GameServer> {
public:
    GameServer(HttpServer &server) : AbstractServer<GameServer>(server) {
        this->bindAndAddMethod(Procedure("getPlayerInfo", PARAMS_BY_NAME, "playerId", Json::integerValue, NULL), &GameServer::getPlayerInfo);
    }

    void getPlayerInfo(const Json::Value &request, Json::Value &response) {
        try {
            if (!request.isMember("playerId")) {
                throw JsonRpcException(-32602, "Invalid params: 'playerId' is required");
            }

            int playerId = request["playerId"].asInt();
            if (playerId <= 0) {
                throw JsonRpcException(-32000, "Invalid player ID");
            }

            // 가상의 플레이어 정보 반환
            response["name"] = "PlayerOne";
            response["level"] = 42;
            response["score"] = 98765;
        } catch (const JsonRpcException &e) {
            throw e;  // JSON-RPC 오류 응답 반환
        } catch (...) {
            throw JsonRpcException(-32603, "Internal server error");
        }
    }
};

int main() {
    HttpServer server(8080);
    GameServer gameServer(server);

    cout << "JSON-RPC 서버 실행 중..." << endl;
    gameServer.StartListening();
    getchar();
    gameServer.StopListening();
    return 0;
}

#include <jsonrpccpp/client/connectors/httpclient.h>
#include <jsonrpccpp/client.h>
#include <json/json.h>
#include <iostream>

using namespace jsonrpc;
using namespace std;

int main() {
    HttpClient httpClient("http://localhost:8080");
    Client client(httpClient, jsonrpc::JSONRPC_CLIENT_V2);

    try {
        Json::Value params;
        params["playerId"] = -1;  // 잘못된 ID

        Json::Value response = client.CallMethod("getPlayerInfo", params);
        cout << "Player Name: " << response["name"].asString() << endl;
    } catch (const JsonRpcException &e) {
        cerr << "JSON-RPC 오류 발생: " << e.GetMessage() << endl;
    } catch (const exception &e) {
        cerr << "일반 예외 발생: " << e.what() << endl;
    } catch (...) {
        cerr << "알 수 없는 오류 발생" << endl;
    }

    return 0;
}

JSON-RPC 오류 발생: Invalid player ID

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32600,
    "message": "Invalid Request"
  },
  "id": null
}

#include <jsonrpccpp/server/connectors/httpserver.h>
#include <jsonrpccpp/server.h>
#include <json/json.h>
#include <iostream>
#include <thread>
#include <future>

using namespace jsonrpc;
using namespace std;

class AsyncGameServer : public AbstractServer<AsyncGameServer> {
public:
    AsyncGameServer(HttpServer &server) : AbstractServer<AsyncGameServer>(server) {
        this->bindAndAddMethod(Procedure("getPlayerInfo", PARAMS_BY_NAME, "playerId", Json::integerValue, NULL),
                               &AsyncGameServer::getPlayerInfo);
    }

    void getPlayerInfo(const Json::Value &request, Json::Value &response) {
        int playerId = request["playerId"].asInt();
        cout << "Received request for Player ID: " << playerId << endl;

        // 비동기 처리를 위해 std::async 사용
        auto futureResult = async(launch::async, [playerId]() {
            Json::Value result;
            this_thread::sleep_for(chrono::seconds(2));  // 2초 동안 지연(데이터베이스 조회 시뮬레이션)
            result["name"] = "PlayerOne";
            result["level"] = 42;
            result["score"] = 98765;
            return result;
        });

        response = futureResult.get();  // 비동기 결과를 받아 응답
    }
};

int main() {
    HttpServer server(8080);
    AsyncGameServer gameServer(server);

    cout << "비동기 JSON-RPC 서버 실행 중..." << endl;
    gameServer.StartListening();
    getchar();  // 엔터 키 입력 시 종료
    gameServer.StopListening();
    return 0;
}

curl -X POST http://localhost:8080 -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}'

{
  "jsonrpc": "2.0",
  "result": {
    "name": "PlayerOne",
    "level": 42,
    "score": 98765
  },
  "id": 1
}

#include <boost/asio.hpp>
#include <jsonrpccpp/server/connectors/httpserver.h>
#include <jsonrpccpp/server.h>
#include <json/json.h>
#include <iostream>
#include <thread>

using namespace jsonrpc;
using namespace std;
using namespace boost::asio;

class ThreadPoolGameServer : public AbstractServer<ThreadPoolGameServer> {
public:
    ThreadPoolGameServer(HttpServer &server, io_context &ioc)
        : AbstractServer<ThreadPoolGameServer>(server), ioc_(ioc) {
        this->bindAndAddMethod(Procedure("getPlayerInfo", PARAMS_BY_NAME, "playerId", Json::integerValue, NULL),
                               &ThreadPoolGameServer::getPlayerInfo);
    }

    void getPlayerInfo(const Json::Value &request, Json::Value &response) {
        int playerId = request["playerId"].asInt();
        cout << "Processing request for Player ID: " << playerId << endl;

        // 스레드 풀에서 비동기 처리
        post(ioc_, [this, playerId, &response]() {
            this_thread::sleep_for(chrono::seconds(2));  // 데이터 조회 시뮬레이션
            response["name"] = "PlayerOne";
            response["level"] = 42;
            response["score"] = 98765;
        });
    }

private:
    io_context &ioc_;
};

int main() {
    HttpServer server(8080);
    io_context ioc;
    ThreadPoolGameServer gameServer(server, ioc);

    // 스레드 풀 생성 (4개 스레드 사용)
    vector<thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back([&ioc]() { ioc.run(); });
    }

    cout << "멀티스레드 JSON-RPC 서버 실행 중..." << endl;
    gameServer.StartListening();

    getchar();  // 엔터 키 입력 시 종료
    gameServer.StopListening();
    ioc.stop();
    for (auto &t : threads) {
        t.join();
    }

    return 0;
}

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": {
    "playerId": 12345,
    "apiKey": "secret_api_key"
  },
  "id": 1
}

void getPlayerInfo(const Json::Value &request, Json::Value &response) {
    if (!request.isMember("apiKey") || request["apiKey"].asString() != "secret_api_key") {
        throw JsonRpcException(-32001, "Invalid API Key");
    }

    int playerId = request["playerId"].asInt();
    response["name"] = "PlayerOne";
    response["level"] = 42;
    response["score"] = 98765;
}

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": { "playerId": 12345 },
  "id": 1
}

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

#include <jsonrpccpp/server/connectors/httpsserver.h>

HttpsServer httpsServer(8443, "server-cert.pem", "server-key.pem");
GameServer gameServer(httpsServer);
gameServer.StartListening();

{
  "jsonrpc": "2.0",
  "method": "getPlayerInfo",
  "params": {
    "playerId": 12345,
    "hmac": "f2d6c69a36d1dfc24e60e90a348d78b2"
  },
  "id": 1
}

#include <map>
#include <chrono>

map<string, int> requestCount;
const int MAX_REQUESTS_PER_MIN = 100;

bool isRateLimited(string ip) {
    auto now = chrono::system_clock::now();
    requestCount[ip]++;

    if (requestCount[ip] > MAX_REQUESTS_PER_MIN) {
        return true;
    }
    return false;
}

#include <future>

void getPlayerInfoAsync(const Json::Value &request, Json::Value &response) {
    auto futureResult = std::async(std::launch::async, [&]() {
        Json::Value result;
        this_thread::sleep_for(chrono::milliseconds(50)); // 데이터 조회 시뮬레이션
        result["name"] = "PlayerOne";
        result["level"] = 42;
        result["score"] = 98765;
        return result;
    });

    response = futureResult.get();
}

[
  {
    "jsonrpc": "2.0",
    "method": "getPlayerInfo",
    "params": { "playerId": 12345 },
    "id": 1
  },
  {
    "jsonrpc": "2.0",
    "method": "getLeaderboard",
    "id": 2
  }
]

#include <thread>

void handleRequest(int playerId) {
    cout << "Processing request for Player ID: " << playerId << endl;
    this_thread::sleep_for(chrono::milliseconds(100));  // 데이터 조회 시뮬레이션
}

int main() {
    vector<thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(handleRequest, 12345 + i);
    }

    for (auto &t : threads) {
        t.join();
    }
    return 0;
}

#include <boost/asio.hpp>
using namespace boost::asio;

io_service service;
ip::tcp::socket socket(service);

#include <nlohmann/json.hpp>
using json = nlohmann::json;

json j = {{"playerId", 12345}, {"level", 42}};
cout << j.dump() << endl;

#include <unordered_map>

unordered_map<int, Json::Value> playerCache;

Json::Value getCachedPlayerInfo(int playerId) {
    if (playerCache.find(playerId) != playerCache.end()) {
        return playerCache[playerId];
    }

    // DB 조회 후 캐싱
    Json::Value player;
    player["name"] = "PlayerOne";
    player["level"] = 42;
    player["score"] = 98765;
    playerCache[playerId] = player;

    return player;
}

#include <spdlog/spdlog.h>

spdlog::info("Received JSON-RPC request: {}", request.toStyledString());