/**
 * 原生JS通用API请求函数（支持GET/POST，JSON格式）
 * @param {string} url - API接口完整地址
 * @param {string} method - 请求方法，仅支持GET/POST
 * @param {object} [data={}] - 请求参数（GET拼接到URL，POST作为JSON请求体）
 * @returns {Promise} - 返回接口响应的JSON数据
 */
async function requestApi(url, method, data = {}) {
  try {
    // 处理GET请求：拼接参数到URL
    let requestUrl = url;
    if (method.toUpperCase() === 'GET' && Object.keys(data).length > 0) {
      const params = new URLSearchParams(data).toString();
      requestUrl = `${requestUrl}${requestUrl.includes('?') ? '&' : '?'}${params}`;
    }

    // 配置请求选项
    const requestOptions = {
      method: method.toUpperCase(),
      headers: { 'Content-Type': 'application/json' },
      credentials: 'include' // 跨域时携带Cookie，不需要可改为omit
    };

    // 处理POST请求：设置JSON请求体
    if (method.toUpperCase() === 'POST') {
      requestOptions.body = JSON.stringify(data);
    }

    // 发送请求并处理响应
    const response = await fetch(requestUrl, requestOptions);
    if (!response.ok) throw new Error(`请求失败：${response.status} ${response.statusText}`);
    const result = await response.json(); // 自动解析JSON响应
    return result;

  } catch (error) {
    console.error('API请求错误：', error.message);
    throw error; // 抛出错误供调用方处理
  }
}

// -------------------------- 使用示例 --------------------------
// 1. GET请求示例（查询数据）
async function testGet() {
  try {
    const data = await requestApi(
      'https://api.example.com/user/list', // 替换为实际接口地址
      'GET',
      { page: 1, size: 10, keyword: 'test' } // GET请求参数
    );
    console.log('GET请求成功：', data);
    // 业务逻辑处理...
  } catch (err) {
    alert('GET请求失败：' + err.message);
  }
}

// 2. POST请求示例（提交数据）
async function testPost() {
  try {
    const data = await requestApi(
      'https://api.example.com/user/login', // 替换为实际接口地址
      'POST',
      { username: 'admin', password: '123456' } // POST请求体数据
    );
    console.log('POST请求成功：', data);
    // 业务逻辑处理...
  } catch (err) {
    alert('POST请求失败：' + err.message);
  }
}

// 执行请求（按需调用）
// testGet();
// testPost();

import okhttp3.*;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * Java 单文件实现GET/POST(JSON) API请求
 * 基于OkHttp和Jackson，复制后直接使用（需添加Maven/Gradle依赖）
 */
public class ApiRequest {
    // 全局OkHttpClient实例（复用连接池）
    private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(10, TimeUnit.SECONDS)
            .writeTimeout(10, TimeUnit.SECONDS)
            .build();

