Axum路由

于 2024-09-13 08:00:00 发布
阅读量631 收藏 6
点赞数 16
分类专栏： 后端 文章标签： rust web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62799021/article/details/142005366
版权

main.rs

use axum::{
    routing::get,
    Router,
};
// 属性宏，将此函数标记为异步程序的入口点，启动一个异步运行时（Tokio 运行时）来执行这个异步函数
#[tokio::main]
async fn main() {
    // 创建路由实例
    let app = Router::new().route("/hello", get(|| async { "Hello, Axum!"}));
    // 使用hyper监听所有地址的9090端口，.await等待异步完成，绑定成功返回TcpListener实例，失败panic并打印错误信息
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    println!("->>LISTENING on {:?}",listener);
    // 使用serve函数启动一个异步服务器，监听TcpListener实例，并使用app作为处理函数
    axum::serve(listener, app).await.unwrap();
}

使用postman请求0.0.0.0:8080/hello可以看到返回了数据

Hello, Axum!

0.0.0.0表示所有ipv4地址，但不能被ping通

127.0.0.1表示回环地址。所有网络号为127的地址都是回环地址

Rust项目源代码发生变化时自动运行 Cargo 命令

# 安装（关闭杀毒软件）
cargo install cargo-watch

监听src/目录，更改代码自动重新执行cargo run

cargo watch -q -c -w src/ -x run

若要监听tests/目录，更改代码自动重新执行cargo test -q test_dev -- --nocapture测试并显示所有输出

cargo watch -q -c -w tests/ -x "test -q test_dev -- --nocapture"

axum::Router路由

闭包传递路由

闭包可以捕获调用者作用域中的值

