C++ Windows 网络请求库设计

于 2025-07-18 10:57:06 发布
阅读量174 收藏 1
点赞数 3
CC 4.0 BY-SA版权
文章标签： c++ windows 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Giser_D/article/details/149440233 
#pragma once

#include <string>
#include <map>
#include <vector>
#include <functional>
#include <memory>
#include <future>
#include <chrono>

namespace HttpRequestUtil {

	// 前向声明
	class Interceptor;
	class Request;
	class Response;
	class HttpRequestImpl;

	// 请求方法枚举
	enum class Method {
		GET,
		POST,
		PUT,
		DELETE_,
		PATCH,
		HEAD,
		OPTIONS
	};

	// 重试配置结构
	struct RetryConfig {
		int maxRetries = 3;           // 最大重试次数
		int retryDelay = 1000;        // 重试间隔(毫秒)
		bool retryOnTimeout = true;   // 超时时是否重试
		bool retryOnConnectionError = true;  // 连接错误时是否重试
		bool retryOnServerError = false;     // 服务器错误时是否重试
		std::function<bool(const Response&)> shouldRetry = nullptr;  // 自定义重试条件
	};

	// 请求配置结构
	struct RequestConfig {
		std::string url;
		Method method = Method::GET;
		std::map<std::string, std::string> headers;
		std::string data;  // 请求体数据
		std::map<std::string, std::string> params;  // URL参数
		int timeout = 30000;  // 超时时间(毫秒)
		bool followRedirects = true;
		int maxRedirects = 5;
		std::string userAgent = "HttpRequest/1.0";
		bool verifySSL = true;
		std::string proxy;
		std::string proxyAuth;
		RetryConfig retryConfig;  // 重试配置
	};

	// 响应结构
	struct Response {
		int statusCode = 0;
		std::wstring statusText;
		std::map<std::wstring, std::wstring> headers;
		std::wstring data;
		std::wstring url;
		bool success = false;
		std::wstring error;

		// 便捷方法
		bool isOk() const { return statusCode >= 200 && statusCode < 300; }
		bool isRedirect() const { return statusCode >= 300 && statusCode < 400; }
		bool isClientError() const { return statusCode >= 400 && statusCode < 500; }
		bool isServerError() const { return statusCode >= 500 && statusCode < 600; }
	};

	// 拦截器接口
	class Interceptor {
	public:
		virtual ~Interceptor() = default;

		// 请求拦截器
		virtual bool onRequest(RequestConfig& config) = 0;

		// 响应拦截器
		virtual bool onResponse(Response& response) = 0;

		// 错误拦截器
		virtual bool onError(const std::wstring& error) = 0;
	};

	// 业务拦截器基类
	class BusinessInterceptor : public Interceptor {
	public:
		virtual ~BusinessInterceptor() = default;
	};

	// 通用拦截器基类
	class CommonInterceptor : public Interceptor {
	public:
		virtual ~CommonInterceptor() = default;
	};

	// 主HttpRequest类
	class HttpRequest {
	public:
		HttpRequest();
		~HttpRequest();

		// 禁用拷贝
		HttpRequest(const HttpRequest&) = delete;
		HttpRequest& operator=(const HttpRequest&) = delete;

		// 允许移动
		HttpRequest(HttpRequest&&) noexcept;
		HttpRequest& operator=(HttpRequest&&) noexcept;

		// 同步请求方法
		Response get(const std::string& url, const std::map<std::string, std::string>& params = {});
		Response post(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		Response put(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		Response delete_(const std::string& url, const std::map<std::string, std::string>& headers = {});
		Response patch(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});

		// 通用请求方法
		Response request(const RequestConfig& config);

		// 异步请求方法
		std::future<Response> getAsync(const std::string& url, const std::map<std::string, std::string>& params = {});
		std::future<Response> postAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		std::future<Response> putAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		std::future<Response> deleteAsync(const std::string& url, const std::map<std::string, std::string>& headers = {});
		std::future<Response> patchAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		std::future<Response> requestAsync(const RequestConfig& config);

		// 拦截器管理
		void addInterceptor(std::shared_ptr<Interceptor> interceptor);
		void addBusinessInterceptor(std::shared_ptr<BusinessInterceptor> interceptor);
		void addCommonInterceptor(std::shared_ptr<CommonInterceptor> interceptor);
		void removeInterceptor(std::shared_ptr<Interceptor> interceptor);
		void clearInterceptors();

		// 全局配置
		void setDefaultTimeout(int timeout);
		void setDefaultHeaders(const std::map<std::string, std::string>& headers);
		void setUserAgent(const std::string& userAgent);
		void setProxy(const std::string& proxy, const std::string& auth = "");
		void setSSLVerification(bool verify);
		void setDefaultRetryConfig(const RetryConfig& retryConfig);

		// 便捷方法
		static std::string methodToString(Method method);
		static Method stringToMethod(const std::string& method);

	private:
		std::unique_ptr<HttpRequestImpl> pImpl;
	};

