Rust中类型转换在错误处理中的应用小结

更新时间：2023年09月26日 11:39:20 作者：明天好，会的

随着项目的进展,关于Rust的故事又翻开了新的一页,今天来到了服务器端的开发场景,发现错误处理中的错误类型转换有必要分享一下,对Rust错误处理相关知识感兴趣的朋友一起看看吧

Rust抽象出来了Result<T,E>，T是返回值的类型，E是错误类型。只要函数的返回值的类型被定义为Resut<T,E>，那么作为开发人员就有责任来处理调用这个函数可能发生的错误。通过Result<T,E>，Rust其实给开发人员指明了一条错误处理的道路，使代码更加健壮。

场景

服务器端处理api请求的框架：Rocket
服务器端处理数据持久化的框架：tokio_postgres

在api请求的框架中，我把返回类型定义成了 Result<T, rocket::response::status::Custom\<String>> ，即错误类型是 rocket::response::status::Custom\<String> 。

在tokio_postgres中，直接使用 tokio_postgres::error::Error 。

即如果要处理错误，就必须将 tokio_postgres::error::Error 转换成 rocket::response::status::Custom\<String> 。那么我们从下面的原理开始，逐一领略Rust的错误处理方式，通过对比找到最合适的方式吧。

原理

对错误的处理，Rust有3种可选的方式

使用match
使用if let
使用map_err

下面我结合场景，逐一演示各种方式是如何处理错误的。

下面的代码中涉及到2个模块（文件）。 /src/routes/notes.rs 是路由层，负责将api请求导向合适的service。 /src/services/note_books.rs 是service层，负责业务逻辑和数据持久化的处理。这里的逻辑也很简单，就是route层调用service层，将数据写入到数据库中。

使用match

src/routes/notes.rs

#[post("/api/notes", format = "application/json", data = "<note>")]
pub async fn post_notes(note: Json<Note>) -> Result<(), rocket::response::status::Custom<String>> {
    insert_or_update_note(&note.into_inner()).await
}

/src/services/note_book.rs

pub async fn insert_or_update_note(
    note: &Note,
) -> Result<(), rocket::response::status::Custom<String>> {
    let (client, connection) = match connect(
        "host=localhost dbname=notes_db user=postgres port=5432",
        NoTls,
    )
    .await
    {
        Ok(res) => res,
        Err(err) => {
            return Err(rocket::response::status::Custom(
                rocket::http::Status::ExpectationFailed,
                format!("{}", err),
            ));
        }
    };
    ...
    match client
        .execute(
            "insert into notes (id, title, content) values($1, $2, $3);",
            &[&get_system_seconds(), &note.title, &note.content],
        )
        .await
    {
        Ok(res) => Ok(()),
        Err(err) => Err(rocket::response::status::Custom(
            rocket::http::Status::ExpectationFailed,
            format!("{}", err),
        )),
    }
}

通过上面的代码我们可以读出一下内容：

在service层定义了route层相同的错误类型
在service层将持久层的错误转换成了route层的错误类型
使用match的代码量还是比较大

使用if let

/src/services/note_book.rs

pub async fn insert_or_update_note(
    note: &Note,
) -> Result<(), rocket::response::status::Custom<String>> {
    if let Ok((client, connection)) = connect(
        "host=localhost dbname=notes_db user=postgres port=5432",
        NoTls,
    )
    .await
    {
        ...
        if let Ok(res) = client
            .execute(
                "insert into notes (id, title, content) values($1, $2, $3);",
                &[&get_system_seconds(), &note.title, &note.content],
            )
            .await
        {
            Ok(())
        } else {
            Err(rocket::response::status::Custom(
                rocket::http::Status::ExpectationFailed,
                format!("{}", "unknown error"),
            ))
        }
    } else {
        Err(rocket::response::status::Custom(
            rocket::http::Status::ExpectationFailed,
            format!("{}", "unknown error"),
        ))
    }
}

src/routes/notes.rs

