使用Rust编写一个web todolist应用

最新推荐文章于 2024-09-08 11:00:00 发布
最新推荐文章于 2024-09-08 11:00:00 发布
阅读量592 收藏 7
点赞数 5
文章标签： rust 开发语言 后端 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QZXSY1/article/details/140856937
版权

使用rust编写一个web服务不如使用java提供的spring boot一样简单，需要手工去添加依赖，目前rust web生态已趋近成熟，可以尝试进行web开发。

本次开发的服务使用的依赖有

  • axum：一个专注于生态和模块化的web应用开发框架
  • serde：rust中数据的泛用性序列化/反序列化库
  • tokio：异步运行时库
  • tower：为server/client提供模块化和可重用的库
  • tower-http：专为HTTP协议提供的模块化和可重用的库
  • tracing：日志库
  • tracing-subscriber：给tracing日志库提供工具和组合消费者的方法，这个可以提供给axum使用
  • bb8：连接池，基于tokio
  • bb8_postgres：连接池，专为postgres提供

做一个简单的Web应用，有以下几个步骤

  1. 设置db schema
  2. 编写对应schema的rust struct
  3. 规划router，加入http endpoints
  4. 规划handlers
  5. 规划前后端的数据交互格式
  6. 写代码
  7. 测试

我们一步一步来，首先我们先创建一个应用

cargo new todolist

然后，我们添加依赖，这里我们使用cargo add 添加

cargo add axum serde tokio tower tower-http tracing tracing-subscriber bb8 bb8-postgres clap --features serde/derive,tokio/rt-multi-thread,tower-http/fs,tower-http/trace,clap/derive

这样的话，就不用添加版本了。

这里我们建一个简单的数据库

create database todolist;

create table todo (
	id serial  primary key,
	description varchar(512) not null,
	completed bool not null
);

然后我们正式进入我们的代码部分：

定义postgresql连接，这里我使用了clip库，从命令行传入数据连接参数

// 定义传入参数模型
#[derive(Parser, Debug)]
#[command(version, about, long_about=None)]
struct Args {
    #[arg(short='H', long)]
    host: String,
    #[arg(short, long)]
    user: String,
    #[arg(short, long)]
    password: String,
    #[arg(short, long)]
    dbname: String,
}

// 主体部分，建立postgreSQL的数据库连接
let args = Args::parse();
let connection_str = format!("host={} user={} password={} dbname={}", args.host,args.user,args.password,args.dbname);
let manager = PostgresConnectionManager::new_from_stringlike(connection_str, NoTls).unwrap();
let pool = Pool::builder().build(manager).await.unwrap();

这里，我使用了axum中的AppState来管理全局所要使用的变量，在axum中使用Router::new()提供的with_state，值得注意的是，这里的struct必须实现Clone trait。

#[derive(Clone)]
struct MyAppState {
    dbpool: Pool<PostgresConnectionManager<NoTls>>,
}

接下来，我们定义初始化日志模块

tracing_subscriber::fmt::init();

一行代码就能搞定。

