Actix-Web路由

最新推荐文章于 2025-11-28 06:18:53 发布
原创 最新推荐文章于 2025-11-28 06:18:53 发布 · 338 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#前端 #数据库 #java #mysql #服务器

一、路由

上一篇文章，介绍了Actix-Web入门知识，链接如下：https://www.cnblogs.com/xiao987334176/p/19271995

接下来介绍路由

基础路由

修改主代码 src/main.rs

use actix_web::{get, post, put, delete, web, HttpResponse};
use serde::{Deserialize, Serialize};
 
#[derive(Serialize, Deserialize)]
struct User {
    id: u32,
    name: String,
    email: String,
}
 
// GET 请求
#[get("/users")]
async fn get_users() -> HttpResponse {
    let users = vec![
        User {
            id: 1,
            name: "Alice".to_string(),
            email: "alice@example.com".to_string(),
        },
        User {
            id: 2,
            name: "Bob".to_string(),
            email: "bob@example.com".to_string(),
        },
    ];
    
    HttpResponse::Ok().json(users)
}
 
// GET 请求(带路径参数)
#[get("/users/{id}")]
async fn get_user(path: web::Path<u32>) -> HttpResponse {
    let user_id = path.into_inner();
    
    let user = User {
        id: user_id,
        name: "Alice".to_string(),
        email: "alice@example.com".to_string(),
    };
    
    HttpResponse::Ok().json(user)
}
 
// POST 请求(创建资源)
#[post("/users")]
async fn create_user(user: web::Json<User>) -> HttpResponse {
    println!("创建用户: {:?}", user.name);
    HttpResponse::Created().json(user.into_inner())
}
 
// PUT 请求(更新资源)
#[put("/users/{id}")]
async fn update_user(
    path: web::Path<u32>,
    user: web::Json<User>,
) -> HttpResponse {
    let user_id = path.into_inner();
    println!("更新用户 {}: {:?}", user_id, user.name);
    HttpResponse::Ok().json(user.into_inner())
}
 
// DELETE 请求
#[delete("/users/{id}")]
async fn delete_user(path: web::Path<u32>) -> HttpResponse {
    let user_id = path.into_inner();
    println!("删除用户: {}", user_id);
    HttpResponse::NoContent().finish()
}

以上是示例代码，看不出效果。接下来，将以上接口注册到Swagger

use actix_web::{delete, get, post, put, web, App, HttpResponse, HttpServer, Responder};
use serde::{Deserialize, Serialize};
use utoipa::{OpenApi, ToSchema};
use utoipa_swagger_ui::SwaggerUi;

#[derive(Serialize, Deserialize, ToSchema, Clone, Debug)]
struct User {
    id: u32,
    name: String,
    email: String,
}

/* ---------- hello ---------- */
#[derive(Serialize, ToSchema)]
struct HelloReply {
    message: String,
}

/// 根路径接口
#[utoipa::path(
    get,
    path = "/",
    responses((status = 200, description = "Say hello", body = HelloReply)),
    tag = "hello"
)]
#[get("/")]
async fn hello() -> impl Responder {
    web::Json(HelloReply {
        message: "Hello, world!".to_owned(),
    })
}

/* ---------- user ---------- */
/// 列表用户
#[utoipa::path(
    get,
    path = "/users",
    responses((status = 200, description = "用户列表", body = Vec<User>)),
    tag = "user"
)]
#[get("/users")]
async fn get_users() -> HttpResponse {
    HttpResponse::Ok().json(vec![
        User { id: 1, name: "Alice".into(), email: "alice@example.com".into() },
        User { id: 2, name: "Bob".into(),   email: "bob@example.com".into() },
    ])
}

/// 根据 ID 查用户
#[utoipa::path(
    get,
    path = "/users/{id}",
    params(("id" = u32, Path, description = "用户主键")),
    responses((status = 200, description = "单个用户", body = User)),
    tag = "user"
)]
#[get("/users/{id}")]
async fn get_user(id: web::Path<u32>) -> HttpResponse {
    HttpResponse::Ok().json(User {
        id: *id,
        name: "Alice".into(),
        email: "alice@example.com".into(),
    })
}

