Actix-webRust Web框架入门教程

最新推荐文章于 2025-10-29 13:27:57 发布
原创 最新推荐文章于 2025-10-29 13:27:57 发布 · 924 阅读 · 12 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#前端 #其他

文章目录

引言

嘿，各位开发者们！今天我要和大家分享一个在Rust生态系统中备受瞩目的Web框架——Actix-web。作为Rust世界中最受欢迎的Web框架之一，Actix-web以其惊人的性能和友好的API设计赢得了众多开发者的青睐。无论你是Rust新手还是老手，这篇教程都将帮助你快速上手这个强大的工具！

我第一次接触Actix-web时简直被它的速度震惊了（真的超级快！！！）。如果你正在寻找一个高性能、类型安全且易于使用的Web框架，那么Actix-web绝对值得你花时间学习。

Actix-web是什么？

Actix-web是一个用Rust编写的高性能Web框架，它建立在actor系统Actix的基础上（虽然现在已经可以独立使用）。它提供了创建HTTP服务器和客户端的工具，支持WebSockets、HTTP/2等现代Web技术。

与其他Web框架相比，Actix-web的主要优势在于:

  • 极致性能 - 在多项基准测试中，它经常位居前列（有时甚至超过Go和Node.js框架）
  • 类型安全 - 利用Rust的类型系统，避免常见错误
  • 异步支持 - 完全拥抱Rust的异步编程模型
  • 灵活性 - 从简单API到复杂应用，都能胜任

准备工作

在开始之前，你需要准备好Rust开发环境。如果你还没有安装Rust，可以通过rustup来安装：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

确保你的Rust是最新版本：

rustup update

接下来，创建一个新的Rust项目：

cargo new actix_demo
cd actix_demo

然后，在Cargo.toml文件中添加Actix-web依赖：

[dependencies]
actix-web = "4.3.1"

你的第一个Actix-web应用

让我们开始创建一个简单的"Hello World"应用。打开src/main.rs文件，并替换为以下内容：

use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder};

#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body("Hello, Actix-web!")
}

#[post("/echo")]
async fn echo(req_body: String) -> impl Responder {
    HttpResponse::Ok().body(req_body)
}