    // Jackson JSON解析工具
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    /**
     * GET请求方法
     * @param url 接口地址
     * @param params URL参数键值对
     * @return 接口响应字符串
     * @throws IOException 网络异常
     */
    public static String doGet(String url, Map params) throws IOException {
        HttpUrl.Builder urlBuilder = HttpUrl.parse(url).newBuilder();
        if (params != null && !params.isEmpty()) {
            for (Map.Entry entry : params.entrySet()) {
                urlBuilder.addQueryParameter(entry.getKey(), entry.getValue());
            }
        }
        Request request = new Request.Builder().url(urlBuilder.build()).get().build();
        try (Response response = OK_HTTP_CLIENT.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("GET请求失败：" + response.code() + " " + response.message());
            }
            return response.body() != null ? response.body().string() : "";
        }
    }

    /**
     * POST(JSON)请求方法
     * @param url 接口地址
     * @param jsonStr JSON请求体字符串
     * @return 接口响应字符串
     * @throws IOException 网络异常
     */
    public static String doPostJson(String url, String jsonStr) throws IOException {
        MediaType mediaType = MediaType.parse("application/json; charset=utf-8");
        RequestBody requestBody = RequestBody.create(mediaType, jsonStr);
        Request request = new Request.Builder().url(url).post(requestBody).build();
        try (Response response = OK_HTTP_CLIENT.newCall(request).execute()) {
            if (!response.isSuccessful()) {
                throw new IOException("POST请求失败：" + response.code() + " " + response.message());
            }
            return response.body() != null ? response.body().string() : "";
        }
    }

    /**
     * 格式化JSON字符串（便于阅读）
     * @param jsonStr 原始JSON字符串
     * @return 格式化后的JSON
     * @throws IOException 解析异常
     */
    public static String formatJson(String jsonStr) throws IOException {
        if (jsonStr == null || jsonStr.isEmpty()) {
            return "";
        }
        Object jsonObj = OBJECT_MAPPER.readValue(jsonStr, Object.class);
        return OBJECT_MAPPER.writerWithDefaultPrettyPrinter().writeValueAsString(jsonObj);
    }

    // 主方法：测试GET/POST请求
    public static void main(String[] args) {
        try {
            // ------------------- 测试GET请求 -------------------
            String getUrl = "https://api.example.com/user/list"; // 替换为实际接口地址
            Map getParams = new HashMap<>();
            getParams.put("page", "1");
            getParams.put("size", "10");
            getParams.put("keyword", "test");
            String getResponse = doGet(getUrl, getParams);
            System.out.println("=== GET请求响应结果 ===");
            System.out.println(formatJson(getResponse));

            System.out.println("------------------------");

            // ------------------- 测试POST请求 -------------------
            String postUrl = "https://api.example.com/user/login"; // 替换为实际接口地址
            Map postData = new HashMap<>();
            postData.put("username", "admin");
            postData.put("password", "123456");
            String jsonStr = OBJECT_MAPPER.writeValueAsString(postData);
            String postResponse = doPostJson(postUrl, jsonStr);
            System.out.println("=== POST请求响应结果 ===");
            System.out.println(formatJson(postResponse));

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"net/url"
	"time"
)

// 全局HTTP客户端，设置超时时间
var httpClient = &http.Client{
	Timeout: 10 * time.Second, // 请求超时时间10秒
}

// DoGet 发送GET请求，自动拼接URL参数
// urlStr: 接口地址
// params: URL查询参数（键值对）
// 返回：响应体字符串、错误信息
func DoGet(urlStr string, params map[string]string) (string, error) {
	// 解析基础URL
	parsedUrl, err := url.Parse(urlStr)
	if err != nil {
		return "", fmt.Errorf("URL解析失败: %v", err)
	}

	// 拼接查询参数
	query := parsedUrl.Query()
	for key, value := range params {
		query.Add(key, value)
	}
	parsedUrl.RawQuery = query.Encode()

	// 发送GET请求
	resp, err := httpClient.Get(parsedUrl.String())
	if err != nil {
		return "", fmt.Errorf("GET请求失败: %v", err)
	}
	defer resp.Body.Close() // 确保响应体关闭

	// 检查响应状态码
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return "", fmt.Errorf("请求返回异常状态码: %d", resp.StatusCode)
	}

	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("读取响应体失败: %v", err)
	}

	return string(body), nil
}

// DoPostJson 发送POST请求，JSON格式请求体
// urlStr: 接口地址
// data: 请求体数据（任意可序列化为JSON的结构体/Map）
// 返回：响应体字符串、错误信息
func DoPostJson(urlStr string, data interface{}) (string, error) {
	// 将数据序列化为JSON字节流
	jsonData, err := json.Marshal(data)
	if err != nil {
		return "", fmt.Errorf("JSON序列化失败: %v", err)
	}

	// 发送POST请求
	resp, err := httpClient.Post(urlStr, "application/json", bytes.NewBuffer(jsonData))
	if err != nil {
		return "", fmt.Errorf("POST请求失败: %v", err)
	}
	defer resp.Body.Close()

	// 检查响应状态码
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return "", fmt.Errorf("请求返回异常状态码: %d", resp.StatusCode)
	}

	// 读取响应体
	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		return "", fmt.Errorf("读取响应体失败: %v", err)
	}

	return string(body), nil
}

// FormatJson 格式化JSON字符串（便于控制台阅读）
func FormatJson(jsonStr string) string {
	var prettyJson bytes.Buffer
	err := json.Indent(&prettyJson, []byte(jsonStr), "", "  ")
	if err != nil {
		return jsonStr // 格式化失败则返回原字符串
	}
	return prettyJson.String()
}

func main() {
	// ------------------- 测试GET请求 -------------------
	fmt.Println("=== 开始测试GET请求 ===")
	getUrl := "https://api.example.com/user/list" // 替换为实际接口地址
	getParams := map[string]string{
		"page":    "1",
		"size":    "10",
		"keyword": "test",
	}
	getResp, err := DoGet(getUrl, getParams)
	if err != nil {
		fmt.Printf("GET请求出错: %v\n", err)
	} else {
		fmt.Println("GET请求响应结果:\n", FormatJson(getResp))
	}

	fmt.Println("------------------------")

	// ------------------- 测试POST请求 -------------------
	fmt.Println("=== 开始测试POST请求 ===")
	postUrl := "https://api.example.com/user/login" // 替换为实际接口地址
	// 定义POST请求体（可替换为自定义结构体）
	postData := map[string]string{
		"username": "admin",
		"password": "123456",
	}
	postResp, err := DoPostJson(postUrl, postData)
	if err != nil {
		fmt.Printf("POST请求出错: %v\n", err)
	} else {
		fmt.Println("POST请求响应结果:\n", FormatJson(postResp))
	}
}

