Rust 常用库

Rust 生态系统中有许多高质量的库，本章节将介绍一些常用的 Rust 库。

网络库

reqwest

reqwest 是一个功能强大的 HTTP 客户端库：

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }

use reqwest::Error;

#[tokio::main]
async fn main() -> Result<(), Error> {
    // 发送 GET 请求
    let response = reqwest::get("https://api.github.com/users/rust-lang").await?;
    let user: serde_json::Value = response.json().await?;
    println!("{:?}", user);
    
    // 发送 POST 请求
    let client = reqwest::Client::new();
    let res = client.post("https://httpbin.org/post")
        .json(&serde_json::json!({
            "name": "John",
            "age": 30
        }))
        .send()
        .await?;
    
    println!("Status: {}", res.status());
    Ok(())
}

hyper

hyper 是一个低级 HTTP 库，用于构建 HTTP 服务器和客户端：

[dependencies]
hyper = { version = "1", features = ["full"] }
tokio = { version = "1", features = ["full"] }

序列化库

serde

serde 是 Rust 中最流行的序列化库：

[dependencies]
serde = { version = "1", features = ["derive"] }
serde_json = "1"

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Person {
    name: String,
    age: u32,
    email: Option<String>,
}

fn main() {
    // 序列化
    let person = Person {
        name: "John",
        age: 30,
        email: Some("john@example.com"),
    };
    
    let json = serde_json::to_string(&person).unwrap();
    println!("JSON: {}", json);
    
    // 反序列化
    let deserialized: Person = serde_json::from_str(&json).unwrap();
    println!("Deserialized: {:?}", deserialized);
}

数据库库

diesel

diesel 是 Rust 中流行的 ORM 库：

[dependencies]
diesel = { version = "2", features = ["sqlite", "r2d2"] }

sqlx

sqlx 是一个异步 SQL 数据库库：

[dependencies]
sqlx = { version = "0.6", features = ["sqlite", "runtime-tokio-rustls"] }
tokio = { version = "1", features = ["full"] }

命令行工具库

clap

clap 是一个命令行参数解析库：

[dependencies]
clap = { version = "4", features = ["derive"] }

use clap::Parser;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Name of the person to greet
    #[arg(short, long)]
    name: String,
    
    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
}

fn main() {
    let args = Args::parse();
    
    for _ in 0..args.count {
        println!("Hello, {}!", args.name);
    }
}

colored

colored 用于在终端中输出彩色文本：

[dependencies]
colored = "2"

use colored::*;

fn main() {
    println!("{}", "Hello".red());
    println!("{}", "World".green().bold());
    println!("{}", "Rust".blue().italic());
}

异步库

tokio

tokio 是 Rust 中最流行的异步运行时：

[dependencies]
tokio = { version = "1", features = ["full"] }

async-std

async-std 是另一个流行的异步运行时：

[dependencies]
async-std = { version = "1", features = ["full"] }

实用工具库

anyhow

anyhow 用于简化错误处理：

[dependencies]
anyhow = "1"

use anyhow::Result;

fn main() -> Result<()> {
    let result = do_something()?;
    println!("Result: {}", result);
    Ok(())
}

fn do_something() -> Result<i32> {
    Ok(42)
}

thiserror

thiserror 用于定义错误类型：

[dependencies]
thiserror = "1"

use thiserror::Error;

#[derive(Error, Debug)]
enum MyError {
    #[error("Invalid input: {0}")]
    InvalidInput(String),
    
    #[error("Network error: {0}")]
    NetworkError(#[from] reqwest::Error),
}

fn main() {
    let result = validate_input("");
    match result {
        Ok(_) => println!("Valid input"),
        Err(e) => println!("Error: {}", e),
    }
}

fn validate_input(input: &str) -> Result<(), MyError> {
    if input.is_empty() {
        return Err(MyError::InvalidInput("Input cannot be empty".to_string()));
    }
    Ok(())
}

总结

• 网络库：reqwest、hyper
• 序列化库：serde、serde_json
• 数据库库：diesel、sqlx
• 命令行工具库：clap、colored
• 异步库：tokio、async-std
• 实用工具库：anyhow、thiserror

Rust 生态系统中有许多高质量的库，这些库可以帮助我们更高效地开发 Rust 应用。通过本章节的学习，你应该已经了解了一些常用的 Rust 库及其使用方法。