	// 全局便捷函数
	namespace http {
		// 创建HttpRequest实例
		std::shared_ptr<HttpRequest> create();

		// 静态便捷方法
		Response get(const std::string& url, const std::map<std::string, std::string>& params = {});
		Response post(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		Response put(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		Response delete_(const std::string& url, const std::map<std::string, std::string>& headers = {});
		Response patch(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});

		// 异步便捷方法
		std::future<Response> getAsync(const std::string& url, const std::map<std::string, std::string>& params = {});
		std::future<Response> postAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		std::future<Response> putAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
		std::future<Response> deleteAsync(const std::string& url, const std::map<std::string, std::string>& headers = {});
		std::future<Response> patchAsync(const std::string& url, const std::string& data = "", const std::map<std::string, std::string>& headers = {});
	}

} // namespace HttpRequest

实现文件：

#include "HttpRequest.h"
#include <windows.h>
#include <winhttp.h>
#include <sstream>
#include <algorithm>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <queue>
#include <atomic>

#pragma comment(lib, "winhttp.lib")

namespace HttpRequestUtil {

	// 内部实现类
	class HttpRequestImpl {
	public:
		HttpRequestImpl() : defaultTimeout(30000), verifySSL(true) {
			// 初始化默认头
			defaultHeaders["User-Agent"] = "HttpRequest/1.0";
			defaultHeaders["Accept"] = "*/*";
			defaultHeaders["Accept-Encoding"] = "gzip, deflate";

			// 初始化默认重试配置
			defaultRetryConfig.maxRetries = 3;
			defaultRetryConfig.retryDelay = 1000;
			defaultRetryConfig.retryOnTimeout = true;
			defaultRetryConfig.retryOnConnectionError = true;
			defaultRetryConfig.retryOnServerError = false;
		}

		~HttpRequestImpl() = default;

		// 同步请求实现
		Response request(const RequestConfig& config) {
			RequestConfig finalConfig = config;

			// 应用默认配置
			if (finalConfig.timeout == 30000) {
				finalConfig.timeout = defaultTimeout;
			}

			// 应用默认重试配置
			if (finalConfig.retryConfig.maxRetries == 3 &&
				finalConfig.retryConfig.retryDelay == 1000) {
				finalConfig.retryConfig = defaultRetryConfig;
			}

			// 合并默认头
			for (const auto& header : defaultHeaders) {
				if (finalConfig.headers.find(header.first) == finalConfig.headers.end()) {
					finalConfig.headers[header.first] = header.second;
				}
			}

			// 运行请求拦截器
			runRequestInterceptors(finalConfig);

			// 执行带重试的请求
			Response response = performRequestWithRetry(finalConfig);

			// 运行响应拦截器
			runResponseInterceptors(response);

			return response;
		}

		// 异步请求实现
		std::future<Response> requestAsync(const RequestConfig& config) {
			return std::async(std::launch::async, [this, config]() {
				return this->request(config);
			});
		}

		// 拦截器管理
		void addInterceptor(std::shared_ptr<Interceptor> interceptor) {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			interceptors.push_back(interceptor);
		}

		void removeInterceptor(std::shared_ptr<Interceptor> interceptor) {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			interceptors.erase(
				std::remove(interceptors.begin(), interceptors.end(), interceptor),
				interceptors.end()
				);
		}

		void clearInterceptors() {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			interceptors.clear();
		}