import requests
import json

# 配置全局请求超时时间（单位：秒）
TIMEOUT = 10

def do_get(url: str, params: dict = None) -> str:
    """
    发送GET请求
    :param url: 接口地址
    :param params: URL查询参数（字典）
    :return: 响应体字符串（格式化后的JSON）
    :raises Exception: 请求失败时抛出异常
    """
    try:
        # 发送GET请求
        response = requests.get(url, params=params, timeout=TIMEOUT)
        # 检查响应状态码
        response.raise_for_status()
        # 返回格式化后的JSON字符串
        return json.dumps(response.json(), indent=2, ensure_ascii=False)
    except requests.exceptions.RequestException as e:
        raise Exception(f"GET请求失败: {str(e)}")

def do_post_json(url: str, data: dict = None) -> str:
    """
    发送POST请求（JSON格式请求体）
    :param url: 接口地址
    :param data: JSON请求体（字典）
    :return: 响应体字符串（格式化后的JSON）
    :raises Exception: 请求失败时抛出异常
    """
    try:
        # 发送POST请求，自动设置Content-Type为application/json
        response = requests.post(url, json=data, timeout=TIMEOUT)
        # 检查响应状态码
        response.raise_for_status()
        # 返回格式化后的JSON字符串
        return json.dumps(response.json(), indent=2, ensure_ascii=False)
    except requests.exceptions.RequestException as e:
        raise Exception(f"POST请求失败: {str(e)}")

if __name__ == "__main__":
    # ------------------- 测试GET请求 -------------------
    print("=== 开始测试GET请求 ===")
    get_url = "https://api.example.com/user/list"  # 替换为实际接口地址
    get_params = {
        "page": 1,
        "size": 10,
        "keyword": "test"
    }
    try:
        get_resp = do_get(get_url, get_params)
        print("GET请求响应结果:\n", get_resp)
    except Exception as e:
        print(e)

    print("-" * 40)

    # ------------------- 测试POST请求 -------------------
    print("=== 开始测试POST请求 ===")
    post_url = "https://api.example.com/user/login"  # 替换为实际接口地址
    post_data = {
        "username": "admin",
        "password": "123456"
    }
    try:
        post_resp = do_post_json(post_url, post_data)
        print("POST请求响应结果:\n", post_resp)
    except Exception as e:
        print(e)

const http = require('http');
const https = require('https');
const querystring = require('querystring');

/**
 * 通用请求函数（支持GET/POST，JSON格式）
 * @param {string} url - 接口完整地址
 * @param {string} method - GET/POST
 * @param {object} [data={}] - 请求参数（GET拼URL，POST为JSON体）
 * @returns {Promise} - 响应JSON数据
 */
function requestApi(url, method, data = {}) {
  return new Promise((resolve, reject) => {
    // 解析URL
    const urlObj = new URL(url);
    const isHttps = urlObj.protocol === 'https:';
    const client = isHttps ? https : http;

    // 处理GET参数
    let path = urlObj.pathname;
    if (method.toUpperCase() === 'GET' && Object.keys(data).length > 0) {
      const params = querystring.stringify(data);
      path += (urlObj.search ? '&' : '?') + params;
    }

    // 处理POST请求体
    let postData = '';
    if (method.toUpperCase() === 'POST') {
      postData = JSON.stringify(data);
    }

    // 配置请求选项
    const options = {
      hostname: urlObj.hostname,
      port: urlObj.port || (isHttps ? 443 : 80),
      path: path + urlObj.search,
      method: method.toUpperCase(),
      headers: {
        'Content-Type': 'application/json; charset=utf-8',
        'Content-Length': Buffer.byteLength(postData)
      }
    };

    // 发送请求
    const req = client.request(options, (res) => {
      let rawData = '';
      res.on('data', (chunk) => { rawData += chunk; });
      res.on('end', () => {
        try {
          // 解析JSON响应
          const result = JSON.parse(rawData);
          resolve(result);
        } catch (err) {
          reject(new Error(`响应解析失败: ${err.message}`));
        }
      });
    });

    // 错误处理
    req.on('error', (err) => {
      reject(new Error(`请求失败: ${err.message}`));
    });

    // 写入POST请求体
    if (method.toUpperCase() === 'POST') {
      req.write(postData);
    }
    req.end();
  });
}