#[post("/api/notes", format = "application/json", data = "<note>")]
pub async fn post_notes(note: Json<Note>) -> Result<(), rocket::response::status::Custom<String>> {
    insert_or_update_note(&note.into_inner()).await
}

使用了 if let ... ，代码更加的别扭，并且在else分支中，拿不到具体的错误信息。

其实，不难看出，我们的目标是将api的请求，经过route层和service层，将数据写入到数据中。但这其中的错误处理代码的干扰就特别大，甚至要有逻辑嵌套现象。这种代码的已经离初衷比较远了，是否有更加简洁的方式，使代码能够最大限度的还原逻辑本身，把错误处理的噪音降到最低呢？答案肯定是有的。那就是map_err

map_err

map_err是Result上的一个方法，专门用于错误的转换。下面的代码经过了map_err的改写，看上去是不是清爽了不少啊。/src/services/note_book.rs

pub async fn insert_or_update_note(
    note: &Note,
) -> Result<(), rocket::response::status::Custom<String>> {
    let (client, connection) = connect(
        "host=localhost dbname=notes_db user=postgres port=5432",
        NoTls,
    )
    .await
    .map_err(|err| {
        rocket::response::status::Custom(
            rocket::http::Status::ExpectationFailed,
            format!("{}", err),
        )
    })?;
    ...
    let _ = client
        .execute(
            "insert into notes (id, title, content) values($1, $2, $3);",
            &[&get_system_seconds(), &note.title, &note.content],
        )
        .await
        .map_err(|err| {
            rocket::response::status::Custom(
                rocket::http::Status::ExpectationFailed,
                format!("{}", err),
            )
        })?;
    Ok(())
}

src/routes/notes.rs

#[post("/api/notes", format = "application/json", data = "<note>")]
pub async fn post_notes(note: Json<Note>) -> Result<(), rocket::response::status::Custom<String>> {
    insert_or_update_note(&note.into_inner()).await
}

经过map_err改写后的代码，代码的逻辑流程基本上还原了逻辑本身，但是map_err要额外占4行代码，且错误对象的初始化代码存在重复。在实际的工程项目中，service层的处理函数可能是成百上千，如果再乘以4，那多出来的代码量也不少啊，这会给后期的维护带来不小的压力。

那是否还有改进的空间呢？答案是Yes。

Rust为我们提供了From<T> trait，用于类型转换。它定义了从一种类型T到另一种类型Self的转换方法。我觉得这是Rust语言设计亮点之一。

但是，Rust有一个显示，即实现From<T> trait的结构，必须有一个在当前的crate中，也就是说我们不能直接通过From<T>来实现从 tokio_postgres::error::Error 到 rocket::response::status::Custom<String> 。也就是说下面的代码编译器会报错。

impl From<tokio_postgres::Error> for rocket::response::status::Custom<String> {}

报错如下：

32 | impl From<tokio_postgres::Error> for rocket::response::status::Custom<String> {}
| ^^^^^---------------------------^^^^^----------------------------------------
| | | |
| | | `rocket::response::status::Custom` is not defined in the current crate
| | `tokio_postgres::Error` is not defined in the current crate
| impl doesn't use only types from inside the current crate

因此，我们要定义一个类型 MyError 作为中间类型来转换一下。/src/models.rs

pub struct MyError {
    pub message: String,
}
impl From<tokio_postgres::Error> for MyError {
    fn from(err: Error) -> Self {
        Self {
            message: format!("{}", err),
        }
    }
}
impl From<MyError> for rocket::response::status::Custom<String> {
    fn from(val: MyError) -> Self {
        status::Custom(Status::ExpectationFailed, val.message)
    }
}

/src/services/note_book.rs

pub async fn insert_or_update_note(
    note: &Note,
) -> Result<(), rocket::response::status::Custom<String>> {
    let (client, connection) = connect(
        "host=localhost dbname=notes_db user=postgres port=5432",
        NoTls,
    )
    .await
    .map_err(MyError::from)?;
    ...
    let _ = client
        .execute(
            "insert into notes (id, title, content) values($1, $2, $3);",
            &[&get_system_seconds(), &note.title, &note.content],
        )
        .await
        .map_err(MyError::from)?;
    Ok(())
}