		// 配置管理
		void setDefaultTimeout(int timeout) { defaultTimeout = timeout; }
		void setDefaultHeaders(const std::map<std::string, std::string>& headers) { defaultHeaders = headers; }
		void setUserAgent(const std::string& userAgent) { defaultHeaders["User-Agent"] = userAgent; }
		void setProxy(const std::string& proxy, const std::string& auth) {
			this->proxy = proxy;
			this->proxyAuth = auth;
		}
		void setSSLVerification(bool verify) { verifySSL = verify; }
		void setDefaultRetryConfig(const RetryConfig& retryConfig) { defaultRetryConfig = retryConfig; }

	private:
		// 执行HTTP请求的核心方法
		Response performRequest(const RequestConfig& config) {
			Response response;

			// 解析URL
			URL_COMPONENTS urlComp = { 0 };
			urlComp.dwStructSize = sizeof(URL_COMPONENTS);
			urlComp.dwSchemeLength = -1;
			urlComp.dwHostNameLength = -1;
			urlComp.dwUrlPathLength = -1;

			std::wstring wUrl = std::wstring(config.url.begin(), config.url.end());
			if (!WinHttpCrackUrl(wUrl.c_str(), 0, 0, &urlComp)) {
				throw std::runtime_error("Invalid URL");
			}

			// 构建完整URL（包含查询参数）
			std::string fullUrl = config.url;
			if (!config.params.empty()) {
				fullUrl += "?";
				bool first = true;
				for (const auto& param : config.params) {
					if (!first) fullUrl += "&";
					fullUrl += param.first + "=" + param.second;
					first = false;
				}
			}

			// 创建会话
			HINTERNET hSession = WinHttpOpen(
				L"HttpRequest/1.0",
				WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
				WINHTTP_NO_PROXY_NAME,
				WINHTTP_NO_PROXY_BYPASS,
				0
				);

			if (!hSession) {
				throw std::runtime_error("Failed to create WinHTTP session");
			}

			// 设置超时
			WinHttpSetTimeouts(hSession, config.timeout, config.timeout, config.timeout, config.timeout);

			// 设置SSL选项
			if (!verifySSL) {
				DWORD flags = SECURITY_FLAG_IGNORE_UNKNOWN_CA |
					SECURITY_FLAG_IGNORE_CERT_DATE_INVALID |
					SECURITY_FLAG_IGNORE_CERT_CN_INVALID;
				WinHttpSetOption(hSession, WINHTTP_OPTION_SECURITY_FLAGS, &flags, sizeof(flags));
			}

			// 连接服务器
			HINTERNET hConnect = WinHttpConnect(
				hSession,
				urlComp.lpszHostName,
				urlComp.nPort,
				0
				);

			if (!hConnect) {
				WinHttpCloseHandle(hSession);
				throw std::runtime_error("Failed to connect to server");
			}

			// 创建请求
			std::wstring methodStr;
			switch (config.method) {
			case Method::GET: methodStr = L"GET"; break;
			case Method::POST: methodStr = L"POST"; break;
			case Method::PUT: methodStr = L"PUT"; break;
			case Method::DELETE_: methodStr = L"DELETE"; break;
			case Method::PATCH: methodStr = L"PATCH"; break;
			case Method::HEAD: methodStr = L"HEAD"; break;
			case Method::OPTIONS: methodStr = L"OPTIONS"; break;
			default: methodStr = L"GET"; break;
			}

			HINTERNET hRequest = WinHttpOpenRequest(
				hConnect,
				methodStr.c_str(),
				urlComp.lpszUrlPath,
				nullptr,
				WINHTTP_NO_REFERER,
				WINHTTP_DEFAULT_ACCEPT_TYPES,
				(urlComp.nScheme == INTERNET_SCHEME_HTTPS) ? WINHTTP_FLAG_SECURE : 0
				);

			if (!hRequest) {
				WinHttpCloseHandle(hConnect);
				WinHttpCloseHandle(hSession);
				throw std::runtime_error("Failed to create request");
			}

			// 设置请求头
			for (const auto& header : config.headers) {
				std::wstring wHeader = std::wstring(header.first.begin(), header.first.end()) + L": " +
					std::wstring(header.second.begin(), header.second.end());
				WinHttpAddRequestHeaders(hRequest, wHeader.c_str(), -1, WINHTTP_ADDREQ_FLAG_ADD);
			}

			// 发送请求
			BOOL bResults = FALSE;
			if (config.method == Method::POST || config.method == Method::PUT || config.method == Method::PATCH) {
				bResults = WinHttpSendRequest(
					hRequest,
					WINHTTP_NO_ADDITIONAL_HEADERS,
					0,
					(LPVOID)config.data.c_str(),
					config.data.length(),
					config.data.length(),
					0
					);
			}
			else {
				bResults = WinHttpSendRequest(
					hRequest,
					WINHTTP_NO_ADDITIONAL_HEADERS,
					0,
					WINHTTP_NO_REQUEST_DATA,
					0,
					0,
					0
					);
			}

			if (!bResults) {
				WinHttpCloseHandle(hRequest);
				WinHttpCloseHandle(hConnect);
				WinHttpCloseHandle(hSession);
				throw std::runtime_error("Failed to send request");
			}

			// 接收响应
			bResults = WinHttpReceiveResponse(hRequest, nullptr);
			if (!bResults) {
				WinHttpCloseHandle(hRequest);
				WinHttpCloseHandle(hConnect);
				WinHttpCloseHandle(hSession);
				throw std::runtime_error("Failed to receive response");
			}

			// 获取状态码
			DWORD statusCode = 0;
			DWORD statusCodeSize = sizeof(statusCode);
			WinHttpQueryHeaders(
				hRequest,
				WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
				WINHTTP_HEADER_NAME_BY_INDEX,
				&statusCode,
				&statusCodeSize,
				WINHTTP_NO_HEADER_INDEX
				);

			response.statusCode = statusCode;
			response.url = std::wstring(fullUrl.begin(), fullUrl.end());

			// 获取响应头
			DWORD headerSize = 0;
			WinHttpQueryHeaders(
				hRequest,
				WINHTTP_QUERY_RAW_HEADERS_CRLF,
				WINHTTP_HEADER_NAME_BY_INDEX,
				WINHTTP_NO_OUTPUT_BUFFER,
				&headerSize,
				WINHTTP_NO_HEADER_INDEX
				);

			if (headerSize > 0) {
				std::vector<wchar_t> headerBuffer(headerSize / sizeof(wchar_t));
				WinHttpQueryHeaders(
					hRequest,
					WINHTTP_QUERY_RAW_HEADERS_CRLF,
					WINHTTP_HEADER_NAME_BY_INDEX,
					headerBuffer.data(),
					&headerSize,
					WINHTTP_NO_HEADER_INDEX
					);

				// 解析响应头
				std::wstring headersStr(headerBuffer.data());
				parseHeaders(headersStr, response.headers);
			}

			// 读取响应体
			std::wstring responseData;
			DWORD bytesAvailable = 0;
			do {
				bytesAvailable = 0;
				WinHttpQueryDataAvailable(hRequest, &bytesAvailable);

				if (bytesAvailable > 0) {
					std::vector<char> buffer(bytesAvailable);
					DWORD bytesRead = 0;

					if (WinHttpReadData(hRequest, buffer.data(), bytesAvailable, &bytesRead)) {
						// 将字节数据转换为宽字符
						std::string tempData(buffer.data(), bytesRead);
						responseData += std::wstring(tempData.begin(), tempData.end());
					}
				}
			} while (bytesAvailable > 0);

			response.data = responseData;

			// 清理资源
			WinHttpCloseHandle(hRequest);
			WinHttpCloseHandle(hConnect);
			WinHttpCloseHandle(hSession);

			return response;
		}