// 测试主函数
async function main() {
  try {
    // ------------------- 测试GET请求 -------------------
    console.log('=== 开始测试GET请求 ===');
    const getUrl = 'https://api.example.com/user/list'; // 替换为实际接口
    const getParams = { page: 1, size: 10, keyword: 'test' };
    const getResult = await requestApi(getUrl, 'GET', getParams);
    console.log('GET请求响应:', JSON.stringify(getResult, null, 2));

    console.log('------------------------');

    // ------------------- 测试POST请求 -------------------
    console.log('=== 开始测试POST请求 ===');
    const postUrl = 'https://api.example.com/user/login'; // 替换为实际接口
    const postData = { username: 'admin', password: '123456' };
    const postResult = await requestApi(postUrl, 'POST', postData);
    console.log('POST请求响应:', JSON.stringify(postResult, null, 2));
  } catch (err) {
    console.error('请求出错:', err.message);
  }
}

// 执行测试
main();

#include 
#include 
#include 
#include 

// 定义缓冲区结构体，用于存储响应数据
typedef struct {
    char* data;
    size_t size;
} ResponseBuffer;

// libcurl的写回调函数，将响应数据写入缓冲区
static size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {
    size_t realsize = size * nmemb;
    ResponseBuffer* buffer = (ResponseBuffer*)userp;

    // 重新分配内存存储响应数据
    char* temp = realloc(buffer->data, buffer->size + realsize + 1);
    if (temp == NULL) {
        fprintf(stderr, "内存分配失败！\n");
        return 0;
    }
    buffer->data = temp;
    memcpy(&(buffer->data[buffer->size]), contents, realsize);
    buffer->size += realsize;
    buffer->data[buffer->size] = '\0'; // 字符串结束符

    return realsize;
}

// 初始化响应缓冲区
void init_buffer(ResponseBuffer* buffer) {
    buffer->data = malloc(1);
    buffer->size = 0;
}

// 释放响应缓冲区内存
void free_buffer(ResponseBuffer* buffer) {
    free(buffer->data);
    buffer->data = NULL;
    buffer->size = 0;
}

/**
 * 发送GET请求
 * @param url 接口地址
 * @param params URL参数（格式："key1=value1&key2=value2"，传NULL则无参数）
 * @return 响应字符串（需手动free释放），失败返回NULL
 */
char* http_get(const char* url, const char* params) {
    CURL* curl = curl_easy_init();
    if (!curl) {
        fprintf(stderr, "CURL初始化失败！\n");
        return NULL;
    }

    ResponseBuffer buffer;
    init_buffer(&buffer);

    // 拼接GET请求的URL和参数
    char* full_url = NULL;
    if (params && strlen(params) > 0) {
        full_url = (char*)malloc(strlen(url) + strlen(params) + 2);
        sprintf(full_url, "%s?%s", url, params);
    } else {
        full_url = (char*)malloc(strlen(url) + 1);
        strcpy(full_url, url);
    }

    // 设置CURL选项
    curl_easy_setopt(curl, CURLOPT_URL, full_url);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L); // 超时时间10秒
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // 跟随重定向

    // 执行GET请求
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "GET请求失败: %s\n", curl_easy_strerror(res));
        free_buffer(&buffer);
        free(full_url);
        curl_easy_cleanup(curl);
        return NULL;
    }

    // 检查响应状态码
    long response_code;
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    if (response_code < 200 || response_code >= 300) {
        fprintf(stderr, "GET请求返回异常状态码: %ld\n", response_code);
        free_buffer(&buffer);
        free(full_url);
        curl_easy_cleanup(curl);
        return NULL;
    }

    // 释放资源
    free(full_url);
    curl_easy_cleanup(curl);

    // 返回响应数据（需调用者手动free）
    return buffer.data;
}

/**
 * 发送POST请求（JSON格式请求体）
 * @param url 接口地址
 * @param json_data JSON请求体字符串
 * @return 响应字符串（需手动free释放），失败返回NULL
 */
