Rust 错误传播模式：从 Result 到 thiserror，让编译器帮你排错-CSDN博客

Rust 错误传播模式：从 Result 到 thiserror，让编译器帮你排错

cover

一、Rust 错误处理的哲学：没有异常，只有值

Rust 没有异常机制——没有 try-catch，没有 throw。错误处理通过 Result<T, E> 类型完成：Ok(T) 表示成功，Err(E) 表示失败。编译器强制你处理每个可能的错误，不能假装它不存在。

这种设计初看繁琐，但核心优势是：错误是函数签名的一部分。看函数签名就知道它可能失败，调用者必须处理。而异常机制中，任何函数都可能抛出任何异常，调用者无法从签名判断。Rust 的错误处理让 Bug 在编译期暴露，而非运行时崩溃。

二、Rust 错误传播的三层机制

flowchart TB
    A[错误发生] --> B{错误类型}
    B -->|可恢复| C[Result Ok Err]
    B -->|不可恢复| D[panic!]

    C --> E{传播方式}
    E -->|手动匹配| F[match expr]
    E -->|问号运算符| G[expr?]
    E -->|自定义错误类型| H[thiserror/anyhow]

    G --> I[自动转换错误类型 From trait]
    I --> J[调用方统一处理]

    style C fill:#6bcb77,color:#fff
    style D fill:#ff6b6b,color:#fff
    style G fill:#4d96ff,color:#fff

三层机制的关系：

Result 类型：基础层，Result<T, E> 是错误值的容器。Ok(v) 包装成功值，Err(e) 包装错误值。
问号运算符 ?：语法糖，expr? 的语义是"如果 Err 就提前返回，如果 Ok 就解包继续"。自动调用 From trait 做错误类型转换。
自定义错误类型：工程层，用 thiserror 定义项目级错误枚举，用 anyhow 简化应用层错误处理。

三、错误传播实战

// 基础层：Result + 问号运算符
use std::fs;
use std::io;

// 问号运算符的展开形式
fn read_file_manual(path: &str) -> Result<String, io::Error> {
    let content = match fs::read_to_string(path) {
        Ok(content) => content,
        Err(e) => return Err(e),  // 错误提前返回
    };
    Ok(content)
}

// 用 ? 简化：等价于上面的手动匹配
fn read_file_short(path: &str) -> Result<String, io::Error> {
    let content = fs::read_to_string(path)?;  // Err 自动返回，Ok 自动解包
    Ok(content)
}

// ? 会自动调用 From::from 做错误类型转换
fn read_and_parse(path: &str) -> Result<i32, io::Error> {
    let content = fs::read_to_string(path)?;  // io::Error 直接传播
    let number: i32 = content.trim().parse()
        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
    // parse 返回 ParseIntError，需要手动转换为 io::Error
    // 因为 io::Error 没有实现 From<ParseIntError>
    Ok(number)
}

// 工程层：thiserror 自定义错误类型
use thiserror::Error;

/// 应用级错误类型：统一所有可能的错误来源
#[derive(Debug, Error)]
enum AppError {
    // #[error] 属性定义错误显示信息
    #[error("文件读取失败: {0}")]
    Io(#[from] io::Error),  // #[from] 自动实现 From<io::Error>

    #[error("数据解析失败: {0}")]
    Parse(#[from] std::num::ParseIntError),  // 自动实现 From<ParseIntError>

    #[error("配置无效: {key}={value}, 原因: {reason}")]
    InvalidConfig {
        key: String,
        value: String,
        reason: String,
    },

    #[error("数据库查询超时: {query} ({timeout_ms}ms)")]
    DbTimeout {
        query: String,
        timeout_ms: u64,
    },

    #[error(transparent)]  // 透明转发，不修改底层错误信息
    Other(#[from] anyhow::Error),
}

// 使用自定义错误类型
fn read_and_parse_v2(path: &str) -> Result<i32, AppError> {
    let content = fs::read_to_string(path)?;  // io::Error → AppError::Io
    let number: i32 = content.trim().parse()?;  // ParseIntError → AppError::Parse
    Ok(number)
}

fn validate_config(key: &str, value: &str) -> Result<(), AppError> {
    if value.is_empty() {
        return Err(AppError::InvalidConfig {
            key: key.to_string(),
            value: value.to_string(),
            reason: "值不能为空".to_string(),
        });
    }
    Ok(())
}

// 应用层：anyhow 简化错误处理
use anyhow::{Context, Result, anyhow};

// anyhow::Result = Result<T, anyhow::Error>
// 适用于应用入口层，不需要精确区分错误类型
fn run_app(config_path: &str) -> Result<()> {
    let content = fs::read_to_string(config_path)
        .context(format!("无法读取配置文件: {}", config_path))?;
    // .context() 添加上下文信息，出错时显示完整调用链

    let number: i32 = content.trim().parse()
        .context("配置文件内容必须是整数")?;

    if number <= 0 {
        // anyhow! 宏创建带格式的错误
        return Err(anyhow!("无效的端口号: {}, 必须大于 0", number));
    }

    println!("应用启动，端口: {}", number);
    Ok(())
}

// main 函数返回 anyhow::Result
fn main() -> Result<()> {
    run_app("config.txt")
    // 错误会自动打印完整的上下文链：
    // "无法读取配置文件: config.txt"
    // Caused by: No such file or directory (os error 2)
}

// 库层 vs 应用层的错误处理策略
// 库（library）：用 thiserror 定义精确的错误类型，让调用者可以 match
pub mod library {
    use thiserror::Error;

    #[derive(Debug, Error)]
    pub enum CacheError {
        #[error("缓存未命中: {key}")]
        Miss { key: String },

        #[error("缓存过期: {key}, 过期于 {expired_at}")]
        Expired { key: String, expired_at: String },

        #[error("序列化失败: {0}")]
        Serialization(#[from] serde_json::Error),
    }

    pub fn get_cache(key: &str) -> Result<String, CacheError> {
        // 调用者可以精确 match 每种错误
        Err(CacheError::Miss { key: key.to_string() })
    }
}

// 应用（application）：用 anyhow 统一处理，不需要精确匹配
pub mod app {
    use anyhow::Result;

    pub fn run() -> Result<()> {
        // 库的错误自动转换为 anyhow::Error
        let value = library::get_cache("user:123")?;
        println!("{}", value);
        Ok(())
    }
}