		// 解析响应头
		void parseHeaders(const std::wstring& headersStr, std::map<std::wstring, std::wstring>& headers) {
			std::wistringstream stream(headersStr);
			std::wstring line;

			// 跳过状态行
			std::getline(stream, line);

			while (std::getline(stream, line)) {
				if (line.empty() || line == L"\r") break;

				size_t colonPos = line.find(L':');
				if (colonPos != std::wstring::npos) {
					std::wstring key = line.substr(0, colonPos);
					std::wstring value = line.substr(colonPos + 1);

					// 去除前后空格和\r
					key.erase(0, key.find_first_not_of(L" \t\r"));
					key.erase(key.find_last_not_of(L" \t\r") + 1);
					value.erase(0, value.find_first_not_of(L" \t\r"));
					value.erase(value.find_last_not_of(L" \t\r") + 1);

					headers[key] = value;
				}
			}
		}

		// 运行请求拦截器
		void runRequestInterceptors(RequestConfig& config) {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			for (auto& interceptor : interceptors) {
				if (!interceptor->onRequest(config)) {
					break;
				}
			}
		}

		// 运行响应拦截器
		void runResponseInterceptors(Response& response) {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			for (auto& interceptor : interceptors) {
				if (!interceptor->onResponse(response)) {
					break;
				}
			}
		}