然后我们定义几个model，注意这里面实现的trait，serde提供的Serialize，Deserialize，还有Debug, Clone。

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Todo {
    id: i32,
    description: String,
    completed: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct CreateTodo {
    description: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct UpdateTodo {
    id: i32,
    description: Option<String>,
    completed: Option<bool>
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct ResultWrapper<T> {
    code: u32,
    message: String,
    data: Option<T>,
}

接下来我们定义handler，分别是获取todo数据列表，新建数据列表和删除数据列表

这里要求返回的结果必须实现IntoResponse，否则无法在axum的Route中注册，可以使用axum提供的Json Struct包括数据和结果，这样就能将数据正常转换为Respone。

State则在axum中进行注册，可以直接在参数列表中传入，这里bb8提供的Pool，不用考虑所有权，不使用clone，直接进行get使用。

返回的结果为一个tuple，第一元素为状态码，第二个为参数。

async fn todo_list(State(app_state): State<MyAppState>) -> impl IntoResponse {
    match app_state.dbpool.get().await {
        Ok(db) => match db.query("SELECT * FROM todo", &[]).await {
            Ok(rows) => {
                let data: Vec<Todo> = rows.into_iter().map(|i| {
                    Todo {
                        id: i.get(0),
                        description: i.get(1),
                        completed: i.get(2)
                    }
                }).collect();
                (StatusCode::OK, Json(ResultWrapper{code: 0, message: "ok".to_string(), data: Some(data)}))
            }, Err(e) => {
                (StatusCode::INTERNAL_SERVER_ERROR, Json(ResultWrapper{code: 500, message: e.to_string(), data: None}))
            }
        }, Err(e) => {
            (StatusCode::INTERNAL_SERVER_ERROR, Json(ResultWrapper{code: 500, message: e.to_string(), data: None}))
        }
    }
}

async fn todo_delete(State(pool): State<MyAppState>, Json(id): Json<i32>) -> impl IntoResponse {
    match pool.dbpool.get().await {
        Ok(db) => match db.execute("DELETE FROM todo WHERE id = $1", &[&id]).await {
            Ok(r) => {
                tracing::info!("todo list id {} had been deleted", id);
                (
                    StatusCode::OK,
                    Json(ResultWrapper {
                        code: 0,
                        message: "ok".to_string(),
                        data: Some(r),
                    }),
                )
            }
            Err(e) => (
                StatusCode::BAD_REQUEST,
                Json(ResultWrapper {
                    code: 500,
                    message: e.to_string(),
                    data: None,
                }),
            ),
        },
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ResultWrapper {
                code: 500,
                message: e.to_string(),
                data: None,
            }),
        ),
    }
}

async fn todo_create(
    State(pool): State<MyAppState>,
    Json(input): Json<CreateTodo>,
) -> impl IntoResponse {
    match pool.dbpool.get().await {
        Ok(db) => {
            match db
                .query(
                    "INSERT INTO todo (description, completed) VALUES ($1, FALSE) RETURNING id",
                    &[&input.description],
                )
                .await
            {
                Ok(rows) => {
                    if let Some(row) = rows.get(0) {
                        let id: i32 = row.get(0);
                        (
                            StatusCode::OK,
                            Json(ResultWrapper {
                                code: 0,
                                message: "ok".to_string(),
                                data: Some(id),
                            }),
                        )
                    } else {
                        (
                            StatusCode::INTERNAL_SERVER_ERROR,
                            Json(ResultWrapper {
                                code: 400,
                                message: "no return data".to_string(),
                                data: None,
                            }),
                        )
                    }
                }
                Err(e) => (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    Json(ResultWrapper {
                        code: 500,
                        message: e.to_string(),
                        data: None,
                    }),
                ),
            }
        }
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ResultWrapper {
                code: 500,
                message: e.to_string(),
                data: None,
            }),
        ),
    }
}

我们看一下，axum的主体部分，即路由注册和端口注册启动这个环节

这里面有：

  • 注册路由
  • 添加app_state
  • 增加日志部分
  • 启动web server服务
let app = Router::new()
   .route("/", post(todo_create))
   .route("/", delete(todo_delete))
   .route("/", get(todo_list))
   .with_state(my_state)
   .layer(TraceLayer::new_for_http());

let listener = tokio::net::TcpListener::bind("127.0.0.1:8889")
   .await
   .unwrap();
axum::serve(listener, app).await.unwrap();

这样，整体一个简单的todolist webserver就已完成，这里面还有一个update部分没有编写，不过仿照上面的handler也可以编写出来。

下面是整体代码

use axum::{
    extract::State,
    http::StatusCode,
    response::IntoResponse,
    routing::{delete, get, post},
    Json, Router,
};
use bb8::Pool;
use bb8_postgres::{tokio_postgres::NoTls, PostgresConnectionManager};
use clap::Parser;
use serde::{Deserialize, Serialize};
use tower_http::trace::TraceLayer;

#[derive(Parser, Debug)]
#[command(version, about, long_about=None)]
struct Args {
    #[arg(short = 'H', long)]
    host: String,
    #[arg(short, long)]
    user: String,
    #[arg(short, long)]
    password: String,
    #[arg(short, long)]
    dbname: String,
}

#[derive(Clone)]
struct MyAppState {
    dbpool: Pool<PostgresConnectionManager<NoTls>>,
}

