求推荐C/C++开发可接收JSON并转发修改后JSON的REST WebService资料

Hey there! Let's break down how to build this C/C++ REST service that receives JSON, modifies it, and forwards it to another endpoint. I'll walk you through the key components, top libraries to use, and a basic implementation outline to get you started.

To pull this off, you'll need three core parts:

• An HTTP server to receive incoming JSON requests
• A JSON processing library to parse and modify the payload
• An HTTP client to send the modified JSON to the target service

These are industry-standard tools with clear, practical documentation to help you build your service efficiently:

HTTP Server Options #

• libmicrohttpd: A lightweight, cross-platform library perfect for small to mid-sized REST services. Its official docs include step-by-step examples for handling POST requests—you can directly follow the "Handling POST Data" section to learn how to read JSON from the request body.
• Pistache: A modern, C++-style HTTP framework with native support for RESTful routing. Its tutorials have dedicated POST request handling examples, making it easy to extract JSON payloads. It also comes with helper tools for JSON serialization/deserialization, which simplifies your workflow.

JSON Processing Libraries #

• nlohmann/json: Hands down one of the most user-friendly JSON libraries for C++. It's header-only (no compilation/linking needed—just include the header file) and has an API as intuitive as Python dictionaries. The docs are packed with examples: parsing JSON strings, modifying existing fields, adding new key-value pairs, and generating updated JSON output.
• cJSON: A lightweight C-language library with minimal memory footprint, ideal for resource-constrained environments. Its guides cover everything from parsing JSON objects to modifying node values and generating new JSON strings—perfect if you're working on a pure C project.

HTTP Client for Forwarding #

• libcurl: A veteran cross-platform HTTP client that supports nearly all HTTP features. You can use it to send POST requests with your modified JSON as the request body. The official examples include an "HTTP POST with JSON" snippet that you can adapt directly for your use case.
• cpp-httplib: A lightweight C++ library that supports both HTTP server and client functionality. If you want to minimize dependencies, using it for both receiving and forwarding requests is a great choice. Its docs have clear examples of sending JSON payloads via client requests.

Here's a simplified example using Pistache (server), nlohmann/json (processing), and cpp-httplib (client) to give you a starting point:

#include <pistache/endpoint.h>
#include <nlohmann/json.hpp>
#include <httplib.h>
#include <stdexcept>

using namespace Pistache;
using json = nlohmann::json;

// Handle incoming POST requests with JSON payload
void processAndForward(const Rest::Request& req, Http::ResponseWriter res) {
    try {
        // Parse the received JSON from request body
        json inputJson = json::parse(req.body());

        // Modify the JSON (customize this to your needs)
        inputJson["status"] = "processed";
        if (inputJson.contains("data")) {
            inputJson["data"]["modified_at"] = "2024-05-20T12:00:00Z";
        }

        // Forward modified JSON to target service
        httplib::Client targetClient("http://your-target-service.com");
        auto forwardResponse = targetClient.Post(
            "/api/forward-endpoint",
            inputJson.dump(),
            "application/json"
        );

        // Send response back to original requester
        if (forwardResponse) {
            res.send(Http::Code::Ok, forwardResponse->body, MIME(Application, Json));
        } else {
            res.send(Http::Code::Bad_Gateway, R"({"error":"Failed to forward request"})", MIME(Application, Json));
        }
    } catch (const json::parse_error&) {
        res.send(Http::Code::Bad_Request, R"({"error":"Invalid JSON format"})", MIME(Application, Json));
    } catch (const std::exception& e) {
        res.send(Http::Code::Internal_Server_Error, R"({"error":"Server error"})", MIME(Application, Json));
    }
}

int main() {
    // Initialize and start the HTTP server
    Http::Endpoint server(Pistache::Address("0.0.0.0", 8080));
    auto serverOpts = Http::Endpoint::options().threads(2);
    server.init(serverOpts);

    // Set up REST route
    Rest::Router router;
    Rest::Routes::Post(router, "/api/receive-json", Rest::Routes::bind(&processAndForward));

    server.setHandler(router.handler());
    server.serve();

    return 0;
}

A few quick notes:

• Make sure to install the required libraries first (most are available via package managers like apt or brew, or via vcpkg for cross-platform setups)
• Expand the error handling to match your production needs (e.g., timeouts for the target service, validation of input JSON fields)

内容的提问来源于stack exchange，提问作者kittu