		// 运行错误拦截器
		void runErrorInterceptors(const std::wstring& error) {
			std::lock_guard<std::mutex> lock(interceptorsMutex);
			for (auto& interceptor : interceptors) {
				if (!interceptor->onError(error)) {
					break;
				}
			}
		}

		// 执行带重试的请求
		Response performRequestWithRetry(const RequestConfig& config) {
			Response response;
			int retryCount = 0;

			while (retryCount <= config.retryConfig.maxRetries) {
				try {
					response = performRequest(config);
					response.success = response.statusCode >= 200 && response.statusCode < 300;

					// 检查是否需要重试
					if (!shouldRetry(response, config.retryConfig, retryCount)) {
						break;
					}

				}
				catch (const std::exception& e) {
					response.success = false;
					response.error = std::wstring(e.what(), e.what() + strlen(e.what()));

					// 检查异常是否应该重试
					if (!shouldRetryOnException(e.what(), config.retryConfig, retryCount)) {
						runErrorInterceptors(response.error);
						break;
					}
				}

				retryCount++;
				if (retryCount <= config.retryConfig.maxRetries) {
					// 等待重试间隔
					std::this_thread::sleep_for(std::chrono::milliseconds(config.retryConfig.retryDelay));
				}
			}

			return response;
		}

		// 判断是否应该重试（基于响应）
		bool shouldRetry(const Response& response, const RetryConfig& retryConfig, int retryCount) {
			if (retryCount >= retryConfig.maxRetries) {
				return false;
			}

			// 检查自定义重试条件
			if (retryConfig.shouldRetry && retryConfig.shouldRetry(response)) {
				return true;
			}

			// 检查服务器错误
			if (retryConfig.retryOnServerError && response.isServerError()) {
				return true;
			}

			return false;
		}

		// 判断是否应该重试（基于异常）
		bool shouldRetryOnException(const std::string& error, const RetryConfig& retryConfig, int retryCount) {
			if (retryCount >= retryConfig.maxRetries) {
				return false;
			}

			// 检查连接错误
			if (retryConfig.retryOnConnectionError) {
				std::string lowerError = error;
				std::transform(lowerError.begin(), lowerError.end(), lowerError.begin(), ::tolower);

				if (lowerError.find("connection") != std::string::npos ||
					lowerError.find("timeout") != std::string::npos ||
					lowerError.find("network") != std::string::npos ||
					lowerError.find("failed to connect") != std::string::npos ||
					lowerError.find("invalid url") != std::string::npos) {
					return true;
				}
			}

			return false;
		}

	private:
		std::vector<std::shared_ptr<Interceptor>> interceptors;
		std::mutex interceptorsMutex;

		int defaultTimeout;
		std::map<std::string, std::string> defaultHeaders;
		std::string proxy;
		std::string proxyAuth;
		bool verifySSL;
		RetryConfig defaultRetryConfig;
	};

	// HttpRequest类实现
	HttpRequest::HttpRequest() : pImpl(std::make_unique<HttpRequestImpl>()) {}

	HttpRequest::~HttpRequest() = default;

	HttpRequest::HttpRequest(HttpRequest&&) noexcept = default;
	HttpRequest& HttpRequest::operator=(HttpRequest&&) noexcept = default;

	// 同步请求方法
	Response HttpRequest::get(const std::string& url, const std::map<std::string, std::string>& params) {
		RequestConfig config;
		config.url = url;
		config.method = Method::GET;
		config.params = params;
		return pImpl->request(config);
	}