/// 新建用户
#[utoipa::path(
    post,
    path = "/users",
    request_body = User,
    responses((status = 201, description = "创建成功", body = User)),
    tag = "user"
)]
#[post("/users")]
async fn create_user(user: web::Json<User>) -> HttpResponse {
    HttpResponse::Created().json(user.into_inner())
}

/// 更新用户
#[utoipa::path(
    put,
    path = "/users/{id}",
    params(("id" = u32, Path, description = "用户主键")),
    request_body = User,
    responses((status = 200, description = "更新成功", body = User)),
    tag = "user"
)]
#[put("/users/{id}")]
async fn update_user(id: web::Path<u32>, user: web::Json<User>) -> HttpResponse {
    let _ = id.into_inner();
    HttpResponse::Ok().json(user.into_inner())
}

/// 删除用户
#[utoipa::path(
    delete,
    path = "/users/{id}",
    params(("id" = u32, Path, description = "用户主键")),
    responses((status = 204, description = "删除成功")),
    tag = "user"
)]
#[delete("/users/{id}")]
async fn delete_user(id: web::Path<u32>) -> HttpResponse {
    let _ = id.into_inner();
    HttpResponse::NoContent().finish()
}

/// OpenApi 文档
#[derive(OpenApi)]
#[openapi(
    paths(hello, get_users, get_user, create_user, update_user, delete_user),
    components(schemas(HelloReply, User)),
    tags(
        (name = "hello", description = "hello接口"),
        (name = "user",    description = "用户管理接口")
    )
)]
struct ApiDoc;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
    log::info!("Starting HTTP server on http://127.0.0.1:8080");

    HttpServer::new(|| {
        App::new()
            .service(hello)
            .service(get_users)
            .service(get_user)
            .service(create_user)
            .service(update_user)
            .service(delete_user)
            .service(
                SwaggerUi::new("/swagger-ui/{_:.*}")
                    .url("/api-doc/openapi.json", ApiDoc::openapi()),
            )
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

重新运行，访问Swagger UI：http://localhost:8080/swagger-ui/

image

这样就比较清晰了，接口做了分组显示。

先来测试列表用户，点击“Try it out”调试，可以看到返回了2条用户信息

image

查询参数与表单处理

 修改主代码 src/main.rs

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

 
#[derive(Deserialize)]
struct QueryParams {
    page: Option<u32>,
    limit: Option<u32>,
    search: Option<String>,
}
 
// 查询参数
#[get("/search")]
async fn search(query: web::Query<QueryParams>) -> HttpResponse {
    let page = query.page.unwrap_or(1);
    let limit = query.limit.unwrap_or(10);
    let search_term = query.search.as_deref().unwrap_or("");
    
    HttpResponse::Ok().json(serde_json::json!({
        "page": page,
        "limit": limit,
        "search": search_term,
        "results": []
    }))
}
 
// 表单数据
#[derive(Deserialize)]
struct LoginForm {
    username: String,
    password: String,
}
 
#[post("/login")]
async fn login(form: web::Json<LoginForm>) -> HttpResponse {
    println!("登录用户: {}", form.username);
    
    // 模拟验证
    if form.username == "admin" && form.password == "password" {
        HttpResponse::Ok().json(serde_json::json!({
            "status": "success",
            "token": "mock-jwt-token"
        }))
    } else {
        HttpResponse::Unauthorized().json(serde_json::json!({
            "status": "error",
            "message": "Invalid credentials"
        }))
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
    log::info!("Starting HTTP server on http://127.0.0.1:8080");

    HttpServer::new(|| {
        App::new()
            .service(search)
            .service(login)
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

重新运行，访问：http://127.0.0.1:8080/search

效果如下：

image

使用postman调用接口，http://127.0.0.1:8080/login

指定请求头类型为json

image

 输出json参数

{
    "username":"admin",
    "password":"password"
}

请求接口，就可以得到json返回信息，效果如下

image

路由组织(Scope)

use actix_web::{web,get,post, HttpResponse,HttpServer,App};
use serde::Deserialize;
use actix_web::web::Path; 

 
#[derive(Deserialize)]
struct QueryParams {
    page: Option<u32>,
    limit: Option<u32>,
    search: Option<String>,
}
 
// 查询参数
#[get("/search")]
async fn search(query: web::Query<QueryParams>) -> HttpResponse {
    let page = query.page.unwrap_or(1);
    let limit = query.limit.unwrap_or(10);
    let search_term = query.search.as_deref().unwrap_or("");
    
    HttpResponse::Ok().json(serde_json::json!({
        "page": page,
        "limit": limit,
        "search": search_term,
        "results": []
    }))
}
 
// 表单数据
#[derive(Deserialize)]
struct LoginForm {
    username: String,
    password: String,
}
 
#[post("/login")]
async fn login(form: web::Json<LoginForm>) -> HttpResponse {
    println!("登录用户: {}", form.username);
    
    // 模拟验证
    if form.username == "admin" && form.password == "password" {
        HttpResponse::Ok().json(serde_json::json!({
            "status": "success",
            "token": "mock-jwt-token"
        }))
    } else {
        HttpResponse::Unauthorized().json(serde_json::json!({
            "status": "error",
            "message": "Invalid credentials"
        }))
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(env_logger::Env::default().default_filter_or("info"));
    log::info!("Starting HTTP server on http://127.0.0.1:8080");

    HttpServer::new(|| {
        App::new()
            // API v1 路由组
            .service(
                web::scope("/api/v1")
                    .service(
                        web::scope("/users")
                            .service(search)
                    )
                    .service(
                        web::scope("/posts")
                            .route("", web::get().to(get_posts))
                            .route("/{id}", web::get().to(get_post))
                    )
            )
            // API v2 路由组
            .service(
                web::scope("/api/v2")
                    .service(search)
            )
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

async fn get_posts() -> HttpResponse {
    HttpResponse::Ok().json(Vec::<String>::new())
}
 

async fn get_post(id: Path<PostId>) -> HttpResponse {
    println!("收到 post id: {}", id.id);          // <-- 这里打印id
    HttpResponse::Ok().json(serde_json::json!({
        "post_id": id.id
    }))
}

// 路径参数结构体
#[derive(serde::Deserialize)]
struct PostId {
    id: String,   // 如果想用 u32 也行，这里先用 String 更宽松
}

路由结构可视化：

/api/v1
  ├── /users
  │   ├── GET    /          (获取用户列表)
  │   ├── GET    /{id}      (获取单个用户)
  │   ├── POST   /          (创建用户)
  │   ├── PUT    /{id}      (更新用户)
  │   └── DELETE /{id}      (删除用户)
  └── /posts
      ├── GET    /          (获取文章列表)
      └── GET    /{id}      (获取单篇文章)

以上代码，可以访问以下几个接口

api v1

http://127.0.0.1:8080/api/v1/users/search

image

 http://127.0.0.1:8080/api/v1/posts

输出：[]

http://127.0.0.1:8080/api/v1/posts/123

这里会打印出id参数

image

api v2

http://127.0.0.1:8080/api/v2/search

image

本文参考链接：https://blog.youkuaiyun.com/sinat_41617212/article/details/154069236

shykevin
关注
36、使用Rust的Actix-web构建Web应用
linux的博客
07-11 145
本文详细介绍了如何使用Rust的Actix-web框架构建一个书签管理的REST API服务linksnap。通过内存中的HashMap实现链接数据的存储，并展示了路由处理、状态管理及actor模型的结合应用，突出了Rust语言在Web开发中高效、安全和高性能的优势。
基于Rust语言的rust-actix-web框架的Web架构设计与源码自学指南
02-07
随着学习的深入，学习者可以尝试阅读更复杂的源码部分，如路由、中间件、消息处理等，这些都是构建Web应用不可或缺的组成部分。 在学习的过程中，遇到问题是非常正常的现象。此时，学习者可以参考网络上的教程、...
Actix-web Rust Web 框架入门指南
backendbridge的博客
10-02 871
Actix-web是Rust生态中高性能的Web框架，具有出色的并发处理能力和内存安全保障。文章介绍了如何搭建开发环境、创建Hello World示例，并详细讲解了Actix-web的核心功能：灵活的路由系统（支持宏和资源配置两种方式）、多种请求处理方式（路径参数、查询字符串和JSON请求体）、丰富的响应处理以及中间件机制（内置日志和压缩功能，支持自定义中间件）。该框架充分利用Rust的类型安全和异步特性，是构建高效Web应用的理想选择。
actix-web -介绍
大怀特的博客
12-07 3966
快速入门安装RustHello,world! 安装Rust 如果你没有安装rust,我们推荐你使用rustup来管理你的rust安装. 官方rust指导有精彩部分来入门. Actix web 当前最低支持Rust1.4.2版本.运行rustup update来保证你有最近和最高Rust可用版本.因此这个指南假设你运行Rust1.42或更高版本. Hello,world! 开始通过创建一个新的基础Cargo的二进制项目并进入 新目录. cargo new hello-world cd hello-world
Rust Web开发框架对比：Warp与Actix-web
Dontla的博客
09-14 2601
Warp是一个基于异步编程的轻量级Web框架，构建在高性能的异步运行时Tokio之上。Warp的核心理念是Filter（过滤器），通过组合不同的过滤器来构建Web应用。主要特点类型安全且可组合的过滤器系统内置WebSocket支持友好的错误处理机制简洁的API设计Actix-web是一个功能丰富、高性能的Web框架，同样基于Tokio运行时。它采用了Actor模型，擅长处理高并发和复杂的异步操作。主要特点基于Actor模型的并发处理丰富的中间件支持强大的生态系统优异的性能表现。
Rust Actix-web框架源码解析：基于Actor模型的高性能Web开发
热门推荐
Rqaqedamancy的博客
10-27 1万+
fill:#fff;color:#fff;color:#fff;fill:none;important;important;important;color:#fff!important;important;important;important;color:#fff!important;important;important;important;color:#fff!important;important;important;important;color:#fff!important;important。
Actix-webRust Web框架入门教程
systemseer的博客
09-15 889
Actix-web是Rust生态中高性能的Web框架，以极致性能、类型安全和异步支持著称。本文介绍了如何快速搭建一个Actix-web应用，包括环境配置、创建"Hello World"示例、理解路由处理机制、请求响应处理方式（路径参数、查询参数、JSON）、中间件使用以及状态管理。通过一个简单的计数器示例和待办事项API的CRUD操作演示，展示了Actix-web的核心功能和应用场景，帮助开发者快速入门这一强大的Rust Web框架。
Actix-Web 框架实战：构建高性能 RESTful API 服务
七夜的博客
10-29 1137
Actix-Web 是 Rust 生态中高性能 Web 框架，基于 Actor 模型和 Tokio 异步运行时。本文涵盖其核心架构、路由系统、中间件开发和数据库集成。通过博客 API 项目实战，讲解 RESTful 服务构建全流程，包括路由组织（Scope）、共享状态（AppData）、连接池配置等。关键优势包括极高性能（700 万+ req/sec）、类型安全和强大的异步支持。还涉及错误处理、性能优化（压缩/连接池）及生产级问题讨论，为开发者提供构建可靠 Web 服务的完整指南。
构建第一个Actix-Web健康检查端点
weixin_35835030的博客
05-10 363
本文介绍了如何在Actix-Web框架中创建一个简单的健康检查端点。我们将深入探讨App组件、路由添加、异步运行时tokio的使用，以及如何编写第一个集成测试，确保我们的API端点按照预期工作。
Actix-web 3.0 中文使用指南
gitblog_00166的博客
09-15 1215
Actix-web 3.0 中文使用指南 项目介绍 Actix-web 是一个高效的 Rust Web 框架，以其高性能、可扩展性和异步编程模型而闻名。这个特定的仓库 https://github.com/dslchd/actix-web3-CN-doc 是 Actix-web 3.0 的中文文档翻译版本，旨在帮助那些更偏好中文阅读的开发者更好地理解和应用该框架。虽然文档试图忠实于原始英文文档的内...
精选资源
actix-swagger：用于actix-web框架的Swagger代码生成器
02-06
7. **使用方法**：使用actix-swagger通常需要在actix-web应用中导入相应的依赖，定义API路由和响应，然后通过actix-swagger自动生成OpenAPI描述，最后可以将生成的文档集成到Web服务器，提供在线的API文档查看和测试...
如何使用Rust和Actix-web框架构建一个基本的Web API管理系统
10-08
Actix-web以其轻量级、高性能、反应式编程范式、强类型路由系统以及支持异步编程能力而著称。 构建Web API管理系统时，后端服务通常包括实现API端点以接收和响应HTTP请求。一个基本的Web API管理系统应该至少具备...
精选资源
actix-web：Actix Web是一个功能强大，实用且快速的Rust Web框架。
02-05
2. **HTTP支持**：Actix Web提供全面的HTTP/1.1和HTTP/2支持，包括常见的HTTP方法、状态码、首部和路由处理。开发者可以使用清晰的API定义路由规则，如路径参数、查询参数和HTTP方法匹配。 3. **WebSockets支持**：...
actix-web-单线程
02-15
创建一个简单的 Actix-web 单线程服务，你需要定义一个处理函数（Handler），然后设置路由来匹配 HTTP 请求。以下是一个基本示例： ```rust use actix_web::{web, App, HttpServer}; async fn index() -> String {...
前端在移动端中的页面切换
2509_93939582的博客
11-28 205
记得加硬件加速，用transform和opacity属性，别动不动改布局属性（比如width或height），那样容易引发重排重绘，卡成幻灯片。不过，SPA也不是万能药，它初次加载可能慢点，得靠代码分割和懒加载来优化——比如把不常用的模块拆开，等用户需要时再加载，这样既省资源又提速。还有，别忘了图片和视频的懒加载：页面切换时，先加载核心内容，图片等可视区域再加载，这样首屏能秒开。另外，内存管理也得注意，SPA容易内存泄漏，切换页面时记得清理事件监听器和定时器，不然用久了手机会变卡。
MyBatis + PageHelper 分页内幕，PageHelper 是如何动态构建 LIMIT 分页 SQL 的
日常笔记 | 干货分享 | 毕设源码 | 毕设指导 | 答辩指导
11-26 637
若依系统中有很多的表格数据、后端接口实体中并没有看到有接收分页大小和页码的属性，在系统的mapper层面SQL语句中并没有看到对应的分页限制。它是如何实现这个分页效果的呢？是将所有的数据查询出来，然后再分页吗？这样效率岂不是非常低。带着这样的疑问，稍微研究了一下这个系统的分页方法。更多详细文章后端是通过从 HttpServletRequest 对象中获取分页的页码和大小，然后创建Page分页对象，在执行sql查询的时候，动态构建分页限制条件。从而实现分页，并不是在查询到所有数据之后再进行的分页处理。
一文让你了解UI自动化测试
HUACE4600的博客
11-26 759
这些资料，对于做【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴我走过了最艰难的路程，希望也能帮助到你！凡事要趁早，特别是技术行业，一定要提升技术功底。
springBoot 2.x.x MetaObjectHandler自动填充不生效
Billow_lamb的博客
11-27 88
这个文件在全局拦截中做处理 通过前端的请求头里面去解析token信息 然后去redis 的key的匹配前端的token 在通过redis去解析 拿到 当前登录用户信息。MetaObjectHandler自动填充不生效 踩空日记。企鹅群 398913416。
前端跨域解决方案
最新发布
2509_93942660的博客
11-28 222
如果涉及带凭证的请求，比如cookie，还得加Access-Control-Allow-Credentials: true，并且Origin不能是通配符。原理很简单，前端请求发给同域的代理，代理再转发给目标服务器，绕过浏览器限制。比如，你页面里嵌了个第三方iframe，想和它通信，就可以用window.postMessage发消息，对方用message事件接收。JSONP适合老项目，CORS是首选标准，代理在开发时好用，WebSocket专攻实时，postMessage处理iframe问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值