文章目录

前言

嘿，各位开发者们！今天我想和大家聊聊 Rust 生态系统中一个非常强大的 HTTP 库 —— Hyper。作为 Rust 中最流行的 HTTP 实现之一，Hyper 以其高性能、安全性和可靠性赢得了广泛赞誉。无论你是 Rust 新手还是老手，了解 Hyper 都会让你在网络应用开发中如虎添翼！

在这篇教程中，我会从零开始，带你一步步了解 Hyper 的基础知识，并通过实际例子帮助你快速上手。（这绝对是值得投入时间学习的库！）

Hyper 是什么？

Hyper 是一个用 Rust 编写的快速、安全的 HTTP 实现，它专注于正确性和性能。与其他 HTTP 库不同，Hyper 采用了零拷贝设计原则，这意味着它能够在处理 HTTP 请求和响应时最大限度地减少内存使用和数据复制。

关键特点：

  • 高性能：底层优化确保处理请求的速度极快
  • 类型安全：利用 Rust 的类型系统防止常见错误
  • 异步设计：完全拥抱 Rust 的 async/await 生态
  • 灵活性：可作为客户端或服务器使用
  • 现代化：支持 HTTP/1.x 和 HTTP/2

为什么选择 Hyper？

你可能会想：已经有这么多 HTTP 库了，为什么要学习 Hyper？

答案很简单 —— Hyper 几乎是 Rust 生态中所有主流 Web 框架的基础！像 Rocket、Actix-web 和 Warp 这样的热门框架都构建在 Hyper 之上。了解 Hyper 的工作原理不仅能帮助你开发自己的 HTTP 应用，还能让你更深入地理解这些框架的底层机制。

另外，Hyper 的性能实在是太棒了！它经常在各种 Web 框架基准测试中名列前茅，尤其在高并发场景下表现更为出色。

开始使用 Hyper

环境准备

首先，确保你已经安装了 Rust 和 Cargo。然后，创建一个新项目：

cargo new hyper_demo
cd hyper_demo

接下来，在 Cargo.toml 文件中添加 Hyper 依赖：

[dependencies]
hyper = { version = "0.14", features = ["full"] }
tokio = { version = "1", features = ["full"] }

这里我们添加了 Hyper 和 Tokio。Tokio 是 Rust 的异步运行时，Hyper 需要它来运行异步代码。

第一个 Hyper 客户端

让我们从一个简单的 HTTP 客户端开始，它可以发送 GET 请求并打印响应：

use std::convert::Infallible;
use hyper::{Body, Client, Request, Response, Server, Uri};
use hyper::service::{make_service_fn, service_fn};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    // 创建客户端
    let client = Client::new();
    
    // 构建请求
    let uri = "http://httpbin.org/get".parse::<Uri>()?;
    let response = client.get(uri).await?;
    
    // 处理响应
    println!("Response status: {}", response.status());
    
    // 读取响应体
    let body_bytes = hyper::body::to_bytes(response.into_body()).await?;
    let body_str = String::from_utf8(body_bytes.to_vec())?;
    println!("Response body: {}", body_str);
    
    Ok(())
}

这段代码做了什么？它创建了一个 Hyper 客户端，向 httpbin.org 发送 GET 请求，然后打印响应状态和内容。相当直接明了！

但等等，上面的代码可能看起来有点复杂（特别是对 Rust 新手来说）。不用担心！让我们慢慢解析它：

  1. 首先，我们创建了一个 Client 实例
  2. 然后，构建了一个指向 httpbin.org 的 URI
  3. 使用 .get() 方法发送请求并等待响应
  4. 打印响应状态码
  5. 最后，将响应体转换为字符串并打印出来

创建 Hyper 服务器

Hyper 不仅可以作为客户端使用，还可以用来构建服务器。下面是一个简单的 Hello World 服务器示例：

use std::convert::Infallible;
use std::net::SocketAddr;
use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};

async fn handle(_req: Request<Body>) -> Result<Response<Body>, Infallible> {
    Ok(Response::new(Body::from("Hello, World!")))
}