	Response HttpRequest::post(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::POST;
		config.data = data;
		config.headers = headers;
		return pImpl->request(config);
	}

	Response HttpRequest::put(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::PUT;
		config.data = data;
		config.headers = headers;
		return pImpl->request(config);
	}

	Response HttpRequest::delete_(const std::string& url, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::DELETE_;
		config.headers = headers;
		return pImpl->request(config);
	}

	Response HttpRequest::patch(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::PATCH;
		config.data = data;
		config.headers = headers;
		return pImpl->request(config);
	}

	Response HttpRequest::request(const RequestConfig& config) {
		return pImpl->request(config);
	}

	// 异步请求方法
	std::future<Response> HttpRequest::getAsync(const std::string& url, const std::map<std::string, std::string>& params) {
		RequestConfig config;
		config.url = url;
		config.method = Method::GET;
		config.params = params;
		return pImpl->requestAsync(config);
	}

	std::future<Response> HttpRequest::postAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::POST;
		config.data = data;
		config.headers = headers;
		return pImpl->requestAsync(config);
	}

	std::future<Response> HttpRequest::putAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::PUT;
		config.data = data;
		config.headers = headers;
		return pImpl->requestAsync(config);
	}

	std::future<Response> HttpRequest::deleteAsync(const std::string& url, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::DELETE_;
		config.headers = headers;
		return pImpl->requestAsync(config);
	}

	std::future<Response> HttpRequest::patchAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
		RequestConfig config;
		config.url = url;
		config.method = Method::PATCH;
		config.data = data;
		config.headers = headers;
		return pImpl->requestAsync(config);
	}

	std::future<Response> HttpRequest::requestAsync(const RequestConfig& config) {
		return pImpl->requestAsync(config);
	}

	// 拦截器管理
	void HttpRequest::addInterceptor(std::shared_ptr<Interceptor> interceptor) {
		pImpl->addInterceptor(interceptor);
	}

	void HttpRequest::addBusinessInterceptor(std::shared_ptr<BusinessInterceptor> interceptor) {
		pImpl->addInterceptor(interceptor);
	}

	void HttpRequest::addCommonInterceptor(std::shared_ptr<CommonInterceptor> interceptor) {
		pImpl->addInterceptor(interceptor);
	}

	void HttpRequest::removeInterceptor(std::shared_ptr<Interceptor> interceptor) {
		pImpl->removeInterceptor(interceptor);
	}

	void HttpRequest::clearInterceptors() {
		pImpl->clearInterceptors();
	}

	// 配置管理
	void HttpRequest::setDefaultTimeout(int timeout) {
		pImpl->setDefaultTimeout(timeout);
	}

	void HttpRequest::setDefaultHeaders(const std::map<std::string, std::string>& headers) {
		pImpl->setDefaultHeaders(headers);
	}

	void HttpRequest::setUserAgent(const std::string& userAgent) {
		pImpl->setUserAgent(userAgent);
	}

	void HttpRequest::setProxy(const std::string& proxy, const std::string& auth) {
		pImpl->setProxy(proxy, auth);
	}

	void HttpRequest::setSSLVerification(bool verify) {
		pImpl->setSSLVerification(verify);
	}

	void HttpRequest::setDefaultRetryConfig(const RetryConfig& retryConfig) {
		pImpl->setDefaultRetryConfig(retryConfig);
	}

	// 便捷方法
	std::string HttpRequest::methodToString(Method method) {
		switch (method) {
		case Method::GET: return "GET";
		case Method::POST: return "POST";
		case Method::PUT: return "PUT";
		case Method::DELETE_: return "DELETE";
		case Method::PATCH: return "PATCH";
		case Method::HEAD: return "HEAD";
		case Method::OPTIONS: return "OPTIONS";
		default: return "GET";
		}
	}

	Method HttpRequest::stringToMethod(const std::string& method) {
		std::string upperMethod = method;
		std::transform(upperMethod.begin(), upperMethod.end(), upperMethod.begin(), ::toupper);

		if (upperMethod == "GET") return Method::GET;
		if (upperMethod == "POST") return Method::POST;
		if (upperMethod == "PUT") return Method::PUT;
		if (upperMethod == "DELETE") return Method::DELETE_;
		if (upperMethod == "PATCH") return Method::PATCH;
		if (upperMethod == "HEAD") return Method::HEAD;
		if (upperMethod == "OPTIONS") return Method::OPTIONS;

		return Method::GET;
	}

	// 全局便捷函数实现
	namespace http {
		static std::shared_ptr<HttpRequest> defaultInstance = std::make_shared<HttpRequest>();

		std::shared_ptr<HttpRequest> create() {
			return std::make_shared<HttpRequest>();
		}

		Response get(const std::string& url, const std::map<std::string, std::string>& params) {
			return defaultInstance->get(url, params);
		}

		Response post(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->post(url, data, headers);
		}

		Response put(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->put(url, data, headers);
		}

		Response delete_(const std::string& url, const std::map<std::string, std::string>& headers) {
			return defaultInstance->delete_(url, headers);
		}

		Response patch(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->patch(url, data, headers);
		}

		std::future<Response> getAsync(const std::string& url, const std::map<std::string, std::string>& params) {
			return defaultInstance->getAsync(url, params);
		}

		std::future<Response> postAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->postAsync(url, data, headers);
		}

		std::future<Response> putAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->putAsync(url, data, headers);
		}

		std::future<Response> deleteAsync(const std::string& url, const std::map<std::string, std::string>& headers) {
			return defaultInstance->deleteAsync(url, headers);
		}

		std::future<Response> patchAsync(const std::string& url, const std::string& data, const std::map<std::string, std::string>& headers) {
			return defaultInstance->patchAsync(url, data, headers);
		}
	}

} // namespace HttpRequest

