libcurl test

编译库和程序

 ./configure --prefix=/opt/libcurl --without-ssl --without-libpsl
 make && make install
 
 g++ -std=c++11 -I./include -L./lib -lcurl curlTestv2.cp

curlTestv2.cp:

#include <curl/curl.h>
#include <iostream>
#include <memory>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
#include <mutex>

class CurlHttp {
public:
    class RequestBuilder;

    CurlHttp() {
        static std::once_flag curlGlobalInitFlag;
        std::call_once(curlGlobalInitFlag, []() {
            curl_global_init(CURL_GLOBAL_ALL);
        });
    }

    ~CurlHttp() = default;

    CurlHttp(const CurlHttp&) = delete;
    CurlHttp& operator=(const CurlHttp&) = delete;

    static size_t writeCallback(char* ptr, size_t size, size_t nmemb, std::ostringstream* stream) {
        stream->write(ptr, size * nmemb);
        return size * nmemb;
    }

    std::string performRequest(const std::string& url, 
                               const std::string& method, 
                               const std::vector<std::string>& headers,
                               const std::string& body,
                               long timeout = 10) {
        std::unique_ptr<CURL, decltype(&curl_easy_cleanup)> curl(curl_easy_init(), &curl_easy_cleanup);
        if (!curl) {
            throw std::runtime_error("CURL initialization failed");
        }

        curl_easy_setopt(curl.get(), CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl.get(), CURLOPT_CUSTOMREQUEST, method.c_str());
        if (!body.empty()) {
            curl_easy_setopt(curl.get(), CURLOPT_POSTFIELDS, body.c_str());
        }

        struct curl_slist* curlHeaders = nullptr;
        for (const auto& header : headers) {
            curlHeaders = curl_slist_append(curlHeaders, header.c_str());
        }
        curl_easy_setopt(curl.get(), CURLOPT_HTTPHEADER, curlHeaders);
        curl_easy_setopt(curl.get(), CURLOPT_WRITEFUNCTION, writeCallback);
        curl_easy_setopt(curl.get(), CURLOPT_WRITEDATA, &responseStream);

        // 设置超时
        curl_easy_setopt(curl.get(), CURLOPT_TIMEOUT, timeout);

        CURLcode res = curl_easy_perform(curl.get());
        curl_slist_free_all(curlHeaders); // Clean up headers

        if (res != CURLE_OK) {
            throw std::runtime_error(curl_easy_strerror(res));
        }

        return responseStream.str();
    }
private:
    std::ostringstream responseStream;
};

class CurlHttp::RequestBuilder {
    std::string url;
    std::string method = "GET";
    std::vector<std::string> headers;
    std::string body;
    long timeout = 10; // 默认超时为10秒

public:
    RequestBuilder& setUrl(const std::string& url) {
        this->url = url;
        return *this;
    }

    RequestBuilder& setMethod(const std::string& method) {
        this->method = method;
        return *this;
    }

    RequestBuilder& addHeader(const std::string& header) {
        headers.push_back(header);
        return *this;
    }

    RequestBuilder& setBody(const std::string& body) {
        this->body = body;
        return *this;
    }

    RequestBuilder& setTimeout(long timeout) {
        this->timeout = timeout;
        return *this;
    }

    std::string send() {
        CurlHttp http;
        return http.performRequest(url, method, headers, body, timeout);
    }
};


int main() {
    try {
        std::string getUrl = "http://httpbin.org/get?query=example";
        std::string getResponse = CurlHttp::RequestBuilder()
                                    .setUrl(getUrl)
                                    .setMethod("GET")
                                    .addHeader("Accept: application/json")
                                    .send();
        std::cout << "GET Response: \n" << getResponse << "\n\n";
        std::cout <<  "*** -------------------------------------------------------------***" << std::endl;
        std::string response = CurlHttp::RequestBuilder()
                                .setUrl("http://httpbin.org/post")
                                .setMethod("POST")
                                .addHeader("Content-Type: application/json")
                                .setBody(R"({"key-kkk":"value-vvv"})")
                                .send();
        std::cout << "Response: \n" << response << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    curl_global_cleanup();
    return 0;
}