#[tokio::main]
async fn main() {
    let args = Args::parse();
    let connection_str = format!(
        "host={} user={} password={} dbname={}",
        args.host, args.user, args.password, args.dbname
    );

    let manager = PostgresConnectionManager::new_from_stringlike(connection_str, NoTls).unwrap();
    let pool = Pool::builder().build(manager).await.unwrap();
    let my_state = MyAppState { dbpool: pool };

    tracing_subscriber::fmt::init();

    let app = Router::new()
        .route("/", post(todo_create))
        .route("/", delete(todo_delete))
        .route("/", get(todo_list))
        .with_state(my_state)
        .layer(TraceLayer::new_for_http());

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

#[derive(Debug, Serialize, Deserialize, Clone)]
struct Todo {
    id: i32,
    description: String,
    completed: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct CreateTodo {
    description: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct UpdateTodo {
    id: i32,
    description: Option<String>,
    completed: Option<bool>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
struct ResultWrapper<T> {
    code: u32,
    message: String,
    data: Option<T>,
}

async fn todo_list(State(app_state): State<MyAppState>) -> impl IntoResponse {
    match app_state.dbpool.get().await {
        Ok(db) => match db.query("SELECT * FROM todo", &[]).await {
            Ok(rows) => {
                let data: Vec<Todo> = rows
                    .into_iter()
                    .map(|i| Todo {
                        id: i.get(0),
                        description: i.get(1),
                        completed: i.get(2),
                    })
                    .collect();
                (
                    StatusCode::OK,
                    Json(ResultWrapper {
                        code: 0,
                        message: "ok".to_string(),
                        data: Some(data),
                    }),
                )
            }
            Err(e) => (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(ResultWrapper {
                    code: 500,
                    message: e.to_string(),
                    data: None,
                }),
            ),
        },
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ResultWrapper {
                code: 500,
                message: e.to_string(),
                data: None,
            }),
        ),
    }
}

async fn todo_delete(State(pool): State<MyAppState>, Json(id): Json<i32>) -> impl IntoResponse {
    match pool.dbpool.get().await {
        Ok(db) => match db.execute("DELETE FROM todo WHERE id = $1", &[&id]).await {
            Ok(r) => {
                tracing::info!("todo list id {} had been deleted", id);
                (
                    StatusCode::OK,
                    Json(ResultWrapper {
                        code: 0,
                        message: "ok".to_string(),
                        data: Some(r),
                    }),
                )
            }
            Err(e) => (
                StatusCode::BAD_REQUEST,
                Json(ResultWrapper {
                    code: 500,
                    message: e.to_string(),
                    data: None,
                }),
            ),
        },
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ResultWrapper {
                code: 500,
                message: e.to_string(),
                data: None,
            }),
        ),
    }
}

async fn todo_create(
    State(pool): State<MyAppState>,
    Json(input): Json<CreateTodo>,
) -> impl IntoResponse {
    match pool.dbpool.get().await {
        Ok(db) => {
            match db
                .query(
                    "INSERT INTO todo (description, completed) VALUES ($1, FALSE) RETURNING id",
                    &[&input.description],
                )
                .await
            {
                Ok(rows) => {
                    if let Some(row) = rows.get(0) {
                        let id: i32 = row.get(0);
                        (
                            StatusCode::OK,
                            Json(ResultWrapper {
                                code: 0,
                                message: "ok".to_string(),
                                data: Some(id),
                            }),
                        )
                    } else {
                        (
                            StatusCode::INTERNAL_SERVER_ERROR,
                            Json(ResultWrapper {
                                code: 400,
                                message: "no return data".to_string(),
                                data: None,
                            }),
                        )
                    }
                }
                Err(e) => (
                    StatusCode::INTERNAL_SERVER_ERROR,
                    Json(ResultWrapper {
                        code: 500,
                        message: e.to_string(),
                        data: None,
                    }),
                ),
            }
        }
        Err(e) => (
            StatusCode::INTERNAL_SERVER_ERROR,
            Json(ResultWrapper {
                code: 500,
                message: e.to_string(),
                data: None,
            }),
        ),
    }
}

依赖的版本为