char* http_post_json(const char* url, const char* json_data) {
    CURL* curl = curl_easy_init();
    if (!curl) {
        fprintf(stderr, "CURL初始化失败！\n");
        return NULL;
    }

    ResponseBuffer buffer;
    init_buffer(&buffer);

    // 设置CURL选项
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 10L); // 超时时间10秒
    curl_easy_setopt(curl, CURLOPT_POST, 1L); // 启用POST请求

    // 设置JSON请求体和请求头
    struct curl_slist* headers = NULL;
    headers = curl_slist_append(headers, "Content-Type: application/json; charset=utf-8");
    curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, json_data);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, strlen(json_data));

    // 执行POST请求
    CURLcode res = curl_easy_perform(curl);
    if (res != CURLE_OK) {
        fprintf(stderr, "POST请求失败: %s\n", curl_easy_strerror(res));
        free_buffer(&buffer);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        return NULL;
    }

    // 检查响应状态码
    long response_code;
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
    if (response_code < 200 || response_code >= 300) {
        fprintf(stderr, "POST请求返回异常状态码: %ld\n", response_code);
        free_buffer(&buffer);
        curl_slist_free_all(headers);
        curl_easy_cleanup(curl);
        return NULL;
    }

    // 释放资源
    curl_slist_free_all(headers);
    curl_easy_cleanup(curl);

    // 返回响应数据（需调用者手动free）
    return buffer.data;
}

int main(void) {
    // 初始化libcurl
    curl_global_init(CURL_GLOBAL_ALL);

    // ------------------- 测试GET请求 -------------------
    printf("=== 开始测试GET请求 ===\n");
    const char* get_url = "https://api.example.com/user/list"; // 替换为实际接口
    const char* get_params = "page=1&size=10&keyword=test";   // GET参数
    char* get_resp = http_get(get_url, get_params);
    if (get_resp) {
        printf("GET请求响应结果:\n%s\n", get_resp);
        free(get_resp); // 释放响应内存
    }

    printf("------------------------\n");

    // ------------------- 测试POST请求 -------------------
    printf("=== 开始测试POST请求 ===\n");
    const char* post_url = "https://api.example.com/user/login"; // 替换为实际接口
    const char* post_json = "{\"username\":\"admin\",\"password\":\"123456\"}"; // JSON请求体
    char* post_resp = http_post_json(post_url, post_json);
    if (post_resp) {
        printf("POST请求响应结果:\n%s\n", post_resp);
        free(post_resp); // 释放响应内存
    }

    // 清理libcurl全局资源
    curl_global_cleanup();
    return 0;
}

#include 
#include 
#include 
#include 

// 响应数据缓冲区类，封装内存管理
class ResponseBuffer {
public:
    std::string data; // 存储响应数据的字符串，自动管理内存

    // libcurl写回调函数，将响应数据写入缓冲区
    static size_t WriteCallback(void* contents, size_t size, size_t nmemb, void* userp) {
        size_t realSize = size * nmemb;
        ResponseBuffer* buffer = static_cast(userp);
        buffer->data.append(static_cast(contents), realSize);
        return realSize;
    }
};

// HTTP请求工具类，封装GET/POST(JSON)方法
class HttpRequester {
private:
    CURL* curl; // CURL句柄
    long timeout; // 请求超时时间（秒）

public:
    // 构造函数：初始化CURL
    HttpRequester(long timeout = 10) : timeout(timeout) {
        curl_global_init(CURL_GLOBAL_ALL);
        curl = curl_easy_init();
        if (!curl) {
            throw std::runtime_error("CURL初始化失败！");
        }
        // 设置全局超时
        curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout);
        // 跟随HTTP重定向
        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
    }

    // 析构函数：释放CURL资源
    ~HttpRequester() {
        if (curl) {
            curl_easy_cleanup(curl);
        }
        curl_global_cleanup();
    }

    // 禁用拷贝构造和赋值，避免资源重复释放
    HttpRequester(const HttpRequester&) = delete;
    HttpRequester& operator=(const HttpRequester&) = delete;

    /**
     * 发送GET请求
     * @param url 接口地址
     * @param params URL参数（格式："key1=value1&key2=value2"）
     * @return 响应字符串
     * @throws std::runtime_error 请求失败时抛出异常
     */
    std::string Get(const std::string& url, const std::string& params = "") {
        if (!curl) {
            throw std::runtime_error("CURL句柄未初始化");
        }

        // 拼接完整URL（带参数）
        std::string fullUrl = url;
        if (!params.empty()) {
            fullUrl += "?" + params;
        }

        ResponseBuffer buffer;
        // 设置CURL选项
        curl_easy_setopt(curl, CURLOPT_URL, fullUrl.c_str());
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseBuffer::WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);

        // 执行GET请求
        CURLcode res = curl_easy_perform(curl);
        if (res != CURLE_OK) {
            throw std::runtime_error("GET请求失败: " + std::string(curl_easy_strerror(res)));
        }

        // 检查响应状态码
        long responseCode;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
        if (responseCode < 200 || responseCode >= 300) {
            throw std::runtime_error("GET请求返回异常状态码: " + std::to_string(responseCode));
        }

        return buffer.data;
    }

    /**
     * 发送POST请求（JSON格式请求体）
     * @param url 接口地址
     * @param jsonData JSON请求体字符串
     * @return 响应字符串
     * @throws std::runtime_error 请求失败时抛出异常
     */
    std::string PostJson(const std::string& url, const std::string& jsonData) {
        if (!curl) {
            throw std::runtime_error("CURL句柄未初始化");
        }

        ResponseBuffer buffer;
        // 设置POST请求基础选项
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_POST, 1L); // 启用POST方法
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonData.c_str()); // 设置请求体
        curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, jsonData.length()); // 设置请求体长度
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, ResponseBuffer::WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &buffer);

        // 设置JSON请求头
        struct curl_slist* headers = nullptr;
        headers = curl_slist_append(headers, "Content-Type: application/json; charset=utf-8");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);

        // 执行POST请求
        CURLcode res = curl_easy_perform(curl);
        // 释放请求头链表（无论请求成功与否都要释放）
        curl_slist_free_all(headers);

        if (res != CURLE_OK) {
            throw std::runtime_error("POST请求失败: " + std::string(curl_easy_strerror(res)));
        }

        // 检查响应状态码
        long responseCode;
        curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &responseCode);
        if (responseCode < 200 || responseCode >= 300) {
            throw std::runtime_error("POST请求返回异常状态码: " + std::to_string(responseCode));
        }

        return buffer.data;
    }
};