async fn manual_hello() -> impl Responder {
    HttpResponse::Ok().body("Hey there!")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .service(hello)
            .service(echo)
            .route("/hey", web::get().to(manual_hello))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

运行这个程序：

cargo run

现在你可以访问 http://localhost:8080/ 看到"Hello, Actix-web!"的响应。也可以通过POST请求发送数据到 http://localhost:8080/echo 端点，或者访问 http://localhost:8080/hey 查看另一个响应。

理解代码结构

让我们分解上面的代码，以便理解Actix-web的核心概念：

  1. 路由处理函数：在Actix-web中，每个路由对应一个处理函数，如上例中的hello、echo和manual_hello。这些函数必须是异步的，并且返回实现了Responder特质的类型。

  2. 宏注解：#[get("/")]和#[post("/echo")]是路由宏，它们简化了路由定义。也可以通过.route()方法手动定义路由，就像/hey路由那样。

  3. HttpServer和App：HttpServer负责处理HTTP请求，而App是应用程序的主体，它包含了所有的路由和中间件配置。

  4. 绑定和运行：使用.bind()方法指定服务器监听的地址和端口，然后调用.run().await启动服务器。

处理请求和响应

在Web开发中，处理请求和生成响应是最基本的任务。Actix-web提供了多种方式来处理这些操作。

接收请求数据

Actix-web支持多种方式获取请求数据：

  1. 路径参数：
#[get("/users/{id}")]
async fn get_user(path: web::Path<(u32,)>) -> impl Responder {
    let user_id = path.into_inner().0;
    HttpResponse::Ok().body(format!("User ID: {}", user_id))
}
  1. 查询参数：
#[derive(Deserialize)]
struct Info {
    name: String,
    age: u32,
}

#[get("/info")]
async fn info(query: web::Query<Info>) -> impl Responder {
    format!("Welcome {}! You are {} years old.", query.name, query.age)
}
  1. JSON请求体：
#[derive(Deserialize)]
struct User {
    name: String,
    email: String,
}

#[post("/users")]
async fn create_user(user: web::Json<User>) -> impl Responder {
    HttpResponse::Created().json(user.into_inner())
}

返回响应

Actix-web提供了多种方式来构建响应：

  1. 简单文本响应：
HttpResponse::Ok().body("Hello world!")
  1. JSON响应：
#[derive(Serialize)]
struct Response {
    message: String,
    status: String,
}

async fn json_response() -> impl Responder {
    let response = Response {
        message: "Success".to_string(),
        status: "OK".to_string(),
    };
    
    web::Json(response)
}
  1. 重定向：
async fn redirect() -> impl Responder {
    HttpResponse::Found()
        .append_header(("Location", "/login"))
        .finish()
}

中间件 - 增强你的应用

中间件允许你在请求处理的前后添加额外的逻辑。Actix-web提供了许多内置的中间件，如日志记录、压缩、CORS支持等。你也可以创建自定义中间件。

以下是如何添加日志中间件的示例：

use actix_web::middleware::Logger;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    std::env::set_var("RUST_LOG", "actix_web=info");
    env_logger::init();

    HttpServer::new(|| {
        App::new()
            .wrap(Logger::default())
            .service(hello)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

这会记录所有传入的请求，包括路径、状态码和处理时间。

状态管理和依赖注入

在Web应用中，你经常需要在不同的请求处理程序之间共享状态（如数据库连接）。Actix-web提供了一种类型安全的方式来实现这一点：

use std::sync::Mutex;

struct AppState {
    counter: Mutex<i32>,
}

#[get("/count")]
async fn count(data: web::Data<AppState>) -> String {
    let mut counter = data.counter.lock().unwrap();
    *counter += 1;
    format!("Request number: {}", counter)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_state = web::Data::new(AppState {
        counter: Mutex::new(0),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .service(count)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

这个例子创建了一个简单的计数器，每次访问/count路径时增加计数。

实用示例：构建RESTful API

让我们构建一个简单的待办事项API，它支持创建、读取、更新和删除操作（CRUD）：

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use std::sync::Mutex;

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Task {
    id: Option<u32>,
    title: String,
    completed: bool,
}

struct AppState {
    tasks: Mutex<Vec<Task>>,
    counter: Mutex<u32>,
}

async fn get_tasks(data: web::Data<AppState>) -> impl Responder {
    let tasks = data.tasks.lock().unwrap();
    HttpResponse::Ok().json(&*tasks)
}

async fn get_task_by_id(path: web::Path<u32>, data: web::Data<AppState>) -> impl Responder {
    let task_id = path.into_inner();
    let tasks = data.tasks.lock().unwrap();
    
    if let Some(task) = tasks.iter().find(|t| t.id == Some(task_id)) {
        HttpResponse::Ok().json(task)
    } else {
        HttpResponse::NotFound().body("Task not found")
    }
}

async fn create_task(task: web::Json<Task>, data: web::Data<AppState>) -> impl Responder {
    let mut tasks = data.tasks.lock().unwrap();
    let mut counter = data.counter.lock().unwrap();
    
    let mut new_task = task.into_inner();
    *counter += 1;
    new_task.id = Some(*counter);
    
    tasks.push(new_task.clone());
    HttpResponse::Created().json(new_task)
}

async fn update_task(path: web::Path<u32>, task: web::Json<Task>, data: web::Data<AppState>) -> impl Responder {
    let task_id = path.into_inner();
    let mut tasks = data.tasks.lock().unwrap();
    
    if let Some(pos) = tasks.iter().position(|t| t.id == Some(task_id)) {
        let mut updated_task = task.into_inner();
        updated_task.id = Some(task_id);
        tasks[pos] = updated_task.clone();
        HttpResponse::Ok().json(updated_task)
    } else {
        HttpResponse::NotFound().body("Task not found")
    }
}

async fn delete_task(path: web::Path<u32>, data: web::Data<AppState>) -> impl Responder {
    let task_id = path.into_inner();
    let mut tasks = data.tasks.lock().unwrap();
    
    if let Some(pos) = tasks.iter().position(|t| t.id == Some(task_id)) {
        tasks.remove(pos);
        HttpResponse::Ok().body("Task deleted")
    } else {
        HttpResponse::NotFound().body("Task not found")
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_state = web::Data::new(AppState {
        tasks: Mutex::new(Vec::new()),
        counter: Mutex::new(0),
    });

    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .route("/tasks", web::get().to(get_tasks))
            .route("/tasks", web::post().to(create_task))
            .route("/tasks/{id}", web::get().to(get_task_by_id))
            .route("/tasks/{id}", web::put().to(update_task))
            .route("/tasks/{id}", web::delete().to(delete_task))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

这个例子实现了一个完整的RESTful API，支持以下操作：

  • GET /tasks - 获取所有任务
  • POST /tasks - 创建新任务
  • GET /tasks/{id} - 获取特定任务
  • PUT /tasks/{id} - 更新特定任务
  • DELETE /tasks/{id} - 删除特定任务

测试你的Actix-web应用

Actix-web提供了测试工具，让你可以方便地测试你的应用：

#[cfg(test)]
mod tests {
    use super::*;
    use actix_web::{test, App};

    #[actix_web::test]
    async fn test_hello_endpoint() {
        let app = test::init_service(
            App::new().service(hello)
        ).await;
        
        let req = test::TestRequest::get().uri("/").to_request();
        let resp = test::call_service(&app, req).await;
        
        assert!(resp.status().is_success());
        
        let body = test::read_body(resp).await;
        assert_eq!(body, "Hello, Actix-web!");
    }
}

这个测试创建了一个测试服务，发送GET请求到"/"路径，然后验证响应状态和内容。

部署Actix-web应用

当你准备部署你的应用时，记住以下几点：

  1. 使用--release标志进行编译，以获得最佳性能：
cargo build --release
  1. 考虑使用反向代理（如Nginx）来处理SSL、负载均衡等：
server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://localhost:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
    }
}
  1. 为生产环境配置日志和监控。

结语

Actix-web是一个功能强大且高性能的Web框架，非常适合构建从简单API到复杂Web应用的各种项目。它的类型安全和并发模型使得开发安全可靠的Web服务变得简单。

虽然学习曲线可能比一些其他语言的Web框架稍陡（主要是因为Rust本身），但投入的时间绝对值得。一旦你习惯了Actix-web的开发模式，你会发现它不仅高效而且非常愉快！

希望这篇教程能帮助你开始使用Actix-web！记住，最好的学习方式是实践，所以赶快动手尝试吧。（相信我，你会爱上它的！）

额外资源

祝你编码愉快！

systemseer
关注
# Rust Actix Web 入门指南
大白菜代码的博客
01-19 909
ActixWeb入门ActixWeb路由添加数据库ActixWeb应用状态中间件静态文件服务部署总结时至今日，ActixWeb仍然是RustWeb后端生态系统中极其强大的竞争者。尽管经历了一些事件，它依然保持强劲，成为Rust中最受推荐的Web框架之一。最初基于同名的actor框架（actix），现在已经脱离了原来的设计，现在actix主要用于WebSocket端点。本文主要讨论v4.4版本。
Rust web开发 ActixWeb 入门
xuejianxinokok的专栏
03-22 3755
目前，Actix Web 仍然是 Rust Web 后端生态系统中极其强大的竞争对手。尽管之前的事件可能对其产生影响，但它仍然很强大，并且是 Rust 中最受推荐的 Web 框架之一。最初基于同名的 actor 框架 (actix)，后来它已经消失，并且actix现在仅用于 websocket 端点。本文将主要讨论 v4.4。
Actix-Web 框架实战：构建高性能 RESTful API 服务
最新发布
七夜zippoe的博客
10-29 1215
Actix-Web 是 Rust 生态中高性能 Web 框架，基于 Actor 模型和 Tokio 异步运行时。本文涵盖其核心架构、路由系统、中间件开发和数据库集成。通过博客 API 项目实战，讲解 RESTful 服务构建全流程，包括路由组织（Scope）、共享状态（AppData）、连接池配置等。关键优势包括极高性能（700 万+ req/sec）、类型安全和强大的异步支持。还涉及错误处理、性能优化（压缩/连接池）及生产级问题讨论，为开发者提供构建可靠 Web 服务的完整指南。
使用 Actix-Web、SQLx 和 Redis 构建高性能 Rust Web 服务
大白菜代码的博客
01-01 1935
Actix-Web是一个用于构建 Web 应用程序的高性能、异步框架，基于 Rust 语言。异步：使用tokio和async-std等异步运行时，提供高性能和高并发处理能力。中间件：支持中间件机制，可以方便地扩展功能。路由：灵活的路由机制，支持路径参数、查询参数等多种路由方式。类型安全：利用 Rust 的类型系统，确保代码的类型安全性和健壮性。社区支持：拥有活跃的开发者社区和丰富的文档资源。
Actix Web 项目教程
gitblog_00713的博客
08-10 748
Actix Web 项目教程 1. 项目的目录结构及介绍 Actix Web 项目的目录结构如下： actix-web/ ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── justfile ├── src/ │ ├── main.rs │ ├── lib.rs │ └── ... ├── exampl...
精选资源
actix-swagger：用于actix-web框架的Swagger代码生成器
02-06
标题中的“actix-swagger”是一个专门为基于Rust编程语言的actix-web框架设计的工具，它实现了Swagger（现称为OpenAPI）规范。Swagger是一种流行的API文档化和接口测试工具，能够帮助开发者自动生成RESTful API的...
actix-web 项目的入门模板，感觉非常具有 Django 风格。 避免无聊的东西并更快地移动。
06-28
它以 Python 的 Django 为模型，但尽量不过多地隐藏底层的 actix-web 框架。这样做是因为 Web 框架传统上分为两类：厨房水槽：它几乎什么都有，一旦你需要缩放它，你就会开始把东西撕掉，并有点生气。微框架：非常...
actix-web-static-files-作为资源支持的actix-web静态文件-Rust开发
05-27
作为资源的actix-web静态文件支持MIT或UNLICENSE下的Legal Dual-licensed。 功能将静态资源嵌入到可执行文件中当资源支持MIT或UNLICENSE下的Legal Dual-licensed时，服务于静态actix-web静态文件。 功能将静态资源...
精选资源
actix-web：Actix Web是一个功能强大，实用且快速的Rust Web框架。
02-05
Actix Web是一个基于Actix生态系统构建的高性能、实用且快速的Web框架，它专为Rust编程语言设计。Actix Web充分利用了Rust语言的安全性、并发性和内存管理特性，为开发者提供了构建现代Web应用程序的强大工具。 在...
如何使用Rust和Actix-web框架构建一个基本的Web API管理系统
10-08
在本次示例中，我们将探讨如何使用Rust编程语言及其Actix-web框架来构建一个基础的Web API管理系统。 Rust是一种系统编程语言，它被设计为确保内存安全和并发性，而不会牺牲性能。它自2010年起由Mozilla研究院启动...
Actix Web是一个小型，实用且快速的锈蚀Web框架。-C/C++开发
05-26
Actix网站Actix网站是一个小型，实用且快速的防锈网络框架。 聊天| 示例Actix网站是一个简单，实用且快速的web框架f Actix网站Actix网站是一个小型，实用且快速的rust Web框架。 聊天| 示例Actix Web是用于Rust的简单，实用，非常快速的Web框架。 支持的HTTP / 1.x和HTTP / 2.0协议流传输和流水线保持活动和慢速请求处理客户端/服务器WebSockets支持透明的内容压缩/解压缩（br，gzip，deflate）可配置的请求路由多部分流静态资产支持OpenSSL或SSL的静态资产
Actix-Web构建一个简单的HTTP服务器
m0_47202518的博客
04-08 6120
Actix框架是目前性能上数一数二的rust的web框架，它的性能远超gin，spring等目前流行的框架。 仅仅是返回hello,wold，我发现actix的性能就已经是gin的3倍。但是使用actix-web的缺点也非常明显，就是写出正确的代码并不简单，rust的语法复杂，编译器非常严格。 ...
【Actix Web】构建高性能 Rust API：Actix Web 最佳实践与进阶指南
LCG元的博客
06-28 1032
本文介绍如何使用Rust生态中的高性能Web框架Actix Web构建RESTful API服务。主要内容包括： 高性能架构设计：采用多线程模型、Redis缓存、PostgreSQL主从分离等组件搭建高性能系统架构。 项目初始化：详细说明如何创建项目、配置Cargo.toml依赖和服务器参数。 核心模块实现：包含应用状态管理、数据模型定义等关键代码实现，使用Arc实现线程安全共享状态。 认证系统：基于JWT的认证流程和工具函数实现，包括Token生成与验证。 文章通过Mermaid图表展示系统架构和认证流程
【跟小嘉学 Rust 编程】三十三、Rust的Web开发框架之一: Actix-Web的基础
小嘉丶学长的博客
10-25 4292
本章节讲解 Rust的Web开发框架的介绍和对比。Actix Web、Axum、Rocket、Warp、Tide、Poem、Pavex、Hyper等框架。主要教材参考 《The Rust Programming Language》主要教材参考 《Rust For Rustaceans》主要教材参考 《The Rustonomicon》主要教材参考 《Rust 高级编程》主要教材参考 《Cargo 指南》主要教材参考 《Rust 异步编程》主要教材参考 《Rust 设计模式》
[Rust实战]初探 actix_web
学生董格
06-24 1836
Rust语言的特点 高性能- Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。 可靠性- Rust 丰富的类型系统和所有权模型保证了内存安全和线程安全，让您在编译期就能够消除各种各样的错误。 生产力- Rust 拥有出色的文档、友好的编译器和清晰的错误提示信息， 还集成了一流的工具 —— 包管理器和构建工具， 智能地自动补全和类型检验的多编辑器支持， 以及自动格式化代码等等。...
rust web框架actix （快速入门文档译）----基础（第一节）
小Y的博客
11-03 7117
入门 让我们编写第一个actix Web应用程序！ Hello, world! 首先创建一个新的基于二进制的Cargo项目并切换到新目录： cargo new hello-world cd hello-world 现在，通过确保您的Cargo.toml包含以下内容，将actix-web添加为项目的依赖项： [dependencies] actix-web = "0.7" 为了实现Web服务器，...
Actix-Web学习
笨笨D幸福 - 后花园
02-23 6554
Actix-web 学习 请求处理分为两个阶段。 首先调用处理程序对象，返回实现Responder trait的任何对象。 然后，在返回的对象上调用respond_to()，将其自身转换为AsyncResult或Error。 默认情况下，actix为一些标准类型提供响应器实现，比如静态str、字符串等。要查看完整的实现列表，请查看响应器文档。 基础的Demo extern crate actix_...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值