[dependencies]
axum = "0.7.5"
bb8 = "0.8.5"
bb8-postgres = "0.8.1"
clap = { version = "4.5.13", features = ["derive"] }
serde = { version = "1.0.204", features = ["derive"] }
tokio = { version = "1.39.2", features = ["rt-multi-thread"] }
tower = "0.4.13"
tower-http = { version = "0.5.2", features = ["fs", "trace"] }
tracing = "0.1.40"
tracing-subscriber = "0.3.18"
QZXSY1
关注
Rust Web框架怎么选？研究本文就够了！
weixin_45583158的博客
02-24 3万+
作者简介：成锁元，Westar实验室技术专家。Westar实验室（westar.io），成立于 2018 年，关注于区块链及分布式前沿技术，包括区块链分层架构、二层路由，网络性能、智能合...
5 个开源的 Rust Web 开发框架，你选择哪个？
m0_52789121的博客
07-29 5360
在它的主要优点中，它列出了一个像React和Elm那样的基于组件的框架，由于对多线程的支持和JavaScript的互操作性，它具有出色的性能。到目前为止，它还没有生产就绪，但是对于内部工具来说，它应该是一个非常好的选择，特别是如果想使用WASM的场景。Rust拥有非常活跃和快节奏的开源生态系统，有大量的贡献者在做着许多很棒的项目，Rust几乎可以构建一切。它是高度可定制化的，可以快速启动一个新的应用程序。对于一个web框架来说，它是相当小巧的，并且只提供基本的开箱即用的功能。...
todo-rs：用Rust编写的待办事项清单
02-14
todo-rs：用Rust编写的待办事项清单
Rocket: 从零开始构建Rust Web服务
最新发布
hello.reader
09-08 1320
作为一个现代化的Web框架，Rocket以其类型安全性、简洁的API和卓越的性能脱颖而出。无论你是想构建一个简单的静态网站，还是复杂的RESTful API，Rocket都能胜任。通过构建一个简单的用户管理API，我们体验了Rocket的路由、数据处理、中间件以及数据库集成。现在，让我们综合这些知识，构建一个简单的用户管理API，实现用户的创建和查询功能。中间件记录了每个请求的处理时间，并将其作为HTTP响应头的一部分返回给客户端，使得开发者可以轻松监控和优化应用的性能。
Rust-AI todo list 开发体验
欢迎来到我的博客！我是一名拥有10年以上经验的系统架构师。在这个博客中，我将与大家分享我在C#、JavaScript、Python、Docker、SQL和Rust等领域的知识与经验。 作为一名技术爱好者，我相信技术的力量可以改变世界。
02-07 1380
如果你稍微留意一下todo list v0.0.3的代码，你会发现它是比较臃肿的，因为，这个版本只是通过组装AI写出来的代码，完成了功能的开发。说“能”，我想不用我说，很早就有人用AI生成正则表达式的相关功能代码，从这个角度来说，AI 已经替代了程序员的工作了。
Rust Web 框架入门和对比
xuejianxinokok的专栏
03-18 3050
利用 Tokio、Tower 和 Hyper 建立强大的生态系统。很棒的开发者经验。仍处于 0.x 版本，因此可能会发生重大更改。强大、独立的生态系统。通过主要版本保证实现稳定的 API。很棒的文档。丰富的内置功能。不像以前那样积极发展。对于初学者来说仍然是一个不错的选择。Functional approach. 函数式方法。Very expressive. 非常富有表现力。靠近 Tokio、Tower 和 Hyper，拥有强大的生态系统。
【转载】2023 年最好的 Rust Web 框架
m0_51810668的博客
05-17 2922
2023年最好的 Rust Web 框架
另一个用Rust编写的操作系统-Rust综述
03-17
- **核心概念**：Redox OS是一个采用Rust语言构建的全新类Unix操作系统，它着重于提高安全性、可靠性和性能。 - **架构特点**： - **微内核架构**：采用微内核设计来减少内核的复杂性，提高系统的可维护性和安全性...
rust-snake使用rust编写的贪吃蛇游戏
03-08
rust-snake使用rust编写的贪吃蛇游戏 仅供学习参考。 rust-snake使用rust编写的贪吃蛇游戏 仅供学习参考。 rust-snake使用rust编写的贪吃蛇游戏 仅供学习参考。 rust-snake使用rust编写的贪吃蛇游戏 仅供学习参考。...
alcro:一个使用rust和现代Web技术创建桌面应用程序的库
03-21
一个小型图书馆，可使用Rust和现代网络技术构建桌面应用程序。它使用Chrom（e / ium）或类似的浏览器（例如MS Edge（新））作为UI。它不捆绑Chrome，而是与现有的Chrome安装通信。因此，可以从UI调用Rust函数，而...
Rust编写一个ChatGPT桌面应用（保姆级教程）
wjianwei666的专栏
04-18 819
2.安装 Rust 插件：打开 IntelliJ IDEA，然后转到 "File" > "Settings" (Windows/Linux) 或 "IntelliJ IDEA" > "Preferences" (macOS)。在设置窗口中，选择 "Plugins"，搜索 "Rust"，然后单击 "Install"。3.创建新的 Rust 项目：在 IntelliJ IDEA 中，选择 "File" > "New" > "Project"，然后在项目类型列表中选择 "Rust"。效率高、资源占用量低。
Rust编写一个简单的LED闪烁程序
06-02
下面是一个简单的Rust嵌入式系统开发的例子，我们将使用Rust编写一个简单的LED闪烁程序。 这个例子假设你使用的是STM32F1系列微控制器，并且你的开发板有一个LED连接到PA引脚。你需要根据你的具体硬件和开发环境...
【小沐学前端】Rust实现Web服务器
爱看书的小沐
06-04 2289
Rust: 一种使每个人都能够构建可靠且高效的软件的语言。如今，全球有数百家公司在生产环境中使用 Rust，以提供快速、资源少、跨平台的解决方案。您熟悉和喜爱的软件，例如Firefox、 Dropbox和Cloudflare，都使用 Rust。从初创公司到大公司，从嵌入式设备到可扩展的 Web 服务，Rust 都非常适合。高性能Rust 速度惊人且内存利用率极高。由于没有运行时和垃圾回收，它能够胜任对性能要求特别高的服务，可以在嵌入式设备上运行，还能轻松和其他语言集成。可靠性。
rust中web框架rocket
DCABQ的博客
06-04 2139
rocket翻译教程
顶级 Rust Web 框架：Rocket、Actix-web、Tide、Warp 和 Gotham
我的博客，不一样的自我表达
06-14 3387
他创建了一个可扩展的高性能解决方案，以其干净的 API 和异步功能给用户和同事留下了深刻的印象。它为开发人员提供了构建强大而高效的Web 应用程序所需的工具，由于其简单性、速度和对安全性的重视，使他们的编码之旅更加顺畅和愉快。由于其强大的路由系统、对异步请求的支持以及对安全的重视，Gotham 为在 Rust 中构建安全和可扩展的 Web 应用程序提供了坚实的基础。
Rust Web开发：构建安全与高效的未来
silenceallat的博客
04-07 740
1. 安全性：Rust语言的设计注重内存安全，自动处理内存管理，有效预防内存泄漏和数据竞争等问题，从而提高Web应用的安全性。 2. 性能：Rust编译成的WebAssembly可以在浏览器中运行，提供接近原生代码的性能。同时，Rust的异步编程特性可以充分利用多核CPU，提高Web应用的并发性能。 3. 灵活性：Rust支持所有权、借用和生命周期等独特特性，使得代码更加简洁、易维护。同时，Rust的生态系统中有很多实用的库和工具，方便开发者快速构建Web应用。 4. 跨平台：Rust可以编译成适用于多个平
Rust Web开发入门指南：构建安全高效的Web应用
热门推荐
努力是为了站在万人之中，成为别人的光
06-25 1万+
通过本文的介绍，你学习了如何使用Rust语言和Actix-web框架构建一个简单但完整的Web应用。从选择框架、处理HTTP请求、数据库操作到编写RESTful API，我们覆盖了Rust Web开发的基本知识和实际操作。Rust作为一门安全且高性能的语言，在Web开发中展现出了其独特的优势，为开发者提供了构建高效、安全的Web应用的理想平台。随着Rust生态系统的不断成熟和丰富，它在Web开发中的应用前景将更加广阔。
【跟小嘉学 Rust 编程】三十三、Rust的Web开发框架之一: Actix-Web的基础
小嘉丶学长的博客
10-25 3145
本章节讲解 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的Web开发，actix的基本使用
weixin_37957321的博客
08-31 3817
这里不对以上框架做优缺点比较，因为自己涉猎也比较浅，所以不知道，则不评价，仅仅是因为自己会简单使用Actix，所以这里对Rust中使用Actix做简单分享。闭包函数创建了APP实例，并监听了/hello服务，同时将这个/hello服务，指定index服务函数处理。这里非常喜欢Actix对于中文字符的处理，即使用的时候，不需要添加多余的处理方式，轻松得到没有乱码的数据。这里用web::get()，明确指定了请求/getReq为get请求，以其他方式的调用，均是不允许的。同时需要创建一个结构体，用于接收参数。.
使用rust编写一个图形化界面
03-25
作为一个AI语言模型，我不能直接编写代码，但是我可以提供给你一些有用的信息和提示： 1. Rust 常用的 GUI 框架包括 GTK、Qt、Egui 等，你可以先了解一下它们的特点和使用方法，选择一种适合自己的框架进行学习和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值