// 主函数：测试GET/POST请求
int main() {
    try {
        // 创建HTTP请求器实例
        HttpRequester requester;

        // ------------------- 测试GET请求 -------------------
        std::cout << "=== 开始测试GET请求 ===" << std::endl;
        std::string getUrl = "https://api.example.com/user/list"; // 替换为实际接口
        std::string getParams = "page=1&size=10&keyword=test";   // GET参数
        std::string getResp = requester.Get(getUrl, getParams);
        std::cout << "GET请求响应结果:\n" << getResp << std::endl;

        std::cout << "------------------------" << std::endl;

        // ------------------- 测试POST请求 -------------------
        std::cout << "=== 开始测试POST请求 ===" << std::endl;
        std::string postUrl = "https://api.example.com/user/login"; // 替换为实际接口
        std::string postJson = R"({"username":"admin","password":"123456"})"; // JSON请求体（原生字符串避免转义）
        std::string postResp = requester.PostJson(postUrl, postJson);
        std::cout << "POST请求响应结果:\n" << postResp << std::endl;

    } catch (const std::exception& e) {
        // 捕获所有异常并打印
        std::cerr << "请求出错: " << e.what() << std::endl;
        return 1;
    }

    return 0;
}

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Text.Json;

/// 

/// HTTP请求工具类，封装GET/POST(JSON)请求
/// 
public class HttpRequester
{
    // 静态HttpClient实例（推荐单例使用，避免频繁创建释放连接）
    private static readonly HttpClient _httpClient = new HttpClient
    {
        Timeout = TimeSpan.FromSeconds(10) // 设置10秒超时
    };

    /// 

    /// 发送GET请求
    /// 
    /// 接口完整地址
    /// URL查询参数（键值对）
    /// 格式化后的JSON响应字符串
    /// 请求失败时抛出异常
    public static async Task GetAsync(string url, System.Collections.Generic.Dictionary paramsDict = null)
    {
        // 拼接查询参数
        if (paramsDict != null && paramsDict.Count > 0)
        {
            var queryBuilder = new System.Text.StringBuilder();
            foreach (var pair in paramsDict)
            {
                queryBuilder.Append($"{Uri.EscapeDataString(pair.Key)}={Uri.EscapeDataString(pair.Value)}&");
            }
            string query = queryBuilder.ToString().TrimEnd('&');
            url += $"{(url.Contains("?") ? "&" : "?")}{query}";
        }

        // 发送GET请求
        using var response = await _httpClient.GetAsync(url);
        // 检查响应状态码，非2xx则抛出异常
        response.EnsureSuccessStatusCode();

        // 读取响应并格式化JSON
        string jsonResponse = await response.Content.ReadAsStringAsync();
        return FormatJson(jsonResponse);
    }

    /// 