#[tokio::main]
async fn main() {
    // 我们将服务器绑定到 127.0.0.1:3000
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    
    // 创建一个服务函数
    let make_svc = make_service_fn(|_conn| async {
        Ok::<_, Infallible>(service_fn(handle))
    });
    
    // 创建服务器
    let server = Server::bind(&addr).serve(make_svc);
    
    // 运行服务器
    println!("Server running on http://{}", addr);
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

这个服务器会监听 localhost:3000，对所有请求都响应 “Hello, World!”。

我知道这可能看起来有点吓人（尤其是那个 make_service_fn 的部分），但别担心！Hyper 的这种设计是为了提供最大的灵活性。一旦你熟悉了它的模式，你会发现这其实很直观。

简单来说：

  • handle 函数处理每个传入的请求
  • make_service_fn 创建一个服务生成器
  • Server::bind 将服务器绑定到指定地址
  • serve 方法使用我们的服务处理请求

更实用的例子：构建一个 API 客户端

让我们做点更有趣的事情 - 构建一个简单的 API 客户端，从 JSONPlaceholder 获取数据：

use hyper::{Client, Uri, Body};
use hyper::client::HttpConnector;

// 定义一个简单的 API 客户端
struct ApiClient {
    client: Client<HttpConnector, Body>,
    base_url: String,
}

impl ApiClient {
    // 创建新客户端
    fn new(base_url: &str) -> Self {
        Self {
            client: Client::new(),
            base_url: base_url.to_string(),
        }
    }
    
    // 获取所有帖子
    async fn get_posts(&self) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
        let url = format!("{}/posts", self.base_url).parse::<Uri>()?;
        let response = self.client.get(url).await?;
        let body_bytes = hyper::body::to_bytes(response.into_body()).await?;
        Ok(String::from_utf8(body_bytes.to_vec())?)
    }
    
    // 获取特定帖子
    async fn get_post(&self, id: u32) -> Result<String, Box<dyn std::error::Error + Send + Sync>> {
        let url = format!("{}/posts/{}", self.base_url, id).parse::<Uri>()?;
        let response = self.client.get(url).await?;
        let body_bytes = hyper::body::to_bytes(response.into_body()).await?;
        Ok(String::from_utf8(body_bytes.to_vec())?)
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let api = ApiClient::new("https://jsonplaceholder.typicode.com");
    
    // 获取第一篇帖子
    let post = api.get_post(1).await?;
    println!("Post #1:\n{}\n", post);
    
    // 获取所有帖子（这里只打印前 100 个字符作为示例）
    let posts = api.get_posts().await?;
    println!("All posts (preview): {}", &posts[..100]);
    
    Ok(())
}

这个例子展示了如何将 Hyper 封装到自己的客户端结构中，这在实际应用中非常常见。我们定义了两个方法：一个获取所有帖子，另一个获取特定 ID 的帖子。

处理 POST 请求

到目前为止，我们只看了 GET 请求。现在让我们尝试发送一个 POST 请求：

use hyper::{Body, Client, Method, Request, Uri};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let client = Client::new();
    
    // 构建 JSON 数据
    let json_data = r#"{"title":"foo","body":"bar","userId":1}"#;
    
    // 创建请求
    let req = Request::builder()
        .method(Method::POST)
        .uri("https://jsonplaceholder.typicode.com/posts")
        .header("content-type", "application/json")
        .body(Body::from(json_data))?;
    
    // 发送请求
    let resp = client.request(req).await?;
    
    // 处理响应
    println!("Status: {}", resp.status());
    let body_bytes = hyper::body::to_bytes(resp.into_body()).await?;
    let body = String::from_utf8(body_bytes.to_vec())?;
    println!("Response: {}", body);
    
    Ok(())
}

这里，我们使用 Request::builder() 来构建一个更复杂的请求，包括设置方法、URI、头部和请求体。这种方式比简单的 .get() 方法更灵活，允许我们完全控制请求的各个方面。

处理中间件与自定义服务

Hyper 的一个强大之处是它的中间件系统。我们可以创建自定义的服务函数来处理请求，并在处理过程中添加自定义逻辑：

use std::convert::Infallible;
use std::net::SocketAddr;
use std::time::Instant;
use hyper::{Body, Request, Response, Server};
use hyper::service::{make_service_fn, service_fn};

// 记录请求处理时间的中间件
async fn with_logging(req: Request<Body>) -> Result<Response<Body>, Infallible> {
    let start = Instant::now();
    let path = req.uri().path().to_owned();
    let method = req.method().clone();
    
    // 调用实际的处理函数
    let response = handle_request(req).await;
    
    // 计算处理时间
    let duration = start.elapsed();
    println!("{} {} - {:?}", method, path, duration);
    
    Ok(response)
}

// 实际处理请求的函数
async fn handle_request(req: Request<Body>) -> Response<Body> {
    match (req.method(), req.uri().path()) {
        (&hyper::Method::GET, "/") => {
            Response::new(Body::from("Welcome to the home page!"))
        },
        (&hyper::Method::GET, "/about") => {
            Response::new(Body::from("This is the about page."))
        },
        _ => {
            let mut not_found = Response::new(Body::from("404 Not Found"));
            *not_found.status_mut() = hyper::StatusCode::NOT_FOUND;
            not_found
        }
    }
}