总结 很python的cpp

【C++开源库使用】使用libcurl开源库发送url请求（http/https请求）去下载用户头像文件（附完整源码）
dvlinker的技术专栏
07-07 2万+
本文详细讲述如何使用libcurl开源库发送url请求（http请求）去下载用户头像文件，并给出了完整实现源码。
C/C++开发人员要了解的几大著名C/C++开源库
热门推荐
dvlinker的技术专栏
07-24 5万+
本文详细讲述C/C++开发人员需要了解的几大著名C/C++开源库。
c++ requests网络请求库
Cosmopolitan的博客
04-21 7401
项目地址： https://github.com/lxwAsm/requests 演示视频： https://www.bilibili.com/video/bv1gV411Z7fT 基本使用： #include <iostream> #include <string> #include "http.h" using namespace std; using namespac...
MFC C++ 项目网络请求并返回数据使用JSONCPP解析
oZhaiHenZhai的博客
03-02 1220
1.导入JSONCPP 具体JSONCPP 使用请看这篇文章 2.直接上代码使用MFC自带的网络请求库GET请求 #include <iostream> using namespace std; // 加入JSONCpp解析 #include "json/json.h" #include "json-forwards.h" //使用MFC自带的网络请求库 #include &lt...
windows下C++网络编程入门
weixin_34007886的博客
01-02 489
winsocket分为流套接字和数据报套接字。winsocket编程一般都采用C/S模式。在server端的流程一般如下：1、初始化winsocket2、建立socket3、与本机进行邦定(bind)4、开始监听(listen)5、然后与客户端建立连接(accept)6、然后与客户端进行通信(send, recv)7、当通信完成以后，关闭连接8、释放winsocket的有关资源在Client端的流...
C++ http请求
Shan_mei的专栏
09-05 1012
std::string CHttpTool::HttpRequest(char * lpHostName,short sPort,char * lpUrl,char * lpMethod,char * lpPostData,int nPostDataLen)   {   HINTERNET hInternet,hConnect,hRequest;   BOOL bRet;  
C++ Windows网络通信程序设计全解析
以上知识点为读者提供了关于C++在Windows环境下进行网络与通信程序设计的全面了解，涉及到关键的编程模式和实现技术。在实际开发过程中，开发者可以基于这些知识点，结合具体需求，开发出高性能和高可用性的网络应用...
网络请求的高效处理：C++ libmicrohttpd库详解
Z_suger7的博客
07-01 1272
libmicrohttpd是一个小型的C语言库，用于创建HTTP服务器和客户端。它提供了HTTP 1.1协议的完整实现，包括持久连接、管道化请求、虚拟主机等特性。轻量级：易于集成到C或C++项目中。跨平台：支持多种操作系统，包括Linux、Windows和macOS。高性能：设计用于处理大量并发连接。
C++发送HTTP请求的实现代码
09-04
这个例子展示了一个简单的C++程序，利用Windows API中的`Wininet`库来实现HTTP请求。下面将详细解释这段代码的工作原理和涉及的知识点。 1. **`Wininet`库**：`Wininet`是Windows操作系统提供的一个库，它提供了一...
C++进行http请求，并获取返回结果
03-08
使用C++进行对网友的http请求，本例当中请求http://m.hbgajg.com/，并进行了相关数据的填写。
C++实现HTTP请求
08-21
C++实现HTTP POST GET请求
c/c++ 发送HTTP POST/GET请求50行代码搞定
08-16
50行代码http发送Post/Get请求，直接在linux gcc编译即可使用，或在win下任意c/c++编译器都可
C/C++爬虫篇之网络编程（请求服务器）
weixin_42467369的博客
06-28 1149
目录 C/C++套接字 C/C++请求服务器实现 先来张效果图： 1- C/C++套接字 在说明套接字之前，先简单了解客户端和服务器之间的关系。（往后再发TCP三次握手和四次挥手详细叙述过程） 1、TCP三次握手 标记 说明 SYN 建立连接标记，当某主机发送信息的时候，该标记会被设置为1 ，并和其他数据一起发送出去。 ACK 确认信息标记，当接收到某主机发送的信息之后，该标记会被设置为1，并和其他数据一起返回给某主机，表示确认接收到某主机发送的信息。 seq 报文序列号，该值
C++：发送HTTP请求（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
02-13 1283
本项目实现了一个简单的HTTP请求工具，使用了libcurl库来发送GET和POST请求。通过封装HTTP请求，我们可以方便地在C++项目中与Web服务进行交互。此工具适用于需要与RESTful API交互、抓取网页数据或执行其他HTTP操作的场景。
C++之网络编程
m0_74078963的博客
11-14 1166
人与人沟通的方式有很多：书信、电话、qq、等。两个人如果想沟通，必须选择一种沟通方式，一方用电话，另一方也应该用电话，而不是书信。人与人聊天可以说反话，说套话，人脑是智能的所以可以理解，但是机器不是，机器是死板的，所以协议是网络通讯的规则，是约定。
http协议简析及C++实现HTTP请求
诗筱涵的博客
09-05 3969
转载自：https://blog.csdn.net/liubailiuestc/article/details/79828896 http协议简析及C++实现HTTP请求 liubailiuestc 2018-04-07 21:12:39 14436 收藏 22 分类专栏： 网络编程 文章标签： HTTP请求 请求报文 TCP握手 C HTTP请求 版权 网络编程 专栏收录该内容 1 篇文章 0 订阅 订阅专栏 http是超文本传输协议，无状态协议(不同批次无法相互识别)，无连
C++：C语言实现HTTP的GET和POST请求
诗筱涵的博客
09-10 7223
转载自：C++：C语言实现HTTP的GET和POST请求 - 方方和圆圆 - 博客园 C++：C语言实现HTTP的GET和POST请求 阅读目录 　HTTP请求和IP/TCP 　实现GET请求 　实现POST请求： 　参考： 回到顶部 　　HTTP请求和IP/TCP 　　所谓的HTTP协议是基于IP/TCP协议的， 所以要获取远端的html数据只要创建socket对象就足够了； 　　HTTP是基于IP/TCP加上了网络请求的固定格式， 比如： 运行下面代码 metho...
c++发送http请求winnet
qq_28039867的博客
03-11 637
写之前网上也有找 不过可以发送http请求 但是不能发送数据与是做了改进//模拟浏览器发送HTTP请求函数 //地址，端口，跳转路径，方法，数据，数据长度 std::string HttpRequest(char * lpHostName,short sPort,char * lpUrl,char * lpMethod,char * lpPostData,int nPostDataLen) {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AIGC布道师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值