    /// 发送POST请求（JSON格式请求体）
    /// 
    /// 接口完整地址
    /// 请求体数据（任意可序列化的对象）
    /// 格式化后的JSON响应字符串
    /// 请求失败时抛出异常
    public static async Task PostJsonAsync(string url, T data)
    {
        // 将对象序列化为JSON字符串
        string jsonData = JsonSerializer.Serialize(data, new JsonSerializerOptions { WriteIndented = false });
        // 构造JSON请求体
        using var content = new StringContent(jsonData, Encoding.UTF8, "application/json");
        // 发送POST请求
        using var response = await _httpClient.PostAsync(url, content);
        // 检查响应状态码
        response.EnsureSuccessStatusCode();

        // 读取响应并格式化JSON
        string jsonResponse = await response.Content.ReadAsStringAsync();
        return FormatJson(jsonResponse);
    }

    /// 

    /// 格式化JSON字符串（便于阅读）
    /// 
    private static string FormatJson(string json)
    {
        if (string.IsNullOrEmpty(json)) return json;
        var jsonDoc = JsonDocument.Parse(json);
        return JsonSerializer.Serialize(jsonDoc, new JsonSerializerOptions { WriteIndented = true });
    }
}

/// 

/// 测试类，包含主函数
/// 
class Program
{
    // C# 7.1+支持Main方法为async
    static async Task Main(string[] args)
    {
        try
        {
            // ------------------- 测试GET请求 -------------------
            Console.WriteLine("=== 开始测试GET请求 ===");
            string getUrl = "https://api.example.com/user/list"; // 替换为实际接口
            var getParams = new System.Collections.Generic.Dictionary
            {
                { "page", "1" },
                { "size", "10" },
                { "keyword", "test" }
            };
            string getResponse = await HttpRequester.GetAsync(getUrl, getParams);
            Console.WriteLine("GET请求响应结果:\n" + getResponse);

            Console.WriteLine("------------------------");

            // ------------------- 测试POST请求 -------------------
            Console.WriteLine("=== 开始测试POST请求 ===");
            string postUrl = "https://api.example.com/user/login"; // 替换为实际接口
            // 定义请求体对象（可替换为自定义类）
            var postData = new
            {
                username = "admin",
                password = "123456"
            };
            string postResponse = await HttpRequester.PostJsonAsync(postUrl, postData);
            Console.WriteLine("POST请求响应结果:\n" + postResponse);
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"请求失败: {ex.Message}");
            if (ex.InnerException != null)
            {
                Console.WriteLine($"内部异常: {ex.InnerException.Message}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"程序异常: {ex.Message}");
        }

        // 防止控制台立即关闭
        Console.WriteLine("\n按任意键退出...");
        Console.ReadKey();
    }
}

' 引入必要的命名空间
Imports System
Imports System.Net.Http
Imports System.Text
Imports System.Threading.Tasks
Imports System.Collections.Generic
Imports System.Text.Json
Imports System.Net.Http.Headers

''' 

''' HTTP请求工具类，封装GET/POST(JSON)核心逻辑
''' 基于.NET内置HttpClient，支持异步请求、JSON序列化/反序列化
''' 
Public Class HttpHelper
    ' 静态HttpClient单例（推荐单例使用，避免端口耗尽）
    Private Shared ReadOnly _httpClient As New HttpClient With {
        .Timeout = TimeSpan.FromSeconds(10) ' 设置10秒请求超时
    }

    ''' 

    ''' 发送GET请求，自动拼接URL参数
    ''' 
    ''' 接口基础地址
    ''' URL查询参数（键值对）
    ''' 格式化后的JSON响应字符串
    Public Shared Async Function SendGetRequestAsync(baseUrl As String, Optional parameters As Dictionary(Of String, String) = Nothing) As Task(Of String)
        Try
            ' 拼接查询参数
            Dim requestUrl As String = baseUrl
            If parameters IsNot Nothing AndAlso parameters.Count > 0 Then
                Dim queryBuilder As New StringBuilder()
                For Each pair In parameters
                    queryBuilder.Append($"{Uri.EscapeDataString(pair.Key)}={Uri.EscapeDataString(pair.Value)}&")
                Next
                Dim query As String = queryBuilder.ToString().TrimEnd("&"c)
                requestUrl &= If(requestUrl.Contains("?"), "&", "?") & query
            End If

            ' 发送GET请求并验证状态码
            Dim response As HttpResponseMessage = Await _httpClient.GetAsync(requestUrl)
            response.EnsureSuccessStatusCode()