#[tokio::main]
async fn main() {
    let addr = SocketAddr::from(([127, 0, 0, 1], 3000));
    
    let make_svc = make_service_fn(|_conn| async {
        Ok::<_, Infallible>(service_fn(with_logging))
    });
    
    let server = Server::bind(&addr).serve(make_svc);
    
    println!("Server running on http://{}", addr);
    if let Err(e) = server.await {
        eprintln!("server error: {}", e);
    }
}

这个例子中，我们创建了一个记录请求处理时间的中间件。当请求进来时，它首先经过 with_logging 函数，然后被传递给实际的 handle_request 函数处理。这种模式让我们可以轻松地添加横切关注点，如日志记录、认证、压缩等。

异步流处理

Hyper 的 Body 类型实际上是一个异步流。这意味着我们可以逐块处理大型响应体，而不必一次性将它们加载到内存中：

use futures_util::StreamExt;
use hyper::{Body, Client, Uri};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    let client = Client::new();
    let uri = "http://httpbin.org/bytes/1024".parse::<Uri>()?;
    
    let response = client.get(uri).await?;
    let status = response.status();
    println!("Response status: {}", status);
    
    // 获取响应体作为流
    let mut body = response.into_body();
    
    // 计算接收的总字节数
    let mut total_bytes = 0;
    
    // 逐块处理响应体
    while let Some(chunk) = body.next().await {
        let chunk = chunk?;
        let size = chunk.len();
        total_bytes += size;
        println!("Received chunk of {} bytes", size);
    }
    
    println!("Total received: {} bytes", total_bytes);
    
    Ok(())
}

这个例子展示了如何将响应体作为流处理，逐块接收数据。这对于处理大型文件下载或流媒体内容特别有用！

结语

我们今天学习了 Hyper 的基础知识，从简单的客户端和服务器开始，到处理不同类型的请求和响应，再到使用中间件和流处理。这只是 Hyper 强大功能的冰山一角！

随着你对 Hyper 的深入了解，你会发现它提供了构建高性能 HTTP 应用所需的所有工具。虽然它的 API 可能一开始看起来有点复杂，但这种设计为你提供了极大的灵活性和控制力。

如果你正在构建 Rust Web 应用，我强烈建议深入研究 Hyper 文档，并尝试使用它构建更复杂的应用。即使你最终选择使用更高级别的框架如 Rocket 或 Actix-web，了解底层的 Hyper 也会让你成为更好的 Rust Web 开发者！

希望这篇教程对你有所帮助！祝你在 Rust 网络编程之旅中一切顺利！

（记得查看官方文档获取最新信息和更多示例哦！）

# rust # http # 开发语言 # 其他
Logo
亚马逊云科技技术品牌专区

更多推荐

open-code-review Codex 插件教程：对话式调用评审技能指南

本文是一份面向新手的 **open-code-review Codex 插件教程**，教你在 Codex 中通过对话式方式调用 open-code-review 的 AI 代码评审技能。open-code-review 是阿里巴巴开源的 AI 代码评审工具，采用"确定性流水线 + LLM Agent"混合架构，内置多语言评审规则（NPE、线程安全、XSS、SQL 注入等），可在 Codex 里用一

avatar 亚马逊云科技技术品牌专区

OBS Studio 完整指南：免费开源录屏与直播软件从零上手

想做一场像模像样的直播，或者把屏幕内容录成教程视频，但一想到商用软件的订阅费就有些犹豫？其实你不需要花一分钱。OBS Studio 是一款免费开源的直播与录屏软件，支持 Windows、macOS 和 Linux，采集、混音、编码、推流、录制，一条流水线全包了。## 先搞清楚 OBS Studio 是什么OBS Studio 是一个"场景化"的采集合成工具：你把摄像头、窗口、浏览器、图片、

avatar 亚马逊云科技技术品牌专区

如何用MediaCrawler爬取小红书抖音数据？7大平台爬虫从安装到实战完整指南

MediaCrawler 是一个支持小红书、抖音、快手、B站、微博、百度贴吧、知乎的开源自媒体数据采集工具。它能按关键词、按帖子、按创作者主页三种方式抓取笔记/视频内容、评论甚至二级评论，并把结果存成 JSON、CSV、Excel 或数据库。适合做市场调研、竞品监控、内容选题的运营人员，以及想要现成爬虫框架而不想从零写 JS 逆向的开发者。## 从一次"手动抄数据"说起想象这个场景：你负责

avatar 亚马逊云科技技术品牌专区