跳至主要內容

HTTP请求库

eastspire2025年6月26日大约 8 分钟http-requestrequestrust

GITHUB 地址

API 文档

http-request 是一个轻量级、高效的库，用于在 Rust 应用程序中构建、发送和处理 HTTP/HTTPS 请求。它提供了简单直观的 API，允许开发者轻松与 Web 服务交互，无论使用的是 "HTTP" 还是 "HTTPS" 协议。该库支持各种 HTTP 方法、自定义头部、请求体、超时、自动处理重定向（包括检测重定向循环）以及增强的响应体解码（自动和手动），实现快速安全的通信。无论是处理安全的 "HTTPS" 连接还是标准的 "HTTP" 请求，该库都针对性能、最小资源使用和易于集成到 Rust 项目进行了优化。

特性

  • 支持 HTTP/HTTPS：支持 HTTP 和 HTTPS 协议。
  • WebSocket 支持：完整的 WebSocket 支持，提供同步和异步 API 用于实时通信。
  • 轻量级设计：http_request crate 提供简单高效的 API 来构建、发送和处理 HTTP 请求，同时最小化资源消耗。
  • 支持常见 HTTP 方法：支持常见的 HTTP 方法，如 GET 和 POST。
  • 灵活的请求构建：通过 RequestBuilder 提供丰富的配置选项来设置请求头、请求体和 URL。
  • 简单的错误处理：利用 Result 类型处理请求和响应中的错误，使错误处理变得简单直接。
  • 自定义头部和请求体：轻松添加自定义头部和请求体。
  • 响应处理：提供 HTTP 响应的简单包装器，便于访问和处理响应数据。
  • 优化的内存管理：实现高效的内存管理，最小化不必要的内存分配并提高性能。
  • 重定向处理：支持重定向处理，允许设置最大重定向次数，并包含重定向循环检测。
  • 超时：支持超时。
  • 自动和手动响应体解码：支持响应体的自动和手动解码，允许与不同内容类型（如 JSON、XML 等）无缝交互。
  • 代理支持：全面的代理支持，包括 HTTP、HTTPS 和 SOCKS5 代理，支持 HTTP 请求和 WebSocket 连接的身份验证。

安装

要使用此 crate，您可以运行命令：

cargo add http-request

同步

发送 GET 请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

发送 POST 请求

发送 JSON 请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let body: JsonValue = json_value!({
    "test": 1
});
let mut request_builder = RequestBuilder::new()
    .post("http://code.ltpp.vip")
    .json(body)
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.decode(4096).text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

发送文本请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .post("http://ide.ltpp.vip/?language=rust")
    .text("hello")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

发送二进制请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .post("http://ide.ltpp.vip/?language=rust")
    .body("hello".as_bytes())
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.decode(4096).text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

使用 HTTP 代理发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .http_proxy("127.0.0.1", 7890)
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

使用 HTTP 代理身份验证发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .http_proxy_auth("127.0.0.1", 7890, "username", "password")
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

使用 SOCKS5 代理发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("http://ide.ltpp.vip/?language=rust")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .socks5_proxy("127.0.0.1", 1080)
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

使用 SOCKS5 代理身份验证发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("http://ide.ltpp.vip/?language=rust")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .socks5_proxy_auth("127.0.0.1", 1080, "username", "password")
    .build_sync();
request_builder
    .send()
    .and_then(|response| {
        println!("{:?}", response.text());
        Ok(())
    })
    .unwrap_or_else(|e| println!("Error => {}", e));

WebSocket 连接

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("Authorization", "Bearer test-token");

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .headers(header)
    .timeout(10000)
    .buffer(4096)
    .protocols(&["chat", "superchat"])
    .build_sync();

websocket_builder
    .send_text("Hello WebSocket!")
    .and_then(|_| {
        println!("Sync WebSocket text message sent successfully");
        websocket_builder.send_binary(b"binary data")
    })
    .and_then(|_| {
        println!("Sync WebSocket binary message sent successfully");
        match websocket_builder.receive() {
            Ok(message) => match message {
                WebSocketMessage::Text(text) => println!("Received text: {}", text),
                WebSocketMessage::Binary(data) => println!("Received binary: {:?}", data),
                WebSocketMessage::Close => println!("Connection closed"),
                _ => println!("Received other message type"),
            },
            Err(e) => println!("Error receiving message: {}", e),
        }
        Ok(())
    })
    .and_then(|_| websocket_builder.close())
    .unwrap_or_else(|e| println!("Error => {}", e));

使用 HTTP 代理的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .http_proxy("127.0.0.1", 7890)
    .build_sync();

match websocket_builder.send_text("Hello WebSocket with HTTP proxy!") {
    Ok(_) => println!("WebSocket HTTP proxy message sent successfully"),
    Err(e) => println!("WebSocket HTTP proxy error: {}", e),
}

使用 HTTP 代理身份验证的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .http_proxy_auth("127.0.0.1", 7890, "username", "password")
    .build_sync();

match websocket_builder.send_text("Hello WebSocket with HTTP proxy auth!") {
    Ok(_) => println!("WebSocket HTTP proxy auth message sent successfully"),
    Err(e) => println!("WebSocket HTTP proxy auth error: {}", e),
}

使用 SOCKS5 代理的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .socks5_proxy("127.0.0.1", 1080)
    .build_sync();

match websocket_builder.send_text("Hello WebSocket with SOCKS5 proxy!") {
    Ok(_) => println!("WebSocket SOCKS5 proxy message sent successfully"),
    Err(e) => println!("WebSocket SOCKS5 proxy error: {}", e),
}