use axum::{
    routing::get,
    Router,
    extract::Path,
};
// use tracing::info;
#[tokio::main]
async fn main() {

    let app = Router::new()
    .route("/", get(|| async { "Hello, Rust!" }))
    .route("/hello", get(|| async { "Hello, World!" }))
    .route("/tokio/:name", get(|name:Path<String>| async move{ format!("Hello,{:?}",name) }));

    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

还可以将路由函数提取出来，相同路由可以的不同处理可以通过.添加处理器并添加自定义方法，如.get().post().patch().delete()

use axum::{
    routing::get,
    Router,
};
use tokio::net::TcpListener;

// 获取
async fn get_handler() -> String {
    "Hello, world!".to_string()
}
// 创建
async fn post_handler() -> String {
    "post".to_string()
}
// 更新
async fn patch_handler() -> String {
    "update".to_string()
}
// 删除
async fn delete_handler() -> String {
    "delete".to_string()
}
#[tokio::main]
async fn main() {
    
    let app = Router::new()
       .route("/", get(get_handler))
       .route("/hello", get(get_handler).post(post_handler).patch(patch_handler).delete(delete_handler));

    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

幂等：一个操作被多次重复执行多次，其结果与第一次执行的结果相同

同样的请求被执行一次与连续执行多次，对服务器的预期影响是相同的，那么称这个 HTTP 方法是幂等的，如PUT、DELETE

所有的安全方法都是幂等的，如GET、HEAD、OPTIONS

安全：一个 HTTP 方法是安全的，是指这是个方法不会修改服务器的数据，即只读的方法，如GET、HEAD、OPTIONS

  • GET（获取资源）：请求资源
    • GET 请求是安全、幂等的
  • POST（创建资源）：通常用于向服务器提交数据以创建新的资源
    • POST 请求是不安全、不幂等的
    • POST 请求的主体可以包含任意格式的数据，例如表单数据、JSON 或 XML
  • PUT（更新资源）：更新服务器上的现有资源，客户端将完整的资源表示发送到服务器，服务器用这个表示替换现有的资源
    • PUT请求是不安全、幂等的
  • PATCH（部分更新资源）： PATCH 只需要提供资源的部分，服务器只更新指定的部分
    • PATCH请求是不安全、不幂等的
  • DELETE（删除资源）：删除指定的资源
    • DELETE请求是不安全、幂等的
  • HEAD（获取资源头信息）：只返回资源的头部信息，不返回资源的主体内容，用于检查资源的存在性、获取资源的大小、最后修改时间等信息，而不需要下载整个资源
  • OPTIONS（获取服务器支持的方法）：获取服务器支持的 HTTP 方法和其他选项信息，客户端发送 OPTIONS 请求以了解服务器对特定资源的支持情况
    • OPTIONS请求的响应通常包含一个Allow头部，列出服务器支持的方法
    • OPTIONS 请求可以用于客户端在发送实际请求之前了解服务器的能力和限制

路由匹配

:创建动态路由，可作为传递的值，必须有值才能匹配到

  • /hello/:id匹配/hello/12
  • /:id/hello匹配/12/hello

*创建通配符路由

  • /hello/*file匹配/hello/sssssssfile
  • 特殊/hello/*key不匹配/hello/但会匹配/hello/下的所有路由，如/hello/cci/cci/cci/

多个参数传递使用axum::extract::Path提取

路径只包含一个参数时，可以省略元组

use axum::{
    extract::Path,
    routing::get,
    Router,
};
use tokio::net::TcpListener;

// 获取
async fn get_handler() -> String {
    "Hello, world!".to_string()
}
async fn show_user(Path((user_id,team_id)):Path<(String,String)>)-> String {
    format!("{}_{}", user_id, team_id)
}
#[tokio::main]
async fn main() {
    
    let app = Router::new()
       .route("/", get(get_handler))
       .route("/users/:user_id/team/:team_id", get(show_user));
        
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

nest 嵌套路由

将路由嵌套在另一个路由下，例如将用户相关的路由嵌套在users下，请求路径必须包含users

  • 嵌套路由不会看到原始请求 URI，而是会删除匹配的前缀
  • 使用原始URI请使用axum::extract::OriginalUri
  • 嵌套路由和通配符路由功能类似，嵌套路由会删除前缀，通配符路由保留完整路由
use axum::{
    extract::Path,
    routing::{get,post},
    Router,
};
use tokio::net::TcpListener;
async fn show_user(Path(id): Path<String>) -> String {
    format!("id: {:?}", id)
}
async fn post_user() -> String {
    "post_user".to_string()
}
#[tokio::main]
async fn main() {
    let user_routes = Router::new().route("/:id", get(show_user));
    let team_routes = Router::new().route("/", post(post_user));

    let api_routes = Router::new()
    .nest("/users", user_routes)// GET /api/users/145632
    .nest("/teams", team_routes);// POST /api/teams/
    let app = Router::new().nest("/api", api_routes);
        
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

fallback 后备路由

fallback：后备，备用方案或回退机制，主要的操作或功能无法正常执行时，程序可以使用预先定义的 fallback来处理情况，以确保程序不会完全失败或崩溃

后背路由仅适用于路由中任何内容均不匹配的路由，创建路由后使用.fallback()添加后备路由

callback：区分回调函数

如果嵌套路由没有自己的后备，那么将继承外部路由的后备，以下例子

  • 当请求:8080/api/users/145632时可以匹配成功
  • 当请求:8080/test时，由于没有路由可以匹配，会执行/api定义的后备
  • 当请求:8080/api/users/时，由于没有路由可以匹配，会执行/users定义的后备
  • 当请求:8080/api/users/145632/test时，由于没有路由可以匹配，/:id路由没有定义后备路由，会执行外部的/users定义的后备
use axum::{
    http::Uri,
    extract::OriginalUri,
    routing::get,
    Router,
    http::StatusCode
};
use tokio::net::TcpListener;
async fn show_user(uri: Uri, OriginalUri(original_uri): OriginalUri) -> String {
    format!("uri: {:?}\noriginal_uri: {:?}\n", uri,original_uri)
}
async fn fallback_api() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "Not Found /api")
}
async fn fallback_users() -> (StatusCode, &'static str) {
    (StatusCode::NOT_FOUND, "Not Found /users")
}

#[tokio::main]
async fn main() {
    let user_routes = Router::new().route("/:id", get(show_user));

    let api_routes = Router::new()
    .nest("/users", user_routes).fallback(fallback_users);

    let app = Router::new().nest("/api", api_routes).fallback(fallback_api);
        
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

axum::extract::OriginalUri

获取原始URI

use axum::{
    http::Uri,
    extract::OriginalUri,
    routing::{get,post},
    Router,
};
use tokio::net::TcpListener;
async fn show_user(uri: Uri, OriginalUri(original_uri): OriginalUri) -> String {
    //uri: /145632
    //original_uri: /api/users/145632
    format!("uri: {:?}\noriginal_uri: {:?}\n", uri,original_uri)
}
async fn post_user() -> String {
    "post_user".to_string()
}
#[tokio::main]
async fn main() {
    let user_routes = Router::new().route("/:id", get(show_user));
    let team_routes = Router::new().route("/", post(post_user));

    let api_routes = Router::new()
    .nest("/users", user_routes)// GET \api\users\145632
    .nest("/teams", team_routes);// POST \api\teams\
    let app = Router::new().nest("/api", api_routes);
        
    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

merge 合并路由

将多个独立的路由组合到一起统一处理，例如两个模块中定义了路由，在主应用中合并为一个路由

use axum::{
    routing::get,
    Router,
    extract::Path,
};
use tokio::net::TcpListener;
async fn users_list() -> String {
    "users list".to_string()
}
async fn users_show(Path(id):Path<String>) -> String {
    format!("user show: {:?}",id)
}
async fn teams_list() -> String {
    "teams list".to_string()
}
#[tokio::main]
async fn main() {

    let user_routes = Router::new()
        .route("/users", get(users_list)) // GET :8080/users
        .route("/users/:id", get(users_show)); // GET :8080/users/145632

    let team_routes = Router::new()
        .route("/teams", get(teams_list)); // GET :8080/teams

    let app = Router::new()
        .merge(user_routes)
        .merge(team_routes);

    let listener = TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

路由还可以携带状态，如数据库连接、context，使用.with_state(state)，案例见https://github.com/SeaQL/sea-orm/blob/master/examples/axum_example/api/src/lib.rs

cci497
关注
专栏目录
【Rust实战】Axum + Nextjs 前后端全栈开发04：设计路由
编程不止
05-21 878
【Rust实战】Axum + Nextjs 前后端全栈开发04：设计路由
Rust - axum(01)分离路由模块
stark张宇
08-17 1897
网上有很多axum框架的教程，但是都不是那么详细，根据业务的需求，准备把原有的分布式更换成以Rust axum 的web微服务，认真记录当前的每一步拆解，供朋友们交流和学习。
Axum 框架教程
gitblog_00183的博客
08-13 285
Axum 框架教程 axumErgonomic and modular web framework built with Tokio, Tower, and Hyper项目地址:https://gitcode.com/gh_mirrors/ax/axum 项目介绍 Axum 是一个基于 Rust 的 Web 应用框架，专注于易用性和模块化。它利用了 Tokio 运行时和 Hyper 库，提供了宏...
Axum 项目教程
gitblog_00786的博客
08-15 322
Axum 项目教程 axumErgonomic and modular web framework built with Tokio, Tower, and Hyper项目地址:https://gitcode.com/gh_mirrors/ax/axum 项目的目录结构及介绍 Axum 是一个 Rust 编写的 Web 应用框架，其 GitHub 仓库的目录结构如下： axum/ ├── axu...
rust axum项目实践
Cassie的博客
02-22 3634
基于rust axum 完成web端手脚架 基础权限,用户,缓存,验证,代码生成 rust axum web 是rust开发的web手脚架项目
Rust Axum前后端分离项目-项目初始化
weixin_39141295的博客
06-28 356
【代码】Rust创建Axum项目。
Realworld Axum SQLx 项目教程
gitblog_00480的博客
08-09 261
Realworld Axum SQLx 项目教程 realworld-axum-sqlxA Rust implementation of the Realworld demo app spec using Axum and SQLx.项目地址:https://gitcode.com/gh_mirrors/re/realworld-axum-sqlx 1. 项目的目录结构及介绍 realworld...
Axum Server 开源项目教程
gitblog_00579的博客
08-23 280
Axum Server 开源项目教程 axum-serverHigh level server designed to be used with axum framework.项目地址:https://gitcode.com/gh_mirrors/ax/axum-server 1. 项目的目录结构及介绍 Axum Server 是一个基于 Rust 语言的 Web 框架，其目录结构清晰，便于理解...
RUST web框架axum快速入门教程
02-20
3. 基本概念：了解axum中的基本概念，如路由、请求处理、响应处理等。 4. 实现算法：在axum中实现算法是构建web应用的关键。本节将介绍如何在axum中实现常见的算法，如排序、查找等。 5. 难点解析：在实现算法的过程...
Axum Programmers Guide
04-17
《Axum程序员指南》是一本深入探讨Axum编程语言的专业书籍，主要面向正在学习或已经从事Axum开发的程序员。Axum是由微软开发的一种新型的、高性能的、并发友好的编程语言，它旨在提高现代多核处理器环境下的软件开发...
第十九章 rust服务器开发：axum框架详解
余识-
09-02 906
因为rust拥有着极高的性能，加上tokio这个非常优秀的运行时，这使得rust很适合被用于开发服务器。目前rust已经拥有了众多的web框架，例如rocket、axum、axtix-web、tide、warp等等。而axum这个web框架是由tokio团队所维护的，相对来说，可能在某些方面更加专业，所以本文也将以axum框架来介绍rust的web框架开发。也就是链式调用，get方法的返回值可以继续调用其上的post方法，传入post方法的处理函数。
【Rust日报】2021-07-31 Tokio 的 Web 框架 Axum
Rust语言学习交流
07-31 3268
Axum: Tokio 出品的 Web 框架这个框架一出，意味着 tokio 生态正在强势建立！算的上是 Rust Web 开发领域的里程碑事件！让其他 web 框架顿时失色！当然，我并不...
Rocket: 从零开始构建Rust Web服务
hello.reader
09-08 1059
作为一个现代化的Web框架，Rocket以其类型安全性、简洁的API和卓越的性能脱颖而出。无论你是想构建一个简单的静态网站，还是复杂的RESTful API，Rocket都能胜任。通过构建一个简单的用户管理API，我们体验了Rocket的路由、数据处理、中间件以及数据库集成。现在，让我们综合这些知识，构建一个简单的用户管理API，实现用户的创建和查询功能。中间件记录了每个请求的处理时间，并将其作为HTTP响应头的一部分返回给客户端，使得开发者可以轻松监控和优化应用的性能。
Rust 所有权 借用与引用
最新发布
HHX_01的博客
09-12 861
Rust的所有权、引用和借用机制提供了一种强大而安全的内存管理方式。通过这些机制，Rust能够在编译时避免许多常见的内存错误，如悬垂引用和数据竞争。尽管这些规则可能在开始时显得复杂，但它们为你提供了一个强大的工具集来编写安全、并发的代码。Rust的所有权系统是其安全性和性能的核心，它通过一套严格的规则来管理内存使用，防止数据竞争和悬垂引用。本文将详细探讨Rust中的引用、借用及其规则，并讨论如何利用这些特性来编写健壮的代码。借用是Rust中的一个重要概念，它允许函数在不获取所有权的情况下使用值。
Rust 所有权 简介
HHX_01的博客
09-12 288
所有权是Rust语言的核心特性之一，它为内存管理提供了全新的解决方案。掌握所有权机制，有助于我们编写更安全、高效的Rust代码。虽然所有权概念在初学者看来较为复杂，但只要勤加练习，相信大家都能熟练运用。在后续的学习中，我们将继续探讨Rust的其他高级特性。
rust解说
owolai的博客
09-12 340
Rust 是一种开源的系统编程语言，由 Mozilla 研究院开发，旨在提供高性能、内存安全且并发性良好的编程体验。Rust 于 2010 年由 Graydon Hoare 开始设计，并在 2015 年发布了第一个稳定版本。Rust 的设计目标是解决 C++ 等传统系统编程语言在内存安全和并发处理方面的挑战。
Rust 简介与安装
HHX_01的博客
09-09 935
Rust的介绍：Rust是一种系统编程语言，旨在提供安全性和性能，适用于需要高效内存管理和并发编程的场景。Rust的优点内存安全：Rust通过所有权系统（Ownership）避免了内存泄漏和数据竞争。性能：接近C/C++的性能，无需垃圾回收。并发支持：借助Rust的所有权系统，能够更安全地处理并发任务。现代语法：具备现代编程语言的特性，如模式匹配、泛型和闭包等。Rust的缺点学习曲线：对于新手来说，所有权和生命周期管理可能较难掌握。生态系统：虽然在不断增长，但相较于成熟的语言，仍然在发展中。
Rust的常量
brucexia的专栏
09-12 485
常量和变量是高级程序设计语言中数据的两种表现形式。这里我们先介绍常量，常量是指程序运行过程中值始终不变的量。常量的特点是一旦被定义就不能被修改或重新定义。常量可以是一个具体的数值或一个数学表达式。例如，数学中的圆周率π，就是一个常量，它的取值是固定且不能被改变的，又如1、2、1000、5.88等数值也是常量。在Rust中，常量分为直接常量和const常量。3.3.2。
rust后端框架Axum
07-23
以下是一个简单的示例，展示如何使用Rust后端框架Axum来创建一个基本的Web应用程序： 首先，确保您已经安装Rust和Cargo。然后，在您的项目目录中创建一个新的Cargo.toml文件，并添加以下内容： ```toml [package] name = "axum_example" version = "0.1.0" edition = "2021" [dependencies] axum = "0.2" tokio = { version = "1", features = ["full"] } ``` 接下来，创建一个main.rs文件，并添加以下代码： ```rust use axum::{handler::get, Router}; use std::net::SocketAddr; async fn hello_world() -> &'static str { "Hello, world!" } #[tokio::main] async fn main() { // 创建一个Axum应用程序的根路由 let app = Router::new().route("/", get(hello_world)); // 定义服务器的地址和端口 let addr = SocketAddr::from(([127, 0, 0, 1], 3000)); // 运行服务器 axum::Server::bind(&addr) .serve(app.into_make_service()) .await .unwrap(); } ``` 上述代码创建了一个简单的Axum应用程序，该应用程序定义了一个根路由"/"，并使用GET方法处理请求。处理程序函数hello_world返回一个字符串"Hello, world!"作为响应。 最后，打开终端，导航到您的项目目录，并运行以下命令来构建和运行应用程序： ``` cargo build cargo run ``` 您应该会看到类似于以下输出： ``` Listening on http://127.0.0.1:3000 ``` 现在，您可以在浏览器中访问http://127.0.0.1:3000，并应该看到"Hello, world!"的响应。 这只是Axum的一个简单示例，您可以根据需要添加更多的路由和处理程序来构建更复杂的应用程序。Axum提供了许多功能和中间件，使您能够处理不同类型的请求和实现复杂的业务逻辑。您可以参考Axum的官方文档以获得更多详细信息和示例代码：https://docs.rs/axum/0.2.5/axum/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

cci497

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值