src/routes/notes.rs

#[post("/api/notes", format = "application/json", data = "<note>")]
pub async fn post_notes(note: Json<Note>) -> Result<(), rocket::response::status::Custom<String>> {
    insert_or_update_note(&note.into_inner()).await
}

而 MyError 到 rocket::response::status::Custom<String> 之间的转换是隐式的，由编译器来完成。因此我们的错误类型的转换最终缩短为 map_err(|err|MyError::from(err)) ，再简写为 map_err(MyError::from)。

关于错误处理中的类型转换应用解析就到这里。通过分析这个过程，我们可以看到，在设计模块时，我们应该确定一种错误类型，就像tokio_postgres库一样，只暴露了tokio_postgress::error::Error一种错误类型。这种设计既方便我们在设计模块时处理错误转换，也方便其我们的模块在被调用时，其它代码进行错误处理。

到此这篇关于Rust中类型转换在错误处理中的应用解析的文章就介绍到这了,更多相关Rust错误处理内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

聊聊Rust 运算符
运算符用于对数据执行一些操作。被运算符执行操作的数据我们称之为操作数。下面通过本文给大家介绍Rust 运算符的相关知识，感兴趣的朋友一起看看吧
2021-11-11
Rust Atomics and Locks并发基础理解
这篇文章主要为大家介绍了Rust Atomics and Locks并发基础理解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-02-02
Rust 堆内存指针 Box的实现示例
在 Rust 中,Box<T>是最基础、最简洁的智能指针,核心作用是将数据从栈内存转移到堆内存,并通过独占所有权机制管理堆内存的分配与释放,下面就来详细的介绍一下,感兴趣的可以了解一下
2026-04-04
用rust 写一个jar包 class冲突检测工具
这篇文章主要介绍了用rust 写一个jar包 class冲突检测工具的相关资料,需要的朋友可以参考下
2023-05-05
如何使用Rust直接编译单个的Solidity合约
本文介绍了如何使用Rust语言直接编译Solidity智能合约,特别适用于没有外部依赖或flatten后的合约,一般情况下,Solidity开发者使用Hardhat或Foundry框架,本文给大家介绍如何使用Rust直接编译单个的Solidity合约,感兴趣的朋友一起看看吧
2024-09-09
深入解析Rust中的智能指针
本文介绍了Rust中的智能指针,Box、Rc、Arc、RefCell、Mutex、RwLock对应的功能、场景与常用方法,并提供了组合使用方式,以及Cow、Pin的使用方式,感兴趣的朋友跟随小编一起看看吧
2025-10-10
详解Rust中的workspace
这篇文章主要向大家介绍Rust中的workspace,主要内容包括基础应用、实用技巧、原理机制等方面，这个概念在Rust中是通用的，只不过maven换成了cargo，而模块变成了crate，下面跟着小编通过一个例子给大家介绍下
2022-03-03
详解Rust中的所有权机制
Rust 语言提供了跟其他系统编程语言相同的方式来控制你使用的内存，但拥有数据所有者在离开作用域后自动清除其数据的功能意味着你无须额外编写和调试相关的控制代码,这篇文章主要介绍了Rust中的所有权机制,需要的朋友可以参考下
2022-10-10
rust 一个日志缓存记录的通用实现方法
本文给出了一个通用的设计模式,通过建造者模式实例化记录对象,可自定义格式化器将实例化后的记录对象写入到指定的缓存对象中,这篇文章主要介绍了rust 一个日志缓存记录的通用实现方法,需要的朋友可以参考下
2024-04-04
Tauri 打开本地文件踩坑分析解决
这篇文章主要为大家介绍了Tauri 打开本地文件踩坑分析解决，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2023-04-04

Rust中类型转换在错误处理中的应用小结

目录

场景

原理

使用match

使用if let

map_err

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具