使用 SOCKS5 代理身份验证的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .socks5_proxy_auth("127.0.0.1", 1080, "username", "password")
    .build_sync();

match websocket_builder.send_text("Hello WebSocket with SOCKS5 proxy auth!") {
    Ok(_) => println!("WebSocket SOCKS5 proxy auth message sent successfully"),
    Err(e) => println!("WebSocket SOCKS5 proxy auth error: {}", e),
}

异步

发送 GET 请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

发送 POST 请求

发送 JSON 请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let body: JsonValue = json_value!({
    "test": 1
});
let mut request_builder = RequestBuilder::new()
    .post("http://code.ltpp.vip")
    .json(body)
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.decode(4096).text());
    }
    Err(e) => println!("Error => {}", e),
}

发送文本请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .post("http://ide.ltpp.vip/?language=rust")
    .text("hello")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

发送二进制请求体

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .post("http://ide.ltpp.vip/?language=rust")
    .body("hello".as_bytes())
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.decode(4096).text());
    }
    Err(e) => println!("Error => {}", e),
}

使用 HTTP 代理发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .http_proxy("127.0.0.1", 7890)
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

使用 HTTP 代理身份验证发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("https://ltpp.vip/")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .http_proxy_auth("127.0.0.1", 7890, "username", "password")
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

使用 SOCKS5 代理发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("http://ide.ltpp.vip/?language=rust")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .socks5_proxy("127.0.0.1", 1080)
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

使用 SOCKS5 代理身份验证发送请求

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("header-key", "header-value");
let mut request_builder = RequestBuilder::new()
    .get("http://ide.ltpp.vip/?language=rust")
    .headers(header)
    .timeout(6000)
    .redirect()
    .max_redirect_times(8)
    .http1_1_only()
    .buffer(4096)
    .decode()
    .socks5_proxy_auth("127.0.0.1", 1080, "username", "password")
    .build_async();
match request_builder.send().await {
    Ok(response) => {
        println!("{:?}", response.text());
    }
    Err(e) => println!("Error => {}", e),
}

WebSocket 连接

use http_request::*;

let mut header: HashMapXxHash3_64<&str, &str> = hash_map_xx_hash3_64();
header.insert("Authorization", "Bearer test-token");

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .headers(header)
    .timeout(10000)
    .buffer(4096)
    .protocols(&["chat", "superchat"])
    .build_async();

match websocket_builder.send_text_async("Hello WebSocket!").await {
    Ok(_) => {
        println!("Async WebSocket text message sent successfully");
        match websocket_builder.send_binary_async(b"binary data").await {
            Ok(_) => {
                println!("Async WebSocket binary message sent successfully");
                match websocket_builder.receive_async().await {
                    Ok(message) => match message {
                        WebSocketMessage::Text(text) => println!("Received text: {}", text),
                        WebSocketMessage::Binary(data) => println!("Received binary: {:?}", data),
                        WebSocketMessage::Close => println!("Connection closed"),
                        _ => println!("Received other message type"),
                    },
                    Err(e) => println!("Error receiving message: {}", e),
                }
            }
            Err(e) => println!("Error sending binary: {}", e),
        }
    }
    Err(e) => println!("Error sending text: {}", e),
}

websocket_builder
    .close_async_method()
    .await
    .unwrap_or_else(|e| println!("Error closing: {}", e));

使用 HTTP 代理的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .http_proxy("127.0.0.1", 7890)
    .build_async();

match websocket_builder.send_text_async("Hello WebSocket with HTTP proxy!").await {
    Ok(_) => println!("Async WebSocket HTTP proxy message sent successfully"),
    Err(e) => println!("Async WebSocket HTTP proxy error: {}", e),
}

使用 HTTP 代理身份验证的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .http_proxy_auth("127.0.0.1", 7890, "username", "password")
    .build_async();

match websocket_builder.send_text_async("Hello WebSocket with HTTP proxy auth!").await {
    Ok(_) => println!("Async WebSocket HTTP proxy auth message sent successfully"),
    Err(e) => println!("Async WebSocket HTTP proxy auth error: {}", e),
}

使用 SOCKS5 代理的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .socks5_proxy("127.0.0.1", 1080)
    .build_async();

match websocket_builder.send_text_async("Hello WebSocket with SOCKS5 proxy!").await {
    Ok(_) => println!("Async WebSocket SOCKS5 proxy message sent successfully"),
    Err(e) => println!("Async WebSocket SOCKS5 proxy error: {}", e),
}

使用 SOCKS5 代理身份验证的 WebSocket

use http_request::*;

let mut websocket_builder: WebSocket = WebSocketBuilder::new()
    .connect("ws://127.0.0.1:60006/api/ws?uuid=1")
    .timeout(10000)
    .buffer(4096)
    .socks5_proxy_auth("127.0.0.1", 1080, "username", "password")
    .build_async();

match websocket_builder.send_text_async("Hello WebSocket with SOCKS5 proxy auth!").await {
    Ok(_) => println!("Async WebSocket SOCKS5 proxy auth message sent successfully"),
    Err(e) => println!("Async WebSocket SOCKS5 proxy auth error: {}", e),
}

帮助

确保系统上已安装 CMake。

许可证

该项目采用 MIT 许可证。有关详情，请查看 license 文件。

贡献

欢迎贡献代码！请提交 Issue 或发起 Pull Request。

联系方式

如有任何疑问，请联系作者：[email protected]。

上次编辑于: 2025/6/26 14:41:09
贡献者: 尤雨东