            ' 读取响应并格式化JSON
            Dim responseJson As String = Await response.Content.ReadAsStringAsync()
            Return FormatJsonString(responseJson)
        Catch ex As HttpRequestException
            Throw New Exception($"GET请求失败：{ex.Message}", ex)
        End Try
    End Function

    ''' 

    ''' 发送POST请求（JSON格式请求体）
    ''' 
    ''' 请求体数据类型
    ''' 接口完整地址
    ''' 请求体数据（任意可序列化对象）
    ''' 格式化后的JSON响应字符串
    Public Shared Async Function SendPostJsonRequestAsync(Of T)(apiUrl As String, requestData As T) As Task(Of String)
        Try
            ' 将对象序列化为JSON字符串
            Dim jsonBody As String = JsonSerializer.Serialize(requestData, New JsonSerializerOptions With {.WriteIndented = False})
            ' 构造JSON请求体
            Dim content As New StringContent(jsonBody, Encoding.UTF8, "application/json")

            ' 发送POST请求并验证状态码
            Dim response As HttpResponseMessage = Await _httpClient.PostAsync(apiUrl, content)
            response.EnsureSuccessStatusCode()

            ' 读取响应并格式化JSON
            Dim responseJson As String = Await response.Content.ReadAsStringAsync()
            Return FormatJsonString(responseJson)
        Catch ex As HttpRequestException
            Throw New Exception($"POST请求失败：{ex.Message}", ex)
        End Try
    End Function

    ''' 

    ''' 添加全局请求头（如Token、API Key）
    ''' 
    ''' 请求头名称
    ''' 请求头值
    Public Shared Sub AddGlobalHeader(headerName As String, headerValue As String)
        If Not _httpClient.DefaultRequestHeaders.Contains(headerName) Then
            _httpClient.DefaultRequestHeaders.Add(headerName, headerValue)
        End If
    End Sub

    ''' 

    ''' 格式化JSON字符串，提升可读性
    ''' 
    ''' 原始JSON字符串
    ''' 格式化后的JSON
    Private Shared Function FormatJsonString(rawJson As String) As String
        If String.IsNullOrEmpty(rawJson) Then Return rawJson
        Dim jsonDoc As JsonDocument = JsonDocument.Parse(rawJson)
        Return JsonSerializer.Serialize(jsonDoc, New JsonSerializerOptions With {.WriteIndented = True})
    End Function
End Class

''' 

''' 测试程序入口，演示GET/POST请求的使用
''' 
Module Program
    ' VB.NET主函数，异步执行测试逻辑
    Sub Main()
        ' 同步等待异步方法执行（控制台程序专用）
        TestApiRequestsAsync().GetAwaiter().GetResult()
        ' 防止控制台立即关闭
        Console.WriteLine(vbCrLf & "按任意键退出程序...")
        Console.ReadKey()
    End Sub

    ''' 

    ''' 测试GET和POST API请求
    ''' 
    Private Async Function TestApiRequestsAsync() As Task
        Try
            ' 可选：添加全局请求头（如Token认证）
            ' HttpHelper.AddGlobalHeader("Authorization", "Bearer your_token_here")
            ' HttpHelper.AddGlobalHeader("X-API-Key", "your_api_key_here")

            ' ------------------- 测试GET请求 -------------------
            Console.WriteLine("=== 开始执行GET请求 ===")
            Dim getUrl As String = "https://api.example.com/user/list" ' 替换为实际接口地址
            Dim getParams As New Dictionary(Of String, String) From {
                {"page", "1"},
                {"size", "10"},
                {"keyword", "vb.net_test"}
            }
            Dim getResponse As String = Await HttpHelper.SendGetRequestAsync(getUrl, getParams)
            Console.WriteLine("GET请求响应结果：" & vbCrLf & getResponse)

            Console.WriteLine("------------------------")

            ' ------------------- 测试POST请求 -------------------
            Console.WriteLine("=== 开始执行POST请求 ===")
            Dim postUrl As String = "https://api.example.com/user/login" ' 替换为实际接口地址
            ' 匿名类型请求体（也可替换为自定义实体类）
            Dim postData = New With {
                .username = "vbnet_admin",
                .password = "123456_test",
                .rememberMe = True
            }
            Dim postResponse As String = Await HttpHelper.SendPostJsonRequestAsync(postUrl, postData)
            Console.WriteLine("POST请求响应结果：" & vbCrLf & postResponse)

        Catch ex As Exception
            Console.WriteLine($"请求异常：{ex.Message}")
            If ex.InnerException IsNot Nothing Then
                Console.WriteLine($"内部异常详情：{ex.InnerException.Message}")
            End If
        End Try
    End Function
End Module