第1章：Rust 概述与环境搭建

学习目标

理解 Rust 的设计理念和核心特性
掌握 Rust 开发环境的标准配置流程
学会使用 Cargo 包管理工具
了解 Rust 的编译和运行机制

1.1 Rust 语言概述

1.1.1 Rust 的诞生背景

Rust 是 Mozilla 在 2006 年开始研发的系统编程语言，目标是在保持 C++ 性能的同时解决内存安全问题。

#![allow(unused)]
fn main() {
// Rust 的哲学：安全、并发、实用
// 不需要垃圾回收器手动管理内存
// 编译时保证内存安全
// 零成本抽象 - 性能无损失
}

1.1.2 核心特性

内存安全

Rust 通过编译时严格的规则（如所有权和借用检查）防止常见的内存错误，包括空指针解引用、缓冲区溢出、数据竞争和悬垂引用。这无需运行时垃圾回收或手动内存管理，而是让编译器在构建时捕获潜在问题，确保代码在不牺牲性能的前提下高度可靠，特别适合系统级开发。

#![allow(unused)]
fn main() {
// 编译时防止常见内存错误
fn demonstrate_memory_safety() {
    let string = String::from("Hello");
    let slice = &string; // 借用，不转移所有权
    // 编译时确保不会有野指针或内存泄漏
    println!("{}", slice);
    
    // let mut data = vec![1, 2, 3];
    // let slice = &data;  // 不可变借用
    // data.push(4);       // 编译错误！违反了借用规则
}
}

零成本抽象

Rust 允许开发者使用高级抽象（如泛型、trait 和迭代器）来编写简洁、表达力强的代码，但这些抽象在编译后不会引入任何运行时开销。生成的机器码与直接用低级代码（如循环）编写的一样高效，这意味着“抽象不会让你付出代价”，促进了可维护性和性能的平衡。

#![allow(unused)]
fn main() {
// 高级语言特性不带来性能损失
fn high_level_abstraction() {
    let numbers: Vec<i32> = (0..1000).collect();
    
    // 高级的函数式编程风格
    let sum: i32 = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)     // 只保留偶数
        .map(|&x| x * x)              // 平方
        .sum();                       // 求和
    
    // 编译器会优化为类似 C 代码的性能
    println!("平方偶数和: {}", sum);
}
}

所有权系统

这是 Rust 的核心创新：每个值都有一个唯一所有者，当所有者超出作用域时，值自动被释放（通过 drop 机制）。所有权可以转移（move）或借用（immutable & 或 mutable &mut），编译器强制执行这些规则，避免内存泄漏、双重释放和无效访问，实现静态保证的内存管理。

#![allow(unused)]
fn main() {
// 所有权和借用保证内存安全
fn ownership_demo() {
    // 所有权转移
    let data = vec![1, 2, 3];
    let transferred = data; // data 移动到 transferred
    
    // println!("{:?}", data); // 编译错误！data 已经移动
    println!("{:?}", transferred); // 正常
    
    // 借用（引用）
    let reference = &transferred;
    println!("引用值: {:?}", reference); // 读取操作不需要所有权
    
    // 多重引用
    let another_ref = &transferred;
    // 但是不能有可变引用
    // let mut_ref = &mut transferred; // 编译错误！
    
    println!("两个引用: {:?}, {:?}", reference, another_ref);
}
}

1.2 安装 Rust 开发环境

1.2.1 使用 rustup 安装

# 安装 Rust 工具链
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# 重新加载环境变量
source ~/.cargo/env

# 验证安装
rustc --version
cargo --version

# 更新 Rust
rustup update

# 查看所有安装的版本
rustup show

1.2.2 工具链管理

# 查看可用工具链
rustup target list --installed

# 添加新目标平台
rustup target add x86_64-pc-windows-msvc
rustup target add x86_64-apple-darwin
rustup target add aarch64-unknown-linux-gnu

# 切换工具链
rustup default stable
rustup default nightly

1.2.3 开发工具推荐

# 安装常用开发工具
cargo install cargo-watch     # 文件监控自动重编译
cargo install cargo-audit     # 安全漏洞检查
cargo install cargo-clippy    # 代码质量检查
cargo install rust-analyzer   # 语言服务器协议

# VS Code 扩展
# - Rust Analyzer
# - rust-analyzer
# - Rust Test Explorer
# - CodeLLDB (调试器)

1.3 Cargo 包管理详解

1.3.1 创建新项目

# 创建二进制可执行项目
cargo new my_project
cd my_project

# 创建库项目
cargo new --lib my_library

# 创建脚手架项目
cargo generate --git https://github.com/rustwasm/wasm-pack-template

1.3.2 Cargo.toml 配置文件

# my_project/Cargo.toml
[package]
name = "my_project"           # 项目名称
version = "0.1.0"            # 版本号
edition = "2021"             # Rust 版本
authors = ["Your Name <email@example.com>"]
license = "MIT"              # 许可证
description = "A sample Rust project"
repository = "https://github.com/user/my_project"
keywords = ["rust", "example", "demo"]
categories = ["development-tools"]
documentation = "https://docs.rs/my_project"
readme = "README.md"

# 项目依赖
[dependencies]
# 基础依赖
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1.0", features = ["full"] }

# 可选依赖
rand = "0.8"
chrono = { version = "0.4", optional = true }

# 开发依赖
[dev-dependencies]
tempfile = "3.0"
mockall = "0.11"

# 构建脚本依赖
[build-dependencies]
cc = "1.0"

# 功能标志
[features]
default = ["json"]
json = ["serde_json"]
csv = ["serde_csv"]
chrono_time = ["chrono"]

1.3.3 项目结构说明

my_project/
├── src/                      # 源代码目录
│   ├── main.rs              # 入口文件
│   ├── lib.rs               # 库入口（可选）
│   ├── mod1/                # 模块目录
│   │   ├── mod.rs
│   │   └── submodule.rs
│   └── utils/               # 工具模块
│       ├── mod.rs
│       └── helpers.rs
├── Cargo.toml               # 项目配置
├── Cargo.lock               # 依赖锁定（自动生成）
├── README.md                # 项目说明
├── CHANGELOG.md             # 更新日志
├── LICENSE                  # 许可证文件
├── .gitignore              # Git 忽略文件
├── tests/                   # 集成测试
├── examples/                # 示例代码
├── benches/                 # 性能测试
└── target/                  # 构建输出（自动生成）
    ├── debug/               # 调试构建
    └── release/             # 发布构建

1.4 第一个 Rust 程序

1.4.1 基础 Hello World

// src/main.rs
// 单行注释

/*
   多行注释
   这是我们的第一个 Rust 程序
*/

fn main() {
    // println! 是一个宏（用 ! 表示）
    println!("Hello, Rust World!");
    
    // 变量和类型
    let name = "Rust 开发者";
    let version = 1.0;
    let is_awesome = true;
    
    println!("欢迎 {}！Rust 版本 {}", name, version);
    
    // 格式化输出
    println!("{} 是 {} 编程语言", "Rust", "现代");
    println!("{subject} {verb} {object}", 
             subject="Rust", verb="是", object="安全");
    
    // 占位符
    println!("十进制: {}", 42);
    println!("十六进制: {:#x}", 255);
    println!("二进制: {:#b}", 15);
    println!("科学计数法: {}", 123.456789);
    
    // 命名参数
    println!("{language} 在 {year} 年发布了！", 
             language="Rust", year=2021);
}

Result:

Hello, Rust World!
欢迎 Rust 开发者！Rust 版本 1
Rust 是 现代 编程语言
Rust 是 安全
十进制: 42
十六进制: 0xff
二进制: 0b1111
科学计数法: 123.456789
Rust 在 2021 年发布了！

{} 是格式化占位符（placeholder），用于在字符串中插入变量值。它类似于 C 中的 printf 中的 %s 或 Python 的 f-string 中的 {}，但 Rust 使用基于 std::fmt 模块的强大格式化系统。

作用：每个 {} 会按顺序被后面的参数（如 name 和 version）替换。编译时，Rust 会检查类型匹配（例如，name 必须实现 Display trait 以便打印）。

默认行为：{} 表示使用 {:?} 或 {}（取决于上下文），但通常是 {} 用于人类可读的字符串表示。

位置：占位符按从左到右的顺序匹配参数。如果参数多于占位符，会忽略多余的。

1.4.2 构建和运行

# 开发模式构建和运行
cargo run

# 调试构建
cargo build

# 发布构建（优化）
cargo build --release

# 仅编译检查（快速验证）
cargo check

# 运行示例
cargo run --example hello_world

# 运行测试
cargo test

# 运行基准测试
cargo bench

1.4.3 依赖管理

// src/main.rs - 使用外部依赖
use rand::Rng;        // 随机数生成器
use serde_json::{json, Value}; // JSON 处理

fn main() {
    // 随机数示例
    let random_number = rand::thread_rng().gen_range(1..=100);
    println!("随机数: {}", random_number);
    
    // JSON 序列化示例
    let data = json!({
        "name": "Alice",
        "age": 30,
        "skills": ["Rust", "Python", "JavaScript"]
    });
    
    let json_string = serde_json::to_string_pretty(&data)
        .expect("JSON 序列化失败");
    
    println!("JSON 数据:");
    println!("{}", json_string);
}

1.5 项目实践：Rust 开发环境配置工具

1.5.1 项目需求分析

创建一个自动化工具帮助开发团队配置统一的 Rust 开发环境：

#![allow(unused)]
fn main() {
// 项目目标：
// 1. 检测当前环境状态
// 2. 自动安装/更新 Rust 工具链
// 3. 配置开发工具
// 4. 生成项目模板
// 5. 提供回滚功能
}

1.5.2 项目结构设计

// src/main.rs
use std::process;

mod commands;
mod utils;
mod config;

use commands::{EnvironmentDetector, ToolInstaller, TemplateGenerator};
use utils::{Logger, ErrorHandler};
use config::Settings;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    let logger = Logger::new("rustdev-setup");
    logger.info("开始环境配置");
    
    // 加载配置
    let settings = Settings::load_from_file("config.toml")?;
    
    // 检测环境
    let detector = EnvironmentDetector::new(&logger);
    let environment = detector.detect()?;
    
    logger.info(format!("检测到环境: {:?}", environment));
    
    // 安装工具
    let installer = ToolInstaller::new(&settings, &logger);
    installer.install_all(&environment)?;
    
    // 生成模板
    let generator = TemplateGenerator::new(&settings, &logger);
    generator.generate_templates()?;
    
    logger.info("环境配置完成！");
    
    Ok(())
}

1.5.3 环境检测模块

#![allow(unused)]
fn main() {
// src/commands/detect.rs
use std::env;
use std::process::Command;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SystemInfo {
    pub os: OperatingSystem,
    pub architecture: String,
    pub shell: String,
    pub home_dir: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum OperatingSystem {
    Linux(String),
    MacOS(String),
    Windows(String),
    Unknown(String),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct RustInfo {
    pub version: String,
    pub toolchain: String,
    pub target: Vec<String>,
    pub cargo_version: String,
}

pub struct EnvironmentDetector {
    logger: Box<dyn Logger>,
}

impl EnvironmentDetector {
    pub fn new(logger: Box<dyn Logger>) -> Self {
        Self { logger }
    }
    
    pub fn detect(&self) -> Result<Environment, Error> {
        self.logger.info("开始检测系统环境");
        
        let system_info = self.detect_system_info()?;
        let rust_info = self.detect_rust_info()?;
        let tools_info = self.detect_development_tools()?;
        
        Ok(Environment {
            system: system_info,
            rust: rust_info,
            tools: tools_info,
        })
    }
    
    fn detect_system_info(&self) -> Result<SystemInfo, Error> {
        let os = env::consts::OS;
        let arch = env::consts::ARCH;
        let shell = env::var("SHELL").unwrap_or_default();
        let home = env::var("HOME").unwrap_or_default();
        
        let operating_system = match os {
            "linux" => OperatingSystem::Linux(self.get_distro_name()?),
            "macos" => OperatingSystem::MacOS(self.get_macos_version()?),
            "windows" => OperatingSystem::Windows(self.get_windows_version()?),
            _ => OperatingSystem::Unknown(os.to_string()),
        };
        
        Ok(SystemInfo {
            os: operating_system,
            architecture: arch.to_string(),
            shell,
            home_dir: home,
        })
    }
    
    fn detect_rust_info(&self) -> Result<RustInfo, Error> {
        // 检查 rustc 版本
        let rustc_output = self.run_command("rustc", &["--version"])?;
        let rustc_version = rustc_output.trim().to_string();
        
        // 检查 cargo 版本
        let cargo_output = self.run_command("cargo", &["--version"])?;
        let cargo_version = cargo_output.trim().to_string();
        
        // 获取默认工具链
        let default_toolchain = self.run_command("rustup", &["default"])?
            .trim()
            .to_string();
        
        // 获取已安装目标
        let targets_output = self.run_command("rustup", &["target", "list", "--installed"])?;
        let targets: Vec<String> = targets_output
            .lines()
            .filter(|line| !line.trim().is_empty())
            .map(|line| line.trim().to_string())
            .collect();
        
        Ok(RustInfo {
            version: rustc_version,
            toolchain: default_toolchain,
            target: targets,
            cargo_version: cargo_version,
        })
    }
    
    fn run_command(&self, command: &str, args: &[&str]) -> Result<String, Error> {
        match Command::new(command).args(args).output() {
            Ok(output) => {
                if output.status.success() {
                    Ok(String::from_utf8_lossy(&output.stdout).to_string())
                } else {
                    let stderr = String::from_utf8_lossy(&output.stderr);
                    Err(Error::CommandFailed(command.to_string(), stderr.to_string()))
                }
            }
            Err(e) => Err(Error::CommandNotFound(command.to_string(), e.to_string())),
        }
    }
}

// 错误处理
#[derive(Debug, thiserror::Error)]
pub enum Error {
    #[error("命令执行失败: {0} - {1}")]
    CommandFailed(String, String),
    #[error("命令未找到: {0} - {1}")]
    CommandNotFound(String, String),
    #[error("系统检测错误: {0}")]
    SystemDetection(String),
}
}

1.5.4 工具安装模块

#![allow(unused)]
fn main() {
// src/commands/install.rs
use std::path::Path;
use std::fs;

pub struct ToolInstaller {
    settings: Box<Settings>,
    logger: Box<dyn Logger>,
}

impl ToolInstaller {
    pub fn new(settings: &Settings, logger: Box<dyn Logger>) -> Self {
        Self {
            settings: Box::new(settings.clone()),
            logger,
        }
    }
    
    pub fn install_all(&self, environment: &Environment) -> Result<(), Error> {
        self.logger.info("开始安装开发工具");
        
        // 安装/更新 Rust 工具链
        self.install_rust_toolchain(environment)?;
        
        // 安装常用工具
        self.install_cargo_tools()?;
        
        // 配置开发环境
        self.configure_development_environment()?;
        
        self.logger.info("工具安装完成");
        Ok(())
    }
    
    fn install_rust_toolchain(&self, environment: &Environment) -> Result<(), Error> {
        self.logger.info("安装/更新 Rust 工具链");
        
        // 确保 rustup 安装
        if !self.command_exists("rustup") {
            self.run_with_progress("安装 rustup", || {
                Command::new("curl")
                    .args(&["--proto", "=https", "--tlsv1.2", "-sSf", 
                             "https://sh.rustup.rs"])
                    .stdout(std::process::Stdio::piped())
                    .spawn()?
                    .wait()
            })?;
        }
        
        // 更新 Rust
        self.run_command("rustup", &["update"])?;
        
        // 安装常用目标
        for target in &self.settings.common_targets {
            self.run_command("rustup", &["target", "add", target])?;
        }
        
        Ok(())
    }
    
    fn install_cargo_tools(&self) -> Result<(), Error> {
        self.logger.info("安装 Cargo 工具");
        
        for tool in &self.settings.cargo_tools {
            self.logger.info(format!("安装工具: {}", tool.name));
            
            let install_args = vec!["install", &tool.package];
            self.run_command("cargo", &install_args)?;
        }
        
        Ok(())
    }
    
    fn configure_development_environment(&self) -> Result<(), Error> {
        self.logger.info("配置开发环境");
        
        // 创建 .cargo/config.toml
        self.create_cargo_config()?;
        
        // 创建项目模板目录
        self.create_template_directories()?;
        
        Ok(())
    }
    
    fn create_cargo_config(&self) -> Result<(), Error> {
        let config_path = dirs::home_dir()
            .unwrap_or_default()
            .join(".cargo/config.toml");
        
        let config_content = format!(r#"
[http]
check-revoke = false

[source.crates-io]
replace-with = "vendored-sources"

[source.vendored-sources]
directory = "vendor"

[net]
git-fetch-with-cli = true
"#);
        
        fs::write(&config_path, config_content)?;
        Ok(())
    }
}

// 工具配置
#[derive(Clone)]
pub struct ToolConfig {
    pub name: String,
    pub package: String,
    pub description: String,
}

#[derive(Clone)]
pub struct Settings {
    pub common_targets: Vec<String>,
    pub cargo_tools: Vec<ToolConfig>,
}

impl Default for Settings {
    fn default() -> Self {
        Self {
            common_targets: vec![
                "x86_64-unknown-linux-gnu".to_string(),
                "x86_64-pc-windows-msvc".to_string(),
                "aarch64-unknown-linux-gnu".to_string(),
            ],
            cargo_tools: vec![
                ToolConfig {
                    name: "ripgrep".to_string(),
                    package: "ripgrep".to_string(),
                    description: "快速文件搜索工具".to_string(),
                },
                ToolConfig {
                    name: "fd".to_string(),
                    package: "fd".to_string(),
                    description: "现代化 find 替代品".to_string(),
                },
                ToolConfig {
                    name: "exa".to_string(),
                    package: "exa".to_string(),
                    description: "现代化 ls 替代品".to_string(),
                },
            ],
        }
    }
}
}

1.5.5 模板生成模块

// src/commands/generate.rs
use std::fs;
use std::path::Path;
use handlebars::{Handlebars, no_escape};
use serde_json::json;

pub struct TemplateGenerator {
    settings: Box<Settings>,
    logger: Box<dyn Logger>,
    handlebars: Handlebars<'static>,
}

impl TemplateGenerator {
    pub fn new(settings: &Settings, logger: Box<dyn Logger>) -> Self {
        let mut handlebars = Handlebars::new();
        handlebars.set_strict_mode(true);
        handlebars.register_escape_fn(no_escape);
        
        // 注册模板
        handlebars.register_template_string("project", PROJECT_TEMPLATE)?;
        handlebars.register_template_string("gitignore", GITIGNORE_TEMPLATE)?;
        handlebars.register_template_string("rustfmt", RUSTFMT_TEMPLATE)?;
        handlebars.register_template_string("clippy", CLIPPY_TEMPLATE)?;
        
        Ok(Self {
            settings: Box::new(settings.clone()),
            logger,
            handlebars,
        })
    }
    
    pub fn generate_templates(&self) -> Result<(), Error> {
        self.logger.info("生成项目模板");
        
        // 创建模板目录
        let template_dir = std::env::current_dir()?
            .join("rustdev-templates");
        fs::create_dir_all(&template_dir)?;
        
        // 生成项目模板
        self.generate_project_template(&template_dir)?;
        
        // 生成配置文件
        self.generate_config_files(&template_dir)?;
        
        self.logger.info("模板生成完成");
        Ok(())
    }
    
    fn generate_project_template(&self, base_dir: &Path) -> Result<(), Error> {
        let project_template_dir = base_dir.join("project");
        fs::create_dir_all(&project_template_dir)?;
        
        let template_data = json!({
            "project_name": "my-rust-project",
            "version": "0.1.0",
            "authors": ["Your Name <email@example.com>"],
            "description": "A Rust project generated with rustdev-setup"
        });
        
        // 生成 Cargo.toml
        let cargo_toml = self.handlebars.render("project", &template_data)?;
        fs::write(project_template_dir.join("Cargo.toml"), cargo_toml)?;
        
        // 生成 main.rs
        fs::write(project_template_dir.join("src/main.rs"), MAIN_RS_TEMPLATE)?;
        
        // 生成 README.md
        let readme = self.handlebars.render("project", &template_data)?;
        fs::write(project_template_dir.join("README.md"), readme)?;
        
        Ok(())
    }
}

// 项目模板
const PROJECT_TEMPLATE: &str = r#"
[package]
name = "{{project_name}}"
version = "{{version}}"
authors = {{#each authors}}"{{this}}"{{#unless @last}}, {{/unless}}{{/each}}
description = "{{description}}"
edition = "2021"

[dependencies]
常用依赖
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1.0", features = ["full"] }

[dev-dependencies]
tempfile = "3.0"
mockall = "0.11"

[build-dependencies]
cc = "1.0"
"#;

const MAIN_RS_TEMPLATE: &str = r#"
use std::error::Error;
use std::process;

fn main() -> Result<(), Box<dyn Error>> {
    println!("Hello, {{project_name}}!");
    
    // 你的代码在这里
    // 记得处理错误
    // process::exit(1);
    
    Ok(())
}
"#;

// 配置文件模板
const RUSTFMT_TEMPLATE: &str = r#"
edition = "2021"
unstable_features = true
imports_granularity = "Crate"
group_imports = "StdExternalCrate"
use_small_heuristics = "Default"
reorder_impl_items = true
"#;

const GITIGNORE_TEMPLATE: &str = r#"
目标目录
target/
Cargo.lock

IDE 文件
.vscode/
.idea/
*.swp
*.swo
*~

操作系统
.DS_Store
Thumbs.db

临时文件
*.tmp
*.log
.env

Rust
rustc-*
debug/
"#;

const CLIPPY_TEMPLATE: &str = r#"
允许的 clippy 规则
[lint.clippy::all]
allow = [
    "module_name_repetitions",
    "similar_names",
    "too_many_arguments"
]

允许的 clippy 警告
[lint.clippy::allow]
allow = [
    "missing_docs_in_private_items"
]
"#;

1.6 最佳实践和注意事项

1.6.1 开发环境配置最佳实践

#![allow(unused)]
fn main() {
// 1. 使用工具链管理器
// ~/.cargo/config.toml
[toolchain]
channel = "stable"
targets = ["x86_64-unknown-linux-gnu"]
profile = "minimal"

[build]
target = "x86_64-unknown-linux-gnu"

[net]
git-fetch-with-cli = true
}

1.6.2 代码质量工具

#![allow(unused)]
fn main() {
// 集成到构建过程
use cargo_toml;
use std::path::Path;

fn run_quality_checks() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 格式检查
    std::process::Command::new("cargo")
        .args(&["fmt", "--check"])
        .status()?;
    
    // 2. 静态分析
    std::process::Command::new("cargo")
        .args(&["clippy"])
        .status()?;
    
    // 3. 安全检查
    std::process::Command::new("cargo")
        .args(&["audit"])
        .status()?;
    
    // 4. 测试
    std::process::Command::new("cargo")
        .args(&["test"])
        .status()?;
    
    Ok(())
}
}

1.6.3 常见问题解决

#![allow(unused)]
fn main() {
// 常见错误和解决方案
fn troubleshooting_guide() {
    // 1. 编译错误
    // 错误：borrowed value does not live long enough
    // 解决：确保引用生命周期
    
    let data = vec![1, 2, 3];
    let reference = &data;
    // println!("{:?}", data); // 编译错误
    
    // 2. 所有权移动错误
    let string1 = String::from("hello");
    let string2 = string1; // 移动所有权
    // println!("{}", string1); // 编译错误
    println!("{}", string2);
    
    // 3. 可变性错误
    let mut counter = 0;
    counter += 1; // 需要 mut 声明
    
    // 4. 借用检查器错误
    let mut data = vec![1, 2, 3];
    let first = &data[0]; // 不可变借用
    // data.push(4); // 编译错误，因为存在借用
    
    println!("{}", first);
}
}

1.7 练习题

练习 1.1：环境检测

创建一个简单的环境检测工具，检查：

当前操作系统
Rust 版本信息
已安装的 Cargo 工具

练习 1.2：项目模板

设计一个脚手架工具，能够：

生成标准的 Rust 项目结构
配置常用的依赖
创建 Git 仓库

1.8 本章总结

通过本章学习，你已经掌握了：

Rust 语言基础概念：内存安全、所有权系统、零成本抽象
环境安装配置：rustup 工具链管理、工具链切换
Cargo 包管理：项目结构、依赖管理、构建过程
实践项目：企业级开发环境配置工具

关键要点

Rust 的设计哲学和安全特性
工具链的安装和管理
Cargo 工作流
项目结构最佳实践

下一步

深入学习 Rust 语法
掌握变量和数据类型
理解所有权和借用
开发实战项目

练习答案和更多资源将在后续章节中提供。记住，实践是掌握 Rust 的最佳方式！

第2章：变量、数据类型与控制流

学习目标

掌握 Rust 中变量声明和使用的基本语法
理解各种数据类型的特性和使用场景
熟练使用控制流语句进行逻辑控制
学会定义和调用函数

2.1 变量与可变性

2.1.1 基本变量声明

在 Rust 中，变量通过 let 关键字声明，默认是不可变的（immutable）。这意味着一旦变量被绑定到一个值，你就不能再修改它。这种设计是为了确保代码的安全性和可预测性，避免意外的副作用。Rust 的类型系统会自动推断变量的类型，但你也可以显式指定（如 let x: i32 = 5;）。

#![allow(unused)]
fn main() {
// 基本变量声明（不可变）
fn variable_basics() {
    let x = 42;                    // 整数
    let y = 3.14;                  // 浮点数
    let name = "Rust";             // 字符串字面量
    let is_rust_awesome = true;    // 布尔值
    
    println!("整数: {}", x);
    println!("浮点数: {}", y);
    println!("字符串: {}", name);
    println!("布尔值: {}", is_rust_awesome);
    
    // 变量遮蔽（shadowing）
    let x = x + 10;                // 创建新的 x，原 x 被隐藏
    {
        let x = "shadowed";       // 创建新的 x，原 x 被隐藏
        println!("遮蔽中的 x: {}", x);
    }
    println!("遮蔽后的 x: {}", x);
}
}

Result:

整数: 42
浮点数: 3.14
字符串: Rust
布尔值: true
遮蔽中的 x: shadowed
遮蔽后的 x: 52

关键点：

使用 let 绑定值。
变量名区分大小写，遵循蛇形命名法（snake_case）。
在函数或块作用域内有效，超出作用域后自动释放（所有权系统）。

2.1.2 可变变量

Rust 的默认不可变性很严格，但如果你需要修改变量，可以使用 mut 关键字声明为可变的（mutable）。这允许你重新赋值，但必须在声明时就指定，以明确意图。注意，可变性是作用域内的：一个变量在整个作用域内要么可变，要么不可变，不能中途改变。

#![allow(unused)]
fn main() {
fn mutable_variables() {
    // 可变变量声明
    let mut counter = 0;
    println!("初始值: {}", counter);
    
    // 修改可变变量
    counter += 1;
    counter *= 2;
    println!("修改后: {}", counter);
    
    // 可变变量的典型用途
    let mut sum = 0;  // 初始化为 0
    let numbers = vec![1, 2, 3, 4, 5];  // 创建一个向量
    
    for num in numbers {
        sum += num;                // 在循环中累积计算
    }
    
    println!("数列和: {}", sum);
}
}

Result:

初始值: 0
修改后: 2
数列和: 15

关键点：

使用 let mut 声明可变变量。
可变变量可以在声明后重新赋值。
可变变量在循环或函数中常用，以累积计算结果。
可变变量在 Rust 中是谨慎使用的，以避免意外修改。
只在需要时使用 mut，以最小化可变性（减少 bug 风险）。
在借用规则下，可变借用（&mut）有严格限制，确保线程安全。
作用域内，变量要么可变，要么不可变，不能中途改变。

可变变量是 Rust 灵活性的关键，但结合所有权和借用检查器，使用时需小心避免编译错误。

2.1.3 常量声明

常量通过 const 关键字声明，是不可变的，且必须在编译时确定值（不能是运行时计算的）。常量是全局可见的（如果在模块顶层声明），并在整个程序生命周期内有效。它们适合定义不变的配置或数学常数。类型必须显式指定，且不能是 mut。

#![allow(unused)]
fn main() {
// 常量声明（always immutable, must have type annotation）
fn constants_example() {
    const PI: f64 = 3.14159265359;  // 浮点数常量
    const MAX_SIZE: usize = 1000; // 无符号整数常量
    const GREETING: &str = "Hello, World!"; // 字符串常量
    
    println!("PI = {}", PI);
    println!("最大尺寸: {}", MAX_SIZE);
    println!("问候语: {}", GREETING);
    
    // 常量表达式
    const AREA: f64 = PI * 10.0 * 10.0;  // 圆面积公式
    println!("圆面积: {}", AREA);
}
}

Result:

PI = 3.14159265359
最大尺寸: 1000
问候语: Hello, World!
圆面积: 314.15926535899996

关键点：

使用 const NAME: Type = value; 格式，NAME 遵循大写蛇形命名（SCREAMING_SNAKE_CASE）。
值必须是常量表达式（如字面量、简单计算），不能依赖运行时输入。
静态常量（static）类似，但有额外生命周期考虑；const 更常见用于简单值。
常量在编译时确定，提升代码的可维护性和性能。
常量不可变，适用于定义不变的事实或配置。

常量提升了代码的可维护性，因为它们是不可变的“事实”，并在编译时优化。

2.2 基础数据类型

Rust 的基础数据类型分为标量类型（scalar types）和复合类型（compound types）。标量类型表示单一值，复合类型可包含多个值。这些类型在编译时确定大小，确保内存安全和性能。

标量类型（Scalars）

整数（Integers）：有符号（i8, i16, i32, i64, isize）和无符号（u8, u16, u32, u64, usize）。默认 i32。
浮点数（Floats）：f32（单精度）和 f64（双精度，默认）。
布尔（Boolean）：bool，仅 true 或 false。
字符（Character）：char，Unicode 标量值（如 'a'）。

复合类型（Compounds）

元组（Tuples）：固定大小的异构集合，如 (i32, bool)。
数组（Arrays）：固定长度、同构元素，如 [i32; 5]（5 个 i32）。

2.2.1 整数类型

#![allow(unused)]
fn main() {
fn integer_types() {
    // 有符号整数
    let i8_val: i8 = -128;          // 范围: -128 到 127 
    let i16_val: i16 = -32768;      // 范围: -32768 到 32767
    let i32_val: i32 = -2147483648; // 默认的整数类型
    let i64_val: i64 = -9223372036854775808;
    let i128_val: i128 = -170141183460469231731687303715884105728;
    
    // 无符号整数
    let u8_val: u8 = 255;           // 范围: 0 到 255
    let u16_val: u16 = 65535;
    let u32_val: u32 = 4294967295;
    let u64_val: u64 = 18446744073709551615;
    let u128_val: u128 = 340282366920938463463374607431768211455;
    
    // 平台相关整数类型
    let isize: isize = -1;          // 平台相关大小
    let usize: usize = 1;           // 平台相关大小
    
    // 数值字面量
    let decimal = 98_222;           // 十进制（可用下划线分隔）
    let hex = 0xff;                 // 十六进制
    let octal = 0o77;               // 八进制
    let binary = 0b1111_0000;       // 二进制
    let byte = b'A';                // 字节字符（仅 u8）
    
    println!("整数值: {}, {}, {}, {}", decimal, hex, octal, binary);
}
}

Result:

整数值: 98222, 255, 63, 240

关键点：

Rust 中的整数类型有符号和无符号，有符号整数可以表示负数，无符号整数只能表示非负数。
Rust 提供了多种整数类型，包括 8 位、16 位、32 位、64 位和 128 位的有符号和无符号整数。
Rust 还提供了平台相关的整数类型，如 isize 和 usize，它们的大小取决于运行程序的计算机架构。
Rust 支持数值字面量的多种表示方式，包括十进制、十六进制、八进制和二进制。
Rust 中的整数类型都有固定的范围，超过范围会导致溢出错误。
Rust 提供了 std::num 模块中的函数来处理整数溢出，如 wrapping_add、wrapping_sub、wrapping_mul 等。
...

2.2.2 浮点类型

#![allow(unused)]
fn main() {
fn float_types() {
    let f32_val: f32 = 3.141592653589793; // 32位浮点
    let f64_val: f64 = 3.141592653589793; // 64位浮点（默认）

    // 特殊值
    let infinity = f32::INFINITY;
    let neg_infinity = f32::NEG_INFINITY;
    let not_a_number = f32::NAN;

    println!("f32: {}", f32_val);
    println!("f64: {}", f64_val);
    println!("无穷大: {}", infinity);
    println!("负无穷大: {}", neg_infinity);
    println!("非数字: {}", not_a_number);

    // 数学运算
    let result = f32::sqrt(2.0);
    println!("√2 = {}", result);

    // 比较运算
    let x: f64 = 1.0;   //必须显式声明类型，否则编译器无法推断
    let y: f64 = 0.1 + 0.1 + 0.1 + 0.1 + 0.1; //必须显式声明类型，否则编译器无法推断
    println!("x == y: {}", x == y); // 避免直接比较浮点数
    println!("(x - y).abs() < 1e-10: {}", (x - y).abs() < 1e-10);
}
}

Result:

f32: 3.1415927
f64: 3.141592653589793
无穷大: inf
负无穷大: -inf
非数字: NaN
√2 = 1.4142135
x == y: false
(x - y).abs() < 1e-10: false

关键点：

Rust 提供了两种浮点类型：f32 和 f64，分别占用 32 位和 64 位内存。
浮点数可以表示特殊值，如无穷大、负无穷大和非数字（NaN）。
浮点数运算可能会产生不精确的结果，因此建议避免直接比较浮点数，而是比较它们的差值是否在可接受范围内。
浮点数运算符包括加法（+）、减法（-）、乘法（*）、除法（/）和取余（%）。
浮点数函数包括平方根（sqrt）、指数（exp）、对数（log）、三角函数等。
浮点数类型可以与整数类型进行混合运算，但结果类型将自动提升为浮点数类型。
浮点数类型可以与布尔类型进行混合运算，但结果类型将自动提升为布尔类型。
浮点数类型可以与字符串类型进行混合运算，但结果类型将自动提升为字符串类型。
...

2.2.3 布尔类型

#![allow(unused)]
fn main() {
fn boolean_types() {
    let is_learning_rust = true;
    let is_difficult = false;

    // 条件表达式
    let message = if is_learning_rust {
        "Keep going!"
    } else {
        "Try harder!"
    };

    // 布尔逻辑
    let both_true = is_learning_rust && !is_difficult;
    let either_or = is_learning_rust || is_difficult;

    println!("{} {}", message, both_true);
    println!("Either learning or difficult: {}", either_or);

    // 模式匹配中的布尔
    match (is_learning_rust, is_difficult) {
        (true, false) => println!("Perfect learning situation!"),
        (true, true) => println!("Challenging but rewarding!"),
        (false, _) => println!("Maybe try something else?"),
    }
}
}

Result:

Keep going! true
Either learning or difficult: true
Perfect learning situation!

关键点：

布尔类型只有两个值：true 和 false。
布尔类型可以与整数类型进行混合运算，但结果类型将自动提升为整数类型。
布尔类型可以与字符串类型进行混合运算，但结果类型将自动提升为字符串类型。

2.2.4 字符类型

Rust 中的“字符”指的是 Unicode 标量值（Unicode scalar value），通过 chars() 方法获取。它不是固定大小的字节，而是逻辑上的字符单位。

字符需要使用单引号包裹，并且只能表示一个字符。字符串底层是字节数组（[u8]），可以通过 as_bytes() 获取视图。

注意：字节操作高效，但需小心：切片字节可能截断字符，导致无效 UTF-8。

#![allow(unused)]
fn main() {
fn character_types() {
    let c1 = 'z';                          // 单个字符
    let c2 = 'ℤ';                          // Unicode 字符
    let c3 = '😊';                         // 表情符号
    
    println!("字符: {}, {}, {}", c1, c2, c3);
    
    // 转义字符
    let newline = '\n';
    let tab = '\t';
    let quote = '\'';
    let backslash = '\\';
    
    // 字符串中的字符
    let string = "Hello, 世界! 🌍";
    for (index, char) in string.chars().enumerate() {
        println!("字符 {}: {}", index, char);
    }
    
    // 获取字节
    let bytes = string.as_bytes();
    println!("字符串长度（字节）: {}", bytes.len());
}
}

Result:

字符: z, ℤ, 😊
字符 0: H
字符 1: e
字符 2: l
字符 3: l
字符 4: o
字符 5: ,
字符 6:
字符 7: 世
字符 8: 界
字符 9: !
字符 10:
字符 11: 🌍
字符串长度（字节）: 19

关键点：

字符类型是 Unicode 标量值，可以表示任何字符。
字符串是字节数组，可以通过 as_bytes() 获取字节视图。
字符串中的字符可以通过 chars() 方法获取，并使用 enumerate() 方法遍历。
字符串长度是字节长度，而不是字符长度。
字符串中的字符可能被截断，导致无效 UTF-8。
字符串中的字符可以通过 chars() 方法获取，并使用 enumerate() 方法遍历。
...

2.3 复合数据类型：元组和数组

2.3.1 元组（Tuple）

元组是固定长度的有序集合，可以包含不同类型的元素。创建后长度不可变，但内部元素可以是非同质的。

元组基础操作

#![allow(unused)]
fn main() {
fn tuple_basics() {
    // 创建元组
    let tup: (i32, f64, u8) = (500, 6.4, 1);
    let tup2 = (42, "Hello", true);
    
    // 访问元组元素（使用索引）
    let x = tup.0;  // 500
    let y = tup.1;  // 6.4
    let z = tup.2;  // 1
    
    println!("元组值: ({}, {}, {})", x, y, z);
    
    // 解构赋值（模式匹配）
    let (a, b, c) = tup;
    println!("解构后的值: a={}, b={}, c={}", a, b, c);
    
    // 单个元素的元组（注意逗号）
    let single_tuple: (i32,) = (5,);
    let single_value = single_tuple.0;
    println!("单个元素元组: ({}, {})", single_value, single_tuple.0);
}
}

Result:

元组值: (500, 6.4, 1)
解构后的值: a=500, b=6.4, c=1
单个元素元组: (5, 5)

关键点：

元组是固定长度的有序集合，可以包含不同类型的元素。
元组可以通过索引访问元素，索引从 0 开始。
元组可以使用解构赋值将元素赋值给变量。
单个元素的元组需要使用逗号，否则会被解析为表达式。
元组可以用于函数返回多个值。
元组可以用于模式匹配，将元组中的元素赋值给变量。
...

实用元组示例

#![allow(unused)]
fn main() {
fn practical_tuples() {
    // 函数返回多个值
    let result = divide_and_remainder(17, 5);
    let (quotient, remainder) = result;
    println!("17 除以 5 的商和余数: {}, {}", quotient, remainder);
    
    // 使用解构直接获取结果
    let (sum, product) = calculate_sum_product(10, 20);
    println!("和: {}, 积: {}", sum, product);
    
    // 存储混合类型的数据
    let person_info = ("张三", 25, 175.5, true);
    let (name, age, height, is_student) = person_info;
    println!("{}今年{}岁，身高{:.1}cm，状态：{}", name, age, height, 
             if is_student { "学生" } else { "非学生" });
    
    // 嵌套元组
    let nested_tuple = (1, (2, 3), 4);
    let inner_tuple = nested_tuple.1;
    let first_inner = inner_tuple.0;  // 2
    println!("嵌套元组中的值: {}", first_inner);
}

// 返回元组的函数示例
fn divide_and_remainder(dividend: i32, divisor: i32) -> (i32, i32) {
    let quotient = dividend / divisor;
    let remainder = dividend % divisor;
    (quotient, remainder)
}

fn calculate_sum_product(a: i32, b: i32) -> (i32, i32) {
    (a + b, a * b)
}
}

Result：

17 除以 5 的商和余数: 3, 2
和: 30, 积: 200
张三今年25岁，身高175.5cm，状态：学生
嵌套元组中的值: 2

元组在模式匹配中的应用

#![allow(unused)]
fn main() {
fn tuple_pattern_matching() {
    let coordinates = (10, 20);
    
    match coordinates {
        (0, 0) => println!("原点"),
        (x, 0) => println!("在X轴上，X坐标: {}", x),
        (0, y) => println!("在Y轴上，Y坐标: {}", y),
        (x, y) => println!("坐标点: ({}, {})", x, y),
    }
    
    // 包含条件守卫的模式
    let point = (15, 30);
    match point {
        (x, y) if x == y => println!("在对角线上: ({}, {})", x, y),
        (x, y) if x + y == 45 => println!("坐标和为45: ({}, {})", x, y),
        (x, y) => println!("一般坐标: ({}, {})", x, y),
    }
    
    // 解构函数参数
    let (name, age) = get_person_info();
    println!("个人信息: {}，{}岁", name, age);
}

fn get_person_info() -> (&'static str, u32) {
    ("李四", 30)
}
}

Result：

坐标点: (10, 20)
坐标和为45: (15, 30)
个人信息: 李四，30岁

关键点：

元组可以包含不同类型的元素。
元组可以用于模式匹配，以提取和操作元组中的值。
元组可以用于函数返回值，以返回多个值。
元组可以用于解构赋值，以将元组中的值分配给多个变量。
元组可以用于模式匹配中的条件守卫，以根据条件执行不同的代码块。
元组可以用于函数参数，以传递多个值给函数。
元组可以用于解构函数参数，以将函数参数中的值分配给多个变量。
元组可以用于模式匹配中的条件守卫，以根据条件执行不同的代码块。
元组可以用于函数返回值，以返回多个值给调用者。
...

2.3.2 数组（Array）

数组是固定长度的相同类型元素的集合。数组长度在编译时确定，不能动态增长。

数组基础操作

#![allow(unused)]
fn main() {
fn array_basics() {
    // 数组声明和初始化
    let numbers: [i32; 5] = [1, 2, 3, 4, 5];
    let floats = [3.14, 2.71, 1.41, 1.73];  // 类型推导
    let chars = ['R', 'u', 's', 't'];       // 字符数组
    
    // 访问数组元素
    let first = numbers[0];
    let last = numbers[4];
    println!("第一个元素: {}, 最后一个元素: {}", first, last);
    
    // 数组长度
    println!("numbers数组长度: {}", numbers.len());
    
    // 初始化相同值的数组
    let repeated = [0; 10];  // 长度为10的数组，所有元素都是0
    println!("重复值数组长度: {}", repeated.len());
    
    // 遍历数组
    for (index, &value) in numbers.iter().enumerate() {
        println!("numbers[{}] = {}", index, value);
    }
}
}

Result：

第一个元素: 1, 最后一个元素: 5
numbers数组长度: 5
重复值数组长度: 10
numbers[0] = 1
numbers[1] = 2
numbers[2] = 3
numbers[3] = 4
numbers[4] = 5

关键点：

数组长度在编译时确定，不能动态增长。
数组元素类型相同。
数组元素可以通过索引访问。
数组长度可以通过 len() 方法获取。
数组可以初始化为相同值。
数组可以遍历。
数组元素可以通过 iter() 方法获取迭代器，然后使用 enumerate() 方法获取索引和值。
数组元素可以通过 & 符号获取引用，以避免所有权转移。
数组元素可以通过 iter_mut() 方法获取可变引用，以修改数组元素。
数组元素可以通过 get() 方法获取可变引用，以修改数组元素。
数组元素可以通过 get_mut() 方法获取可变引用，以修改数组元素。
...

数组与循环

#![allow(unused)]
fn main() {
fn array_loops() {
    let arr = [10, 20, 30, 40, 50];
    let mut sum = 0;
    
    // 方法1: 使用索引循环
    let len = arr.len();
    for i in 0..len {
        sum += arr[i];
        println!("添加 arr[{}] = {}, 当前总和: {}", i, arr[i], sum);
    }
    println!("数组总和: {}", sum);
    
    // 方法2: 直接遍历元素（更安全）
    let mut sum2 = 0;
    for &value in &arr {
        sum2 += value;
        println!("元素值: {}", value);
    }
    println!("重新计算的总和: {}", sum2);
    
    // 方法3: enumerate遍历
    for (i, &value) in arr.iter().enumerate() {
        println!("索引 {}: 值 {}", i, value);
    }
}
}

Result：

添加 arr[0] = 10, 当前总和: 10
添加 arr[1] = 20, 当前总和: 30
添加 arr[2] = 30, 当前总和: 60
添加 arr[3] = 40, 当前总和: 100
添加 arr[4] = 50, 当前总和: 150
数组总和: 150
元素值: 10
元素值: 20
元素值: 30
元素值: 40
元素值: 50
重新计算的总和: 150
索引 0: 值 10
索引 1: 值 20
索引 2: 值 30
索引 3: 值 40
索引 4: 值 50

关键点：

使用 & 符号获取不可变引用，以遍历数组元素。
使用 iter() 方法获取不可变引用，以遍历数组元素。
使用 iter_mut() 方法获取可变引用，以修改数组元素。
使用 enumerate() 方法获取索引和值，以遍历数组元素。
...

多维数组

#![allow(unused)]
fn main() {
fn multidimensional_arrays() {
    // 二维数组
    let matrix: [[i32; 3]; 2] = [
        [1, 2, 3],
        [4, 5, 6],
    ];
    
    println!("矩阵内容:");
    for (i, row) in matrix.iter().enumerate() {
        for (j, &value) in row.iter().enumerate() {
            print!("matrix[{}][{}] = {}  ", i, j, value);
        }
        println!();
    }
    
    // 访问二维数组元素
    let element = matrix[1][2];  // 第二行第三列的值: 6
    println!("matrix[1][2] = {}", element);
    
    // 三维数组示例
    let three_d: [[[i32; 2]; 2]; 2] = [
        [[1, 2], [3, 4]],
        [[5, 6], [7, 8]],
    ];
    
    println!("三维数组内容:");
    for (i, depth) in three_d.iter().enumerate() {
        for (j, row) in depth.iter().enumerate() {
            for (k, &value) in row.iter().enumerate() {
                print!("[{}][{}][{}] = {}  ", i, j, k, value);
            }
            println!();
        }
    }
}
}

Result:

矩阵内容:
matrix[0][0] = 1  matrix[0][1] = 2  matrix[0][2] = 3
matrix[1][0] = 4  matrix[1][1] = 5  matrix[1][2] = 6
matrix[1][2] = 6
三维数组内容:
[0][0][0] = 1  [0][0][1] = 2
[0][1][0] = 3  [0][1][1] = 4
[1][0][0] = 5  [1][0][1] = 6
[1][1][0] = 7  [1][1][1] = 8

关键点：

使用get方法安全地访问数组元素，避免越界错误。
使用iter方法遍历数组，并使用enumerate方法获取索引。
使用match表达式检查get方法返回的Option类型，以处理可能越界的情况。
使用多维数组时，可以嵌套使用iter和enumerate方法来遍历每个维度。
使用print!和println!宏来格式化输出。
...

数组越界检查

#![allow(unused)]
fn main() {
fn array_bounds_checking() {
    let arr = [10, 20, 30];
    
    // 安全的访问
    if let Some(&value) = arr.get(1) {
        println!("arr[1] = {}", value);
    }
    
    // 检查是否越界
    match arr.get(5) {
        Some(value) => println!("arr[5] = {}", value),
        None => println!("数组越界! 最大索引: {}", arr.len() - 1),
    }
    
    // 数组切片（引用数组的一部分）
    let slice = &arr[0..2];  // 包含索引0到1
    println!("切片内容: {:?}", slice);
    
    let slice_to_end = &arr[1..];  // 从索引1到末尾
    println!("从索引1开始的切片: {:?}", slice_to_end);
    
    let slice_from_start = &arr[..2];  // 从开头到索引2（不包含2）
    println!("从开头到索引2的切片: {:?}", slice_from_start);
    
    let full_slice = &arr[..];  // 整个数组的切片
    println!("完整切片: {:?}", full_slice);
}
}

Result:

arr[1] = 20
数组越界! 最大索引: 2
切片内容: [10, 20]
从索引1开始的切片: [20, 30]
从开头到索引2的切片: [10, 20]
完整切片: [10, 20, 30]

关键点：

使用get方法安全地访问数组元素，避免越界错误。
使用match表达式检查get方法返回的Option类型，以处理可能越界的情况。
使用数组切片（引用数组的一部分）来访问数组的一部分，避免越界错误。
...

实用数组操作

#![allow(unused)]
fn main() {
fn array_operations() {
    let mut numbers = [64, 34, 25, 12, 22, 11, 90];
    
    println!("原始数组: {:?}", numbers);
    
    // 查找最大值和最小值
    let max = numbers.iter().max().unwrap();
    let min = numbers.iter().min().unwrap();
    println!("最大值: {}, 最小值: {}", max, min);
    
    // 计算数组总和和平均值
    let sum: i32 = numbers.iter().sum();
    let average = sum as f64 / numbers.len() as f64;
    println!("总和: {}, 平均值: {:.2}", sum, average);
    
    // 过滤和变换
    let even_numbers: Vec<_> = numbers.iter()
        .filter(|&&x| x % 2 == 0)
        .copied()
        .collect();
    println!("偶数: {:?}", even_numbers);
    
    let squared: Vec<_> = numbers.iter()
        .map(|&x| x * x)
        .collect();
    println!("平方: {:?}", squared);
    
    // 检查是否包含某个值
    let contains_25 = numbers.contains(&25);
    let position = numbers.iter().position(|&x| x == 25);
    println!("包含25: {}, 位置: {:?}", contains_25, position);
    
    // 排序
    let mut sorted = numbers;
    sorted.sort();
    println!("排序后: {:?}", sorted);
}
}

Result：

原始数组: [64, 34, 25, 12, 22, 11, 90]
最大值: 90, 最小值: 11
总和: 258, 平均值: 36.86
偶数: [64, 34, 12, 22, 90]
平方: [4096, 1156, 625, 144, 484, 121, 8100]
包含25: true, 位置: Some(2)
排序后: [11, 12, 22, 25, 34, 64, 90]

关键点：

iter() 方法返回一个迭代器，用于遍历数组元素。
sum() 方法计算数组元素的总和。
copied() 方法将迭代器中的元素复制到新向量中。
filter() 方法用于过滤数组元素。
map() 方法用于变换数组元素。
contains() 方法用于检查数组是否包含某个值。
position() 方法用于查找数组中某个值的索引。
sort() 方法用于对数组进行排序。
enumerate() 方法用于同时获取数组元素的索引和值。
...

字符串数组和字符处理

#![allow(unused)]
fn main() {
fn string_and_char_arrays() {
    // 字符串数组
    let fruits = ["苹果", "香蕉", "橙子", "葡萄"];
    
    for (i, fruit) in fruits.iter().enumerate() {
        println!("fruits[{}] = {}", i, fruit);
    }
    
    // 字符数组
    let word = ['R', 'u', 's', 't'];
    let word_str: String = word.iter().collect();
    println!("字符数组转换为字符串: {}", word_str);
    
    // 字符数组的遍历
    for char in &word {
        println!("字符: {}", char);
        // 转换为ASCII码
        println!("ASCII码: {}", *char as u8);
    }
    
    // 计算字符串的长度（以字符计）
    let multi_char_str = "你好，世界！ 🌍";
    let chars: Vec<char> = multi_char_str.chars().collect();
    println!("字符串: {}", multi_char_str);
    println!("字符数量: {}", chars.len());
    println!("字节长度: {}", multi_char_str.len());
}
}

Result：

fruits[0] = 苹果
fruits[1] = 香蕉
fruits[2] = 橙子
fruits[3] = 葡萄
字符数组转换为字符串: Rust
字符: R
ASCII码: 82
字符: u
ASCII码: 117
字符: s
ASCII码: 115
字符: t
ASCII码: 116
字符串: 你好，世界！ 🌍
字符数量: 8
字节长度: 23

关键点：

iter() 方法用于获取数组的迭代器。
enumerate() 方法用于同时获取数组元素的索引和值。
collect() 方法用于将迭代器转换为集合类型。
chars() 方法用于将字符串转换为字符迭代器。
len() 方法用于获取字符串的长度（以字符计）。
...

字符串切片

#![allow(unused)]

fn main() {
### 数组在函数中的应用

```rust
fn array_in_functions() {
    let arr = [1, 2, 3, 4, 5];
    
    // 传递数组引用
    let sum = sum_array(&arr);
    let max = max_array(&arr);
    
    println!("数组: {:?}", arr);
    println!("总和: {}, 最大值: {}", sum, max);
    
    // 修改数组（需要mut）
    let mut mut_arr = [10, 20, 30];
    modify_array(&mut mut_arr);
    println!("修改后: {:?}", mut_arr);
    
    // 返回数组
    let squared = square_array(&arr);
    println!("平方后: {:?}", squared);
}

// 计算数组总和
fn sum_array(arr: &[i32]) -> i32 {
    arr.iter().sum()
}

// 找最大值
fn max_array(arr: &[i32]) -> i32 {
    arr.iter().max().copied().unwrap_or(0)
}

// 修改数组元素
fn modify_array(arr: &mut [i32]) {
    for i in 0..arr.len() {
        arr[i] *= 2;
    }
}

// 返回平方数组
fn square_array(arr: &[i32]) -> Vec<i32> {
    arr.iter().map(|&x| x * x).collect()
}
}

Result：

数组: [1, 2, 3, 4, 5]
总和: 15, 最大值: 5
修改后: [20, 40, 60]
平方后: [1, 4, 9, 16, 25]

关键点：

&arr 传递数组引用，避免所有权转移。
&mut mut_arr 传递可变数组引用，允许修改数组。
&arr 返回数组引用，避免所有权转移。
&arr 作为参数传递时，不需要显式地使用 &，因为数组引用已经是引用类型。
&arr 返回数组引用时，不需要显式地使用 &，因为数组引用已经是引用类型。
&mut mut_arr 作为参数传递时，需要显式地使用 &mut，因为数组引用是可变引用类型。
&mut mut_arr 返回数组引用时，需要显式地使用 &mut，因为数组引用是可变引用类型。
&arr 和 &mut mut_arr 在函数内部都是引用类型，不需要显式地使用 & 或 &mut。
...

2.4 字符串类型

2.4.1 字符串字面量和切片

Rust 中的字符串字面量是不可变的、硬编码的文本，使用双引号定义，如 "hello"。它们是 &str 类型（字符串切片），指向静态内存中的 UTF-8 编码字节序列。切片（slice）是引用现有数据的视图，如 &[T]，字符串切片 &str 是对字符串的不可变引用。

#![allow(unused)]
fn main() {
fn string_slices() {
    // 字符串字面量（&str）- 编译时常量
    let greeting = "Hello, Rust!";
    let name = "World";
    
    // 切片（不拥有所有权）
    let slice = &greeting[0..5];           // "Hello"
    let slice_from_middle = &greeting[7..11]; // "Rust"
    
    println!("完整问候: {}", greeting);
    println!("切片: {}", slice);
    
    // 字符串方法
    let trimmed = "  hello  ".trim();      // "hello"
    let uppercase = "rust".to_uppercase(); // "RUST"
    let lowercase = "RUST".to_lowercase(); // "rust"
    
    // 查找和分割
    let text = "one,two,three,four";
    let parts: Vec<&str> = text.split(',').collect();
    println!("分割结果: {:?}", parts);
    
    // 替换
    let replaced = "hello world".replace("world", "Rust");
    println!("替换后: {}", replaced);
}
}

Result：

完整问候: Hello, Rust!
切片: Hello
分割结果: ["one", "two", "three", "four"]
替换后: hello Rust

关键点：

字面量生命周期为 'static，不可变,它们是 &str 类型。
切片不拥有数据，仅借用；索引必须是有效 UTF-8 边界，否则 panic。
常用作函数参数，促进零拷贝。
字符串切片是引用类型，可以引用字符串字面量或 String 类型。
字符串切片可以用于字符串操作，如查找、替换和分割等。
字符串切片不拥有所有权，因此它们的生命周期不能超过它们引用的数据的生命周期。
字符串切片可以用于字符串字面量和 String 类型，但不能用于 char 类型。
字符串切片可以通过 &str 类型转换为 String 类型，但需要使用 to_string 方法。
字符串切片可以通过 split 方法分割为多个子字符串，并返回一个 Vec<&str> 类型的结果。
...

2.4.2 String 类型

String 是可增长、可变、拥有的 UTF-8 编码字符串，存储在堆上。不同于 &str，String 拥有数据，可以修改（如追加）。它实现了 Deref 到 &str，允许隐式转换为切片。

#![allow(unused)]
fn main() {
fn string_type() {
    // String 类型（拥有所有权）
    let mut s = String::new();             // 空字符串
    let s1 = String::from("hello");        // 从字符串字面量创建
    let s2 = "world".to_string();          // 转换为 String
    
    // 追加内容
    s.push('A');                           // 追加字符
    s.push_str("pple");                    // 追加字符串
    s += " Banana";                        // 连接操作符
    
    println!("字符串 s: {}", s);
    
    // 格式化
    let name = "Alice";
    let age = 30;
    let formatted = format!("{} is {} years old", name, age);
    println!("格式化: {}", formatted);
    
    // 使用宏
    println!("测试值: {}, 另一个值: {}", 42, "text");
    
    // 所有权示例
    let original = String::from("original");
    let moved = original;                  // 所有权转移
    // println!("{}", original);           // 编译错误！original 已移动
    println!("移动后的字符串: {}", moved);
}
}

Result：

字符串 s: Apple Banana
格式化: Alice is 30 years old
测试值: 42, 另一个值: text
移动后的字符串: original

关键点：

String 类型是拥有所有权的，因此需要使用 String::from 或 to_string 方法来创建 String 实例。
push 和 push_str 方法用于向 String 实例中追加内容。
所有权规则适用：移动后不可用，除非克隆（.clone()）。
format! 宏用于格式化字符串。
println! 宏用于打印字符串。
String 的所有权转移示例展示了所有权转移的概念，即 original 在赋值给 moved 后，original 不再有效。
...

2.5 控制流

2.5.1 if 条件语句

Rust 的 if 是表达式，可返回值的条件分支。无需括号包围条件，支持 else 和 else if。条件必须是 bool 类型，无隐式转换。

#![allow(unused)]
fn main() {
fn conditional_statements() {
    let number = 7;
    
    // 基本 if-else
    if number < 5 {
        println!("数字小于 5");
    } else if number == 5 {
        println!("数字等于 5");
    } else {
        println!("数字大于 5");
    }
    
    // if 作为表达式（返回值）
    let grade = if number >= 90 {
        "A"
    } else if number >= 80 {
        "B"
    } else if number >= 70 {
        "C"
    } else {
        "F"
    };
    
    println!("成绩: {}", grade);
    
    // 条件赋值
    let status = if number % 2 == 0 {
        "偶数"
    } else {
        "奇数"
    };
    println!("{} 是 {}", number, status);
}
}

Result：

数字大于 5
成绩: F
7 是 奇数

关键点：

if 语句的基本用法，包括条件判断和分支执行。
if 语句可以作为表达式返回值。
if 语句的嵌套使用。
条件赋值的使用，根据条件为变量赋值。
if 语句的执行顺序，根据条件判断结果选择执行相应的分支。
if 语句的返回值，可以是任意类型，但需要与上下文中的变量类型匹配。
...

2.5.2 循环控制

loop 无穷循环

#![allow(unused)]

fn main() {
## 2.5.2 循环控制

### loop 无穷循环

`loop` 是无限循环，直到显式 `break`。可返回值的表达式，支持标签用于嵌套循环控制。

```rust
fn loop_examples() {
    // 基本 loop
    let mut counter = 0;
    loop {
        counter += 1;
        println!("计数器: {}", counter);
        
        if counter >= 5 {
            break;                          // 退出循环
        }
    }
    
    // loop 作为表达式（返回值）
    let result = loop {
        counter += 1;
        
        if counter == 10 {
            break counter;                 // 退出并返回值
        }
    };
    
    println!("循环结果: {}", result);
}
}

Result：

计数器: 1
计数器: 2
计数器: 3
计数器: 4
计数器: 5
循环结果: 10

关键点：

break 退出循环
break 可以返回值
continue 跳过本次循环
loop 可以作为表达式，返回值
loop 可以嵌套
loop 可以与标签（label）配合使用，用于退出多层嵌套循环,标签如 'outer: loop {} 用于多层控制。
...

while 条件循环

while 是条件循环，在条件为 true 时执行。条件必须是 bool。

#![allow(unused)]
fn main() {
fn while_examples() {
    let mut number = 3;
    
    while number != 0 {
        println!("倒计时: {}", number);
        number -= 1;
    }
    
    println!("发射！");
    
    // 数组遍历
    let array = [10, 20, 30, 40, 50];
    let mut index = 0;
    
    while index < array.len() {
        println!("索引 {}: 值 {}", index, array[index]);
        index += 1;
    }
}
}

Result：

倒计时: 3
倒计时: 2
倒计时: 1
发射！
索引 0: 值 10
索引 1: 值 20
索引 2: 值 30
索引 3: 值 40
索引 4: 值 50

Result：

无 do-while，但可用 loop 模拟。
适合未知迭代次数但有条件的情况。
while 循环可以遍历数组，循环也可以嵌套
while 循环可以与标签（label）配合使用，用于退出多层嵌套循环
while 循环可以与 break 和 continue 配合使用，用于控制循环的执行
while 循环可以与 loop 配合使用，用于创建无限循环
while 循环可以与 for 循环配合使用，用于遍历集合
while 循环可以与 match 配合使用，用于处理多种情况
while 循环可以与 if 配合使用，用于条件判断
while 循环可以与 let 配合使用，用于声明变量
while 循环可以与 return 配合使用，用于返回值
while 循环可以与 yield 配合使用，用于生成器函数
while 循环可以与 try 配合使用，用于处理错误
while 循环可以与 await 配合使用，用于异步编程
while 循环可以与 panic! 配合使用，用于处理异常
while 循环可以与 println! 配合使用，用于输出日志
while 循环可以与 debug!、info!等配合使用，用于调试
while 循环可以与 assert! 配合使用，用于断言
while 循环可以与 unwrap!、 expect! 配合使用，用于处理 Option 和 Result等等
...

for 循环和迭代器

for 用于迭代集合，如范围或迭代器。语法 for item in iterator {}，高效处理所有权。

#![allow(unused)]
fn main() {
fn for_loop_examples() {
    // 基本 for 循环
    for i in 0..5 {                        // 0 到 4
        println!("for 循环: {}", i);
    }
    
    // 包含结束值的 range
    for i in 0..=5 {                       // 0 到 5
        println!("包含结束值: {}", i);
    }
    
    // 数组迭代
    let array = [1, 2, 3, 4, 5];
    for item in array {
        println!("数组项: {}", item);
    }
    
    // 索引和值的迭代
    let names = vec!["Alice", "Bob", "Charlie"];
    for (index, name) in names.iter().enumerate() {
        println!("{}: {}", index, name);
    }
    
    // 字符串字符迭代
    let text = "Rust";
    for char in text.chars() {
        println!("字符: {}", char);
    }
    
    // 字节迭代
    for byte in text.bytes() {
        println!("字节: {}", byte);
    }
}
}

Result：

for 循环: 0
for 循环: 1
for 循环: 2
for 循环: 3
for 循环: 4
包含结束值: 0
包含结束值: 1
包含结束值: 2
包含结束值: 3
包含结束值: 4
包含结束值: 5
数组项: 1
数组项: 2
数组项: 3
数组项: 4
数组项: 5
0: Alice
1: Bob
2: Charlie
字符: R
字符: u
字符: s
字符: t
字节: 82
字节: 117
字节: 115
字节: 116

关键点：

for 循环用于遍历范围、数组、向量、字符串等。
0..5 创建一个从 0 到 4 的范围。
0..=5 创建一个从 0 到 5 的范围（包含 5）。
array 是一个数组，names 是一个向量。
enumerate 方法用于获取索引和值。
...

2.5.3 模式匹配

模式匹配通过 match 表达式解构值，处理多种情况。必须穷尽所有可能（或用 _ 通配）。支持绑定、守卫和嵌套。

#![allow(unused)]
fn main() {
fn pattern_matching() {
    let x = 42;
    
    match x {
        0 => println!("零"),
        1..=10 => println!("一到十之间"),
        20 | 30 | 40 => println!("20, 30 或 40"),
        n if n % 2 == 0 => println!("偶数: {}", n),
        _ => println!("其他值: {}", x),    // 通配符
    }
    
    // 绑定值的模式
    match x {
        0 => println!("零"),
        1 => println!("一"),
        n => println!("其他: {}", n),      // 绑定值
    }
    
    // 复合模式
    let point = (0, 7);
    match point {
        (0, 0) => println!("原点"),
        (0, y) => println!("在 Y 轴上: y = {}", y),
        (x, 0) => println!("在 X 轴上: x = {}", x),
        (x, y) => println!("点 ({}, {})", x, y),
    }
}
}

Result：

偶数: 42
其他: 42
在 Y 轴上: y = 7

关键点：

模式如绑定（x @ 1..=5）、解构（元组、结构体）。
与 if let、while let 结合简化可选匹配。
match 语句用于模式匹配。
if 表达式可以在 match 分支中使用。
_ 是通配符，匹配任何值。
绑定值可以在 match 分支中使用。
复合模式可以匹配多个值。
match 语句必须覆盖所有可能的值。
match 语句可以返回值。
match 语句用途广泛,可用于错误处理、枚举类型、元组、结构体、引用(可变/不可变)、切片、数组、字符串、闭包、函数、宏、模式匹配、类型转换、类型检查等场景。
...

2.6 函数定义与调用

2.6.1 函数基础

Rust 中的函数是代码的可重用块，通过 fn 关键字定义。函数名使用蛇形命名法（snake_case），并可接受参数和返回值。每个程序至少有一个 main 函数作为入口。函数体用 {}包围，支持表达式和语句。Rust 函数是静态类型的，确保类型安全。

#![allow(unused)]
fn main() {
// 函数定义
fn greet(name: &str) {
    println!("你好, {}!", name);
}

// 有返回值的函数
fn add(a: i32, b: i32) -> i32 {
    a + b                                 // 没有分号表示返回值
}

// 显式返回语句
fn multiply(x: i32, y: i32) -> i32 {
    return x * y;                         // 显式返回
}

// 函数调用
fn function_examples() {
    greet("Rust");
    let sum = add(5, 3);
    let product = multiply(4, 7);
    
    println!("5 + 3 = {}", sum);
    println!("4 × 7 = {}", product);
    
    // 函数作为表达式
    let result = {
        let a = 10;
        let b = 20;
        a + b                             // 块表达式返回值
    };
    println!("块表达式结果: {}", result);
}
}

Result：

你好, Rust!
5 + 3 = 8
4 × 7 = 28
块表达式结果: 30

关键点：

函数定义使用 fn 关键字。
函数参数类型在参数名后面指定。
函数返回值类型在 -> 后面指定。
函数体中的最后一行表达式是返回值，不需要分号。
函数调用使用函数名和参数列表。
函数可以返回值，也可以不返回值。
函数可以包含块表达式，块表达式的最后一行是返回值。
函数可以嵌套定义，但不能嵌套调用。
函数可以递归调用，但不能递归定义。
函数可以接受可变参数，但不能接受可变参数数量。
...

2.6.2 函数参数和返回值

函数参数在括号中定义，指定类型。Rust 使用所有权系统：参数可通过值传递（移动所有权）或引用（借用）。可变参数需用 mut。参数是不可变的，除非显式标记。函数通过 -> Type 指定返回值类型。最后表达式隐式返回，或用 return 显式返回。无返回值默认为 ()（单元类型）。多值返回用元组。

#![allow(unused)]
fn main() {
// 多个参数
fn calculate_area(length: f64, width: f64) -> f64 {
    length * width
}

// 可变参数数量
fn print_values(values: &[i32]) {
    for value in values {
        println!("值: {}", value);
    }
}

// 元组返回
fn get_coordinates() -> (i32, i32) {
    (10, 20)
}

// 命名返回结构
#[derive(Debug)]
struct Rectangle {
    width: f64,
    height: f64,
}

fn create_rectangle(width: f64, height: f64) -> Rectangle {
    Rectangle { width, height }
}

fn calculate_rectangle_area(rect: &Rectangle) -> f64 {
    rect.width * rect.height
}

fn function_parameters() {
    let area = calculate_area(5.0, 3.0);
    println!("矩形面积: {}", area);
    
    let values = vec![1, 2, 3, 4, 5];
    print_values(&values);
    
    let (x, y) = get_coordinates();
    println!("坐标: ({}, {})", x, y);
    
    let rectangle = create_rectangle(4.0, 6.0);
    let rect_area = calculate_rectangle_area(&rectangle);
    println!("矩形面积: {}", rect_area);
}
}

Result：

矩形面积: 15
值: 1
值: 2
值: 3
值: 4
值: 5
坐标: (10, 20)
矩形面积: 24

关键点：

Rust 中的函数参数和返回值类型必须显式声明。
Rust 中的函数参数和返回值类型可以是泛型、元组、结构体、枚举、闭包等多种类型。
...

2.6.3 高阶函数示例

#![allow(unused)]
fn main() {
// 基础函数
fn add(a: i32, b: i32) -> i32 {
    a + b
}

fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

// 函数作为参数
fn apply_function<F>(value: i32, f: F) -> i32
where
    F: Fn(i32) -> i32,
{
    f(value)
}

// 函数作为返回值
fn get_operation(operation: &str) -> fn(i32, i32) -> i32 {
    match operation {
        "add" => add,
        "multiply" => multiply,
        _ => add, // 默认操作
    }
}

fn higher_order_functions() {
    let result1 = apply_function(5, |x| x * x); // 闭包
    let result2 = apply_function(10, |x| x + 100); // 另一个闭包

    println!("平方: {}", result1);
    println!("加100: {}", result2);

    let operation = get_operation("add");
    let result3 = operation(15, 25);
    println!("函数指针结果: {}", result3);
}
}

Result：

平方: 25
加100: 110
函数指针结果: 40

关键点：

Rust 中的函数可以作为参数传递。
Rust 中的函数可以作为返回值。
Rust 中的闭包是一种匿名函数，可以作为参数传递或作为返回值。
Rust 中的函数指针是一种指向函数的指针，可以作为参数传递或作为返回值。
Rust 中的泛型函数可以接受不同类型的参数，并返回不同类型的值。
Rust 中的函数可以接受元组、结构体、枚举等多种类型的参数，并返回不同类型的值。
Rust 中的函数可以接受可变参数，并返回不同类型的值。
...

2.7 实践项目：科学计算器与数据处理工具

2.7.1 项目需求分析

创建一个功能完善的科学计算器，支持：

基础和科学运算
表达式解析和求值
数据统计分析
历史记录功能

2.7.2 项目结构设计

// src/main.rs
mod calculator;
mod data;
mod history;
mod utils;

use calculator::{Calculator, Operation};
use data::Statistics;
use history::HistoryManager;
use utils::Error;

fn main() -> Result<(), Error> {
    println!("=== 科学计算器 v1.0 ===");
    
    let mut calculator = Calculator::new();
    let mut history = HistoryManager::new();
    
    // 示例计算
    run_example_calculations(&mut calculator, &mut history)?;
    
    Ok(())
}

fn run_example_calculations(
    calc: &mut Calculator, 
    history: &mut HistoryManager
) -> Result<(), Error> {
    // 基础运算
    let result1 = calc.add(10.0, 5.0)?;
    println!("10 + 5 = {}", result1);
    history.add_record("10 + 5", result1);
    
    let result2 = calc.multiply(result1, 2.0)?;
    println!("({}) × 2 = {}", result1, result2);
    history.add_record("10 + 5 * 2", result2);
    
    // 科学运算
    let result3 = calc.sqrt(16.0)?;
    println!("√16 = {}", result3);
    history.add_record("√16", result3);
    
    let result4 = calc.sin(30.0_f64.to_radians())?;
    println!("sin(30°) = {}", result4);
    history.add_record("sin(30°)", result4);
    
    // 表达式求值
    let expr_result = calc.evaluate_expression("(10 + 5) * 2 - √16")?;
    println!("(10 + 5) * 2 - √16 = {}", expr_result);
    history.add_record("(10 + 5) * 2 - √16", expr_result);
    
    // 统计计算
    let data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
    let stats = calc.calculate_statistics(&data)?;
    println!("数据集统计: {:?}", stats);
    
    history.display();
    
    Ok(())
}

2.7.3 计算器核心模块

#![allow(unused)]
fn main() {
// src/calculator/mod.rs
pub mod operations;
pub mod parser;
pub mod evaluator;

use operations::Operation;
use parser::ExpressionParser;
use evaluator::ExpressionEvaluator;
use utils::Error;

pub struct Calculator {
    parser: ExpressionParser,
    evaluator: ExpressionEvaluator,
}

impl Calculator {
    pub fn new() -> Self {
        Self {
            parser: ExpressionParser::new(),
            evaluator: ExpressionEvaluator::new(),
        }
    }
    
    // 基础运算方法
    pub fn add(&self, a: f64, b: f64) -> Result<f64, Error> {
        Ok(a + b)
    }
    
    pub fn subtract(&self, a: f64, b: f64) -> Result<f64, Error> {
        Ok(a - b)
    }
    
    pub fn multiply(&self, a: f64, b: f64) -> Result<f64, Error> {
        Ok(a * b)
    }
    
    pub fn divide(&self, a: f64, b: f64) -> Result<f64, Error> {
        if b == 0.0 {
            return Err(Error::DivisionByZero);
        }
        Ok(a / b)
    }
    
    pub fn power(&self, base: f64, exponent: f64) -> Result<f64, Error> {
        Ok(base.powf(exponent))
    }
    
    pub fn sqrt(&self, value: f64) -> Result<f64, Error> {
        if value < 0.0 {
            return Err(Error::NegativeSquareRoot);
        }
        Ok(value.sqrt())
    }
    
    pub fn sin(&self, angle: f64) -> Result<f64, Error> {
        Ok(angle.sin())
    }
    
    pub fn cos(&self, angle: f64) -> Result<f64, Error> {
        Ok(angle.cos())
    }
    
    pub fn tan(&self, angle: f64) -> Result<f64, Error> {
        Ok(angle.tan())
    }
    
    pub fn ln(&self, value: f64) -> Result<f64, Error> {
        if value <= 0.0 {
            return Err(Error::InvalidLogarithm);
        }
        Ok(value.ln())
    }
    
    pub fn log(&self, value: f64, base: f64) -> Result<f64, Error> {
        if value <= 0.0 || base <= 0.0 || base == 1.0 {
            return Err(Error::InvalidLogarithm);
        }
        Ok(value.log(base))
    }
    
    pub fn factorial(&self, n: u64) -> Result<f64, Error> {
        if n > 20 {
            return Err(Error::FactorialTooLarge);
        }
        Ok((1..=n).product::<u64>() as f64)
    }
    
    // 表达式求值
    pub fn evaluate_expression(&self, expression: &str) -> Result<f64, Error> {
        let tokens = self.parser.tokenize(expression)?;
        let ast = self.parser.parse(tokens)?;
        self.evaluator.evaluate(&ast)
    }
    
    // 统计计算
    pub fn calculate_statistics(&self, data: &[f64]) -> Result<Statistics, Error> {
        if data.is_empty() {
            return Err(Error::EmptyDataSet);
        }
        
        let n = data.len() as f64;
        let sum: f64 = data.iter().sum();
        let mean = sum / n;
        
        // 计算方差
        let variance: f64 = data.iter()
            .map(|&x| (x - mean).powi(2))
            .sum::<f64>() / n;
        let std_dev = variance.sqrt();
        
        // 计算中位数
        let mut sorted_data = data.to_vec();
        sorted_data.sort_by(|a, b| a.partial_cmp(b).unwrap());
        let median = if n % 2.0 == 0.0 {
            (sorted_data[(n as usize / 2) - 1] + sorted_data[n as usize / 2]) / 2.0
        } else {
            sorted_data[n as usize / 2]
        };
        
        let min = data.iter().cloned().fold(f64::INFINITY, f64::min);
        let max = data.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
        
        // 计算众数
        let mut frequency = std::collections::HashMap::new();
        for &value in data {
            *frequency.entry(value).or_insert(0) += 1;
        }
        let max_count = frequency.values().max().unwrap_or(&0).clone();
        let mode: Vec<f64> = frequency
            .into_iter()
            .filter(|&(_, count)| count == max_count)
            .map(|(value, _)| value)
            .collect();
        
        Ok(Statistics {
            count: data.len(),
            mean,
            median,
            mode,
            variance,
            std_dev,
            min,
            max,
            sum,
        })
    }
}
}

2.7.4 表达式解析器

#![allow(unused)]
fn main() {
// src/calculator/parser.rs
use crate::utils::Error;

#[derive(Debug, Clone, PartialEq)]
pub enum Token {
    Number(f64),
    Identifier(String),
    Operator(Operator),
    LParen,
    RParen,
    Comma,
}

#[derive(Debug, Clone, PartialEq)]
pub enum Operator {
    Add,
    Subtract,
    Multiply,
    Divide,
    Power,
    Sqrt,
    Sin,
    Cos,
    Tan,
    Ln,
    Log,
    Factorial,
}

#[derive(Debug, Clone)]
pub enum AstNode {
    Number(f64),
    Identifier(String),
    UnaryOp(Operator, Box<AstNode>),
    BinaryOp(Operator, Box<AstNode>, Box<AstNode>),
    FunctionCall(String, Vec<AstNode>),
}

pub struct ExpressionParser {
    // 操作符优先级
    precedence: std::collections::HashMap<Operator, i32>,
}

impl ExpressionParser {
    pub fn new() -> Self {
        let mut precedence = std::collections::HashMap::new();
        precedence.insert(Operator::Add, 1);
        precedence.insert(Operator::Subtract, 1);
        precedence.insert(Operator::Multiply, 2);
        precedence.insert(Operator::Divide, 2);
        precedence.insert(Operator::Power, 3);
        precedence.insert(Operator::Sqrt, 4);
        precedence.insert(Operator::Factorial, 5);
        precedence.insert(Operator::Sin, 6);
        precedence.insert(Operator::Cos, 6);
        precedence.insert(Operator::Tan, 6);
        precedence.insert(Operator::Ln, 6);
        precedence.insert(Operator::Log, 6);
        
        Self { precedence }
    }
    
    pub fn tokenize(&self, input: &str) -> Result<Vec<Token>, Error> {
        let mut tokens = Vec::new();
        let mut chars = input.chars().peekable();
        
        while let Some(ch) = chars.next() {
            match ch {
                '0'..='9' | '.' => {
                    let mut number_str = ch.to_string();
                    
                    // 继续读取数字和小数点
                    while let Some(&next_ch) = chars.peek() {
                        if next_ch.is_numeric() || next_ch == &'.' {
                            number_str.push(chars.next().unwrap());
                        } else {
                            break;
                        }
                    }
                    
                    let number: f64 = number_str.parse()
                        .map_err(|_| Error::InvalidNumber(number_str))?;
                    tokens.push(Token::Number(number));
                }
                'a'..='z' | 'A'..='Z' | '_' => {
                    let mut ident = ch.to_string();
                    
                    // 继续读取标识符字符
                    while let Some(&next_ch) = chars.peek() {
                        if next_ch.is_alphanumeric() || next_ch == &'_' {
                            ident.push(chars.next().unwrap());
                        } else {
                            break;
                        }
                    }
                    
                    tokens.push(Token::Identifier(ident));
                }
                '+' => tokens.push(Token::Operator(Operator::Add)),
                '-' => tokens.push(Token::Operator(Operator::Subtract)),
                '*' => tokens.push(Token::Operator(Operator::Multiply)),
                '/' => tokens.push(Token::Operator(Operator::Divide)),
                '^' => tokens.push(Token::Operator(Operator::Power)),
                '(' => tokens.push(Token::LParen),
                ')' => tokens.push(Token::RParen),
                ',' => tokens.push(Token::Comma),
                ' ' | '\t' | '\n' | '\r' => continue, // 跳过空白字符
                _ => return Err(Error::InvalidCharacter(ch)),
            }
        }
        
        Ok(tokens)
    }
    
    pub fn parse(&self, tokens: Vec<Token>) -> Result<AstNode, Error> {
        let mut output = Vec::new();
        let mut operators = Vec::new();
        
        for token in tokens {
            match token {
                Token::Number(n) => output.push(AstNode::Number(n)),
                Token::Identifier(ident) => output.push(AstNode::Identifier(ident)),
                Token::Operator(op) => {
                    while let Some(Token::Operator(prev_op)) = operators.last() {
                        if self.get_precedence(prev_op) >= self.get_precedence(&op) {
                            self.pop_operator_to_output(&mut operators, &mut output)?;
                        } else {
                            break;
                        }
                    }
                    operators.push(Token::Operator(op));
                }
                Token::LParen => operators.push(token),
                Token::RParen => {
                    while let Some(op) = operators.pop() {
                        match op {
                            Token::LParen => break,
                            Token::Operator(op) => self.pop_operator_to_output(&operators, &mut output)?,
                            _ => return Err(Error::MismatchedParen),
                        }
                    }
                }
                Token::Comma => {
                    while let Some(token) = operators.pop() {
                        match token {
                            Token::LParen => return Err(Error::MismatchedParen),
                            Token::Operator(op) => self.pop_operator_to_output(&operators, &mut output)?,
                            _ => {}
                        }
                    }
                }
            }
        }
        
        while let Some(token) = operators.pop() {
            match token {
                Token::Operator(op) => self.pop_operator_to_output(&operators, &mut output)?,
                Token::LParen | Token::RParen | Token::Comma => 
                    return Err(Error::MismatchedParen),
            }
        }
        
        if output.len() != 1 {
            return Err(Error::InvalidExpression);
        }
        
        Ok(output.remove(0))
    }
    
    fn get_precedence(&self, op: &Operator) -> i32 {
        *self.precedence.get(op).unwrap_or(&0)
    }
    
    fn pop_operator_to_output(
        &self, 
        operators: &mut Vec<Token>, 
        output: &mut Vec<AstNode>
    ) -> Result<(), Error> {
        if let Some(Token::Operator(op)) = operators.pop() {
            match op {
                Operator::Sqrt | Operator::Sin | Operator::Cos | Operator::Tan 
                | Operator::Ln | Operator::Factorial => {
                    if let Some(operand) = output.pop() {
                        output.push(AstNode::UnaryOp(op, Box::new(operand)));
                    } else {
                        return Err(Error::InsufficientOperands);
                    }
                }
                _ => {
                    if let (Some(right), Some(left)) = (output.pop(), output.pop()) {
                        output.push(AstNode::BinaryOp(op, Box::new(left), Box::new(right)));
                    } else {
                        return Err(Error::InsufficientOperands);
                    }
                }
            }
        }
        Ok(())
    }
}
}

2.7.5 表达式求值器

#![allow(unused)]
fn main() {
// src/calculator/evaluator.rs
use super::parser::{AstNode, Operator};
use crate::utils::Error;

pub struct ExpressionEvaluator {
    functions: std::collections::HashMap<String, fn(&[f64]) -> Result<f64, Error>>,
}

impl ExpressionEvaluator {
    pub fn new() -> Self {
        let mut functions = std::collections::HashMap::new();
        
        // 注册内置函数
        functions.insert("sqrt".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("sqrt".to_string(), 1, args.len()));
            }
            if args[0] < 0.0 {
                return Err(Error::NegativeSquareRoot);
            }
            Ok(args[0].sqrt())
        });
        
        functions.insert("sin".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("sin".to_string(), 1, args.len()));
            }
            Ok(args[0].sin())
        });
        
        functions.insert("cos".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("cos".to_string(), 1, args.len()));
            }
            Ok(args[0].cos())
        });
        
        functions.insert("tan".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("tan".to_string(), 1, args.len()));
            }
            Ok(args[0].tan())
        });
        
        functions.insert("ln".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("ln".to_string(), 1, args.len()));
            }
            if args[0] <= 0.0 {
                return Err(Error::InvalidLogarithm);
            }
            Ok(args[0].ln())
        });
        
        functions.insert("log".to_string(), |args| {
            if args.len() != 2 {
                return Err(Error::InvalidArgumentCount("log".to_string(), 2, args.len()));
            }
            if args[0] <= 0.0 || args[1] <= 0.0 || args[1] == 1.0 {
                return Err(Error::InvalidLogarithm);
            }
            Ok(args[0].log(args[1]))
        });
        
        functions.insert("factorial".to_string(), |args| {
            if args.len() != 1 {
                return Err(Error::InvalidArgumentCount("factorial".to_string(), 1, args.len()));
            }
            let n = args[0] as u64;
            if args[0] < 0.0 || args[0] - n as f64 != 0.0 {
                return Err(Error::InvalidFactorialArgument);
            }
            if n > 20 {
                return Err(Error::FactorialTooLarge);
            }
            Ok((1..=n).product::<u64>() as f64)
        });
        
        Self { functions }
    }
    
    pub fn evaluate(&self, ast: &AstNode) -> Result<f64, Error> {
        match ast {
            AstNode::Number(n) => Ok(*n),
            AstNode::Identifier(ident) => {
                // 处理常量和变量
                match ident.as_str() {
                    "pi" => Ok(std::f64::consts::PI),
                    "e" => Ok(std::f64::consts::E),
                    _ => Err(Error::UndefinedVariable(ident.clone())),
                }
            }
            AstNode::UnaryOp(op, operand) => {
                let value = self.evaluate(operand)?;
                self.evaluate_unary_op(*op, value)
            }
            AstNode::BinaryOp(op, left, right) => {
                let left_val = self.evaluate(left)?;
                let right_val = self.evaluate(right)?;
                self.evaluate_binary_op(*op, left_val, right_val)
            }
            AstNode::FunctionCall(name, args) => {
                let arg_values: Result<Vec<f64>, _> = 
                    args.iter().map(|arg| self.evaluate(arg)).collect();
                let arg_values = arg_values?;
                
                if let Some(func) = self.functions.get(name) {
                    func(&arg_values)
                } else {
                    Err(Error::UndefinedFunction(name.clone()))
                }
            }
        }
    }
    
    fn evaluate_unary_op(&self, op: Operator, value: f64) -> Result<f64, Error> {
        match op {
            Operator::Sqrt => {
                if value < 0.0 {
                    Err(Error::NegativeSquareRoot)
                } else {
                    Ok(value.sqrt())
                }
            }
            Operator::Sin => Ok(value.sin()),
            Operator::Cos => Ok(value.cos()),
            Operator::Tan => Ok(value.tan()),
            Operator::Ln => {
                if value <= 0.0 {
                    Err(Error::InvalidLogarithm)
                } else {
                    Ok(value.ln())
                }
            }
            Operator::Factorial => {
                if value < 0.0 || value.fract() != 0.0 {
                    return Err(Error::InvalidFactorialArgument);
                }
                let n = value as u64;
                if n > 20 {
                    return Err(Error::FactorialTooLarge);
                }
                Ok((1..=n).product::<u64>() as f64)
            }
            _ => Err(Error::InvalidOperator),
        }
    }
    
    fn evaluate_binary_op(&self, op: Operator, left: f64, right: f64) -> Result<f64, Error> {
        match op {
            Operator::Add => Ok(left + right),
            Operator::Subtract => Ok(left - right),
            Operator::Multiply => Ok(left * right),
            Operator::Divide => {
                if right == 0.0 {
                    Err(Error::DivisionByZero)
                } else {
                    Ok(left / right)
                }
            }
            Operator::Power => Ok(left.powf(right)),
            _ => Err(Error::InvalidOperator),
        }
    }
}
}

2.7.6 数据统计模块

#![allow(unused)]
fn main() {
// src/data/mod.rs
pub mod types;
pub mod statistics;

use types::Statistics;

// 重新导出
pub use statistics::Statistics;
}

#![allow(unused)]
fn main() {
// src/data/statistics.rs
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Statistics {
    pub count: usize,
    pub mean: f64,
    pub median: f64,
    pub mode: Vec<f64>,
    pub variance: f64,
    pub std_dev: f64,
    pub min: f64,
    pub max: f64,
    pub sum: f64,
}

impl Statistics {
    pub fn print_detailed(&self) {
        println!("=== 统计信息 ===");
        println!("数据个数: {}", self.count);
        println!("总和: {:.2}", self.sum);
        println!("平均值: {:.2}", self.mean);
        println!("中位数: {:.2}", self.median);
        println!("众数: {:?}", self.mode.iter()
            .map(|&x| format!("{:.2}", x))
            .collect::<Vec<_>>()
            .join(", "));
        println!("最小值: {:.2}", self.min);
        println!("最大值: {:.2}", self.max);
        println!("方差: {:.4}", self.variance);
        println!("标准差: {:.4}", self.std_dev);
        println!("===============");
    }
    
    pub fn get_range(&self) -> f64 {
        self.max - self.min
    }
    
    pub fn get_coefficient_of_variation(&self) -> f64 {
        if self.mean == 0.0 {
            0.0
        } else {
            self.std_dev / self.mean.abs()
        }
    }
}

// 线性回归
pub struct LinearRegression {
    pub slope: f64,
    pub intercept: f64,
    pub r_squared: f64,
}

impl LinearRegression {
    pub fn new(x_data: &[f64], y_data: &[f64]) -> Option<Self> {
        if x_data.len() != y_data.len() || x_data.is_empty() {
            return None;
        }
        
        let n = x_data.len() as f64;
        let sum_x: f64 = x_data.iter().sum();
        let sum_y: f64 = y_data.iter().sum();
        let sum_xy: f64 = x_data.iter().zip(y_data.iter())
            .map(|(&x, &y)| x * y).sum();
        let sum_x2: f64 = x_data.iter().map(|&x| x * x).sum();
        let sum_y2: f64 = y_data.iter().map(|&y| y * y).sum();
        
        let slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x * sum_x);
        let intercept = (sum_y - slope * sum_x) / n;
        
        // 计算 R²
        let ss_tot: f64 = y_data.iter()
            .map(|&y| (y - sum_y / n).powi(2))
            .sum();
        let ss_res: f64 = x_data.iter().zip(y_data.iter())
            .map(|(&x, &y)| {
                let predicted = slope * x + intercept;
                (y - predicted).powi(2)
            })
            .sum();
        let r_squared = 1.0 - (ss_res / ss_tot);
        
        Some(Self {
            slope,
            intercept,
            r_squared,
        })
    }
    
    pub fn predict(&self, x: f64) -> f64 {
        self.slope * x + self.intercept
    }
    
    pub fn print_equation(&self) {
        println!("线性回归方程: y = {:.4}x + {:.4}", self.slope, self.intercept);
        println!("决定系数 (R²): {:.4}", self.r_squared);
    }
}
}

2.7.7 历史记录管理

#![allow(unused)]
fn main() {
// src/history/mod.rs
use serde::{Deserialize, Serialize};
use std::fs::{self, File};
use std::io::{self, BufRead, BufReader, Write};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HistoryRecord {
    pub expression: String,
    pub result: f64,
    pub timestamp: chrono::DateTime<chrono::Utc>,
}

pub struct HistoryManager {
    records: Vec<HistoryRecord>,
    max_records: usize,
}

impl HistoryManager {
    pub fn new() -> Self {
        Self::with_capacity(100)
    }
    
    pub fn with_capacity(capacity: usize) -> Self {
        let records = Self::load_from_file().unwrap_or_default();
        Self {
            records,
            max_records: capacity,
        }
    }
    
    pub fn add_record(&mut self, expression: &str, result: f64) {
        let record = HistoryRecord {
            expression: expression.to_string(),
            result,
            timestamp: chrono::Utc::now(),
        };
        
        self.records.push(record);
        
        // 保持记录数量限制
        if self.records.len() > self.max_records {
            self.records.remove(0);
        }
        
        // 保存到文件
        self.save_to_file().ok();
    }
    
    pub fn get_recent_records(&self, count: usize) -> &[HistoryRecord] {
        let start = if self.records.len() > count {
            self.records.len() - count
        } else {
            0
        };
        &self.records[start..]
    }
    
    pub fn search_records(&self, query: &str) -> Vec<&HistoryRecord> {
        self.records
            .iter()
            .filter(|record| 
                record.expression.contains(query) ||
                record.result.to_string().contains(query)
            )
            .collect()
    }
    
    pub fn clear(&mut self) {
        self.records.clear();
        self.save_to_file().ok();
    }
    
    pub fn display(&self) {
        if self.records.is_empty() {
            println!("暂无计算历史");
            return;
        }
        
        println!("=== 计算历史 ===");
        for (i, record) in self.records.iter().enumerate() {
            println!("{}. {} = {}", 
                i + 1, 
                record.expression, 
                record.result
            );
        }
        println!("===============");
    }
    
    fn get_history_file() -> std::path::PathBuf {
        let mut path = dirs::home_dir().unwrap_or_default();
        path.push(".rust_calculator_history.json");
        path
    }
    
    fn load_from_file() -> io::Result<Vec<HistoryRecord>> {
        let path = Self::get_history_file();
        if !path.exists() {
            return Ok(Vec::new());
        }
        
        let file = File::open(path)?;
        let reader = BufReader::new(file);
        
        let records: Vec<HistoryRecord> = serde_json::from_reader(reader)
            .unwrap_or_default();
        
        Ok(records)
    }
    
    fn save_to_file(&self) -> io::Result<()> {
        let path = Self::get_history_file();
        
        // 确保目录存在
        if let Some(parent) = path.parent() {
            fs::create_dir_all(parent)?;
        }
        
        let file = File::create(path)?;
        serde_json::to_writer_pretty(file, &self.records)?;
        
        Ok(())
    }
}
}

2.7.8 错误处理

#![allow(unused)]
fn main() {
// src/utils/mod.rs
pub mod error;

pub use error::Error;
}

#![allow(unused)]
fn main() {
// src/utils/error.rs
use serde::{Deserialize, Serialize};

#[derive(Debug, thiserror::Error, Serialize, Deserialize)]
pub enum Error {
    #[error("除零错误")]
    DivisionByZero,
    
    #[error("负数开平方根: {0}")]
    NegativeSquareRoot,
    
    #[error("无效的对数: 底数必须 > 0 且 ≠ 1, 真数必须 > 0")]
    InvalidLogarithm,
    
    #[error("阶乘参数无效: 必须是非负整数")]
    InvalidFactorialArgument,
    
    #[error("阶乘值过大: n > 20")]
    FactorialTooLarge,
    
    #[error("空数据集")]
    EmptyDataSet,
    
    #[error("无效数字: {0}")]
    InvalidNumber(String),
    
    #[error("无效字符: {0}")]
    InvalidCharacter(char),
    
    #[error("括号不匹配")]
    MismatchedParen,
    
    #[error("无效表达式")]
    InvalidExpression,
    
    #[error("操作数不足")]
    InsufficientOperands,
    
    #[error("无效操作符")]
    InvalidOperator,
    
    #[error("未定义变量: {0}")]
    UndefinedVariable(String),
    
    #[error("未定义函数: {0}")]
    UndefinedFunction(String),
    
    #[error("函数 {0} 参数数量错误: 期望 {1}, 实际 {2}")]
    InvalidArgumentCount(String, usize, usize),
    
    #[error("输入/输出错误: {0}")]
    Io(#[from] std::io::Error),
    
    #[error("JSON 序列化错误: {0}")]
    Json(#[from] serde_json::Error),
    
    #[error("时间处理错误: {0}")]
    Chrono(#[from] chrono::ParseError),
}
}

2.8 练习题

练习 2.1：基础计算器

实现一个基础的四则运算计算器：

支持 +、-、*、/ 操作
处理错误情况（除零等）
提供用户友好的界面

练习 2.2：温度转换器

创建一个温度转换工具：

摄氏度 ↔ 华氏度
摄氏度 ↔ 开尔文
支持批量转换
显示转换历史

练习 2.3：数据分析工具

开发一个简单数据处理器：

读取 CSV 文件
计算基础统计量
找出极值和异常值
生成报告

练习 2.4：单位转换器

设计一个单位转换系统：

长度单位转换（米、厘米、英尺等）
重量单位转换（公斤、磅、盎司等）
温度单位转换
自定义转换函数

练习 2.5：元组数据处理器

创建一个处理元组数据的工具：

解析包含姓名、年龄、成绩的学生信息
实现坐标几何计算（点距离、中点等）
时间处理（小时、分钟、秒的转换）
多值返回函数的练习

练习 2.6：数组数据分析器

开发一个数组数据处理程序：

数组的排序、搜索和统计分析
多维数组操作（矩阵运算）
数组元素的替换和删除
实现经典算法（冒泡排序、二分查找等）

2.9 性能优化建议

2.9.1 数值计算优化

#![allow(unused)]
fn main() {
// 避免重复计算
fn optimized_calculation(data: &[f64]) -> (f64, f64) {
    let n = data.len() as f64;
    let sum: f64 = data.iter().sum();
    let mean = sum / n;
    
    // 一次遍历计算方差
    let variance: f64 = data.iter()
        .map(|&x| (x - mean).powi(2))
        .sum::<f64>() / n;
    
    let std_dev = variance.sqrt();
    (mean, std_dev)
}

// 使用迭代器优化
fn iterator_optimization() {
    let numbers: Vec<i32> = (1..=1000).collect();
    
    // 链式操作
    let result: i32 = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)    // 过滤偶数
        .map(|&x| x * x)             // 平方
        .sum();                      // 求和
    
    println!("偶数平方和: {}", result);
}
}

2.9.2 内存管理优化

#![allow(unused)]
fn main() {
// 预分配容量
fn preallocate_example() {
    let mut numbers = Vec::with_capacity(1000);
    for i in 0..1000 {
        numbers.push(i);
    }
}

// 避免不必要的克隆
fn efficient_cloning() {
    let original = vec![1, 2, 3, 4, 5];
    
    // 使用引用而不是克隆
    let sum: i32 = original.iter().sum();
    
    // 只在需要时克隆
    if sum > 10 {
        let cloned = original.clone();  // 必要时才克隆
        // 使用 cloned
    }
}
}

2.10 本章总结

通过本章学习，你已经掌握了：

核心概念

变量声明：let、let mut、const 的使用和区别
基础数据类型：整数、浮点、布尔、字符、字符串
复合数据类型：元组（不同类型元素的固定集合）、数组（相同类型元素的固定集合）
控制流：if、loop、while、for、match
函数：定义、调用、参数、返回值

下一章预告

所有权和借用系统
内存安全保证
引用和切片
生命周期概念

通过这些基础知识的掌握和实际项目的练习，你已经具备了 Rust 编程的基本能力。接下来将深入学习 Rust 最具特色的所有权系统！

第三章：所有权与借用

学习目标

通过本章学习，您将掌握：

Rust所有权系统的核心概念
借用检查器的工作原理
生命周期如何保证内存安全
如何安全地处理文件和内存管理
实战项目：构建一个内存安全的文件处理工具

3.1 引言：Rust的内存安全革命

在现代编程中，内存安全是一个至关重要的课题。传统的系统编程语言如C和C++虽然提供了强大的性能，但开发者需要手动管理内存，这往往导致：

内存泄漏：忘记释放已分配的内存
双重释放：释放已经被释放的内存
悬空指针：访问已释放的内存
缓冲区溢出：写入超出分配范围的内存

Rust通过其独特的所有权系统，在编译时就确保了内存安全，无需垃圾回收器。这是Rust能够在性能上匹敌C++，同时提供内存安全保证的核心机制。

3.2 所有权基础

3.2.1 什么是所有权？

Rust 中的每一个值都有且仅有一个所有者（owner），当所有者离开作用域（scope）时，这个值会被自动释放（drop）。

基本规则：

Rust 所有权三大铁律（必须全部记住）

规则编号	规则名称	具体内容	违反后果
1	每个值有且仅有一个所有者	同一时间只能有一个变量“拥有”这份内存	编译错误
2	所有权可以转移（move）	把值赋值给另一个变量，或作为参数传给函数时，所有权会转移给新变量/函数	原来的变量失效
3	所有者离开作用域时释放	变量离开自己所在的 `{}` 作用域时，Rust 会自动调用值的 `drop()` 方法释放内存	无（这是正常行为）

让我们通过一个简单的示例来理解：

fn main() {
    let s1 = String::from("Hello");
    let s2 = s1; // s1的所有权转移给s2
    
    // 编译错误！s1已不再拥有这个值
    // println!("{}, world!", s1); 
    println!("{}, world!", s2); // 正常，可以访问s2
}

Result:

#![allow(unused)]

fn main() {
Hello, world!

}

在这个例子中：

s1创建了一个String类型的值，并拥有它
let s2 = s1;将所有权从s1转移到s2
s1在转移后不再拥有值，无法使用

3.2.2 转移所有权（Move）

Rust中的移动（Move）是所有权的转移。当我们将一个值赋给另一个变量时，原始变量会失效：

fn main() {
    let v1 = vec![1, 2, 3, 4];
    let v2 = v1; // v1的所有权转移给v2
    
    // 编译错误！v1已失效
    // println!("v1: {:?}", v1);
    
    println!("v2: {:?}", v2); // 正常
}

Result:

#![allow(unused)]
fn main() {
v2: [1, 2, 3, 4]
}

对于基本类型（实现了Copy trait的类型），赋值时会复制值而不是移动：

fn main() {
    let x = 42;
    let y = x; // 复制值，x仍然有效
    
    println!("x: {}", x); // 正常，x仍然有效
    println!("y: {}", y); // 正常
}

Result:

#![allow(unused)]
fn main() {
x: 42
y: 42
}

Rust 所有权转移（Move）简单总结

情况	行为	原始变量之后还能用吗？	典型类型例子	原因
赋值给新变量	所有权转移	不能	String, Vec, Box, 自定义结构体	默认 move 语义
作为函数参数传入（非引用）	所有权转移	不能	同上	函数拿走了所有权
从函数返回	所有权转移	—	—	返回值成为调用者的所有权
基本类型 / 实现了 Copy 的类型	复制（不是移动）	能	i8~i128, u8~u128, f32/f64, bool, char, 元组(全部元素都Copy), &T	实现了 Copy trait
&T （不可变引用）	复制引用	能	&String, &[i32], &str	只是复制了指针
&mut T（可变引用）	复制引用	能	&mut String, &mut Vec	只是复制了指针（可变指针）

最核心的几句话记忆口诀

没实现 Copy → 移动所有权（move）
- 赋值、传参（非引用形式）→ 原来的变量立刻失效
- 谁最后拥有，谁负责释放
实现了 Copy → 只是复制值
- 原来的变量仍然有效（像普通语言的赋值一样）
最常见的 move 类型（要记住这几个）
- String
- Vec
- Box
- 几乎所有自己写的没标 Copy 的结构体
- 任何包含以上类型的复合类型

快速判断「这次赋值会不会让旧变量失效」口诀

问自己一句话就够了：

「这个类型放栈上完整复制的成本贵不贵？」

贵 → 不实现 Copy → 会 move（String、Vec、自定义大结构体）
不贵 → 实现 Copy → 直接复制（数字、bool、char、小数组、&引用等）

一句话极简总结

Rust 默认：赋值 = 转移所有权（move）
只有实现了 Copy 的类型，才会变成普通赋值（复制）

大多数需要动态内存管理的类型（String、Vec 等）都不实现 Copy，
所以它们在赋值、传参时会发生所有权转移，这是 Rust 新手最容易踩坑的地方。

3.2.3 函数中的所有权

当我们将值传递给函数时，所有权也会转移：

fn main() {
    let s = String::from("hello");
    takes_ownership(s); // s的所有权转移给函数
    
    // 编译错误！s不再拥有值
    // println!("{}", s);
    
    let x = 5;
    makes_copy(x); // x被复制，x仍然有效
    println!("x: {}", x); // 正常
}

fn takes_ownership(some_string: String) {
    println!("{}", some_string);
} // some_string超出作用域，值被丢弃

fn makes_copy(some_integer: i32) {
    println!("{}", some_integer);
} // some_integer超出作用域，但基本类型没有影响

Result:

#![allow(unused)]
fn main() {
hello
5
x: 5
}

核心概念总结

1. 所有权转移（Move）

当 String 类型的值 s 传递给 takes_ownership 函数时，所有权从 main 函数转移到了 takes_ownership 函数
转移后，原变量 s 不再有效，无法继续使用

2. 复制（Copy）

基本数据类型如 i32 实现了 Copy trait
当 x 传递给 makes_copy 时，实际是复制了一份值
原变量 x 仍然有效，可以继续使用

3. 作用域与内存管理

函数参数超出作用域时，如果是 String 类型，会自动释放内存（避免双重释放）
如果是 Copy 类型，则简单离开作用域，无额外操作

总结：Rust 通过所有权系统自动管理内存，无需手动 free，确保内存安全的同时避免了垃圾回收的开销。

3.3 引用与借用

3.3.1 什么是借用？

借用是创建引用的过程，允许我们使用值而不取得所有权。这解决了在函数中使用值但不转移所有权的问题。

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // 借用s1
    
    println!("The length of '{}' is {}.", s1, len); // s1仍然可用
}

fn calculate_length(s: &String) -> usize { // s是String的引用
    s.len()
} // s超出作用域，但不会丢弃引用指向的值，因为s没有所有权

Result:

#![allow(unused)]
fn main() {
The length of 'hello' is 5.
}

3.3.2 可变引用

如果我们需要修改引用的值，可以使用可变引用：

fn main() {
    let mut s = String::from("hello");
    change(&mut s); // 传递可变引用
    
    println!("{}", s); // 输出 "hello, world"
}

fn change(some_string: &mut String) {
    some_string.push_str(", world");
}

Result:

#![allow(unused)]
fn main() {
hello, world
}

可变引用的重要限制：

同一时间，对同一个值只能有一个可变引用
不能同时拥有可变引用和不可变引用

fn main() {
    let mut s = String::from("hello");
    
    let r1 = &s; // 不可变引用
    let r2 = &s; // 另一个不可变引用
    // let r3 = &mut s; // 编译错误！不能同时拥有可变和不可变引用
    
    println!("{} and {}", r1, r2);
    // r1和r2在作用域结束前都可以使用
    
    println!("{}", r1);
    // 重新使用可变引用
    let r3 = &mut s; // 现在可以创建可变引用了
    println!("{}", r3);
}

Result:

#![allow(unused)]
fn main() {
hello and hello
hello
hello
}

3.3.3 借用检查器

Rust的借用检查器在编译时验证引用的有效性，确保：

悬空引用：不允许存在悬空引用
引用作用域：引用不能比其引用的值存在更久

fn main() {
    let r;
    {
        let x = 5;
        r = &x; // 编译错误！x的作用域比r短
    }
    println!("{}", r);
}

   Compiling playground v0.0.1 (/playground)
error[E0597]: `x` does not live long enough
 --> src/main.rs:5:13
  |
4 |         let x = 5;
  |             - binding `x` declared here
5 |         r = &x; // 编译错误！x的作用域比r短
  |             ^^ borrowed value does not live long enough
6 |     }
  |     - `x` dropped here while still borrowed
7 |     println!("{}", r);
  |                    - borrow later used here

For more information about this error, try `rustc --explain E0597`.
error: could not compile `playground` (bin "playground") due to 1 previous error

在这个例子中，x的作用域在}处结束，但r在println!中仍在使用，这会导致悬空引用，Rust会拒绝编译。

3.4 生命周期

3.4.1 什么是生命周期？

生命周期是引用保持有效的作用域。Rust需要确保引用的有效性，这就是为什么借用检查器需要跟踪生命周期。

本质问题 生命周期解决的核心问题：编译器需要确保引用不会指向无效数据（悬垂引用）。

核心规则 借用不能超过被借用值的生命周期

大多数情况下，Rust可以自动推断生命周期：

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

fn longest(x: &str, y: &str) -> &str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

   Compiling playground v0.0.1 (/playground)
error[E0106]: missing lifetime specifier
 --> src/main.rs:9:33
  |
9 | fn longest(x: &str, y: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `x` or `y`
help: consider introducing a named lifetime parameter
  |
9 | fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
  |           ++++     ++          ++          ++

For more information about this error, try `rustc --explain E0106`.
error: could not compile `playground` (bin "playground") due to 1 previous error

在你的代码中，longest 函数返回的是 &str 类型，这是一个引用类型。编译器无法仅通过函数签名确定这个返回的引用到底是来自参数x还是 y。

Rust 编译器需要明确知道：

返回的引用与哪个输入参数的生命周期相关联
返回的引用的有效范围不能超过其源参数的有效范围
如果两个参数都可能返回，编译器需要知道如何确定实际返回的是哪一个

longest 可以做如下修改：

#![allow(unused)]
fn main() {
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
}

这里的生命周期标注含义如下：

'a 是一个生命周期参数，表示一个泛型的生命周期范围
x: &'a str 表示 x 是一个字符串引用，其生命周期至少为 'a
y: &'a str 表示 y 是一个字符串引用，其生命周期至少为 'a
-> &'a str 表示返回的字符串引用的生命周期也是 'a

这个标注告诉编译器："返回的引用的生命周期与输入参数中较短的那个相同"。编译器会确保调用这个函数时，返回的引用不会超过两个输入参数中任何一个的有效范围。

修复后的完整代码：

fn main() {
    let string1 = String::from("abcd");
    let string2 = "xyz";
    
    // longest 函数现在有了正确的生命周期标注
    let result = longest(string1.as_str(), string2);
    println!("The longest string is {}", result);
}

// 添加了生命周期参数 'a
fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Result:

The longest string is abcd

3.4.3 生命周期在struct中的应用

当结构体包含引用时，需要显式注解生命周期：

struct ImportantExcerpt<'a> {
    part: &'a str,
}

impl<'a> ImportantExcerpt<'a> {
    fn level(&self) -> i32 {
        3
    }
}

fn main() {
    let novel = String::from("Call me Ishmael. Some years ago...");
    let first_sentence = novel.split('.').next().expect("Could not find a '.'");
    
    let i = ImportantExcerpt {
        part: first_sentence,
    };
    
    println!("Excerpt: {}", i.part);
}

Result:

Excerpt: Call me Ishmael

变量绑定与生命周期推导 在 main 函数中，我们首先创建了一个 String 类型的变量 novel，它拥有字符串 "Call me Ishmael. Some years ago..." 的所有权。这个字符串存储在堆上，其生命周期与 novel 变量绑定在一起。

接着，我们使用 split('.') 方法将字符串按句号分割，并使用 next() 方法获取第一个分割后的片段。这个操作返回的是一个字符串切片 &str，即对 novel 字符串数据的引用。Rust 编译器能够正确推断出 first_sentence 这个引用的生命周期与 novel 相同，因为它直接引用了 novel 的数据。

结构体实例的创建 当我们创建 ImportantExcerpt 结构体的实例时，part 字段被赋值为 first_sentence，这是一个对 novel 字符串的引用。此时，Rust 编译器会进行生命周期检查：由于 first_sentence 引用了 novel 的数据，所以 ImportantExcerpt 实例 i 的生命周期不能超过 novel 的生命周期。这是一种自动的生命周期推导机制，开发者不需要手动指定，因为编译器能够根据赋值关系推断出正确的结果。

在这个例子中，novel、first_sentence 和 i 三个变量形成了正确的生命周期关系：i 中的引用 part 指向 first_sentence 的数据，而 first_sentence 又引用 novel 的数据，因此 i 的生命周期被自动限制在 novel 的有效范围内。

3.5 智能指针

3.5.1 Box - 堆分配指针

Box 是 Rust 中最基础的智能指针，用于将数据分配到堆上而不是栈上。当数据较大或需要在运行时确定大小时，Box 是理想的选择。

Box 实现了 Deref 和 Drop trait，使得使用方式与普通引用类似，通过解引用运算符 * 或自动解引用可以访问内部数据。当 Box 离开作用域时，它会自动调用 Drop trait 释放堆上的内存，无需手动管理。Box 适用于递归类型（如链表、树等数据结构），因为编译器在编译时需要知道类型的大小，而 Box 可以通过间接引用解决这一问题。需要注意的是，Box 是独占所有权的，一个数据同时只能有一个 Box 持有，无法共享。

Box<T>允许在堆上分配值，当box超出作用域时被自动清理：

fn main() {
    let b = Box::new(5);
    println!("b = {}", b);
} // b被自动清理

Result:

b = 5

3.5.2 Rc - 引用计数指针（单线程）

Rc<T>（Reference Counting）是引用计数的智能指针，允许多个所有者，用于实现数据的共享所有权。当多个所有者需要共享同一份数据，且数据只在一个线程内使用时，Rc 是最佳选择。

Rc 它通过引用计数来跟踪数据的所有者数量，每次克隆 Rc 时计数增加，当 Rc 被丢弃时计数减少。当计数归零时，数据自动被释放。Rc 只适用于单线程场景，因为它使用了非原子性的引用计数，在多线程中可能导致数据竞争。Rc 提供了 clone() 方法来创建新的引用，但这里的克隆是浅拷贝，只复制指针而不复制数据。需要注意的是，Rc 指向的数据是不可变的，如果需要可变共享数据，需要结合 RefCell 使用（内部可变性模式）。

use std::rc::Rc;

fn main() {
    let s = Rc::new(String::from("hello"));
    let s1 = Rc::clone(&s);
    let s2 = Rc::clone(&s);
    
    println!("s: {}, ref count: {}", s, Rc::strong_count(&s));
    println!("s1: {}, ref count: {}", s1, Rc::strong_count(&s));
    println!("s2: {}, ref count: {}", s2, Rc::strong_count(&s));
} // s1和s2被清理后，s也被清理

Result:

s: hello, ref count: 3
s1: hello, ref count: 3
s2: hello, ref count: 3

3.5.3 Arc - 原子引用计数指针（多线程）

Arc<T>（Atomic Reference Counting）是线程安全版本的Rc，用于在多个线程之间共享数据的所有权。它通过原子操作实现引用计数，保证计数更新的线程安全性。

Arc 它使用原子性指令来更新引用计数，这保证了多线程环境下的正确性，但相比Rc 有一定的性能开销。Arc 只支持共享只读数据，如果需要可变访问，同样需要结合 Mutex、RwCell 或原子类型使用。Arc 适用于读多写少的场景，例如配置数据的共享、只读缓存等。由于原子操作的性能开销，在单线程场景下应优先使用 Rc。Arc 的内存布局与 Rc 类似，都是通过胖指针实现的（包含指向数据的指针和引用计数）。

use std::sync::Arc;

fn main() {
    let s = Arc::new(String::from("hello"));
    let s1 = Arc::clone(&s);
    let s2 = Arc::clone(&s);
    
    println!("Reference count: {}", Arc::strong_count(&s));
    println!("s1: {}", s1);
    println!("s2: {}", s2);
}

Result:

Reference count: 3
s1: hello
s2: hello

3.6 实战项目：内存安全的文件处理工具

现在我们来实现一个完整的文件处理工具，演示所有权、借用和生命周期的实际应用。

3.6.1 项目设计

项目名称：rust-file-processor

核心功能：

安全文件读取（避免内存泄漏）
流式大文件处理
批量文件重命名
文件完整性验证
并发文件处理

3.6.2 项目结构

rust-file-processor/
├── src/
│   ├── main.rs
│   ├── processors/
│   │   ├── mod.rs
│   │   ├── csv.rs
│   │   ├── json.rs
│   │   ├── text.rs
│   │   └── image.rs
│   ├── utilities/
│   │   ├── mod.rs
│   │   ├── file_ops.rs
│   │   ├── encoding.rs
│   │   └── validation.rs
│   ├── concurrent/
│   │   ├── mod.rs
│   │   ├── worker.rs
│   │   └── pool.rs
│   └── config/
│       ├── mod.rs
│       └── settings.rs
├── tests/
├── examples/
└── fixtures/
    ├── sample.csv
    ├── sample.json
    └── large_file.txt

3.6.3 核心实现

3.6.3.1 安全的文件读取器

src/utilities/file_ops.rs

#![allow(unused)]
fn main() {
use std::fs::File;
use std::io::{BufReader, Read, Lines, BufRead};
use std::path::{Path, PathBuf};
use std::error::Error;
use std::sync::Arc;
use rayon::prelude::*;

#[derive(Debug)]
pub struct FileReader {
    path: Arc<PathBuf>,
    buffer_size: usize,
    encoding: Encoding,
}

#[derive(Debug, Clone, Copy)]
pub enum Encoding {
    UTF8,
    GBK,
    ASCII,
}

impl FileReader {
    pub fn new<P: Into<PathBuf>>(path: P) -> Self {
        Self {
            path: Arc::new(path.into()),
            buffer_size: 8192,
            encoding: Encoding::UTF8,
        }
    }
    
    pub fn with_buffer_size(mut self, size: usize) -> Self {
        self.buffer_size = size;
        self
    }
    
    pub fn with_encoding(mut self, encoding: Encoding) -> Self {
        self.encoding = encoding;
        self
    }
    
    /// 使用借用避免所有权转移
    pub fn process_lines<F, T>(&self, processor: F) -> Result<T, Box<dyn Error>>
    where
        F: Fn(&str) -> Result<T, Box<dyn Error>> + Send + Sync,
        T: Send,
    {
        let file = File::open(&*self.path)?;
        let reader = BufReader::new(file);
        
        // 使用流式处理，避免加载整个文件到内存
        let lines = reader.lines().filter_map(|line| match line {
            Ok(line) => Some(line),
            Err(e) => {
                eprintln!("Warning: Skipping invalid line: {}", e);
                None
            }
        });
        
        // 并发处理行，只借用引用
        let results: Vec<Result<T, Box<dyn Error>>> = lines
            .par_iter()
            .map(|line| processor(line))
            .collect();
        
        // 收集结果，如果任一处理失败则返回错误
        let mut processed_results = Vec::new();
        for result in results {
            match result {
                Ok(result) => processed_results.push(result),
                Err(e) => return Err(e),
            }
        }
        
        Ok(self.combine_results(processed_results))
    }
    
    /// 批量处理文件
    pub fn process_batch<P, F, T>(&self, files: &[P], processor: F) -> Result<Vec<T>, Box<dyn Error>>
    where
        P: AsRef<Path> + Send + Sync,
        F: Fn(&Path) -> Result<T, Box<dyn Error>> + Send + Sync,
        T: Send,
    {
        files.par_iter().map(|path| {
            processor(path.as_ref())
        }).collect()
    }
    
    /// 流式处理大文件
    pub fn stream_process<P, F, T>(&self, output: &P, processor: F) -> Result<T, Box<dyn Error>>
    where
        P: AsRef<Path>,
        F: Fn(&str) -> Result<String, Box<dyn Error>>,
    {
        let input_file = File::open(&*self.path)?;
        let output_file = File::create(output.as_ref())?;
        
        let mut reader = BufReader::new(input_file);
        let mut writer = BufWriter::new(output_file);
        
        let mut buffer = String::new();
        let mut results = Vec::new();
        
        while reader.read_line(&mut buffer)? > 0 {
            let processed_line = processor(&buffer)?;
            writeln!(writer, "{}", processed_line)?;
            results.push(processed_line);
            buffer.clear();
        }
        
        Ok(self.combine_results(results))
    }
    
    /// 文件完整性验证
    pub fn verify_integrity(&self) -> Result<bool, Box<dyn Error>> {
        let metadata = self.path.metadata()?;
        let file_size = metadata.len();
        
        // 简单的完整性检查：验证文件可以完整读取
        let file = File::open(&*self.path)?;
        let mut reader = BufReader::new(file);
        let mut buffer = Vec::new();
        
        reader.read_to_end(&mut buffer)?;
        
        Ok(buffer.len() == file_size as usize)
    }
    
    /// 重命名文件
    pub fn rename<P: AsRef<Path>>(&self, new_path: P) -> Result<(), Box<dyn Error>> {
        std::fs::rename(&*self.path, new_path.as_ref())?;
        Ok(())
    }
    
    /// 获取文件元数据
    pub fn metadata(&self) -> Result<std::fs::Metadata, Box<dyn Error>> {
        self.path.metadata().map_err(|e| e.into())
    }
    
    /// 合并处理结果（根据类型）
    fn combine_results(&self, results: Vec<T>) -> T {
        // 这里应该根据具体类型实现合并逻辑
        // 简化示例
        if !results.is_empty() {
            results.into_iter().next().unwrap()
        } else {
            // 根据具体类型返回默认值
            todo!("Return appropriate default value based on type")
        }
    }
}

impl Clone for FileReader {
    fn clone(&self) -> Self {
        Self {
            path: Arc::clone(&self.path),
            buffer_size: self.buffer_size,
            encoding: self.encoding,
        }
    }
}
}

3.6.3.2 文件编码处理

src/utilities/encoding.rs

#![allow(unused)]
fn main() {
use std::io::{Read, Write, Result as IoResult};
use std::str;
use encoding_rs::{GBK, UTF_8};
use encoding_rs_io::DecodeReaderBytesBuilder;

pub enum TextEncoding {
    UTF8,
    GBK,
    ASCII,
}

impl TextEncoding {
    pub fn from_name(name: &str) -> Option<Self> {
        match name.to_lowercase().as_str() {
            "utf-8" | "utf8" => Some(TextEncoding::UTF8),
            "gbk" | "gb2312" => Some(TextEncoding::GBK),
            "ascii" => Some(TextEncoding::ASCII),
            _ => None,
        }
    }
    
    pub fn decode(&self, bytes: &[u8]) -> Result<String, Box<dyn std::error::Error>> {
        match self {
            TextEncoding::UTF8 => {
                Ok(String::from_utf8(bytes.to_vec())?)
            }
            TextEncoding::GBK => {
                let (decoded, _, _) = GBK.decode(bytes);
                Ok(decoded.into())
            }
            TextEncoding::ASCII => {
                Ok(String::from_utf8(bytes.to_vec())?)
            }
        }
    }
    
    pub fn encode(&self, text: &str) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        match self {
            TextEncoding::UTF8 => {
                Ok(text.as_bytes().to_vec())
            }
            TextEncoding::GBK => {
                let (encoded, _, _) = GBK.encode(text);
                Ok(encoded.to_vec())
            }
            TextEncoding::ASCII => {
                Ok(text.as_bytes().to_vec())
            }
        }
    }
}

/// 通用编码读取器
pub struct EncodingReader<R> {
    reader: R,
    encoding: TextEncoding,
}

impl<R: Read> EncodingReader<R> {
    pub fn new(reader: R, encoding: TextEncoding) -> Self {
        Self { reader, encoding }
    }
    
    pub fn read_to_string(&mut self) -> Result<String, Box<dyn std::error::Error>> {
        let mut buffer = Vec::new();
        self.reader.read_to_end(&mut buffer)?;
        self.encoding.decode(&buffer)
    }
    
    pub fn read_lines(&mut self) -> Result<Vec<String>, Box<dyn std::error::Error>> {
        let content = self.read_to_string()?;
        Ok(content.lines().map(|line| line.to_string()).collect())
    }
}
}

3.6.3.3 并发处理

src/concurrent/worker.rs

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use std::path::{Path, PathBuf};
use std::error::Error;
use rayon::prelude::*;
use futures::executor::ThreadPool;

type Job = Box<dyn FnOnce() + Send + 'static>;

pub struct WorkerPool {
    workers: Vec<Worker>,
    sender: crossbeam::channel::Sender<Job>,
}

struct Worker {
    id: usize,
    thread: Option<thread::JoinHandle<()>>,
}

impl WorkerPool {
    pub fn new(size: usize) -> WorkerPool {
        assert!(size > 0);
        
        let (sender, receiver) = crossbeam::channel::unbounded();
        let receiver = Arc::new(Mutex::new(receiver));
        
        let mut workers = Vec::with_capacity(size);
        
        for id in 0..size {
            workers.push(Worker::new(id, Arc::clone(&receiver)));
        }
        
        WorkerPool { workers, sender }
    }
    
    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);
        self.sender.send(job).unwrap();
    }
}

impl Worker {
    fn new(id: usize, receiver: Arc<crossbeam::channel::Receiver<Job>>) -> Worker {
        let thread = thread::spawn(move || loop {
            let job = receiver.lock().unwrap().recv();
            match job {
                Ok(job) => {
                    job();
                }
                Err(_) => {
                    // Shutdown signal received
                    break;
                }
            }
        });
        
        Worker {
            id,
            thread: Some(thread),
        }
    }
}

impl Drop for WorkerPool {
    fn drop(&mut self) {
        // 关闭所有通道，发送shutdown信号
        drop(self.sender);
        
        for worker in &mut self.workers {
            if let Some(thread) = worker.thread.take() {
                thread.join().unwrap();
            }
        }
    }
}

/// 文件处理作业
pub struct FileProcessingJob {
    files: Vec<PathBuf>,
    processor: Arc<dyn Fn(&Path) -> Result<(), Box<dyn Error>> + Send + Sync>,
    progress: Arc<Mutex<Progress>>,
}

#[derive(Debug, Default)]
pub struct Progress {
    pub total: usize,
    pub completed: usize,
    pub failed: usize,
}

impl FileProcessingJob {
    pub fn new(
        files: Vec<PathBuf>,
        processor: Arc<dyn Fn(&Path) -> Result<(), Box<dyn Error>> + Send + Sync>,
    ) -> Self {
        let total = files.len();
        Self {
            files,
            processor,
            progress: Arc::new(Mutex::new(Progress { total, ..Default::default() })),
        }
    }
    
    pub fn execute(&self, pool: &WorkerPool) -> Result<Progress, Box<dyn Error>> {
        // 使用rayon进行并行处理
        let results: Vec<Result<(), Box<dyn Error>>> = self.files
            .par_iter()
            .map(|file| {
                let result = (self.processor)(file);
                
                {
                    let mut progress = self.progress.lock().unwrap();
                    if result.is_ok() {
                        progress.completed += 1;
                    } else {
                        progress.failed += 1;
                    }
                }
                
                result
            })
            .collect();
        
        // 检查是否有失败的任务
        for result in results {
            result?;
        }
        
        Ok(self.progress.lock().unwrap().clone())
    }
    
    pub fn get_progress(&self) -> Progress {
        self.progress.lock().unwrap().clone()
    }
}
}

3.6.3.4 文件处理器

src/processors/text.rs

#![allow(unused)]
fn main() {
use crate::utilities::file_ops::FileReader;
use crate::utilities::encoding::TextEncoding;
use std::path::Path;
use std::error::Error;
use std::collections::HashMap;

pub struct TextProcessor {
    encoding: TextEncoding,
    ignore_patterns: Vec<String>,
}

impl TextProcessor {
    pub fn new(encoding: TextEncoding) -> Self {
        Self {
            encoding,
            ignore_patterns: Vec::new(),
        }
    }
    
    pub fn add_ignore_pattern(&mut self, pattern: String) {
        self.ignore_patterns.push(pattern);
    }
    
    /// 文本搜索替换
    pub fn find_and_replace<P, Q>(
        &self,
        input: P,
        output: Q,
        replacements: &HashMap<&str, &str>,
    ) -> Result<usize, Box<dyn Error>>
    where
        P: AsRef<Path>,
        Q: AsRef<Path>,
    {
        let reader = FileReader::new(input).with_encoding(self.encoding);
        
        reader.stream_process(output, |line| {
            let mut result = line.to_string();
            for (from, to) in replacements {
                result = result.replace(from, to);
            }
            Ok(result)
        })?;
        
        Ok(replacements.len())
    }
    
    /// 提取文本统计信息
    pub fn analyze_text(&self, file: &Path) -> Result<TextStats, Box<dyn Error>> {
        let reader = FileReader::new(file);
        
        let stats = reader.process_lines(|line| {
            Ok((
                line.len(),
                line.chars().count(),
                line.split_whitespace().count(),
            ))
        })?;
        
        Ok(stats)
    }
    
    /// 去重文本行
    pub fn deduplicate<P, Q>(&self, input: P, output: Q) -> Result<usize, Box<dyn Error>>
    where
        P: AsRef<Path>,
        Q: AsRef<Path>,
    {
        let mut lines = std::fs::read_to_string(input)?;
        
        // 去重并保持顺序
        lines.lines().collect::<std::collections::HashSet<_>>();
        
        let reader = FileReader::new(input).with_encoding(self.encoding);
        let mut unique_lines = Vec::new();
        
        reader.process_lines(|line| {
            if !unique_lines.contains(&line) {
                unique_lines.push(line);
            }
            Ok(())
        })?;
        
        let output_content = unique_lines.join("\n");
        std::fs::write(output, output_content)?;
        
        Ok(unique_lines.len())
    }
}

#[derive(Debug, Default)]
pub struct TextStats {
    pub total_lines: usize,
    pub total_chars: usize,
    pub total_words: usize,
    pub avg_line_length: f64,
    pub longest_line: usize,
    pub shortest_line: usize,
}

impl std::fmt::Display for TextStats {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Text Statistics:
    Total lines: {}
    Total characters: {}
    Total words: {}
    Average line length: {:.2}
    Longest line: {} characters
    Shortest line: {} characters", 
            self.total_lines, self.total_chars, self.total_words, 
            self.avg_line_length, self.longest_line, self.shortest_line)
    }
}
}

3.6.3.5 主程序

src/main.rs

use rust_file_processor::processors::text::TextProcessor;
use rust_file_processor::utilities::encoding::TextEncoding;
use rust_file_processor::concurrent::worker::FileProcessingJob;
use std::path::PathBuf;
use std::collections::HashMap;
use std::sync::Arc;
use std::error::Error;
use clap::{Arg, Command};
use indicatif::{ProgressBar, ProgressStyle};
use rayon;

fn main() -> Result<(), Box<dyn Error>> {
    // 配置rayon线程池
    rayon::ThreadPoolBuilder::new()
        .thread_name(|i| format!("worker-{}", i))
        .build_global()?;
    
    let matches = Command::new("rust-file-processor")
        .version("1.0")
        .about("Memory-safe file processing tool")
        .subcommand_required(true)
        .arg_required_else_help(true)
        
        .subcommand(
            Command::new("process")
                .about("Process files with text transformations")
                .arg(Arg::new("input")
                    .required(true)
                    .help("Input file or directory"))
                .arg(Arg::new("output")
                    .required(true)
                    .help("Output file or directory"))
                .arg(Arg::new("encoding")
                    .long("encoding")
                    .value_name("ENCODING")
                    .help("Text encoding (utf-8, gbk, ascii)")
                    .default_value("utf-8"))
                .arg(Arg::new("replace")
                    .long("replace")
                    .value_name("FROM=TO")
                    .help("Text replacement in format FROM=TO")
                    .multiple_values(true))
        )
        
        .subcommand(
            Command::new("analyze")
                .about("Analyze text files")
                .arg(Arg::new("input")
                    .required(true)
                    .help("Input file or directory"))
                .arg(Arg::new("encoding")
                    .long("encoding")
                    .value_name("ENCODING")
                    .help("Text encoding")
                    .default_value("utf-8"))
        )
        
        .subcommand(
            Command::new("verify")
                .about("Verify file integrity")
                .arg(Arg::new("input")
                    .required(true)
                    .help("Input file or directory"))
        )
        
        .get_matches();
    
    match matches.subcommand() {
        Some(("process", args)) => {
            let input = PathBuf::from(args.value_of("input").unwrap());
            let output = PathBuf::from(args.value_of("output").unwrap());
            let encoding = TextEncoding::from_name(args.value_of("encoding").unwrap())
                .ok_or("Invalid encoding")?;
            
            let mut processor = TextProcessor::new(encoding);
            
            if let Some(replacements) = args.values_of("replace") {
                let mut replace_map = HashMap::new();
                for replacement in replacements {
                    if let Some((from, to)) = replacement.split_once('=') {
                        replace_map.insert(from, to);
                    }
                }
                
                if input.is_file() {
                    let files = vec![input.clone()];
                    process_files_batch(&files, &output, &replace_map, &processor)?;
                } else {
                    process_directory_batch(&input, &output, &replace_map, &processor)?;
                }
            }
            
            println!("Processing completed successfully!");
        }
        
        Some(("analyze", args)) => {
            let input = PathBuf::from(args.value_of("input").unwrap());
            let encoding = TextEncoding::from_name(args.value_of("encoding").unwrap())
                .ok_or("Invalid encoding")?;
            
            let processor = TextProcessor::new(encoding);
            
            if input.is_file() {
                let stats = processor.analyze_text(&input)?;
                println!("{}", stats);
            } else {
                analyze_directory(&input, &processor)?;
            }
        }
        
        Some(("verify", args)) => {
            let input = PathBuf::from(args.value_of("input").unwrap());
            
            if input.is_file() {
                let result = rust_file_processor::utilities::file_ops::FileReader::new(&input)
                    .verify_integrity()?;
                println!("File integrity: {}", if result { "OK" } else { "FAILED" });
            } else {
                verify_directory(&input)?;
            }
        }
        
        _ => unreachable!(),
    }
    
    Ok(())
}

fn process_files_batch(
    files: &[PathBuf],
    output: &PathBuf,
    replacements: &HashMap<&str, &str>,
    processor: &TextProcessor,
) -> Result<(), Box<dyn Error>> {
    let total_files = files.len();
    let progress_bar = ProgressBar::new(total_files as u64);
    progress_bar.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {pos}/{len} {msg}")
            .unwrap()
    );
    
    for (i, file) in files.iter().enumerate() {
        let output_file = output.join(file.file_name().unwrap());
        let replacements = replacements.clone();
        let processor = processor.clone();
        
        let result = processor.find_and_replace(file, &output_file, &replacements);
        
        match result {
            Ok(_) => {
                progress_bar.set_message(format!("Processing: {:?}", file.file_name().unwrap()));
            }
            Err(e) => {
                eprintln!("Error processing {:?}: {}", file, e);
            }
        }
        
        progress_bar.inc(1);
    }
    
    progress_bar.finish_with_message("Processing complete!");
    Ok(())
}

fn process_directory_batch(
    input_dir: &PathBuf,
    output_dir: &PathBuf,
    replacements: &HashMap<&str, &str>,
    processor: &TextProcessor,
) -> Result<(), Box<dyn Error>> {
    // 递归查找所有文件
    let files: Vec<PathBuf> = walkdir::WalkDir::new(input_dir)
        .into_iter()
        .filter_map(|entry| entry.ok())
        .filter(|entry| entry.file_type().is_file())
        .map(|entry| entry.path().to_path_buf())
        .collect();
    
    std::fs::create_dir_all(output_dir)?;
    
    let total_files = files.len();
    let progress_bar = ProgressBar::new(total_files as u64);
    progress_bar.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {pos}/{len} {msg}")
            .unwrap()
    );
    
    // 使用并发处理
    let pool = rust_file_processor::concurrent::worker::WorkerPool::new(num_cpus::get());
    
    for file in files {
        let output_file = output_dir.join(file.strip_prefix(input_dir).unwrap());
        let replacements = replacements.clone();
        let processor = processor.clone();
        
        pool.execute(move || {
            let result = processor.find_and_replace(&file, &output_file, &replacements);
            match result {
                Ok(_) => println!("Processed: {:?}", file),
                Err(e) => eprintln!("Error processing {:?}: {}", file, e),
            }
        });
    }
    
    progress_bar.set_message("Processing all files...");
    drop(pool); // 等待所有任务完成
    
    progress_bar.finish_with_message("Batch processing complete!");
    Ok(())
}

fn analyze_directory(
    input_dir: &PathBuf,
    processor: &TextProcessor,
) -> Result<(), Box<dyn Error>> {
    let files: Vec<PathBuf> = walkdir::WalkDir::new(input_dir)
        .into_iter()
        .filter_map(|entry| entry.ok())
        .filter(|entry| entry.file_type().is_file())
        .map(|entry| entry.path().to_path_buf())
        .collect();
    
    let progress_bar = ProgressBar::new(files.len() as u64);
    progress_bar.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {pos}/{len} {msg}")
            .unwrap()
    );
    
    for file in files {
        if let Ok(stats) = processor.analyze_text(&file) {
            println!("\nFile: {:?}", file);
            println!("{}", stats);
        }
        progress_bar.inc(1);
    }
    
    progress_bar.finish_with_message("Analysis complete!");
    Ok(())
}

fn verify_directory(input_dir: &PathBuf) -> Result<(), Box<dyn Error>> {
    let files: Vec<PathBuf> = walkdir::WalkDir::new(input_dir)
        .into_iter()
        .filter_map(|entry| entry.ok())
        .filter(|entry| entry.file_type().is_file())
        .map(|entry| entry.path().to_path_buf())
        .collect();
    
    let progress_bar = ProgressBar::new(files.len() as u64);
    progress_bar.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{wide_bar:.cyan/blue}] {pos}/{len} {msg}")
            .unwrap()
    );
    
    let mut failed_files = Vec::new();
    
    for file in files {
        let result = rust_file_processor::utilities::file_ops::FileReader::new(&file)
            .verify_integrity();
        
        match result {
            Ok(true) => println!("✓ {:?}", file),
            Ok(false) => {
                println!("✗ {:?}", file);
                failed_files.push(file);
            }
            Err(e) => {
                println!("✗ {:?} (Error: {})", file, e);
                failed_files.push(file);
            }
        }
        
        progress_bar.inc(1);
    }
    
    progress_bar.finish_with_message("Verification complete!");
    
    if !failed_files.is_empty() {
        eprintln!("\nFailed files:");
        for file in failed_files {
            eprintln!("  {:?}", file);
        }
        return Err("Some files failed integrity check".into());
    }
    
    println!("\nAll files passed integrity check!");
    Ok(())
}

3.6.3.6 项目配置

Cargo.toml

[package]
name = "rust-file-processor"
version = "1.0.0"
edition = "2021"
authors = ["Your Name <your.email@example.com>"]
description = "Memory-safe file processing tool"
license = "MIT"
repository = "https://github.com/yourname/rust-file-processor"

[dependencies]
# 异步和并发
rayon = "1.7"
crossbeam = "0.8"
futures = "0.3"

# 文件处理
walkdir = "2.4"
encoding_rs = "0.8"
encoding_rs_io = "0.1"

# CLI
clap = { version = "4.0", features = ["derive"] }

# 用户界面
indicatif = "0.17"
colored = "2.0"

# 系统信息
num_cpus = "1.16"

# 错误处理
anyhow = "1.0"

[dev-dependencies]
tempfile = "3.5"
criterion = "0.5"

[[example]]
name = "basic_usage"
path = "examples/basic_usage.rs"

[[example]]
name = "concurrent_processing"
path = "examples/concurrent_processing.rs"

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
panic = "abort"

3.6.4 使用示例

3.6.4.1 基础使用

examples/basic_usage.rs

use rust_file_processor::utilities::file_ops::FileReader;
use rust_file_processor::utilities::encoding::TextEncoding;
use rust_file_processor::processors::text::TextProcessor;
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建文本处理器
    let processor = TextProcessor::new(TextEncoding::UTF8);
    
    // 读取文件并分析
    let stats = processor.analyze_text("sample.txt")?;
    println!("Text statistics: {}", stats);
    
    // 文本替换
    let mut replacements = HashMap::new();
    replacements.insert("hello", "world");
    replacements.insert("foo", "bar");
    
    processor.find_and_replace("input.txt", "output.txt", &replacements)?;
    println!("Text replacement completed");
    
    Ok(())
}

3.6.4.2 并发处理示例

examples/concurrent_processing.rs

use rust_file_processor::concurrent::worker::{FileProcessingJob, WorkerPool};
use std::path::PathBuf;
use std::sync::Arc;
use std::error::Error;

fn main() -> Result<(), Box<dyn Error>> {
    // 准备文件列表
    let files = vec![
        PathBuf::from("file1.txt"),
        PathBuf::from("file2.txt"),
        PathBuf::from("file3.txt"),
    ];
    
    // 创建处理器闭包
    let processor = Arc::new(|file: &Path| -> Result<(), Box<dyn Error>> {
        println!("Processing: {:?}", file);
        // 模拟文件处理
        std::thread::sleep(std::time::Duration::from_millis(100));
        Ok(())
    });
    
    // 创建处理作业
    let job = FileProcessingJob::new(files, processor);
    
    // 创建工作池
    let pool = WorkerPool::new(num_cpus::get());
    
    // 执行处理
    let progress = job.execute(&pool)?;
    
    println!("Processing completed:");
    println!("  Total: {}", progress.total);
    println!("  Completed: {}", progress.completed);
    println!("  Failed: {}", progress.failed);
    
    Ok(())
}

3.6.5 性能测试

tests/performance.rs

#![allow(unused)]
fn main() {
use rust_file_processor::utilities::file_ops::FileReader;
use std::path::Path;
use std::time::Instant;

#[test]
fn test_large_file_processing() {
    // 创建测试大文件
    let test_file = "test_large.txt";
    create_large_file(test_file, 1024 * 1024); // 1MB
    
    let start = Instant::now();
    
    // 测试流式处理
    let reader = FileReader::new(test_file).with_buffer_size(8192);
    let line_count = reader.process_lines(|_| Ok(()));
    
    let duration = start.elapsed();
    
    assert!(duration.as_millis() < 1000); // 应该在1秒内完成
    assert!(line_count.is_ok());
    
    // 清理
    std::fs::remove_file(test_file).ok();
}

fn create_large_file(path: &str, size: usize) {
    use std::fs::File;
    use std::io::Write;
    
    let mut file = File::create(path).unwrap();
    let line = "This is a test line for large file processing. ".repeat(10);
    
    for _ in 0..(size / line.len()) {
        writeln!(file, "{}", line).unwrap();
    }
}
}

3.6.6 生产级考虑

3.6.6.1 内存使用监控

在生产环境中，监控内存使用至关重要：

#![allow(unused)]
fn main() {
use sysinfo::{System, SystemExt, ProcessExt};

pub struct MemoryMonitor {
    sys: System,
}

impl MemoryMonitor {
    pub fn new() -> Self {
        Self {
            sys: System::new_all(),
        }
    }
    
    pub fn get_memory_usage(&mut self) -> MemoryUsage {
        self.sys.refresh_all();
        
        MemoryUsage {
            total: self.sys.total_memory(),
            available: self.sys.available_memory(),
            used: self.sys.used_memory(),
            used_percent: (self.sys.used_memory() as f64 / self.sys.total_memory() as f64) * 100.0,
        }
    }
    
    pub fn warn_if_high_usage(&mut self, threshold: f64) -> bool {
        let usage = self.get_memory_usage();
        if usage.used_percent > threshold {
            eprintln!("Warning: Memory usage is {}%", usage.used_percent);
            true
        } else {
            false
        }
    }
}

#[derive(Debug, Clone)]
pub struct MemoryUsage {
    pub total: u64,
    pub available: u64,
    pub used: u64,
    pub used_percent: f64,
}
}

3.6.6.2 原子操作

确保文件操作的原子性：

#![allow(unused)]
fn main() {
use std::fs;
use std::path::Path;
use std::io::{self, Write, Read};

pub fn atomic_file_write<P: AsRef<Path>, C: AsRef<[u8]>>(
    path: P,
    content: C
) -> io::Result<()> {
    let temp_path = format!("{}.tmp", path.as_ref().display());
    
    // 写入临时文件
    {
        let mut temp_file = fs::File::create(&temp_path)?;
        temp_file.write_all(content.as_ref())?;
    }
    
    // 原子性重命名
    fs::rename(&temp_path, path)?;
    Ok(())
}
}

3.6.6.3 错误恢复机制

#![allow(unused)]
fn main() {
use std::collections::HashSet;
use std::path::PathBuf;

pub struct ErrorRecovery {
    processed_files: HashSet<PathBuf>,
    failed_files: Vec<PathBuf>,
    max_retries: usize,
}

impl ErrorRecovery {
    pub fn new(max_retries: usize) -> Self {
        Self {
            processed_files: HashSet::new(),
            failed_files: Vec::new(),
            max_retries,
        }
    }
    
    pub fn mark_processed(&mut self, file: PathBuf) {
        self.processed_files.insert(file);
    }
    
    pub fn mark_failed(&mut self, file: PathBuf) {
        self.failed_files.push(file);
    }
    
    pub fn retry_failed(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        let mut retry_count = 0;
        
        while !self.failed_files.is_empty() && retry_count < self.max_retries {
            retry_count += 1;
            let failed = std::mem::take(&mut self.failed_files);
            
            for file in failed {
                if self.processed_files.contains(&file) {
                    continue; // 已处理，跳过
                }
                
                // 重试处理
                match self.process_file(&file) {
                    Ok(_) => {
                        self.mark_processed(file);
                    }
                    Err(_) => {
                        self.failed_files.push(file); // 重新加入失败列表
                    }
                }
            }
        }
        
        if !self.failed_files.is_empty() {
            return Err("Some files failed to process after retries".into());
        }
        
        Ok(())
    }
    
    fn process_file(&self, file: &Path) -> Result<(), Box<dyn std::error::Error>> {
        // 实现文件处理逻辑
        Ok(())
    }
}
}

3.7 最佳实践

3.7.1 所有权使用原则

优先借用：除非必要，否则使用引用而非获取所有权
移动而非复制：对于大型数据结构，优先移动所有权而非复制
智能指针选择：
- 使用Box<T>在堆上分配单所有权值
- 使用Rc<T>在单线程环境共享多所有权
- 使用Arc<T>在多线程环境共享多所有权

3.7.2 借用检查器技巧

使用可变借用分离：

#![allow(unused)]
fn main() {
let mut data = vec![1, 2, 3];
let first = &data[0];
// 这里不能获取可变引用
// let first_mut = &mut data[0];
}

使用内部可变性：

#![allow(unused)]
fn main() {
use std::cell::RefCell;
let data = RefCell::new(vec![1, 2, 3]);
data.borrow_mut().push(4); // 可以在不可变引用内部修改
}

使用生命周期参数：

#![allow(unused)]
fn main() {
fn longest_with_announcement<'a, T>(
    x: &'a str,
    y: &'a str,
    ann: T,
) -> &'a str
where
    T: std::fmt::Display,
{
    println!("Announcement: {}", ann);
    if x.len() > y.len() {
        x
    } else {
        y
    }
}
}

3.7.3 性能优化

避免不必要的所有权转移：

#![allow(unused)]
fn main() {
// 不好的方式
fn process_string(s: String) -> String {
    // 处理字符串
    s
}

// 好的方式
fn process_string(s: &str) -> String {
    // 处理字符串
    s.to_string()
}
}

使用零拷贝技术：

#![allow(unused)]
fn main() {
fn parse_csv_line(line: &str) -> (&str, &str, &str) {
    // 使用切片而不是创建新字符串
    let mut iter = line.split(',');
    (
        iter.next().unwrap(),
        iter.next().unwrap(),
        iter.next().unwrap(),
    )
}
}

批量处理减少内存分配：

#![allow(unused)]
fn main() {
fn process_batch(items: &[Item], batch_size: usize) {
    for chunk in items.chunks(batch_size) {
        process_chunk(chunk); // 批量处理减少分配
    }
}
}

3.8 总结

本章深入探讨了Rust的所有权系统，这是Rust语言的核心特性之一。通过本章的学习，您已经：

理解了所有权概念：每个值都有一个所有者，作用域结束时自动清理
掌握了借用机制：通过引用安全地使用值而不转移所有权
学会了生命周期管理：确保引用的有效性
了解了智能指针：处理复杂的所有权情况
构建了实用项目：开发了内存安全的文件处理工具

所有权系统让Rust在保持高性能的同时提供了内存安全保证，这是现代系统编程的重要进步。在实际开发中，合理使用借用、智能指针和生命周期注解，可以构建既安全又高效的Rust应用程序。

3.9 验收标准

完成本章后，您应该能够：

解释所有权、借用和生命周期的关系
识别并解决借用检查器错误
选择合适的智能指针类型
实现内存安全的文件处理程序
编写高效的批量数据处理代码
设计生产级的错误处理和恢复机制

3.10 练习题

所有权转换：实现一个函数，接受一个Vec的所有权，返回处理后的Vec
借用优化：重构代码以使用借用而不是所有权的转移
生命周期注解：为复杂的函数添加正确的生命周期参数
性能测试：对比使用借用和所有权转移的性能差异
错误处理：为文件处理工具添加重试机制和回滚功能

3.11 扩展阅读

第四章：结构体与枚举

学习目标

通过本章学习，您将掌握：

Rust中结构体的定义、方法和关联函数
枚举的强大功能和模式匹配
如何设计灵活的数据结构
实现生产级的配置管理系统
实战项目：构建一个企业级配置管理工具

4.1 引言：结构化数据的重要性

在现实世界中，数据很少是孤立的。应用程序需要处理复杂的、相互关联的数据结构。Rust通过结构体和枚举提供了强大的工具来建模和操作这些复杂数据。

为什么需要结构体和枚举？

类型安全：确保数据结构的完整性
表达力：精确建模业务逻辑
维护性：清晰的代码组织
性能：零成本的抽象

4.2 结构体基础

4.2.1 什么是结构体？

结构体（Struct）是一种复合数据类型，允许将多个相关的数据项组合在一起。与元组不同，结构体为每个字段提供有意义的名称。

struct User {
    name: String,
    email: String,
    age: u32,
    is_active: bool,
}

fn main() {
    let user = User {
        name: String::from("Alice"),
        email: String::from("alice@example.com"),
        age: 25,
        is_active: true,
    };
    
    println!("User: {} ({})", user.name, user.email);
}

4.2.2 定义和使用结构体

4.2.2.1 基础结构体

// 定义一个点结构体
struct Point {
    x: f64,
    y: f64,
}

// 定义一个矩形结构体
struct Rectangle {
    top_left: Point,
    width: f64,
    height: f64,
}

impl Rectangle {
    // 关联函数（类似静态方法）
    fn new(top_left: Point, width: f64, height: f64) -> Self {
        Self {
            top_left,
            width,
            height,
        }
    }
    
    // 方法
    fn area(&self) -> f64 {
        self.width * self.height
    }
    
    fn contains_point(&self, point: &Point) -> bool {
        point.x >= self.top_left.x
            && point.x <= self.top_left.x + self.width
            && point.y >= self.top_left.y
            && point.y <= self.top_left.y + self.height
    }
    
    fn move_to(&mut self, new_x: f64, new_y: f64) {
        self.top_left.x = new_x;
        self.top_left.y = new_y;
    }
}

// 关联函数vs方法的区别
fn main() {
    // 使用关联函数创建实例
    let rect = Rectangle::new(Point { x: 0.0, y: 0.0 }, 10.0, 5.0);
    
    // 调用方法
    println!("Area: {}", rect.area());
    
    // 只能通过方法修改，因为self是&mut self
    let mut rect = rect; // 需要声明mut
    rect.move_to(5.0, 2.0);
    
    let test_point = Point { x: 3.0, y: 1.0 };
    if rect.contains_point(&test_point) {
        println!("Point is inside rectangle");
    }
}

4.2.2.2 元组结构体

元组结构体类似于元组，但每个字段都有类型：

struct Color(u8, u8, u8);
struct Point3D(f64, f64, f64);

fn main() {
    let red = Color(255, 0, 0);
    let point = Point3D(1.0, 2.0, 3.0);
    
    // 通过索引访问
    println!("Red: {}, Green: {}, Blue: {}", red.0, red.1, red.2);
    println!("Point: x={}, y={}, z={}", point.0, point.1, point.2);
}

4.2.2.3 单元结构体

没有字段的结构体，称为单元结构体：

struct UnitStruct;

// 主要用于实现trait
impl SomeTrait for UnitStruct {
    // 可以为空
}

fn main() {
    let unit = UnitStruct;
    // unit可以用作标记
}

4.2.3 结构和操作

4.2.3.1 字段访问

struct Student {
    name: String,
    student_id: u32,
    gpa: f32,
    subjects: Vec<String>,
}

fn main() {
    let mut student = Student {
        name: String::from("Bob"),
        student_id: 2023001,
        gpa: 3.85,
        subjects: Vec::new(),
    };
    
    // 访问字段
    println!("Student: {} (ID: {})", student.name, student.student_id);
    
    // 修改字段
    student.subjects.push("Rust Programming".to_string());
    student.gpa += 0.1; // 获得额外分数
    
    // 完整更新语法
    let student2 = Student {
        name: String::from("Charlie"),
        student_id: 2023002,
        // ... 复制其他字段
        gpa: 3.75,
        subjects: vec!["Python".to_string()],
    };
    
    let student3 = Student {
        name: String::from("Diana"),
        ..student2 // 复制除name外的其他字段
    };
}

4.2.3.2 方法和关联函数

struct Calculator {
    result: f64,
    history: Vec<String>,
}

impl Calculator {
    // 关联函数（类似构造器）
    fn new() -> Self {
        Self {
            result: 0.0,
            history: Vec::new(),
        }
    }
    
    fn with_initial_value(value: f64) -> Self {
        Self {
            result: value,
            history: vec![format!("Initial value: {}", value)],
        }
    }
    
    // 方法（接收&self）
    fn get_result(&self) -> f64 {
        self.result
    }
    
    // 方法（接收&mut self）
    fn add(&mut self, value: f64) {
        self.result += value;
        self.history.push(format!("+ {} = {}", value, self.result));
    }
    
    // 方法（接收self，消耗实例）
    fn get_history(self) -> Vec<String> {
        self.history
    }
    
    // 泛型方法
    fn apply_operation<T>(&mut self, value: T, operation: Operation)
    where
        T: Into<f64>,
    {
        let num: f64 = value.into();
        self.perform_operation(num, operation);
    }
    
    fn perform_operation(&mut self, value: f64, operation: Operation) {
        match operation {
            Operation::Add => self.result += value,
            Operation::Subtract => self.result -= value,
            Operation::Multiply => self.result *= value,
            Operation::Divide => {
                if value != 0.0 {
                    self.result /= value;
                }
            }
        }
        self.history.push(format!("{:?} {} = {}", operation, value, self.result));
    }
}

#[derive(Debug)]
enum Operation {
    Add,
    Subtract,
    Multiply,
    Divide,
}

fn main() {
    let mut calc = Calculator::new();
    calc.add(10.0);
    calc.add(5.0);
    calc.apply_operation(2.0, Operation::Multiply);
    calc.apply_operation(3.0, Operation::Subtract);
    
    println!("Result: {}", calc.get_result());
    
    // 获取历史记录（消耗calc）
    let history = calc.get_history();
    println!("History: {:?}", history);
}

4.2.4 高级特性

4.2.4.1 泛型结构体

struct Container<T> {
    items: Vec<T>,
    capacity: usize,
}

impl<T> Container<T> {
    fn new(capacity: usize) -> Self {
        Self {
            items: Vec::with_capacity(capacity),
            capacity,
        }
    }
    
    fn push(&mut self, item: T) {
        if self.items.len() < self.capacity {
            self.items.push(item);
        } else {
            panic!("Container is full");
        }
    }
    
    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }
    
    fn len(&self) -> usize {
        self.items.len()
    }
    
    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }
    
    fn get(&self, index: usize) -> Option<&T> {
        self.items.get(index)
    }
    
    fn get_all(&self) -> &[T] {
        &self.items
    }
    
    fn iter(&self) -> std::slice::Iter<'_, T> {
        self.items.iter()
    }
    
    fn clear(&mut self) {
        self.items.clear();
    }
}

fn main() {
    // 字符串容器
    let mut string_container = Container::new(3);
    string_container.push("Hello".to_string());
    string_container.push("World".to_string());
    string_container.push("Rust".to_string());
    
    println!("String container length: {}", string_container.len());
    
    for item in string_container.iter() {
        println!("Item: {}", item);
    }
    
    // 数字容器
    let mut number_container = Container::new(5);
    number_container.push(1.0);
    number_container.push(2.5);
    number_container.push(3.7);
    
    for num in number_container.get_all() {
        println!("Number: {}", num);
    }
}

4.2.4.2 生命周期在结构体中

struct ReferenceHolder<'a> {
    reference: &'a str,
    data: String,
}

impl<'a> ReferenceHolder<'a> {
    fn new(reference: &'a str, data: String) -> Self {
        Self {
            reference,
            data,
        }
    }
    
    fn get_reference(&self) -> &'a str {
        self.reference
    }
    
    fn get_data(&self) -> &str {
        &self.data
    }
    
    // 返回生命周期较短的引用
    fn get_data_mut(&mut self) -> &mut str {
        &mut self.data
    }
    
    fn get_data_string(self) -> (String, String) {
        (self.reference.to_string(), self.data)
    }
}

fn main() {
    let data = String::from("Hello World");
    let holder = ReferenceHolder::new(&data, data);
    
    // 引用指向的数据比holder生命周期长
    let _long_lived_ref = holder.get_reference(); // OK
    
    // 所有权数据
    let _owned_data = holder.get_data().to_string(); // 复制
    let (ref_str, data_str) = holder.get_data_string();
    println!("Reference: {}, Data: {}", ref_str, data_str);
}

4.3 枚举详解

4.3.1 基础枚举

枚举允许定义一个类型，其值可以是几个固定选项中的一个：

// 简单的枚举
enum TrafficLight {
    Red,
    Yellow,
    Green,
}

impl TrafficLight {
    fn time(&self) -> u32 {
        match self {
            TrafficLight::Red => 30,
            TrafficLight::Yellow => 5,
            TrafficLight::Green => 45,
        }
    }
    
    fn next(&self) -> TrafficLight {
        match self {
            TrafficLight::Red => TrafficLight::Green,
            TrafficLight::Yellow => TrafficLight::Red,
            TrafficLight::Green => TrafficLight::Yellow,
        }
    }
}

// 携带数据的枚举
enum WebEvent {
    PageLoad,
    PageUnload,
    Click { x: i32, y: i32 },
    KeyPress(char),
    Paste(String),
    Scroll { delta_x: f32, delta_y: f32 },
    Resize { width: u32, height: u32 },
}

fn main() {
    let light = TrafficLight::Red;
    println!("Light time: {} seconds", light.time());
    println!("Next light: {:?}", light.next());
    
    let click = WebEvent::Click { x: 50, y: 100 };
    let paste = WebEvent::Paste("Hello Rust!".to_string());
    let resize = WebEvent::Resize { width: 1920, height: 1080 };
    
    process_event(click);
    process_event(paste);
    process_event(resize);
}

fn process_event(event: WebEvent) {
    match event {
        WebEvent::PageLoad => println!("Page loaded"),
        WebEvent::PageUnload => println!("Page unloaded"),
        WebEvent::Click { x, y } => println!("Click at ({}, {})", x, y),
        WebEvent::KeyPress(c) => println!("Key pressed: {}", c),
        WebEvent::Paste(text) => println!("Pasted: {}", text),
        WebEvent::Scroll { delta_x, delta_y } => {
            println!("Scrolled: ({}, {})", delta_x, delta_y);
        }
        WebEvent::Resize { width, height } => {
            println!("Window resized: {}x{}", width, height);
        }
    }
}

4.3.2 复杂的枚举

4.3.2.1 Option枚举

Option是Rust标准库中最重要的枚举：

enum Option<T> {
    Some(T),
    None,
}

fn divide(a: f64, b: f64) -> Option<f64> {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

fn find_user(id: u32) -> Option<User> {
    if id == 1 {
        Some(User { name: "Alice".to_string(), id })
    } else {
        None
    }
}

#[derive(Debug, Clone)]
struct User {
    name: String,
    id: u32,
}

fn main() {
    let result = divide(10.0, 2.0);
    match result {
        Some(quotient) => println!("10 / 2 = {}", quotient),
        None => println!("Cannot divide by zero"),
    }
    
    // 使用if let进行条件检查
    if let Some(quotient) = divide(10.0, 0.0) {
        println!("Result: {}", quotient);
    } else {
        println!("Division by zero");
    }
    
    // unwrap 方法
    let value = result.unwrap(); // 可能 panic!
    
    // unwrap_or 提供默认值
    let value = divide(10.0, 0.0).unwrap_or(0.0);
    
    // 链式操作
    let user = find_user(1)
        .and_then(|user| find_user(2).map(|user2| (user, user2)))
        .unwrap_or((
            User { name: "Anonymous".to_string(), id: 0 },
            User { name: "Anonymous".to_string(), id: 0 },
        ));
    
    println!("Found users: {:?}", user);
}

4.3.2.2 Result枚举

Result用于错误处理：

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn parse_number(s: &str) -> Result<i32, String> {
    match s.parse::<i32>() {
        Ok(n) => Ok(n),
        Err(_) => Err(format!("'{}' is not a number", s)),
    }
}

fn read_file(path: &str) -> Result<String, std::io::Error> {
    std::fs::read_to_string(path)
}

fn main() {
    match parse_number("42") {
        Ok(n) => println!("Number: {}", n),
        Err(e) => println!("Error: {}", e),
    }
    
    if let Ok(n) = parse_number("42") {
        println!("Parsed: {}", n);
    }
    
    // 错误传播
    fn process_numbers(a: &str, b: &str) -> Result<i32, String> {
        let num1 = parse_number(a)?; // 传播错误
        let num2 = parse_number(b)?;
        Ok(num1 + num2)
    }
    
    let sum = process_numbers("10", "32")?;
    println!("Sum: {}", sum);
    
    // 组合多个Result
    let results = vec!["1", "2", "3", "4"];
    let numbers: Result<Vec<i32>, _> = results.iter()
        .map(|s| parse_number(s))
        .collect();
    
    match numbers {
        Ok(nums) => println!("All numbers: {:?}", nums),
        Err(e) => println!("Failed to parse: {}", e),
    }
}

4.3.2.3 自定义错误类型

#![allow(unused)]
fn main() {
// 自定义错误类型
#[derive(Debug)]
enum ConfigError {
    FileNotFound(String),
    InvalidFormat(String),
    MissingKey(String),
    ValidationFailed(String),
    IOError(std::io::Error),
}

impl std::fmt::Display for ConfigError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ConfigError::FileNotFound(path) => write!(f, "Configuration file not found: {}", path),
            ConfigError::InvalidFormat(msg) => write!(f, "Invalid format: {}", msg),
            ConfigError::MissingKey(key) => write!(f, "Missing required key: {}", key),
            ConfigError::ValidationFailed(msg) => write!(f, "Validation failed: {}", msg),
            ConfigError::IOError(e) => write!(f, "IO error: {}", e),
        }
    }
}

impl std::error::Error for ConfigError {}

impl From<std::io::Error> for ConfigError {
    fn from(e: std::io::Error) -> Self {
        ConfigError::IOError(e)
    }
}

// 错误处理函数
fn load_config(path: &str) -> Result<Config, ConfigError> {
    if !std::path::Path::new(path).exists() {
        return Err(ConfigError::FileNotFound(path.to_string()));
    }
    
    let content = std::fs::read_to_string(path)?;
    parse_config(&content)
}

fn parse_config(content: &str) -> Result<Config, ConfigError> {
    if content.trim().is_empty() {
        return Err(ConfigError::InvalidFormat("Empty content".to_string()));
    }
    
    // 解析逻辑...
    Ok(Config::new())
}

struct Config {
    settings: std::collections::HashMap<String, String>,
}

impl Config {
    fn new() -> Self {
        Self {
            settings: std::collections::HashMap::new(),
        }
    }
}
}

4.3.3 枚举的高级用法

4.3.3.1 枚举作为泛型参数

enum Either<T, E> {
    Left(T),
    Right(E),
}

enum Nullable<T> {
    Some(T),
    None,
}

enum ResultOr<T, E> {
    Success(T),
    Failure(E),
}

// 模式匹配与泛型
impl<T, E> Either<T, E> {
    fn is_left(&self) -> bool {
        matches!(self, Either::Left(_))
    }
    
    fn is_right(&self) -> bool {
        matches!(self, Either::Right(_))
    }
    
    fn as_ref(&self) -> Either<&T, &E> {
        match self {
            Either::Left(value) => Either::Left(value),
            Either::Right(error) => Either::Right(error),
        }
    }
    
    fn map<U, F>(self, f: F) -> Either<U, E>
    where
        F: FnOnce(T) -> U,
    {
        match self {
            Either::Left(value) => Either::Left(f(value)),
            Either::Right(error) => Either::Right(error),
        }
    }
    
    fn unwrap_or(self, default: T) -> T {
        match self {
            Either::Left(value) => value,
            Either::Right(_) => default,
        }
    }
}

fn main() {
    let result: Either<i32, String> = Either::Left(42);
    let error: Either<i32, String> = Either::Right("Error".to_string());
    
    if result.is_left() {
        println!("Got a value");
    }
    
    if error.is_right() {
        println!("Got an error");
    }
    
    let mapped = result.map(|x| x * 2);
    println!("Mapped result: {:?}", mapped);
}

4.3.3.2 复杂的状态机

// 状态机模式
enum State {
    Idle,
    Connecting,
    Connected,
    Authenticating,
    Authenticated,
    Error(String),
    Closed,
}

enum Event {
    Connect,
    Disconnect,
    DataReceived(String),
    Error(String),
    Timeout,
    AuthSuccess,
    AuthFailed,
}

struct Connection {
    state: State,
    retry_count: u32,
    max_retries: u32,
}

impl Connection {
    fn new(max_retries: u32) -> Self {
        Self {
            state: State::Idle,
            retry_count: 0,
            max_retries,
        }
    }
    
    fn handle_event(&mut self, event: Event) -> Result<(), String> {
        let old_state = self.state.clone();
        
        self.state = match (self.state.clone(), event) {
            (State::Idle, Event::Connect) => {
                self.retry_count = 0;
                State::Connecting
            }
            
            (State::Connecting, Event::DataReceived(_)) => State::Authenticating,
            (State::Connecting, Event::Timeout) => {
                self.retry_count += 1;
                if self.retry_count >= self.max_retries {
                    return Err("Max retries exceeded".to_string());
                }
                State::Connecting
            }
            (State::Connecting, Event::Error(e)) => State::Error(e),
            
            (State::Authenticating, Event::AuthSuccess) => State::Authenticated,
            (State::Authenticating, Event::AuthFailed) => {
                self.retry_count += 1;
                if self.retry_count >= self.max_retries {
                    return Err("Authentication failed after max retries".to_string());
                }
                State::Connecting
            }
            (State::Authenticating, Event::Error(e)) => State::Error(e),
            
            (State::Authenticated, Event::Disconnect) => State::Closed,
            (State::Authenticated, Event::Error(e)) => State::Error(e),
            
            (State::Error(_), Event::Connect) => {
                self.retry_count = 0;
                State::Connecting
            }
            
            (State::Error(_), Event::Disconnect) => State::Closed,
            
            (_, Event::Disconnect) => State::Closed,
            
            (s, e) => {
                println!("Unhandled transition: {:?} -> {:?}", s, e);
                s
            }
        };
        
        println!("State transition: {:?} -> {:?}", old_state, self.state);
        Ok(())
    }
    
    fn get_state(&self) -> &State {
        &self.state
    }
    
    fn is_connected(&self) -> bool {
        matches!(self.state, State::Authenticated)
    }
}

fn main() {
    let mut conn = Connection::new(3);
    
    // 连接流程
    conn.handle_event(Event::Connect).unwrap();
    conn.handle_event(Event::DataReceived("response".to_string())).unwrap();
    conn.handle_event(Event::AuthSuccess).unwrap();
    
    println!("Connected: {}", conn.is_connected());
    
    // 断开连接
    conn.handle_event(Event::Disconnect).unwrap();
    println!("State: {:?}", conn.get_state());
}

4.4 模式匹配

4.4.1 基础模式匹配

fn main() {
    let value = 42;
    
    match value {
        0 => println!("Zero"),
        1 => println!("One"),
        2..=10 => println!("Between 2 and 10"),
        11..=100 => println!("Between 11 and 100"),
        _ => println!("Something else: {}", value),
    }
    
    // if let 语法
    if let 42 = value {
        println!("Found 42!");
    }
    
    // while let
    let mut option: Option<i32> = Some(5);
    while let Some(x) = option {
        println!("Processing: {}", x);
        option = if x > 0 {
            Some(x - 1)
        } else {
            None
        };
    }
    
    // 匹配Option
    let maybe_number = Some(42);
    if let Some(n) = maybe_number {
        println!("Number: {}", n);
    } else {
        println!("No number");
    }
}

4.4.2 高级模式匹配

4.4.2.1 解构结构体

struct Point {
    x: i32,
    y: i32,
}

struct Person {
    name: String,
    age: i32,
    address: Address,
}

struct Address {
    street: String,
    city: String,
    zip_code: String,
}

fn main() {
    let person = Person {
        name: "Alice".to_string(),
        age: 30,
        address: Address {
            street: "123 Main St".to_string(),
            city: "Anytown".to_string(),
            zip_code: "12345".to_string(),
        },
    };
    
    match person {
        Person {
            name,
            age,
            address: Address {
                street,
                city,
                ..
            },
        } if age >= 18 => {
            println!("Adult: {} lives in {}", name, city);
        }
        Person { name, age, .. } => {
            println!("Minor: {} is {} years old", name, age);
        }
    }
    
    // 简单解构
    let point = Point { x: 10, y: 20 };
    let Point { x, y } = point;
    println!("Point: ({}, {})", x, y);
    
    // 在let语句中使用模式
    let Point { x: x1, y: y1 } = point;
    println!("x1: {}, y1: {}", x1, y1);
}

4.4.2.2 守卫条件

#[derive(Debug)]
enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
    SetVolume(i32),
}

fn main() {
    let msg = Message::ChangeColor(255, 0, 0);
    
    match msg {
        Message::Move { x, y } if x == y => {
            println!("Diagonal move: {}, {}", x, y);
        }
        Message::Move { x, y } if x == 0 || y == 0 => {
            println!("Axis-aligned move: {}, {}", x, y);
        }
        Message::Move { x, y } => {
            println!("General move: {}, {}", x, y);
        }
        Message::Write(text) if text.len() > 10 => {
            println!("Long message: {}", text);
        }
        Message::Write(text) => {
            println!("Short message: {}", text);
        }
        Message::ChangeColor(r, g, b) if r == g && g == b => {
            println!("Grayscale: ({}, {}, {})", r, g, b);
        }
        Message::ChangeColor(r, g, b) if r == 255 && g == 0 && b == 0 => {
            println!("Pure red color");
        }
        Message::ChangeColor(r, g, b) => {
            println!("Color: ({}, {}, {})", r, g, b);
        }
        Message::SetVolume(volume) if volume > 100 => {
            println!("Volume too high: {}", volume);
        }
        Message::SetVolume(volume) if volume == 0 => {
            println!("Muted");
        }
        Message::SetVolume(volume) => {
            println!("Volume: {}", volume);
        }
        Message::Quit => {
            println!("Quitting");
        }
    }
}

4.4.3 模式匹配最佳实践

4.4.3.1 穷尽性检查

#![allow(unused)]
fn main() {
enum Color {
    Red,
    Green,
    Blue,
    Alpha(f32),
}

fn match_color(color: Color) -> String {
    // Rust会检查是否穷尽了所有情况
    match color {
        Color::Red => "Red".to_string(),
        Color::Green => "Green".to_string(),
        Color::Blue => "Blue".to_string(),
        // 必须处理Alpha变体
        Color::Alpha(a) => format!("Alpha: {}", a),
    }
}

// 如果我们忘记处理某个变体，编译器会报错：
fn bad_match_color(color: Color) -> String {
    match color {
        Color::Red => "Red".to_string(),
        Color::Green => "Green".to_string(),
        // 错误：未处理Blue和Alpha
        _ => "Unknown".to_string(), // 使用通配符但会丢失信息
    }
}

// 更好的做法：明确处理所有变体
fn better_match_color(color: Color) -> String {
    match color {
        Color::Red => "Red".to_string(),
        Color::Green => "Green".to_string(),
        Color::Blue => "Blue".to_string(),
        Color::Alpha(a) => format!("Alpha: {}", a),
    }
}
}

4.4.3.2 @绑定

#[derive(Debug)]
enum Message {
    Move { x: i32, y: i32 },
    Say(String),
    Other,
}

fn main() {
    let msg = Message::Move { x: 5, y: 10 };
    
    match msg {
        // 绑定整个值到m，同时解构字段
        m @ Message::Move { x, y } => {
            println!("Message: {:?} has coordinates ({}, {})", m, x, y);
        }
        // 绑定字符串到s
        s @ Message::Say(_) => {
            println!("Say message: {:?}", s);
        }
        // 绑定到other
        other => {
            println!("Other message: {:?}", other);
        }
    }
    
    // 使用@绑定进行复杂模式匹配
    let point = (1, 2);
    match point {
        (x, y) if x == y => {
            println!("Equal point: ({}, {})", x, y);
        }
        pt @ (x, y) if x > y => {
            println!("Diagonal point: {:?}", pt);
        }
        pt => {
            println!("Other point: {:?}", pt);
        }
    }
}

4.5 实战项目：企业级配置管理工具

现在我们来构建一个完整的配置管理工具，展示结构体和枚举的实际应用。

4.5.1 项目设计

项目名称：config-manager

核心功能：

多格式配置解析（JSON、YAML、TOML）
类型安全的配置验证
动态配置更新和热重载
配置模板系统
环境特定配置管理

4.5.2 项目结构

config-manager/
├── src/
│   ├── main.rs
│   ├── config/
│   │   ├── mod.rs
│   │   ├── value.rs
│   │   ├── manager.rs
│   │   └── validation.rs
│   ├── parsers/
│   │   ├── mod.rs
│   │   ├── json.rs
│   │   ├── yaml.rs
│   │   ├── toml.rs
│   │   └── custom.rs
│   ├── hot_reload/
│   │   ├── mod.rs
│   │   ├── watcher.rs
│   │   └── notifier.rs
│   ├── templates/
│   │   ├── mod.rs
│   │   ├── engine.rs
│   │   └── generator.rs
│   └── utils/
│       ├── mod.rs
│       ├── error.rs
│       └── types.rs
├── examples/
├── tests/
└── configs/
    ├── development.yaml
    ├── production.json
    └── template.toml

4.5.3 核心实现

4.5.3.1 配置值系统

src/config/value.rs

#![allow(unused)]
fn main() {
use serde_json::Value as JsonValue;
use std::collections::HashMap;
use std::fmt;
use std::str::FromStr;

/// 配置数据类型
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum DataType {
    String,
    Integer,
    Float,
    Boolean,
    Array(Box<DataType>),
    Object,
    Custom(String),
}

impl DataType {
    pub fn is_compatible_with(&self, value: &ConfigValue) -> bool {
        match (self, &value.data_type) {
            (DataType::String, DataType::String) => true,
            (DataType::Integer, DataType::Integer) => true,
            (DataType::Float, DataType::Float) => true,
            (DataType::Boolean, DataType::Boolean) => true,
            (DataType::Array(inner_type), DataType::Array(value_type)) => {
                inner_type.is_compatible_with(&ConfigValue {
                    data_type: *value_type.clone(),
                    value: value.value.clone(),
                    required: false,
                    validation_rules: vec![],
                    description: String::new(),
                })
            }
            (DataType::Object, DataType::Object) => true,
            (DataType::Custom(custom1), DataType::Custom(custom2)) => custom1 == custom2,
            _ => false,
        }
    }
    
    pub fn from_json_value(value: &JsonValue) -> Self {
        match value {
            JsonValue::String(_) => DataType::String,
            JsonValue::Number(n) if n.is_i64() => DataType::Integer,
            JsonValue::Number(n) if n.is_f64() => DataType::Float,
            JsonValue::Bool(_) => DataType::Boolean,
            JsonValue::Array(_) => DataType::Object,
            JsonValue::Object(_) => DataType::Object,
            _ => DataType::String,
        }
    }
}

/// 配置验证规则
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ValidationRule {
    MinValue(i64),
    MaxValue(i64),
    MinLength(usize),
    MaxLength(usize),
    Pattern(String), // 正则表达式
    Required,
    Custom(String), // 自定义验证脚本
}

/// 配置值结构
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ConfigValue {
    pub value: JsonValue,
    pub data_type: DataType,
    pub required: bool,
    pub validation_rules: Vec<ValidationRule>,
    pub description: String,
    pub default_value: Option<JsonValue>,
    pub env_override: Option<String>,
    pub depends_on: Option<String>, // 依赖的另一个配置项
}

impl ConfigValue {
    pub fn new(
        value: JsonValue,
        data_type: DataType,
        required: bool,
    ) -> Self {
        Self {
            value: value.clone(),
            data_type,
            required,
            validation_rules: vec![],
            description: String::new(),
            default_value: None,
            env_override: None,
            depends_on: None,
        }
    }
    
    /// 验证配置值
    pub fn validate(&self) -> Result<(), ValidationError> {
        // 检查必需值
        if self.required && self.value.is_null() {
            if let Some(default) = &self.default_value {
                return Ok(()); // 使用默认值
            }
            return Err(ValidationError::Required(
                "Required configuration value is missing".to_string()
            ));
        }
        
        // 检查数据类型
        if !self.data_type.is_compatible_with(self) {
            return Err(ValidationError::TypeMismatch(format!(
                "Expected {:?}, got {:?}",
                self.data_type, self.value
            )));
        }
        
        // 应用验证规则
        for rule in &self.validation_rules {
            rule.apply(&self.value)?;
        }
        
        Ok(())
    }
    
    /// 获取实际值（考虑环境变量覆盖）
    pub fn get_actual_value(&self) -> Result<JsonValue, ConfigError> {
        // 检查环境变量覆盖
        if let Some(env_var) = &self.env_override {
            if let Ok(env_value) = std::env::var(env_var) {
                return Ok(JsonValue::String(env_value));
            }
        }
        
        // 返回实际值或默认值
        if self.value.is_null() {
            self.default_value.clone()
                .ok_or(ConfigError::MissingValue(self.description.clone()))
        } else {
            Ok(self.value.clone())
        }
    }
}

impl ValidationRule {
    pub fn apply(&self, value: &JsonValue) -> Result<(), ValidationError> {
        match self {
            ValidationRule::MinValue(min) => {
                if let Some(num) = value.as_i64() {
                    if num < *min {
                        return Err(ValidationError::MinValue(*min, num));
                    }
                }
            }
            ValidationRule::MaxValue(max) => {
                if let Some(num) = value.as_i64() {
                    if num > *max {
                        return Err(ValidationError::MaxValue(*max, num));
                    }
                }
            }
            ValidationRule::MinLength(min) => {
                if let Some(text) = value.as_str() {
                    if text.len() < *min {
                        return Err(ValidationError::MinLength(*min, text.len()));
                    }
                }
            }
            ValidationRule::MaxLength(max) => {
                if let Some(text) = value.as_str() {
                    if text.len() > *max {
                        return Err(ValidationError::MaxLength(*max, text.len()));
                    }
                }
            }
            ValidationRule::Pattern(pattern) => {
                if let Some(text) = value.as_str() {
                    let regex = regex::Regex::new(pattern)
                        .map_err(|e| ValidationError::InvalidPattern(e.to_string()))?;
                    if !regex.is_match(text) {
                        return Err(ValidationError::PatternMismatch(pattern.clone(), text.to_string()));
                    }
                }
            }
            ValidationRule::Required => {
                if value.is_null() {
                    return Err(ValidationError::Required("Value is required".to_string()));
                }
            }
            ValidationRule::Custom(_) => {
                // 自定义验证逻辑
                // 这里可以实现更复杂的验证脚本
            }
        }
        
        Ok(())
    }
}

/// 配置错误类型
#[derive(Debug, thiserror::Error)]
pub enum ConfigError {
    #[error("Configuration file not found: {0}")]
    FileNotFound(String),
    
    #[error("Invalid configuration format: {0}")]
    InvalidFormat(String),
    
    #[error("Missing required key: {0}")]
    MissingValue(String),
    
    #[error("Configuration key not found: {0}")]
    KeyNotFound(String),
    
    #[error("Type conversion error: {0}")]
    TypeConversionError(String),
    
    #[error("Environment variable not set: {0}")]
    EnvNotSet(String),
    
    #[error("File I/O error: {0}")]
    IOError(#[from] std::io::Error),
    
    #[error("JSON error: {0}")]
    JsonError(#[from] serde_json::Error),
    
    #[error("YAML error: {0}")]
    YamlError(#[from] serde_yaml::Error),
    
    #[error("TOML error: {0}")]
    TomlError(#[from] toml::de::Error),
}

/// 验证错误类型
#[derive(Debug, thiserror::Error)]
pub enum ValidationError {
    #[error("Required value missing: {0}")]
    Required(String),
    
    #[error("Expected value >= {0}, got {1}")]
    MinValue(i64, i64),
    
    #[error("Expected value <= {0}, got {1}")]
    MaxValue(i64, i64),
    
    #[error("Expected length >= {0}, got {1}")]
    MinLength(usize, usize),
    
    #[error("Expected length <= {0}, got {1}")]
    MaxLength(usize, usize),
    
    #[error("Pattern mismatch: expected {0}, got {1}")]
    PatternMismatch(String, String),
    
    #[error("Invalid pattern: {0}")]
    InvalidPattern(String),
    
    #[error("Type mismatch: {0}")]
    TypeMismatch(String),
}

/// 配置监听器
pub trait ConfigWatcher: Send + Sync {
    fn on_config_change(&self, key: &str, new_value: &ConfigValue);
    fn on_config_removed(&self, key: &str);
    fn on_validation_error(&self, key: &str, error: &ValidationError);
}

/// 配置监听器实现
pub struct LoggingWatcher {
    logger: slog::Logger,
}

impl LoggingWatcher {
    pub fn new(logger: slog::Logger) -> Self {
        Self { logger }
    }
}

impl ConfigWatcher for LoggingWatcher {
    fn on_config_change(&self, key: &str, new_value: &ConfigValue) {
        info!(self.logger, "Configuration changed: {} = {:?}", key, new_value.value);
    }
    
    fn on_config_removed(&self, key: &str) {
        warn!(self.logger, "Configuration removed: {}", key);
    }
    
    fn on_validation_error(&self, key: &str, error: &ValidationError) {
        error!(self.logger, "Configuration validation error: {} - {}", key, error);
    }
}
}

4.5.3.2 配置管理器

src/config/manager.rs

#![allow(unused)]
fn main() {
use crate::config::value::{ConfigValue, ConfigError, ValidationError, ConfigWatcher, DataType};
use crate::parsers::{load_config_file, ConfigFormat};
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::path::Path;
use std::fs;
use notify::{RecommendedWatcher, Watcher, RecursiveMode, Event};
use crossbeam::channel::{unbounded, Receiver, Sender};
use rayon::prelude::*;

pub struct ConfigManager {
    configs: Arc<RwLock<HashMap<String, ConfigValue>>>,
    watchers: Arc<RwLock<Vec<Box<dyn ConfigWatcher>>>>,
    change_sender: Option<Sender<ConfigChangeEvent>>,
    watcher: Option<RecommendedWatcher>,
    logger: slog::Logger,
}

#[derive(Debug, Clone)]
pub struct ConfigChangeEvent {
    pub key: String,
    pub old_value: Option<ConfigValue>,
    pub new_value: Option<ConfigValue>,
    pub change_type: ChangeType,
}

#[derive(Debug, Clone)]
pub enum ChangeType {
    Added,
    Modified,
    Removed,
}

impl ConfigManager {
    pub fn new(logger: slog::Logger) -> Self {
        let (change_sender, change_receiver) = unbounded();
        
        Self {
            configs: Arc::new(RwLock::new(HashMap::new())),
            watchers: Arc::new(RwLock::new(Vec::new())),
            change_sender: Some(change_sender),
            watcher: None,
            logger,
        }
    }
    
    /// 从文件加载配置
    pub fn load_from_file<P: AsRef<Path>>(&mut self, path: P) -> Result<(), ConfigError> {
        let path = path.as_ref();
        let content = fs::read_to_string(path)?;
        
        // 检测文件格式
        let format = ConfigFormat::from_file_extension(path)
            .ok_or_else(|| ConfigError::InvalidFormat(
                format!("Unsupported file extension: {:?}", path.extension())
            ))?;
        
        let configs: HashMap<String, ConfigValue> = match format {
            ConfigFormat::Json => serde_json::from_str(&content)?,
            ConfigFormat::Yaml => serde_yaml::from_str(&content)?,
            ConfigFormat::Toml => toml::from_str(&content)?,
        };
        
        self.update_configurations(configs)?;
        self.start_file_watcher(path)?;
        
        Ok(())
    }
    
    /// 更新配置集合
    fn update_configurations(&self, new_configs: HashMap<String, ConfigValue>) -> Result<(), ConfigError> {
        let mut current_configs = self.configs.write().unwrap();
        
        // 验证所有新配置
        for (key, config) in &new_configs {
            config.validate()
                .map_err(|e| ConfigError::InvalidFormat(format!("Validation error in {}: {}", key, e)))?;
        }
        
        // 检测变化
        let changes = self.detect_changes(&current_configs, &new_configs);
        
        // 更新配置
        *current_configs = new_configs;
        
        // 发送变化通知
        if let Some(ref sender) = self.change_sender {
            for change in changes {
                if let Err(e) = sender.send(change) {
                    error!(self.logger, "Failed to send change event: {}", e);
                }
            }
        }
        
        // 通知所有监听器
        self.notify_watchers(&current_configs)?;
        
        Ok(())
    }
    
    /// 检测配置变化
    fn detect_changes(
        &self,
        current: &HashMap<String, ConfigValue>,
        new: &HashMap<String, ConfigValue>,
    ) -> Vec<ConfigChangeEvent> {
        let mut changes = Vec::new();
        
        // 检查新增和修改的键
        for (key, new_value) in new {
            match current.get(key) {
                Some(old_value) => {
                    if old_value != new_value {
                        changes.push(ConfigChangeEvent {
                            key: key.clone(),
                            old_value: Some(old_value.clone()),
                            new_value: Some(new_value.clone()),
                            change_type: ChangeType::Modified,
                        });
                    }
                }
                None => {
                    changes.push(ConfigChangeEvent {
                        key: key.clone(),
                        old_value: None,
                        new_value: Some(new_value.clone()),
                        change_type: ChangeType::Added,
                    });
                }
            }
        }
        
        // 检查删除的键
        for key in current.keys() {
            if !new.contains_key(key) {
                changes.push(ConfigChangeEvent {
                    key: key.clone(),
                    old_value: current.get(key).cloned(),
                    new_value: None,
                    change_type: ChangeType::Removed,
                });
            }
        }
        
        changes
    }
    
    /// 获取配置值
    pub fn get<T>(&self, key: &str) -> Result<T, ConfigError>
    where
        T: serde::de::DeserializeOwned,
    {
        let configs = self.configs.read().unwrap();
        let config_value = configs.get(key)
            .ok_or(ConfigError::KeyNotFound(key.to_string()))?;
        
        // 获取实际值（考虑环境变量覆盖）
        let actual_value = config_value.get_actual_value()?;
        let parsed_value: T = serde_json::from_value(actual_value)
            .map_err(|e| ConfigError::TypeConversionError(e.to_string()))?;
        
        Ok(parsed_value)
    }
    
    /// 获取所有配置键
    pub fn keys(&self) -> Vec<String> {
        let configs = self.configs.read().unwrap();
        configs.keys().cloned().collect()
    }
    
    /// 检查配置是否存在
    pub fn has(&self, key: &str) -> bool {
        let configs = self.configs.read().unwrap();
        configs.contains_key(key)
    }
    
    /// 设置配置值
    pub fn set(&mut self, key: String, value: ConfigValue) -> Result<(), ConfigError> {
        value.validate()?;
        
        let mut configs = self.configs.write().unwrap();
        let old_value = configs.get(&key).cloned();
        
        configs.insert(key.clone(), value.clone());
        
        // 发送变化通知
        if let Some(ref sender) = self.change_sender {
            let change = ConfigChangeEvent {
                key: key.clone(),
                old_value,
                new_value: Some(value),
                change_type: if old_value.is_some() { ChangeType::Modified } else { ChangeType::Added },
            };
            
            if let Err(e) = sender.send(change) {
                error!(self.logger, "Failed to send change event: {}", e);
            }
        }
        
        // 通知监听器
        if let Some(watcher) = configs.get(&key) {
            self.notify_single_watcher(&key, watcher)?;
        }
        
        Ok(())
    }
    
    /// 移除配置
    pub fn remove(&mut self, key: &str) -> Result<Option<ConfigValue>, ConfigError> {
        let mut configs = self.configs.write().unwrap();
        let removed_value = configs.remove(key);
        
        if let Some(ref removed) = removed_value {
            // 发送变化通知
            if let Some(ref sender) = self.change_sender {
                let change = ConfigChangeEvent {
                    key: key.to_string(),
                    old_value: Some(removed.clone()),
                    new_value: None,
                    change_type: ChangeType::Removed,
                };
                
                if let Err(e) = sender.send(change) {
                    error!(self.logger, "Failed to send change event: {}", e);
                }
            }
            
            // 通知监听器
            self.notify_watcher_removed(key)?;
        }
        
        Ok(removed_value)
    }
    
    /// 添加监听器
    pub fn add_watcher(&mut self, watcher: Box<dyn ConfigWatcher>) {
        let mut watchers = self.watchers.write().unwrap();
        watchers.push(watcher);
    }
    
    /// 移除监听器
    pub fn remove_watcher(&mut self, index: usize) {
        let mut watchers = self.watchers.write().unwrap();
        if index < watchers.len() {
            watchers.remove(index);
        }
    }
    
    /// 启动文件监视
    fn start_file_watcher<P: AsRef<Path>>(&mut self, path: P) -> Result<(), ConfigError> {
        let path = path.as_ref().to_path_buf();
        let logger = self.logger.clone();
        
        let (tx, rx) = crossbeam::channel::unbounded();
        
        let mut watcher = RecommendedWatcher::new(
            move |result: Result<Event, notify::Error>| {
                if let Ok(event) = result {
                    if event.kind.is_modify() {
                        let _ = tx.send(event);
                    }
                }
            },
            notify::Config::default(),
        )?;
        
        watcher.watch(path.parent().unwrap(), RecursiveMode::NonRecursive)?;
        
        // 启动异步处理
        std::thread::spawn(move || {
            for event in rx {
                info!(logger, "File change detected: {:?}", event.paths);
                
                // 重新加载配置
                // 这里可以添加重试逻辑和错误处理
            }
        });
        
        self.watcher = Some(watcher);
        Ok(())
    }
    
    /// 停止文件监视
    pub fn stop_file_watcher(&mut self) {
        if let Some(mut watcher) = self.watcher.take() {
            let _ = watcher.unwatch(&std::path::Path::new("."));
        }
    }
    
    /// 获取变化事件接收器
    pub fn get_change_receiver(&self) -> Option<Receiver<ConfigChangeEvent>> {
        self.change_sender.as_ref().map(|sender| sender.subscribe())
    }
    
    /// 通知所有监听器
    fn notify_watchers(&self, configs: &HashMap<String, ConfigValue>) -> Result<(), ConfigError> {
        let watchers = self.watchers.read().unwrap();
        let notify_tasks: Vec<_> = watchers
            .par_iter()
            .map(|watcher| {
                for (key, config) in configs {
                    watcher.on_config_change(key, config);
                }
                Ok::<(), ConfigError>(())
            })
            .collect();
        
        for result in notify_tasks {
            result?;
        }
        
        Ok(())
    }
    
    /// 通知单个监听器
    fn notify_single_watcher(&self, key: &str, config: &ConfigValue) -> Result<(), ConfigError> {
        let watchers = self.watchers.read().unwrap();
        for watcher in watchers.iter() {
            watcher.on_config_change(key, config);
        }
        Ok(())
    }
    
    /// 通知监听器配置被移除
    fn notify_watcher_removed(&self, key: &str) -> Result<(), ConfigError> {
        let watchers = self.watchers.read().unwrap();
        for watcher in watchers.iter() {
            watcher.on_config_removed(key);
        }
        Ok(())
    }
    
    /// 导出配置为JSON
    pub fn export_json(&self) -> Result<String, ConfigError> {
        let configs = self.configs.read().unwrap();
        let export_data: HashMap<String, JsonValue> = configs
            .iter()
            .map(|(k, v)| (k.clone(), v.value.clone()))
            .collect();
        
        Ok(serde_json::to_string_pretty(&export_data)?)
    }
    
    /// 验证所有配置
    pub fn validate_all(&self) -> Result<(), ValidationError> {
        let configs = self.configs.read().unwrap();
        for (key, config) in configs {
            if let Err(error) = config.validate() {
                return Err(error);
            }
        }
        Ok(())
    }
}

impl Drop for ConfigManager {
    fn drop(&mut self) {
        self.stop_file_watcher();
    }
}
}

4.6 本章总结

本章深入探讨了Rust中结构体和枚举的强大功能，这是构建复杂应用程序的基础。通过本章的学习，您已经：

掌握了结构体基础：定义了各种类型的结构体，包括元组结构体和泛型结构体
学会了方法设计：区分了关联函数和方法的用法
了解了枚举威力：从简单的枚举到复杂的携带数据的枚举
掌握了模式匹配：学会了使用match表达式进行复杂的模式匹配
构建了实用项目：开发了企业级配置管理工具

结构体和枚举为Rust提供了强大的数据建模能力，使得开发者能够创建类型安全、表达力强的代码。这些概念在实际的Rust开发中无处不在，是掌握Rust编程的必备知识。

4.7 验收标准

完成本章后，您应该能够：

设计合理的结构体来建模业务数据
实现结构体的方法和关联函数
使用枚举精确建模状态和选项
编写复杂的模式匹配代码
实现生产级的配置管理系统
设计可扩展的数据验证框架

4.8 练习题

设计Employee结构体：创建一个Employee结构体，包含姓名、职位、薪资等字段
实现状态机：使用枚举实现一个游戏状态机
配置验证器：为配置系统添加更多验证规则
模式匹配优化：重构代码以使用更简洁的模式匹配
性能对比测试：比较不同数据结构实现的性能差异

4.9 扩展阅读

第五章：泛型与特征

5.1 章节概述

泛型（Generics）和特征（Traits）是Rust语言中最重要的抽象机制之一。它们允许我们编写既灵活又类型安全的代码，通过抽象出通用的算法和数据结构，而不需要为每种具体类型编写重复的代码。

在本章中，我们将通过构建一个通用数据处理与分析框架（dataflow-framework）来深入学习这些概念。这个框架将展示如何在实际项目中应用泛型和特征来创建可扩展、可维护的企业级系统。

学习目标

完成本章学习后，您将能够：

理解泛型的基本概念和语法
掌握特征的定义、实现和使用
学会特征边界和泛型约束
掌握特征对象和动态分发的概念
理解关联类型和泛型关联类型
学会如何使用泛型和特征设计可扩展的架构
构建一个完整的数据处理框架

实战项目预览

本章实战项目将构建一个通用数据处理框架，支持：

多种数据源（文件、数据库、API、实时流）
灵活的数据处理管道
多种输出格式
性能优化和并发处理

5.2 泛型基础

5.2.1 什么是泛型

泛型允许我们编写可以处理多种数据类型的代码，而不需要为每种类型单独实现。通过泛型，我们可以创建：

泛型函数
泛型结构体
泛型枚举
泛型方法

5.2.2 泛型函数

让我们从一个简单的泛型函数开始：

// 泛型函数示例
fn compare<T>(a: T, b: T) -> i32 
where
    T: PartialOrd,
{
    if a < b {
        -1
    } else if a > b {
        1
    } else {
        0
    }
}

// 使用泛型函数
fn main() {
    println!("比较整数: {}", compare(5, 3));  // 输出: 1
    println!("比较浮点数: {}", compare(3.14, 2.71));  // 输出: 1
    println!("比较字符串: {}", compare("abc", "xyz"));  // 输出: -1
}

在上面的例子中：

T 是类型参数，表示函数可以处理任何类型
where T: PartialOrd 是特征边界，指定T必须实现PartialOrd特征
这样函数就能对所有实现了比较操作符的类型工作

5.2.3 泛型结构体

// 泛型结构体
#[derive(Debug, Clone)]
struct Container<T> {
    items: Vec<T>,
    capacity: usize,
}

impl<T> Container<T> {
    fn new(capacity: usize) -> Self {
        Self {
            items: Vec::with_capacity(capacity),
            capacity,
        }
    }
    
    fn push(&mut self, item: T) {
        if self.items.len() < self.capacity {
            self.items.push(item);
        }
    }
    
    fn get(&self, index: usize) -> Option<&T> {
        self.items.get(index)
    }
    
    fn len(&self) -> usize {
        self.items.len()
    }
}

// 泛型结构体的方法
impl<T: std::fmt::Display> Container<T> {
    fn print_all(&self) {
        for item in &self.items {
            println!("{}", item);
        }
    }
}

fn main() {
    let mut int_container = Container::new(3);
    int_container.push(1);
    int_container.push(2);
    int_container.push(3);
    
    println!("整数容器内容: {:?}", int_container.items);
    println!("容器大小: {}", int_container.len());
    
    let mut string_container = Container::new(2);
    string_container.push("hello");
    string_container.push("world");
    string_container.print_all();  // 需要Display trait
}

5.2.4 泛型枚举

// 泛型枚举示例
#[derive(Debug, Clone)]
enum Result<T, E> {
    Ok(T),
    Err(E),
}

#[derive(Debug, Clone)]
enum Option<T> {
    Some(T),
    None,
}

// 实用函数
impl<T, E> Result<T, E> {
    fn is_ok(&self) -> bool {
        matches!(self, Ok(_))
    }
    
    fn is_err(&self) -> bool {
        matches!(self, Err(_))
    }
}

impl<T> Option<T> {
    fn unwrap(self) -> T {
        match self {
            Some(value) => value,
            None => panic!("Called Option::unwrap() on a None value"),
        }
    }
    
    fn unwrap_or(self, default: T) -> T {
        match self {
            Some(value) => value,
            None => default,
        }
    }
}

fn main() {
    let success: Result<i32, &str> = Ok(42);
    let failure: Result<i32, &str> = Err("something went wrong");
    
    let present: Option<i32> = Some(100);
    let absent: Option<i32> = None;
    
    println!("成功: {}, 失败: {}", success.is_ok(), failure.is_err());
    println!("存在: {}, 缺失: {}", present.is_some(), absent.is_none());
    println!("unwrap 结果: {}", present.unwrap());
    println!("unwrap_or 结果: {}", absent.unwrap_or(0));
}

5.3 特征基础

5.3.1 什么是特征

特征（Trait）定义了一组可以由不同类型实现的方法。它们类似于其他语言中的接口，但功能更强大。

5.3.2 定义和使用特征

// 定义一个特征
pub trait Drawable {
    fn draw(&self) -> String;
    
    // 默认实现
    fn area(&self) -> f64 {
        0.0  // 默认面积为0
    }
    
    // 可以有其他方法
    fn is_visible(&self) -> bool {
        true  // 默认可见
    }
}

// 实现特征的类型
struct Circle {
    radius: f64,
}

struct Rectangle {
    width: f64,
    height: f64,
}

struct Triangle {
    base: f64,
    height: f64,
}

// 为每个类型实现Drawable特征
impl Drawable for Circle {
    fn draw(&self) -> String {
        format!("画一个半径为 {} 的圆形", self.radius)
    }
    
    fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

impl Drawable for Rectangle {
    fn draw(&self) -> String {
        format!("画一个 {}x{} 的矩形", self.width, self.height)
    }
    
    fn area(&self) -> f64 {
        self.width * self.height
    }
}

impl Drawable for Triangle {
    fn draw(&self) -> String {
        format!("画一个底边 {}，高 {} 的三角形", self.base, self.height)
    }
    
    fn area(&self) -> f64 {
        (self.base * self.height) / 2.0
    }
}

// 函数接受实现了特征的类型
fn draw_shape<T: Drawable>(shape: &T) {
    println!("{}", shape.draw());
    println!("面积: {:.2}", shape.area());
    println!("可见: {}", shape.is_visible());
    println!("---");
}

fn main() {
    let circle = Circle { radius: 5.0 };
    let rectangle = Rectangle { width: 4.0, height: 6.0 };
    let triangle = Triangle { base: 3.0, height: 4.0 };
    
    draw_shape(&circle);
    draw_shape(&rectangle);
    draw_shape(&triangle);
}

5.3.3 特征作为参数

#![allow(unused)]
fn main() {
// 使用特征作为函数参数
fn summarize_shape(shape: &impl Drawable) -> String {
    format!(
        "这是一个图形，面积是 {:.2}，状态是 {}",
        shape.area(),
        if shape.is_visible() { "可见" } else { "隐藏" }
    )
}

// 多个特征约束
fn create_summary<T: Drawable + Clone>(shape: &T) -> String {
    // 可以调用两个特征的方法
    let original = format!("原始: {}", shape.draw());
    let clone = format!("克隆: {}", shape.clone().draw());
    format!("{}\n{}", original, clone)
}

// 返回实现了特征的类型
fn create_circle() -> impl Drawable {
    Circle { radius: 3.0 }
}

// 泛型约束语法
fn complex_draw<T>(shapes: &[T]) -> Vec<String>
where
    T: Drawable,
{
    shapes.iter().map(|shape| shape.draw()).collect()
}
}

5.3.4 特征与泛型结合

// 泛型特征
trait Calculate {
    type Output;  // 关联类型
    
    fn calculate(&self) -> Self::Output;
}

struct MathOperations<T> {
    value: T,
}

impl<T> Calculate for MathOperations<T>
where
    T: std::ops::Add<Output = T>
    + std::ops::Sub<Output = T>
    + std::ops::Mul<Output = T>
    + Copy,
{
    type Output = T;
    
    fn calculate(&self) -> Self::Output {
        // 使用泛型进行数学运算
        let a = self.value;
        let b = self.value;
        (a + b) * b  // 使用实现了这些运算的类型
    }
}

// 泛型特征约束
fn process_calculate<T>(op: &MathOperations<T>) -> T
where
    T: std::ops::Add<Output = T>
    + std::ops::Sub<Output = T>
    + std::ops::Mul<Output = T>
    + Copy
    + std::fmt::Debug,
{
    let result = op.calculate();
    println!("操作结果: {:?}", result);
    result
}

fn main() {
    let int_op = MathOperations { value: 5 };
    let float_op = MathOperations { value: 3.14 };
    
    let int_result = process_calculate(&int_op);  // 40
    let float_result = process_calculate(&float_op);  // 19.4784
}

5.4 特征边界高级用法

5.4.1 多个特征约束

#![allow(unused)]
fn main() {
// 定义多个特征
trait Printable {
    fn print(&self);
}

trait Cloneable {
    fn clone_me(&self) -> Self;
}

trait Validatable {
    fn is_valid(&self) -> bool;
}

// 使用多个特征约束
fn process_item<T>(item: &T) 
where
    T: Printable + Cloneable + Validatable,
{
    if item.is_valid() {
        item.print();
        let cloned = item.clone_me();
        cloned.print();
    }
}

// 或者使用 + 语法
fn process_item_shorthand<T: Printable + Cloneable + Validatable>(item: &T) {
    // 同样的实现
}

// 复杂约束示例
fn complex_processing<T, U, V>(item1: T, item2: U, item3: V) 
where
    T: std::fmt::Display + Cloneable,
    U: Printable + Validatable,
    V: Cloneable + Validatable + std::fmt::Debug,
{
    println!("项目1: {}", item1);
    if item2.is_valid() {
        item2.print();
    }
    println!("项目3: {:?}", item3);
}
}

5.4.2 特征对象

#![allow(unused)]
fn main() {
// 特征对象允许我们使用不同类型的相同特征
fn demonstrate_trait_objects() {
    let shapes: Vec<Box<dyn Drawable>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Rectangle { width: 2.0, height: 3.0 }),
        Box::new(Triangle { base: 4.0, height: 5.0 }),
    ];
    
    // 动态分派 - 运行时决定调用哪个方法
    for shape in &shapes {
        println!("{}", shape.draw());
        println!("面积: {:.2}", shape.area());
    }
}

// 特征对象的返回类型
fn create_shape(shape_type: &str) -> Box<dyn Drawable> {
    match shape_type {
        "circle" => Box::new(Circle { radius: 2.0 }),
        "rectangle" => Box::new(Rectangle { width: 3.0, height: 4.0 }),
        "triangle" => Box::new(Triangle { base: 5.0, height: 6.0 }),
        _ => Box::new(Circle { radius: 1.0 }),
    }
}

// 特征对象作为参数
fn draw_all_shapes(shapes: &[Box<dyn Drawable>]) {
    for (i, shape) in shapes.iter().enumerate() {
        println!("形状 {}: {}", i + 1, shape.draw());
    }
}
}

5.4.3 特征对象 vs 泛型

// 泛型方式 - 编译时分派，性能更好
fn draw_shapes_generic<T>(shapes: &[T])
where
    T: Drawable,
{
    for shape in shapes {
        shape.draw();
    }
}

// 特征对象方式 - 运行时动态分派，更灵活
fn draw_shapes_trait_object(shapes: &[Box<dyn Drawable>]) {
    for shape in shapes {
        shape.draw();
    }
}

// 使用泛型
fn main() {
    let circles = vec![Circle { radius: 1.0 }, Circle { radius: 2.0 }];
    // draw_shapes_generic(&circles);  // 只处理同一种类型
    
    let mixed_shapes: Vec<Box<dyn Drawable>> = vec![
        Box::new(Circle { radius: 1.0 }),
        Box::new(Rectangle { width: 2.0, height: 3.0 }),
    ];
    // draw_shapes_trait_object(&mixed_shapes);  // 可以处理不同类型
}

5.5 实战项目：数据流框架架构设计

现在让我们开始构建实战项目。首先，我们需要设计数据处理框架的核心架构。

5.5.1 框架概述

我们的数据流框架将使用以下设计模式：

流水线模式：数据从源到处理到输出的完整流程
插件架构：可插拔的处理器和适配器
特征约束：确保组件间的类型安全交互
泛型实现：支持多种数据类型和格式

5.5.2 核心特征设计

#![allow(unused)]
fn main() {
// 核心特征定义
use std::fmt::Debug;
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

// 数据源特征
pub trait DataSource<T> {
    type Error: Debug;
    
    /// 读取所有数据
    fn read(&self) -> Result<Vec<T>, Self::Error>;
    
    /// 读取流数据（用于大文件）
    fn read_stream(&self) -> Result<Box<dyn Iterator<Item = Result<T, Self::Error>>>, Self::Error>;
    
    /// 获取数据计数
    fn count(&self) -> Result<u64, Self::Error>;
    
    /// 检查数据源是否有效
    fn is_valid(&self) -> bool;
}

// 数据处理器特征
pub trait DataProcessor<T, U> {
    type Error: Debug;
    
    /// 批量处理数据
    fn process(&self, data: Vec<T>) -> Result<Vec<U>, Self::Error>;
    
    /// 单项处理数据
    fn process_item(&self, item: T) -> Result<U, Self::Error>;
    
    /// 处理数据流
    fn process_stream(&self, stream: Box<dyn Iterator<Item = T>>) -> Result<Box<dyn Iterator<Item = Result<U, Self::Error>>>, Self::Error>;
    
    /// 获取处理器信息
    fn info(&self) -> ProcessorInfo;
}

// 数据输出特征
pub trait DataSink<T> {
    type Error: Debug;
    
    /// 写入数据
    fn write(&self, data: Vec<T>) -> Result<(), Self::Error>;
    
    /// 写入数据流
    fn write_stream(&self, stream: Box<dyn Iterator<Item = T>>) -> Result<(), Self::Error>;
    
    /// 刷新输出
    fn flush(&self) -> Result<(), Self::Error>;
    
    /// 获取输出统计
    fn stats(&self) -> SinkStats;
}

// 处理器信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProcessorInfo {
    pub name: String,
    pub version: String,
    pub description: String,
    pub input_type: String,
    pub output_type: String,
    pub performance_metrics: PerformanceMetrics,
}

// 性能指标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceMetrics {
    pub processing_time_ms: u64,
    pub throughput_items_per_second: f64,
    pub memory_usage_mb: f64,
}

// 接收器统计
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SinkStats {
    pub total_written: u64,
    pub write_time_ms: u64,
    pub last_write: Option<std::time::SystemTime>,
}
}

5.5.3 数据管道实现

#![allow(unused)]
fn main() {
// 数据管道
pub struct DataPipeline<S, P, K> 
where
    S: DataSource<serde_json::Value>,
    P: DataProcessor<serde_json::Value, serde_json::Value>,
    K: DataSink<serde_json::Value>,
{
    source: S,
    processor: P,
    sink: K,
    config: PipelineConfig,
    metrics: PipelineMetrics,
}

#[derive(Debug, Clone)]
pub struct PipelineConfig {
    pub batch_size: usize,
    pub parallel_processing: bool,
    pub max_concurrency: usize,
    pub enable_cache: bool,
    pub cache_ttl_seconds: u64,
    pub retry_attempts: u32,
    pub timeout_seconds: u64,
}

#[derive(Debug, Clone)]
pub struct PipelineMetrics {
    pub start_time: std::time::Instant,
    pub items_processed: u64,
    pub items_failed: u64,
    pub bytes_processed: u64,
    pub total_time_ms: u64,
}

impl Default for PipelineConfig {
    fn default() -> Self {
        Self {
            batch_size: 1000,
            parallel_processing: true,
            max_concurrency: 4,
            enable_cache: true,
            cache_ttl_seconds: 3600,
            retry_attempts: 3,
            timeout_seconds: 300,
        }
    }
}

impl Default for PipelineMetrics {
    fn default() -> Self {
        Self {
            start_time: std::time::Instant::now(),
            items_processed: 0,
            items_failed: 0,
            bytes_processed: 0,
            total_time_ms: 0,
        }
    }
}

impl<S, P, K> DataPipeline<S, P, K> 
where
    S: DataSource<serde_json::Value>,
    P: DataProcessor<serde_json::Value, serde_json::Value>,
    K: DataSink<serde_json::Value>,
{
    /// 创建新的数据管道
    pub fn new(source: S, processor: P, sink: K) -> Self {
        Self {
            source,
            processor,
            sink,
            config: PipelineConfig::default(),
            metrics: PipelineMetrics::default(),
        }
    }
    
    /// 使用自定义配置创建管道
    pub fn with_config(source: S, processor: P, sink: K, config: PipelineConfig) -> Self {
        Self {
            source,
            processor,
            sink,
            config,
            metrics: PipelineMetrics::default(),
        }
    }
    
    /// 运行数据处理管道
    pub async fn run(&mut self) -> Result<PipelineMetrics, PipelineError> {
        println!("开始运行数据处理管道...");
        
        let start_time = std::time::Instant::now();
        
        // 验证组件
        self.validate_pipeline()?;
        
        // 选择处理模式
        if self.config.parallel_processing {
            self.run_parallel().await
        } else {
            self.run_sequential().await
        }?;
        
        // 更新指标
        self.metrics.total_time_ms = start_time.elapsed().as_millis() as u64;
        
        println!("管道运行完成，处理了 {} 项数据", self.metrics.items_processed);
        Ok(self.metrics.clone())
    }
    
    /// 顺序执行处理
    async fn run_sequential(&mut self) -> Result<(), PipelineError> {
        // 读取数据
        let data = self.source.read()
            .map_err(PipelineError::SourceError)?;
        
        if data.is_empty() {
            println!("没有数据需要处理");
            return Ok(());
        }
        
        println!("读取到 {} 项数据", data.len());
        
        // 批量处理数据
        let chunks = data.chunks(self.config.batch_size);
        
        for (chunk_index, chunk) in chunks.enumerate() {
            let chunk_vec: Vec<_> = chunk.to_vec();
            
            // 处理数据块
            let processed = self.processor.process(chunk_vec)
                .map_err(PipelineError::ProcessorError)?;
            
            // 输出结果
            self.sink.write(processed)
                .map_err(PipelineError::SinkError)?;
            
            // 更新统计
            self.metrics.items_processed += chunk_vec.len() as u64;
            
            // 进度报告
            if (chunk_index + 1) % 10 == 0 {
                println!("已处理 {} 个批次", chunk_index + 1);
            }
        }
        
        // 刷新输出
        self.sink.flush()
            .map_err(PipelineError::SinkError)?;
            
        Ok(())
    }
    
    /// 并行执行处理
    async fn run_parallel(&mut self) -> Result<(), PipelineError> {
        use tokio::task;
        use std::sync::Arc;
        
        // 读取数据
        let data = self.source.read()
            .map_err(PipelineError::SourceError)?;
        
        if data.is_empty() {
            println!("没有数据需要处理");
            return Ok(());
        }
        
        // 分块处理
        let chunks: Vec<_> = data.chunks(self.config.batch_size)
            .map(|chunk| chunk.to_vec())
            .collect();
        
        println!("开始并行处理 {} 个数据块", chunks.len());
        
        // 并行处理数据块
        let mut handles = Vec::new();
        let max_concurrency = self.config.max_concurrency;
        
        for chunk in chunks {
            if handles.len() >= max_concurrency {
                // 等待一个任务完成
                let handle = handles.remove(0);
                handle.await.map_err(|_| PipelineError::TaskJoinError)?;
            }
            
            let processor = self.processor;
            let sink = &self.sink;
            let config = self.config.clone();
            
            let handle = task::spawn(async move {
                // 处理数据
                let processed = processor.process(chunk)
                    .map_err(PipelineError::ProcessorError)?;
                
                // 写入结果
                sink.write(processed)
                    .map_err(PipelineError::SinkError)?;
                
                Ok(())
            });
            
            handles.push(handle);
        }
        
        // 等待所有任务完成
        for handle in handles {
            handle.await.map_err(|_| PipelineError::TaskJoinError)??;
        }
        
        // 刷新输出
        self.sink.flush()
            .map_err(PipelineError::SinkError)?;
            
        self.metrics.items_processed = data.len() as u64;
        Ok(())
    }
    
    /// 验证管道组件
    fn validate_pipeline(&self) -> Result<(), PipelineError> {
        // 验证源数据源
        if !self.source.is_valid() {
            return Err(PipelineError::SourceInvalid);
        }
        
        // 验证处理器信息
        let info = self.processor.info();
        if info.input_type.is_empty() || info.output_type.is_empty() {
            return Err(PipelineError::InvalidProcessorInfo);
        }
        
        Ok(())
    }
    
    /// 获取管道状态
    pub fn get_status(&self) -> PipelineStatus {
        PipelineStatus {
            is_running: false, // 简化为非运行状态
            items_processed: self.metrics.items_processed,
            items_failed: self.metrics.items_failed,
            total_time_ms: self.metrics.total_time_ms,
            throughput_per_second: if self.metrics.total_time_ms > 0 {
                (self.metrics.items_processed as f64) / (self.metrics.total_time_ms as f64 / 1000.0)
            } else {
                0.0
            },
        }
    }
}

/// 管道状态
#[derive(Debug, Clone)]
pub struct PipelineStatus {
    pub is_running: bool,
    pub items_processed: u64,
    pub items_failed: u64,
    pub total_time_ms: u64,
    pub throughput_per_second: f64,
}

/// 管道错误
#[derive(Debug, thiserror::Error)]
pub enum PipelineError {
    #[error("源数据源错误: {0}")]
    SourceError(#[source] Box<dyn std::error::Error>),
    
    #[error("数据处理器错误: {0}")]
    ProcessorError(#[source] Box<dyn std::error::Error>),
    
    #[error("数据接收器错误: {0}")]
    SinkError(#[source] Box<dyn std::error::Error>),
    
    #[error("任务Join错误")]
    TaskJoinError,
    
    #[error("源数据源无效")]
    SourceInvalid,
    
    #[error("处理器信息无效")]
    InvalidProcessorInfo,
    
    #[error("配置错误: {0}")]
    ConfigError(String),
}
}

5.6 具体实现：CSV数据源

现在让我们实现一个具体的CSV数据源来演示如何使用这些特征。

#![allow(unused)]
fn main() {
// CSV数据源实现
use csv::Reader;
use serde_json::{Value, Map, Number};
use std::fs::File;
use std::path::Path;
use std::io::BufReader;
use std::io::Read;

/// CSV数据源
pub struct CsvDataSource {
    path: PathBuf,
    delimiter: char,
    has_header: bool,
    encoding: String,
    buffer_size: usize,
}

impl CsvDataSource {
    /// 创建新的CSV数据源
    pub fn new<P: Into<PathBuf>>(path: P) -> Self {
        Self {
            path: path.into(),
            delimiter: ',',
            has_header: true,
            encoding: "UTF-8".to_string(),
            buffer_size: 8192,
        }
    }
    
    /// 设置分隔符
    pub fn delimiter(mut self, delimiter: char) -> Self {
        self.delimiter = delimiter;
        self
    }
    
    /// 设置是否包含标题行
    pub fn has_header(mut self, has_header: bool) -> Self {
        self.has_header = has_header;
        self
    }
    
    /// 设置编码
    pub fn encoding(mut self, encoding: &str) -> Self {
        self.encoding = encoding.to_string();
        self
    }
    
    /// 设置缓冲区大小
    pub fn buffer_size(mut self, buffer_size: usize) -> Self {
        self.buffer_size = buffer_size;
        self
    }
}

impl DataSource<Value> for CsvDataSource {
    type Error = CsvError;
    
    fn read(&self) -> Result<Vec<Value>, Self::Error> {
        // 打开文件
        let file = File::open(&self.path)
            .map_err(|e| CsvError::FileOpenError(e))?;
        
        // 创建CSV读取器
        let mut reader = Reader::new(BufReader::new(file))
            .delimiter(self.delimiter as u8);
        
        let mut records = Vec::new();
        
        if self.has_header {
            self.read_with_header(&mut reader, &mut records)?;
        } else {
            self.read_without_header(&mut reader, &mut records)?;
        }
        
        Ok(records)
    }
    
    fn read_stream(&self) -> Result<Box<dyn Iterator<Item = Result<Value, Self::Error>>>, Self::Error> {
        // 创建流式读取器
        let file = File::open(&self.path)
            .map_err(|e| CsvError::FileOpenError(e))?;
        
        let mut reader = Reader::new(BufReader::new(file))
            .delimiter(self.delimiter as u8);
        
        if self.has_header {
            let headers = reader.headers()
                .map_err(|e| CsvError::ReadError(e))?
                .iter()
                .map(|h| h.to_string())
                .collect::<Vec<_>>();
            
            Ok(Box::new(CsvRecordIterator {
                reader: Some(reader),
                headers: Some(headers),
                has_header: true,
                finished: false,
            }))
        } else {
            Ok(Box::new(CsvRecordIterator {
                reader: Some(reader),
                headers: None,
                has_header: false,
                finished: false,
            }))
        }
    }
    
    fn count(&self) -> Result<u64, Self::Error> {
        let mut count = 0u64;
        let file = File::open(&self.path)
            .map_err(|e| CsvError::FileOpenError(e))?;
        
        let mut reader = Reader::new(BufReader::new(file))
            .delimiter(self.delimiter as u8);
        
        if self.has_header {
            // 跳过标题行
            for _ in reader.records() {
                count += 1;
            }
        } else {
            for _ in reader.records() {
                count += 1;
            }
        }
        
        Ok(count)
    }
    
    fn is_valid(&self) -> bool {
        self.path.exists() && 
        self.path.is_file() && 
        self.path.extension()
            .map(|ext| ext == "csv" || ext == "tsv")
            .unwrap_or(false)
    }
}

impl CsvDataSource {
    /// 读取带标题的CSV
    fn read_with_header(
        &self, 
        reader: &mut Reader<BufReader<File>>, 
        records: &mut Vec<Value>
    ) -> Result<(), CsvError> {
        // 读取标题行
        let headers = reader.headers()
            .map_err(|e| CsvError::ReadError(e))?
            .iter()
            .map(|h| h.to_string())
            .collect::<Vec<_>>();
        
        // 读取数据记录
        for result in reader.records() {
            let record = result.map_err(|e| CsvError::ReadError(e))?;
            
            // 将记录转换为JSON对象
            let mut obj = Map::new();
            for (i, field) in record.iter().enumerate() {
                if i < headers.len() {
                    // 尝试解析为数字或布尔值
                    let value = if field == "true" {
                        Value::Bool(true)
                    } else if field == "false" {
                        Value::Bool(false)
                    } else if let Ok(num) = field.parse::<i64>() {
                        Value::Number(Number::from(num))
                    } else if let Ok(num) = field.parse::<f64>() {
                        Value::Number(Number::from_f64(num).unwrap())
                    } else {
                        Value::String(field.to_string())
                    };
                    obj.insert(headers[i].clone(), value);
                }
            }
            
            records.push(Value::Object(obj));
        }
        
        Ok(())
    }
    
    /// 读取无标题的CSV
    fn read_without_header(
        &self, 
        reader: &mut Reader<BufReader<File>>, 
        records: &mut Vec<Value>
    ) -> Result<(), CsvError> {
        for result in reader.records() {
            let record = result.map_err(|e| CsvError::ReadError(e))?;
            
            // 将记录转换为JSON数组
            let mut array = Vec::new();
            for field in record.iter() {
                // 尝试解析为数字或布尔值
                let value = if field == "true" {
                    Value::Bool(true)
                } else if field == "false" {
                    Value::Bool(false)
                } else if let Ok(num) = field.parse::<i64>() {
                    Value::Number(Number::from(num))
                } else if let Ok(num) = field.parse::<f64>() {
                    Value::Number(Number::from_f64(num).unwrap())
                } else {
                    Value::String(field.to_string())
                };
                array.push(value);
            }
            
            records.push(Value::Array(array));
        }
        
        Ok(())
    }
}

/// CSV记录迭代器（流式读取）
struct CsvRecordIterator<R: Read> {
    reader: Option<Reader<BufReader<R>>>,
    headers: Option<Vec<String>>,
    has_header: bool,
    finished: bool,
}

impl<R: Read> Iterator for CsvRecordIterator<R> {
    type Item = Result<Value, CsvError>;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.finished || self.reader.is_none() {
            return None;
        }
        
        let reader = self.reader.as_mut()?;
        let headers = self.headers.as_ref();
        
        match reader.records().next() {
            Some(Ok(record)) => {
                // 将记录转换为Value
                if self.has_header {
                    if let Some(headers) = headers {
                        let mut obj = Map::new();
                        for (i, field) in record.iter().enumerate() {
                            if i < headers.len() {
                                let value = if field == "true" {
                                    Value::Bool(true)
                                } else if field == "false" {
                                    Value::Bool(false)
                                } else if let Ok(num) = field.parse::<i64>() {
                                    Value::Number(Number::from(num))
                                } else if let Ok(num) = field.parse::<f64>() {
                                    Value::Number(Number::from_f64(num).unwrap())
                                } else {
                                    Value::String(field.to_string())
                                };
                                obj.insert(headers[i].clone(), value);
                            }
                        }
                        Some(Ok(Value::Object(obj)))
                    } else {
                        Some(Ok(Value::Array(Vec::new())))
                    }
                } else {
                    let mut array = Vec::new();
                    for field in record.iter() {
                        let value = if field == "true" {
                            Value::Bool(true)
                        } else if field == "false" {
                            Value::Bool(false)
                        } else if let Ok(num) = field.parse::<i64>() {
                            Value::Number(Number::from(num))
                        } else if let Ok(num) = field.parse::<f64>() {
                            Value::Number(Number::from_f64(num).unwrap())
                        } else {
                            Value::String(field.to_string())
                        };
                        array.push(value);
                    }
                    Some(Ok(Value::Array(array)))
                }
            }
            Some(Err(e)) => Some(Err(CsvError::ReadError(e))),
            None => {
                self.finished = true;
                self.reader = None;
                None
            }
        }
    }
}

/// CSV错误类型
#[derive(Debug, thiserror::Error)]
pub enum CsvError {
    #[error("文件打开错误: {0}")]
    FileOpenError(std::io::Error),
    
    #[error("读取错误: {0}")]
    ReadError(csv::Error),
    
    #[error("编码错误: {0}")]
    EncodingError(String),
    
    #[error("格式错误: {0}")]
    FormatError(String),
    
    #[error("IO错误: {0}")]
    IoError(#[from] std::io::Error),
}
}

5.7 数据处理器实现

接下来实现一个数据处理器，用于转换和验证数据。

#![allow(unused)]
fn main() {
// 数据处理器实现
use std::collections::HashMap;

/// 数据转换处理器
pub struct DataTransformProcessor {
    transformations: Vec<DataTransform>,
    validations: Vec<DataValidation>,
    filters: Vec<DataFilter>,
    config: TransformConfig,
}

#[derive(Debug, Clone)]
pub struct TransformConfig {
    pub fail_on_error: bool,
    pub continue_on_warning: bool,
    pub max_errors: usize,
    pub enable_logging: bool,
}

impl Default for TransformConfig {
    fn default() -> Self {
        Self {
            fail_on_error: true,
            continue_on_warning: true,
            max_errors: 100,
            enable_logging: true,
        }
    }
}

/// 数据转换操作
#[derive(Debug, Clone)]
pub enum DataTransform {
    /// 字段重命名
    RenameField { from: String, to: String },
    /// 字段类型转换
    ConvertType { field: String, to_type: FieldType },
    /// 字段计算
    ComputeField { 
        target: String, 
        operation: ComputeOperation 
    },
    /// 字段映射
    MapField { 
        field: String, 
        mapping: HashMap<String, String> 
    },
    /// 添加常量
    AddConstant { field: String, value: Value },
    /// 删除字段
    RemoveField(String),
    /// JSON路径操作
    JsonPath { path: String, operation: JsonPathOperation },
}

/// 字段类型
#[derive(Debug, Clone)]
pub enum FieldType {
    String,
    Integer,
    Float,
    Boolean,
    DateTime,
    Email,
    Url,
}

/// 计算操作
#[derive(Debug, Clone)]
pub enum ComputeOperation {
    /// 数值运算
    Math { operation: MathOperation, operands: Vec<String> },
    /// 字符串操作
    String { operation: StringOperation, source_field: String },
    /// 条件计算
    Conditional { condition: Condition, then_value: Value, else_value: Option<Value> },
    /// 聚合操作
    Aggregate { operation: AggregateOperation, group_by: Vec<String> },
}

/// 数学运算
#[derive(Debug, Clone)]
pub enum MathOperation {
    Add,
    Subtract,
    Multiply,
    Divide,
    Modulo,
    Power,
}

/// 字符串操作
#[derive(Debug, Clone)]
pub enum StringOperation {
    Uppercase,
    Lowercase,
    Trim,
    Replace { from: String, to: String },
    Substring { start: usize, length: Option<usize> },
    Length,
    Contains(String),
    StartsWith(String),
    EndsWith(String),
}

/// 条件
#[derive(Debug, Clone)]
pub struct Condition {
    pub field: String,
    pub operator: ConditionOperator,
    pub value: Value,
}

#[derive(Debug, Clone)]
pub enum ConditionOperator {
    Equals,
    NotEquals,
    GreaterThan,
    LessThan,
    GreaterEqual,
    LessEqual,
    Contains,
    In(Vec<Value>),
    NotIn(Vec<Value>),
    IsNull,
    IsNotNull,
}

/// 聚合操作
#[derive(Debug, Clone)]
pub enum AggregateOperation {
    Count,
    Sum,
    Average,
    Min,
    Max,
}

/// JSON路径操作
#[derive(Debug, Clone)]
pub enum JsonPathOperation {
    Get(String),
    Set(String, Value),
    Delete(String),
    Exists(String),
}

/// 数据验证规则
#[derive(Debug, Clone)]
pub enum DataValidation {
    Required { fields: Vec<String> },
    TypeCheck { field: String, expected_type: FieldType },
    Range { field: String, min: Option<Value>, max: Option<Value> },
    Pattern { field: String, pattern: String },
    Unique { field: String },
    Custom { field: String, rule: String },
}

/// 数据过滤规则
#[derive(Debug, Clone)]
pub enum DataFilter {
    Include { condition: Condition },
    Exclude { condition: Condition },
    FieldPresence { field: String, present: bool },
}

impl DataTransformProcessor {
    /// 创建新的转换处理器
    pub fn new() -> Self {
        Self {
            transformations: Vec::new(),
            validations: Vec::new(),
            filters: Vec::new(),
            config: TransformConfig::default(),
        }
    }
    
    /// 添加转换操作
    pub fn add_transform(mut self, transform: DataTransform) -> Self {
        self.transformations.push(transform);
        self
    }
    
    /// 添加验证规则
    pub fn add_validation(mut self, validation: DataValidation) -> Self {
        self.validations.push(validation);
        self
    }
    
    /// 添加过滤规则
    pub fn add_filter(mut self, filter: DataFilter) -> Self {
        self.filters.push(filter);
        self
    }
    
    /// 设置配置
    pub fn with_config(mut self, config: TransformConfig) -> Self {
        self.config = config;
        self
    }
    
    /// 检查数据是否通过过滤
    fn passes_filters(&self, data: &Value) -> bool {
        for filter in &self.filters {
            if !self.apply_filter(filter, data) {
                return false;
            }
        }
        true
    }
    
    /// 应用单个过滤器
    fn apply_filter(&self, filter: &DataFilter, data: &Value) -> bool {
        match filter {
            DataFilter::Include { condition } => self.evaluate_condition(condition, data),
            DataFilter::Exclude { condition } => !self.evaluate_condition(condition, data),
            DataFilter::FieldPresence { field, present } => {
                let has_field = self.has_field(data, field);
                has_field == *present
            }
        }
    }
    
    /// 评估条件
    fn evaluate_condition(&self, condition: &Condition, data: &Value) -> bool {
        let field_value = self.get_field_value(data, &condition.field);
        
        match condition.operator {
            ConditionOperator::Equals => field_value == Some(condition.value.clone()),
            ConditionOperator::NotEquals => field_value != Some(condition.value.clone()),
            ConditionOperator::IsNull => field_value.is_none(),
            ConditionOperator::IsNotNull => field_value.is_some(),
            _ => {
                // 数值比较和其他操作
                if let (Some(Value::Number(lhs)), Some(Value::Number(rhs))) = (field_value, Some(condition.value.clone())) {
                    match condition.operator {
                        ConditionOperator::GreaterThan => lhs.as_f64() > rhs.as_f64(),
                        ConditionOperator::LessThan => lhs.as_f64() < rhs.as_f64(),
                        ConditionOperator::GreaterEqual => lhs.as_f64() >= rhs.as_f64(),
                        ConditionOperator::LessEqual => lhs.as_f64() <= rhs.as_f64(),
                        _ => false,
                    }
                } else {
                    false
                }
            }
        }
    }
    
    /// 获取字段值
    fn get_field_value(&self, data: &Value, field: &str) -> Option<Value> {
        match data {
            Value::Object(obj) => obj.get(field).cloned(),
            Value::Array(arr) => {
                if let Ok(index) = field.parse::<usize>() {
                    arr.get(index).cloned()
                } else {
                    None
                }
            }
            _ => None,
        }
    }
    
    /// 检查字段是否存在
    fn has_field(&self, data: &Value, field: &str) -> bool {
        self.get_field_value(data, field).is_some()
    }
    
    /// 应用所有转换
    fn apply_transformations(&self, mut data: Value) -> Result<Value, TransformError> {
        for transform in &self.transformations {
            data = self.apply_transform(transform, data)?;
        }
        Ok(data)
    }
    
    /// 应用单个转换
    fn apply_transform(&self, transform: &DataTransform, data: Value) -> Result<Value, TransformError> {
        match transform {
            DataTransform::RenameField { from, to } => {
                if let Value::Object(ref mut obj) = data {
                    if let Some(value) = obj.remove(from) {
                        obj.insert(to.clone(), value);
                    }
                    Ok(data)
                } else {
                    Err(TransformError::InvalidOperation("Cannot rename field in non-object data".to_string()))
                }
            }
            
            DataTransform::ConvertType { field, to_type } => {
                if let Value::Object(ref mut obj) = data {
                    if let Some(value) = obj.get_mut(field) {
                        *value = self.convert_type(value.clone(), to_type)?;
                    }
                    Ok(data)
                } else {
                    Err(TransformError::InvalidOperation("Cannot convert type in non-object data".to_string()))
                }
            }
            
            DataTransform::AddConstant { field, value } => {
                if let Value::Object(ref mut obj) = data {
                    obj.insert(field.clone(), value.clone());
                    Ok(data)
                } else {
                    Err(TransformError::InvalidOperation("Cannot add constant to non-object data".to_string()))
                }
            }
            
            DataTransform::RemoveField(field_name) => {
                if let Value::Object(ref mut obj) = data {
                    obj.remove(field_name);
                    Ok(data)
                } else {
                    Err(TransformError::InvalidOperation("Cannot remove field from non-object data".to_string()))
                }
            }
            
            _ => {
                // 简化实现，其他转换类型
                Ok(data)
            }
        }
    }
    
    /// 类型转换
    fn convert_type(&self, value: Value, to_type: &FieldType) -> Result<Value, TransformError> {
        match to_type {
            FieldType::String => {
                let string_value = match value {
                    Value::Number(n) => n.to_string(),
                    Value::Bool(b) => b.to_string(),
                    Value::Null => "null".to_string(),
                    Value::String(s) => s,
                    Value::Array(_) | Value::Object(_) => {
                        return Err(TransformError::TypeConversionError("Cannot convert complex type to string".to_string()))
                    }
                };
                Ok(Value::String(string_value))
            }
            
            FieldType::Integer => {
                match value {
                    Value::String(s) => {
                        if let Ok(num) = s.parse::<i64>() {
                            Ok(Value::Number(serde_json::Number::from(num)))
                        } else {
                            Err(TransformError::TypeConversionError("Cannot convert string to integer".to_string()))
                        }
                    }
                    Value::Number(n) => {
                        if n.is_i64() {
                            Ok(Value::Number(n))
                        } else {
                            Err(TransformError::TypeConversionError("Cannot convert float to integer".to_string()))
                        }
                    }
                    Value::Bool(b) => Ok(Value::Number(serde_json::Number::from(if b { 1 } else { 0 }))),
                    _ => Err(TransformError::TypeConversionError("Invalid type conversion".to_string())),
                }
            }
            
            FieldType::Boolean => {
                match value {
                    Value::String(s) => Ok(Value::Bool(s.parse::<bool>().unwrap_or(false))),
                    Value::Number(n) => Ok(Value::Bool(n.as_i64() != Some(0))),
                    Value::Bool(b) => Ok(Value::Bool(b)),
                    _ => Err(TransformError::TypeConversionError("Invalid type conversion to boolean".to_string())),
                }
            }
            
            _ => Ok(value), // 简化实现
        }
    }
}

impl DataProcessor<Value, Value> for DataTransformProcessor {
    type Error = TransformError;
    
    fn process(&self, data: Vec<Value>) -> Result<Vec<Value>, Self::Error> {
        let mut results = Vec::with_capacity(data.len());
        let mut error_count = 0;
        
        for item in data {
            // 检查是否通过过滤器
            if !self.passes_filters(&item) {
                continue;
            }
            
            // 应用转换
            match self.apply_transformations(item) {
                Ok(transformed) => {
                    results.push(transformed);
                }
                Err(e) => {
                    error_count += 1;
                    
                    if self.config.fail_on_error && error_count > self.config.max_errors {
                        return Err(e);
                    }
                    
                    if self.config.enable_logging {
                        eprintln!("转换错误: {:?}", e);
                    }
                    
                    if self.config.fail_on_error {
                        return Err(e);
                    }
                }
            }
        }
        
        Ok(results)
    }
    
    fn process_item(&self, item: Value) -> Result<Value, Self::Error> {
        if !self.passes_filters(&item) {
            return Err(TransformError::FilteredOut("Item filtered out".to_string()));
        }
        
        self.apply_transformations(item)
    }
    
    fn process_stream(&self, stream: Box<dyn Iterator<Item = Value>>) -> Result<Box<dyn Iterator<Item = Result<Value, Self::Error>>>, Self::Error> {
        let processor = self.clone();
        let config = self.config.clone();
        
        Ok(Box::new(stream.map(move |item| {
            if !processor.passes_filters(&item) {
                return Ok(item); // 保留原始数据或根据需求过滤
            }
            
            match processor.apply_transformations(item) {
                Ok(transformed) => Ok(transformed),
                Err(e) => {
                    if config.fail_on_error {
                        Err(e)
                    } else {
                        Ok(item) // 返回原始数据
                    }
                }
            }
        })))
    }
    
    fn info(&self) -> ProcessorInfo {
        ProcessorInfo {
            name: "DataTransformProcessor".to_string(),
            version: "1.0.0".to_string(),
            description: "数据转换和验证处理器".to_string(),
            input_type: "serde_json::Value".to_string(),
            output_type: "serde_json::Value".to_string(),
            performance_metrics: PerformanceMetrics {
                processing_time_ms: 0,
                throughput_items_per_second: 0.0,
                memory_usage_mb: 0.0,
            },
        }
    }
}

/// 转换错误
#[derive(Debug, thiserror::Error)]
pub enum TransformError {
    #[error("类型转换错误: {0}")]
    TypeConversionError(String),
    
    #[error("无效操作: {0}")]
    InvalidOperation(String),
    
    #[error("验证错误: {0}")]
    ValidationError(String),
    
    #[error("字段错误: {0}")]
    FieldError(String),
    
    #[error("被过滤: {0}")]
    FilteredOut(String),
    
    #[error("处理错误: {0}")]
    ProcessingError(String),
}
}

5.8 数据输出实现

现在实现一个文件输出处理器：

#![allow(unused)]
fn main() {
// 数据输出实现
use serde_json::{Value, Map, Number};
use std::fs::File;
use std::io::Write;
use std::path::Path;

/// JSON文件输出处理器
pub struct JsonFileSink {
    path: PathBuf,
    format: OutputFormat,
    config: OutputConfig,
    stats: SinkStats,
    buffer: Vec<Value>,
    buffer_size: usize,
}

#[derive(Debug, Clone)]
pub enum OutputFormat {
    /// 标准JSON格式
    Json {
        pretty: bool,
        pretty_indent: usize,
    },
    /// NDJSON (每行一个JSON对象)
    Ndjson,
    /// 压缩JSON
    JsonCompressed {
        compression: CompressionType,
    },
    /// CSV格式
    Csv {
        delimiter: char,
        has_header: bool,
        include_nulls: bool,
    },
}

#[derive(Debug, Clone)]
pub enum CompressionType {
    None,
    Gzip,
    Zstd,
    Bzip2,
}

#[derive(Debug, Clone)]
pub struct OutputConfig {
    pub buffer_size: usize,
    pub auto_flush: bool,
    pub create_dirs: bool,
    pub overwrite_existing: bool,
    pub encoding: String,
}

impl Default for OutputConfig {
    fn default() -> Self {
        Self {
            buffer_size: 1000,
            auto_flush: true,
            create_dirs: true,
            overwrite_existing: false,
            encoding: "UTF-8".to_string(),
        }
    }
}

impl JsonFileSink {
    /// 创建新的JSON文件输出
    pub fn new<P: Into<PathBuf>>(path: P) -> Self {
        Self {
            path: path.into(),
            format: OutputFormat::Json { pretty: true, pretty_indent: 2 },
            config: OutputConfig::default(),
            stats: SinkStats {
                total_written: 0,
                write_time_ms: 0,
                last_write: None,
            },
            buffer: Vec::new(),
            buffer_size: 0,
        }
    }
    
    /// 设置输出格式
    pub fn format(mut self, format: OutputFormat) -> Self {
        self.format = format;
        self
    }
    
    /// 设置配置
    pub fn with_config(mut self, config: OutputConfig) -> Self {
        self.config = config;
        self
    }
    
    /// 创建目录
    fn create_directories(&self) -> Result<(), SinkError> {
        if let Some(parent) = self.path.parent() {
            if !parent.exists() {
                std::fs::create_dir_all(parent)
                    .map_err(|e| SinkError::IoError(e))?;
            }
        }
        Ok(())
    }
    
    /// 打开文件（如果需要的话）
    fn open_file(&self) -> Result<File, SinkError> {
        let file = if self.config.overwrite_existing {
            File::create(&self.path)
        } else {
            File::options()
                .write(true)
                .create_new(true)
                .open(&self.path)
        };
        
        file.map_err(|e| SinkError::FileOpenError(e))
    }
    
    /// 写入单个记录
    fn write_record(&mut self, record: &Value) -> Result<(), SinkError> {
        let start_time = std::time::Instant::now();
        
        // 格式化数据
        let formatted = match &self.format {
            OutputFormat::Json { pretty, indent } => {
                if *pretty {
                    serde_json::to_string_pretty(record)
                } else {
                    serde_json::to_string(record)
                }
                .map_err(|e| SinkError::SerializationError(e))?
            }
            OutputFormat::Ndjson => {
                serde_json::to_string(record)
                    .map_err(|e| SinkError::SerializationError(e))?
            }
            OutputFormat::JsonCompressed { .. } => {
                // 简化实现，实际应该压缩
                serde_json::to_string(record)
                    .map_err(|e| SinkError::SerializationError(e))?
            }
            OutputFormat::Csv { .. } => {
                self.convert_to_csv_line(record)?
            }
        };
        
        // 写入文件（这里简化实现，实际应该保持文件句柄）
        let mut file = self.open_file()?;
        writeln!(file, "{}", formatted)
            .map_err(|e| SinkError::WriteError(e))?;
        
        // 更新统计
        self.stats.total_written += 1;
        self.stats.write_time_ms += start_time.elapsed().as_millis() as u64;
        self.stats.last_write = Some(std::time::SystemTime::now());
        
        Ok(())
    }
    
    /// 转换为CSV行
    fn convert_to_csv_line(&self, record: &Value) -> Result<String, SinkError> {
        match record {
            Value::Object(obj) => {
                // 对象转换为CSV行
                let mut values = Vec::new();
                for (_, value) in obj {
                    let csv_value = match value {
                        Value::Null => "".to_string(),
                        Value::String(s) => s.clone(),
                        Value::Number(n) => n.to_string(),
                        Value::Bool(b) => b.to_string(),
                        Value::Array(_) | Value::Object(_) => {
                            return Err(SinkError::ConversionError("Complex types not supported in CSV".to_string()))
                        }
                    };
                    values.push(csv_value);
                }
                Ok(values.join(","))
            }
            Value::Array(arr) => {
                // 数组直接转换为CSV行
                let mut values = Vec::new();
                for value in arr {
                    let csv_value = match value {
                        Value::Null => "".to_string(),
                        Value::String(s) => s.clone(),
                        Value::Number(n) => n.to_string(),
                        Value::Bool(b) => b.to_string(),
                        Value::Array(_) | Value::Object(_) => {
                            return Err(SinkError::ConversionError("Complex types not supported in CSV".to_string()))
                        }
                    };
                    values.push(csv_value);
                }
                Ok(values.join(","))
            }
            _ => {
                Err(SinkError::ConversionError("Record is not object or array".to_string()))
            }
        }
    }
    
    /// 刷新缓冲区
    fn flush_buffer(&mut self) -> Result<(), SinkError> {
        if self.buffer.is_empty() {
            return Ok(());
        }
        
        // 批量写入
        for record in &self.buffer {
            self.write_record(record)?;
        }
        
        self.buffer.clear();
        self.buffer_size = 0;
        
        Ok(())
    }
}

impl DataSink<Value> for JsonFileSink {
    type Error = SinkError;
    
    fn write(&mut self, data: Vec<Value>) -> Result<(), Self::Error> {
        // 创建目录
        if self.config.create_dirs {
            self.create_directories()?;
        }
        
        for record in data {
            if self.config.buffer_size > 0 {
                // 使用缓冲区
                self.buffer.push(record);
                self.buffer_size += 1;
                
                if self.buffer_size >= self.config.buffer_size || self.config.auto_flush {
                    self.flush_buffer()?;
                }
            } else {
                // 直接写入
                self.write_record(&record)?;
            }
        }
        
        Ok(())
    }
    
    fn write_stream(&mut self, stream: Box<dyn Iterator<Item = Value>>) -> Result<(), Self::Error> {
        // 创建目录
        if self.config.create_dirs {
            self.create_directories()?;
        }
        
        for record in stream {
            if self.config.buffer_size > 0 {
                self.buffer.push(record);
                self.buffer_size += 1;
                
                if self.buffer_size >= self.config.buffer_size || self.config.auto_flush {
                    self.flush_buffer()?;
                }
            } else {
                self.write_record(&record)?;
            }
        }
        
        Ok(())
    }
    
    fn flush(&mut self) -> Result<(), Self::Error> {
        self.flush_buffer()?;
        
        // 这里可以刷新底层的文件句柄
        // 简化实现中我们已经在每次写入时刷新了
        Ok(())
    }
    
    fn stats(&self) -> SinkStats {
        self.stats.clone()
    }
}

/// 接收器错误
#[derive(Debug, thiserror::Error)]
pub enum SinkError {
    #[error("文件打开错误: {0}")]
    FileOpenError(std::io::Error),
    
    #[error("写入错误: {0}")]
    WriteError(std::io::Error),
    
    #[error("序列化错误: {0}")]
    SerializationError(#[from] serde_json::Error),
    
    #[error("IO错误: {0}")]
    IoError(std::io::Error),
    
    #[error("转换错误: {0}")]
    ConversionError(String),
    
    #[error("配置错误: {0}")]
    ConfigError(String),
}
}

5.9 完整的示例程序

现在让我们创建一个完整的示例程序来展示整个数据流框架的使用：

// 主程序示例
use dataflow_framework::prelude::*;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== 数据流框架示例 ===\n");
    
    // 1. 创建数据源（CSV文件）
    println!("1. 创建CSV数据源");
    let source = CsvDataSource::new("data/sample.csv")
        .has_header(true)
        .delimiter(',');
    
    // 2. 创建数据处理器
    println!("2. 创建数据转换处理器");
    let mut transforms = Vec::new();
    
    // 添加字段重命名
    transforms.push(DataTransform::RenameField { 
        from: "name".to_string(), 
        to: "full_name".to_string() 
    });
    
    // 添加类型转换
    transforms.push(DataTransform::ConvertType { 
        field: "age".to_string(), 
        to_type: FieldType::Integer 
    });
    
    // 添加常量字段
    transforms.push(DataTransform::AddConstant { 
        field: "source".to_string(), 
        Value::String("csv_import".to_string()) 
    });
    
    // 添加验证
    let mut validations = Vec::new();
    validations.push(DataValidation::Required { 
        fields: vec!["name".to_string(), "age".to_string()] 
    });
    
    // 添加过滤
    let mut filters = Vec::new();
    filters.push(DataFilter::Include { 
        condition: Condition {
            field: "age".to_string(),
            operator: ConditionOperator::GreaterEqual,
            value: Value::Number(Number::from(18)),
        }
    });
    
    let processor = DataTransformProcessor::new()
        .add_transforms(transforms)
        .add_validations(validations)
        .add_filters(filters);
    
    // 3. 创建数据接收器
    println!("3. 创建JSON文件输出");
    let output_format = OutputFormat::Json { 
        pretty: true, 
        pretty_indent: 2 
    };
    
    let output_config = OutputConfig {
        buffer_size: 100,
        auto_flush: true,
        create_dirs: true,
        overwrite_existing: true,
        encoding: "UTF-8".to_string(),
    };
    
    let sink = JsonFileSink::new("output/processed_data.json")
        .format(output_format)
        .with_config(output_config);
    
    // 4. 创建数据管道
    println!("4. 创建数据处理管道");
    let pipeline_config = PipelineConfig {
        batch_size: 50,
        parallel_processing: false,  // 示例中关闭并行处理
        max_concurrency: 4,
        enable_cache: true,
        cache_ttl_seconds: 3600,
        retry_attempts: 3,
        timeout_seconds: 300,
    };
    
    let mut pipeline = DataPipeline::with_config(source, processor, sink, pipeline_config);
    
    // 5. 运行管道
    println!("5. 开始处理数据...\n");
    let start_time = std::time::Instant::now();
    
    let metrics = pipeline.run().await?;
    
    let total_time = start_time.elapsed();
    
    // 6. 显示结果
    println!("\n=== 处理完成 ===");
    println!("总处理时间: {:?}", total_time);
    println!("处理的数据项数: {}", metrics.items_processed);
    println!("失败的数据项数: {}", metrics.items_failed);
    println!("处理吞吐量: {:.2} 项/秒", 
             metrics.items_processed as f64 / total_time.as_secs_f64());
    
    if metrics.items_failed > 0 {
        println!("警告: 有 {} 项数据处理失败", metrics.items_failed);
    }
    
    // 7. 获取管道状态
    let status = pipeline.get_status();
    println!("\n=== 管道状态 ===");
    println!("是否运行中: {}", status.is_running);
    println!("吞吐量: {:.2} 项/秒", status.throughput_per_second);
    
    Ok(())
}

// 为DataTransformProcessor添加方便的方法
trait DataTransformProcessorBuilder {
    fn add_transforms(self, transforms: Vec<DataTransform>) -> Self;
    fn add_validations(self, validations: Vec<DataValidation>) -> Self;
    fn add_filters(self, filters: Vec<DataFilter>) -> Self;
}

impl DataTransformProcessorBuilder for DataTransformProcessor {
    fn add_transforms(mut self, transforms: Vec<DataTransform>) -> Self {
        for transform in transforms {
            self = self.add_transform(transform);
        }
        self
    }
    
    fn add_validations(mut self, validations: Vec<DataValidation>) -> Self {
        for validation in validations {
            self = self.add_validation(validation);
        }
        self
    }
    
    fn add_filters(mut self, filters: Vec<DataFilter>) -> Self {
        for filter in filters {
            self = self.add_filter(filter);
        }
        self
    }
}

5.10 测试代码

让我们为框架创建全面的测试：

#![allow(unused)]
fn main() {
// 测试代码
#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;
    use std::io::Write;
    use serde_json::{json, Value};

    #[test]
    fn test_csv_data_source() {
        // 创建临时CSV文件
        let mut temp_file = NamedTempFile::new().unwrap();
        writeln!(temp_file, "name,age,city").unwrap();
        writeln!(temp_file, "Alice,25,New York").unwrap();
        writeln!(temp_file, "Bob,30,Los Angeles").unwrap();
        temp_file.flush().unwrap();
        
        // 测试CSV数据源
        let source = CsvDataSource::new(temp_file.path())
            .has_header(true);
        
        let data = source.read().unwrap();
        
        assert_eq!(data.len(), 2);
        assert_eq!(data[0]["name"], "Alice");
        assert_eq!(data[0]["age"], 25);
        assert_eq!(data[0]["city"], "New York");
    }
    
    #[test]
    fn test_data_transform_processor() {
        let processor = DataTransformProcessor::new()
            .add_transform(DataTransform::RenameField {
                from: "name".to_string(),
                to: "full_name".to_string(),
            })
            .add_transform(DataTransform::AddConstant {
                field: "source".to_string(),
                Value::String("test".to_string()),
            });
        
        let input_data = vec![
            json!({
                "name": "Alice",
                "age": 25
            }),
            json!({
                "name": "Bob",
                "age": 30
            }),
        ];
        
        let result = processor.process(input_data).unwrap();
        
        assert_eq!(result.len(), 2);
        assert_eq!(result[0]["full_name"], "Alice");
        assert_eq!(result[0]["source"], "test");
        assert_eq!(result[1]["full_name"], "Bob");
        assert_eq!(result[1]["source"], "test");
    }
    
    #[test]
    fn test_data_filters() {
        let processor = DataTransformProcessor::new()
            .add_filter(DataFilter::Include {
                condition: Condition {
                    field: "age".to_string(),
                    operator: ConditionOperator::GreaterEqual,
                    value: json!(25),
                }
            });
        
        let input_data = vec![
            json!({"name": "Alice", "age": 25}),
            json!({"name": "Bob", "age": 20}),
            json!({"name": "Carol", "age": 30}),
        ];
        
        let result = processor.process(input_data).unwrap();
        
        // 应该过滤掉Bob（age < 25）
        assert_eq!(result.len(), 2);
        assert_eq!(result[0]["name"], "Alice");
        assert_eq!(result[1]["name"], "Carol");
    }
    
    #[test]
    fn test_type_conversion() {
        let processor = DataTransformProcessor::new()
            .add_transform(DataTransform::ConvertType {
                field: "age".to_string(),
                to_type: FieldType::Integer,
            });
        
        let input_data = vec![json!({"age": "25"})];
        
        let result = processor.process(input_data).unwrap();
        
        assert_eq!(result[0]["age"], 25);
    }
    
    #[test]
    fn test_json_file_sink() {
        // 创建临时文件
        let temp_file = NamedTempFile::new().unwrap();
        let path = temp_file.path().to_path_buf();
        drop(temp_file); // 关闭文件句柄
        
        let mut sink = JsonFileSink::new(path.clone())
            .format(OutputFormat::Json { pretty: true, pretty_indent: 2 });
        
        let data = vec![
            json!({"name": "Alice", "age": 25}),
            json!({"name": "Bob", "age": 30}),
        ];
        
        sink.write(data).unwrap();
        sink.flush().unwrap();
        
        // 验证输出文件
        let content = std::fs::read_to_string(path).unwrap();
        assert!(content.contains("Alice"));
        assert!(content.contains("Bob"));
        assert!(content.contains("25"));
    }
    
    #[test]
    fn test_data_pipeline() {
        // 简化测试：使用内存数据源
        struct MemoryDataSource {
            data: Vec<Value>,
        }
        
        impl MemoryDataSource {
            fn new(data: Vec<Value>) -> Self {
                Self { data }
            }
        }
        
        impl DataSource<Value> for MemoryDataSource {
            type Error = Box<dyn std::error::Error>;
            
            fn read(&self) -> Result<Vec<Value>, Self::Error> {
                Ok(self.data.clone())
            }
            
            fn read_stream(&self) -> Result<Box<dyn Iterator<Item = Result<Value, Self::Error>>>, Self::Error> {
                let data = self.data.clone();
                Ok(Box::new(data.into_iter().map(Ok)))
            }
            
            fn count(&self) -> Result<u64, Self::Error> {
                Ok(self.data.len() as u64)
            }
            
            fn is_valid(&self) -> bool {
                !self.data.is_empty()
            }
        }
        
        let source = MemoryDataSource::new(vec![
            json!({"name": "Alice", "age": 25}),
            json!({"name": "Bob", "age": 30}),
        ]);
        
        let processor = DataTransformProcessor::new()
            .add_transform(DataTransform::AddConstant {
                field: "processed".to_string(),
                Value::Bool(true),
            });
        
        let temp_file = NamedTempFile::new().unwrap();
        let path = temp_file.path().to_path_buf();
        drop(temp_file);
        
        let sink = JsonFileSink::new(path);
        
        let pipeline = DataPipeline::new(source, processor, sink);
        let status = pipeline.get_status();
        
        assert_eq!(status.items_processed, 0); // 管道还没运行
    }
    
    #[test]
    fn test_error_handling() {
        let processor = DataTransformProcessor::new()
            .with_config(TransformConfig {
                fail_on_error: true,
                continue_on_warning: true,
                max_errors: 1,
                enable_logging: false,
            });
        
        // 无效的转换（尝试重命名字段但数据不是对象）
        let input_data = vec![json!(42)]; // 数字不是对象
        
        let result = processor.process(input_data);
        
        // 应该返回错误
        assert!(result.is_err());
    }
}
}

5.11 性能优化技巧

在企业级应用中，性能是关键考虑因素。以下是一些优化数据流框架性能的方法：

5.11.1 内存管理优化

#![allow(unused)]
fn main() {
// 内存优化的数据处理
pub struct StreamingDataProcessor<T> {
    buffer_size: usize,
    _phantom: std::marker::PhantomData<T>,
}

impl<T> StreamingDataProcessor<T> {
    pub fn new(buffer_size: usize) -> Self {
        Self {
            buffer_size,
            _phantom: std::marker::PhantomData,
        }
    }
    
    /// 流式处理大量数据
    pub async fn process_stream<'a, S, P>(
        &'a self,
        source: S,
        processor: P,
    ) -> Result<StreamingStats, Box<dyn std::error::Error + Send + Sync>>
    where
        S: futures::stream::Stream<Item = Result<T, Box<dyn std::error::Error + Send + Sync>>>,
        P: Fn(&[T]) -> Result<Vec<T>, Box<dyn std::error::Error + Send + Sync>> + Send + Sync,
        T: Send + Sync + 'a,
    {
        let mut buffer = Vec::with_capacity(self.buffer_size);
        let mut output = Vec::new();
        let mut stats = StreamingStats::default();
        
        // 使用异步流处理
        let mut stream = source.fuse();
        
        while let Some(item_result) = stream.next().await {
            let item = item_result?;
            
            buffer.push(item);
            stats.input_count += 1;
            
            // 当缓冲区满时处理
            if buffer.len() >= self.buffer_size {
                let processed_batch = processor(&buffer)?;
                output.extend(processed_batch);
                stats.output_count += processed_batch.len() as u64;
                buffer.clear();
                
                // 强制释放内存
                if buffer.capacity() > self.buffer_size * 2 {
                    buffer.shrink_to_fit();
                }
            }
        }
        
        // 处理剩余数据
        if !buffer.is_empty() {
            let processed_batch = processor(&buffer)?;
            output.extend(processed_batch);
            stats.output_count += processed_batch.len() as u64;
        }
        
        Ok(stats)
    }
}

#[derive(Debug, Default)]
pub struct StreamingStats {
    pub input_count: u64,
    pub output_count: u64,
    pub processing_time_ms: u64,
    pub memory_peak_mb: f64,
}
}

5.11.2 并发优化

#![allow(unused)]
fn main() {
// 并发数据处理
use rayon::prelude::*;

pub struct ParallelDataProcessor {
    chunk_size: usize,
    worker_threads: usize,
}

impl ParallelDataProcessor {
    pub fn new(chunk_size: usize, worker_threads: usize) -> Self {
        rayon::ThreadPoolBuilder::new()
            .num_threads(worker_threads)
            .build_global()
            .ok();
            
        Self { chunk_size, worker_threads }
    }
    
    /// 并行处理数据
    pub fn process_parallel<T, P, R>(
        &self,
        data: &[T],
        processor: P,
    ) -> Result<Vec<R>, Box<dyn std::error::Error + Send + Sync>>
    where
        T: Send + Sync,
        R: Send + Sync,
        P: Fn(&[T]) -> Result<Vec<R>, Box<dyn std::error::Error + Send + Sync>> + Send + Sync + Clone,
    {
        // 将数据分块
        let chunks: Vec<_> = data.chunks(self.chunk_size).collect();
        
        // 并行处理每个块
        let results: Vec<_> = chunks
            .par_iter()
            .map(|chunk| {
                let processed = processor(chunk)?;
                Ok(processed)
            })
            .collect::<Result<Vec<_>, _>>()?;
        
        // 合并结果
        let mut output = Vec::new();
        for result_chunk in results {
            output.extend(result_chunk);
        }
        
        Ok(output)
    }
}
}

5.12 总结

在本章中，我们深入学习了Rust的泛型和特征，并构建了一个完整

第六章：错误处理

6.1 章节概述

错误处理是任何健壮软件系统的核心组成部分。在Rust中，错误处理不仅是一种编程习惯，更是一种编译时保证。Rust的错误处理机制通过Result<T, E>和Option<T>类型，结合强大的模式匹配和错误传播机制，为开发者提供了构建可靠系统的强大工具。

在本章中，我们将通过构建一个企业级API客户端库（enterprise-api-client）来深入学习Rust的错误处理机制。这个项目将展示如何在实际企业环境中处理各种复杂的错误场景，包括网络错误、业务逻辑错误、验证错误等。

学习目标

完成本章学习后，您将能够：

理解Rust错误处理的基本原则
掌握Result<T, E>和Option<T>的使用
学会自定义错误类型的设计
掌握错误传播和转换机制
理解?操作符的使用场景
学会错误处理在异步环境中的最佳实践
构建健壮的错误恢复和重试机制
实现细粒度的错误分类和处理策略

实战项目预览

本章实战项目将构建一个企业级API客户端库，支持：

细粒度错误分类和处理
自动重试和熔断器模式
异步错误处理
限流和缓存机制
监控和指标收集
多种认证方式

6.2 Rust错误处理基础

6.2.1 为什么需要健壮的错误处理

在现代软件开发中，错误不仅仅是程序失败，它们是系统正常运行的一部分：

网络连接问题：超时、连接失败、服务器不可用
数据验证问题：无效输入、格式错误、业务规则违反
资源限制：内存不足、磁盘空间不够、CPU负载过高
业务逻辑错误：权限不足、配置错误、状态冲突
外部依赖问题：第三方API失败、数据库连接丢失

Rust的设计哲学是"让错误处理变得显式和强大"，而不是试图隐藏或忽略错误。

6.2.2 Option<T>：处理可能为空的值

Option<T>是Rust中处理可能为空值的标准方式，它强制开发者明确处理空值情况。

#![allow(unused)]
fn main() {
// Option的基本使用
fn demonstrate_option() {
    // 一些可能返回空值的函数
    let numbers = vec![1, 2, 3, 4, 5];
    
    // vec::get返回Option<&T>
    let first = numbers.get(0);
    let tenth = numbers.get(9);
    
    println!("第一个数字: {:?}", first);    // Some(1)
    println!("第十个数字: {:?}", tenth);   // None
    
    // 模式匹配处理Option
    match first {
        Some(value) => println!("值: {}", value),
        None => println!("没有值"),
    }
    
    // 使用if let进行简洁的匹配
    if let Some(value) = tenth {
        println!("第十个数字: {}", value);
    } else {
        println!("第十个数字不存在");
    }
    
    // 链式操作
    let result = numbers.get(0)
        .map(|x| x * 2)
        .unwrap_or(0);
    println!("翻倍结果: {}", result);
    
    // 组合多个Option
    let value1 = numbers.get(0);
    let value2 = numbers.get(1);
    
    if let (Some(v1), Some(v2)) = (value1, value2) {
        println!("两个值: {} + {} = {}", v1, v2, v1 + v2);
    }
}

// 自定义Option使用示例
#[derive(Debug, Clone)]
struct User {
    id: u64,
    name: String,
    email: Option<String>,
}

impl User {
    fn new(id: u64, name: String) -> Self {
        Self {
            id,
            name,
            email: None,
        }
    }
    
    fn with_email(mut self, email: String) -> Self {
        self.email = Some(email);
        self
    }
    
    fn get_display_name(&self) -> &str {
        if let Some(ref email) = self.email {
            email
        } else {
            &self.name
        }
    }
}

fn option_practical_example() {
    let user1 = User::new(1, "Alice".to_string());
    let user2 = User::new(2, "Bob".to_string()).with_email("bob@example.com".to_string());
    
    println!("用户1显示名: {}", user1.get_display_name());
    println!("用户2显示名: {}", user2.get_display_name());
    
    // 处理可能的空值情况
    let users = vec![user1, user2];
    
    for user in &users {
        match &user.email {
            Some(email) => println!("用户 {} 邮箱: {}", user.name, email),
            None => println!("用户 {} 没有邮箱", user.name),
        }
    }
}
}

6.2.3 Result<T, E>：处理可能失败的操作

Result<T, E>是处理可能失败操作的标准方式，它明确区分成功和失败的情况。

#![allow(unused)]
fn main() {
// Result的基本使用
fn demonstrate_result() {
    // 可能失败的除法操作
    let divide = |a: f64, b: f64| -> Result<f64, String> {
        if b == 0.0 {
            Err("除数不能为零".to_string())
        } else {
            Ok(a / b)
        }
    };
    
    // 使用match处理结果
    match divide(10.0, 2.0) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(error) => println!("错误: {}", error),
    }
    
    match divide(10.0, 0.0) {
        Ok(result) => println!("10 / 0 = {}", result),
        Err(error) => println!("错误: {}", error),
    }
    
    // 使用?操作符传播错误
    fn calculate_average(numbers: &[f64]) -> Result<f64, String> {
        if numbers.is_empty() {
            return Err("数字列表不能为空".to_string());
        }
        
        let sum: f64 = numbers.iter().sum();
        let average = sum / numbers.len() as f64;
        
        if average.is_nan() {
            return Err("计算结果无效".to_string());
        }
        
        Ok(average)
    }
    
    // 组合多个Result
    let numbers1 = vec![1.0, 2.0, 3.0, 4.0, 5.0];
    let numbers2 = vec![];
    
    println!("数组1平均值: {:?}", calculate_average(&numbers1));
    println!("数组2平均值: {:?}", calculate_average(&numbers2));
    
    // 使用链式操作
    let result = calculate_average(&numbers1)
        .map(|avg| avg * 2.0)  // 如果成功，将平均值翻倍
        .map_err(|e| format!("计算错误: {}", e));  // 如果失败，添加上下文
    
    println!("翻倍后的平均值: {:?}", result);
}

// 文件操作的Result示例
use std::fs::File;
use std::io::{Read, Write};

fn file_operations() -> Result<String, String> {
    // 尝试打开文件
    let mut file = match File::open("config.json") {
        Ok(file) => file,
        Err(e) => return Err(format!("无法打开文件: {}", e)),
    };
    
    // 读取文件内容
    let mut contents = String::new();
    match file.read_to_string(&mut contents) {
        Ok(_) => contents,
        Err(e) => return Err(format!("无法读取文件: {}", e)),
    }
    
    // 验证内容
    if contents.is_empty() {
        return Err("文件内容为空".to_string());
    }
    
    Ok(contents)
}

fn write_to_file() -> Result<(), String> {
    let data = "Hello, World!";
    
    let mut file = match File::create("output.txt") {
        Ok(file) => file,
        Err(e) => return Err(format!("无法创建文件: {}", e)),
    };
    
    match file.write_all(data.as_bytes()) {
        Ok(_) => println!("文件写入成功"),
        Err(e) => return Err(format!("写入失败: {}", e)),
    }
    
    Ok(())
}

// 使用简化的错误传播
fn simplified_file_operations() -> Result<String, std::io::Error> {
    let mut file = File::open("config.json")?;  // ?操作符自动传播错误
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;  // 如果失败立即返回错误
    Ok(contents)
}
}

6.2.4 错误传播和转换

#![allow(unused)]
fn main() {
// 错误转换和处理
#[derive(Debug)]
enum ParseError {
    InvalidNumber(String),
    EmptyInput,
    OutOfRange { value: f64, min: f64, max: f64 },
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::InvalidNumber(s) => write!(f, "无效数字: {}", s),
            ParseError::EmptyInput => write!(f, "输入为空"),
            ParseError::OutOfRange { value, min, max } => {
                write!(f, "值 {} 不在范围 [{}, {}] 内", value, min, max)
            }
        }
    }
}

impl std::error::Error for ParseError {}

// 从其他错误类型转换
impl From<std::io::Error> for ParseError {
    fn from(error: std::io::Error) -> Self {
        ParseError::InvalidNumber(format!("IO错误: {}", error))
    }
}

impl From<&str> for ParseError {
    fn from(msg: &str) -> Self {
        ParseError::InvalidNumber(msg.to_string())
    }
}

// 数字解析函数
fn parse_number(input: &str, min: f64, max: f64) -> Result<f64, ParseError> {
    if input.trim().is_empty() {
        return Err(ParseError::EmptyInput);
    }
    
    let number: f64 = input.trim()
        .parse()
        .map_err(|_| ParseError::InvalidNumber(input.to_string()))?;
    
    if number < min || number > max {
        return Err(ParseError::OutOfRange { value: number, min, max });
    }
    
    Ok(number)
}

// 链式错误处理
fn process_user_input() -> Result<f64, ParseError> {
    let inputs = vec!["", "not_a_number", "50", "150"];
    
    for input in inputs {
        match parse_number(input, 0.0, 100.0) {
            Ok(number) => {
                println!("成功解析: {} -> {}", input, number);
                return Ok(number);
            }
            Err(error) => {
                println!("解析失败 '{}': {}", input, error);
                // 继续尝试下一个输入
            }
        }
    }
    
    Err("所有输入都无效".into())
}

// 错误恢复策略
fn robust_calculation() -> Result<f64, String> {
    let values = vec!["10", "20", "invalid", "30", ""];
    
    let mut sum = 0.0;
    let mut valid_count = 0;
    let mut errors = Vec::new();
    
    for value in values {
        match parse_number(value, 0.0, 1000.0) {
            Ok(num) => {
                sum += num;
                valid_count += 1;
            }
            Err(error) => {
                errors.push(format!("'{}': {}", value, error));
            }
        }
    }
    
    if valid_count == 0 {
        return Err(format!("没有有效值，错误: {:?}", errors));
    }
    
    let average = sum / valid_count as f64;
    
    if !errors.is_empty() {
        println!("警告: 跳过了一些无效值: {:?}", errors);
    }
    
    Ok(average)
}
}

6.3 异步错误处理

在现代网络编程中，异步错误处理是关键技术。Rust的async/await语法与错误处理完美结合。

6.3.1 异步错误处理基础

#![allow(unused)]
fn main() {
// 异步错误处理示例
use tokio::time::{sleep, Duration};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[derive(Debug)]
enum AsyncError {
    NetworkTimeout,
    ConnectionFailed,
    InvalidResponse,
    FileNotFound,
    PermissionDenied,
}

impl std::fmt::Display for AsyncError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            AsyncError::NetworkTimeout => write!(f, "网络超时"),
            AsyncError::ConnectionFailed => write!(f, "连接失败"),
            AsyncError::InvalidResponse => write!(f, "无效响应"),
            AsyncError::FileNotFound => write!(f, "文件未找到"),
            AsyncError::PermissionDenied => write!(f, "权限拒绝"),
        }
    }
}

impl std::error::Error for AsyncError {}

// 模拟异步网络请求
async fn fetch_data(url: &str) -> Result<String, AsyncError> {
    println!("开始请求: {}", url);
    
    // 模拟网络延迟
    sleep(Duration::from_millis(100)).await;
    
    // 模拟可能的错误
    if url.contains("timeout") {
        return Err(AsyncError::NetworkTimeout);
    }
    
    if url.contains("404") {
        return Err(AsyncError::FileNotFound);
    }
    
    if url.contains("500") {
        return Err(AsyncError::ConnectionFailed);
    }
    
    // 模拟成功响应
    Ok(format!("响应来自: {}", url))
}

// 异步错误恢复
async fn fetch_with_retry(url: &str, max_retries: usize) -> Result<String, AsyncError> {
    let mut last_error = None;
    
    for attempt in 1..=max_retries {
        match fetch_data(url).await {
            Ok(data) => {
                println!("第{}次尝试成功", attempt);
                return Ok(data);
            }
            Err(error) => {
                println!("第{}次尝试失败: {}", attempt, error);
                last_error = Some(error);
                
                if attempt < max_retries {
                    // 指数退避
                    let delay = Duration::from_millis(100 * (2_u64.pow(attempt as u32 - 1)));
                    println!("等待 {}ms 后重试", delay.as_millis());
                    sleep(delay).await;
                }
            }
        }
    }
    
    Err(last_error.unwrap())
}

// 并发异步操作和错误处理
async fn fetch_multiple_urls(urls: &[&str]) -> Result<Vec<String>, AsyncError> {
    use futures::future::join_all;
    
    // 并发执行所有请求
    let futures: Vec<_> = urls.iter()
        .map(|&url| fetch_data(url))
        .collect();
    
    let results = join_all(futures).await;
    
    // 收集成功和失败的结果
    let mut successful = Vec::new();
    let mut errors = Vec::new();
    
    for result in results {
        match result {
            Ok(data) => successful.push(data),
            Err(error) => errors.push(error),
        }
    }
    
    if !errors.is_empty() {
        return Err(format!("{} 个请求失败", errors.len()).into());
    }
    
    Ok(successful)
}

// 选择最快的响应
async fn fetch_fastest_response(urls: &[&str]) -> Result<String, AsyncError> {
    use futures::future::select;
    use futures::pin_mut;
    
    let futures: Vec<_> = urls.iter()
        .map(|&url| Box::pin(fetch_data(url)))
        .collect();
    
    // 选择最先完成的任务
    let mut completed = false;
    
    for future in futures {
        if completed {
            break;
        }
        
        pin_mut!(future);
        match select(future, sleep(Duration::from_secs(5))).await {
            std::task::Poll::Ready((result, _)) => {
                match result {
                    Ok(data) => {
                        completed = true;
                        return Ok(data);
                    }
                    Err(error) => {
                        eprintln!("请求失败: {}", error);
                    }
                }
            }
            std::task::Poll::Pending => {
                // 继续下一个请求
                continue;
            }
        }
    }
    
    Err("所有请求都失败了".into())
}
}

6.3.2 异步错误处理最佳实践

#![allow(unused)]
fn main() {
// 异步错误处理最佳实践
use std::sync::Arc;
use tokio::sync::Mutex;

// 错误累积器
struct ErrorCollector {
    errors: Vec<String>,
    max_errors: usize,
}

impl ErrorCollector {
    fn new(max_errors: usize) -> Self {
        Self {
            errors: Vec::new(),
            max_errors,
        }
    }
    
    async fn add_error(&mut self, error: String) {
        if self.errors.len() < self.max_errors {
            self.errors.push(error);
        }
    }
    
    fn has_errors(&self) -> bool {
        !self.errors.is_empty()
    }
    
    fn get_errors(&self) -> &[String] {
        &self.errors
    }
}

// 批量异步操作
async fn batch_process_with_error_handling(
    items: Vec<String>,
    processor: Arc<dyn ProcessItem + Send + Sync>,
) -> Result<Vec<String>, String> {
    use tokio::sync::Semaphore;
    use std::sync::atomic::{AtomicUsize, Ordering};
    
    let semaphore = Arc::new(Semaphore::new(5)); // 限制并发数
    let error_collector = Arc::new(Mutex::new(ErrorCollector::new(10)));
    let processed_count = Arc::new(AtomicUsize::new(0));
    
    let mut handles = Vec::new();
    
    for item in items {
        let semaphore = semaphore.clone();
        let processor = processor.clone();
        let error_collector = error_collector.clone();
        let processed_count = processed_count.clone();
        
        let handle = tokio::spawn(async move {
            // 获取信号量许可
            let _permit = semaphore.acquire().await.unwrap();
            
            match processor.process_item(&item).await {
                Ok(result) => {
                    processed_count.fetch_add(1, Ordering::Relaxed);
                    Some(result)
                }
                Err(error) => {
                    let error_msg = format!("处理项目 '{}' 失败: {}", item, error);
                    error_collector.lock().await.add_error(error_msg).await;
                    None
                }
            }
        });
        
        handles.push(handle);
    }
    
    // 等待所有任务完成
    let mut results = Vec::new();
    for handle in handles {
        if let Some(result) = handle.await.map_err(|e| e.to_string())? {
            results.push(result);
        }
    }
    
    // 检查是否有错误
    let errors = error_collector.lock().await.get_errors().to_vec();
    if !errors.is_empty() {
        return Err(format!("处理失败: {:?}", errors));
    }
    
    println!("成功处理了 {} 个项目", processed_count.load(Ordering::Relaxed));
    Ok(results)
}

// 异步处理trait
#[async_trait::async_trait]
trait ProcessItem {
    async fn process_item(&self, item: &str) -> Result<String, String>;
}

// 具体的处理器实现
struct DataProcessor {
    delay_ms: u64,
}

impl DataProcessor {
    fn new(delay_ms: u64) -> Self {
        Self { delay_ms }
    }
}

#[async_trait::async_trait]
impl ProcessItem for DataProcessor {
    async fn process_item(&self, item: &str) -> Result<String, String> {
        // 模拟处理延迟
        tokio::time::sleep(Duration::from_millis(self.delay_ms)).await;
        
        // 模拟可能的处理错误
        if item.contains("error") {
            return Err("包含错误标记".to_string());
        }
        
        Ok(format!("处理完成: {}", item.to_uppercase()))
    }
}

// 超时处理
async fn with_timeout<T, F, Fut>(timeout: Duration, future: F) -> Result<T, AsyncError>
where
    F: Future<Output = T>,
    Fut: Future<Output = Result<T, String>>,
{
    use futures::future::select;
    
    let timeout_future = sleep(timeout);
    let operation_future = future.map_err(|e| AsyncError::InvalidResponse);
    
    pin_mut!(timeout_future);
    pin_mut!(operation_future);
    
    match select(timeout_future, operation_future).await {
        std::task::Poll::Ready(_) => Err(AsyncError::NetworkTimeout),
        std::task::Poll::Ready((result, _)) => result.map_err(|e| AsyncError::InvalidResponse),
    }
}
}

6.4 实战项目：企业级API客户端库

现在开始构建我们的实战项目。首先设计错误处理架构。

6.4.1 错误类型设计

#![allow(unused)]
fn main() {
// 企业级错误处理系统
use std::collections::HashMap;
use std::time::{Duration, SystemTime};

/// API客户端错误类型
#[derive(Debug, thiserror::Error)]
pub enum ApiError {
    #[error("请求超时: {0}")]
    Timeout(#[from] tokio::time::error::Elapsed),
    
    #[error("网络错误: {0}")]
    Network(#[from] reqwest::Error),
    
    #[error("HTTP错误: {status} - {message}")]
    Http { 
        status: reqwest::StatusCode, 
        message: String,
        body: Option<String>,
        headers: HashMap<String, String>,
    },
    
    #[error("认证错误: {0}")]
    Authentication(String),
    
    #[error("授权错误: {0}")]
    Authorization(String),
    
    #[error("频率限制: {remaining:?}")]
    RateLimit { 
        remaining: Option<Duration>,
        reset_time: Option<SystemTime>,
        retry_after: Option<Duration>,
    },
    
    #[error("服务不可用: {reason}")]
    ServiceUnavailable { reason: String },
    
    #[error("配置错误: {0}")]
    Configuration(String),
    
    #[error("重试耗尽: 已尝试 {attempts} 次")]
    RetryExhausted { attempts: u32 },
    
    #[error("熔断器开启")]
    CircuitBreakerOpen,
    
    #[error("缓存错误: {0}")]
    Cache(#[from] CacheError),
    
    #[error("验证错误: {0}")]
    Validation(#[from] ValidationError),
    
    #[error("序列化错误: {0}")]
    Serialization(#[from] serde_json::Error),
    
    #[error("业务逻辑错误: {0}")]
    Business(String),
    
    #[error("系统错误: {0}")]
    System(String),
}

impl ApiError {
    /// 判断错误是否是可重试的
    pub fn is_retryable(&self) -> bool {
        match self {
            ApiError::Network(_) | ApiError::Timeout(_) => true,
            ApiError::Http { status, .. } => {
                status.is_server_error() || status.as_u16() == 429
            }
            ApiError::ServiceUnavailable { .. } => true,
            ApiError::CircuitBreakerOpen => false,
            ApiError::RateLimit { retry_after, .. } => retry_after.is_some(),
            ApiError::Configuration(_) | ApiError::Authentication(_) | ApiError::Authorization(_) => false,
            ApiError::Cache(_) | ApiError::Validation(_) | ApiError::Serialization(_) => true,
            ApiError::Business(_) | ApiError::System(_) => false,
        }
    }
    
    /// 获取重试建议的延迟时间
    pub fn recommended_delay(&self) -> Option<Duration> {
        match self {
            ApiError::Network(_) | ApiError::Timeout(_) => Some(Duration::from_millis(100)),
            ApiError::Http { status, .. } if status.is_server_error() => Some(Duration::from_secs(1)),
            ApiError::RateLimit { retry_after, .. } => *retry_after,
            ApiError::ServiceUnavailable { .. } => Some(Duration::from_secs(5)),
            _ => None,
        }
    }
    
    /// 获取错误分类
    pub fn category(&self) -> ErrorCategory {
        match self {
            ApiError::Network(_) | ApiError::Timeout(_) => ErrorCategory::Network,
            ApiError::Http { .. } => ErrorCategory::Http,
            ApiError::Authentication(_) | ApiError::Authorization(_) => ErrorCategory::Auth,
            ApiError::RateLimit { .. } => ErrorCategory::RateLimit,
            ApiError::Configuration(_) => ErrorCategory::Configuration,
            ApiError::Validation(_) | ApiError::Serialization(_) => ErrorCategory::Data,
            ApiError::Business(_) => ErrorCategory::Business,
            ApiError::System(_) | ApiError::ServiceUnavailable { .. } => ErrorCategory::System,
            ApiError::Cache(_) => ErrorCategory::Cache,
            ApiError::CircuitBreakerOpen | ApiError::RetryExhausted { .. } => ErrorCategory::Reliability,
        }
    }
}

/// 错误分类
#[derive(Debug, Clone, PartialEq)]
pub enum ErrorCategory {
    Network,
    Http,
    Auth,
    RateLimit,
    Configuration,
    Data,
    Business,
    System,
    Cache,
    Reliability,
}

/// 验证错误
#[derive(Debug, thiserror::Error)]
pub enum ValidationError {
    #[error("缺少必需字段: {field}")]
    MissingField { field: String },
    
    #[error("字段格式错误: {field} - {reason}")]
    InvalidFormat { field: String, reason: String },
    
    #[error("字段值超出范围: {field} - {min} 到 {max}")]
    OutOfRange { field: String, min: String, max: String },
    
    #[error("字段值不符合模式: {field} - 模式: {pattern}")]
    PatternMismatch { field: String, pattern: String, value: String },
    
    #[error("自定义验证失败: {0}")]
    Custom(String),
}

/// 缓存错误
#[derive(Debug, thiserror::Error)]
pub enum CacheError {
    #[error("键不存在: {key}")]
    KeyNotFound { key: String },
    
    #[error("键已过期: {key}")]
    KeyExpired { key: String, expired_at: SystemTime },
    
    #[error("缓存未命中: {key}")]
    CacheMiss { key: String },
    
    #[error("缓存存储失败: {key} - {reason}")]
    StorageError { key: String, reason: String },
    
    #[error("连接错误: {0}")]
    ConnectionError(String),
    
    #[error("配置错误: {0}")]
    ConfigurationError(String),
}

/// 错误上下文信息
#[derive(Debug, Clone)]
pub struct ErrorContext {
    pub timestamp: SystemTime,
    pub request_id: Option<String>,
    pub user_id: Option<String>,
    pub endpoint: Option<String>,
    pub method: Option<String>,
    pub status_code: Option<reqwest::StatusCode>,
    pub response_time_ms: Option<u64>,
    pub retry_count: Option<u32>,
}

impl Default for ErrorContext {
    fn default() -> Self {
        Self {
            timestamp: SystemTime::now(),
            request_id: None,
            user_id: None,
            endpoint: None,
            method: None,
            status_code: None,
            response_time_ms: None,
            retry_count: None,
        }
    }
}

/// 错误统计
#[derive(Debug, Clone)]
pub struct ErrorStats {
    pub total_errors: u64,
    pub errors_by_category: HashMap<ErrorCategory, u64>,
    pub last_error_time: Option<SystemTime>,
    pub error_rate: f64, // 每秒错误数
}

impl Default for ErrorStats {
    fn default() -> Self {
        Self {
            total_errors: 0,
            errors_by_category: HashMap::new(),
            last_error_time: None,
            error_rate: 0.0,
        }
    }
}
}

6.4.2 重试策略和熔断器

#![allow(unused)]
fn main() {
// 重试策略实现
use std::collections::VecDeque;
use std::time::Instant;

/// 重试配置
#[derive(Debug, Clone)]
pub struct RetryConfig {
    pub max_attempts: u32,
    pub base_delay: Duration,
    pub max_delay: Duration,
    pub backoff_multiplier: f64,
    pub jitter_enabled: bool,
    pub jitter_range: f64, // 0.0 到 1.0
    pub retryable_errors: Vec<ErrorCategory>,
}

impl Default for RetryConfig {
    fn default() -> Self {
        Self {
            max_attempts: 3,
            base_delay: Duration::from_millis(100),
            max_delay: Duration::from_secs(30),
            backoff_multiplier: 2.0,
            jitter_enabled: true,
            jitter_range: 0.1, // 10%的抖动
            retryable_errors: vec![
                ErrorCategory::Network,
                ErrorCategory::Http,
                ErrorCategory::RateLimit,
            ],
        }
    }
}

/// 熔断器状态
#[derive(Debug, Clone, PartialEq)]
pub enum CircuitBreakerState {
    Closed,     // 正常状态，允许请求
    Open,       // 熔断状态，拒绝请求
    HalfOpen,   // 半开状态，允许少量请求测试
}

/// 熔断器配置
#[derive(Debug, Clone)]
pub struct CircuitBreakerConfig {
    pub failure_threshold: u32,  // 失败阈值
    pub success_threshold: u32,  // 成功阈值
    pub timeout: Duration,       // 熔断持续时间
    pub monitor_window: Duration, // 监控时间窗口
}

impl Default for CircuitBreakerConfig {
    fn default() -> Self {
        Self {
            failure_threshold: 5,
            success_threshold: 3,
            timeout: Duration::from_secs(60),
            monitor_window: Duration::from_secs(60),
        }
    }
}

/// 熔断器实现
pub struct CircuitBreaker {
    config: CircuitBreakerConfig,
    state: CircuitBreakerState,
    failure_count: u32,
    success_count: u32,
    last_failure_time: Option<Instant>,
    last_success_time: Option<Instant>,
}

impl CircuitBreaker {
    /// 创建新的熔断器
    pub fn new(config: CircuitBreakerConfig) -> Self {
        Self {
            config,
            state: CircuitBreakerState::Closed,
            failure_count: 0,
            success_count: 0,
            last_failure_time: None,
            last_success_time: None,
        }
    }
    
    /// 检查是否可以执行请求
    pub fn can_execute(&mut self) -> bool {
        let now = Instant::now();
        
        match self.state {
            CircuitBreakerState::Closed => true,
            CircuitBreakerState::Open => {
                // 检查是否可以转换到半开状态
                if let Some(last_failure) = self.last_failure_time {
                    if now.duration_since(last_failure) > self.config.timeout {
                        self.state = CircuitBreakerState::HalfOpen;
                        self.success_count = 0;
                        true
                    } else {
                        false
                    }
                } else {
                    true
                }
            }
            CircuitBreakerState::HalfOpen => true,
        }
    }
    
    /// 记录成功
    pub fn on_success(&mut self) {
        let now = Instant::now();
        
        match self.state {
            CircuitBreakerState::Closed => {
                self.failure_count = 0; // 清除失败计数
            }
            CircuitBreakerState::HalfOpen => {
                self.success_count += 1;
                if self.success_count >= self.config.success_threshold {
                    self.state = CircuitBreakerState::Closed;
                    self.failure_count = 0;
                    self.success_count = 0;
                }
            }
            CircuitBreakerState::Open => {
                // 在熔断状态下不应该有成功的调用
            }
        }
        
        self.last_success_time = Some(now);
    }
    
    /// 记录失败
    pub fn on_failure(&mut self) {
        let now = Instant::now();
        
        self.failure_count += 1;
        self.last_failure_time = Some(now);
        
        match self.state {
            CircuitBreakerState::Closed => {
                if self.failure_count >= self.config.failure_threshold {
                    self.state = CircuitBreakerState::Open;
                }
            }
            CircuitBreakerState::HalfOpen => {
                // 在半开状态下的任何失败都回到打开状态
                self.state = CircuitBreakerState::Open;
                self.success_count = 0;
            }
            CircuitBreakerState::Open => {
                // 保持在打开状态
            }
        }
    }
    
    /// 获取当前状态
    pub fn state(&self) -> CircuitBreakerState {
        self.state.clone()
    }
    
    /// 获取状态信息
    pub fn status(&self) -> CircuitBreakerStatus {
        CircuitBreakerStatus {
            state: self.state(),
            failure_count: self.failure_count,
            success_count: self.success_count,
            last_failure_time: self.last_failure_time.map(|i| i.elapsed()),
            last_success_time: self.last_success_time.map(|i| i.elapsed()),
        }
    }
}

/// 熔断器状态信息
#[derive(Debug, Clone)]
pub struct CircuitBreakerStatus {
    pub state: CircuitBreakerState,
    pub failure_count: u32,
    pub success_count: u32,
    pub last_failure_time: Option<Duration>,
    pub last_success_time: Option<Duration>,
}

/// 重试器
pub struct RetryHandler {
    config: RetryConfig,
    attempt_history: VecDeque<Duration>,
    max_history_size: usize,
}

impl RetryHandler {
    /// 创建新的重试处理器
    pub fn new(config: RetryConfig) -> Self {
        Self {
            config,
            attempt_history: VecDeque::new(),
            max_history_size: 100,
        }
    }
    
    /// 执行带重试的操作
    pub async fn execute_with_retry<T, F, Fut>(
        &mut self,
        operation: F,
        initial_context: ErrorContext,
    ) -> Result<T, ApiError>
    where
        F: Fn(u32, ErrorContext) -> Fut,
        Fut: Future<Output = Result<T, ApiError>>,
    {
        let mut context = initial_context;
        let mut last_error = None;
        
        for attempt in 1..=self.config.max_attempts {
            context.retry_count = Some(attempt);
            
            match operation(attempt, context.clone()).await {
                Ok(result) => {
                    // 成功：记录重试历史并返回结果
                    self.record_attempt(attempt, true);
                    return Ok(result);
                }
                Err(error) => {
                    last_error = Some(error);
                    
                    // 记录失败历史
                    self.record_attempt(attempt, false);
                    
                    // 检查是否应该重试
                    if !self.should_retry(&error) || attempt == self.config.max_attempts {
                        return Err(error);
                    }
                    
                    // 计算延迟时间
                    let delay = self.calculate_delay(attempt);
                    println!("重试 {} 将在 {:?} 后执行", attempt, delay);
                    tokio::time::sleep(delay).await;
                    
                    // 更新上下文
                    context.timestamp = SystemTime::now();
                }
            }
        }
        
        unreachable!()
    }
    
    /// 检查是否应该重试
    fn should_retry(&self, error: &ApiError) -> bool {
        // 检查错误类型是否可重试
        if !self.config.retryable_errors.contains(&error.category()) {
            return false;
        }
        
        // 检查是否在推荐的重试窗口内
        if let Some(recommended_delay) = error.recommended_delay() {
            if recommended_delay > self.config.max_delay {
                return false;
            }
        }
        
        true
    }
    
    /// 计算重试延迟
    fn calculate_delay(&self, attempt: u32) -> Duration {
        let mut delay = self.config.base_delay;
        
        if attempt > 1 {
            let exponential_delay = self.config.base_delay.as_millis() as f64 * 
                self.config.backoff_multiplier.powi(attempt as i32 - 1);
            
            delay = Duration::from_millis(exponential_delay as u64);
            delay = delay.min(self.config.max_delay);
            
            // 添加抖动
            if self.config.jitter_enabled {
                let jitter_range = delay.as_millis() as f64 * self.config.jitter_range;
                let jitter = rand::thread_rng().gen_range(-jitter_range..jitter_range);
                let jittered_delay = delay.as_millis() as f64 + jitter;
                delay = Duration::from_millis(jittered_delay.max(0.0) as u64);
            }
        }
        
        delay
    }
    
    /// 记录尝试历史
    fn record_attempt(&mut self, attempt: u32, success: bool) {
        if success {
            // 记录成功尝试的延迟时间
            self.attempt_history.push_back(Duration::from_millis(100)); // 简化实现
        } else {
            // 记录失败尝试的延迟时间
            self.attempt_history.push_back(Duration::from_millis(200)); // 简化实现
        }
        
        // 保持历史记录大小
        if self.attempt_history.len() > self.max_history_size {
            self.attempt_history.pop_front();
        }
    }
    
    /// 获取重试统计
    pub fn get_stats(&self) -> RetryStats {
        let total_attempts = self.attempt_history.len() as u64;
        let total_time: u64 = self.attempt_history.iter()
            .map(|d| d.as_millis() as u64)
            .sum();
        
        RetryStats {
            total_attempts,
            average_delay_ms: if total_attempts > 0 {
                total_time / total_attempts
            } else {
                0
            },
            success_rate: if total_attempts > 0 {
                // 简化计算
                0.5
            } else {
                0.0
            },
        }
    }
}

/// 重试统计
#[derive(Debug, Clone)]
pub struct RetryStats {
    pub total_attempts: u64,
    pub average_delay_ms: u64,
    pub success_rate: f64,
}
}

6.4.3 限流器实现

#![allow(unused)]
fn main() {
// 限流器实现
use std::collections::VecDeque;
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};

/// 限流器配置
#[derive(Debug, Clone)]
pub struct RateLimitConfig {
    pub requests_per_second: f64,
    pub burst_size: u32,
    pub window_size: Duration,
}

impl Default for RateLimitConfig {
    fn default() -> Self {
        Self {
            requests_per_second: 10.0,
            burst_size: 5,
            window_size: Duration::from_secs(1),
        }
    }
}

/// 滑动窗口限流器
pub struct SlidingWindowRateLimiter {
    config: RateLimitConfig,
    request_times: VecDeque<Instant>,
    allowed_tokens: AtomicU64,
    max_tokens: u64,
}

impl SlidingWindowRateLimiter {
    /// 创建新的限流器
    pub fn new(config: RateLimitConfig) -> Self {
        let max_tokens = (config.requests_per_second * config.window_size.as_secs_f64()) as u64 + config.burst_size as u64;
        
        Self {
            config,
            request_times: VecDeque::new(),
            allowed_tokens: AtomicU64::new(max_tokens),
            max_tokens,
        }
    }
    
    /// 尝试获取执行许可
    pub async fn acquire(&self) -> Result<(), ApiError> {
        // 简化实现：直接使用原子变量
        let current_tokens = self.allowed_tokens.load(Ordering::Relaxed);
        
        if current_tokens > 0 {
            if self.allowed_tokens.compare_exchange_weak(
                current_tokens,
                current_tokens - 1,
                Ordering::Relaxed,
                Ordering::Relaxed
            ).is_ok() {
                return Ok(());
            }
        }
        
        // 如果没有可用令牌，抛出错误
        Err(ApiError::RateLimit {
            remaining: Some(Duration::from_millis(100)), // 模拟延迟
            reset_time: Some(SystemTime::now()),
            retry_after: Some(Duration::from_millis(100)),
        })
    }
    
    /// 释放令牌
    pub fn release(&self) {
        let current_tokens = self.allowed_tokens.load(Ordering::Relaxed);
        if current_tokens < self.max_tokens {
            self.allowed_tokens.fetch_add(1, Ordering::Relaxed);
        }
    }
    
    /// 获取当前状态
    pub fn status(&self) -> RateLimitStatus {
        let current_tokens = self.allowed_tokens.load(Ordering::Relaxed);
        
        RateLimitStatus {
            available_tokens: current_tokens,
            max_tokens: self.max_tokens,
            tokens_per_second: self.config.requests_per_second,
            remaining: Some(Duration::from_secs((current_tokens as f64 / self.config.requests_per_second) as u64)),
        }
    }
}

/// 限流器状态
#[derive(Debug, Clone)]
pub struct RateLimitStatus {
    pub available_tokens: u64,
    pub max_tokens: u64,
    pub tokens_per_second: f64,
    pub remaining: Option<Duration>,
}

/// 令牌桶限流器
pub struct TokenBucketRateLimiter {
    config: RateLimitConfig,
    tokens: AtomicU64,
    last_refill: Instant,
}

impl TokenBucketRateLimiter {
    /// 创建令牌桶限流器
    pub fn new(config: RateLimitConfig) -> Self {
        let initial_tokens = config.burst_size as u64;
        
        Self {
            config,
            tokens: AtomicU64::new(initial_tokens),
            last_refill: Instant::now(),
        }
    }
    
    /// 尝试获取令牌
    pub async fn acquire(&self) -> Result<(), ApiError> {
        self.refill_tokens();
        
        let current_tokens = self.tokens.load(Ordering::Relaxed);
        
        if current_tokens > 0 {
            if self.tokens.compare_exchange_weak(
                current_tokens,
                current_tokens - 1,
                Ordering::Relaxed,
                Ordering::Relaxed
            ).is_ok() {
                return Ok(());
            }
        }
        
        Err(ApiError::RateLimit {
            remaining: Some(self.time_to_next_token()),
            reset_time: Some(SystemTime::now()),
            retry_after: Some(self.time_to_next_token()),
        })
    }
    
    /// 补充令牌
    fn refill_tokens(&self) {
        let now = Instant::now();
        let elapsed = now.duration_since(self.last_refill);
        
        let tokens_to_add = (elapsed.as_secs_f64() * self.config.requests_per_second) as u64;
        
        if tokens_to_add > 0 {
            let current_tokens = self.tokens.load(Ordering::Relaxed);
            let new_tokens = (current_tokens + tokens_to_add).min(self.config.burst_size as u64);
            
            self.tokens.store(new_tokens, Ordering::Relaxed);
            
            // 更新最后补充时间
            let _ = std::sync::Arc::new(self) as *const Self; // 简化实现
        }
    }
    
    /// 计算到下一个令牌的时间
    fn time_to_next_token(&self) -> Duration {
        Duration::from_millis((1.0 / self.config.requests_per_second * 1000.0) as u64)
    }
}
}

6.5 完整的API客户端实现

现在实现完整的API客户端：

#![allow(unused)]
fn main() {
// 完整的API客户端实现
use reqwest::{Client as HttpClient, ClientBuilder};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use tokio::sync::RwLock;

/// HTTP方法
#[derive(Debug, Clone)]
pub enum HttpMethod {
    GET,
    POST,
    PUT,
    PATCH,
    DELETE,
    HEAD,
    OPTIONS,
}

impl HttpMethod {
    fn as_str(&self) -> &'static str {
        match self {
            HttpMethod::GET => "GET",
            HttpMethod::POST => "POST",
            HttpMethod::PUT => "PUT",
            HttpMethod::PATCH => "PATCH",
            HttpMethod::DELETE => "DELETE",
            HttpMethod::HEAD => "HEAD",
            HttpMethod::OPTIONS => "OPTIONS",
        }
    }
}

/// API客户端配置
#[derive(Debug, Clone)]
pub struct ClientConfig {
    pub base_url: String,
    pub timeout: Duration,
    pub connect_timeout: Duration,
    pub user_agent: String,
    pub retry_config: RetryConfig,
    pub rate_limit_config: RateLimitConfig,
    pub circuit_breaker_config: CircuitBreakerConfig,
    pub cache_config: CacheConfig,
    pub auth_config: AuthConfig,
}

impl Default for ClientConfig {
    fn default() -> Self {
        Self {
            base_url: "https://api.example.com".to_string(),
            timeout: Duration::from_secs(30),
            connect_timeout: Duration::from_secs(10),
            user_agent: "EnterpriseAPIClient/1.0".to_string(),
            retry_config: RetryConfig::default(),
            rate_limit_config: RateLimitConfig::default(),
            circuit_breaker_config: CircuitBreakerConfig::default(),
            cache_config: CacheConfig::default(),
            auth_config: AuthConfig::default(),
        }
    }
}

/// 认证配置
#[derive(Debug, Clone)]
pub struct AuthConfig {
    pub auth_type: AuthType,
    pub credentials: AuthCredentials,
    pub refresh_strategy: RefreshStrategy,
}

impl Default for AuthConfig {
    fn default() -> Self {
        Self {
            auth_type: AuthType::None,
            credentials: AuthCredentials::None,
            refresh_strategy: RefreshStrategy::Never,
        }
    }
}

#[derive(Debug, Clone)]
pub enum AuthType {
    None,
    Bearer,
    ApiKey,
    Basic,
    OAuth2,
}

#[derive(Debug, Clone)]
pub enum AuthCredentials {
    None,
    Bearer { token: String },
    ApiKey { key: String, header_name: String },
    Basic { username: String, password: String },
    OAuth2 { client_id: String, client_secret: String, token_url: String },
}

#[derive(Debug, Clone)]
pub enum RefreshStrategy {
    Never,
    Automatic { refresh_threshold: Duration },
    Manual,
}

/// 缓存配置
#[derive(Debug, Clone)]
pub struct CacheConfig {
    pub enabled: bool,
    pub default_ttl: Duration,
    pub max_size: usize,
    pub cache_type: CacheType,
}

impl Default for CacheConfig {
    fn default() -> Self {
        Self {
            enabled: true,
            default_ttl: Duration::from_secs(300),
            max_size: 1000,
            cache_type: CacheType::Memory,
        }
    }
}

#[derive(Debug, Clone)]
pub enum CacheType {
    Memory,
    Redis,
}

/// API客户端
pub struct ApiClient {
    http_client: HttpClient,
    config: ClientConfig,
    circuit_breaker: Arc<RwLock<CircuitBreaker>>,
    rate_limiter: Arc<SlidingWindowRateLimiter>,
    retry_handler: Arc<RwLock<RetryHandler>>,
    cache: Arc<dyn Cache>,
    metrics: Arc<Metrics>,
}

impl ApiClient {
    /// 创建新的API客户端
    pub fn new(config: ClientConfig) -> Result<Self, ApiError> {
        // 构建HTTP客户端
        let http_client = ClientBuilder::new()
            .timeout(config.timeout)
            .connect_timeout(config.connect_timeout)
            .user_agent(&config.user_agent)
            .build()
            .map_err(ApiError::Network)?;
        
        // 创建组件
        let circuit_breaker = Arc::new(RwLock::new(CircuitBreaker::new(config.circuit_breaker_config.clone())));
        let rate_limiter = Arc::new(SlidingWindowRateLimiter::new(config.rate_limit_config.clone()));
        let retry_handler = Arc::new(RwLock::new(RetryHandler::new(config.retry_config.clone())));
        let cache = Arc::new(match config.cache_config.cache_type {
            CacheType::Memory => CacheImpl::Memory(MemoryCache::new()),
            CacheType::Redis => todo!("Redis缓存实现"),
        });
        let metrics = Arc::new(Metrics::new());
        
        Ok(Self {
            http_client,
            config,
            circuit_breaker,
            rate_limiter,
            retry_handler,
            cache,
            metrics,
        })
    }
    
    /// 发送GET请求
    pub async fn get<T>(&self, endpoint: &str) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        self.request::<(), T>(HttpMethod::GET, endpoint, None).await
    }
    
    /// 发送POST请求
    pub async fn post<B, T>(&self, endpoint: &str, body: &B) -> Result<T, ApiError>
    where
        B: Serialize,
        T: DeserializeOwned,
    {
        self.request_with_body(HttpMethod::POST, endpoint, Some(body)).await
    }
    
    /// 通用请求方法
    pub async fn request<T>(&self, method: HttpMethod, endpoint: &str, body: Option<&impl Serialize>) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        self.request_with_body::<T>(method, endpoint, body).await
    }
    
    /// 通用请求方法（带请求体）
    pub async fn request_with_body<T>(&self, method: HttpMethod, endpoint: &str, body: Option<&impl Serialize>) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        let start_time = Instant::now();
        let request_id = uuid::Uuid::new_v4().to_string();
        
        // 构建请求URL
        let url = if endpoint.starts_with("http") {
            endpoint.to_string()
        } else {
            format!("{}{}", self.config.base_url.trim_end_matches('/'), endpoint)
        };
        
        // 检查熔断器
        {
            let mut breaker = self.circuit_breaker.write().await;
            if !breaker.can_execute() {
                return Err(ApiError::CircuitBreakerOpen);
            }
        }
        
        // 检查限流器
        self.rate_limiter.acquire().await?;
        
        // 检查缓存
        let cache_key = self.generate_cache_key(&method, &url, body);
        if let Some(cached_response) = self.get_cached_response::<T>(&cache_key).await? {
            self.metrics.record_cache_hit();
            return Ok(cached_response);
        }
        
        // 执行请求
        let response = self.execute_request_with_retry(method, &url, body, request_id).await?;
        
        // 更新熔断器
        {
            let mut breaker = self.circuit_breaker.write().await;
            if response.is_ok() {
                breaker.on_success();
            } else {
                breaker.on_failure();
            }
        }
        
        // 记录指标
        self.metrics.record_request(
            method.as_str().to_string(),
            url,
            response.is_ok(),
            start_time.elapsed(),
        );
        
        match response {
            Ok(data) => {
                // 更新缓存
                if self.config.cache_config.enabled {
                    self.set_cache_response(&cache_key, &data).await?;
                }
                Ok(data)
            }
            Err(error) => {
                Err(error)
            }
        }
    }
    
    /// 执行带重试的请求
    async fn execute_request_with_retry<T>(
        &self,
        method: HttpMethod,
        url: &str,
        body: Option<&impl Serialize>,
        request_id: String,
    ) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        let initial_context = ErrorContext {
            request_id: Some(request_id),
            endpoint: Some(url.to_string()),
            method: Some(method.as_str().to_string()),
            ..Default::default()
        };
        
        let operation = |attempt: u32, context: ErrorContext| async move {
            self.perform_http_request::<T>(method.clone(), url, body, context).await
        };
        
        let mut retry_handler = self.retry_handler.write().await;
        retry_handler.execute_with_retry(operation, initial_context).await
    }
    
    /// 执行HTTP请求
    async fn perform_http_request<T>(
        &self,
        method: HttpMethod,
        url: &str,
        body: Option<&impl Serialize>,
        context: ErrorContext,
    ) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        let mut request = self.http_client
            .request(reqwest::Method::from_str(method.as_str()), url)
            .header("X-Request-ID", context.request_id.clone().unwrap_or_default());
        
        // 添加认证
        if let Err(e) = self.add_authentication(&mut request).await {
            return Err(e);
        }
        
        // 添加请求体
        if let Some(body_data) = body {
            request = request.json(body_data);
        }
        
        // 执行请求
        let response = request.send().await.map_err(ApiError::Network)?;
        let status = response.status();
        
        // 更新上下文
        let context = ErrorContext {
            status_code: Some(status),
            ..context
        };
        
        // 处理响应
        self.handle_response::<T>(response, status, context).await
    }
    
    /// 处理HTTP响应
    async fn handle_response<T>(
        &self,
        response: reqwest::Response,
        status: reqwest::StatusCode,
        context: ErrorContext,
    ) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        let headers: HashMap<String, String> = response
            .headers()
            .iter()
            .filter_map(|(k, v)| {
                v.to_str()
                    .ok()
                    .map(|s| (k.as_str().to_string(), s.to_string()))
            })
            .collect();
        
        match status {
            reqwest::StatusCode::OK | reqwest::StatusCode::CREATED | reqwest::StatusCode::ACCEPTED => {
                // 成功响应
                let data: T = response.json().await.map_err(ApiError::Serialization)?;
                Ok(data)
            }
            reqwest::StatusCode::UNAUTHORIZED => {
                // 认证错误
                let body = response.text().await.ok();
                let message = body.as_deref().unwrap_or("未授权");
                Err(ApiError::Authentication(message.to_string()))
            }
            reqwest::StatusCode::FORBIDDEN => {
                // 授权错误
                let body = response.text().await.ok();
                let message = body.as_deref().unwrap_or("禁止访问");
                Err(ApiError::Authorization(message.to_string()))
            }
            reqwest::StatusCode::TOO_MANY_REQUESTS => {
                // 频率限制
                let retry_after = response.headers()
                    .get("retry-after")
                    .and_then(|v| v.to_str().ok())
                    .and_then(|s| s.parse::<u64>().ok())
                    .map(Duration::from_secs);
                
                Err(ApiError::RateLimit {
                    remaining: None,
                    reset_time: Some(SystemTime::now()),
                    retry_after,
                })
            }
            status if status.is_server_error() => {
                // 服务器错误
                let body = response.text().await.ok();
                let message = body.as_deref().unwrap_or("服务器内部错误");
                Err(ApiError::Http {
                    status,
                    message: message.to_string(),
                    body,
                    headers,
                })
            }
            status => {
                // 其他HTTP错误
                let body = response.text().await.ok();
                let message = format!("HTTP {} 错误", status.as_u16());
                Err(ApiError::Http {
                    status,
                    message,
                    body,
                    headers,
                })
            }
        }
    }
    
    /// 添加认证
    async fn add_authentication(&self, request: &mut reqwest::RequestBuilder) -> Result<(), ApiError> {
        match &self.config.auth_config.auth_type {
            AuthType::None => Ok(()),
            AuthType::Bearer => {
                if let AuthCredentials::Bearer { token } = &self.config.auth_config.credentials {
                    let header_value = format!("Bearer {}", token);
                    Ok(request.bearer_auth(header_value))
                } else {
                    Err(ApiError::Configuration("无效的认证凭据".to_string()))
                }
            }
            AuthType::ApiKey => {
                if let AuthCredentials::ApiKey { key, header_name } = &self.config.auth_config.credentials {
                    Ok(request.header(header_name, key))
                } else {
                    Err(ApiError::Configuration("无效的API密钥".to_string()))
                }
            }
            _ => Ok(()), // 其他认证类型简化实现
        }
    }
    
    /// 生成缓存键
    fn generate_cache_key(&self, method: &HttpMethod, url: &str, body: Option<&impl Serialize>) -> String {
        let mut key = format!("{}:{}", method.as_str(), url);
        
        if let Some(body_data) = body {
            if let Ok(body_str) = serde_json::to_string(body_data) {
                key.push_str(&format!(":body:{}", body_str));
            }
        }
        
        // 简单哈希
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};
        
        let mut hasher = DefaultHasher::new();
        key.hash(&mut hasher);
        format!("cache:{:x}", hasher.finish())
    }
    
    /// 从缓存获取响应
    async fn get_cached_response<T>(&self, key: &str) -> Result<Option<T>, ApiError>
    where
        T: DeserializeOwned + Serialize,
    {
        if !self.config.cache_config.enabled {
            return Ok(None);
        }
        
        match self.cache.get(key).await {
            Ok(cached_data) => {
                if let Some(data) = cached_data {
                    let result = serde_json::from_value::<T>(data)
                        .map_err(ApiError::Serialization)?;
                    Ok(Some(result))
                } else {
                    Ok(None)
                }
            }
            Err(e) => {
                eprintln!("缓存获取失败: {:?}", e);
                Ok(None)
            }
        }
    }
    
    /// 设置缓存响应
    async fn set_cache_response<T>(&self, key: &str, data: &T) -> Result<(), ApiError>
    where
        T: Serialize,
    {
        if !self.config.cache_config.enabled {
            return Ok(());
        }
        
        let json_value = serde_json::to_value(data)
            .map_err(ApiError::Serialization)?;
        
        self.cache.set(key, &json_value, self.config.cache_config.default_ttl).await
    }
    
    /// 获取客户端状态
    pub async fn get_status(&self) -> ClientStatus {
        let circuit_breaker_status = self.circuit_breaker.read().await.status();
        let rate_limit_status = self.rate_limiter.status();
        let retry_stats = self.retry_handler.read().await.get_stats();
        let error_stats = self.metrics.get_error_stats();
        
        ClientStatus {
            circuit_breaker: circuit_breaker_status,
            rate_limiter: rate_limit_status,
            retry_stats,
            error_stats,
            total_requests: self.metrics.get_total_requests(),
        }
    }
}

/// 内存缓存实现
struct MemoryCache {
    data: Arc<RwLock<HashMap<String, (serde_json::Value, SystemTime)>>>,
    max_size: usize,
}

impl MemoryCache {
    fn new() -> Self {
        Self {
            data: Arc::new(RwLock::new(HashMap::new())),
            max_size: 1000,
        }
    }
}

#[async_trait::async_trait]
impl Cache for MemoryCache {
    async fn get(&self, key: &str) -> Result<Option<serde_json::Value>, CacheError> {
        let data = self.data.read().await;
        if let Some((value, expires_at)) = data.get(key) {
            if *expires_at > SystemTime::now() {
                Ok(Some(value.clone()))
            } else {
                // 已过期，删除
                drop(data);
                let mut data = self.data.write().await;
                data.remove(key);
                Ok(None)
            }
        } else {
            Ok(None)
        }
    }
    
    async fn set(&self, key: &str, value: &serde_json::Value, ttl: Duration) -> Result<(), CacheError> {
        let mut data = self.data.write().await;
        
        // 检查大小限制
        if data.len() >= self.max_size {
            // 简单的LRU实现：删除最旧的条目
            if let Some((oldest_key, _)) = data.iter().next() {
                data.remove(oldest_key);
            }
        }
        
        let expires_at = SystemTime::now() + ttl;
        data.insert(key.to_string(), (value.clone(), expires_at));
        
        Ok(())
    }
    
    async fn remove(&self, key: &str) -> Result<(), CacheError> {
        let mut data = self.data.write().await;
        data.remove(key);
        Ok(())
    }
    
    async fn clear(&self) -> Result<(), CacheError> {
        let mut data = self.data.write().await;
        data.clear();
        Ok(())
    }
}

/// 缓存trait
#[async_trait::async_trait]
pub trait Cache: Send + Sync {
    async fn get(&self, key: &str) -> Result<Option<serde_json::Value>, CacheError>;
    async fn set(&self, key: &str, value: &serde_json::Value, ttl: Duration) -> Result<(), CacheError>;
    async fn remove(&self, key: &str) -> Result<(), CacheError>;
    async fn clear(&self) -> Result<(), CacheError>;
}

/// 客户端状态
#[derive(Debug, Clone)]
pub struct ClientStatus {
    pub circuit_breaker: CircuitBreakerStatus,
    pub rate_limiter: RateLimitStatus,
    pub retry_stats: RetryStats,
    pub error_stats: ErrorStats,
    pub total_requests: u64,
}

/// 指标收集
pub struct Metrics {
    request_count: Arc<AtomicU64>,
    success_count: Arc<AtomicU64>,
    error_count: Arc<AtomicU64>,
    response_time_sum: Arc<AtomicU64>,
    cache_hits: Arc<AtomicU64>,
    cache_misses: Arc<AtomicU64>,
    errors_by_category: Arc<RwLock<HashMap<ErrorCategory, AtomicU64>>>,
}

impl Metrics {
    fn new() -> Self {
        Self {
            request_count: Arc::new(AtomicU64::new(0)),
            success_count: Arc::new(AtomicU64::new(0)),
            error_count: Arc::new(AtomicU64::new(0)),
            response_time_sum: Arc::new(AtomicU64::new(0)),
            cache_hits: Arc::new(AtomicU64::new(0)),
            cache_misses: Arc::new(AtomicU64::new(0)),
            errors_by_category: Arc::new(RwLock::new(HashMap::new())),
        }
    }
    
    fn record_request(&self, method: String, url: String, success: bool, duration: Duration) {
        self.request_count.fetch_add(1, Ordering::Relaxed);
        
        if success {
            self.success_count.fetch_add(1, Ordering::Relaxed);
        } else {
            self.error_count.fetch_add(1, Ordering::Relaxed);
        }
        
        self.response_time_sum.fetch_add(duration.as_millis() as u64, Ordering::Relaxed);
    }
    
    fn record_cache_hit(&self) {
        self.cache_hits.fetch_add(1, Ordering::Relaxed);
    }
    
    fn record_cache_miss(&self) {
        self.cache_misses.fetch_add(1, Ordering::Relaxed);
    }
    
    fn record_error(&self, error: &ApiError) {
        self.error_count.fetch_add(1, Ordering::Relaxed);
        
        let category = error.category();
        let errors = self.errors_by_category.clone();
        tokio::spawn(async move {
            let mut errors_map = errors.write().await;
            let counter = errors_map.entry(category).or_insert_with(|| AtomicU64::new(0));
            counter.fetch_add(1, Ordering::Relaxed);
        });
    }
    
    fn get_total_requests(&self) -> u64 {
        self.request_count.load(Ordering::Relaxed)
    }
    
    fn get_error_stats(&self) -> ErrorStats {
        let mut errors_by_category = HashMap::new();
        let errors_map = self.errors_by_category.blocking_read();
        for (category, counter) in errors_map.iter() {
            errors_by_category.insert(category.clone(), counter.load(Ordering::Relaxed));
        }
        
        ErrorStats {
            total_errors: self.error_count.load(Ordering::Relaxed),
            errors_by_category,
            last_error_time: Some(SystemTime::now()),
            error_rate: 0.0, // 简化计算
        }
    }
}
}

6.6 使用示例和测试

// 使用示例
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize)]
struct User {
    id: u64,
    name: String,
    email: String,
    created_at: String,
}

#[derive(Debug, Deserialize, Serialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}

#[derive(Debug, Deserialize, Serialize)]
struct ApiResponse<T> {
    success: bool,
    data: Option<T>,
    error: Option<String>,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建客户端配置
    let config = ClientConfig {
        base_url: "https://jsonplaceholder.typicode.com".to_string(),
        timeout: Duration::from_secs(10),
        retry_config: RetryConfig {
            max_attempts: 3,
            base_delay: Duration::from_millis(500),
            ..Default::default()
        },
        ..Default::default()
    };
    
    // 创建API客户端
    let client = ApiClient::new(config)?;
    
    // 示例1: GET请求
    println!("=== GET请求示例 ===");
    match client.get::<Vec<User>>("/users").await {
        Ok(users) => {
            println!("成功获取 {} 个用户", users.len());
            if let Some(user) = users.first() {
                println!("第一个用户: {} ({})", user.name, user.email);
            }
        }
        Err(error) => {
            println!("请求失败: {}", error);
        }
    }
    
    // 示例2: POST请求
    println!("\n=== POST请求示例 ===");
    let new_user = CreateUserRequest {
        name: "John Doe".to_string(),
        email: "john.doe@example.com".to_string(),
    };
    
    match client.post("/posts", &new_user).await {
        Ok(post) => {
            println!("创建帖子成功: {:?}", post);
        }
        Err(error) => {
            println!("创建失败: {}", error);
        }
    }
    
    // 示例3: 错误处理
    println!("\n=== 错误处理示例 ===");
    // 尝试访问不存在的端点
    match client.get::<ApiResponse<User>>("/users/9999").await {
        Ok(response) => {
            println!("响应: {:?}", response);
        }
        Err(error) => {
            println!("预期错误: {}", error);
            
            // 检查错误类型
            match error {
                ApiError::Http { status, .. } => {
                    println!("HTTP状态码: {}", status);
                }
                ApiError::Network(e) => {
                    println!("网络错误: {}", e);
                }
                _ => {
                    println!("其他错误类型");
                }
            }
        }
    }
    
    // 示例4: 获取客户端状态
    println!("\n=== 客户端状态 ===");
    let status = client.get_status().await;
    println!("熔断器状态: {:?}", status.circuit_breaker.state);
    println!("总请求数: {}", status.total_requests);
    println!("错误统计: {:?}", status.error_stats);
    
    Ok(())
}

// 测试代码
#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;
    use std::io::Write;

    #[test]
    fn test_error_classification() {
        let network_error = ApiError::Network(reqwest::Error::from(reqwest::Error::new(
            reqwest::ErrorKind::Timeout,
            "Connection timeout"
        )));
        
        let http_error = ApiError::Http {
            status: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
            message: "Internal Server Error".to_string(),
            body: None,
            headers: HashMap::new(),
        };
        
        assert!(network_error.is_retryable());
        assert!(http_error.is_retryable());
        
        assert_eq!(network_error.category(), ErrorCategory::Network);
        assert_eq!(http_error.category(), ErrorCategory::Http);
    }
    
    #[test]
    fn test_circuit_breaker() {
        let config = CircuitBreakerConfig {
            failure_threshold: 2,
            success_threshold: 1,
            ..Default::default()
        };
        
        let mut breaker = CircuitBreaker::new(config);
        
        // 测试初始状态
        assert!(breaker.can_execute());
        assert_eq!(breaker.state(), CircuitBreakerState::Closed);
        
        // 触发失败
        breaker.on_failure();
        assert_eq!(breaker.failure_count, 1);
        
        // 再次触发失败，应该进入打开状态
        breaker.on_failure();
        assert_eq!(breaker.failure_count, 2);
        assert_eq!(breaker.state(), CircuitBreakerState::Open);
        
        // 熔断器打开时不能执行
        assert!(!breaker.can_execute());
    }
    
    #[test]
    fn test_rate_limiter() {
        let config = RateLimitConfig {
            requests_per_second: 2.0,
            burst_size: 1,
            ..Default::default()
        };
        
        let limiter = SlidingWindowRateLimiter::new(config);
        
        // 第一个请求应该成功
        assert!(tokio_test::block_on(limiter.acquire()).is_ok());
        
        // 第二个请求可能会被限制
        let result = tokio_test::block_on(limiter.acquire());
        // 结果取决于具体的实现细节
    }
    
    #[test]
    fn test_retry_handler() {
        let config = RetryConfig {
            max_attempts: 3,
            base_delay: Duration::from_millis(10),
            ..Default::default()
        };
        
        let mut handler = RetryHandler::new(config);
        
        // 模拟一个总是失败的操作
        let operation = |_attempt: u32, _context: ErrorContext| async {
            Err(ApiError::Network(reqwest::Error::new(
                reqwest::ErrorKind::Timeout,
                "Connection timeout"
            )))
        };
        
        let result = tokio_test::block_on(handler.execute_with_retry(operation, ErrorContext::default()));
        
        // 应该最终返回错误
        assert!(result.is_err());
        
        // 检查重试统计
        let stats = handler.get_stats();
        assert_eq!(stats.total_attempts, 3); // 应该尝试3次
    }
}

6.7 最佳实践和高级技巧

6.7.1 错误处理最佳实践

#![allow(unused)]
fn main() {
// 错误处理最佳实践

/// 1. 错误上下文和跟踪
#[derive(Debug, Clone)]
struct ErrorWithContext {
    error: ApiError,
    context: ErrorContext,
    chain: Vec<ErrorContext>,
}

impl ErrorWithContext {
    fn new(error: ApiError, context: ErrorContext) -> Self {
        Self {
            error,
            context,
            chain: Vec::new(),
        }
    }
    
    fn with_chain(mut self, prev_error: ErrorWithContext) -> Self {
        self.chain.push(prev_error.context);
        self
    }
    
    fn print_chain(&self) {
        println!("错误链:");
        for (i, ctx) in self.chain.iter().enumerate() {
            println!("  {}: {:?}", i + 1, ctx);
        }
        println!("  当前: {:?}", self.context);
        println!("  错误: {}", self.error);
    }
}

/// 2. 错误聚合器
struct ErrorAggregator {
    errors: Vec<ErrorWithContext>,
    max_errors: usize,
}

impl ErrorAggregator {
    fn new(max_errors: usize) -> Self {
        Self {
            errors: Vec::new(),
            max_errors,
        }
    }
    
    fn add_error(&mut self, error: ErrorWithContext) {
        if self.errors.len() < self.max_errors {
            self.errors.push(error);
        }
    }
    
    fn has_critical_error(&self) -> bool {
        self.errors.iter().any(|e| matches!(e.error, ApiError::CircuitBreakerOpen))
    }
    
    fn summarize(&self) -> String {
        let total = self.errors.len();
        let categories: HashMap<ErrorCategory, usize> = self.errors
            .iter()
            .map(|e| e.error.category())
            .fold(HashMap::new(), |mut acc, cat| {
                *acc.entry(cat).or_insert(0) += 1;
                acc
            });
        
        let mut summary = format!("总错误数: {}\n", total);
        for (category, count) in categories {
            summary.push_str(&format!("  {:?}: {} 个\n", category, count));
        }
        summary
    }
}

/// 3. 优雅降级策略
struct GracefulDegradation {
    primary_service: Arc<ApiClient>,
    fallback_service: Arc<ApiClient>,
    degradation_threshold: f64, // 0.0 到 1.0
    current_error_rate: f64,
}

impl GracefulDegradation {
    fn new(primary: Arc<ApiClient>, fallback: Arc<ApiClient>) -> Self {
        Self {
            primary_service: primary,
            fallback_service: fallback,
            degradation_threshold: 0.1, // 10%错误率触发降级
            current_error_rate: 0.0,
        }
    }
    
    async fn request_with_fallback<T>(&self, method: HttpMethod, endpoint: &str, body: Option<&impl Serialize>) -> Result<T, ApiError>
    where
        T: DeserializeOwned,
    {
        // 首先尝试主要服务
        match self.primary_service.request_with_body(method.clone(), endpoint, body).await {
            Ok(result) => {
                self.update_success_rate();
                Ok(result)
            }
            Err(primary_error) => {
                // 记录错误并检查是否需要降级
                self.update_error_rate();
                
                if self.should_degrade() {
                    println!("主要服务失败，尝试降级服务");
                    match self.fallback_service.request_with_body(method, endpoint, body).await {
                        Ok(result) => {
                            println!("降级服务成功");
                            Ok(result)
                        }
                        Err(fallback_error) => {
                            // 两个服务都失败了，返回主服务错误
                            primary_error
                        }
                    }
                } else {
                    primary_error
                }
            }
           }
    
    fn should_degrade(&self) -> bool {
        self.current_error_rate > self.degradation_threshold
    }
    
    fn update_success_rate(&mut self) {
        // 更新错误率（简化实现）
        if self.current_error_rate > 0.0 {
            self.current_error_rate *= 0.9; // 成功时降低错误率
        }
    }
    
    fn update_error_rate(&mut self) {
        // 更新错误率（简化实现）
        self.current_error_rate = (self.current_error_rate + 0.1).min(1.0);
    }
    
    fn get_status(&self) -> DegradationStatus {
        DegradationStatus {
            current_error_rate: self.current_error_rate,
            threshold: self.degradation_threshold,
            should_degrade: self.should_degrade(),
        }
    }
}

#[derive(Debug, Clone)]
struct DegradationStatus {
    current_error_rate: f64,
    threshold: f64,
    should_degrade: bool,
}
}

6.7.2 异步错误处理高级模式

#![allow(unused)]
fn main() {
// 高级异步错误处理模式

/// 1. 批处理和错误聚合
async fn batch_process_with_aggregation(
    items: Vec<String>,
    processor: Arc<dyn BatchProcessor + Send + Sync>,
) -> Result<BatchResult, BatchError> {
    use tokio::sync::Semaphore;
    use std::sync::atomic::{AtomicUsize, Ordering};
    
    let semaphore = Arc::new(Semaphore::new(10));
    let processed_count = Arc::new(AtomicUsize::new(0));
    let error_aggregator = Arc::new(Mutex::new(ErrorAggregator::new(100)));
    
    let mut handles = Vec::new();
    
    for (index, item) in items.into_iter().enumerate() {
        let semaphore = semaphore.clone();
        let processor = processor.clone();
        let processed_count = processed_count.clone();
        let error_aggregator = error_aggregator.clone();
        
        let handle = tokio::spawn(async move {
            let _permit = semaphore.acquire().await.unwrap();
            
            match processor.process_batch_item(index, &item).await {
                Ok(_) => {
                    processed_count.fetch_add(1, Ordering::Relaxed);
                    (index, Ok(()))
                }
                Err(error) => {
                    let error_with_context = ErrorWithContext::new(
                        error,
                        ErrorContext {
                            request_id: Some(format!("item_{}", index)),
                            ..Default::default()
                        }
                    );
                    
                    let mut aggregator = error_aggregator.lock().await;
                    aggregator.add_error(error_with_context);
                    (index, Err(()))
                }
            }
        });
        
        handles.push(handle);
    }
    
    // 等待所有任务完成
    let mut results = Vec::new();
    for handle in handles {
        if let Ok((index, result)) = handle.await {
            results.push((index, result));
        }
    }
    
    // 检查结果
    let mut aggregator = error_aggregator.lock().await;
    let error_count = aggregator.errors.len();
    
    if aggregator.has_critical_error() {
        return Err(BatchError::Critical(aggregator.errors));
    }
    
    if error_count > 0 {
        return Err(BatchError::Partial {
            success_count: processed_count.load(Ordering::Relaxed),
            error_count,
            errors: aggregator.errors.clone(),
        });
    }
    
    Ok(BatchResult {
        total_processed: processed_count.load(Ordering::Relaxed),
        errors: Vec::new(),
    })
}

/// 批处理错误类型
#[derive(Debug, thiserror::Error)]
pub enum BatchError {
    #[error("关键错误: {0:?}")]
    Critical(Vec<ErrorWithContext>),
    
    #[error("部分成功: 成功 {success_count}, 失败 {error_count}")]
    Partial {
        success_count: usize,
        error_count: usize,
        errors: Vec<ErrorWithContext>,
    },
}

/// 批处理结果
#[derive(Debug)]
struct BatchResult {
    total_processed: usize,
    errors: Vec<ErrorWithContext>,
}

/// 批处理器trait
#[async_trait::async_trait]
pub trait BatchProcessor: Send + Sync {
    async fn process_batch_item(&self, index: usize, item: &str) -> Result<(), ApiError>;
}

/// 2. 错误恢复策略
enum RecoveryStrategy {
    RetryWithBackoff,
    UseCache,
    CallFallbackService,
    SkipAndContinue,
    FailFast,
}

impl RecoveryStrategy {
    fn select_strategy(error: &ApiError) -> Self {
        match error {
            ApiError::Network(_) | ApiError::Timeout(_) => RecoveryStrategy::RetryWithBackoff,
            ApiError::Http { status, .. } if status.is_server_error() => RecoveryStrategy::UseCache,
            ApiError::RateLimit { .. } => RecoveryStrategy::RetryWithBackoff,
            ApiError::CircuitBreakerOpen => RecoveryStrategy::CallFallbackService,
            ApiError::Validation(_) | ApiError::Business(_) => RecoveryStrategy::FailFast,
            _ => RecoveryStrategy::SkipAndContinue,
        }
    }
}

async fn recover_from_error<T>(
    original_result: Result<T, ApiError>,
    recovery_context: &RecoveryContext,
) -> Result<T, ApiError> {
    match original_result {
        Ok(data) => Ok(data),
        Err(error) => {
            let strategy = RecoveryStrategy::select_strategy(&error);
            
            match strategy {
                RecoveryStrategy::RetryWithBackoff => {
                    // 执行重试
                    let delay = error.recommended_delay().unwrap_or(Duration::from_millis(100));
                    tokio::time::sleep(delay).await;
                    Err(error)
                }
                RecoveryStrategy::UseCache => {
                    // 尝试从缓存获取
                    if let Some(cached_data) = &recovery_context.cached_data {
                        Ok(cached_data.clone())
                    } else {
                        Err(error)
                    }
                }
                RecoveryStrategy::CallFallbackService => {
                    // 使用备用服务
                    if let Some(fallback_result) = &recovery_context.fallback_result {
                        fallback_result.clone()
                    } else {
                        Err(error)
                    }
                }
                RecoveryStrategy::SkipAndContinue => {
                    // 跳过错误（适用于批量操作）
                    if let Some(default_data) = &recovery_context.default_data {
                        Ok(default_data.clone())
                    } else {
                        Err(error)
                    }
                }
                RecoveryStrategy::FailFast => Err(error),
            }
        }
    }
}

/// 恢复上下文
struct RecoveryContext {
    cached_data: Option<serde_json::Value>,
    fallback_result: Option<serde_json::Value>,
    default_data: Option<serde_json::Value>,
}
}

6.7.3 监控和告警

#![allow(unused)]
fn main() {
// 错误监控和告警系统

/// 错误监控器
pub struct ErrorMonitor {
    config: MonitorConfig,
    metrics: Arc<Metrics>,
    alerts: Arc<AlertManager>,
    history: Arc<RwLock<Vec<ErrorRecord>>>,
}

#[derive(Debug, Clone)]
pub struct MonitorConfig {
    pub error_rate_threshold: f64,
    pub error_count_threshold: u64,
    pub time_window: Duration,
    pub alert_channels: Vec<AlertChannel>,
}

#[derive(Debug, Clone)]
pub enum AlertChannel {
    Email { smtp_server: String, recipients: Vec<String> },
    Webhook { url: String, headers: HashMap<String, String> },
    Slack { webhook_url: String, channel: String },
}

impl ErrorMonitor {
    pub fn new(config: MonitorConfig, metrics: Arc<Metrics>) -> Self {
        Self {
            config,
            metrics,
            alerts: Arc::new(AlertManager::new()),
            history: Arc::new(RwLock::new(Vec::new())),
        }
    }
    
    pub async fn record_error(&self, error: &ApiError) {
        // 记录错误
        let record = ErrorRecord::new(error);
        let mut history = self.history.write().await;
        history.push(record);
        
        // 清理过期记录
        self.cleanup_old_records(&mut history).await;
        
        // 检查是否需要告警
        self.check_alerts().await;
    }
    
    async fn check_alerts(&self) {
        let history = self.history.read().await;
        let recent_errors = self.get_recent_errors(&history).await;
        
        if recent_errors.len() > self.config.error_count_threshold as usize {
            self.trigger_alert(AlertType::HighErrorCount {
                count: recent_errors.len(),
                threshold: self.config.error_count_threshold,
            }).await;
        }
        
        let error_rate = self.calculate_error_rate(&recent_errors);
        if error_rate > self.config.error_rate_threshold {
            self.trigger_alert(AlertType::HighErrorRate {
                rate: error_rate,
                threshold: self.config.error_rate_threshold,
            }).await;
        }
    }
    
    async fn get_recent_errors(&self, history: &[ErrorRecord]) -> Vec<&ErrorRecord> {
        let now = SystemTime::now();
        history.iter()
            .filter(|record| {
                now.duration_since(record.timestamp)
                    .map(|duration| duration < self.config.time_window)
                    .unwrap_or(false)
            })
            .collect()
    }
    
    fn calculate_error_rate(&self, errors: Vec<&ErrorRecord>) -> f64 {
        if errors.is_empty() {
            return 0.0;
        }
        
        let time_span = errors
            .iter()
            .map(|r| r.timestamp)
            .min()
            .and_then(|min_time| {
                errors
                    .iter()
                    .map(|r| r.timestamp)
                    .max()
                    .map(|max_time| max_time.duration_since(min_time))
            })
            .unwrap_or_else(|| Duration::from_secs(1));
        
        errors.len() as f64 / time_span.as_secs_f64()
    }
    
    async fn trigger_alert(&self, alert_type: AlertType) {
        for channel in &self.config.alert_channels {
            match self.send_alert(channel, &alert_type).await {
                Ok(_) => println!("告警发送成功: {:?}", alert_type),
                Err(e) => eprintln!("告警发送失败: {:?}", e),
            }
        }
    }
    
    async fn send_alert(&self, channel: &AlertChannel, alert: &AlertType) -> Result<(), AlertError> {
        match channel {
            AlertChannel::Email { smtp_server, recipients } => {
                // 简化实现：实际应该使用SMTP库
                println!("发送邮件告警到 {:?}: {:?}", recipients, alert);
                Ok(())
            }
            AlertChannel::Webhook { url, headers } => {
                // 使用reqwest发送webhook
                let client = reqwest::Client::new();
                let response = client
                    .post(url)
                    .headers(headers.clone())
                    .json(alert)
                    .send()
                    .await
                    .map_err(|e| AlertError::Network(e))?;
                
                if !response.status().is_success() {
                    return Err(AlertError::Http(response.status()));
                }
                
                Ok(())
            }
            AlertChannel::Slack { webhook_url, channel } => {
                // 发送Slack消息
                let client = reqwest::Client::new();
                let payload = SlackPayload {
                    channel,
                    text: format!("告警: {:?}", alert),
                    username: "ErrorMonitor",
                    icon_emoji: ":warning:",
                };
                
                client
                    .post(webhook_url)
                    .json(&payload)
                    .send()
                    .await
                    .map_err(|e| AlertError::Network(e))?;
                
                Ok(())
            }
        }
    }
    
    async fn cleanup_old_records(&self, history: &mut Vec<ErrorRecord>) {
        let now = SystemTime::now();
        history.retain(|record| {
            now.duration_since(record.timestamp)
                .map(|duration| duration < self.config.time_window * 2) // 保留两倍时间窗口
                .unwrap_or(false)
        });
    }
}

/// 错误记录
#[derive(Debug, Clone)]
struct ErrorRecord {
    timestamp: SystemTime,
    error: ApiError,
    context: ErrorContext,
}

/// 告警类型
#[derive(Debug, Serialize, Deserialize)]
#[serde(tag = "type")]
enum AlertType {
    #[serde(rename = "high_error_count")]
    HighErrorCount { count: usize, threshold: u64 },
    
    #[serde(rename = "high_error_rate")]
    HighErrorRate { rate: f64, threshold: f64 },
    
    #[serde(rename = "circuit_breaker_opened")]
    CircuitBreakerOpened,
    
    #[serde(rename = "service_unavailable")]
    ServiceUnavailable { reason: String },
}

/// 告警管理器
struct AlertManager;

impl AlertManager {
    fn new() -> Self {
        Self
    }
}

/// 告警错误
#[derive(Debug, thiserror::Error)]
pub enum AlertError {
    #[error("网络错误: {0}")]
    Network(reqwest::Error),
    
    #[error("HTTP错误: {0}")]
    Http(reqwest::StatusCode),
    
    #[error("配置错误: {0}")]
    Config(String),
    
    #[error("发送失败: {0}")]
    SendFailed(String),
}

/// Slack消息负载
#[derive(Debug, Serialize)]
struct SlackPayload {
    channel: String,
    text: String,
    username: String,
    icon_emoji: String,
}
}

6.8 性能优化和调试

#![allow(unused)]
fn main() {
// 性能优化和调试工具

/// 性能分析器
pub struct PerformanceProfiler {
    operations: Arc<RwLock<HashMap<String, OperationStats>>>,
    enabled: bool,
}

#[derive(Debug, Clone)]
struct OperationStats {
    call_count: u64,
    total_time: Duration,
    min_time: Option<Duration>,
    max_time: Option<Duration>,
    error_count: u64,
}

impl PerformanceProfiler {
    fn new(enabled: bool) -> Self {
        Self {
            operations: Arc::new(RwLock::new(HashMap::new())),
            enabled,
        }
    }
    
    async fn record_operation(&self, name: &str, duration: Duration, success: bool) {
        if !self.enabled {
            return;
        }
        
        let mut stats_map = self.operations.write().await;
        let stats = stats_map.entry(name.to_string()).or_insert_with(|| OperationStats {
            call_count: 0,
            total_time: Duration::from_millis(0),
            min_time: None,
            max_time: None,
            error_count: 0,
        });
        
        stats.call_count += 1;
        stats.total_time += duration;
        stats.min_time = Some(stats.min_time.map_or(duration, |min| min.min(duration)));
        stats.max_time = Some(stats.max_time.map_or(duration, |max| max.max(duration)));
        
        if !success {
            stats.error_count += 1;
        }
    }
    
    async fn get_report(&self) -> PerformanceReport {
        let stats_map = self.operations.read().await;
        
        let mut report = PerformanceReport::new();
        
        for (name, stats) in stats_map.iter() {
            let avg_time = if stats.call_count > 0 {
                Duration::from_nanos(stats.total_time.as_nanos() as u64 / stats.call_count)
            } else {
                Duration::from_millis(0)
            };
            
            let success_rate = if stats.call_count > 0 {
                (stats.call_count - stats.error_count) as f64 / stats.call_count as f64
            } else {
                1.0
            };
            
            report.add_operation(OperationReport {
                name: name.clone(),
                call_count: stats.call_count,
                total_time: stats.total_time,
                avg_time,
                min_time: stats.min_time,
                max_time: stats.max_time,
                success_rate,
                error_count: stats.error_count,
            });
        }
        
        report
    }
}

/// 性能报告
#[derive(Debug)]
struct PerformanceReport {
    operations: Vec<OperationReport>,
    total_operations: u64,
    total_time: Duration,
}

impl PerformanceReport {
    fn new() -> Self {
        Self {
            operations: Vec::new(),
            total_operations: 0,
            total_time: Duration::from_millis(0),
        }
    }
    
    fn add_operation(&mut self, operation: OperationReport) {
        self.operations.push(operation);
        self.total_operations += 1;
    }
    
    fn generate_text(&self) -> String {
        let mut report = String::new();
        report.push_str(&format!("=== 性能报告 ===\n"));
        report.push_str(&format!("总操作数: {}\n", self.total_operations));
        report.push_str(&format!("总耗时: {:?}\n\n", self.total_time));
        
        for op in &self.operations {
            report.push_str(&format!("操作: {}\n", op.name));
            report.push_str(&format!("  调用次数: {}\n", op.call_count));
            report.push_str(&format!("  平均耗时: {:?}\n", op.avg_time));
            report.push_str(&format!("  最小耗时: {:?}\n", op.min_time));
            report.push_str(&format!("  最大耗时: {:?}\n", op.max_time));
            report.push_str(&format!("  成功率: {:.2}%\n", op.success_rate * 100.0));
            report.push_str(&format!("  错误数: {}\n", op.error_count));
            report.push_str("\n");
        }
        
        report
    }
}

#[derive(Debug)]
struct OperationReport {
    name: String,
    call_count: u64,
    total_time: Duration,
    avg_time: Duration,
    min_time: Option<Duration>,
    max_time: Option<Duration>,
    success_rate: f64,
    error_count: u64,
}

/// 调试工具
pub struct DebugTools {
    profiler: PerformanceProfiler,
    trace_collector: TraceCollector,
}

impl DebugTools {
    fn new() -> Self {
        Self {
            profiler: PerformanceProfiler::new(true),
            trace_collector: TraceCollector::new(),
        }
    }
    
    async fn start_trace(&self, trace_id: &str) -> TraceContext {
        let span = self.trace_collector.start_span(trace_id);
        TraceContext::new(span)
    }
    
    async fn record_metric(&self, name: &str, value: f64, tags: HashMap<String, String>) {
        self.trace_collector.record_metric(name, value, tags).await;
    }
}

/// 分布式跟踪收集器
struct TraceCollector {
    spans: Arc<RwLock<Vec<TraceSpan>>>,
}

#[derive(Debug, Clone)]
struct TraceSpan {
    id: String,
    parent_id: Option<String>,
    operation: String,
    start_time: SystemTime,
    end_time: Option<SystemTime>,
    tags: HashMap<String, String>,
    metrics: Vec<Metric>,
}

#[derive(Debug, Clone)]
struct Metric {
    name: String,
    value: f64,
    tags: HashMap<String, String>,
    timestamp: SystemTime,
}

impl TraceCollector {
    fn new() -> Self {
        Self {
            spans: Arc::new(RwLock::new(Vec::new())),
        }
    }
    
    fn start_span(&self, operation: &str) -> String {
        let span_id = uuid::Uuid::new_v4().to_string();
        let span = TraceSpan {
            id: span_id.clone(),
            parent_id: None,
            operation: operation.to_string(),
            start_time: SystemTime::now(),
            end_time: None,
            tags: HashMap::new(),
            metrics: Vec::new(),
        };
        
        let mut spans = self.spans.blocking_write();
        spans.push(span);
        
        span_id
    }
    
    async fn end_span(&self, span_id: &str) {
        let mut spans = self.spans.write().await;
        
        if let Some(span) = spans.iter_mut().find(|s| s.id == span_id) {
            span.end_time = Some(SystemTime::now());
        }
    }
    
    async fn record_metric(&self, name: &str, value: f64, tags: HashMap<String, String>) {
        let metric = Metric {
            name: name.to_string(),
            value,
            tags,
            timestamp: SystemTime::now(),
        };
        
        // 简化实现：记录到最后一个活跃span
        let mut spans = self.spans.write().await;
        if let Some(span) = spans.iter_mut().last() {
            span.metrics.push(metric);
        }
    }
    
    fn get_trace(&self) -> Vec<TraceSpan> {
        self.spans.blocking_read().clone()
    }
}

/// 跟踪上下文
struct TraceContext {
    span_id: String,
    collector: Arc<TraceCollector>,
}

impl TraceContext {
    fn new(span_id: String) -> Self {
        Self {
            span_id,
            collector: Arc::new(TraceCollector::new()), // 简化实现
        }
    }
    
    fn add_tag(&self, key: &str, value: &str) {
        // 简化实现
    }
    
    fn add_metric(&self, name: &str, value: f64) {
        // 简化实现
    }
}

impl Drop for TraceContext {
    fn drop(&mut self) {
        let collector = self.collector.clone();
        let span_id = self.span_id.clone();
        
        tokio::spawn(async move {
            collector.end_span(&span_id).await;
        });
    }
}
}

6.9 总结

在本章中，我们深入学习了Rust的错误处理机制，并通过构建一个企业级API客户端库来实践这些概念。主要内容包括：

6.9.1 核心概念

Option和Result<T, E>：Rust中处理可选值和可能失败操作的基础
错误传播：?操作符和Result链式操作
自定义错误类型：为特定领域定义有意义的错误类型
错误分类和恢复：根据错误类型选择合适的恢复策略

6.9.2 实战项目亮点

细粒度错误分类：网络错误、HTTP错误、认证错误、业务错误等
重试机制：指数退避、抖动算法、智能重试判断
熔断器模式：防止级联故障，提高系统稳定性
限流控制：滑动窗口和令牌桶算法
监控和告警：错误率监控、实时告警

6.9.3 最佳实践

显式错误处理：不忽略任何可能的错误
错误上下文：记录足够的调试信息
优雅降级：主要服务失败时使用备用服务
性能监控：跟踪操作耗时和成功率
告警机制：及时发现和响应问题

通过这个项目，我们展示了如何在实际企业环境中应用Rust的错误处理特性来构建可靠、可维护的异步网络应用。错误处理不仅仅是异常捕获，更是系统设计和架构决策的重要组成部分。

这个API客户端库可以作为企业级网络应用的基础框架，支持：

高并发请求处理
智能错误恢复
实时性能监控
多级告警机制
完整的错误跟踪

在下一章中，我们将学习Rust的集合类型和数据结构，进一步扩展我们的知识体系。

第7章：集合类型与数据结构

引言

集合类型是任何编程语言的核心，Rust提供了丰富的集合类型来满足不同的数据存储和操作需求。在本章中，我们将深入学习：

Vector（Vec）：动态数组，支持随机访问和高效追加
HashMap与HashSet：哈希表实现，提供O(1)查找性能
迭代器：函数式编程的核心工具
性能考虑：何时使用哪种集合类型

通过两个实战项目（Todo管理器和Web API服务器），我们将学习如何在实际应用中高效使用这些集合类型。

本章学习目标

完成本章学习后，你将能够：

熟练使用各种Rust集合类型
理解不同集合类型的性能特征
设计高效的集合操作策略
构建基于集合的复杂应用

Vector深入理解

Vector基础

Vector（动态数组）是Rust中最常用的集合类型，提供了动态大小的连续内存存储。

// 创建Vector的多种方式
fn main() {
    // 1. 使用vec!宏创建
    let mut numbers = vec![1, 2, 3, 4, 5];
    
    // 2. 动态创建空Vector并添加元素
    let mut names: Vec<String> = Vec::new();
    names.push("Alice".to_string());
    names.push("Bob".to_string());
    
    // 3. 预分配空间
    let mut buffer = Vec::with_capacity(1000);
    
    // 4. 使用迭代器创建
    let squares: Vec<i32> = (1..=10).map(|x| x * x).collect();
    
    println!("Numbers: {:?}", numbers);
    println!("Names: {:?}", names);
    println!("Buffer capacity: {}", buffer.capacity());
    println!("Squares: {:?}", squares);
}

Vector核心操作

#![allow(unused)]
fn main() {
use std::collections::BTreeMap;

fn vector_operations_demo() {
    let mut data = vec![3, 1, 4, 1, 5, 9, 2, 6];
    
    // 1. 访问元素
    println!("First element: {}", data[0]); // 索引访问
    println!("First element (safe): {:?}", data.get(0)); // 安全访问
    println!("Last element: {}", data[data.len() - 1]);
    
    // 2. 修改元素
    data[2] = 10;
    println!("Modified data: {:?}", data);
    
    // 3. 添加和删除
    data.push(15);         // 添加到末尾
    data.insert(3, 7);     // 插入到指定位置
    let popped = data.pop(); // 从末尾删除
    let removed = data.remove(1); // 删除指定位置的元素
    
    println!("After modifications: {:?}", data);
    println!("Popped: {:?}", popped);
    println!("Removed: {:?}", removed);
    
    // 4. 切片操作
    let slice = &data[2..=5];
    println!("Slice: {:?}", slice);
    
    // 5. 查找元素
    if let Some(&index) = data.iter().position(|&x| x == 10) {
        println!("Found 10 at index: {}", index);
    }
    
    // 6. 排序
    data.sort();
    println!("Sorted: {:?}", data);
    
    // 7. 去重
    data.dedup();
    println!("After dedup: {:?}", data);
}
}

Vector内存管理

#![allow(unused)]
fn main() {
fn vector_memory_management() {
    // 1. 预分配容量优化
    let start = std::time::Instant::now();
    let mut unoptimized = Vec::new();
    for i in 0..10000 {
        unoptimized.push(i);
    }
    let unoptimized_time = start.elapsed();
    
    // 2. 预分配容量
    let start = std::time::Instant::now();
    let mut optimized = Vec::with_capacity(10000);
    for i in 0..10000 {
        optimized.push(i);
    }
    let optimized_time = start.elapsed();
    
    println!("Unoptimized time: {:?}", unoptimized_time);
    println!("Optimized time: {:?}", optimized_time);
    println!("Capacity: {}, Length: {}", optimized.capacity(), optimized.len());
    
    // 3. 收缩到合适大小
    optimized.shrink_to_fit();
    println!("After shrink_to_fit - Capacity: {}", optimized.capacity());
    
    // 4. 保留指定容量
    optimized.reserve(5000);
    println!("After reserve(5000) - Capacity: {}", optimized.capacity());
}
}

Vector性能分析

#![allow(unused)]
fn main() {
fn vector_performance_analysis() {
    use std::time::{Duration, Instant};
    
    // 1. 顺序访问性能
    let large_vec: Vec<i32> = (0..1_000_000).collect();
    
    let start = Instant::now();
    for i in 0..large_vec.len() {
        let _ = large_vec[i];
    }
    let sequential_time = start.elapsed();
    
    // 2. 迭代器访问性能
    let start = Instant::now();
    for value in &large_vec {
        let _ = *value;
    }
    let iterator_time = start.elapsed();
    
    println!("Sequential access: {:?}", sequential_time);
    println!("Iterator access: {:?}", iterator_time);
    
    // 3. 预分配vs动态增长
    let iterations = 1000;
    let batch_size = 1000;
    
    // 不预分配
    let start = Instant::now();
    let mut vec1 = Vec::new();
    for _ in 0..iterations {
        for i in 0..batch_size {
            vec1.push(i);
        }
    }
    let no_prealloc_time = start.elapsed();
    
    // 预分配
    let start = Instant::now();
    let mut vec2 = Vec::with_capacity(iterations * batch_size);
    for _ in 0..iterations {
        for i in 0..batch_size {
            vec2.push(i);
        }
    }
    let prealloc_time = start.elapsed();
    
    println!("No pre-allocation: {:?}", no_prealloc_time);
    println!("With pre-allocation: {:?}", prealloc_time);
}
}

HashMap与HashSet详解

HashMap基础

HashMap是Rust中最重要的键值对存储结构，提供O(1)平均时间复杂度的查找、插入和删除操作。

#![allow(unused)]
fn main() {
use std::collections::HashMap;
use std::collections::HashSet;

fn hashmap_basic_operations() {
    // 1. 创建HashMap
    let mut scores = HashMap::new();
    let mut settings = HashMap::from([
        ("theme", "dark"),
        ("language", "Rust"),
        ("editor", "VSCode")
    ]);
    
    // 2. 插入键值对
    scores.insert("Blue", 10);
    scores.insert("Red", 50);
    scores.insert("Green", 25);
    
    // 3. 访问值
    println!("Blue score: {:?}", scores.get("Blue"));
    println!("All scores: {:?}", scores);
    
    // 4. 批量插入
    let additional_scores = vec![
        ("Yellow", 30),
        ("Purple", 40)
    ];
    scores.extend(additional_scores);
    
    // 5. 检查键是否存在
    if scores.contains_key("Red") {
        println!("Red team exists");
    }
    
    // 6. 获取并更新
    let old_value = scores.insert("Red", 60);
    println!("Old Red value: {:?}", old_value);
    
    // 7. 键值对计数
    println!("Number of teams: {}", scores.len());
}
}

HashMap高级操作

#![allow(unused)]
fn main() {
fn hashmap_advanced_operations() {
    let mut inventory = HashMap::new();
    
    // 1. 条件插入（仅当键不存在时）
    inventory.entry("widget").or_insert(0);
    inventory.entry("gadget").or_insert_with(|| 10);
    
    // 2. 修改现有值
    {
        let count = inventory.entry("widget").or_insert(0);
        *count += 5;
    }
    
    // 3. 使用Entry API
    for (item, count) in &inventory {
        println!("{}: {}", item, count);
    }
    
    // 4. 移除键值对
    if let Some(removed_value) = inventory.remove("gadget") {
        println!("Removed gadget with count: {}", removed_value);
    }
    
    // 5. 过滤操作
    let high_inventory: HashMap<String, i32> = inventory
        .iter()
        .filter(|(&k, &v)| v > 5)
        .map(|(k, v)| (k.clone(), *v))
        .collect();
    
    println!("High inventory: {:?}", high_inventory);
    
    // 6. 聚合操作
    let total_items: i32 = inventory.values().sum();
    let unique_items = inventory.keys().len();
    
    println!("Total items: {}", total_items);
    println!("Unique items: {}", unique_items);
}
}

HashSet详解

HashSet是基于HashMap实现的集合类型，用于存储唯一的值。

#![allow(unused)]
fn main() {
fn hashset_operations() {
    // 1. 创建HashSet
    let mut colors: HashSet<String> = HashSet::new();
    let predefined_colors = vec![
        "red".to_string(),
        "green".to_string(),
        "blue".to_string()
    ];
    let mut color_set: HashSet<String> = predefined_colors.into_iter().collect();
    
    // 2. 添加元素
    colors.insert("yellow".to_string());
    colors.insert("red".to_string()); // 不会重复添加
    colors.insert("blue".to_string());
    
    // 3. 集合操作
    let set1: HashSet<i32> = vec![1, 2, 3, 4, 5].into_iter().collect();
    let set2: HashSet<i32> = vec![3, 4, 5, 6, 7].into_iter().collect();
    
    // 并集
    let union: HashSet<i32> = set1.union(&set2).cloned().collect();
    println!("Union: {:?}", union);
    
    // 交集
    let intersection: HashSet<i32> = set1.intersection(&set2).cloned().collect();
    println!("Intersection: {:?}", intersection);
    
    // 差集
    let difference: HashSet<i32> = set1.difference(&set2).cloned().collect();
    println!("Difference: {:?}", difference);
    
    // 对称差集
    let symmetric_difference: HashSet<i32> = 
        set1.symmetric_difference(&set2).cloned().collect();
    println!("Symmetric difference: {:?}", symmetric_difference);
    
    // 4. 集合关系
    println!("set1 is subset of set2: {}", set1.is_subset(&set2));
    println!("set1 is superset of set2: {}", set1.is_superset(&set2));
    println!("set1 is disjoint with set2: {}", set1.is_disjoint(&set2));
}
}

自定义类型作为HashMap键

#![allow(unused)]
fn main() {
use std::hash::{Hash, Hasher};
use std::collections::hash_map::DefaultHasher;

#[derive(Debug, Clone, PartialEq, Eq)]
struct Person {
    id: u32,
    name: String,
    email: String,
}

impl Hash for Person {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.id.hash(state);
        self.name.hash(state);
        self.email.hash(state);
    }
}

fn custom_type_as_key() {
    let mut people_db = HashMap::new();
    
    let person1 = Person {
        id: 1,
        name: "Alice Johnson".to_string(),
        email: "alice@example.com".to_string(),
    };
    
    let person2 = Person {
        id: 2,
        name: "Bob Smith".to_string(),
        email: "bob@example.com".to_string(),
    };
    
    people_db.insert(person1, "Developer");
    people_db.insert(person2.clone(), "Designer");
    
    // 查找
    if let Some(role) = people_db.get(&person2) {
        println!("Bob's role: {}", role);
    }
    
    // 计算哈希值
    let hasher = DefaultHasher::new();
    let hash = person2.hash(hasher);
    println!("Bob's hash: {}", hash);
}
}

迭代器与闭包的深入应用

迭代器基础

#![allow(unused)]
fn main() {
fn iterator_basics() {
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 1. 基本迭代
    for num in numbers.iter() {
        println!("Number: {}", num);
    }
    
    // 2. 消费迭代器
    let sum: i32 = numbers.iter().sum();
    println!("Sum: {}", sum);
    
    // 3. 映射操作
    let squares: Vec<i32> = numbers
        .iter()
        .map(|&x| x * x)
        .collect();
    println!("Squares: {:?}", squares);
    
    // 4. 过滤操作
    let evens: Vec<&i32> = numbers
        .iter()
        .filter(|&&x| x % 2 == 0)
        .collect();
    println!("Even numbers: {:?}", evens);
    
    // 5. 链式操作
    let result: Vec<i32> = numbers
        .iter()
        .filter(|&&x| x > 2)
        .map(|&x| x * 2)
        .collect();
    println!("Doubled and filtered: {:?}", result);
    
    // 6. 查找操作
    if let Some(&first_even) = numbers.iter().find(|&&x| x % 2 == 0) {
        println!("First even number: {}", first_even);
    }
    
    // 7. 位置查找
    if let Some(position) = numbers.iter().position(|&&x| x == 4) {
        println!("4 is at position: {}", position);
    }
}
}

复杂迭代器模式

#![allow(unused)]
fn main() {
fn complex_iterator_patterns() {
    let data = vec![
        ("Alice", 25, "Engineer"),
        ("Bob", 30, "Designer"),
        ("Charlie", 35, "Manager"),
        ("Diana", 28, "Engineer"),
    ];
    
    // 1. 元组解构迭代
    let engineers: Vec<&str> = data
        .iter()
        .filter(|(_, _, role)| *role == "Engineer")
        .map(|(name, _, _)| *name)
        .collect();
    println!("Engineers: {:?}", engineers);
    
    // 2. 分组操作
    let mut age_groups = HashMap::new();
    for (name, age, role) in &data {
        age_groups
            .entry(if *age < 30 { "young" } else { "experienced" })
            .or_insert_with(Vec::new)
            .push((name, age, role));
    }
    println!("Age groups: {:?}", age_groups);
    
    // 3. 累积操作
    let total_ages: usize = data
        .iter()
        .map(|(_, age, _)| *age)
        .fold(0, |acc, age| acc + age as usize);
    let average_age = total_ages / data.len();
    println!("Average age: {}", average_age);
    
    // 4. 嵌套迭代
    let combos: Vec<_> = data
        .iter()
        .flat_map(|(name1, _, _)| {
            data.iter()
                .filter(move |(name2, _, _)| name1 != name2)
                .map(move |(name2, _, _)| format!("{} - {}", name1, name2))
        })
        .collect();
    println!("Name combinations: {:?}", combos);
}
}

闭包与迭代器

#![allow(unused)]
fn main() {
fn closures_with_iterators() {
    // 1. 捕获环境的闭包
    let threshold = 30;
    let numbers = vec![10, 25, 35, 40, 55];
    
    let above_threshold: Vec<i32> = numbers
        .iter()
        .filter(|&&x| {
            let condition = x > threshold;
            println!("Checking {} > {}: {}", x, threshold, condition);
            condition
        })
        .map(|&x| {
            let processed = x * 2;
            println!("Processing {} -> {}", x, processed);
            processed
        })
        .collect();
    println!("Above threshold (doubled): {:?}", above_threshold);
    
    // 2. 高阶函数模式
    let numbers = vec![1, 2, 3, 4, 5];
    
    // 创建通用的数据处理函数
    let process_data = |data: &Vec<i32>, filter: &dyn Fn(&i32) -> bool, 
                       transform: &dyn Fn(&i32) -> i32| -> Vec<i32> {
        data
            .iter()
            .filter(filter)
            .map(transform)
            .collect()
    };
    
    let evens_squared = process_data(
        &numbers,
        |&x| x % 2 == 0,
        |&x| x * x
    );
    
    let odds_cubed = process_data(
        &numbers,
        |&x| x % 2 == 1,
        |&x| x * x * x
    );
    
    println!("Evens squared: {:?}", evens_squared);
    println!("Odds cubed: {:?}", odds_cubed);
}
}

惰性计算与性能

#![allow(unused)]
fn main() {
fn lazy_evaluation_performance() {
    use std::time::Instant;
    
    // 1. 惰性迭代器
    let large_data: Vec<i32> = (1..=1_000_000).collect();
    
    // 计算1到1000000之间所有偶数的平方
    let start = Instant::now();
    let result: Vec<i32> = large_data
        .iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| x * x)
        .take(5) // 只取前5个结果
        .collect();
    let lazy_time = start.elapsed();
    
    println!("Lazy evaluation result: {:?}", result);
    println!("Lazy evaluation time: {:?}", lazy_time);
    
    // 2. 早期退出
    let start = Instant::now();
    let first_large_square = large_data
        .iter()
        .filter(|&&x| x % 2 == 0)
        .find(|&&x| x > 1000)
        .map(|&x| x * x);
    let early_exit_time = start.elapsed();
    
    println!("First large square: {:?}", first_large_square);
    println!("Early exit time: {:?}", early_exit_time);
    
    // 3. 链式操作优化
    let start = Instant::now();
    let chain_result: Vec<i32> = large_data
        .iter()
        .filter(|&&x| x % 2 == 0)
        .map(|&x| {
            // 模拟一个昂贵的操作
            std::thread::sleep(std::time::Duration::from_millis(1));
            x * x
        })
        .take(10)
        .collect();
    let chain_time = start.elapsed();
    
    println!("Chain operation time: {:?}", chain_time);
}
}

其他重要集合类型

BTreeMap与BTreeSet

#![allow(unused)]
fn main() {
use std::collections::{BTreeMap, BTreeSet};

fn btree_collections() {
    // 1. BTreeMap - 保持键的排序
    let mut btree_map: BTreeMap<String, i32> = BTreeMap::new();
    
    btree_map.insert("Charlie".to_string(), 35);
    btree_map.insert("Alice".to_string(), 25);
    btree_map.insert("Bob".to_string(), 30);
    
    println!("BTreeMap (sorted by key):");
    for (name, age) in &btree_map {
        println!("  {}: {}", name, age);
    }
    
    // 2. 范围查询
    let range: BTreeMap<String, i32> = btree_map
        .range("Alice".."Charlie")
        .map(|(k, v)| (k.clone(), *v))
        .collect();
    println!("Range Alice..Charlie: {:?}", range);
    
    // 3. BTreeSet
    let mut btree_set: BTreeSet<i32> = BTreeSet::new();
    btree_set.insert(5);
    btree_set.insert(1);
    btree_set.insert(3);
    btree_set.insert(2);
    btree_set.insert(4);
    
    println!("BTreeSet (sorted): {:?}", btree_set);
    
    // 4. 范围查询
    let range_set: BTreeSet<&i32> = btree_set.range(2..=4).collect();
    println!("Range 2..=4: {:?}", range_set);
}
}

栈和队列

#![allow(unused)]
fn main() {
use std::collections::VecDeque;

fn stack_queue_operations() {
    // 1. 栈 (Vec)
    let mut stack = Vec::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);
    
    println!("Stack: {:?}", stack);
    println!("Top: {:?}", stack.pop());
    println!("After pop: {:?}", stack);
    
    // 2. 队列 (VecDeque)
    let mut queue = VecDeque::new();
    queue.push_back(1);
    queue.push_back(2);
    queue.push_back(3);
    
    println!("Queue: {:?}", queue);
    println!("Front: {:?}", queue.pop_front());
    println!("Back: {:?}", queue.pop_back());
    println!("After operations: {:?}", queue);
    
    // 3. 双向队列
    let mut deque = VecDeque::new();
    deque.push_front(3);
    deque.push_front(2);
    deque.push_front(1);
    deque.push_back(4);
    deque.push_back(5);
    
    println!("Deque: {:?}", deque);
    
    // 4. 滑动窗口算法
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
    let window_size = 3;
    
    let windows: Vec<Vec<i32>> = numbers
        .windows(window_size)
        .map(|window| window.to_vec())
        .collect();
    
    println!("Sliding windows: {:?}", windows);
    
    // 5. 移动窗口
    let chunks: Vec<Vec<i32>> = numbers
        .chunks(window_size)
        .map(|chunk| chunk.to_vec())
        .collect();
    
    println!("Fixed chunks: {:?}", chunks);
}
}

优先级队列

#![allow(unused)]
fn main() {
use std::cmp::Reverse;
use std::collections::BinaryHeap;

fn priority_queue_demo() {
    // 1. 最大堆（默认）
    let mut max_heap = BinaryHeap::new();
    max_heap.push(10);
    max_heap.push(5);
    max_heap.push(20);
    max_heap.push(15);
    
    println!("Max heap:");
    while let Some(num) = max_heap.pop() {
        println!("  {}", num);
    }
    
    // 2. 最小堆（使用Reverse）
    let mut min_heap = BinaryHeap::new();
    min_heap.push(Reverse(10));
    min_heap.push(Reverse(5));
    min_heap.push(Reverse(20));
    min_heap.push(Reverse(15));
    
    println!("\nMin heap:");
    while let Some(Reverse(num)) = min_heap.pop() {
        println!("  {}", num);
    }
    
    // 3. 任务调度器
    #[derive(Debug, PartialEq, Eq)]
    struct Task {
        priority: u8,
        description: String,
    }
    
    impl PartialOrd for Task {
        fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
            Some(self.priority.cmp(&other.priority).reverse())
        }
    }
    
    impl Ord for Task {
        fn cmp(&self, other: &Self) -> std::cmp::Ordering {
            self.priority.cmp(&other.priority).reverse()
        }
    }
    
    let mut task_queue = BinaryHeap::new();
    task_queue.push(Task {
        priority: 3,
        description: "Low priority task".to_string(),
    });
    task_queue.push(Task {
        priority: 1,
        description: "High priority task".to_string(),
    });
    task_queue.push(Task {
        priority: 2,
        description: "Medium priority task".to_string(),
    });
    
    println!("\nTask execution order:");
    while let Some(task) = task_queue.pop() {
        println!("  {}: {}", task.priority, task.description);
    }
}
}

实战项目1：Todo管理器

项目概述

我们将构建一个功能完整的Todo管理器，包含以下功能：

添加、编辑、删除待办事项
标记完成/未完成状态
按优先级、截止日期、状态分类
数据持久化到JSON文件
命令行界面

项目结构

// src/main.rs
use std::env;
use std::fs;
use std::io::{self, Write};
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Todo {
    pub id: u32,
    pub title: String,
    pub description: Option<String>,
    pub completed: bool,
    pub priority: u8, // 1-5, 5为最高优先级
    pub due_date: Option<String>,
    pub tags: Vec<String>,
    pub created_at: String,
    pub updated_at: String,
}

#[derive(Debug)]
pub struct TodoManager {
    pub todos: Vec<Todo>,
    pub next_id: u32,
    pub file_path: PathBuf,
}

impl TodoManager {
    pub fn new() -> Self {
        let mut manager = TodoManager {
            todos: Vec::new(),
            next_id: 1,
            file_path: PathBuf::from("todos.json"),
        };
        
        // 尝试加载已存在的数据
        if manager.file_path.exists() {
            let _ = manager.load_from_file();
        }
        
        manager
    }
    
    pub fn add_todo(&mut self, title: String, description: Option<String>, 
                    priority: u8, due_date: Option<String>, tags: Vec<String>) {
        let now = chrono::Utc::now().to_rfc3339();
        
        let todo = Todo {
            id: self.next_id,
            title,
            description,
            completed: false,
            priority,
            due_date,
            tags,
            created_at: now.clone(),
            updated_at: now,
        };
        
        self.todos.push(todo);
        self.next_id += 1;
        let _ = self.save_to_file();
    }
    
    pub fn list_todos(&self) {
        if self.todos.is_empty() {
            println!("暂无待办事项");
            return;
        }
        
        println!("\n=== 待办事项列表 ===");
        for todo in &self.todos {
            let status = if todo.completed { "✓" } else { "○" };
            let priority_stars = "★".repeat(todo.priority as usize);
            println!("[{}] {} {} - {} (ID: {})", 
                    status, 
                    priority_stars, 
                    todo.title, 
                    if todo.completed { "已完成" } else { "进行中" },
                    todo.id);
            
            if let Some(ref desc) = todo.description {
                println!("    描述: {}", desc);
            }
            
            if let Some(ref due) = todo.due_date {
                println!("    截止日期: {}", due);
            }
            
            if !todo.tags.is_empty() {
                println!("    标签: {}", todo.tags.join(", "));
            }
            
            println!("    创建: {}, 更新: {}", todo.created_at, todo.updated_at);
            println!();
        }
    }
    
    pub fn complete_todo(&mut self, id: u32) -> Result<(), String> {
        if let Some(todo) = self.todos.iter_mut().find(|t| t.id == id) {
            todo.completed = true;
            todo.updated_at = chrono::Utc::now().to_rfc3339();
            let _ = self.save_to_file();
            Ok(())
        } else {
            Err(format!("未找到ID为 {} 的待办事项", id))
        }
    }
    
    pub fn uncomplete_todo(&mut self, id: u32) -> Result<(), String> {
        if let Some(todo) = self.todos.iter_mut().find(|t| t.id == id) {
            todo.completed = false;
            todo.updated_at = chrono::Utc::now().to_rfc3339();
            let _ = self.save_to_file();
            Ok(())
        } else {
            Err(format!("未找到ID为 {} 的待办事项", id))
        }
    }
    
    pub fn update_todo(&mut self, id: u32, title: Option<String>, 
                      description: Option<String>, priority: Option<u8>, 
                      due_date: Option<Option<String>>, tags: Option<Vec<String>>) -> Result<(), String> {
        if let Some(todo) = self.todos.iter_mut().find(|t| t.id == id) {
            if let Some(new_title) = title {
                todo.title = new_title;
            }
            if let Some(new_desc) = description {
                todo.description = Some(new_desc);
            }
            if let Some(new_priority) = priority {
                todo.priority = new_priority;
            }
            if let Some(new_due_date) = due_date {
                todo.due_date = new_due_date;
            }
            if let Some(new_tags) = tags {
                todo.tags = new_tags;
            }
            
            todo.updated_at = chrono::Utc::now().to_rfc3339();
            let _ = self.save_to_file();
            Ok(())
        } else {
            Err(format!("未找到ID为 {} 的待办事项", id))
        }
    }
    
    pub fn delete_todo(&mut self, id: u32) -> Result<(), String> {
        if let Some(index) = self.todos.iter().position(|t| t.id == id) {
            self.todos.remove(index);
            let _ = self.save_to_file();
            Ok(())
        } else {
            Err(format!("未找到ID为 {} 的待办事项", id))
        }
    }
    
    pub fn filter_by_status(&self, completed: bool) -> Vec<&Todo> {
        self.todos.iter().filter(|t| t.completed == completed).collect()
    }
    
    pub fn filter_by_priority(&self, priority: u8) -> Vec<&Todo> {
        self.todos.iter().filter(|t| t.priority == priority).collect()
    }
    
    pub fn search_by_tag(&self, tag: &str) -> Vec<&Todo> {
        self.todos.iter().filter(|t| t.tags.contains(&tag.to_string())).collect()
    }
    
    pub fn search_by_keyword(&self, keyword: &str) -> Vec<&Todo> {
        let keyword = keyword.to_lowercase();
        self.todos.iter()
            .filter(|t| {
                t.title.to_lowercase().contains(&keyword) ||
                t.description.as_ref().map(|d| d.to_lowercase().contains(&keyword)).unwrap_or(false)
            })
            .collect()
    }
    
    pub fn sort_by_priority(&self) -> Vec<&Todo> {
        let mut sorted = self.todos.iter().collect::<Vec<_>>();
        sorted.sort_by(|a, b| b.priority.cmp(&a.priority));
        sorted
    }
    
    pub fn save_to_file(&self) -> Result<(), Box<dyn std::error::Error>> {
        let json = serde_json::to_string_pretty(&self.todos)?;
        fs::write(&self.file_path, json)?;
        Ok(())
    }
    
    pub fn load_from_file(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        let content = fs::read_to_string(&self.file_path)?;
        self.todos = serde_json::from_str(&content)?;
        
        // 更新下一个ID
        if let Some(max_id) = self.todos.iter().map(|t| t.id).max() {
            self.next_id = max_id + 1;
        }
        
        Ok(())
    }
    
    pub fn export_csv(&self, file_path: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut wtr = csv::Writer::from_path(file_path)?;
        
        // 写入表头
        wtr.write_record(&["ID", "标题", "描述", "完成状态", "优先级", "截止日期", "标签", "创建时间", "更新时间"])?;
        
        for todo in &self.todos {
            wtr.write_record(&[
                &todo.id.to_string(),
                &todo.title,
                todo.description.as_deref().unwrap_or(""),
                if todo.completed { "已完成" } else { "进行中" },
                &todo.priority.to_string(),
                todo.due_date.as_deref().unwrap_or(""),
                &todo.tags.join(";"),
                &todo.created_at,
                &todo.updated_at
            ])?;
        }
        
        wtr.flush()?;
        Ok(())
    }
    
    pub fn get_statistics(&self) -> HashMap<String, usize> {
        let mut stats = HashMap::new();
        
        stats.insert("总数量".to_string(), self.todos.len());
        stats.insert("已完成".to_string(), 
                    self.todos.iter().filter(|t| t.completed).count());
        stats.insert("进行中".to_string(), 
                    self.todos.iter().filter(|t| !t.completed).count());
        
        // 按优先级统计
        for priority in 1..=5 {
            let count = self.todos.iter().filter(|t| t.priority == priority).count();
            if count > 0 {
                stats.insert(format!("优先级{}", priority), count);
            }
        }
        
        stats
    }
}

fn print_help() {
    println!("\n=== Todo管理器命令 ===");
    println!("add <标题> [描述] - 添加待办事项");
    println!("list - 列出所有待办事项");
    println!("complete <ID> - 标记为已完成");
    println!("uncomplete <ID> - 标记为进行中");
    println!("update <ID> [选项] - 更新待办事项");
    println!("delete <ID> - 删除待办事项");
    println!("filter <状态> - 按状态筛选 (completed/uncompleted)");
    println!("priority <优先级> - 按优先级筛选 (1-5)");
    println!("search <关键词> - 搜索待办事项");
    println!("tag <标签> - 按标签搜索");
    println!("sort - 按优先级排序显示");
    println!("stats - 显示统计信息");
    println!("export <文件名> - 导出为CSV");
    println!("help - 显示帮助信息");
    println!("quit - 退出程序");
    println!("\n示例:");
    println!("  add \"完成项目报告\" \"需要包含Q3数据\" 4 \"2023-12-31\" work,urgent");
    println!("  list");
    println!("  complete 1");
    println!("  filter completed");
    println!("  update 1 --priority 5 --tag urgent");
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut manager = TodoManager::new();
    
    println!("欢迎使用Todo管理器！输入 'help' 查看帮助信息。");
    
    loop {
        print!("\n> ");
        io::stdout().flush()?;
        
        let mut input = String::new();
        io::stdin().read_line(&mut input)?;
        
        let trimmed = input.trim();
        if trimmed.is_empty() {
            continue;
        }
        
        let parts: Vec<&str> = trimmed.split_whitespace().collect();
        let command = parts[0];
        
        match command {
            "quit" | "exit" => {
                println!("再见！");
                break;
            }
            
            "help" => {
                print_help();
            }
            
            "add" => {
                if parts.len() < 2 {
                    println!("用法: add <标题> [描述] [优先级] [截止日期] [标签]");
                    continue;
                }
                
                let title = parts[1].to_string();
                let description = if parts.len() > 2 { 
                    Some(parts[2].to_string()) 
                } else { None };
                
                let priority = if parts.len() > 3 { 
                    parts[3].parse::<u8>().unwrap_or(3) 
                } else { 3 };
                
                let due_date = if parts.len() > 4 { 
                    Some(parts[4].to_string()) 
                } else { None };
                
                let tags = if parts.len() > 5 { 
                    parts[5].split(',').map(|s| s.trim().to_string()).collect()
                } else { Vec::new() };
                
                manager.add_todo(title, description, priority, due_date, tags);
                println!("✅ 已添加待办事项");
            }
            
            "list" => {
                manager.list_todos();
            }
            
            "complete" => {
                if parts.len() < 2 {
                    println!("用法: complete <ID>");
                    continue;
                }
                
                if let Ok(id) = parts[1].parse::<u32>() {
                    match manager.complete_todo(id) {
                        Ok(_) => println!("✅ 已标记为已完成"),
                        Err(e) => println!("❌ {}", e),
                    }
                } else {
                    println!("❌ 无效的ID");
                }
            }
            
            "uncomplete" => {
                if parts.len() < 2 {
                    println!("用法: uncomplete <ID>");
                    continue;
                }
                
                if let Ok(id) = parts[1].parse::<u32>() {
                    match manager.uncomplete_todo(id) {
                        Ok(_) => println!("✅ 已标记为进行中"),
                        Err(e) => println!("❌ {}", e),
                    }
                } else {
                    println!("❌ 无效的ID");
                }
            }
            
            "update" => {
                if parts.len() < 2 {
                    println!("用法: update <ID> [选项]");
                    continue;
                }
                
                if let Ok(id) = parts[1].parse::<u32>() {
                    let mut title = None;
                    let mut description = None;
                    let mut priority = None;
                    let mut due_date = None;
                    let mut tags = None;
                    
                    for i in (2..parts.len()).step_by(2) {
                        if i + 1 < parts.len() {
                            match parts[i] {
                                "--title" => title = Some(parts[i + 1].to_string()),
                                "--description" => description = Some(parts[i + 1].to_string()),
                                "--priority" => {
                                    if let Ok(p) = parts[i + 1].parse::<u8>() {
                                        priority = Some(p);
                                    }
                                }
                                "--due-date" => due_date = Some(Some(parts[i + 1].to_string())),
                                "--tags" => {
                                    let tag_list: Vec<String> = parts[i + 1]
                                        .split(',')
                                        .map(|s| s.trim().to_string())
                                        .collect();
                                    tags = Some(tag_list);
                                }
                                _ => {}
                            }
                        }
                    }
                    
                    match manager.update_todo(id, title, description, priority, due_date, tags) {
                        Ok(_) => println!("✅ 已更新待办事项"),
                        Err(e) => println!("❌ {}", e),
                    }
                } else {
                    println!("❌ 无效的ID");
                }
            }
            
            "delete" => {
                if parts.len() < 2 {
                    println!("用法: delete <ID>");
                    continue;
                }
                
                if let Ok(id) = parts[1].parse::<u32>() {
                    match manager.delete_todo(id) {
                        Ok(_) => println!("✅ 已删除待办事项"),
                        Err(e) => println!("❌ {}", e),
                    }
                } else {
                    println!("❌ 无效的ID");
                }
            }
            
            "filter" => {
                if parts.len() < 2 {
                    println!("用法: filter <completed|uncompleted>");
                    continue;
                }
                
                match parts[1] {
                    "completed" => {
                        let completed_todos = manager.filter_by_status(true);
                        println!("\n=== 已完成的待办事项 ===");
                        for todo in completed_todos {
                            println!("[✓] {} (ID: {})", todo.title, todo.id);
                        }
                    }
                    "uncompleted" => {
                        let uncompleted_todos = manager.filter_by_status(false);
                        println!("\n=== 进行中的待办事项 ===");
                        for todo in uncompleted_todos {
                            println!("[○] {} (ID: {})", todo.title, todo.id);
                        }
                    }
                    _ => {
                        println!("❌ 无效的筛选条件，使用 completed 或 uncompleted");
                    }
                }
            }
            
            "priority" => {
                if parts.len() < 2 {
                    println!("用法: priority <1-5>");
                    continue;
                }
                
                if let Ok(priority) = parts[1].parse::<u8>() {
                    if priority >= 1 && priority <= 5 {
                        let priority_todos = manager.filter_by_priority(priority);
                        println!("\n=== 优先级{}的待办事项 ===", priority);
                        for todo in priority_todos {
                            let stars = "★".repeat(todo.priority as usize);
                            let status = if todo.completed { "✓" } else { "○" };
                            println!("[{}] {} {} (ID: {})", status, stars, todo.title, todo.id);
                        }
                    } else {
                        println!("❌ 优先级必须在1-5之间");
                    }
                } else {
                    println!("❌ 无效的优先级");
                }
            }
            
            "search" => {
                if parts.len() < 2 {
                    println!("用法: search <关键词>");
                    continue;
                }
                
                let keyword = parts[1];
                let results = manager.search_by_keyword(keyword);
                
                if results.is_empty() {
                    println!("未找到包含 '{}' 的待办事项", keyword);
                } else {
                    println!("\n=== 搜索结果: '{}' ===", keyword);
                    for todo in results {
                        let status = if todo.completed { "✓" } else { "○" };
                        println!("[{}] {} (ID: {})", status, todo.title, todo.id);
                        if let Some(ref desc) = todo.description {
                            println!("    描述: {}", desc);
                        }
                    }
                }
            }
            
            "tag" => {
                if parts.len() < 2 {
                    println!("用法: tag <标签>");
                    continue;
                }
                
                let tag = parts[1];
                let results = manager.search_by_tag(tag);
                
                if results.is_empty() {
                    println!("未找到标签为 '{}' 的待办事项", tag);
                } else {
                    println!("\n=== 标签: '{}' ===", tag);
                    for todo in results {
                        let status = if todo.completed { "✓" } else { "○" };
                        println!("[{}] {} (ID: {})", status, todo.title, todo.id);
                        if !todo.tags.is_empty() {
                            println!("    标签: {}", todo.tags.join(", "));
                        }
                    }
                }
            }
            
            "sort" => {
                let sorted_todos = manager.sort_by_priority();
                println!("\n=== 按优先级排序的待办事项 ===");
                for todo in sorted_todos {
                    let status = if todo.completed { "✓" } else { "○" };
                    let stars = "★".repeat(todo.priority as usize);
                    println!("[{}] {} {} - {} (ID: {})", 
                            status, stars, todo.title, 
                            if todo.completed { "已完成" } else { "进行中" },
                            todo.id);
                }
            }
            
            "stats" => {
                let stats = manager.get_statistics();
                println!("\n=== 统计信息 ===");
                for (key, value) in stats {
                    println!("{}: {}", key, value);
                }
            }
            
            "export" => {
                if parts.len() < 2 {
                    println!("用法: export <文件名.csv>");
                    continue;
                }
                
                match manager.export_csv(parts[1]) {
                    Ok(_) => println!("✅ 已导出到 {}", parts[1]),
                    Err(e) => println!("❌ 导出失败: {}", e),
                }
            }
            
            _ => {
                println!("❌ 未知命令 '{}'，输入 'help' 查看帮助", command);
            }
        }
    }
    
    Ok(())
}

Cargo.toml配置

[package]
name = "todo-manager"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
chrono = { version = "0.4", features = ["serde"] }
csv = "1.1"

项目特色功能

数据持久化：自动保存到JSON文件
复合查询：支持按状态、优先级、标签、关键词筛选
数据导出：支持CSV格式导出
统计分析：提供详细的统计信息
灵活更新：支持部分字段更新
标签系统：多标签管理
优先级管理：5级优先级系统

实战项目2：Web API服务器

项目概述

构建一个基于Rust的Web API服务器，模拟一个博客系统的后端API，包含：

用户管理
文章管理
评论系统
标签管理
RESTful API设计
数据验证
错误处理
中间件支持

项目结构

#![allow(unused)]
fn main() {
// Cargo.toml
[package]
name = "blog-api-server"
version = "0.1.0"
edition = "2021"

[dependencies]
actix-web = "4"
actix-files = "0.6"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
chrono = { version = "0.4", features = ["serde"] }
uuid = { version = "1.0", features = ["v4"] }
tokio = { version = "1", features = ["full"] }
sqlx = { version = "0.7", features = ["runtime-async-std-rustls", "sqlite"] }
async-trait = "0.1"
validator = { version = "0.16", features = ["derive"] }
bcrypt = "0.15"
jsonwebtoken = "9"
env_logger = "0.10"
log = "0.4"
thiserror = "1.0"
anyhow = "1.0"

[dev-dependencies]
tempfile = "3.0"
}

// src/main.rs
use actix_web::{App, HttpServer, web};
use log::info;
use std::env;

mod models;
mod handlers;
mod database;
mod middleware;
mod error;

use database::Database;
use error::AppError;

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init();
    
    let port = env::args()
        .find_map(|arg| {
            if arg.starts_with("--port=") {
                arg.split('=').nth(1)?.parse().ok()
            } else {
                None
            }
        })
        .unwrap_or(8080);
    
    info!("启动服务器，端口: {}", port);
    info!("API文档: http://localhost:{}/api/docs", port);
    
    // 初始化数据库
    let database = Database::new("blog.db").await?;
    
    HttpServer::new(move || {
        App::new()
            .app_data(web::Data::new(database.clone()))
            .wrap(middleware::LoggingMiddleware)
            .wrap(middleware::CorsMiddleware)
            .service(
                web::scope("/api")
                    .service(handlers::auth::register)
                    .service(handlers::auth::login)
                    .service(handlers::users::get_users)
                    .service(handlers::users::get_user)
                    .service(handlers::posts::get_posts)
                    .service(handlers::posts::get_post)
                    .service(handlers::posts::create_post)
                    .service(handlers::posts::update_post)
                    .service(handlers::posts::delete_post)
                    .service(handlers::comments::get_comments)
                    .service(handlers::comments::create_comment)
                    .service(handlers::comments::delete_comment)
                    .service(handlers::tags::get_tags)
                    .service(handlers::tags::create_tag)
                    .service(handlers::stats::get_stats)
            )
            .service(
                actix_files::Files::new("/", "./static/")
                    .index_file("index.html")
            )
    })
    .bind(("0.0.0.0", port))?
    .run()
    .await
}

#![allow(unused)]
fn main() {
// src/models.rs
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use uuid::Uuid;
use validator::Validate;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub username: String,
    pub email: String,
    pub password_hash: String,
    pub display_name: Option<String>,
    pub bio: Option<String>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub is_active: bool,
    pub role: UserRole,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum UserRole {
    Regular,
    Admin,
    Moderator,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Post {
    pub id: Uuid,
    pub title: String,
    pub content: String,
    pub summary: Option<String>,
    pub author_id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub published_at: Option<DateTime<Utc>>,
    pub is_published: bool,
    pub view_count: u64,
    pub like_count: u64,
    pub tags: HashSet<String>,
    pub slug: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Comment {
    pub id: Uuid,
    pub post_id: Uuid,
    pub author_id: Uuid,
    pub parent_id: Option<Uuid>,
    pub content: String,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub is_approved: bool,
    pub like_count: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Tag {
    pub id: Uuid,
    pub name: String,
    pub description: Option<String>,
    pub created_at: DateTime<Utc>,
    pub post_count: u64,
}

// DTOs for API requests/responses
#[derive(Debug, Deserialize, Validate)]
pub struct RegisterRequest {
    #[validate(length(min = 3, max = 30))]
    pub username: String,
    #[validate(email)]
    pub email: String,
    #[validate(length(min = 8))]
    pub password: String,
    pub display_name: Option<String>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct LoginRequest {
    pub username_or_email: String,
    pub password: String,
}

#[derive(Debug, Deserialize, Validate)]
pub struct CreatePostRequest {
    #[validate(length(min = 1, max = 200))]
    pub title: String,
    #[validate(length(min = 1))]
    pub content: String,
    pub summary: Option<String>,
    pub tags: Vec<String>,
    pub is_published: bool,
}

#[derive(Debug, Deserialize, Validate)]
pub struct UpdatePostRequest {
    pub title: Option<String>,
    pub content: Option<String>,
    pub summary: Option<String>,
    pub tags: Option<Vec<String>>,
    pub is_published: Option<bool>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct CreateCommentRequest {
    #[validate(length(min = 1, max = 1000))]
    pub content: String,
    pub parent_id: Option<Uuid>,
}

#[derive(Debug, Deserialize, Validate)]
pub struct CreateTagRequest {
    #[validate(length(min = 1, max = 50))]
    pub name: String,
    pub description: Option<String>,
}

// Response types
#[derive(Debug, Serialize)]
pub struct AuthResponse {
    pub token: String,
    pub user: UserSummary,
    pub expires_at: DateTime<Utc>,
}

#[derive(Debug, Serialize)]
pub struct UserSummary {
    pub id: Uuid,
    pub username: String,
    pub display_name: Option<String>,
    pub role: UserRole,
}

#[derive(Debug, Serialize)]
pub struct PostSummary {
    pub id: Uuid,
    pub title: String,
    pub summary: Option<String>,
    pub author: UserSummary,
    pub created_at: DateTime<Utc>,
    pub published_at: Option<DateTime<Utc>>,
    pub is_published: bool,
    pub view_count: u64,
    pub like_count: u64,
    pub comment_count: u64,
    pub tags: Vec<String>,
    pub slug: String,
}

#[derive(Debug, Serialize)]
pub struct CommentSummary {
    pub id: Uuid,
    pub content: String,
    pub author: UserSummary,
    pub created_at: DateTime<Utc>,
    pub like_count: u64,
    pub replies: Vec<CommentSummary>,
}

#[derive(Debug, Serialize)]
pub struct PaginatedResponse<T> {
    pub items: Vec<T>,
    pub total: u64,
    pub page: u32,
    pub per_page: u32,
    pub total_pages: u32,
}

#[derive(Debug, Serialize)]
pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub message: Option<String>,
    pub error: Option<String>,
}

impl<T> ApiResponse<T> {
    pub fn success(data: T) -> Self {
        Self {
            success: true,
            data: Some(data),
            message: None,
            error: None,
        }
    }
    
    pub fn error(message: String) -> Self {
        Self {
            success: false,
            data: None,
            message: None,
            error: Some(message),
        }
    }
}
}

#![allow(unused)]
fn main() {
// src/database.rs
use sqlx::{Sqlite, Pool, Row};
use sqlx::sqlite::SqlitePoolOptions;
use tokio::time::{Duration, timeout};
use crate::models::*;
use std::collections::HashSet;
use std::time::SystemTime;
use thiserror::Error;
use uuid::Uuid;

#[derive(Error, Debug)]
pub enum DatabaseError {
    #[error("Database connection error: {0}")]
    ConnectionError(String),
    #[error("Query execution error: {0}")]
    QueryError(String),
    #[error("Not found: {0}")]
    NotFound(String),
}

#[derive(Clone)]
pub struct Database {
    pool: Pool<Sqlite>,
}

impl Database {
    pub async fn new(database_url: &str) -> Result<Self, DatabaseError> {
        let pool = SqlitePoolOptions::new()
            .max_connections(10)
            .connect(database_url)
            .await
            .map_err(|e| DatabaseError::ConnectionError(e.to_string()))?;
        
        Self::init_tables(&pool).await?;
        
        Ok(Database { pool })
    }
    
    async fn init_tables(pool: &Pool<Sqlite>) -> Result<(), DatabaseError> {
        // Users table
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS users (
                id TEXT PRIMARY KEY,
                username TEXT UNIQUE NOT NULL,
                email TEXT UNIQUE NOT NULL,
                password_hash TEXT NOT NULL,
                display_name TEXT,
                bio TEXT,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                is_active BOOLEAN DEFAULT 1,
                role TEXT DEFAULT 'regular'
            )
        "#).execute(pool).await.map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Posts table
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS posts (
                id TEXT PRIMARY KEY,
                title TEXT NOT NULL,
                content TEXT NOT NULL,
                summary TEXT,
                author_id TEXT NOT NULL,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                published_at DATETIME,
                is_published BOOLEAN DEFAULT 0,
                view_count INTEGER DEFAULT 0,
                like_count INTEGER DEFAULT 0,
                slug TEXT UNIQUE NOT NULL,
                FOREIGN KEY (author_id) REFERENCES users (id)
            )
        "#).execute(pool).await.map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Post tags junction table
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS post_tags (
                post_id TEXT NOT NULL,
                tag_name TEXT NOT NULL,
                PRIMARY KEY (post_id, tag_name),
                FOREIGN KEY (post_id) REFERENCES posts (id)
            )
        "#).execute(pool).await.map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Comments table
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS comments (
                id TEXT PRIMARY KEY,
                post_id TEXT NOT NULL,
                author_id TEXT NOT NULL,
                parent_id TEXT,
                content TEXT NOT NULL,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                is_approved BOOLEAN DEFAULT 1,
                like_count INTEGER DEFAULT 0,
                FOREIGN KEY (post_id) REFERENCES posts (id),
                FOREIGN KEY (author_id) REFERENCES users (id),
                FOREIGN KEY (parent_id) REFERENCES comments (id)
            )
        "#).execute(pool).await.map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Tags table
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS tags (
                id TEXT PRIMARY KEY,
                name TEXT UNIQUE NOT NULL,
                description TEXT,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        "#).execute(pool).await.map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(())
    }
    
    // User operations
    pub async fn create_user(&self, user: &RegisterRequest) -> Result<User, DatabaseError> {
        let id = Uuid::new_v4().to_string();
        let now = Utc::now();
        let password_hash = bcrypt::hash(&user.password, bcrypt::DEFAULT_COST)
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        sqlx::query(r#"
            INSERT INTO users (id, username, email, password_hash, display_name, created_at, updated_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        "#)
        .bind(&id)
        .bind(&user.username)
        .bind(&user.email)
        .bind(&password_hash)
        .bind(&user.display_name)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        self.get_user_by_id(&id).await
    }
    
    pub async fn get_user_by_username(&self, username: &str) -> Result<Option<User>, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT * FROM users WHERE username = ? AND is_active = 1
        "#)
        .bind(username)
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        match row {
            Some(row) => Ok(Some(Self::user_from_row(row))),
            None => Ok(None),
        }
    }
    
    pub async fn get_user_by_email(&self, email: &str) -> Result<Option<User>, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT * FROM users WHERE email = ? AND is_active = 1
        "#)
        .bind(email)
        .fetch_optional(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        match row {
            Some(row) => Ok(Some(Self::user_from_row(row))),
            None => Ok(None),
        }
    }
    
    pub async fn get_user_by_id(&self, id: &str) -> Result<User, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT * FROM users WHERE id = ?
        "#)
        .bind(id)
        .fetch_one(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(Self::user_from_row(row))
    }
    
    pub async fn verify_password(&self, user: &User, password: &str) -> bool {
        bcrypt::verify(password, &user.password_hash).unwrap_or(false)
    }
    
    fn user_from_row(row: sqlx::sqlite::SqliteRow) -> User {
        User {
            id: Uuid::parse_str(row.get("id")).unwrap(),
            username: row.get("username"),
            email: row.get("email"),
            password_hash: row.get("password_hash"),
            display_name: row.get("display_name"),
            bio: row.get("bio"),
            created_at: row.get("created_at"),
            updated_at: row.get("updated_at"),
            is_active: row.get("is_active"),
            role: match row.get::<String, _>("role").as_str() {
                "admin" => UserRole::Admin,
                "moderator" => UserRole::Moderator,
                _ => UserRole::Regular,
            },
        }
    }
    
    // Post operations
    pub async fn create_post(&self, post: &CreatePostRequest, author_id: Uuid) -> Result<Post, DatabaseError> {
        let id = Uuid::new_v4().to_string();
        let now = Utc::now();
        let slug = Self::generate_slug(&post.title);
        
        sqlx::query(r#"
            INSERT INTO posts (id, title, content, summary, author_id, created_at, updated_at, published_at, is_published, slug)
            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        "#)
        .bind(&id)
        .bind(&post.title)
        .bind(&post.content)
        .bind(&post.summary)
        .bind(author_id.to_string())
        .bind(now)
        .bind(now)
        .bind(if post.is_published { Some(now) } else { None })
        .bind(post.is_published)
        .bind(&slug)
        .execute(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Add tags
        for tag_name in &post.tags {
            sqlx::query(r#"
                INSERT OR IGNORE INTO post_tags (post_id, tag_name) VALUES (?, ?)
            "#)
            .bind(&id)
            .bind(tag_name)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        }
        
        self.get_post_by_id(&id).await
    }
    
    pub async fn get_posts(&self, page: u32, per_page: u32, published_only: bool) -> Result<(Vec<Post>, u64), DatabaseError> {
        let offset = (page - 1) * per_page;
        
        let where_clause = if published_only { "WHERE p.is_published = 1" } else { "" };
        
        // Get total count
        let count_row = sqlx::query(&format!(
            "SELECT COUNT(*) as count FROM posts p {}", where_clause
        ))
        .fetch_one(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        let total: u64 = count_row.get("count");
        
        // Get posts
        let rows = sqlx::query(&format!(
            r#"
            SELECT p.*, 
                   GROUP_CONCAT(pt.tag_name) as tags
            FROM posts p
            LEFT JOIN post_tags pt ON p.id = pt.post_id
            {}
            GROUP BY p.id
            ORDER BY p.created_at DESC
            LIMIT ? OFFSET ?
            "#, where_clause
        ))
        .bind(per_page as i64)
        .bind(offset as i64)
        .fetch_all(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        let posts = rows.into_iter().map(Self::post_from_row).collect();
        Ok((posts, total))
    }
    
    pub async fn get_post_by_id(&self, id: &str) -> Result<Post, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT p.*, GROUP_CONCAT(pt.tag_name) as tags
            FROM posts p
            LEFT JOIN post_tags pt ON p.id = pt.post_id
            WHERE p.id = ?
            GROUP BY p.id
        "#)
        .bind(id)
        .fetch_one(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(Self::post_from_row(row))
    }
    
    pub async fn update_post(&self, id: &str, update: &UpdatePostRequest) -> Result<Post, DatabaseError> {
        let mut set_clauses = Vec::new();
        let mut params: Vec<Box<dyn sqlx::Encode<sqlx::Sqlite> + Send>> = vec![];
        
        if let Some(ref title) = update.title {
            set_clauses.push("title = ?");
            params.push(Box::new(title.clone()));
        }
        
        if let Some(ref content) = update.content {
            set_clauses.push("content = ?");
            params.push(Box::new(content.clone()));
        }
        
        if let Some(ref summary) = update.summary {
            set_clauses.push("summary = ?");
            params.push(Box::new(summary.clone()));
        }
        
        if let Some(is_published) = update.is_published {
            set_clauses.push("is_published = ?");
            params.push(Box::new(is_published));
            if is_published {
                set_clauses.push("published_at = ?");
                params.push(Box::new(Utc::now()));
            }
        }
        
        if let Some(ref tags) = update.tags {
            // Remove existing tags
            sqlx::query("DELETE FROM post_tags WHERE post_id = ?")
                .bind(id)
                .execute(&self.pool)
                .await
                .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
            
            // Add new tags
            for tag_name in tags {
                sqlx::query(r#"
                    INSERT OR IGNORE INTO post_tags (post_id, tag_name) VALUES (?, ?)
                "#)
                .bind(id)
                .bind(tag_name)
                .execute(&self.pool)
                .await
                .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
            }
        }
        
        if !set_clauses.is_empty() {
            set_clauses.push("updated_at = ?");
            params.push(Box::new(Utc::now()));
            
            let query = format!("UPDATE posts SET {} WHERE id = ?", set_clauses.join(", "));
            let mut sql = sqlx::query(&query);
            
            for param in params {
                sql = sql.bind(param);
            }
            
            sql.bind(id)
                .execute(&self.pool)
                .await
                .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        }
        
        self.get_post_by_id(id).await
    }
    
    pub async fn delete_post(&self, id: &str) -> Result<(), DatabaseError> {
        // Delete related data first
        sqlx::query("DELETE FROM comments WHERE post_id = ?")
            .bind(id)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
            
        sqlx::query("DELETE FROM post_tags WHERE post_id = ?")
            .bind(id)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Delete the post
        sqlx::query("DELETE FROM posts WHERE id = ?")
            .bind(id)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(())
    }
    
    fn post_from_row(row: sqlx::sqlite::SqliteRow) -> Post {
        let tags_str: Option<String> = row.get("tags");
        let tags: HashSet<String> = tags_str
            .as_ref()
            .and_then(|s| if s.is_empty() { None } else { Some(s.split(',').map(|s| s.to_string()).collect()) })
            .unwrap_or_default();
        
        Post {
            id: Uuid::parse_str(row.get("id")).unwrap(),
            title: row.get("title"),
            content: row.get("content"),
            summary: row.get("summary"),
            author_id: Uuid::parse_str(row.get("author_id")).unwrap(),
            created_at: row.get("created_at"),
            updated_at: row.get("updated_at"),
            published_at: row.get("published_at"),
            is_published: row.get("is_published"),
            view_count: row.get("view_count"),
            like_count: row.get("like_count"),
            tags,
            slug: row.get("slug"),
        }
    }
    
    fn generate_slug(title: &str) -> String {
        title
            .to_lowercase()
            .chars()
            .map(|c| match c {
                'a'..='z' | '0'..='9' => c,
                ' ' => '-',
                _ => '-',
            })
            .collect::<String>()
            .trim_matches('-')
            .to_string()
    }
}
}

#![allow(unused)]
fn main() {
// src/handlers/mod.rs
pub mod auth;
pub mod users;
pub mod posts;
pub mod comments;
pub mod tags;
pub mod stats;
}

#![allow(unused)]
fn main() {
// src/handlers/auth.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;
use bcrypt::verify;
use jsonwebtoken::{encode, Header, EncodingKey};
use chrono::{Duration, Utc};
use std::env;

pub async fn register(
    db: web::Data<Database>,
    user_data: web::Json<RegisterRequest>,
) -> Result<impl Responder, AppError> {
    let user_data = user_data.into_inner();
    user_data.validate()
        .map_err(|e| AppError::ValidationError(e.to_string()))?;
    
    // Check if username exists
    if let Some(_) = db.get_user_by_username(&user_data.username).await? {
        return Ok(HttpResponse::Conflict().json(ApiResponse::error("用户名已存在".to_string())));
    }
    
    // Check if email exists
    if let Some(_) = db.get_user_by_email(&user_data.email).await? {
        return Ok(HttpResponse::Conflict().json(ApiResponse::error("邮箱已存在".to_string())));
    }
    
    // Create user
    let user = db.create_user(&user_data).await?;
    let token = generate_jwt_token(&user)?;
    
    let user_summary = UserSummary {
        id: user.id,
        username: user.username,
        display_name: user.display_name,
        role: user.role,
    };
    
    let auth_response = AuthResponse {
        token,
        user: user_summary,
        expires_at: Utc::now() + Duration::days(30),
    };
    
    Ok(HttpResponse::Created().json(ApiResponse::success(auth_response)))
}

pub async fn login(
    db: web::Data<Database>,
    login_data: web::Json<LoginRequest>,
) -> Result<impl Responder, AppError> {
    let login_data = login_data.into_inner();
    login_data.validate()
        .map_err(|e| AppError::ValidationError(e.to_string()))?;
    
    // Try to find user by username or email
    let user = if login_data.username_or_email.contains('@') {
        db.get_user_by_email(&login_data.username_or_email).await?
    } else {
        db.get_user_by_username(&login_data.username_or_email).await?
    };
    
    let user = match user {
        Some(user) => user,
        None => return Ok(HttpResponse::Unauthorized().json(ApiResponse::error("用户不存在".to_string()))),
    };
    
    if !db.verify_password(&user, &login_data.password) {
        return Ok(HttpResponse::Unauthorized().json(ApiResponse::error("密码错误".to_string())));
    }
    
    let token = generate_jwt_token(&user)?;
    
    let user_summary = UserSummary {
        id: user.id,
        username: user.username,
        display_name: user.display_name,
        role: user.role,
    };
    
    let auth_response = AuthResponse {
        token,
        user: user_summary,
        expires_at: Utc::now() + Duration::days(30),
    };
    
    Ok(HttpResponse::Ok().json(ApiResponse::success(auth_response)))
}

fn generate_jwt_token(user: &crate::models::User) -> Result<String, AppError> {
    let secret = env::var("JWT_SECRET").unwrap_or_else(|_| "default-secret".to_string());
    
    #[derive(Serialize)]
    struct Claims {
        sub: String,
        username: String,
        role: String,
        exp: usize,
    }
    
    let claims = Claims {
        sub: user.id.to_string(),
        username: user.username.clone(),
        role: match user.role {
            crate::models::UserRole::Admin => "admin".to_string(),
            crate::models::UserRole::Moderator => "moderator".to_string(),
            crate::models::UserRole::Regular => "regular".to_string(),
        },
        exp: (Utc::now() + Duration::days(30)).timestamp() as usize,
    };
    
    encode(
        &Header::default(),
        &claims,
        &EncodingKey::from_secret(secret.as_bytes()),
    )
    .map_err(|e| AppError::TokenGenerationError(e.to_string()))
}```rust
// src/handlers/users.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;

pub async fn get_users(
    db: web::Data<Database>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> Result<impl Responder, AppError> {
    let page = query.get("page").and_then(|s| s.parse().ok()).unwrap_or(1);
    let per_page = query.get("per_page").and_then(|s| s.parse().ok()).unwrap_or(20);
    
    let (users, total) = db.get_users_paginated(page, per_page).await?;
    
    let user_summaries: Vec<UserSummary> = users.into_iter().map(|user| UserSummary {
        id: user.id,
        username: user.username,
        display_name: user.display_name,
        role: user.role,
    }).collect();
    
    let response = PaginatedResponse {
        items: user_summaries,
        total,
        page,
        per_page,
        total_pages: ((total as f32) / per_page as f32).ceil() as u32,
    };
    
    Ok(HttpResponse::Ok().json(ApiResponse::success(response)))
}

pub async fn get_user(
    db: web::Data<Database>,
    path: web::Path<String>,
) -> Result<impl Responder, AppError> {
    let user_id = path.into_inner();
    
    match db.get_user_by_id(&user_id).await {
        Ok(user) => {
            let user_summary = UserSummary {
                id: user.id,
                username: user.username,
                display_name: user.display_name,
                role: user.role,
            };
            Ok(HttpResponse::Ok().json(ApiResponse::success(user_summary)))
        }
        Err(_) => Ok(HttpResponse::NotFound().json(ApiResponse::error("用户不存在".to_string()))),
    }
}
}

#![allow(unused)]
fn main() {
// src/handlers/posts.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;
use uuid::Uuid;

pub async fn get_posts(
    db: web::Data<Database>,
    query: web::Query<std::collections::HashMap<String, String>>,
) -> Result<impl Responder, AppError> {
    let page = query.get("page").and_then(|s| s.parse().ok()).unwrap_or(1);
    let per_page = query.get("per_page").and_then(|s| s.parse().ok()).unwrap_or(10);
    let published_only = query.get("published_only")
        .and_then(|s| s.parse().ok())
        .unwrap_or(true);
    
    let (posts, total) = db.get_posts(page, per_page, published_only).await?;
    
    let post_summaries: Vec<PostSummary> = posts.into_iter().map(|post| {
        // In a real implementation, you'd fetch the author info
        PostSummary {
            id: post.id,
            title: post.title,
            summary: post.summary,
            author: UserSummary {
                id: post.author_id,
                username: "unknown".to_string(),
                display_name: Some("Unknown User".to_string()),
                role: UserRole::Regular,
            },
            created_at: post.created_at,
            published_at: post.published_at,
            is_published: post.is_published,
            view_count: post.view_count,
            like_count: post.like_count,
            comment_count: 0, // Would be fetched in real implementation
            tags: post.tags.into_iter().collect(),
            slug: post.slug,
        }
    }).collect();
    
    let response = PaginatedResponse {
        items: post_summaries,
        total,
        page,
        per_page,
        total_pages: ((total as f32) / per_page as f32).ceil() as u32,
    };
    
    Ok(HttpResponse::Ok().json(ApiResponse::success(response)))
}

pub async fn get_post(
    db: web::Data<Database>,
    path: web::Path<String>,
) -> Result<impl Responder, AppError> {
    let post_id = path.into_inner();
    
    match db.get_post_by_id(&post_id).await {
        Ok(post) => Ok(HttpResponse::Ok().json(ApiResponse::success(post))),
        Err(_) => Ok(HttpResponse::NotFound().json(ApiResponse::error("文章不存在".to_string()))),
    }
}

pub async fn create_post(
    db: web::Data<Database>,
    post_data: web::Json<CreatePostRequest>,
) -> Result<impl Responder, AppError> {
    let post_data = post_data.into_inner();
    post_data.validate()
        .map_err(|e| AppError::ValidationError(e.to_string()))?;
    
    // In a real implementation, you'd get the user ID from JWT token
    let author_id = Uuid::new_v4(); // Placeholder
    
    let post = db.create_post(&post_data, author_id).await?;
    Ok(HttpResponse::Created().json(ApiResponse::success(post)))
}

pub async fn update_post(
    db: web::Data<Database>,
    path: web::Path<String>,
    post_data: web::Json<UpdatePostRequest>,
) -> Result<impl Responder, AppError> {
    let post_id = path.into_inner();
    let post_data = post_data.into_inner();
    
    let post = db.update_post(&post_id, &post_data).await?;
    Ok(HttpResponse::Ok().json(ApiResponse::success(post)))
}

pub async fn delete_post(
    db: web::Data<Database>,
    path: web::Path<String>,
) -> Result<impl Responder, AppError> {
    let post_id = path.into_inner();
    
    db.delete_post(&post_id).await?;
    Ok(HttpResponse::NoContent().finish())
}
}

#![allow(unused)]
fn main() {
// src/handlers/comments.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;
use uuid::Uuid;

pub async fn get_comments(
    db: web::Data<Database>,
    path: web::Path<String>,
) -> Result<impl Responder, AppError> {
    let post_id = path.into_inner();
    
    let comments = db.get_comments_by_post_id(&post_id).await?;
    Ok(HttpResponse::Ok().json(ApiResponse::success(comments)))
}

pub async fn create_comment(
    db: web::Data<Database>,
    path: web::Path<String>,
    comment_data: web::Json<CreateCommentRequest>,
) -> Result<impl Responder, AppError> {
    let post_id = path.into_inner();
    let comment_data = comment_data.into_inner();
    
    comment_data.validate()
        .map_err(|e| AppError::ValidationError(e.to_string()))?;
    
    // In a real implementation, you'd get the user ID from JWT token
    let author_id = Uuid::new_v4(); // Placeholder
    
    let comment = db.create_comment(&post_id, &comment_data, author_id).await?;
    Ok(HttpResponse::Created().json(ApiResponse::success(comment)))
}

pub async fn delete_comment(
    db: web::Data<Database>,
    path: web::Path<String>,
) -> Result<impl Responder, AppError> {
    let comment_id = path.into_inner();
    
    db.delete_comment(&comment_id).await?;
    Ok(HttpResponse::NoContent().finish())
}
}

#![allow(unused)]
fn main() {
// src/handlers/tags.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;
use uuid::Uuid;

pub async fn get_tags(
    db: web::Data<Database>,
) -> Result<impl Responder, AppError> {
    let tags = db.get_all_tags().await?;
    Ok(HttpResponse::Ok().json(ApiResponse::success(tags)))
}

pub async fn create_tag(
    db: web::Data<Database>,
    tag_data: web::Json<CreateTagRequest>,
) -> Result<impl Responder, AppError> {
    let tag_data = tag_data.into_inner();
    tag_data.validate()
        .map_err(|e| AppError::ValidationError(e.to_string()))?;
    
    let tag = db.create_tag(&tag_data).await?;
    Ok(HttpResponse::Created().json(ApiResponse::success(tag)))
}
}

#![allow(unused)]
fn main() {
// src/handlers/stats.rs
use actix_web::{web, HttpResponse, Responder};
use crate::models::*;
use crate::database::Database;
use crate::error::AppError;
use std::collections::HashMap;

pub async fn get_stats(
    db: web::Data<Database>,
) -> Result<impl Responder, AppError> {
    let stats = db.get_blog_statistics().await?;
    Ok(HttpResponse::Ok().json(ApiResponse::success(stats)))
}
}

#![allow(unused)]
fn main() {
// src/middleware.rs
use actix_web::{HttpRequest, HttpResponse, Result};
use actix_web::body::EitherBody;
use futures_util::future::LocalBoxFuture;
use std::future::{ready, Future};

pub struct LoggingMiddleware;

impl<S, B> actix_web::dev::Service<HttpRequest, Response = HttpResponse<EitherBody<B>>, Error = actix_web::Error> for LoggingMiddleware
where
    S: actix_web::dev::Service<HttpRequest, Response = HttpResponse<EitherBody<B>>, Error = actix_web::Error>,
{
    type Response = HttpResponse<EitherBody<B>>;
    type Error = actix_web::Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&self, cx: &mut std::task::Context<'_>) -> std::task::Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&self, req: HttpRequest) -> Self::Future {
        let start_time = std::time::Instant::now();
        
        let future = self.service.call(req);
        
        Box::pin(async move {
            let result = future.await?;
            let elapsed = start_time.elapsed();
            
            log::info!(
                "Request processed in {:?}ms with status: {}",
                elapsed.as_millis(),
                result.status()
            );
            
            Ok(result)
        })
    }
}

pub struct CorsMiddleware;

impl<S, B> actix_web::dev::Service<HttpRequest, Response = HttpResponse<EitherBody<B>>, Error = actix_web::Error> for CorsMiddleware
where
    S: actix_web::dev::Service<HttpRequest, Response = HttpResponse<EitherBody<B>>, Error = actix_web::Error>,
{
    type Response = HttpResponse<EitherBody<B>>;
    type Error = actix_web::Error;
    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;

    fn poll_ready(&self, cx: &mut std::task::Context<'_>) -> std::task::Poll<Result<(), Self::Error>> {
        self.service.poll_ready(cx)
    }

    fn call(&self, mut req: HttpRequest) -> Self::Future {
        let future = self.service.call(req);
        
        Box::pin(async move {
            let mut response = future.await?;
            
            response.headers_mut().insert(
                actix_web::http::header::AccessControlAllowOrigin::ANY,
                actix_web::http::header::HeaderValue::from_static("*"),
            );
            
            response.headers_mut().insert(
                actix_web::http::header::AccessControlAllowMethods,
                actix_web::http::header::HeaderValue::from_static("GET, POST, PUT, DELETE, OPTIONS"),
            );
            
            response.headers_mut().insert(
                actix_web::http::header::AccessControlAllowHeaders,
                actix_web::http::header::HeaderValue::from_static("Content-Type, Authorization"),
            );
            
            Ok(response)
        })
    }
}
}

#![allow(unused)]
fn main() {
// src/error.rs
use actix_web::{HttpResponse, ResponseError};
use thiserror::Error;
use serde_json::json;

#[derive(Error, Debug)]
pub enum AppError {
    #[error("Database error: {0}")]
    DatabaseError(String),
    
    #[error("Validation error: {0}")]
    ValidationError(String),
    
    #[error("Authentication error: {0}")]
    AuthError(String),
    
    #[error("Authorization error: {0}")]
    AuthorizationError(String),
    
    #[error("Not found: {0}")]
    NotFound(String),
    
    #[error("Token generation error: {0}")]
    TokenGenerationError(String),
    
    #[error("External service error: {0}")]
    ExternalServiceError(String),
}

impl ResponseError for AppError {
    fn error_response(&self) -> HttpResponse {
        let status_code = match self {
            AppError::DatabaseError(_) => actix_web::http::StatusCode::INTERNAL_SERVER_ERROR,
            AppError::ValidationError(_) => actix_web::http::StatusCode::BAD_REQUEST,
            AppError::AuthError(_) => actix_web::http::StatusCode::UNAUTHORIZED,
            AppError::AuthorizationError(_) => actix_web::http::StatusCode::FORBIDDEN,
            AppError::NotFound(_) => actix_web::http::StatusCode::NOT_FOUND,
            AppError::TokenGenerationError(_) => actix_web::http::StatusCode::INTERNAL_SERVER_ERROR,
            AppError::ExternalServiceError(_) => actix_web::http::StatusCode::BAD_GATEWAY,
        };
        
        HttpResponse::build(status_code)
            .json(json!({
                "success": false,
                "error": self.to_string()
            }))
    }
}
}

API使用示例

# 启动服务器
cargo run -- --port=8080

# API端点测试

# 1. 用户注册
curl -X POST http://localhost:8080/api/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "john_doe",
    "email": "john@example.com",
    "password": "password123",
    "display_name": "John Doe"
  }'

# 2. 用户登录
curl -X POST http://localhost:8080/api/login \
  -H "Content-Type: application/json" \
  -d '{
    "username_or_email": "john_doe",
    "password": "password123"
  }'

# 3. 创建文章
curl -X POST http://localhost:8080/api/posts \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{
    "title": "My First Rust Blog Post",
    "content": "This is a great post about Rust programming...",
    "summary": "A brief summary of my Rust experience",
    "tags": ["rust", "programming", "tutorial"],
    "is_published": true
  }'

# 4. 获取文章列表
curl -X GET "http://localhost:8080/api/posts?page=1&per_page=10&published_only=true"

# 5. 获取文章详情
curl -X GET http://localhost:8080/api/posts/POST_ID

# 6. 创建评论
curl -X POST http://localhost:8080/api/comments/POST_ID \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{
    "content": "Great post! Very informative.",
    "parent_id": null
  }'

# 7. 获取标签
curl -X GET http://localhost:8080/api/tags

# 8. 创建标签
curl -X POST http://localhost:8080/api/tags \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{
    "name": "web-development",
    "description": "Web development related content"
  }'

# 9. 获取统计信息
curl -X GET http://localhost:8080/api/stats

数据库操作完善

为了完成Database实现，我们还需要添加一些缺失的方法：

#![allow(unused)]
fn main() {
// 在database.rs中添加的方法
impl Database {
    // 补充Database实现
    pub async fn get_users_paginated(&self, page: u32, per_page: u32) -> Result<(Vec<User>, u64), DatabaseError> {
        let offset = (page - 1) * per_page;
        
        // Get total count
        let count_row = sqlx::query("SELECT COUNT(*) as count FROM users WHERE is_active = 1")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        let total: u64 = count_row.get("count");
        
        // Get users
        let rows = sqlx::query("SELECT * FROM users WHERE is_active = 1 LIMIT ? OFFSET ?")
            .bind(per_page as i64)
            .bind(offset as i64)
            .fetch_all(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        let users = rows.into_iter().map(Self::user_from_row).collect();
        Ok((users, total))
    }
    
    pub async fn get_comments_by_post_id(&self, post_id: &str) -> Result<Vec<Comment>, DatabaseError> {
        let rows = sqlx::query(r#"
            SELECT c.*, u.username, u.display_name, u.role
            FROM comments c
            JOIN users u ON c.author_id = u.id
            WHERE c.post_id = ? AND c.is_approved = 1
            ORDER BY c.created_at ASC
        "#)
        .bind(post_id)
        .fetch_all(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(rows.into_iter().map(Self::comment_from_row).collect())
    }
    
    pub async fn create_comment(&self, post_id: &str, comment_data: &CreateCommentRequest, author_id: Uuid) -> Result<Comment, DatabaseError> {
        let id = Uuid::new_v4().to_string();
        let now = Utc::now();
        
        sqlx::query(r#"
            INSERT INTO comments (id, post_id, author_id, parent_id, content, created_at, updated_at)
            VALUES (?, ?, ?, ?, ?, ?, ?)
        "#)
        .bind(&id)
        .bind(post_id)
        .bind(author_id.to_string())
        .bind(comment_data.parent_id.as_ref().map(|id| id.to_string()))
        .bind(&comment_data.content)
        .bind(now)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        self.get_comment_by_id(&id).await
    }
    
    pub async fn get_comment_by_id(&self, id: &str) -> Result<Comment, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT c.*, u.username, u.display_name, u.role
            FROM comments c
            JOIN users u ON c.author_id = u.id
            WHERE c.id = ?
        "#)
        .bind(id)
        .fetch_one(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(Self::comment_from_row(row))
    }
    
    pub async fn delete_comment(&self, id: &str) -> Result<(), DatabaseError> {
        // First delete all replies to this comment
        sqlx::query("DELETE FROM comments WHERE parent_id = ?")
            .bind(id)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        // Then delete the comment itself
        sqlx::query("DELETE FROM comments WHERE id = ?")
            .bind(id)
            .execute(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(())
    }
    
    pub async fn get_all_tags(&self) -> Result<Vec<Tag>, DatabaseError> {
        let rows = sqlx::query(r#"
            SELECT t.*, COUNT(pt.post_id) as post_count
            FROM tags t
            LEFT JOIN post_tags pt ON t.name = pt.tag_name
            GROUP BY t.id, t.name
            ORDER BY t.name ASC
        "#)
        .fetch_all(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(rows.into_iter().map(Self::tag_from_row).collect())
    }
    
    pub async fn create_tag(&self, tag_data: &CreateTagRequest) -> Result<Tag, DatabaseError> {
        let id = Uuid::new_v4().to_string();
        let now = Utc::now();
        
        sqlx::query(r#"
            INSERT INTO tags (id, name, description, created_at)
            VALUES (?, ?, ?, ?)
        "#)
        .bind(&id)
        .bind(&tag_data.name)
        .bind(&tag_data.description)
        .bind(now)
        .execute(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        self.get_tag_by_id(&id).await
    }
    
    pub async fn get_tag_by_id(&self, id: &str) -> Result<Tag, DatabaseError> {
        let row = sqlx::query(r#"
            SELECT t.*, COUNT(pt.post_id) as post_count
            FROM tags t
            LEFT JOIN post_tags pt ON t.id = pt.tag_name
            WHERE t.id = ?
            GROUP BY t.id
        "#)
        .bind(id)
        .fetch_one(&self.pool)
        .await
        .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        
        Ok(Self::tag_from_row(row))
    }
    
    pub async fn get_blog_statistics(&self) -> Result<std::collections::HashMap<String, serde_json::Value>, DatabaseError> {
        let mut stats = std::collections::HashMap::new();
        
        // Total users
        let user_count = sqlx::query_scalar("SELECT COUNT(*) FROM users WHERE is_active = 1")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        stats.insert("total_users".to_string(), serde_json::Value::from(user_count::<i64>()));
        
        // Total posts
        let post_count = sqlx::query_scalar("SELECT COUNT(*) FROM posts")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        stats.insert("total_posts".to_string(), serde_json::Value::from(post_count::<i64>()));
        
        // Published posts
        let published_count = sqlx::query_scalar("SELECT COUNT(*) FROM posts WHERE is_published = 1")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        stats.insert("published_posts".to_string(), serde_json::Value::from(published_count::<i64>()));
        
        // Total comments
        let comment_count = sqlx::query_scalar("SELECT COUNT(*) FROM comments WHERE is_approved = 1")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        stats.insert("total_comments".to_string(), serde_json::Value::from(comment_count::<i64>()));
        
        // Total tags
        let tag_count = sqlx::query_scalar("SELECT COUNT(*) FROM tags")
            .fetch_one(&self.pool)
            .await
            .map_err(|e| DatabaseError::QueryError(e.to_string()))?;
        stats.insert("total_tags".to_string(), serde_json::Value::from(tag_count::<i64>()));
        
        Ok(stats)
    }
    
    fn comment_from_row(row: sqlx::sqlite::SqliteRow) -> Comment {
        Comment {
            id: Uuid::parse_str(row.get("id")).unwrap(),
            post_id: Uuid::parse_str(row.get("post_id")).unwrap(),
            author_id: Uuid::parse_str(row.get("author_id")).unwrap(),
            parent_id: row.get::<Option<String>, _>("parent_id")
                .and_then(|s| Uuid::parse_str(&s).ok()),
            content: row.get("content"),
            created_at: row.get("created_at"),
            updated_at: row.get("updated_at"),
            is_approved: row.get("is_approved"),
            like_count: row.get("like_count"),
        }
    }
    
    fn tag_from_row(row: sqlx::sqlite::SqliteRow) -> Tag {
        Tag {
            id: Uuid::parse_str(row.get("id")).unwrap(),
            name: row.get("name"),
            description: row.get("description"),
            created_at: row.get("created_at"),
            post_count: row.get("post_count"),
        }
    }
}
}

性能优化与最佳实践

1. 集合选择指南

#![allow(unused)]
fn main() {
fn collection_selection_guide() {
    // 何时使用Vec<T>
    // - 需要随机访问 (O(1))
    // - 频繁在末尾添加/删除元素
    // - 需要索引访问
    let mut numbers = Vec::new();
    numbers.push(42); // O(1) 追加
    let first = numbers[0]; // O(1) 访问
    
    // 何时使用HashMap<K, V>
    // - 需要根据键快速查找 (O(1))
    // - 需要根据键插入/删除 (O(1))
    // - 键的唯一性很重要
    let mut user_cache = HashMap::new();
    user_cache.insert("user_id", "user_data"); // O(1) 插入
    
    // 何时使用BTreeMap<K, V>
    // - 需要按键排序遍历
    // - 需要范围查询
    // - 键的大小比较有意义
    let mut sorted_users = BTreeMap::new();
    sorted_users.insert("Bob", "data1");
    sorted_users.insert("Alice", "data2"); // 自动按键排序
    
    // 何时使用HashSet<T>
    // - 需要快速检查成员关系 (O(1))
    // - 需要集合操作 (并集、交集、差集)
    let mut tags = HashSet::new();
    tags.insert("rust");
    tags.insert("programming");
    let has_rust = tags.contains("rust"); // O(1) 检查
    
    // 何时使用VecDeque<T>
    // - 需要高效的在两端添加/删除
    // - 实现队列或双端队列
    let mut queue = VecDeque::new();
    queue.push_back(1); // O(1) 队尾插入
    let front = queue.pop_front(); // O(1) 队头删除
}
}

2. 内存优化策略

#![allow(unused)]
fn main() {
fn memory_optimization() {
    // 1. 预分配容量
    let mut large_vec = Vec::with_capacity(10000);
    for i in 0..10000 {
        large_vec.push(i);
    }
    // 避免重复分配内存
    
    // 2. 压缩数据结构
    use std::mem;
    
    #[repr(C)]
    struct CompactUser {
        id: u32,        // 4字节
        age: u8,        // 1字节
        active: bool,   // 1字节
        // 编译器会在这些字段之间添加填充字节
    }
    
    // 3. 使用引用而不是复制
    let data = vec![1, 2, 3, 4, 5];
    let slice = &data[1..4]; // 只借用数据，而不是复制
    println!("Slice: {:?}", slice);
    
    // 4. 避免不必要的分配
    let mut result = String::new();
    for i in 0..1000 {
        // 不推荐：每次都分配
        let temp = format!("Item {}", i);
        result.push_str(&temp);
    }
    
    // 推荐：重用缓冲区
    let mut buffer = String::with_capacity(8000);
    let mut temp = String::new();
    for i in 0..1000 {
        temp.clear();
        temp.push_str("Item ");
        temp.push_str(&i.to_string());
        buffer.push_str(&temp);
    }
    
    // 5. 懒加载
    struct LazyData<T> {
        data: Option<T>,
        init: Box<dyn Fn() -> T>,
    }
    
    impl<T> LazyData<T> {
        fn new<F: Fn() -> T + 'static>(init: F) -> Self {
            Self {
                data: None,
                init: Box::new(init),
            }
        }
        
        fn get(&mut self) -> &T {
            if self.data.is_none() {
                self.data = Some((self.init)());
            }
            self.data.as_ref().unwrap()
        }
    }
}
}

3. 性能测试

#![allow(unused)]
fn main() {
fn performance_benchmarking() {
    use std::time::{Duration, Instant};
    
    // 1. Vector vs LinkedList vs ArrayDeque
    let iterations = 100000;
    
    // Vector测试
    let start = Instant::now();
    let mut vec = Vec::new();
    for i in 0..iterations {
        vec.push(i);
    }
    let vec_time = start.elapsed();
    
    // 查找测试
    let start = Instant::now();
    for i in 0..10000 {
        let _ = vec.iter().find(|&&x| x == i);
    }
    let vec_search_time = start.elapsed();
    
    println!("Vector operations:");
    println!("  Push: {:?}", vec_time);
    println!("  Search: {:?}", vec_search_time);
    
    // HashMap vs BTreeMap
    let start = Instant::now();
    let mut hash_map = HashMap::new();
    for i in 0..iterations {
        hash_map.insert(i, format!("value_{}", i));
    }
    let hashmap_build_time = start.elapsed();
    
    let start = Instant::now();
    for i in 0..10000 {
        let _ = hash_map.get(&i);
    }
    let hashmap_search_time = start.elapsed();
    
    println!("HashMap operations:");
    println!("  Build: {:?}", hashmap_build_time);
    println!("  Search: {:?}", hashmap_search_time);
    
    // BTreeMap测试
    let start = Instant::now();
    let mut btree_map = BTreeMap::new();
    for i in 0..iterations {
        btree_map.insert(i, format!("value_{}", i));
    }
    let btree_build_time = start.elapsed();
    
    let start = Instant::now();
    for i in 0..10000 {
        let _ = btree_map.get(&i);
    }
    let btree_search_time = start.elapsed();
    
    println!("BTreeMap operations:");
    println!("  Build: {:?}", btree_build_time);
    println!("  Search: {:?}", btree_search_time);
}
}

4. 并发安全集合

#![allow(unused)]
fn main() {
use std::sync::{Arc, RwLock, Mutex};
use std::thread;
use std::time::Duration;

fn concurrent_collections() {
    // 1. 线程安全的HashMap
    let map = Arc::new(RwLock::new(HashMap::new()));
    
    let handles: Vec<_> = (0..10).map(|i| {
        let map_clone = Arc::clone(&map);
        thread::spawn(move || {
            for j in 0..1000 {
                let key = format!("key_{}_{}", i, j);
                let value = format!("value_{}_{}", i, j);
                
                {
                    let mut map = map_clone.write().unwrap();
                    map.insert(key, value);
                }
                
                thread::sleep(Duration::from_micros(1));
            }
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    let final_map = map.read().unwrap();
    println!("Concurrent map size: {}", final_map.len());
    
    // 2. 线程安全的Vec
    let vec = Arc::new(Mutex::new(Vec::new()));
    
    let handles: Vec<_> = (0..5).map(|i| {
        let vec_clone = Arc::clone(&vec);
        thread::spawn(move || {
            for j in 0..100 {
                let mut vec = vec_clone.lock().unwrap();
                vec.push(i * 100 + j);
            }
        })
    }).collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    let final_vec = vec.lock().unwrap();
    println!("Concurrent vec length: {}", final_vec.len());
    println!("Final vec sum: {}", final_vec.iter().sum::<i32>());
}
}

总结

本章要点回顾

Vector（Vec）：
- 动态数组，支持随机访问
- O(1) 追加操作，适合频繁添加元素
- 预分配容量可以提升性能
- 切片操作提供安全访问
HashMap与HashSet：
- O(1) 平均查找性能
- 适合键值对存储和集合操作
- 需要实现Hash trait用于自定义类型
- Entry API提供高效的条件操作
迭代器与闭包：
- 惰性计算，避免不必要的计算
- 链式操作提高代码可读性
- 高阶函数模式支持
- 性能优化通过短路操作
其他集合类型：
- BTreeMap/BTreeSet：有序集合，适合范围查询
- VecDeque：双端队列，支持高效两端操作
- BinaryHeap：优先级队列
实战项目成果：
- Todo管理器：完整的命令行应用，支持数据持久化和复杂查询
- Web API服务器：生产级博客后端，包含用户管理、文章系统、评论功能

学习成果检验

完成本章后，你应该能够：

熟练使用各种Rust集合类型
理解不同集合的性能特征和适用场景
设计高效的数据存储和查询策略
构建基于集合的复杂应用
进行性能优化和内存管理

下章预告

第8章将深入学习模块系统与工程化，包括：

Rust模块系统的深入理解
Crate和Package管理
依赖管理最佳实践
代码组织结构设计
企业级项目架构

实践建议

扩展Todo管理器：
- 添加日历视图功能
- 实现同步到云服务
- 增加团队协作功能
增强Web API：
- 添加缓存层
- 实现全文搜索
- 添加实时通知功能
- 集成第三方服务（邮件、短信等）
性能测试：
- 使用criterion进行基准测试
- 分析内存使用情况
- 进行压力测试

Rust的集合类型为你提供了构建高效、可靠应用程序的强大工具。通过这些基础组件，你可以构建出企业级的复杂系统。在下一章中，我们将学习如何组织这些组件以构建更大的应用程序。

第8章：模块系统与工程化

学习目标

掌握Rust模块系统的核心概念
学会组织和构建大型项目结构
理解包和Crate的关系
掌握Cargo工作空间的使用
学习第三方依赖管理
构建一个完整的企业级微服务框架

8.1 模块系统基础

8.1.1 模块的创建与使用

在Rust中，模块是一种组织代码的方式，可以将相关的功能组合在一起。模块系统是Rust语言的核心特性之一，它帮助我们管理大型项目的复杂性。

基本模块定义

// src/main.rs
mod math {
    // 模块中的私有函数
    fn add(a: i32, b: i32) -> i32 {
        a + b
    }
    
    // 标记为pub的公共函数
    pub fn multiply(a: i32, b: i32) -> i32 {
        a * b
    }
    
    // 子模块
    pub mod advanced {
        pub fn power(base: f64, exponent: f64) -> f64 {
            base.powf(exponent)
        }
    }
}

fn main() {
    // 访问模块中的函数
    let result = math::multiply(5, 3);
    println!("5 * 3 = {}", result);
    
    // 访问子模块中的函数
    let power_result = math::advanced::power(2.0, 3.0);
    println!("2^3 = {}", power_result);
    
    // 无法调用私有函数
    // math::add(1, 2); // 编译错误
}

可见性规则

Rust的模块系统有一个清晰的可见性规则：

默认情况下，模块中的所有项（函数、结构体、枚举等）都是私有的
只有标记为pub的项才能被外部访问
即使是公共项，也需要通过模块路径来访问

mod calculator {
    // 私有结构体
    struct Calculator {
        result: f64,
    }
    
    // 公共结构体
    pub struct Config {
        pub precision: u8,
        pub rounding: bool,
    }
    
    // 私有函数
    fn get_default_config() -> Config {
        Config {
            precision: 2,
            rounding: true,
        }
    }
    
    // 公共函数
    pub fn calculate(operation: &str, a: f64, b: f64) -> Result<f64, String> {
        match operation {
            "add" => Ok(a + b),
            "subtract" => Ok(a - b),
            "multiply" => Ok(a * b),
            "divide" => {
                if b == 0.0 {
                    Err("Division by zero".to_string())
                } else {
                    Ok(a / b)
                }
            },
            _ => Err("Unknown operation".to_string()),
        }
    }
    
    // 重新导出公共项
    pub use Config;
}

fn main() {
    // 使用公共结构体
    let config = calculator::Config {
        precision: 4,
        rounding: true,
    };
    
    // 使用公共函数
    match calculator::calculate("divide", 10.0, 3.0) {
        Ok(result) => println!("Result: {:.2}", result),
        Err(e) => println!("Error: {}", e),
    }
    
    // 使用重新导出的类型
    let config = calculator::Config;
}

8.1.2 路径与模块引用

在Rust中，有两种方式引用模块中的项：

绝对路径（从crate根开始）：crate::module::item
相对路径（从当前模块开始）：module::item、self::item、super::item

// src/main.rs
mod network {
    pub mod client {
        pub struct HttpClient {
            pub base_url: String,
        }
        
        impl HttpClient {
            pub fn new(url: &str) -> Self {
                Self {
                    base_url: url.to_string(),
                }
            }
        }
    }
    
    pub mod server {
        use super::client::HttpClient; // 相对路径导入
        
        pub struct WebServer {
            clients: Vec<HttpClient>,
        }
        
        impl WebServer {
            pub fn new() -> Self {
                Self {
                    clients: Vec::new(),
                }
            }
        }
    }
}

fn main() {
    // 使用绝对路径
    let client = network::client::HttpClient::new("https://api.example.com");
    
    // 使用相对路径
    use network::server::WebServer;
    let server = WebServer::new();
}

路径导入与别名

#![allow(unused)]
fn main() {
use std::collections::HashMap;
use std::io::{self, Read, Write}; // 多项导入
use std::fs::File as MyFile; // 重命名导入

// 全局导入常用项
use std::result::Result as StdResult;

// 嵌套路径导入
use std::{
    path::{Path, PathBuf},
    time::Duration,
};

fn example_usage() {
    // 使用导入的别名
    let file = MyFile::open("data.txt").unwrap();
    
    // 使用嵌套路径导入
    let path = Path::new("example.txt");
    let duration = Duration::from_millis(100);
}
}

8.1.3 模块文件的组织

对于大型项目，模块可以组织在不同的文件中。

单文件组织方式（推荐用于简单项目）：

#![allow(unused)]
fn main() {
// src/main.rs
mod utils {
    mod math {
        pub fn add(a: i32, b: i32) -> i32 {
            a + b
        }
    }
    
    mod string {
        pub fn capitalize(s: &str) -> String {
            s.chars()
                .next()
                .map_or_else(String::new, |c| {
                    c.to_uppercase().collect::<String>() + &s[1..]
                })
        }
    }
}
}

多文件组织方式（推荐用于大型项目）：

// src/main.rs
// 导入子模块
mod utils {
    pub mod math;
    pub mod string;
}

// 重新导出，方便使用
pub use utils::math::add;
pub use utils::string::capitalize;

fn main() {
    let result = add(5, 3);
    let name = capitalize("hello world");
    println!("Result: {}, Capitalized: {}", result, name);
}

#![allow(unused)]
fn main() {
// src/utils/mod.rs
// 声明子模块
pub mod math;
pub mod string;

// 公共工具函数
pub fn validate_email(email: &str) -> bool {
    email.contains('@') && email.contains('.')
}
}

#![allow(unused)]
fn main() {
// src/utils/math.rs
// 数学运算模块
pub fn add(a: i32, b: i32) -> i32 {
    a + b
}

pub fn multiply(a: i32, b: i32) -> i32 {
    a * b
}

pub fn power(base: f64, exponent: f64) -> f64 {
    base.powf(exponent)
}
}

#![allow(unused)]
fn main() {
// src/utils/string.rs
// 字符串处理模块
pub fn capitalize(s: &str) -> String {
    s.chars()
        .next()
        .map_or_else(String::new, |c| {
            c.to_uppercase().collect::<String>() + &s[1..]
        })
}

pub fn reverse(s: &str) -> String {
    s.chars().rev().collect()
}

pub fn word_count(s: &str) -> usize {
    s.split_whitespace().count()
}
}

8.2 Crate与包管理

8.2.1 包（Package）与Crate的区别

在Rust中，理解包（Package）和Crate的区别很重要：

包（Package）：一个包含0个或多个Crate的目录
Crate：编译的基本单元，是一个库或可执行程序

创建包

# 创建新的包
cargo new my-package
# 这会创建：
# my-package/
# ├── Cargo.toml
# └── src/
#     └── main.rs

# Cargo.toml - 包配置文件
[package]
name = "my-package"
version = "0.1.0"
edition = "2021"
authors = ["Your Name <email@example.com>"]
description = "A sample package"
repository = "https://github.com/username/my-package"
license = "MIT"
keywords = ["sample", "tutorial"]
categories = ["development-tools"]

[dependencies]
# 依赖项
serde = "1.0"
serde_json = "1.0"
tokio = { version = "1.0", features = ["full"] }

[dev-dependencies]
# 开发依赖（仅用于测试和构建）
tempfile = "3.0"

[build-dependencies]
# 构建依赖（build.rs中使用）
cc = "1.0"

[features]
# 特性标志
default = []
optimized = ["serde/derive"]

8.2.2 库Crate与二进制Crate

库Crate（生成lib文件）

#![allow(unused)]
fn main() {
// src/lib.rs
// 库 crate 的入口文件
pub mod math {
    pub struct Calculator {
        precision: u8,
    }
    
    impl Calculator {
        pub fn new(precision: u8) -> Self {
            Self { precision }
        }
        
        pub fn add(&self, a: f64, b: f64) -> f64 {
            self.round(a + b)
        }
        
        pub fn multiply(&self, a: f64, b: f64) -> f64 {
            self.round(a * b)
        }
        
        fn round(&self, value: f64) -> f64 {
            let factor = 10f64.powi(self.precision as i32);
            (value * factor).round() / factor
        }
    }
}

pub mod io {
    use std::fs::File;
    use std::io::{self, Read, Write};
    
    pub fn read_file(path: &str) -> Result<String, io::Error> {
        let mut file = File::open(path)?;
        let mut content = String::new();
        file.read_to_string(&mut content)?;
        Ok(content)
    }
    
    pub fn write_file(path: &str, content: &str) -> Result<(), io::Error> {
        let mut file = File::create(path)?;
        file.write_all(content.as_bytes())?;
        Ok(())
    }
}
}

二进制Crate

// src/main.rs
// 入口文件
use my_package::{math::Calculator, io::{read_file, write_file}};
use std::env;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    
    if args.len() < 4 {
        println!("Usage: {} <operation> <num1> <num2> [precision]", args[0]);
        println!("Operations: add, multiply");
        return Ok(());
    }
    
    let operation = &args[1];
    let num1: f64 = args[2].parse()?;
    let num2: f64 = args[3].parse()?;
    let precision = args.get(4).and_then(|s| s.parse().ok()).unwrap_or(2);
    
    let calculator = Calculator::new(precision);
    
    let result = match operation.as_str() {
        "add" => calculator.add(num1, num2),
        "multiply" => calculator.multiply(num1, num2),
        _ => {
            eprintln!("Unknown operation: {}", operation);
            return Ok(());
        }
    };
    
    println!("Result: {}", result);
    
    // 如果提供了文件路径，保存结果
    if args.len() > 5 {
        let output_path = &args[5];
        let output = format!("{} {} {} = {}\n", num1, operation, num2, result);
        write_file(output_path, &output)?;
        println!("Result saved to {}", output_path);
    }
    
    Ok(())
}

8.2.3 内部模块与外部模块

内部模块

#![allow(unused)]
fn main() {
// src/lib.rs
pub mod database {
    pub mod mysql {
        pub struct MySqlConnection {
            pub connection_string: String,
        }
        
        impl MySqlConnection {
            pub fn new(connection_string: &str) -> Self {
                Self {
                    connection_string: connection_string.to_string(),
                }
            }
            
            pub fn connect(&self) -> Result<(), String> {
                // 模拟连接
                println!("Connecting to MySQL: {}", self.connection_string);
                Ok(())
            }
        }
    }
    
    pub mod postgresql {
        pub struct PostgresConnection {
            pub connection_string: String,
        }
        
        impl PostgresConnection {
            pub fn new(connection_string: &str) -> Self {
                Self {
                    connection_string: connection_string.to_string(),
                }
            }
            
            pub fn connect(&self) -> Result<(), String> {
                // 模拟连接
                println!("Connecting to PostgreSQL: {}", self.connection_string);
                Ok(())
            }
        }
    }
}
}

外部模块

#![allow(unused)]
fn main() {
// src/lib.rs
// 外部模块的声明
pub mod external;
}

#![allow(unused)]
fn main() {
// src/external/mod.rs
// 外部模块的实现
pub mod api;
pub mod utils;
}

#![allow(unused)]
fn main() {
// src/external/api.rs
pub mod rest {
    use reqwest::{Client, Response};
    use serde::{Deserialize, Serialize};
    
    #[derive(Debug, Serialize, Deserialize)]
    pub struct ApiResponse<T> {
        pub success: bool,
        pub data: Option<T>,
        pub message: Option<String>,
    }
    
    pub struct RestClient {
        client: Client,
        base_url: String,
    }
    
    impl RestClient {
        pub fn new(base_url: &str) -> Result<Self, Box<dyn std::error::Error>> {
            let client = Client::new();
            Ok(Self {
                client,
                base_url: base_url.to_string(),
            })
        }
        
        pub async fn get<T>(&self, endpoint: &str) -> Result<ApiResponse<T>, Box<dyn std::error::Error>>
        where
            T: serde::de::DeserializeOwned,
        {
            let url = format!("{}/{}", self.base_url, endpoint);
            let response = self.client.get(&url).send().await?;
            let result = response.json::<ApiResponse<T>>().await?;
            Ok(result)
        }
        
        pub async fn post<T, U>(
            &self,
            endpoint: &str,
            data: &U,
        ) -> Result<ApiResponse<T>, Box<dyn std::error::Error>>
        where
            T: serde::de::DeserializeOwned,
            U: serde::ser::Serialize,
        {
            let url = format!("{}/{}", self.base_url, endpoint);
            let response = self.client.post(&url).json(data).send().await?;
            let result = response.json::<ApiResponse<T>>().await?;
            Ok(result)
        }
    }
}
}

8.3 Cargo工作空间

8.3.1 工作空间的概念

Cargo工作空间允许您在多个包之间共享依赖项并简化构建过程。这对于大型项目特别有用。

8.3.2 创建工作空间

工作空间目录结构

# Cargo.toml (工作空间根目录)
[workspace]
members = [
    "framework-core",
    "http-server",
    "service-registry",
    "config-manager",
    "monitoring",
    "examples/user-service",
    "examples/order-service",
    "examples/gateway",
]

[workspace.dependencies]
# 共享的依赖项
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
anyhow = "1.0"
log = "0.4"
tracing = "0.1"
tracing-subscriber = "0.3"

共享依赖配置

# framework-core/Cargo.toml
[package]
name = "framework-core"
version = "0.1.0"
edition = "2021"

[dependencies]
# 继承工作空间的依赖
tokio = { workspace = true }
serde = { workspace = true }
anyhow = { workspace = true }

# 特定依赖
thiserror = "1.0"
async-trait = "0.1"

8.3.3 框架核心模块

#![allow(unused)]
fn main() {
// framework-core/src/lib.rs
pub mod service;
pub mod config;
pub mod error;
pub mod health;

// 导出常用的类型
pub use service::{Service, ServiceBuilder};
pub use config::Config;
pub use error::{FrameworkError, FrameworkResult};
pub use health::{HealthChecker, HealthStatus};

use tracing::{info, error};
use std::sync::Arc;

/// 框架主入口
pub struct Framework {
    services: Vec<Arc<dyn Service>>,
    config: Config,
}

impl Framework {
    pub fn new(config: Config) -> Self {
        Self {
            services: Vec::new(),
            config,
        }
    }
    
    pub fn register_service(&mut self, service: Arc<dyn Service>) {
        info!("Registering service: {}", service.name());
        self.services.push(service);
    }
    
    pub async fn start(&self) -> FrameworkResult<()> {
        info!("Starting Framework with {} services", self.services.len());
        
        for service in &self.services {
            if let Err(e) = service.start().await {
                error!("Failed to start service {}: {}", service.name(), e);
                return Err(e.into());
            }
        }
        
        Ok(())
    }
    
    pub async fn stop(&self) -> FrameworkResult<()> {
        info!("Stopping Framework");
        
        for service in &self.services {
            if let Err(e) = service.stop().await {
                error!("Failed to stop service {}: {}", service.name(), e);
                // 继续停止其他服务
            }
        }
        
        Ok(())
    }
}
}

#![allow(unused)]
fn main() {
// framework-core/src/service.rs
use crate::{FrameworkError, FrameworkResult};
use async_trait::async_trait;
use std::time::{Duration, Instant};

/// 服务特征定义
#[async_trait]
pub trait Service: Send + Sync {
    /// 获取服务名称
    fn name(&self) -> &str;
    
    /// 启动服务
    async fn start(&self) -> FrameworkResult<()>;
    
    /// 停止服务
    async fn stop(&self) -> FrameworkResult<()>;
    
    /// 健康检查
    async fn health_check(&self) -> FrameworkResult<bool>;
}

/// 基础服务实现
pub struct BaseService {
    name: String,
    started_at: Option<Instant>,
    state: ServiceState,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum ServiceState {
    Stopped,
    Starting,
    Running,
    Stopping,
    Failed,
}

impl BaseService {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            started_at: None,
            state: ServiceState::Stopped,
        }
    }
    
    pub fn with_startup_timeout(mut self, timeout: Duration) -> Self {
        // 配置启动超时
        self
    }
}

#[async_trait]
impl Service for BaseService {
    fn name(&self) -> &str {
        &self.name
    }
    
    async fn start(&self) -> FrameworkResult<()> {
        tracing::info!("Starting service: {}", self.name);
        // 模拟启动过程
        tokio::time::sleep(Duration::from_millis(100)).await;
        Ok(())
    }
    
    async fn stop(&self) -> FrameworkResult<()> {
        tracing::info!("Stopping service: {}", self.name);
        // 模拟停止过程
        tokio::time::sleep(Duration::from_millis(50)).await;
        Ok(())
    }
    
    async fn health_check(&self) -> FrameworkResult<bool> {
        // 简单的健康检查
        Ok(true)
    }
}

/// 服务构建器
pub struct ServiceBuilder {
    name: String,
    startup_timeout: Option<Duration>,
    shutdown_timeout: Option<Duration>,
    health_check_interval: Option<Duration>,
}

impl ServiceBuilder {
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            startup_timeout: Some(Duration::from_secs(30)),
            shutdown_timeout: Some(Duration::from_secs(10)),
            health_check_interval: Some(Duration::from_secs(30)),
        }
    }
    
    pub fn startup_timeout(mut self, timeout: Duration) -> Self {
        self.startup_timeout = Some(timeout);
        self
    }
    
    pub fn shutdown_timeout(mut self, timeout: Duration) -> Self {
        self.shutdown_timeout = Some(timeout);
        self
    }
    
    pub fn health_check_interval(mut self, interval: Duration) -> Self {
        self.health_check_interval = Some(interval);
        self
    }
    
    pub fn build(self) -> BaseService {
        BaseService::new(&self.name)
    }
}
}

8.3.4 HTTP服务器模块

#![allow(unused)]
fn main() {
// http-server/src/lib.rs
pub mod server;
pub mod router;
pub mod middleware;
pub mod request_handler;

use framework_core::{Service, FrameworkResult};
use server::HttpServer;
use std::sync::Arc;
use tokio::sync::oneshot;

/// HTTP服务实现
pub struct HttpService {
    name: String,
    server: HttpServer,
    shutdown_tx: Option<oneshot::Sender<()>>,
}

impl HttpService {
    pub fn new(port: u16, routes: router::Router) -> Self {
        let name = format!("http-server-{}", port);
        let server = HttpServer::new(port, routes);
        
        Self {
            name,
            server,
            shutdown_tx: None,
        }
    }
}

#[async_trait::async_trait]
impl Service for HttpService {
    fn name(&self) -> &str {
        &self.name
    }
    
    async fn start(&self) -> FrameworkResult<()> {
        use framework_core::tracing;
        
        tracing::info!("Starting HTTP server on port {}", self.server.port());
        
        let (shutdown_tx, shutdown_rx) = oneshot::channel();
        
        // 启动服务器
        let server_handle = self.server.start();
        
        // 启动后台任务监听关闭信号
        tokio::spawn(async move {
            shutdown_rx.await.ok();
            tracing::info!("Received shutdown signal for HTTP server");
        });
        
        // 等待服务器启动完成
        server_handle.await?;
        
        Ok(())
    }
    
    async fn stop(&self) -> FrameworkResult<()> {
        use framework_core::tracing;
        
        tracing::info!("Stopping HTTP server");
        
        if let Some(tx) = &self.shutdown_tx {
            let _ = tx.send(());
        }
        
        Ok(())
    }
    
    async fn health_check(&self) -> FrameworkResult<bool> {
        // 简单的健康检查 - 检查服务器是否响应
        Ok(true)
    }
}
}

8.3.5 服务注册模块

#![allow(unused)]
fn main() {
// service-registry/src/lib.rs
pub mod registry;
pub mod service_info;
pub mod health_check;
pub mod discovery;

use registry::ServiceRegistry;
use service_info::ServiceInfo;
use health_check::HealthChecker;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use framework_core::{Service, FrameworkResult};
use tracing::{info, warn, error};

/// 服务注册服务
pub struct RegistryService {
    name: String,
    registry: Arc<RwLock<ServiceRegistry>>,
    health_checker: HealthChecker,
}

impl RegistryService {
    pub fn new() -> Self {
        Self {
            name: "service-registry".to_string(),
            registry: Arc::new(RwLock::new(ServiceRegistry::new())),
            health_checker: HealthChecker::new(),
        }
    }
    
    /// 注册新服务
    pub async fn register_service(&self, service: ServiceInfo) -> FrameworkResult<()> {
        let mut registry = self.registry.write().await;
        registry.register(service).await?;
        info!("Service registered successfully");
        Ok(())
    }
    
    /// 查找服务
    pub async fn discover_service(&self, name: &str) -> FrameworkResult<Option<ServiceInfo>> {
        let registry = self.registry.read().await;
        Ok(registry.find_service(name).await)
    }
    
    /// 获取所有服务
    pub async fn list_services(&self) -> FrameworkResult<Vec<ServiceInfo>> {
        let registry = self.registry.read().await;
        Ok(registry.list_services().await)
    }
}

#[async_trait::async_trait]
impl Service for RegistryService {
    fn name(&self) -> &str {
        &self.name
    }
    
    async fn start(&self) -> FrameworkResult<()> {
        info!("Starting service registry");
        
        // 启动健康检查器
        self.health_checker.start().await?;
        
        // 开始定期健康检查
        let registry_clone = self.registry.clone();
        let health_checker = self.health_checker.clone();
        
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(30));
            
            loop {
                interval.tick().await;
                
                let mut registry = registry_clone.write().await;
                if let Err(e) = registry.perform_health_checks(&health_checker).await {
                    error!("Health check failed: {}", e);
                }
            }
        });
        
        Ok(())
    }
    
    async fn stop(&self) -> FrameworkResult<()> {
        info!("Stopping service registry");
        self.health_checker.stop().await?;
        Ok(())
    }
    
    async fn health_check(&self) -> FrameworkResult<bool> {
        Ok(true) // 简单实现
    }
}
}

8.4 实战项目：企业级微服务开发框架

8.4.1 项目整体架构

让我们创建一个完整的企业级微服务开发框架，展示模块化架构设计的最佳实践。

完整项目结构

microservice-framework/
├── Cargo.toml                    # 工作空间根配置
├── framework-core/               # 框架核心
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── service.rs
│   │   ├── config.rs
│   │   ├── error.rs
│   │   ├── health.rs
│   │   └── tracing.rs
│   └── examples/
│       └── basic_service.rs
│
├── http-server/                 # HTTP服务器
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── server.rs
│   │   ├── router.rs
│   │   ├── middleware.rs
│   │   ├── request_handler.rs
│   │   └── response.rs
│   └── examples/
│       └── simple_server.rs
│
├── service-registry/            # 服务注册与发现
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── registry.rs
│   │   ├── service_info.rs
│   │   ├── health_check.rs
│   │   └── discovery.rs
│   └── examples/
│       └── service_registration.rs
│
├── config-manager/              # 配置管理
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── config.rs
│   │   ├── loader.rs
│   │   ├── watcher.rs
│   │   └── provider.rs
│   └── examples/
│       └── config_demo.rs
│
├── monitoring/                  # 监控与指标
│   ├── Cargo.toml
│   ├── src/
│   │   ├── lib.rs
│   │   ├── metrics.rs
│   │   ├── logger.rs
│   │   └── health.rs
│   └── examples/
│       └── monitoring_demo.rs
│
├── examples/                    # 示例服务
│   ├── user-service/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── main.rs
│   │       ├── handlers.rs
│   │       ├── models.rs
│   │       └── config.rs
│   │
│   ├── order-service/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── main.rs
│   │       ├── handlers.rs
│   │       ├── models.rs
│   │       └── config.rs
│   │
│   └── gateway/
│       ├── Cargo.toml
│       └── src/
│           ├── main.rs
│           ├── proxy.rs
│           └── config.rs
│
├── docs/                        # 文档
│   ├── architecture.md
│   ├── api.md
│   └── deployment.md
│
└── scripts/                     # 部署脚本
    ├── deploy.sh
    └── setup.sh

8.4.2 配置文件管理

#![allow(unused)]
fn main() {
// config-manager/src/lib.rs
pub mod config;
pub mod loader;
pub mod watcher;
pub mod provider;

pub use config::ConfigManager;
pub use loader::ConfigLoader;
pub use watcher::ConfigWatcher;
pub use provider::ConfigProvider;

use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use serde::{Serialize, Deserialize};
use tracing::{info, warn, error};

/// 配置管理器主入口
pub struct ConfigManager {
    configs: Arc<RwLock<HashMap<String, ConfigValue>>>,
    watchers: Vec<ConfigWatcher>,
    provider: ConfigProvider,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigValue {
    pub value: serde_json::Value,
    pub source: String,
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub version: u64,
}

impl ConfigManager {
    pub fn new(provider: ConfigProvider) -> Self {
        Self {
            configs: Arc::new(RwLock::new(HashMap::new())),
            watchers: Vec::new(),
            provider,
        }
    }
    
    /// 加载配置
    pub async fn load_config(&self, key: &str) -> Result<ConfigValue, ConfigError> {
        let value = self.provider.load(key).await?;
        let mut configs = self.configs.write().await;
        configs.insert(key.to_string(), value.clone());
        Ok(value)
    }
    
    /// 获取配置值
    pub async fn get_config(&self, key: &str) -> Option<ConfigValue> {
        let configs = self.configs.read().await;
        configs.get(key).cloned()
    }
    
    /// 设置配置值
    pub async fn set_config(&self, key: &str, value: ConfigValue) -> Result<(), ConfigError> {
        self.provider.save(key, &value).await?;
        let mut configs = self.configs.write().await;
        configs.insert(key.to_string(), value);
        
        // 通知观察者
        self.notify_watchers(key).await;
        Ok(())
    }
    
    /// 添加配置观察者
    pub fn add_watcher(&mut self, watcher: ConfigWatcher) {
        self.watchers.push(watcher);
    }
    
    /// 通知所有观察者
    async fn notify_watchers(&self, key: &str) {
        for watcher in &self.watchers {
            if let Err(e) = watcher.notify(key).await {
                error!("Failed to notify watcher: {}", e);
            }
        }
    }
    
    /// 监听配置变化
    pub async fn watch_config(&self, key: &str) -> Result<tokio::sync::mpsc::Receiver<ConfigValue>, ConfigError> {
        let (tx, rx) = tokio::sync::mpsc::channel(100);
        let config_key = key.to_string();
        
        let watcher = ConfigWatcher::new(config_key, tx);
        // 在实际实现中，需要避免无限引用循环
        
        Ok(rx)
    }
}
}

8.4.3 监控与指标

#![allow(unused)]
fn main() {
// monitoring/src/lib.rs
pub mod metrics;
pub mod logger;
pub mod health;

use metrics::{MetricsCollector, Counter, Histogram, Gauge};
use logger::StructuredLogger;
use health::{HealthChecker, HealthStatus};
use std::time::{Duration, Instant};
use tokio::time::interval;

/// 监控主服务
pub struct MonitoringService {
    name: String,
    metrics_collector: MetricsCollector,
    logger: StructuredLogger,
    health_checker: HealthChecker,
    start_time: Instant,
}

impl MonitoringService {
    pub fn new() -> Self {
        Self {
            name: "monitoring".to_string(),
            metrics_collector: MetricsCollector::new(),
            logger: StructuredLogger::new(),
            health_checker: HealthChecker::new(),
            start_time: Instant::now(),
        }
    }
    
    /// 记录请求指标
    pub fn record_request(&self, method: &str, path: &str, status_code: u16, duration: Duration) {
        self.metrics_collector
            .counter("http_requests_total")
            .with_labels(&[("method", method), ("path", path), ("status", &status_code.to_string())])
            .inc();
            
        self.metrics_collector
            .histogram("http_request_duration")
            .with_labels(&[("method", method), ("path", path)])
            .observe(duration.as_secs_f64());
    }
    
    /// 记录服务指标
    pub fn record_service_metric(&self, service: &str, metric: &str, value: f64) {
        self.metrics_collector
            .gauge("service_metric")
            .with_labels(&[("service", service), ("metric", metric)])
            .set(value);
    }
    
    /// 获取系统健康状态
    pub async fn get_health_status(&self) -> HealthStatus {
        let uptime = self.start_time.elapsed();
        let memory_usage = self.get_memory_usage();
        
        HealthStatus::healthy()
            .with_detail("uptime_seconds", uptime.as_secs())
            .with_detail("memory_usage_mb", memory_usage)
    }
    
    fn get_memory_usage(&self) -> f64 {
        // 简化的内存使用量获取
        0.0 // 实际实现中需要使用系统调用
    }
}

#[async_trait::async_trait]
impl framework_core::Service for MonitoringService {
    fn name(&self) -> &str {
        &self.name
    }
    
    async fn start(&self) -> framework_core::FrameworkResult<()> {
        tracing::info!("Starting monitoring service");
        
        // 启动指标收集器
        self.metrics_collector.start().await?;
        
        // 启动日志系统
        self.logger.start().await?;
        
        // 启动健康检查
        self.health_checker.start().await?;
        
        // 启动定期指标报告
        let metrics_collector = self.metrics_collector.clone();
        tokio::spawn(async move {
            let mut interval = interval(Duration::from_secs(60));
            
            loop {
                interval.tick().await;
                if let Err(e) = metrics_collector.report().await {
                    tracing::error!("Failed to report metrics: {}", e);
                }
            }
        });
        
        Ok(())
    }
    
    async fn stop(&self) -> framework_core::FrameworkResult<()> {
        tracing::info!("Stopping monitoring service");
        
        self.metrics_collector.stop().await?;
        self.logger.stop().await?;
        self.health_checker.stop().await?;
        
        Ok(())
    }
    
    async fn health_check(&self) -> framework_core::FrameworkResult<bool> {
        Ok(self.health_checker.check_all().await)
    }
}
}

8.4.4 示例用户服务

// examples/user-service/src/main.rs
use microservice_framework::{
    framework_core::{Framework, ServiceBuilder},
    http_server::HttpService,
    service_registry::RegistryService,
    config_manager::ConfigManager,
    monitoring::MonitoringService,
};
use std::sync::Arc;
use tracing::{info, error};
use tokio;

mod handlers;
mod models;
mod config;

use handlers::UserHandlers;
use models::User;
use config::UserServiceConfig;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::fmt::init();
    
    info!("Starting User Service");
    
    // 加载配置
    let config = UserServiceConfig::load().await?;
    info!("Configuration loaded: {:?}", config);
    
    // 创建框架
    let mut framework = Framework::new(config.framework.clone());
    
    // 创建配置管理器
    let config_manager = ConfigManager::new(config.config_provider);
    framework.register_service(Arc::new(config_manager));
    
    // 创建服务注册器
    let registry_service = RegistryService::new();
    framework.register_service(Arc::new(registry_service));
    
    // 创建监控服务
    let monitoring_service = MonitoringService::new();
    framework.register_service(Arc::new(monitoring_service));
    
    // 创建HTTP服务器
    let user_handlers = UserHandlers::new(config.database.clone());
    let routes = user_handlers.create_routes();
    let http_service = HttpService::new(config.http.port, routes);
    framework.register_service(Arc::new(http_service));
    
    // 启动框架
    framework.start().await?;
    
    // 等待优雅关闭
    tokio::signal::ctrl_c().await?;
    info!("Received shutdown signal");
    
    framework.stop().await?;
    info!("User Service stopped gracefully");
    
    Ok(())
}

#![allow(unused)]
fn main() {
// examples/user-service/src/handlers.rs
use microservice_framework::http_server::{Router, Request, Response, Result as HttpResult};
use crate::models::User;
use crate::config::DatabaseConfig;
use std::sync::Arc;
use tokio::sync::Mutex;
use serde::{Deserialize, Serialize};
use tracing::{info, warn, error};

/// 用户处理器
pub struct UserHandlers {
    database: Arc<Mutex<dyn UserRepository>>,
}

impl UserHandlers {
    pub fn new(database_config: DatabaseConfig) -> Self {
        let database = Arc::new(Mutex::new(InMemoryUserRepository::new()));
        Self { database }
    }
    
    pub fn create_routes(&self) -> Router {
        let mut router = Router::new();
        
        // GET /users - 获取所有用户
        router.get("/users", self.handle_get_users());
        
        // GET /users/:id - 获取特定用户
        router.get("/users/:id", self.handle_get_user());
        
        // POST /users - 创建新用户
        router.post("/users", self.handle_create_user());
        
        // PUT /users/:id - 更新用户
        router.put("/users/:id", self.handle_update_user());
        
        // DELETE /users/:id - 删除用户
        router.delete("/users/:id", self.handle_delete_user());
        
        router
    }
    
    async fn handle_get_users(&self) -> Arc<dyn RequestHandler> {
        Arc::new(GetUsersHandler {
            database: self.database.clone(),
        })
    }
    
    async fn handle_get_user(&self) -> Arc<dyn RequestHandler> {
        Arc::new(GetUserHandler {
            database: self.database.clone(),
        })
    }
    
    async fn handle_create_user(&self) -> Arc<dyn RequestHandler> {
        Arc::new(CreateUserHandler {
            database: self.database.clone(),
        })
    }
    
    async fn handle_update_user(&self) -> Arc<dyn RequestHandler> {
        Arc::new(UpdateUserHandler {
            database: self.database.clone(),
        })
    }
    
    async fn handle_delete_user(&self) -> Arc<dyn RequestHandler> {
        Arc::new(DeleteUserHandler {
            database: self.database.clone(),
        })
    }
}

/// 处理器特征
#[async_trait::async_trait]
pub trait RequestHandler: Send + Sync {
    async fn handle(&self, req: &Request) -> HttpResult<Response>;
}

/// GET /users处理器
pub struct GetUsersHandler {
    database: Arc<Mutex<dyn UserRepository>>,
}

#[async_trait::async_trait]
impl RequestHandler for GetUsersHandler {
    async fn handle(&self, _req: &Request) -> HttpResult<Response> {
        let database = self.database.lock().await;
        let users = database.get_all().await?;
        
        Ok(Response::json(users))
    }
}

/// GET /users/:id处理器
pub struct GetUserHandler {
    database: Arc<Mutex<dyn UserRepository>>,
}

#[async_trait::async_trait]
impl RequestHandler for GetUserHandler {
    async fn handle(&self, req: &Request) -> HttpResult<Response> {
        let id = req.param("id")?.parse::<uuid::Uuid>()?;
        
        let database = self.database.lock().await;
        match database.get_by_id(id).await? {
            Some(user) => Ok(Response::json(user)),
            None => Ok(Response::not_found("User not found")),
        }
    }
}

/// POST /users处理器
pub struct CreateUserHandler {
    database: Arc<Mutex<dyn UserRepository>>,
}

#[async_trait::async_trait]
impl RequestHandler for CreateUserHandler {
    async fn handle(&self, req: &Request) -> HttpResult<Response> {
        let create_user: CreateUserRequest = req.json()?;
        
        let user = User {
            id: uuid::Uuid::new_v4(),
            name: create_user.name,
            email: create_user.email,
            created_at: chrono::Utc::now(),
            updated_at: chrono::Utc::now(),
        };
        
        let database = self.database.lock().await;
        database.create(user.clone()).await?;
        
        info!("User created: {}", user.id);
        Ok(Response::created(user))
    }
}

/// 用户仓库特征
#[async_trait::async_trait]
pub trait UserRepository: Send + Sync {
    async fn get_all(&self) -> HttpResult<Vec<User>>;
    async fn get_by_id(&self, id: uuid::Uuid) -> HttpResult<Option<User>>;
    async fn create(&self, user: User) -> HttpResult<()>;
    async fn update(&self, id: uuid::Uuid, user: Partial<User>) -> HttpResult<()>;
    async fn delete(&self, id: uuid::Uuid) -> HttpResult<()>;
}

/// 内存用户仓库（示例实现）
pub struct InMemoryUserRepository {
    users: std::collections::HashMap<uuid::Uuid, User>,
}

impl InMemoryUserRepository {
    pub fn new() -> Self {
        Self {
            users: std::collections::HashMap::new(),
        }
    }
}

#[async_trait::async_trait]
impl UserRepository for InMemoryUserRepository {
    async fn get_all(&self) -> HttpResult<Vec<User>> {
        Ok(self.users.values().cloned().collect())
    }
    
    async fn get_by_id(&self, id: uuid::Uuid) -> HttpResult<Option<User>> {
        Ok(self.users.get(&id).cloned())
    }
    
    async fn create(&self, user: User) -> HttpResult<()> {
        self.users.insert(user.id, user);
        Ok(())
    }
    
    async fn update(&self, id: uuid::Uuid, partial_user: Partial<User>) -> HttpResult<()> {
        if let Some(existing_user) = self.users.get_mut(&id) {
            if let Some(name) = partial_user.name {
                existing_user.name = name;
            }
            if let Some(email) = partial_user.email {
                existing_user.email = email;
            }
            existing_user.updated_at = chrono::Utc::now();
            Ok(())
        } else {
            Err(microservice_framework::http_server::Error::NotFound)
        }
    }
    
    async fn delete(&self, id: uuid::Uuid) -> HttpResult<()> {
        self.users.remove(&id);
        Ok(())
    }
}

#[derive(Deserialize)]
struct CreateUserRequest {
    name: String,
    email: String,
}
}

8.4.5 部署与运维

#!/bin/bash
# scripts/deploy.sh - 部署脚本

set -e

# 配置
SERVICE_NAME=$1
BUILD_PROFILE=${2:-release}
DOCKER_IMAGE_PREFIX="microservice-framework"

if [ -z "$SERVICE_NAME" ]; then
    echo "Usage: $0 <service_name> [build_profile]"
    echo "Available services: user-service, order-service, gateway"
    exit 1
fi

# 检查服务名称
case $SERVICE_NAME in
    "user-service")
        DOCKERFILE="examples/user-service/Dockerfile"
        ;;
    "order-service")
        DOCKERFILE="examples/order-service/Dockerfile"
        ;;
    "gateway")
        DOCKERFILE="examples/gateway/Dockerfile"
        ;;
    *)
        echo "Unknown service: $SERVICE_NAME"
        exit 1
        ;;
esac

echo "Deploying $SERVICE_NAME with profile: $BUILD_PROFILE"

# 构建应用
echo "Building application..."
cargo build --$BUILD_PROFILE

# 构建Docker镜像
echo "Building Docker image..."
docker build -f $DOCKERFILE -t $DOCKER_IMAGE_PREFIX/$SERVICE_NAME:$BUILD_PROFILE .

# 推送到镜像仓库（如果配置了）
if [ ! -z "$DOCKER_REGISTRY" ]; then
    echo "Pushing to registry: $DOCKER_REGISTRY"
    docker tag $DOCKER_IMAGE_PREFIX/$SERVICE_NAME:$BUILD_PROFILE $DOCKER_REGISTRY/$DOCKER_IMAGE_PREFIX/$SERVICE_NAME:$BUILD_PROFILE
    docker push $DOCKER_REGISTRY/$DOCKER_IMAGE_PREFIX/$SERVICE_NAME:$BUILD_PROFILE
fi

# 部署到Kubernetes（如果配置了）
if [ -f "k8s/$SERVICE_NAME.yaml" ]; then
    echo "Deploying to Kubernetes..."
    kubectl apply -f k8s/$SERVICE_NAME.yaml
    kubectl rollout status deployment/$SERVICE_NAME
fi

echo "Deployment completed successfully!"

# 显示状态
echo "Deployment status:"
if [ -f "k8s/$SERVICE_NAME.yaml" ]; then
    kubectl get pods -l app=$SERVICE_NAME
fi

# examples/user-service/Dockerfile
FROM rust:1.70-slim as builder

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    pkg-config \
    libssl-dev \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*

# 设置工作目录
WORKDIR /app

# 复制Cargo文件
COPY Cargo.toml Cargo.lock ./
COPY framework-core ./framework-core
COPY http-server ./http-server
COPY service-registry ./service-registry
COPY config-manager ./config-manager
COPY monitoring ./monitoring
COPY examples/user-service ./examples/user-service

# 构建应用
RUN cargo build --release --bin user-service

# 运行时镜像
FROM debian:bullseye-slim

# 安装运行时依赖
RUN apt-get update && apt-get install -y \
    ca-certificates \
    libssl3 \
    && rm -rf /var/lib/apt/lists/*

# 创建应用用户
RUN useradd -r -s /bin/false microservice

# 设置工作目录
WORKDIR /app

# 复制二进制文件
COPY --from=builder /app/target/release/user-service /app/user-service

# 复制配置文件
COPY examples/user-service/config/ ./config/

# 设置权限
RUN chown -R microservice:microservice /app
USER microservice

# 暴露端口
EXPOSE 8080

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8080/health || exit 1

# 启动应用
CMD ["./user-service"]

8.5 性能优化与最佳实践

8.5.1 模块设计原则

单一职责原则

#![allow(unused)]
fn main() {
// good: 清晰的单一职责
pub mod http {
    pub mod server {
        pub struct HttpServer { /* ... */ }
        impl HttpServer { /* ... */ }
    }
    
    pub mod client {
        pub struct HttpClient { /* ... */ }
        impl HttpClient { /* ... */ }
    }
}

pub mod database {
    pub mod connection {
        pub struct DatabaseConnection { /* ... */ }
    }
    
    pub mod query {
        pub struct QueryBuilder { /* ... */ }
    }
}

// bad: 混合职责
pub mod network {
    // 混合了太多功能
    pub struct MixedService {
        http_server: HttpServer,
        database: DatabaseConnection,
        cache: Cache,
        // 太多不相关的功能
    }
}
}

依赖倒置

#![allow(unused)]
fn main() {
// 定义特征而非具体实现
pub mod repositories {
    use crate::models::User;
    
    #[async_trait::async_trait]
    pub trait UserRepository: Send + Sync {
        async fn find_by_id(&self, id: uuid::Uuid) -> Result<Option<User>, Error>;
        async fn save(&self, user: User) -> Result<(), Error>;
        async fn delete(&self, id: uuid::Uuid) -> Result<(), Error>;
    }
}

pub mod services {
    use super::repositories::{UserRepository, Error};
    use crate::models::User;
    
    pub struct UserService<R: UserRepository> {
        repository: R,
    }
    
    impl<R: UserRepository> UserService<R> {
        pub fn new(repository: R) -> Self {
            Self { repository }
        }
        
        pub async fn get_user(&self, id: uuid::Uuid) -> Result<Option<User>, Error> {
            self.repository.find_by_id(id).await
        }
        
        pub async fn create_user(&self, user: User) -> Result<User, Error> {
            // 业务逻辑
            let saved_user = self.repository.save(user.clone()).await?;
            Ok(user)
        }
    }
}
}

8.5.2 编译时优化

条件编译

#![allow(unused)]
fn main() {
#[cfg(feature = "metrics")]
pub mod metrics {
    use std::sync::atomic::{AtomicU64, Ordering};
    
    static REQUEST_COUNT: AtomicU64 = AtomicU64::new(0);
    
    pub fn record_request() {
        REQUEST_COUNT.fetch_add(1, Ordering::Relaxed);
    }
    
    pub fn get_request_count() -> u64 {
        REQUEST_COUNT.load(Ordering::Relaxed)
    }
}

#[cfg(not(feature = "metrics"))]
pub mod metrics {
    pub fn record_request() {
        // 空实现
    }
    
    pub fn get_request_count() -> u64 {
        0
    }
}

// 在主代码中使用
pub fn handle_request() {
    #[cfg(feature = "metrics")]
    metrics::record_request();
    
    // 处理请求的逻辑
}
}

泛型特化

#![allow(unused)]
fn main() {
pub trait Serializer<T> {
    fn serialize(&self, value: &T) -> Result<String, Error>;
    fn deserialize(&self, data: &str) -> Result<T, Error>;
}

pub struct JsonSerializer;

impl<T> Serializer<T> for JsonSerializer 
where
    T: serde::Serialize + serde::de::DeserializeOwned,
{
    fn serialize(&self, value: &T) -> Result<String, Error> {
        serde_json::to_string(value).map_err(Error::Serialization)
    }
    
    fn deserialize(&self, data: &str) -> Result<T, Error> {
        serde_json::from_str(data).map_err(Error::Deserialization)
    }
}

pub struct MsgPackSerializer;

impl<T> Serializer<T> for MsgPackSerializer 
where
    T: serde::Serialize + serde::de::DeserializeOwned,
{
    fn serialize(&self, value: &T) -> Result<String, Error> {
        let data = rmp_serde::to_vec(value).map_err(Error::Serialization)?;
        Ok(base64::encode(&data))
    }
    
    fn deserialize(&self, data: &str) -> Result<T, Error> {
        let bytes = base64::decode(data).map_err(Error::Encoding)?;
        rmp_serde::from_slice(&bytes).map_err(Error::Deserialization)
    }
}
}

8.5.3 运行时性能

零拷贝数据结构

#![allow(unused)]
fn main() {
use std::ops::{Deref, DerefMut};

pub struct Bytes {
    data: Vec<u8>,
}

impl Bytes {
    pub fn from_vec(data: Vec<u8>) -> Self {
        Self { data }
    }
    
    pub fn as_str(&self) -> &str {
        std::str::from_utf8(&self.data).unwrap()
    }
    
    pub fn as_slice(&self) -> &[u8] {
        &self.data
    }
}

impl Deref for Bytes {
    type Target = [u8];
    
    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

// 避免不必要的数据复制
pub struct HttpRequest {
    pub method: String,
    pub path: String,
    pub headers: HashMap<String, String>,
    pub body: Option<Bytes>,  // 使用Bytes而不是String
}
}

内存池

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::collections::VecDeque;

pub struct ObjectPool<T: Default> {
    pool: Arc<Mutex<VecDeque<T>>>,
}

impl<T: Default> ObjectPool<T> {
    pub fn new() -> Self {
        Self {
            pool: Arc::new(Mutex::new(VecDeque::new())),
        }
    }
    
    pub fn get(&self) -> PooledObject<T> {
        let mut pool = self.pool.lock().unwrap();
        
        if let Some(obj) = pool.pop_front() {
            PooledObject::new(obj, self.pool.clone())
        } else {
            PooledObject::new(T::default(), self.pool.clone())
        }
    }
    
    pub fn return_object(&self, mut obj: T) {
        let mut pool = self.pool.lock().unwrap();
        pool.push_back(std::mem::take(&mut obj));
    }
}

pub struct PooledObject<T> {
    object: Option<T>,
    pool: Arc<Mutex<VecDeque<T>>>,
}

impl<T> PooledObject<T> {
    fn new(object: T, pool: Arc<Mutex<VecDeque<T>>>) -> Self {
        Self {
            object: Some(object),
            pool,
        }
    }
}

impl<T> Deref for PooledObject<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        self.object.as_ref().unwrap()
    }
}

impl<T> Drop for PooledObject<T> {
    fn drop(&mut self) {
        if let Some(object) = self.object.take() {
            let mut pool = self.pool.lock().unwrap();
            pool.push_back(object);
        }
    }
}
}

8.6 测试策略

8.6.1 单元测试

#![allow(unused)]
fn main() {
// src/utils/math.rs
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
        assert_eq!(add(-1, 1), 0);
        assert_eq!(add(0, 0), 0);
    }
    
    #[test]
    fn test_multiply() {
        assert_eq!(multiply(3, 4), 12);
        assert_eq!(multiply(0, 100), 0);
        assert_eq!(multiply(-2, 3), -6);
    }
    
    #[test]
    fn test_power() {
        assert!((power(2.0, 3.0) - 8.0).abs() < 1e-10);
        assert!((power(5.0, 2.0) - 25.0).abs() < 1e-10);
        assert!((power(10.0, 0.0) - 1.0).abs() < 1e-10);
    }
    
    #[test]
    #[should_panic]
    fn test_division_by_zero() {
        divide(10.0, 0.0);
    }
}
}

8.6.2 集成测试

#![allow(unused)]
fn main() {
// tests/integration/api_test.rs
use microservice_framework::http_server::TestClient;
use serde_json;

#[tokio::test]
async fn test_user_crud_operations() {
    let app = user_service::create_test_app().await;
    let client = TestClient::new(app);
    
    // 创建用户
    let create_response = client
        .post("/users")
        .json(&serde_json::json!({
            "name": "John Doe",
            "email": "john@example.com"
        }))
        .send()
        .await;
    
    assert!(create_response.status().is_success());
    let created_user: User = create_response.json().await;
    assert_eq!(created_user.name, "John Doe");
    assert_eq!(created_user.email, "john@example.com");
    
    // 获取用户
    let get_response = client
        .get(&format!("/users/{}", created_user.id))
        .send()
        .await;
    
    assert!(get_response.status().is_success());
    let retrieved_user: User = get_response.json().await;
    assert_eq!(created_user.id, retrieved_user.id);
    
    // 更新用户
    let update_response = client
        .put(&format!("/users/{}", created_user.id))
        .json(&serde_json::json!({
            "name": "John Smith"
        }))
        .send()
        .await;
    
    assert!(update_response.status().is_success());
    
    // 验证更新
    let get_updated_response = client
        .get(&format!("/users/{}", created_user.id))
        .send()
        .await;
    
    assert!(get_updated_response.status().is_success());
    let updated_user: User = get_updated_response.json().await;
    assert_eq!(updated_user.name, "John Smith");
    
    // 删除用户
    let delete_response = client
        .delete(&format!("/users/{}", created_user.id))
        .send()
        .await;
    
    assert!(delete_response.status().is_success());
    
    // 验证删除
    let get_deleted_response = client
        .get(&format!("/users/{}", created_user.id))
        .send()
        .await;
    
    assert!(get_deleted_response.status().is_not_found());
}
}

8.6.3 性能测试

#![allow(unused)]
fn main() {
// benches/performance.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use microservice_framework::http_server::HttpServer;

fn bench_http_request(c: &mut Criterion) {
    c.bench_function("http_request", |b| {
        b.iter(|| {
            // 创建测试请求
            let request = HttpRequest::new("GET", "/users", "{}", HashMap::new());
            // 模拟处理
            black_box(process_request(request));
        });
    });
}

fn bench_database_operations(c: &mut Criterion) {
    c.bench_function("database_insert", |b| {
        b.iter(|| {
            let user = User::new("test_user", "test@example.com");
            black_box(insert_user(&user));
        });
    });
    
    c.bench_function("database_query", |b| {
        b.iter(|| {
            let user_id = Uuid::new_v4();
            black_box(query_user_by_id(&user_id));
        });
    });
}

fn process_request(request: HttpRequest) -> HttpResponse {
    // 简化实现
    HttpResponse::ok("OK")
}

fn insert_user(user: &User) -> Result<(), Error> {
    // 简化实现
    Ok(())
}

fn query_user_by_id(id: &Uuid) -> Result<Option<User>, Error> {
    // 简化实现
    Ok(None)
}

criterion_group!(benches, bench_http_request, bench_database_operations);
criterion_main!(benches);
}

8.7 总结与进阶

8.7.1 本章要点回顾

模块系统基础：
- 理解模块的创建、导入和使用
- 掌握可见性规则和路径引用
- 学会组织大型项目的文件结构
包与Crate管理：
- 区分包（Package）和Crate的概念
- 掌握库Crate和二进制Crate的区别
- 学会配置Cargo.toml和依赖管理
Cargo工作空间：
- 理解工作空间的概念和优势
- 学会共享依赖和配置
- 掌握大型项目的组织方式
企业级框架开发：
- 构建了完整的微服务开发框架
- 实现了服务注册、配置管理、监控等核心功能
- 学会了模块化架构设计原则

8.7.2 实际应用建议

项目结构规划：
- 为大型项目设计清晰的模块边界
- 使用工作空间管理多个相关包
- 建立统一的代码风格和约定
依赖管理：
- 定期更新依赖项
- 使用特性标志控制编译选项
- 避免依赖冲突和重复
性能优化：
- 使用条件编译减少二进制大小
- 实现内存池提高性能
- 进行性能基准测试
测试策略：
- 建立完整的测试套件
- 进行集成测试验证组件协作
- 定期执行性能测试

8.7.3 扩展学习方向

高级模块化：
- 插件系统设计
- 动态模块加载
- 模块间通信模式
构建系统：
- 自定义构建脚本
- 代码生成工具
- 编译时优化技术
部署架构：
- 容器化部署策略
- 服务网格架构
- 云原生开发模式

通过本章的学习，您已经掌握了Rust模块系统的核心概念和最佳实践，能够构建大型、可维护的企业级应用程序。下一章将介绍并发编程，帮助您实现高并发的网络应用。

第9章：并发编程

学习目标

掌握Rust的安全并发机制
理解线程和异步编程的区别
学会使用消息传递和共享内存进行并发通信
掌握异步编程的基础概念和实践
构建高并发的Web服务器

9.1 并发基础概念

9.1.1 并发与并行的区别

并发（Concurrency）：多个任务在重叠的时间段内执行，但不一定是同时执行 并行（Parallelism）：多个任务真正同时执行

use std::thread;
use std::time::Duration;

fn main() {
    println!("=== 并发示例：切换执行 ===");
    
    // 模拟三个独立的任务
    for i in 1..=3 {
        thread::spawn(move || {
            for j in 1..=5 {
                println!("任务 {}: 步骤 {}", i, j);
                thread::sleep(Duration::from_millis(200));
            }
        });
    }
    
    thread::sleep(Duration::from_millis(1000));
    println!("主线程完成");
}

use rayon::prelude::*;

fn main() {
    println!("=== 并行示例：真正同时执行 ===");
    
    let data: Vec<i32> = (1..=1000).collect();
    
    // 使用Rayon进行并行处理
    let result: Vec<i32> = data
        .par_iter()
        .map(|&x| {
            // 模拟CPU密集型计算
            (0..1000).sum::<i32>() * x
        })
        .collect();
    
    println!("并行处理完成，结果数量: {}", result.len());
}

9.1.2 Rust的并发哲学

Rust的并发安全性基于三个核心原则：

所有权系统：防止数据竞争
借用检查器：确保内存安全
类型系统：通过Send和Sync标记保证线程安全

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;

// 不安全的示例（编译失败）
fn unsafe_concurrent_access() {
    let mut counter = 0;
    
    // 这会导致编译错误，因为多个线程试图访问可变数据
    // thread::spawn(move || {
    //     counter += 1;  // 编译错误
    // });
    //
    // thread::spawn(move || {
    //     counter += 1;  // 编译错误
    // });
}

// 安全的示例
fn safe_concurrent_access() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最终计数: {}", *counter.lock().unwrap());
}
}

9.2 线程编程

9.2.1 基础线程操作

#![allow(unused)]
fn main() {
use std::thread;
use std::time::Duration;

fn basic_thread_creation() {
    // 创建线程的基本方法
    let handle = thread::spawn(|| {
        for i in 1..=5 {
            println!("新线程: {}", i);
            thread::sleep(Duration::from_millis(100));
        }
    });
    
    // 主线程继续执行
    for i in 1..=3 {
        println!("主线程: {}", i);
        thread::sleep(Duration::from_millis(150));
    }
    
    // 等待子线程完成
    handle.join().unwrap();
    println!("所有线程完成");
}
}

线程参数传递

#![allow(unused)]
fn main() {
fn thread_with_parameters() {
    let data = vec![1, 2, 3, 4, 5];
    
    // 使用move关键字将所有权转移给线程
    let handle = thread::spawn(move || {
        let sum: i32 = data.iter().sum();
        println!("子线程计算的和: {}", sum);
    });
    
    // 在主线程中无法再使用data
    // println!("{:?}", data);  // 编译错误
    
    handle.join().unwrap();
}
}

线程返回值

#![allow(unused)]
fn main() {
use std::sync::mpsc;

fn thread_return_value() {
    // 创建通道
    let (tx, rx) = mpsc::channel();
    
    let handle = thread::spawn(move || {
        let result = calculate_fibonacci(10);
        tx.send(result).unwrap();
    });
    
    // 接收线程的返回值
    let result = rx.recv().unwrap();
    println!("斐波那契数列第10项: {}", result);
    
    handle.join().unwrap();
}

fn calculate_fibonacci(n: u32) -> u32 {
    if n <= 1 {
        n
    } else {
        calculate_fibonacci(n - 1) + calculate_fibonacci(n - 2)
    }
}
}

9.2.2 线程池

简单的线程池实现

#![allow(unused)]
fn main() {
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
use std::time::Duration;

pub struct ThreadPool {
    workers: Vec<Worker>,
    sender: mpsc::Sender<Job>,
}

type Job = Box<dyn FnOnce() + Send + 'static>;

struct Worker {
    _id: usize,
    thread: thread::JoinHandle<()>,
}

impl ThreadPool {
    pub fn new(size: usize) -> ThreadPool {
        assert!(size > 0);
        
        let (sender, receiver) = mpsc::channel();
        let receiver = Arc::new(Mutex::new(receiver));
        let mut workers = Vec::with_capacity(size);
        
        for id in 0..size {
            workers.push(Worker::new(id, Arc::clone(&receiver)));
        }
        
        ThreadPool { workers, sender }
    }
    
    pub fn execute<F>(&self, f: F)
    where
        F: FnOnce() + Send + 'static,
    {
        let job = Box::new(f);
        self.sender.send(job).unwrap();
    }
}

impl Worker {
    fn new(id: usize, receiver: Arc<Mutex<mpsc::Receiver<Job>>>) -> Worker {
        let thread = thread::spawn(move || loop {
            let job = receiver.lock().unwrap().recv();
            
            match job {
                Ok(job) => {
                    println!("Worker {} 执行任务", id);
                    job();
                }
                Err(_) => {
                    println!("Worker {} 断开连接，退出", id);
                    break;
                }
            }
        });
        
        Worker { _id: id, thread }
    }
}

impl Drop for ThreadPool {
    fn drop(&mut self) {
        // 发送停止信号
        for _ in &self.workers {
            if let Err(e) = self.sender.send(Box::new(|| {})) {
                eprintln!("发送停止信号失败: {:?}", e);
            }
        }
        
        // 等待所有线程完成
        for worker in &mut self.workers {
            if let Some(handle) = worker.thread.take() {
                handle.join().unwrap();
            }
        }
    }
}
}

使用线程池

#![allow(unused)]
fn main() {
fn thread_pool_example() {
    let pool = ThreadPool::new(4);
    
    for i in 1..=10 {
        pool.execute(move || {
            println!("处理任务 {} (线程ID: {:?})", 
                    i, 
                    std::thread::current().id());
            thread::sleep(Duration::from_millis(1000));
        });
    }
    
    println!("所有任务已提交，等待完成...");
    // ThreadPool在作用域结束时自动清理
}
}

9.3 消息传递

9.3.1 通道（Channel）

Rust的标准库提供了通道（mpsc - multiple producer, single consumer）进行消息传递。

基础通道使用

#![allow(unused)]
fn main() {
use std::sync::mpsc;
use std::thread;
use std::time::Duration;

fn basic_channel() {
    let (tx, rx) = mpsc::channel();
    
    // 创建生产者线程
    let handle = thread::spawn(move || {
        for i in 1..=5 {
            tx.send(format!("消息 {}", i)).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });
    
    // 接收消息
    for received in rx.iter() {
        println!("收到: {}", received);
    }
    
    handle.join().unwrap();
}
}

多生产者通道

#![allow(unused)]
fn main() {
fn multiple_producers() {
    let (tx, rx) = mpsc::channel();
    let tx1 = mpsc::Sender::clone(&tx);
    let tx2 = mpsc::Sender::clone(&tx);
    
    // 启动三个生产者
    thread::spawn(move || {
        for i in 1..=3 {
            tx1.send(format!("生产者1: 消息{}", i)).unwrap();
            thread::sleep(Duration::from_millis(100));
        }
    });
    
    thread::spawn(move || {
        for i in 1..=3 {
            tx2.send(format!("生产者2: 消息{}", i)).unwrap();
            thread::sleep(Duration::from_millis(150));
        }
    });
    
    thread::spawn(move || {
        for i in 1..=3 {
            tx.send(format!("生产者3: 消息{}", i)).unwrap();
            thread::sleep(Duration::from_millis(200));
        }
    });
    
    // 接收所有消息
    for received in rx.iter().take(9) {
        println!("消费者收到: {}", received);
    }
}
}

同步通道

#![allow(unused)]
fn main() {
fn synchronous_channel() {
    // 创建同步通道，容量为0，需要接收者准备好
    let (tx, rx) = mpsc::sync_channel(0);
    
    let handle = thread::spawn(move || {
        println!("生产者: 准备发送消息");
        tx.send("同步消息").unwrap();
        println!("生产者: 消息已发送");
    });
    
    println!("消费者: 准备接收消息");
    let message = rx.recv().unwrap();
    println!("消费者: 收到消息: {}", message);
    
    handle.join().unwrap();
}
}

9.3.2 生产者-消费者模式

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

struct SharedQueue<T> {
    queue: Arc<Mutex<Vec<T>>>,
    capacity: usize,
}

impl<T> SharedQueue<T> {
    fn new(capacity: usize) -> Self {
        Self {
            queue: Arc::new(Mutex::new(Vec::with_capacity(capacity))),
            capacity,
        }
    }
    
    fn push(&self, item: T) -> Result<(), String> {
        let mut queue = self.queue.lock().unwrap();
        if queue.len() >= self.capacity {
            return Err("队列已满".to_string());
        }
        queue.push(item);
        Ok(())
    }
    
    fn pop(&self) -> Option<T> {
        let mut queue = self.queue.lock().unwrap();
        queue.pop()
    }
    
    fn len(&self) -> usize {
        let queue = self.queue.lock().unwrap();
        queue.len()
    }
}

fn producer_consumer_example() {
    let shared_queue = SharedQueue::new(10);
    let shared_queue_clone = shared_queue.clone();
    
    // 生产者
    let producer = thread::spawn(move || {
        for i in 1..=20 {
            while let Err(_) = shared_queue_clone.push(i) {
                thread::sleep(Duration::from_millis(10));
            }
            println!("生产者: 添加了 {}", i);
            thread::sleep(Duration::from_millis(50));
        }
    });
    
    // 消费者
    let consumer = thread::spawn(move || {
        loop {
            match shared_queue.pop() {
                Some(item) => {
                    println!("消费者: 处理了 {}", item);
                    thread::sleep(Duration::from_millis(100));
                }
                None => {
                    thread::sleep(Duration::from_millis(10));
                }
            }
        }
    });
    
    producer.join().unwrap();
    
    // 等待一段时间后消费结束
    thread::sleep(Duration::from_secs(3));
    println!("程序结束");
}
}

9.3.3 复杂消息传递

任务调度器

#![allow(unused)]
fn main() {
use std::sync::mpsc;
use std::thread;
use std::time::{Duration, Instant};

#[derive(Debug, Clone)]
enum Task {
    Immediate(String),
    Delayed(String, Duration),
}

struct TaskScheduler {
    sender: mpsc::Sender<Task>,
}

impl TaskScheduler {
    fn new() -> Self {
        let (sender, receiver) = mpsc::channel();
        
        // 启动调度器线程
        thread::spawn(move || {
            let mut scheduled_tasks: Vec<(Instant, Task)> = Vec::new();
            
            for task in receiver.iter() {
                match task {
                    Task::Immediate(task) => {
                        println!("立即执行任务: {}", task);
                    }
                    Task::Delayed(task, delay) => {
                        let execution_time = Instant::now() + delay;
                        scheduled_tasks.push((execution_time, Task::Immediate(task)));
                    }
                }
                
                // 检查是否有任务到期
                let now = Instant::now();
                scheduled_tasks.retain(|(time, task)| {
                    if *time <= now {
                        if let Task::Immediate(task) = task {
                            println!("执行延迟任务: {}", task);
                        }
                        false
                    } else {
                        true
                    }
                });
            }
        });
        
        Self { sender }
    }
    
    fn schedule_immediate(&self, task: String) {
        self.sender.send(Task::Immediate(task)).unwrap();
    }
    
    fn schedule_delayed(&self, task: String, delay: Duration) {
        self.sender.send(Task::Delayed(task, delay)).unwrap();
    }
}

fn task_scheduler_example() {
    let scheduler = TaskScheduler::new();
    
    scheduler.schedule_immediate("立即任务1".to_string());
    scheduler.schedule_immediate("立即任务2".to_string());
    scheduler.schedule_delayed("延迟任务".to_string(), Duration::from_secs(2));
    
    thread::sleep(Duration::from_secs(3));
}
}

9.4 共享内存

9.4.1 Arc和Mutex

Arc（原子引用计数）

#![allow(unused)]
fn main() {
use std::sync::Arc;
use std::thread;

fn arc_example() {
    let data = Arc::new(vec![1, 2, 3, 4, 5]);
    
    let mut handles = vec![];
    for i in 0..5 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let len = data.len();
            println!("线程 {}: 数组长度 = {}", i, len);
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
}
}

Mutex（互斥锁）

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;

fn mutex_example() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最终计数: {}", *counter.lock().unwrap());
}
}

9.4.2 读写锁（RwLock）

#![allow(unused)]
fn main() {
use std::sync::{Arc, RwLock};
use std::thread;

fn rwlock_example() {
    let data = Arc::new(RwLock::new(vec![1, 2, 3, 4, 5]));
    let mut handles = vec![];
    
    // 多个读者
    for i in 0..5 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let data = data.read().unwrap();
            println!("读者 {}: 数据 = {:?}", i, data);
        });
        handles.push(handle);
    }
    
    // 多个写者
    for i in 0..3 {
        let data = Arc::clone(&data);
        let handle = thread::spawn(move || {
            let mut data = data.write().unwrap();
            data.push(i);
            println!("写者 {}: 添加了 {}", i, i);
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    let data = data.read().unwrap();
    println!("最终数据: {:?}", *data);
}
}

9.4.3 条件变量（Condvar）

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex, Condvar};
use std::thread;
use std::time::Duration;

struct SharedState {
    ready: bool,
    data: Option<String>,
}

fn condition_variable_example() {
    let state = Arc::new((Mutex::new(SharedState { ready: false, data: None }), Condvar::new()));
    let state_clone = Arc::clone(&state);
    
    // 生产者线程
    let producer = thread::spawn(move || {
        thread::sleep(Duration::from_secs(1));
        let (lock, cvar) = &*state_clone;
        let mut shared = lock.lock().unwrap();
        shared.ready = true;
        shared.data = Some("数据已准备".to_string());
        cvar.notify_all();
        println!("生产者: 数据已准备");
    });
    
    // 消费者线程
    let mut consumers = vec![];
    for i in 0..3 {
        let state = Arc::clone(&state);
        let handle = thread::spawn(move || {
            let (lock, cvar) = &*state;
            let mut shared = lock.lock().unwrap();
            
            while !shared.ready {
                shared = cvar.wait(shared).unwrap();
            }
            
            if let Some(ref data) = shared.data {
                println!("消费者 {}: 收到数据: {}", i, data);
            }
        });
        consumers.push(handle);
    }
    
    producer.join().unwrap();
    for handle in consumers {
        handle.join().unwrap();
    }
}
}

9.4.4 无锁数据结构

#![allow(unused)]
fn main() {
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;

struct LockFreeCounter {
    count: AtomicU64,
}

impl LockFreeCounter {
    fn new() -> Self {
        Self {
            count: AtomicU64::new(0),
        }
    }
    
    fn increment(&self) {
        self.count.fetch_add(1, Ordering::SeqCst);
    }
    
    fn get(&self) -> u64 {
        self.count.load(Ordering::SeqCst)
    }
}

fn lock_free_counter_example() {
    let counter = Arc::new(LockFreeCounter::new());
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                counter.increment();
            }
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最终计数: {}", counter.get());
}
}

9.5 异步编程

9.5.1 async/await基础

异步函数定义

#![allow(unused)]
fn main() {
use tokio::time::{sleep, Duration};

async fn async_function() -> String {
    println!("异步函数开始执行");
    sleep(Duration::from_secs(1)).await;
    println!("异步函数等待完成");
    "异步结果".to_string()
}

fn async_main() {
    // 异步函数需要运行时执行
    let rt = tokio::runtime::Runtime::new().unwrap();
    let result = rt.block_on(async_function());
    println!("结果: {}", result);
}
}

多个异步任务

#![allow(unused)]
fn main() {
async fn multiple_async_tasks() {
    let task1 = async {
        sleep(Duration::from_secs(1)).await;
        "任务1完成"
    };
    
    let task2 = async {
        sleep(Duration::from_secs(2)).await;
        "任务2完成"
    };
    
    let task3 = async {
        sleep(Duration::from_millis(500)).await;
        "任务3完成"
    };
    
    // 并行执行所有任务
    let (result1, result2, result3) = tokio::join!(task1, task2, task3);
    
    println!("{} - {} - {}", result1, result2, result3);
}
}

9.5.2 Tokio异步运行时

基础Tokio使用

use tokio::time::{sleep, Duration, Instant};

#[tokio::main]
async fn main() {
    println!("=== Tokio 异步示例 ===");
    
    let start = Instant::now();
    
    // 启动多个异步任务
    let task1 = tokio::spawn(async {
        sleep(Duration::from_secs(2)).await;
        "任务1完成"
    });
    
    let task2 = tokio::spawn(async {
        sleep(Duration::from_secs(1)).await;
        "任务2完成"
    });
    
    let task3 = tokio::spawn(async {
        sleep(Duration::from_millis(500)).await;
        "任务3完成"
    });
    
    // 等待所有任务完成
    let (result1, result2, result3) = tokio::join!(task1, task2, task3);
    
    println!("执行时间: {:?}", start.elapsed());
    println!("结果: {} - {} - {}", 
             result1.unwrap(), 
             result2.unwrap(), 
             result3.unwrap());
}

异步通道

#![allow(unused)]
fn main() {
use tokio::sync::mpsc;
use tokio::time::{sleep, Duration};

#[tokio::main]
async fn async_channel_example() {
    let (tx, mut rx) = mpsc::channel(100);
    
    // 启动发送者
    let tx_clone = tx.clone();
    let sender = tokio::spawn(async move {
        for i in 1..=10 {
            let message = format!("消息 {}", i);
            tx_clone.send(message).await.unwrap();
            sleep(Duration::from_millis(100)).await;
        }
    });
    
    // 启动接收者
    let receiver = tokio::spawn(async move {
        while let Some(message) = rx.recv().await {
            println!("收到: {}", message);
        }
    });
    
    // 等待完成
    let _ = tokio::join!(sender, receiver);
}
}

9.5.3 异步流（Stream）

#![allow(unused)]
fn main() {
use tokio::sync::mpsc;
use tokio::time::{interval, Duration};

async fn stream_example() {
    // 创建定时器流
    let mut interval = interval(Duration::from_millis(500));
    let mut counter = 0;
    
    loop {
        interval.tick().await;
        counter += 1;
        println!("流事件: {}", counter);
        
        if counter >= 5 {
            break;
        }
    }
    
    println!("流处理完成");
}

async fn broadcast_stream_example() {
    use tokio::sync::broadcast;
    
    let (tx, _) = broadcast::channel(16);
    let mut rx1 = tx.subscribe();
    let mut rx2 = tx.subscribe();
    
    // 启动接收者
    let receiver1 = tokio::spawn(async move {
        while let Ok(message) = rx1.recv().await {
            println!("接收者1: {}", message);
        }
    });
    
    let receiver2 = tokio::spawn(async move {
        while let Ok(message) = rx2.recv().await {
            println!("接收者2: {}", message);
        }
    });
    
    // 发送消息
    for i in 1..=5 {
        tx.send(format!("广播消息 {}", i)).unwrap();
        tokio::time::sleep(Duration::from_millis(200)).await;
    }
    
    let _ = tokio::join!(receiver1, receiver2);
}
}

9.5.4 Select语句

#![allow(unused)]
fn main() {
use tokio::time::{sleep, Duration, Instant};

async fn select_example() {
    let start = Instant::now();
    
    // 模拟多个竞争的操作
    let operation1 = async {
        sleep(Duration::from_millis(800)).await;
        "操作1完成 (800ms)"
    };
    
    let operation2 = async {
        sleep(Duration::from_millis(300)).await;
        "操作2完成 (300ms)"
    };
    
    // 使用select选择最快完成的操作
    tokio::select! {
        result1 = operation1 => {
            println!("操作1: {}", result1);
        }
        result2 = operation2 => {
            println!("操作2: {}", result2);
        }
    }
    
    println!("总用时: {:?}", start.elapsed());
}

#[tokio::main]
async fn select_with_channel() {
    let (tx1, mut rx1) = mpsc::channel(32);
    let (tx2, mut rx2) = mpsc::channel(32);
    
    // 发送消息
    tokio::spawn(async move {
        tx1.send("通道1消息").await.unwrap();
    });
    
    tokio::spawn(async move {
        sleep(Duration::from_millis(100)).await;
        tx2.send("通道2消息").await.unwrap();
    });
    
    // 从最快响应的通道接收
    tokio::select! {
        msg1 = rx1.recv() => {
            println!("从通道1收到: {:?}", msg1);
        }
        msg2 = rx2.recv() => {
            println!("从通道2收到: {:?}", msg2);
        }
    }
}
}

9.6 实战项目：高并发Web服务器

9.6.1 服务器架构设计

让我们构建一个完整的高并发Web服务器，展示所有并发技术的应用。

// src/main.rs
use std::sync::Arc;
use tokio::net::TcpListener;
use crate::server::HttpServer;
use crate::thread_pool::ThreadPool;
use crate::config::ServerConfig;

mod server;
mod config;
mod handler;
mod thread_pool;
mod http;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 加载配置
    let config = ServerConfig::load()?;
    
    // 启动服务器
    let server = HttpServer::new(config.port, config.max_connections);
    println!("启动HTTP服务器，监听端口 {}", config.port);
    
    server.listen().await?;
    Ok(())
}

9.6.2 HTTP服务器实现

#![allow(unused)]
fn main() {
// src/server.rs
use std::sync::Arc;
use tokio::net::{TcpListener, TcpStream};
use crate::thread_pool::ThreadPool;
use crate::http::HttpRequest;
use crate::handler::RequestHandler;

pub struct HttpServer {
    port: u16,
    max_connections: usize,
    thread_pool: ThreadPool,
}

impl HttpServer {
    pub fn new(port: u16, max_connections: usize) -> Self {
        Self {
            port,
            max_connections,
            thread_pool: ThreadPool::new(4),
        }
    }
    
    pub async fn listen(self) -> Result<(), Box<dyn std::error::Error>> {
        let listener = TcpListener::bind(("127.0.0.1", self.port)).await?;
        println!("服务器监听在 127.0.0.1:{}", self.port);
        
        // 接受连接
        loop {
            match listener.accept().await {
                Ok((stream, _)) => {
                    let handler = RequestHandler::new();
                    self.handle_connection(stream, handler);
                }
                Err(e) => {
                    eprintln!("接受连接失败: {:?}", e);
                }
            }
        }
    }
    
    fn handle_connection(&self, stream: TcpStream, handler: RequestHandler) {
        self.thread_pool.execute(move || {
            // 使用阻塞式I/O处理HTTP请求
            match handler.handle(stream) {
                Ok(_) => println!("请求处理完成"),
                Err(e) => eprintln!("请求处理失败: {:?}", e),
            }
        });
    }
}
}

9.6.3 HTTP解析器

#![allow(unused)]
fn main() {
// src/http.rs
use std::io::{BufRead, BufReader, Write};
use std::net::TcpStream;
use std::collections::HashMap;
use std::time::{SystemTime, UNIX_EPOCH};

#[derive(Debug, Clone)]
pub struct HttpRequest {
    pub method: String,
    pub path: String,
    pub version: String,
    pub headers: HashMap<String, String>,
    pub body: Option<String>,
}

impl HttpRequest {
    pub fn parse(stream: &mut TcpStream) -> Result<Self, std::io::Error> {
        let mut reader = BufReader::new(stream);
        let mut line = String::new();
        
        // 解析请求行
        reader.read_line(&mut line)?;
        let parts: Vec<&str> = line.trim().split_whitespace().collect();
        
        if parts.len() != 3 {
            return Err(std::io::Error::new(
                std::io::ErrorKind::InvalidData,
                "无效的HTTP请求行"
            ));
        }
        
        let method = parts[0].to_string();
        let path = parts[1].to_string();
        let version = parts[2].to_string();
        
        // 解析请求头
        let mut headers = HashMap::new();
        let mut content_length = 0;
        
        loop {
            line.clear();
            reader.read_line(&mut line)?;
            let line = line.trim();
            
            if line.is_empty() {
                break;
            }
            
            if let Some(colon_pos) = line.find(':') {
                let key = line[..colon_pos].trim().to_string();
                let value = line[colon_pos + 1..].trim().to_string();
                
                if key.to_lowercase() == "content-length" {
                    content_length = value.parse().unwrap_or(0);
                }
                
                headers.insert(key, value);
            }
        }
        
        // 读取请求体
        let mut body = None;
        if content_length > 0 {
            let mut body_bytes = vec![0u8; content_length];
            reader.read_exact(&mut body_bytes)?;
            body = Some(String::from_utf8_lossy(&body_bytes).to_string());
        }
        
        Ok(HttpRequest {
            method,
            path,
            version,
            headers,
            body,
        })
    }
}

pub struct HttpResponse {
    pub status_code: u16,
    pub status_text: String,
    pub headers: HashMap<String, String>,
    pub body: String,
}

impl HttpResponse {
    pub fn new(status_code: u16, body: String) -> Self {
        let status_text = match status_code {
            200 => "OK",
            404 => "Not Found",
            500 => "Internal Server Error",
            _ => "Unknown",
        };
        
        let mut headers = HashMap::new();
        headers.insert("Content-Type".to_string(), "text/html".to_string());
        headers.insert("Content-Length".to_string(), body.len().to_string());
        headers.insert("Server".to_string(), "Rust-HTTP-Server/1.0".to_string());
        headers.insert("Date".to_string(), Self::current_date());
        
        Self {
            status_code,
            status_text: status_text.to_string(),
            headers,
            body,
        }
    }
    
    pub fn not_found() -> Self {
        Self::new(404, "404 Not Found".to_string())
    }
    
    pub fn internal_error() -> Self {
        Self::new(500, "500 Internal Server Error".to_string())
    }
    
    pub fn ok() -> Self {
        Self::new(200, "OK".to_string())
    }
    
    fn current_date() -> String {
        let now = SystemTime::now();
        let datetime = now.duration_since(UNIX_EPOCH).unwrap();
        format!("{}", datetime.as_secs())
    }
    
    pub fn to_bytes(&self) -> Vec<u8> {
        let mut response = String::new();
        response.push_str(&format!("HTTP/1.1 {} {}\r\n", self.status_code, self.status_text));
        
        for (key, value) in &self.headers {
            response.push_str(&format!("{}: {}\r\n", key, value));
        }
        response.push_str("\r\n");
        response.push_str(&self.body);
        
        response.into_bytes()
    }
}
}

9.6.4 请求处理器

#![allow(unused)]
fn main() {
// src/handler.rs
use std::net::TcpStream;
use crate::http::{HttpRequest, HttpResponse};
use std::sync::{Arc, atomic::{AtomicU64, Ordering}};

pub struct RequestHandler {
    request_counter: Arc<AtomicU64>,
}

impl RequestHandler {
    pub fn new() -> Self {
        Self {
            request_counter: Arc::new(AtomicU64::new(0)),
        }
    }
    
    pub fn handle(&self, mut stream: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
        // 增加请求计数
        let count = self.request_counter.fetch_add(1, Ordering::SeqCst);
        
        // 解析请求
        let request = match HttpRequest::parse(&mut stream) {
            Ok(req) => req,
            Err(e) => {
                eprintln!("解析请求失败: {:?}", e);
                let response = HttpResponse::internal_error();
                stream.write_all(&response.to_bytes())?;
                return Ok(());
            }
        };
        
        println!("处理请求 #{}: {} {}", count, request.method, request.path);
        
        // 路由处理
        let response = self.route(&request);
        
        // 发送响应
        stream.write_all(&response.to_bytes())?;
        stream.flush()?;
        
        Ok(())
    }
    
    fn route(&self, request: &HttpRequest) -> HttpResponse {
        match (request.method.as_str(), request.path.as_str()) {
            ("GET", "/") => self.handle_index(),
            ("GET", "/health") => self.handle_health(),
            ("GET", "/status") => self.handle_status(),
            ("GET", path) if path.starts_with("/api/") => self.handle_api(request),
            ("POST", "/api/data") => self.handle_post_data(request),
            _ => HttpResponse::not_found(),
        }
    }
    
    fn handle_index(&self) -> HttpResponse {
        let html = r#"
        <!DOCTYPE html>
        <html>
        <head>
            <title>Rust HTTP Server</title>
        </head>
        <body>
            <h1>欢迎使用Rust高并发HTTP服务器</h1>
            <p>支持的端点:</p>
            <ul>
                <li><a href="/health">健康检查</a></li>
                <li><a href="/status">状态信息</a></li>
                <li>GET /api/data - 获取数据</li>
                <li>POST /api/data - 提交数据</li>
            </ul>
        </body>
        </html>
        "#;
        
        HttpResponse::new(200, html.to_string())
    }
    
    fn handle_health(&self) -> HttpResponse {
        let health = r#"{"status": "healthy", "timestamp": "}"#;
        HttpResponse::new(200, health.to_string())
    }
    
    fn handle_status(&self) -> HttpResponse {
        let total_requests = self.request_counter.load(Ordering::SeqCst);
        let status = format!(
            r#"{{"total_requests": {}, "server": "Rust-HTTP-Server", "status": "running"}}"#,
            total_requests
        );
        HttpResponse::new(200, status)
    }
    
    fn handle_api(&self, request: &HttpRequest) -> HttpResponse {
        let response = format!(
            r#"{{"method": "{}", "path": "{}", "message": "API响应"}}"#,
            request.method, request.path
        );
        HttpResponse::new(200, response)
    }
    
    fn handle_post_data(&self, request: &HttpRequest) -> HttpResponse {
        let body = request.body.as_deref().unwrap_or("");
        let response = format!(
            r#"{{"received": "{}", "processed": true}}"#,
            body
        );
        HttpResponse::new(200, response)
    }
}
}

9.6.5 配置管理

#![allow(unused)]
fn main() {
// src/config.rs
use std::fs;
use std::path::Path;

#[derive(Debug, Clone)]
pub struct ServerConfig {
    pub port: u16,
    pub max_connections: usize,
    pub max_request_size: usize,
    pub worker_threads: usize,
}

impl ServerConfig {
    pub fn load() -> Result<Self, Box<dyn std::error::Error>> {
        // 尝试从配置文件加载，如果没有则使用默认值
        let config_path = "server.conf";
        
        if Path::new(config_path).exists() {
            let content = fs::read_to_string(config_path)?;
            self::parse_config(&content)
        } else {
            Ok(Self::default())
        }
    }
    
    fn parse_config(content: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let mut port = 8080;
        let mut max_connections = 1000;
        let mut max_request_size = 1024 * 1024; // 1MB
        let mut worker_threads = 4;
        
        for line in content.lines() {
            let line = line.trim();
            if line.starts_with('#') || line.is_empty() {
                continue;
            }
            
            if let Some(equals_pos) = line.find('=') {
                let key = line[..equals_pos].trim();
                let value = line[equals_pos + 1..].trim();
                
                match key {
                    "port" => port = value.parse()?,
                    "max_connections" => max_connections = value.parse()?,
                    "max_request_size" => max_request_size = value.parse()?,
                    "worker_threads" => worker_threads = value.parse()?,
                    _ => {}
                }
            }
        }
        
        Ok(ServerConfig {
            port,
            max_connections,
            max_request_size,
            worker_threads,
        })
    }
}

impl Default for ServerConfig {
    fn default() -> Self {
        Self {
            port: 8080,
            max_connections: 1000,
            max_request_size: 1024 * 1024,
            worker_threads: 4,
        }
    }
}
}

9.6.6 性能测试

#![allow(unused)]
fn main() {
// src/benchmarks.rs
use std::sync::Arc;
use std::thread;
use std::time::{Duration, Instant};
use crate::server::HttpServer;

pub struct BenchmarkRunner {
    server: Arc<HttpServer>,
}

impl BenchmarkRunner {
    pub fn new(server: HttpServer) -> Self {
        Self {
            server: Arc::new(server),
        }
    }
    
    pub fn run_concurrent_requests(&self, concurrent_count: usize, total_requests: usize) {
        println!("开始性能测试: {} 并发，{} 总请求", concurrent_count, total_requests);
        
        let start = Instant::now();
        let mut handles = vec![];
        
        // 启动多个客户端线程
        for _ in 0..concurrent_count {
            let server = Arc::clone(&self.server);
            let handle = thread::spawn(move || {
                Self::simulate_client(server, total_requests / concurrent_count);
            });
            handles.push(handle);
        }
        
        // 等待所有线程完成
        for handle in handles {
            handle.join().unwrap();
        }
        
        let duration = start.elapsed();
        let qps = total_requests as f64 / duration.as_secs_f64();
        
        println!("性能测试结果:");
        println!("  总耗时: {:?}", duration);
        println!("  QPS: {:.2} 请求/秒", qps);
        println!("  平均延迟: {:?} 毫秒", 
                 duration / total_requests as u32);
    }
    
    fn simulate_client(server: Arc<HttpServer>, request_count: usize) {
        for _ in 0..request_count {
            // 这里可以模拟实际的HTTP客户端
            // 在实际实现中会连接到服务器并发送请求
            thread::sleep(Duration::from_millis(1));
        }
    }
}
}

9.7 最佳实践与性能优化

9.7.1 并发模式选择

1. I/O密集型 vs CPU密集型

#![allow(unused)]
fn main() {
// I/O密集型：使用异步编程
use tokio::fs;
use tokio::time::sleep;

async fn io_intensive_task() {
    // 并发I/O操作
    let file_tasks = vec![
        fs::read_to_string("file1.txt"),
        fs::read_to_string("file2.txt"),
        fs::read_to_string("file3.txt"),
    ];
    
    let results = tokio::join!(futures::future::join_all(file_tasks));
    println!("I/O密集型任务完成");
}

// CPU密集型：使用多线程
use rayon::prelude::*;

fn cpu_intensive_task() {
    let data: Vec<i32> = (1..=1_000_000).collect();
    
    let result: Vec<i32> = data
        .par_iter()
        .map(|&x| {
            // CPU密集型计算
            (0..1000).sum::<i32>() * x
        })
        .collect();
    
    println!("CPU密集型任务完成，处理的元素数: {}", result.len());
}
}

2. 选择合适的同步原语

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex, RwLock, atomic::AtomicU64};
use std::collections::HashMap;

// 大量写入操作：使用Mutex
fn heavy_writes() {
    let data = Arc::new(Mutex::new(HashMap::new()));
    
    // 每个线程都在写入
    for i in 0..100 {
        let data = Arc::clone(&data);
        thread::spawn(move || {
            for j in 0..1000 {
                let mut map = data.lock().unwrap();
                map.insert(format!("key_{}_{}", i, j), j);
            }
        });
    }
}

// 大量读取操作：使用RwLock
fn heavy_reads() {
    let data = Arc::new(RwLock::new(HashMap::new()));
    
    // 多个读取者，多个写入者
    for _ in 0..10 {
        let data = Arc::clone(&data);
        // 读取线程
        thread::spawn(move || {
            loop {
                let map = data.read().unwrap();
                // 读取操作
                let _size = map.len();
            }
        });
    }
    
    for _ in 0..5 {
        let data = Arc::clone(&data);
        // 写入线程
        thread::spawn(move || {
            loop {
                let mut map = data.write().unwrap();
                // 写入操作
                map.insert("new_key", "new_value");
            }
        });
    }
}

// 无锁操作：使用原子类型
fn lock_free_counter() {
    let counter = Arc::new(AtomicU64::new(0));
    
    let mut handles = vec![];
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            for _ in 0..1000 {
                counter.fetch_add(1, Ordering::SeqCst);
            }
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("最终计数: {}", counter.load(Ordering::SeqCst));
}
}

9.7.2 内存管理优化

1. 减少锁持有时间

#![allow(unused)]
fn main() {
// 不好的做法：长时间持有锁
fn bad_locking_example() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
    
    thread::spawn(move || {
        let mut vec = data.lock().unwrap();
        
        // 长时间计算 - 锁被长时间持有
        for i in 0..10_000_000 {
            // 耗时计算
            let _ = (i * i).sqrt();
        }
        
        vec.push(42); // 最终修改数据
    });
}

// 好的做法：快速获取数据，然后释放锁
fn good_locking_example() {
    let data = Arc::new(Mutex::new(vec![1, 2, 3]));
    
    thread::spawn(move || {
        // 复制数据，释放锁
        let cloned_data = {
            let vec = data.lock().unwrap();
            vec.clone()
        };
        
        // 长时间计算
        for i in 0..10_000_000 {
            let _ = (i * i).sqrt();
        }
        
        // 快速修改
        let mut vec = data.lock().unwrap();
        *vec = cloned_data;
        vec.push(42);
    });
}
}

2. 使用无锁数据结构

#![allow(unused)]
fn main() {
use std::sync::atomic::{AtomicPtr, AtomicU64, Ordering};
use std::ptr::NonNull;

// 无锁队列实现
struct LockFreeQueue<T> {
    head: AtomicPtr<Node<T>>,
    tail: AtomicPtr<Node<T>>,
}

struct Node<T> {
    data: Option<T>,
    next: AtomicPtr<Node<T>>,
}

impl<T> LockFreeQueue<T> {
    fn new() -> Self {
        let dummy = Box::into_raw(Box::new(Node {
            data: None,
            next: AtomicPtr::new(std::ptr::null_mut()),
        }));
        
        Self {
            head: AtomicPtr::new(dummy),
            tail: AtomicPtr::new(dummy),
        }
    }
    
    fn push(&self, item: T) {
        let new_node = Box::into_raw(Box::new(Node {
            data: Some(item),
            next: AtomicPtr::new(std::ptr::null_mut()),
        }));
        
        loop {
            let current_tail = self.tail.load(Ordering::SeqCst);
            let next = unsafe { (*current_tail).next.load(Ordering::SeqCst) };
            
            if next.is_null() {
                if (*current_tail).next.compare_exchange(
                    std::ptr::null_mut(),
                    new_node,
                    Ordering::SeqCst,
                    Ordering::SeqCst
                ).is_ok() {
                    self.tail.store(new_node, Ordering::SeqCst);
                    break;
                }
            } else {
                self.tail.compare_exchange(
                    current_tail,
                    next,
                    Ordering::SeqCst,
                    Ordering::SeqCst
                ).ok();
            }
        }
    }
}
}

9.7.3 错误处理与资源管理

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

#[derive(Debug)]
enum ConcurrencyError {
    LockPoisoned,
    ThreadPanicked,
    Timeout,
}

// RAII风格的资源管理
struct SharedResource {
    data: Arc<Mutex<Vec<String>>>,
    threads: Vec<thread::JoinHandle<Result<(), ConcurrencyError>>>,
}

impl SharedResource {
    fn new() -> Self {
        Self {
            data: Arc::new(Mutex::new(Vec::new())),
            threads: Vec::new(),
        }
    }
    
    fn spawn_worker<F>(&mut self, task: F)
    where
        F: FnOnce(Arc<Mutex<Vec<String>>>) -> Result<(), ConcurrencyError> + Send + 'static,
    {
        let data = Arc::clone(&self.data);
        let handle = thread::spawn(move || {
            task(data)
        });
        
        self.threads.push(handle);
    }
    
    fn wait_for_completion(&mut self) -> Result<(), ConcurrencyError> {
        for handle in self.threads.drain(..) {
            match handle.join() {
                Ok(result) => result?,
                Err(_) => return Err(ConcurrencyError::ThreadPanicked),
            }
        }
        Ok(())
    }
    
    fn get_data(&self) -> Vec<String> {
        self.data.lock().unwrap().clone()
    }
}

impl Drop for SharedResource {
    fn drop(&mut self) {
        // 等待所有线程完成
        for handle in &self.threads {
            let _ = handle.join();
        }
    }
}
}

9.8 测试策略

9.8.1 并发测试

#![allow(unused)]
fn main() {
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_concurrent_counter() {
        let counter = Arc::new(Mutex::new(0));
        let mut handles = vec![];
        
        // 创建10个线程，每个线程递增1000次
        for _ in 0..10 {
            let counter = Arc::clone(&counter);
            let handle = thread::spawn(move || {
                for _ in 0..1000 {
                    let mut num = counter.lock().unwrap();
                    *num += 1;
                }
            });
            handles.push(handle);
        }
        
        for handle in handles {
            handle.join().unwrap();
        }
        
        let final_count = *counter.lock().unwrap();
        assert_eq!(final_count, 10_000);
    }
    
    #[test]
    fn test_producer_consumer() {
        use std::sync::mpsc;
        
        let (tx, rx) = mpsc::channel();
        let tx = mpsc::Sender::clone(&tx);
        
        // 生产者线程
        let producer = thread::spawn(move || {
            for i in 0..10 {
                tx.send(i).unwrap();
            }
        });
        
        // 消费者线程
        let consumer = thread::spawn(move || {
            let mut sum = 0;
            for received in rx.take(10) {
                sum += received;
            }
            sum
        });
        
        producer.join().unwrap();
        let result = consumer.join().unwrap();
        
        assert_eq!(result, 45); // 0+1+2+...+9 = 45
    }
    
    #[test]
    fn test_async_runtime() {
        use tokio;
        
        tokio::runtime::Runtime::new().unwrap().block_on(async {
            let start = tokio::time::Instant::now();
            
            let task1 = tokio::spawn(async {
                tokio::time::sleep(Duration::from_millis(100)).await;
                "task1"
            });
            
            let task2 = tokio::spawn(async {
                tokio::time::sleep(Duration::from_millis(200)).await;
                "task2"
            });
            
            let (result1, result2) = tokio::join!(task1, task2);
            
            assert_eq!(result1.unwrap(), "task1");
            assert_eq!(result2.unwrap(), "task2");
            
            // 验证并发执行
            let elapsed = start.elapsed();
            assert!(elapsed < Duration::from_millis(250)); // 应该接近200ms而不是300ms
        });
    }
}
}

9.8.2 压力测试

#![allow(unused)]
fn main() {
use std::sync::Arc;
use std::thread;
use std::time::{Duration, Instant};

struct StressTest {
    concurrent_threads: usize,
    operations_per_thread: usize,
    shared_resource: Arc<Mutex<Vec<i32>>>,
}

impl StressTest {
    fn new(concurrent_threads: usize, operations_per_thread: usize) -> Self {
        Self {
            concurrent_threads,
            operations_per_thread,
            shared_resource: Arc::new(Mutex::new(Vec::new())),
        }
    }
    
    fn run(&self) -> TestResult {
        let start = Instant::now();
        let mut handles = vec![];
        
        for _ in 0..self.concurrent_threads {
            let resource = Arc::clone(&self.shared_resource);
            let handle = thread::spawn(move || {
                for i in 0..self.operations_per_thread {
                    // 模拟读写操作
                    {
                        let mut vec = resource.lock().unwrap();
                        vec.push(i);
                    }
                    
                    thread::sleep(Duration::from_millis(1));
                }
            });
            handles.push(handle);
        }
        
        for handle in handles {
            handle.join().unwrap();
        }
        
        let duration = start.elapsed();
        let total_operations = self.concurrent_threads * self.operations_per_thread;
        
        TestResult {
            duration,
            total_operations,
            final_size: self.shared_resource.lock().unwrap().len(),
        }
    }
}

#[derive(Debug)]
struct TestResult {
    duration: Duration,
    total_operations: usize,
    final_size: usize,
}

impl TestResult {
    fn throughput(&self) -> f64 {
        self.total_operations as f64 / self.duration.as_secs_f64()
    }
}

#[cfg(test)]
mod stress_tests {
    use super::*;
    
    #[test]
    fn test_concurrent_stress() {
        let test = StressTest::new(10, 1000);
        let result = test.run();
        
        println!("压力测试结果:");
        println!("  总操作数: {}", result.total_operations);
        println!("  执行时间: {:?}", result.duration);
        println!("  吞吐量: {:.2} ops/sec", result.throughput());
        println!("  最终数据大小: {}", result.final_size);
        
        // 验证数据完整性
        assert_eq!(result.final_size, result.total_operations);
    }
}
}

9.9 性能调优

9.9.1 Profiling与监控

#![allow(unused)]
fn main() {
use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
use std::time::{Duration, Instant};

struct PerformanceMetrics {
    total_requests: AtomicU64,
    total_latency: AtomicU64,
    active_connections: AtomicUsize,
    peak_connections: AtomicUsize,
}

impl PerformanceMetrics {
    fn new() -> Self {
        Self {
            total_requests: AtomicU64::new(0),
            total_latency: AtomicU64::new(0),
            active_connections: AtomicUsize::new(0),
            peak_connections: AtomicUsize::new(0),
        }
    }
    
    fn record_request(&self, latency: Duration) {
        self.total_requests.fetch_add(1, Ordering::Relaxed);
        self.total_latency.fetch_add(
            latency.as_micros() as u64, 
            Ordering::Relaxed
        );
    }
    
    fn connection_opened(&self) {
        let active = self.active_connections.fetch_add(1, Ordering::Relaxed) + 1;
        let peak = self.peak_connections.load(Ordering::Relaxed);
        if active > peak {
            self.peak_connections.store(active, Ordering::Relaxed);
        }
    }
    
    fn connection_closed(&self) {
        self.active_connections.fetch_sub(1, Ordering::Relaxed);
    }
    
    fn get_stats(&self) -> ServerStats {
        let total_requests = self.total_requests.load(Ordering::Relaxed);
        let total_latency = self.total_latency.load(Ordering::Relaxed);
        let active_connections = self.active_connections.load(Ordering::Relaxed);
        let peak_connections = self.peak_connections.load(Ordering::Relaxed);
        
        let avg_latency = if total_requests > 0 {
            Duration::from_micros(total_latency / total_requests)
        } else {
            Duration::from_micros(0)
        };
        
        ServerStats {
            total_requests,
            active_connections,
            peak_connections,
            average_latency: avg_latency,
        }
    }
}

#[derive(Debug, Clone)]
struct ServerStats {
    total_requests: u64,
    active_connections: usize,
    peak_connections: usize,
    average_latency: Duration,
}

// 在服务器中使用
pub struct HttpServerWithMetrics {
    metrics: Arc<PerformanceMetrics>,
    // 其他字段...
}

impl HttpServerWithMetrics {
    pub fn new(port: u16) -> Self {
        Self {
            metrics: Arc::new(PerformanceMetrics::new()),
        }
    }
    
    pub async fn handle_request(&self) {
        let start = Instant::now();
        self.metrics.connection_opened();
        
        // 处理请求...
        
        let duration = start.elapsed();
        self.metrics.record_request(duration);
        self.metrics.connection_closed();
    }
    
    pub fn get_performance_stats(&self) -> ServerStats {
        self.metrics.get_stats()
    }
}
}

9.9.2 内存优化

#![allow(unused)]
fn main() {
// 减少内存分配的技巧

// 1. 使用对象池
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};

struct ObjectPool<T: Default> {
    pool: Mutex<VecDeque<T>>,
    capacity: usize,
}

impl<T: Default> ObjectPool<T> {
    fn new(capacity: usize) -> Self {
        Self {
            pool: Mutex::new(VecDeque::with_capacity(capacity)),
            capacity,
        }
    }
    
    fn get(&self) -> T {
        let mut pool = self.pool.lock().unwrap();
        pool.pop_front().unwrap_or_default()
    }
    
    fn return_object(&self, item: T) {
        let mut pool = self.pool.lock().unwrap();
        if pool.len() < self.capacity {
            pool.push_back(item);
        }
    }
}

// 2. 使用栈分配的缓冲区
fn stack_allocated_buffer() {
    // 使用固定大小的数组而不是Vec
    let mut buffer = [0u8; 4096]; // 4KB 栈缓冲区
    
    // 填充数据
    for (i, byte) in buffer.iter_mut().enumerate() {
        *byte = (i % 256) as u8;
    }
    
    println!("栈分配的缓冲区大小: {} 字节", buffer.len());
}

// 3. 避免不必要的clone
use std::sync::Arc;

fn avoid_unnecessary_clones(data: &str) -> String {
    // 不好的做法
    // let owned = data.to_string(); // 不必要的分配
    
    // 好的做法
    if data.is_empty() {
        String::new()
    } else {
        data.to_string() // 只在需要时分配
    }
}

// 4. 使用Cow (Clone-on-Write)
use std::borrow::Cow;

fn use_cow_optimization(input: &str) -> Cow<str> {
    if input.is_empty() {
        Cow::Owned("default".to_string())
    } else if input.len() > 10 {
        Cow::Owned(input.to_uppercase())
    } else {
        Cow::Borrowed(input)
    }
}
}

9.10 总结与进阶

9.10.1 本章要点回顾

并发基础概念：
- 理解并发与并行的区别
- 掌握Rust的并发安全哲学
- 学会所有权和借用在并发中的作用
线程编程：
- 掌握线程创建和管理的各种方式
- 实现线程池和任务调度
- 理解线程间参数传递和返回值
消息传递：
- 使用通道进行线程间通信
- 实现生产者和消费者模式
- 掌握同步和异步通道的区别
共享内存：
- 使用Arc和Mutex进行安全共享
- 掌握RwLock和Condvar的使用
- 了解无锁数据结构的概念
异步编程：
- 理解async/await的语法和语义
- 掌握Tokio异步运行时的使用
- 学会使用select和流处理
实战项目：
- 构建了高并发Web服务器
- 实现了性能监控和指标收集
- 掌握了并发架构设计模式

9.10.2 最佳实践总结

选择合适的并发模型：
- I/O密集型：使用异步编程
- CPU密集型：使用多线程和Rayon
- 混合场景：结合两种方法
同步原语选择指南：
- 大量写入：使用Mutex
- 大量读取：使用RwLock
- 简单计数器：使用原子类型
- 复杂通信：使用通道
性能优化要点：
- 减少锁持有时间
- 避免死锁和活锁
- 使用对象池减少分配
- 监控和调优
错误处理策略：
- 使用Result类型传播错误
- 实现RAII资源管理
- 处理线程panic

9.10.3 进阶学习方向

高级并发模式：
- Actor模型实现
- 分布式系统设计
- 实时系统编程
性能调优技术：
- CPU缓存优化
- 内存布局优化
- SIMD指令使用
系统级编程：
- 零拷贝I/O
- 内存映射文件
- 信号处理
分布式系统：
- 集群协调
- 分布式缓存
- 容错和恢复

通过本章的学习，您已经掌握了Rust强大的并发编程能力，能够构建高性能、可扩展的并发应用程序。下一章将介绍网络编程，进一步扩展您的系统编程技能。

第10章：网络编程

章节概述

网络编程是现代应用程序开发的核心技能。在本章中，我们将深入探索Rust的网络编程能力，从基础的TCP/UDP通信到高级的WebSocket和分布式系统设计。本章不仅关注技术实现，更强调生产环境下的稳定性和性能优化。

学习目标：

掌握Rust网络编程的核心概念和API
理解TCP/UDP协议的工作原理和适用场景
学会构建高性能的HTTP客户端和服务器
掌握WebSocket协议实现实时双向通信
掌握JSON、MessagePack等序列化技术
设计并实现一个可扩展的分布式聊天系统

实战项目：构建一个企业级分布式聊天系统，支持多房间、文件传输、消息持久化等功能。

10.1 网络编程基础

10.1.1 Rust网络编程特性

Rust在网络编程方面具有以下独特优势：

内存安全：防止缓冲区溢出、竞态条件等常见网络编程错误
零成本抽象：高性能的网络编程抽象，接近C++的性能
类型安全：编译时类型检查，避免运行时错误
异步支持：优秀的异步/await支持，适合高并发网络应用

10.1.2 核心网络库介绍

std::net模块

// TCP连接示例
use std::net::TcpStream;
use std::io::{Read, Write};

fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080")?;
    stream.write_all(b"Hello, Server!")?;
    
    let mut response = String::new();
    stream.read_to_string(&mut response)?;
    println!("Response: {}", response);
    Ok(())
}

tokio异步网络库

// 异步TCP服务器
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    
    loop {
        let (stream, addr) = listener.accept().await?;
        println!("New client: {}", addr);
        
        tokio::spawn(async move {
            handle_client(stream).await
        });
    }
}

async fn handle_client(mut stream: TcpStream) -> Result<(), Box<dyn std::error::Error>> {
    let mut buffer = [0; 1024];
    let n = stream.read(&mut buffer).await?;
    if n == 0 {
        return Ok(());
    }
    
    let response = format!("Echo: {}", String::from_utf8_lossy(&buffer[..n]));
    stream.write_all(response.as_bytes()).await?;
    Ok(())
}

10.1.3 网络编程最佳实践

错误处理：使用Result类型处理网络错误
资源管理：确保网络资源正确释放
超时设置：避免无限等待
安全考虑：验证输入、防止注入攻击
性能优化：使用连接池、批量处理等技术

10.2 TCP/UDP编程

10.2.1 TCP协议编程

基础TCP客户端

#![allow(unused)]
fn main() {
use std::net::{TcpStream, SocketAddr};
use std::io::{Read, Write, BufReader, BufRead};
use std::time::Duration;

pub struct TcpClient {
    stream: TcpStream,
    buffer_size: usize,
    timeout: Duration,
}

impl TcpClient {
    pub fn connect(addr: SocketAddr) -> Result<Self, std::io::Error> {
        let stream = TcpStream::connect_timeout(&addr, Duration::from_secs(10))?;
        stream.set_non_blocking(false)?;
        
        Ok(TcpClient {
            stream,
            buffer_size: 4096,
            timeout: Duration::from_secs(30),
        })
    }
    
    pub fn send(&mut self, data: &[u8]) -> Result<usize, std::io::Error> {
        self.stream.set_write_timeout(Some(self.timeout))?;
        self.stream.write_all(data)?;
        Ok(data.len())
    }
    
    pub fn receive(&mut self) -> Result<Vec<u8>, std::io::Error> {
        self.stream.set_read_timeout(Some(self.timeout))?;
        let mut buffer = vec![0u8; self.buffer_size];
        let n = self.stream.read(&mut buffer)?;
        buffer.truncate(n);
        Ok(buffer)
    }
    
    pub fn send_message(&mut self, message: &str) -> Result<String, std::io::Error> {
        self.send(message.as_bytes())?;
        let response = self.receive()?;
        Ok(String::from_utf8_lossy(&response).to_string())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::net::ToSocketAddrs;
    
    #[test]
    fn test_tcp_client_creation() {
        let addr = "127.0.0.1:0".to_socket_addrs().unwrap().next().unwrap();
        // 测试客户端创建
    }
}
}

高级TCP服务器

#![allow(unused)]
fn main() {
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{mpsc, oneshot};
use tokio::time::{timeout, Duration};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::Mutex;

pub struct TcpServer {
    listener: TcpListener,
    clients: Arc<Mutex<HashMap<String, mpsc::UnboundedSender<String>>>>,
    message_rx: mpsc::UnboundedReceiver<String>,
    message_tx: mpsc::UnboundedSender<String>,
}

impl TcpServer {
    pub async fn bind(addr: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let listener = TcpListener::bind(addr).await?;
        let (message_tx, message_rx) = mpsc::unbounded_channel();
        
        Ok(TcpServer {
            listener,
            clients: Arc::new(Mutex::new(HashMap::new())),
            message_rx,
            message_tx,
        })
    }
    
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        let clients = Arc::clone(&self.clients);
        
        // 处理消息广播
        let broadcast_task = {
            let message_tx = self.message_tx.clone();
            tokio::spawn(async move {
                while let Some(message) = self.message_rx.recv().await {
                    let clients = clients.lock().await;
                    for (_, sender) in &clients {
                        let _ = sender.send(message.clone());
                    }
                }
            })
        };
        
        // 处理新连接
        loop {
            match self.listener.accept().await {
                Ok((stream, addr)) => {
                    let client_id = format!("{}", addr);
                    println!("New client connected: {}", client_id);
                    
                    let clients = Arc::clone(&self.clients);
                    let message_tx = self.message_tx.clone();
                    
                    tokio::spawn(async move {
                        Self::handle_client(stream, client_id, clients, message_tx).await
                    });
                }
                Err(e) => {
                    eprintln!("Failed to accept connection: {}", e);
                }
            }
        }
        
        Ok(())
    }
    
    async fn handle_client(
        stream: TcpStream,
        client_id: String,
        clients: Arc<Mutex<HashMap<String, mpsc::UnboundedSender<String>>>>,
        message_tx: mpsc::UnboundedSender<String>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let (reader, mut writer) = stream.into_split();
        let mut buf_reader = tokio::io::BufReader::new(reader);
        
        // 创建客户端消息发送通道
        let (tx, mut rx) = mpsc::unbounded_channel::<String>();
        {
            let mut clients = clients.lock().await;
            clients.insert(client_id.clone(), tx);
        }
        
        let mut client = TcpClientHandler::new(client_id.clone());
        client.register_disconnect_hook(clients.clone());
        
        // 处理客户端消息
        let message_task = tokio::spawn(async move {
            let mut buffer = String::new();
            loop {
                match timeout(Duration::from_secs(30), buf_reader.read_line(&mut buffer)).await {
                    Ok(Ok(0)) => break, // 连接关闭
                    Ok(Ok(n)) => {
                        if n > 0 {
                            let message = format!("{}: {}", client_id, buffer.trim());
                            let _ = message_tx.send(message);
                            buffer.clear();
                        }
                    }
                    Ok(Err(e)) => {
                        eprintln!("Error reading from client {}: {}", client_id, e);
                        break;
                    }
                    Err(_) => {
                        // 超时，继续等待
                    }
                }
            }
        });
        
        // 处理发送消息
        let send_task = tokio::spawn(async move {
            while let Some(message) = rx.recv().await {
                if let Err(e) = writer.write_all(message.as_bytes()).await {
                    eprintln!("Error writing to client {}: {}", client_id, e);
                    break;
                }
            }
        });
        
        tokio::select! {
            result = message_task => {
                if let Err(e) = result {
                    eprintln!("Message task error: {}", e);
                }
            }
            result = send_task => {
                if let Err(e) = result {
                    eprintln!("Send task error: {}", e);
                }
            }
        }
        
        Ok(())
    }
}

struct TcpClientHandler {
    client_id: String,
    disconnect_hooks: Vec<Box<dyn Fn(&str) + Send + Sync>>,
}

impl TcpClientHandler {
    pub fn new(client_id: String) -> Self {
        TcpClientHandler {
            client_id,
            disconnect_hooks: Vec::new(),
        }
    }
    
    pub fn register_disconnect_hook(&mut self, clients: Arc<Mutex<HashMap<String, mpsc::UnboundedSender<String>>>>) {
        let client_id = self.client_id.clone();
        self.disconnect_hooks.push(Box::new(move |_| {
            let mut clients = clients.lock().unwrap();
            clients.remove(&client_id);
            println!("Client {} disconnected and removed", client_id);
        }));
    }
}
}

10.2.2 UDP协议编程

UDP是无连接的协议，适用于对实时性要求高、能够容忍丢包的场景，如视频流、实时游戏等。

#![allow(unused)]
fn main() {
use std::net::{UdpSocket, SocketAddr};
use tokio::net::UdpSocket as AsyncUdpSocket;
use tokio::time::Duration;

pub struct UdpClient {
    socket: AsyncUdpSocket,
    target_addr: SocketAddr,
    buffer_size: usize,
}

impl UdpClient {
    pub async fn connect(target_addr: SocketAddr) -> Result<Self, Box<dyn std::error::Error>> {
        let socket = AsyncUdpSocket::bind("0.0.0.0:0").await?;
        Ok(UdpClient {
            socket,
            target_addr,
            buffer_size: 1024,
        })
    }
    
    pub async fn send(&self, data: &[u8]) -> Result<usize, Box<dyn std::error::Error>> {
        let result = self.socket.send_to(data, self.target_addr).await?;
        Ok(result)
    }
    
    pub async fn receive(&self) -> Result<(Vec<u8>, SocketAddr), Box<dyn std::error::Error>> {
        let mut buffer = vec![0u8; self.buffer_size];
        let (size, source) = self.socket.recv_from(&mut buffer).await?;
        buffer.truncate(size);
        Ok((buffer, source))
    }
    
    pub async fn send_and_receive(
        &self,
        data: &[u8],
        timeout: Duration,
    ) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        self.send(data)?;
        
        tokio::time::timeout(timeout, self.receive())
            .await
            .map_err(|_| "Timeout waiting for response")?
            .map(|(response, _)| response)
    }
}

pub struct UdpServer {
    socket: AsyncUdpSocket,
    clients: Arc<Mutex<HashMap<SocketAddr, ClientInfo>>>,
}

#[derive(Clone)]
struct ClientInfo {
    last_seen: std::time::Instant,
    message_count: u64,
}

impl UdpServer {
    pub async fn bind(addr: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let socket = AsyncUdpSocket::bind(addr).await?;
        Ok(UdpServer {
            socket,
            clients: Arc::new(Mutex::new(HashMap::new())),
        })
    }
    
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        let clients = Arc::clone(&self.clients);
        let mut buffer = vec![0u8; 65536];
        
        loop {
            match self.socket.recv_from(&mut buffer).await {
                Ok((size, source)) => {
                    println!("Received {} bytes from {}", size, source);
                    
                    // 更新客户端信息
                    {
                        let mut clients = clients.lock().await;
                        let info = clients.entry(source).or_insert_with(|| ClientInfo {
                            last_seen: std::time::Instant::now(),
                            message_count: 0,
                        });
                        info.last_seen = std::time::Instant::now();
                        info.message_count += 1;
                    }
                    
                    // 处理数据
                    let response = self.process_packet(&buffer[..size]);
                    
                    // 发送响应
                    if !response.is_empty() {
                        if let Err(e) = self.socket.send_to(&response, source).await {
                            eprintln!("Failed to send response to {}: {}", source, e);
                        }
                    }
                }
                Err(e) => {
                    eprintln!("UDP receive error: {}", e);
                }
            }
        }
    }
    
    fn process_packet(&self, data: &[u8]) -> Vec<u8> {
        // 简单的回应协议
        format!("ACK: {}", data.len()).into_bytes()
    }
    
    pub async fn get_client_stats(&self) -> Vec<(SocketAddr, ClientInfo)> {
        let clients = self.clients.lock().await;
        clients.clone().into_iter().collect()
    }
}

#[cfg(test)]
mod udp_tests {
    use super::*;
    use std::net::SocketAddr;
    use tokio::time::sleep;
    
    #[tokio::test]
    async fn test_udp_echo() -> Result<(), Box<dyn std::error::Error>> {
        let server_addr: SocketAddr = "127.0.0.1:0".parse()?;
        let server = UdpServer::bind("127.0.0.1:0").await?;
        let bind_addr = server.socket.local_addr()?;
        
        let client = UdpClient::connect(bind_addr).await?;
        
        let test_data = b"Hello, UDP!";
        let response = client.send_and_receive(test_data, Duration::from_secs(1)).await?;
        
        assert_eq!(response, b"ACK: 10");
        Ok(())
    }
}
}

10.3 HTTP客户端与服务器

10.3.1 HTTP客户端

基于原生std库的HTTP客户端

#![allow(unused)]
fn main() {
use std::io::{Read, Write};
use std::net::TcpStream;
use std::collections::HashMap;

pub struct HttpClient {
    host: String,
    port: u16,
    timeout: std::time::Duration,
}

impl HttpClient {
    pub fn new(host: impl Into<String>, port: u16) -> Self {
        HttpClient {
            host: host.into(),
            port,
            timeout: std::time::Duration::from_secs(10),
        }
    }
    
    pub fn get(&self, path: &str) -> Result<HttpResponse, Box<dyn std::error::Error>> {
        self.request("GET", path, None)
    }
    
    pub fn post(&self, path: &str, body: &str) -> Result<HttpResponse, Box<dyn std::error::Error>> {
        self.request("POST", path, Some(body))
    }
    
    fn request(&self, method: &str, path: &str, body: Option<&str>) -> Result<HttpResponse, Box<dyn std::error::Error>> {
        let address = format!("{}:{}", self.host, self.port);
        let mut stream = TcpStream::connect(&address)?;
        stream.set_read_timeout(Some(self.timeout))?;
        stream.set_write_timeout(Some(self.timeout))?;
        
        // 构建HTTP请求
        let mut headers = HashMap::new();
        headers.insert("Host", &self.host);
        headers.insert("Connection", "close");
        headers.insert("User-Agent", "Rust-HttpClient/1.0");
        
        if let Some(body) = body {
            headers.insert("Content-Type", "application/json");
            headers.insert("Content-Length", &body.len().to_string());
        }
        
        let request = self.build_request(method, path, &headers, body);
        stream.write_all(request.as_bytes())?;
        
        // 读取响应
        let mut response_buffer = String::new();
        stream.read_to_string(&mut response_buffer)?;
        
        HttpResponse::parse(&response_buffer)
    }
    
    fn build_request(&self, method: &str, path: &str, headers: &HashMap<&str, &str>, body: Option<&str>) -> String {
        let mut request = format!("{} {} HTTP/1.1\r\n", method, path);
        
        for (key, value) in headers {
            request.push_str(&format!("{}: {}\r\n", key, value));
        }
        
        request.push_str("\r\n");
        
        if let Some(body) = body {
            request.push_str(body);
        }
        
        request
    }
}

pub struct HttpResponse {
    status_code: u16,
    headers: HashMap<String, String>,
    body: String,
}

impl HttpResponse {
    fn parse(response: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let lines: Vec<&str> = response.split("\r\n").collect();
        
        if lines.is_empty() {
            return Err("Empty response".into());
        }
        
        // 解析状态行
        let status_line = lines[0];
        let status_parts: Vec<&str> = status_line.split(' ').collect();
        if status_parts.len() < 2 {
            return Err("Invalid status line".into());
        }
        
        let status_code = status_parts[1].parse::<u16>()?;
        
        // 找到空行分隔头部和主体
        let mut header_lines = Vec::new();
        let mut body_lines = Vec::new();
        let mut in_headers = true;
        
        for line in &lines[1..] {
            if line.is_empty() {
                in_headers = false;
                continue;
            }
            
            if in_headers {
                header_lines.push(*line);
            } else {
                body_lines.push(*line);
            }
        }
        
        // 解析头部
        let mut headers = HashMap::new();
        for line in header_lines {
            if let Some(colon_pos) = line.find(':') {
                let key = line[..colon_pos].trim().to_string();
                let value = line[colon_pos + 1..].trim().to_string();
                headers.insert(key, value);
            }
        }
        
        // 构建主体
        let body = body_lines.join("\r\n");
        
        Ok(HttpResponse {
            status_code,
            headers,
            body,
        })
    }
    
    pub fn status(&self) -> u16 {
        self.status_code
    }
    
    pub fn body(&self) -> &str {
        &self.body
    }
    
    pub fn header(&self, key: &str) -> Option<&str> {
        self.headers.get(key).map(|s| s.as_str())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_http_response_parsing() {
        let response = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 13\r\n\r\n{\"status\":\"ok\"}";
        let parsed = HttpResponse::parse(response).unwrap();
        
        assert_eq!(parsed.status(), 200);
        assert_eq!(parsed.body(), "{\"status\":\"ok\"}");
        assert_eq!(parsed.header("Content-Type"), Some("application/json"));
    }
}
}

异步HTTP客户端（使用reqwest）

#![allow(unused)]
fn main() {
use reqwest::{Client, Response};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiError {
    pub error: String,
    pub message: String,
}

pub struct AsyncHttpClient {
    client: Client,
    base_url: String,
    default_headers: HashMap<String, String>,
}

impl AsyncHttpClient {
    pub fn new(base_url: impl Into<String>) -> Self {
        AsyncHttpClient {
            client: Client::new(),
            base_url: base_url.into(),
            default_headers: HashMap::new(),
        }
    }
    
    pub fn with_header(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
        self.default_headers.insert(key.into(), value.into());
        self
    }
    
    pub async fn get<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T, Box<dyn std::error::Error>> {
        let url = format!("{}{}", self.base_url, endpoint);
        let mut request = self.client.get(&url);
        
        // 添加默认头部
        for (key, value) in &self.default_headers {
            request = request.header(key, value);
        }
        
        let response = request.send().await?;
        self.handle_response::<T>(response).await
    }
    
    pub async fn post<T: for<'de> Deserialize<'de>, B: Serialize>(
        &self,
        endpoint: &str,
        body: &B,
    ) -> Result<T, Box<dyn std::error::Error>> {
        let url = format!("{}{}", self.base_url, endpoint);
        let mut request = self.client.post(&url).json(body);
        
        for (key, value) in &self.default_headers {
            request = request.header(key, value);
        }
        
        let response = request.send().await?;
        self.handle_response::<T>(response).await
    }
    
    pub async fn put<T: for<'de> Deserialize<'de>, B: Serialize>(
        &self,
        endpoint: &str,
        body: &B,
    ) -> Result<T, Box<dyn std::error::Error>> {
        let url = format!("{}{}", self.base_url, endpoint);
        let mut request = self.client.put(&url).json(body);
        
        for (key, value) in &self.default_headers {
            request = request.header(key, value);
        }
        
        let response = request.send().await?;
        self.handle_response::<T>(response).await
    }
    
    pub async fn delete<T: for<'de> Deserialize<'de>>(&self, endpoint: &str) -> Result<T, Box<dyn std::error::Error>> {
        let url = format!("{}{}", self.base_url, endpoint);
        let mut request = self.client.delete(&url);
        
        for (key, value) in &self.default_headers {
            request = request.header(key, value);
        }
        
        let response = request.send().await?;
        self.handle_response::<T>(response).await
    }
    
    async fn handle_response<T: for<'de> Deserialize<'de>>(&self, response: Response) -> Result<T, Box<dyn std::error::Error>> {
        let status = response.status();
        
        if !status.is_success() {
            let error_text = response.text().await?;
            let error: ApiError = serde_json::from_str(&error_text)
                .unwrap_or_else(|_| ApiError {
                    error: "Unknown error".to_string(),
                    message: error_text,
                });
            
            return Err(format!("HTTP {}: {} - {}", status.as_u16(), error.error, error.message).into());
        }
        
        let result = response.json::<T>().await?;
        Ok(result)
    }
}

// 使用示例
#[cfg(test)]
mod http_client_tests {
    use super::*;
    use serde_json::json;
    
    #[tokio::test]
    async fn test_async_client() {
        // 创建模拟服务器进行测试
        // 或者使用公共API进行集成测试
    }
}
}

10.3.2 HTTP服务器

基于tokio的HTTP服务器

#![allow(unused)]
fn main() {
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::Mutex;
use serde_json::{json, Value};

#[derive(Clone)]
pub struct RouteHandler {
    handlers: Arc<Mutex<HashMap<String, Handler>>>,
}

impl RouteHandler {
    pub fn new() -> Self {
        RouteHandler {
            handlers: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    pub fn get(&self, path: &str, handler: Handler) {
        let mut handlers = self.handlers.blocking_lock();
        handlers.insert(format!("GET:{}", path), handler);
    }
    
    pub fn post(&self, path: &str, handler: Handler) {
        let mut handlers = self.handlers.blocking_lock();
        handlers.insert(format!("POST:{}", path), handler);
    }
    
    pub fn put(&self, path: &str, handler: Handler) {
        let mut handlers = self.handlers.blocking_lock();
        handlers.insert(format!("PUT:{}", path), handler);
    }
    
    pub fn delete(&self, path: &str, handler: Handler) {
        let mut handlers = self.handlers.blocking_lock();
        handlers.insert(format!("DELETE:{}", path), handler);
    }
    
    pub async fn handle_request(&self, method: &str, path: &str, body: &[u8]) -> Result<Response, Box<dyn std::error::Error>> {
        let handlers = self.handlers.lock().await;
        let handler_key = format!("{}:{}", method, path);
        
        if let Some(handler) = handlers.get(&handler_key) {
            handler(method, path, body).await
        } else {
            Ok(Response::not_found("Route not found"))
        }
    }
}

type Handler = fn(&str, &str, &[u8]) -> Pin<Box<dyn std::future::Future<Output = Result<Response, Box<dyn std::error::Error>>> + Send>>;

pub struct Response {
    status_code: u16,
    headers: HashMap<String, String>,
    body: Vec<u8>,
}

impl Response {
    pub fn ok(body: impl AsRef<[u8]>) -> Self {
        Response {
            status_code: 200,
            headers: [(String::from("Content-Type"), String::from("application/json"))]
                .iter()
                .cloned()
                .collect(),
            body: body.as_ref().to_vec(),
        }
    }
    
    pub fn created(body: impl AsRef<[u8]>) -> Self {
        Response {
            status_code: 201,
            headers: [(String::from("Content-Type"), String::from("application/json"))]
                .iter()
                .cloned()
                .collect(),
            body: body.as_ref().to_vec(),
        }
    }
    
    pub fn bad_request(message: &str) -> Self {
        Response {
            status_code: 400,
            headers: [(String::from("Content-Type"), String::from("application/json"))]
                .iter()
                .cloned()
                .collect(),
            body: json!({ "error": message }).to_string().into_bytes(),
        }
    }
    
    pub fn not_found(message: &str) -> Self {
        Response {
            status_code: 404,
            headers: [(String::from("Content-Type"), String::from("application/json"))]
                .iter()
                .cloned()
                .collect(),
            body: json!({ "error": message }).to_string().into_bytes(),
        }
    }
    
    pub fn internal_server_error(message: &str) -> Self {
        Response {
            status_code: 500,
            headers: [(String::from("Content-Type"), String::from("application/json"))]
                .iter()
                .cloned()
                .collect(),
            body: json!({ "error": message }).to_string().into_bytes(),
        }
    }
    
    pub fn to_http_response(&self) -> String {
        let mut response = format!("HTTP/1.1 {} OK\r\n", self.status_code);
        
        for (key, value) in &self.headers {
            response.push_str(&format!("{}: {}\r\n", key, value));
        }
        
        response.push_str("Connection: close\r\n");
        response.push_str("\r\n");
        response.push_str(&String::from_utf8_lossy(&self.body));
        
        response
    }
}

pub struct HttpServer {
    listener: TcpListener,
    routes: RouteHandler,
    static_files: Option<Arc<std::path::PathBuf>>,
}

impl HttpServer {
    pub async fn bind(addr: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let listener = TcpListener::bind(addr).await?;
        
        Ok(HttpServer {
            listener,
            routes: RouteHandler::new(),
            static_files: None,
        })
    }
    
    pub fn with_static_files(&mut self, path: &std::path::Path) {
        self.static_files = Some(Arc::new(path.to_path_buf()));
    }
    
    pub fn setup_routes(&self) {
        // 根路径
        self.routes.get("/", |_, _, _| {
            Box::pin(async {
                Ok(Response::ok(json!({ "message": "Welcome to Rust HTTP Server" })))
            })
        });
        
        // 健康检查
        self.routes.get("/health", |_, _, _| {
            Box::pin(async {
                Ok(Response::ok(json!({ "status": "healthy" })))
            })
        });
        
        // API示例
        self.routes.get("/api/users", |_, _, _| {
            Box::pin(async {
                let users = json!([
                    { "id": 1, "name": "Alice", "email": "alice@example.com" },
                    { "id": 2, "name": "Bob", "email": "bob@example.com" }
                ]);
                Ok(Response::ok(users))
            })
        });
        
        self.routes.post("/api/echo", |_, _, body| {
            Box::pin(async {
                if let Ok(value) = serde_json::from_slice::<Value>(body) {
                    Ok(Response::ok(value))
                } else {
                    Ok(Response::bad_request("Invalid JSON"))
                }
            })
        });
    }
    
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        println!("HTTP Server listening on {}", self.listener.local_addr()?);
        
        loop {
            match self.listener.accept().await {
                Ok((stream, addr)) => {
                    println!("New connection from {}", addr);
                    
                    let routes = self.routes.clone();
                    let static_files = self.static_files.clone();
                    
                    tokio::spawn(async move {
                        handle_client(stream, routes, static_files).await
                    });
                }
                Err(e) => {
                    eprintln!("Failed to accept connection: {}", e);
                }
            }
        }
    }
}

async fn handle_client(
    stream: TcpStream,
    routes: RouteHandler,
    static_files: Option<Arc<std::path::PathBuf>>,
) {
    let (reader, mut writer) = stream.into_split();
    let mut buf_reader = tokio::io::BufReader::new(reader);
    let mut buffer = String::new();
    
    // 读取HTTP请求
    if let Err(e) = buf_reader.read_to_string(&mut buffer).await {
        eprintln!("Failed to read request: {}", e);
        return;
    }
    
    // 解析HTTP请求
    if let Ok((method, path, _headers, body)) = parse_http_request(&buffer) {
        // 处理静态文件
        if let Some(static_path) = &static_files {
            if let Some(file_response) = serve_static_file(&path, static_path).await {
                let _ = writer.write_all(file_response.to_http_response().as_bytes()).await;
                return;
            }
        }
        
        // 处理路由
        match routes.handle_request(&method, &path, body.as_bytes()).await {
            Ok(response) => {
                let http_response = response.to_http_response();
                if let Err(e) = writer.write_all(http_response.as_bytes()).await {
                    eprintln!("Failed to send response: {}", e);
                }
            }
            Err(e) => {
                eprintln!("Request handling error: {}", e);
                let error_response = Response::internal_server_error("Internal server error");
                let _ = writer.write_all(error_response.to_http_response().as_bytes()).await;
            }
        }
    } else {
        let error_response = Response::bad_request("Invalid HTTP request");
        let _ = writer.write_all(error_response.to_http_response().as_bytes()).await;
    }
}

fn parse_http_request(request: &str) -> Result<(String, String, HashMap<String, String>, String), Box<dyn std::error::Error>> {
    let lines: Vec<&str> = request.split("\r\n").collect();
    
    if lines.is_empty() {
        return Err("Empty request".into());
    }
    
    // 解析请求行
    let request_line = lines[0];
    let parts: Vec<&str> = request_line.split(' ').collect();
    if parts.len() != 3 {
        return Err("Invalid request line".into());
    }
    
    let method = parts[0].to_string();
    let path = parts[1].to_string();
    
    // 解析头部
    let mut headers = HashMap::new();
    let mut body = String::new();
    let mut in_headers = true;
    
    for line in &lines[1..] {
        if line.is_empty() {
            in_headers = false;
            continue;
        }
        
        if in_headers {
            if let Some(colon_pos) = line.find(':') {
                let key = line[..colon_pos].trim().to_string();
                let value = line[colon_pos + 1..].trim().to_string();
                headers.insert(key, value);
            }
        } else {
            body.push_str(line);
        }
    }
    
    Ok((method, path, headers, body))
}

async fn serve_static_file(path: &str, static_dir: &std::path::Path) -> Option<Response> {
    let mut file_path = static_dir.to_path_buf();
    
    // 移除开头的斜杠
    let clean_path = path.trim_start_matches('/');
    file_path.push(clean_path);
    
    // 防止目录遍历攻击
    if file_path.to_string_lossy().contains("..") {
        return None;
    }
    
    // 默认索引文件
    if clean_path.is_empty() || clean_path.ends_with('/') {
        file_path.push("index.html");
    }
    
    if let Ok(content) = tokio::fs::read(&file_path).await {
        let content_type = match file_path.extension()?.to_str()? {
            "html" => "text/html",
            "css" => "text/css",
            "js" => "application/javascript",
            "json" => "application/json",
            "png" => "image/png",
            "jpg" | "jpeg" => "image/jpeg",
            "gif" => "image/gif",
            "svg" => "image/svg+xml",
            _ => "application/octet-stream",
        };
        
        let mut response = Response::ok(content);
        response.headers.insert("Content-Type".to_string(), content_type.to_string());
        Some(response)
    } else {
        None
    }
}

use std::pin::Pin;

#[cfg(test)]
mod tests {
    use super::*;
    
    #[tokio::test]
    async fn test_http_server() {
        let mut server = HttpServer::bind("127.0.0.1:0").await.unwrap();
        server.setup_routes();
        
        let addr = server.listener.local_addr().unwrap();
        
        // 在真实测试中，我们启动服务器并发送HTTP请求
        // 这里省略具体实现
    }
}
}

10.4 WebSocket实现

WebSocket提供了全双工通信能力，特别适合实时应用如聊天、游戏、股票交易等场景。

#![allow(unused)]
fn main() {
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::sync::broadcast;
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::Mutex;
use base64::{Engine as _, engine::general_purpose};
use sha1::{Digest, Sha1};

const WEBSOCKET_GUID: &str = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";

#[derive(Debug, Clone)]
pub enum WebSocketMessage {
    Text(String),
    Binary(Vec<u8>),
    Close,
    Ping(Vec<u8>),
    Pong(Vec<u8>),
}

pub struct WebSocketServer {
    listener: TcpListener,
    clients: Arc<Mutex<HashMap<String, broadcast::Sender<WebSocketMessage>>>>,
    message_tx: broadcast::Sender<WebSocketMessage>,
}

impl WebSocketServer {
    pub async fn bind(addr: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let listener = TcpListener::bind(addr).await?;
        let (message_tx, _) = broadcast::channel(1000);
        
        Ok(WebSocketServer {
            listener,
            clients: Arc::new(Mutex::new(HashMap::new())),
            message_tx,
        })
    }
    
    pub async fn run(&self) -> Result<(), Box<dyn std::error::Error>> {
        println!("WebSocket Server listening on {}", self.listener.local_addr()?);
        
        loop {
            match self.listener.accept().await {
                Ok((stream, addr)) => {
                    let client_id = format!("{}", addr);
                    println!("New WebSocket client: {}", client_id);
                    
                    let clients = Arc::clone(&self.clients);
                    let message_tx = self.message_tx.clone();
                    
                    tokio::spawn(async move {
                        WebSocketServer::handle_websocket_client(stream, client_id, clients, message_tx).await
                    });
                }
                Err(e) => {
                    eprintln!("Failed to accept WebSocket connection: {}", e);
                }
            }
        }
    }
    
    async fn handle_websocket_client(
        stream: TcpStream,
        client_id: String,
        clients: Arc<Mutex<HashMap<String, broadcast::Sender<WebSocketMessage>>>>,
        message_tx: broadcast::Sender<WebSocketMessage>,
    ) {
        if let Err(e) = WebSocketServer::handle_connection(stream, &client_id, clients, message_tx).await {
            eprintln!("WebSocket error for client {}: {}", client_id, e);
        }
    }
    
    async fn handle_connection(
        stream: TcpStream,
        client_id: &str,
        clients: Arc<Mutex<HashMap<String, broadcast::Sender<WebSocketMessage>>>>,
        message_tx: broadcast::Sender<WebSocketMessage>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let (mut reader, mut writer) = stream.into_split();
        
        // 读取初始HTTP请求
        let mut buffer = String::new();
        reader.read_to_string(&mut buffer).await?;
        
        // 解析WebSocket握手请求
        let (key, response_key) = parse_websocket_handshake(&buffer)?;
        
        // 发送握手响应
        let handshake_response = format!(
            "HTTP/1.1 101 Switching Protocols\r\n\
             Upgrade: websocket\r\n\
             Connection: Upgrade\r\n\
             Sec-WebSocket-Accept: {}\r\n\
             \r\n",
            response_key
        );
        
        writer.write_all(handshake_response.as_bytes()).await?;
        
        // 创建客户端消息通道
        let (tx, mut rx) = broadcast::channel(100);
        {
            let mut clients = clients.lock().await;
            clients.insert(client_id.to_string(), tx);
        }
        
        // 读取WebSocket消息的异步任务
        let read_task = tokio::spawn(async move {
            let mut frame_buffer = vec![0u8; 4096];
            
            loop {
                match WebSocketFrame::read_frame(&mut reader, &mut frame_buffer).await {
                    Ok(Some(frame)) => {
                        match frame.opcode() {
                            0x8 => { // Close frame
                                break;
                            }
                            0x9 => { // Ping frame
                                let pong_frame = WebSocketFrame::pong(frame.payload());
                                if let Ok(data) = pong_frame.to_bytes() {
                                    let _ = writer.write_all(&data).await;
                                }
                            }
                            _ => {
                                // 处理其他帧类型
                                println!("Received frame: {:?}", frame.opcode());
                            }
                        }
                    }
                    Ok(None) => {
                        break;
                    }
                    Err(e) => {
                        eprintln!("Frame read error: {}", e);
                        break;
                    }
                }
            }
        });
        
        // 发送消息的异步任务
        let write_task = tokio::spawn(async move {
            while let Ok(message) = rx.recv().await {
                match message {
                    WebSocketMessage::Text(text) => {
                        let frame = WebSocketFrame::text(text.as_bytes());
                        if let Ok(data) = frame.to_bytes() {
                            if let Err(e) = writer.write_all(&data).await {
                                eprintln!("Failed to write WebSocket message: {}", e);
                                break;
                            }
                        }
                    }
                    WebSocketMessage::Binary(binary) => {
                        let frame = WebSocketFrame::binary(&binary);
                        if let Ok(data) = frame.to_bytes() {
                            if let Err(e) = writer.write_all(&data).await {
                                eprintln!("Failed to write WebSocket message: {}", e);
                                break;
                            }
                        }
                    }
                    WebSocketMessage::Close => {
                        let close_frame = WebSocketFrame::close();
                        if let Ok(data) = close_frame.to_bytes() {
                            let _ = writer.write_all(&data).await;
                        }
                        break;
                    }
                    _ => {
                        // 忽略ping/pong，它们在读取端处理
                    }
                }
            }
        });
        
        tokio::select! {
            result = read_task => {
                if let Err(e) = result {
                    eprintln!("Read task error: {}", e);
                }
            }
            result = write_task => {
                if let Err(e) = result {
                    eprintln!("Write task error: {}", e);
                }
            }
        }
        
        // 清理客户端
        {
            let mut clients = clients.lock().await;
            clients.remove(client_id);
        }
        
        Ok(())
    }
}

fn parse_websocket_handshake(request: &str) -> Result<(String, String), Box<dyn std::error::Error>> {
    let lines: Vec<&str> = request.split("\r\n").collect();
    
    // 查找Sec-WebSocket-Key
    let mut key = None;
    for line in &lines {
        if line.starts_with("Sec-WebSocket-Key:") {
            key = Some(line[19..].trim().to_string());
            break;
        }
    }
    
    let key = key.ok_or("Missing Sec-WebSocket-Key header")?;
    
    // 计算响应密钥
    let mut hasher = Sha1::new();
    hasher.update(key.as_bytes());
    hasher.update(WEBSOCKET_GUID.as_bytes());
    let hash = hasher.finalize();
    let response_key = general_purpose::STANDARD.encode(&hash);
    
    Ok((key, response_key))
}

struct WebSocketFrame {
    fin: bool,
    opcode: u8,
    mask: bool,
    payload: Vec<u8>,
}

impl WebSocketFrame {
    pub fn text(data: &[u8]) -> Self {
        WebSocketFrame {
            fin: true,
            opcode: 0x1,
            mask: true,
            payload: data.to_vec(),
        }
    }
    
    pub fn binary(data: &[u8]) -> Self {
        WebSocketFrame {
            fin: true,
            opcode: 0x2,
            mask: true,
            payload: data.to_vec(),
        }
    }
    
    pub fn close() -> Self {
        WebSocketFrame {
            fin: true,
            opcode: 0x8,
            mask: true,
            payload: vec![],
        }
    }
    
    pub fn pong(payload: &[u8]) -> Self {
        WebSocketFrame {
            fin: true,
            opcode: 0xA,
            mask: true,
            payload: payload.to_vec(),
        }
    }
    
    pub fn opcode(&self) -> u8 {
        self.opcode
    }
    
    pub fn payload(&self) -> &[u8] {
        &self.payload
    }
    
    pub async fn read_frame<R: AsyncReadExt>(
        reader: &mut R,
        buffer: &mut [u8],
    ) -> Result<Option<Self>, Box<dyn std::error::Error>> {
        let n = reader.read(buffer).await?;
        if n == 0 {
            return Ok(None);
        }
        
        if n < 2 {
            return Err("Insufficient data for WebSocket frame".into());
        }
        
        let first_byte = buffer[0];
        let second_byte = buffer[1];
        
        let fin = (first_byte & 0x80) != 0;
        let opcode = first_byte & 0x0F;
        let mask = (second_byte & 0x80) != 0;
        let mut payload_len = (second_byte & 0x7F) as usize;
        
        let mut offset = 2;
        
        // 处理扩展长度
        if payload_len == 126 {
            if n < offset + 2 {
                return Err("Insufficient data for extended payload length".into());
            }
            payload_len = ((buffer[offset] as usize) << 8) | (buffer[offset + 1] as usize);
            offset += 2;
        } else if payload_len == 127 {
            if n < offset + 8 {
                return Err("Insufficient data for extended payload length".into());
            }
            // 64位长度支持（这里简化处理）
            payload_len = ((buffer[offset + 4] as usize) << 24) | 
                         ((buffer[offset + 5] as usize) << 16) | 
                         ((buffer[offset + 6] as usize) << 8) | 
                          (buffer[offset + 7] as usize);
            offset += 8;
        }
        
        // 处理掩码
        let mut payload = vec![0u8; payload_len];
        if mask {
            if n < offset + 4 {
                return Err("Insufficient data for masking key".into());
            }
            let masking_key = &buffer[offset..offset + 4];
            offset += 4;
            
            if n < offset + payload_len {
                return Err("Insufficient data for payload".into());
            }
            
            for i in 0..payload_len {
                payload[i] = buffer[offset + i] ^ masking_key[i % 4];
            }
        } else {
            if n < offset + payload_len {
                return Err("Insufficient data for unmasked payload".into());
            }
            payload.copy_from_slice(&buffer[offset..offset + payload_len]);
        }
        
        Ok(Some(WebSocketFrame {
            fin,
            opcode,
            mask,
            payload,
        }))
    }
    
    pub fn to_bytes(&self) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let mut frame = Vec::new();
        
        // 第一个字节
        let mut first_byte = if self.fin { 0x80 } else { 0x00 } | (self.opcode & 0x0F);
        frame.push(first_byte);
        
        // 第二个字节
        let mut second_byte = if self.mask { 0x80 } else { 0x00 };
        
        let payload_len = self.payload.len();
        if payload_len < 126 {
            second_byte |= payload_len as u8;
            frame.push(second_byte);
        } else if payload_len <= 65535 {
            second_byte |= 126;
            frame.push(second_byte);
            frame.push((payload_len >> 8) as u8);
            frame.push(payload_len as u8);
        } else {
            second_byte |= 127;
            frame.push(second_byte);
            // 64位长度（简化）
            for i in (0..8).rev() {
                frame.push((payload_len >> (i * 8)) as u8);
            }
        }
        
        // 掩码密钥
        if self.mask {
            let masking_key = [0x12, 0x34, 0x56, 0x78]; // 固定掩码（实际应该随机生成）
            frame.extend_from_slice(&masking_key);
            
            for (i, byte) in self.payload.iter().enumerate() {
                frame.push(*byte ^ masking_key[i % 4]);
            }
        } else {
            frame.extend_from_slice(&self.payload);
        }
        
        Ok(frame)
    }
}

pub struct WebSocketClient {
    stream: TcpStream,
    server_url: String,
}

impl WebSocketClient {
    pub async fn connect(server_url: &str) -> Result<Self, Box<dyn std::error::Error>> {
        // 解析URL（简化版本）
        let url_parts: Vec<&str> = server_url.split('/').collect();
        let host = url_parts[2];
        let path = if url_parts.len() > 3 {
            format!("/{}", url_parts[3..].join("/"))
        } else {
            "/".to_string()
        };
        
        // 建立TCP连接
        let (host, port) = if host.contains(':') {
            let parts: Vec<&str> = host.split(':').collect();
            (parts[0].to_string(), parts[1].parse()?)
        } else {
            (host.to_string(), 80)
        };
        
        let stream = TcpStream::connect((host.as_str(), port))?;
        
        Ok(WebSocketClient {
            stream,
            server_url: server_url.to_string(),
        })
    }
    
    pub async fn handshake(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        // 生成随机密钥
        let key = generate_random_key();
        
        // 发送握手请求
        let handshake_request = format!(
            "GET {} HTTP/1.1\r\n\
             Host: {}\r\n\
             Upgrade: websocket\r\n\
             Connection: Upgrade\r\n\
             Sec-WebSocket-Key: {}\r\n\
             Sec-WebSocket-Version: 13\r\n\
             \r\n",
            self.extract_path()?,
            self.extract_host()?,
            key
        );
        
        self.stream.write_all(handshake_request.as_bytes())?;
        
        // 读取握手响应
        let mut response = String::new();
        self.stream.read_to_string(&mut response)?;
        
        if !response.contains("101 Switching Protocols") {
            return Err("WebSocket handshake failed".into());
        }
        
        Ok(())
    }
    
    pub async fn send_text(&mut self, text: &str) -> Result<(), Box<dyn std::error::Error>> {
        let frame = WebSocketFrame::text(text.as_bytes());
        let data = frame.to_bytes()?;
        self.stream.write_all(&data)?;
        Ok(())
    }
    
    pub async fn send_binary(&mut self, data: &[u8]) -> Result<(), Box<dyn std::error::Error>> {
        let frame = WebSocketFrame::binary(data);
        let data = frame.to_bytes()?;
        self.stream.write_all(&data)?;
        Ok(())
    }
    
    pub async fn receive(&mut self) -> Result<Option<WebSocketMessage>, Box<dyn std::error::Error>> {
        let mut buffer = vec![0u8; 4096];
        let n = self.stream.read(&mut buffer).await?;
        
        if n == 0 {
            return Ok(None);
        }
        
        let frame = WebSocketFrame::read_frame(&mut &buffer[..n]).await?;
        Ok(frame.map(|f| match f.opcode() {
            0x1 => WebSocketMessage::Text(String::from_utf8_lossy(f.payload()).to_string()),
            0x2 => WebSocketMessage::Binary(f.payload().to_vec()),
            0x8 => WebSocketMessage::Close,
            0x9 => WebSocketMessage::Ping(f.payload().to_vec()),
            0xA => WebSocketMessage::Pong(f.payload().to_vec()),
            _ => WebSocketMessage::Text(String::from_utf8_lossy(f.payload()).to_string()),
        }))
    }
    
    fn extract_host(&self) -> Result<String, Box<dyn std::error::Error>> {
        // 简化实现
        Ok("localhost".to_string())
    }
    
    fn extract_path(&self) -> Result<String, Box<dyn std::error::Error>> {
        // 简化实现
        Ok("/".to_string())
    }
}

fn generate_random_key() -> String {
    use rand::Rng;
    let mut rng = rand::thread_rng();
    let mut key = Vec::with_capacity(16);
    for _ in 0..16 {
        key.push(rng.gen::<u8>());
    }
    general_purpose::STANDARD.encode(&key)
}

#[cfg(test)]
mod websocket_tests {
    use super::*;
    use std::net::SocketAddr;
    use tokio::time::sleep;
    
    #[tokio::test]
    async fn test_websocket_echo() {
        // 这是一个端到端测试，需要服务器和客户端
        // 实际测试中需要启动WebSocket服务器和客户端
    }
}
}

10.5 序列化技术

10.5.1 JSON序列化

#![allow(unused)]
fn main() {
use serde::{Deserialize, Serialize};
use serde_json::{json, Value, Map};

#[derive(Debug, Serialize, Deserialize)]
pub struct User {
    pub id: u64,
    pub name: String,
    pub email: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<String>,
    pub timestamp: chrono::DateTime<chrono::Utc>,
}

impl<T> ApiResponse<T> {
    pub fn success(data: T) -> Self {
        ApiResponse {
            success: true,
            data: Some(data),
            error: None,
            timestamp: chrono::Utc::now(),
        }
    }
    
    pub fn error(message: String) -> ApiResponse<T> {
        ApiResponse {
            success: false,
            data: None,
            error: Some(message),
            timestamp: chrono::Utc::now(),
        }
    }
}

pub struct JsonSerializer {
    pretty_print: bool,
    null_value_handling: bool,
}

impl JsonSerializer {
    pub fn new() -> Self {
        JsonSerializer {
            pretty_print: false,
            null_value_handling: true,
        }
    }
    
    pub fn with_pretty_print(mut self, enable: bool) -> Self {
        self.pretty_print = enable;
        self
    }
    
    pub fn serialize<T: Serialize>(&self, data: &T) -> Result<String, Box<dyn std::error::Error>> {
        if self.pretty_print {
            Ok(serde_json::to_string_pretty(data)?)
        } else {
            Ok(serde_json::to_string(data)?)
        }
    }
    
    pub fn deserialize<T: DeserializeOwned>(&self, json: &str) -> Result<T, Box<dyn std::error::Error>> {
        Ok(serde_json::from_str(json)?)
    }
    
    pub fn serialize_to_bytes<T: Serialize>(&self, data: &T) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        Ok(serde_json::to_vec(data)?)
    }
    
    pub fn deserialize_from_bytes<T: DeserializeOwned>(&self, bytes: &[u8]) -> Result<T, Box<dyn std::error::Error>> {
        Ok(serde_json::from_slice(bytes)?)
    }
}

// 自定义序列化器用于处理复杂的JSON结构
pub struct DynamicJsonHandler {
    serializer: JsonSerializer,
}

impl DynamicJsonHandler {
    pub fn new() -> Self {
        DynamicJsonHandler {
            serializer: JsonSerializer::new(),
        }
    }
    
    pub fn create_nested_object(&self, fields: Vec<(String, Value)>) -> Value {
        let mut map = Map::new();
        for (key, value) in fields {
            map.insert(key, value);
        }
        Value::Object(map)
    }
    
    pub fn create_array(&self, items: Vec<Value>) -> Value {
        Value::Array(items)
    }
    
    pub fn transform_json(&self, input: &Value, transformer: fn(&Value) -> Value) -> Result<String, Box<dyn std::error::Error>> {
        let transformed = transformer(input);
        Ok(self.serializer.serialize(&transformed)?)
    }
}

use serde::de::DeserializeOwned;

#[cfg(test)]
mod json_tests {
    use super::*;
    
    #[test]
    fn test_user_serialization() {
        let user = User {
            id: 1,
            name: "John Doe".to_string(),
            email: "john@example.com".to_string(),
            created_at: chrono::Utc::now(),
        };
        
        let serializer = JsonSerializer::new();
        let json = serializer.serialize(&user).unwrap();
        let deserialized: User = serializer.deserialize(&json).unwrap();
        
        assert_eq!(user.id, deserialized.id);
        assert_eq!(user.name, deserialized.name);
        assert_eq!(user.email, deserialized.email);
    }
    
    #[test]
    fn test_api_response() {
        let response = ApiResponse::success("Hello, World!");
        let json = serde_json::to_string(&response).unwrap();
        let parsed: ApiResponse<String> = serde_json::from_str(&json).unwrap();
        
        assert!(parsed.success);
        assert_eq!(parsed.data, Some("Hello, World!".to_string()));
    }
}
}

10.5.2 MessagePack序列化

#![allow(unused)]
fn main() {
use rmp_serde::{Deserializer, Serializer};
use serde::{Deserialize, Serialize};

pub struct MessagePackSerializer;

impl MessagePackSerializer {
    pub fn serialize<T: Serialize>(&self, data: &T) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let mut buf = Vec::new();
        data.serialize(&mut Serializer::new(&mut buf).with_bin_config()
            .with_struct_map()
            .with_human_readable())?;
        Ok(buf)
    }
    
    pub fn deserialize<T: DeserializeOwned>(&self, data: &[u8]) -> Result<T, Box<dyn std::error::Error>> {
        let mut deserializer = Deserializer::new(data);
        Ok(T::deserialize(&mut deserializer)?)
    }
    
    pub fn serialize_to_writer<T: Serialize, W: std::io::Write>(
        &self,
        data: &T,
        writer: W,
    ) -> Result<(), Box<dyn std::error::Error>> {
        let mut serializer = Serializer::new(writer)
            .with_bin_config()
            .with_struct_map()
            .with_human_readable();
        data.serialize(&mut serializer)?;
        Ok(())
    }
    
    pub fn deserialize_from_reader<T: DeserializeOwned, R: std::io::Read>(
        &self,
        reader: R,
    ) -> Result<T, Box<dyn std::error::Error>> {
        let mut deserializer = Deserializer::new(reader);
        Ok(T::deserialize(&mut deserializer)?)
    }
}

// 高性能二进制协议
pub struct BinaryProtocol {
    serializer: MessagePackSerializer,
    compression: bool,
}

impl BinaryProtocol {
    pub fn new() -> Self {
        BinaryProtocol {
            serializer: MessagePackSerializer,
            compression: false,
        }
    }
    
    pub fn with_compression(mut self, enable: bool) -> Self {
        self.compression = enable;
        self
    }
    
    pub fn encode_message<T: Serialize>(&self, message_id: u16, data: &T) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let payload = self.serializer.serialize(data)?;
        let payload = if self.compression {
            self.compress_data(&payload)?
        } else {
            payload
        };
        
        // 创建消息头
        let mut message = vec![0u8; 4 + payload.len()];
        
        // 消息ID (2字节)
        message[0] = (message_id >> 8) as u8;
        message[1] = (message_id & 0xFF) as u8;
        
        // 消息长度 (2字节)
        let length = payload.len() as u16;
        message[2] = (length >> 8) as u8;
        message[3] = (length & 0xFF) as u8;
        
        // 负载数据
        message[4..].copy_from_slice(&payload);
        
        Ok(message)
    }
    
    pub fn decode_message<T: DeserializeOwned>(&self, data: &[u8]) -> Result<(u16, T), Box<dyn std::error::Error>> {
        if data.len() < 4 {
            return Err("Message too short".into());
        }
        
        // 解析消息头
        let message_id = ((data[0] as u16) << 8) | (data[1] as u16);
        let length = ((data[2] as u16) << 8) | (data[3] as u16);
        
        if data.len() < 4 + length as usize {
            return Err("Message length mismatch".into());
        }
        
        let payload = &data[4..4 + length as usize];
        let payload = if self.compression {
            self.decompress_data(payload)?
        } else {
            payload.to_vec()
        };
        
        let data = self.serializer.deserialize(&payload)?;
        Ok((message_id, data))
    }
    
    fn compress_data(&self, data: &[u8]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        // 使用flate2进行压缩
        useflate2::{Compression, Compress, Decompress};
        
        let mut compressed = Vec::new();
        let mut encoder = Compress::new(Compression::fast(), true);
        
        let status = encoder.compress_vec(data, &mut compressed)?;
        if status != flate2::Status::StreamEnd {
            return Err("Compression failed".into());
        }
        
        Ok(compressed)
    }
    
    fn decompress_data(&self, data: &[u8]) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        use flate2::Decompress;
        
        let mut decompressed = Vec::new();
        let mut decoder = Decompress::new(true);
        
        let status = decoder.decompress_vec(data, &mut decompressed)?;
        if status != flate2::Status::StreamEnd && status != flate2::Status::BufExhausted {
            return Err("Decompression failed".into());
        }
        
        Ok(decompressed)
    }
}

#[derive(Serialize, Deserialize, Debug)]
pub struct NetworkMessage {
    pub id: u16,
    pub message_type: MessageType,
    pub data: MessageData,
    pub timestamp: chrono::DateTime<chrono::Utc>,
    pub sequence_number: u64,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(tag = "type")]
pub enum MessageType {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "binary")]
    Binary,
    #[serde(rename = "command")]
    Command,
    #[serde(rename = "notification")]
    Notification,
}

#[derive(Serialize, Deserialize, Debug)]
#[serde(tag = "data_type")]
pub enum MessageData {
    #[serde(rename = "string")]
    StringData { value: String },
    #[serde(rename = "bytes")]
    BinaryData { value: Vec<u8> },
    #[serde(rename = "number")]
    NumberData { value: f64 },
    #[serde(rename = "object")]
    ObjectData { value: Map<String, Value> },
}

#[cfg(test)]
mod msgpack_tests {
    use super::*;
    
    #[test]
    fn test_msgpack_serialization() {
        let message = NetworkMessage {
            id: 1,
            message_type: MessageType::Text,
            data: MessageData::StringData { 
                value: "Hello, MessagePack!".to_string() 
            },
            timestamp: chrono::Utc::now(),
            sequence_number: 1,
        };
        
        let serializer = MessagePackSerializer;
        let bytes = serializer.serialize(&message).unwrap();
        let deserialized: NetworkMessage = serializer.deserialize(&bytes).unwrap();
        
        assert_eq!(message.id, deserialized.id);
        assert_eq!(message.sequence_number, deserialized.sequence_number);
    }
    
    #[test]
    fn test_binary_protocol() {
        let protocol = BinaryProtocol::new();
        let message = "Test message".to_string();
        
        let encoded = protocol.encode_message(1, &message).unwrap();
        let (message_id, decoded): (u16, String) = protocol.decode_message(&encoded).unwrap();
        
        assert_eq!(message_id, 1);
        assert_eq!(message, decoded);
    }
}
}

10.6 企业级分布式聊天系统

现在我们来构建一个完整的分布式聊天系统，集成所有学到的网络编程技术。

#![allow(unused)]
fn main() {
// 分布式聊天系统主项目文件
// File: chat-system/Cargo.toml
/*
[package]
name = "distributed-chat-system"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
rmp-serde = "1.0"
chrono = { version = "0.4", features = ["serde"] }
uuid = { version = "1.0", features = ["v4", "serde"] }
tokio-rustls = "0.23"
rustls = "0.21"
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "uuid", "chrono", "json"] }
redis = { version = "0.23", features = ["tokio-comp"] }
*/

// 消息定义模块
// File: chat-system/src/messages.rs
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use chrono::{DateTime, Utc};
use uuid::Uuid;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageType {
    #[serde(rename = "text")]
    Text,
    #[serde(rename = "image")]
    Image,
    #[serde(rename = "file")]
    File,
    #[serde(rename = "system")]
    System,
    #[serde(rename = "typing")]
    Typing,
    #[serde(rename = "presence")]
    Presence,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MessageStatus {
    #[serde(rename = "sending")]
    Sending,
    #[serde(rename = "sent")]
    Sent,
    #[serde(rename = "delivered")]
    Delivered,
    #[serde(rename = "read")]
    Read,
    #[serde(rename = "failed")]
    Failed,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub username: String,
    pub display_name: String,
    pub avatar_url: Option<String>,
    pub is_online: bool,
    pub last_seen: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Room {
    pub id: Uuid,
    pub name: String,
    pub description: Option<String>,
    pub room_type: RoomType,
    pub is_private: bool,
    pub members: Vec<Uuid>,
    pub created_by: Uuid,
    pub created_at: DateTime<Utc>,
    pub last_message_at: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum RoomType {
    Private,
    Group,
    Public,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ChatMessage {
    pub id: Uuid,
    pub room_id: Uuid,
    pub sender_id: Uuid,
    pub message_type: MessageType,
    pub content: String,
    pub metadata: HashMap<String, serde_json::Value>,
    pub reply_to: Option<Uuid>,
    pub status: MessageStatus,
    pub created_at: DateTime<Utc>,
    pub edited_at: Option<DateTime<Utc>>,
    pub delivered_to: Vec<Uuid>,
    pub read_by: Vec<Uuid>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WebSocketMessage {
    pub id: Uuid,
    pub message_type: WebSocketMessageType,
    pub data: serde_json::Value,
    pub timestamp: DateTime<Utc>,
    pub sequence: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum WebSocketMessageType {
    Connect { user_id: Uuid },
    Disconnect { user_id: Uuid },
    JoinRoom { room_id: Uuid, user_id: Uuid },
    LeaveRoom { room_id: Uuid, user_id: Uuid },
    SendMessage(ChatMessage),
    MessageStatus { message_id: Uuid, status: MessageStatus },
    Typing { room_id: Uuid, user_id: Uuid, is_typing: bool },
    Presence { user_id: Uuid, is_online: bool },
    Error { code: String, message: String },
    Pong,
}

// 协议定义
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProtocolMessage {
    pub version: String,
    pub message_id: Uuid,
    pub correlation_id: Option<Uuid>,
    pub timestamp: DateTime<Utc>,
    pub data: MessageData,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum MessageData {
    AuthRequest { username: String, password_hash: String },
    AuthResponse { success: bool, token: Option<String>, user: Option<User> },
    RegisterRequest { username: String, email: String, password_hash: String },
    RoomListRequest,
    RoomListResponse { rooms: Vec<Room> },
    JoinRoomRequest { room_id: Uuid },
    LeaveRoomRequest { room_id: Uuid },
    SendMessageRequest { room_id: Uuid, content: String, message_type: MessageType },
    MessageReceived { message: ChatMessage },
    UserListRequest,
    UserListResponse { users: Vec<User> },
    Heartbeat,
    HeartbeatResponse,
    Error { code: String, message: String, details: Option<serde_json::Value> },
}

// HTTP API 结构
#[derive(Debug, Serialize, Deserialize)]
pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<String>,
    pub timestamp: DateTime<Utc>,
    pub request_id: Uuid,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateRoomRequest {
    pub name: String,
    pub description: Option<String>,
    pub room_type: RoomType,
    pub is_private: bool,
    pub members: Vec<Uuid>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct SendMessageRequest {
    pub content: String,
    pub message_type: MessageType,
    pub reply_to: Option<Uuid>,
    pub metadata: HashMap<String, serde_json::Value>,
}

// 错误定义
#[derive(Debug, Serialize, Deserialize)]
pub struct ChatError {
    pub code: String,
    pub message: String,
    pub details: Option<serde_json::Value>,
}

impl ChatError {
    pub fn new(code: impl Into<String>, message: impl Into<String>) -> Self {
        ChatError {
            code: code.into(),
            message: message.into(),
            details: None,
        }
    }
    
    pub fn with_details(mut self, details: serde_json::Value) -> Self {
        self.details = Some(details);
        self
    }
}

// 常用的错误类型
pub const ERROR_USER_NOT_FOUND: &str = "USER_NOT_FOUND";
pub const ERROR_ROOM_NOT_FOUND: &str = "ROOM_NOT_FOUND";
pub const ERROR_MESSAGE_NOT_FOUND: &str = "MESSAGE_NOT_FOUND";
pub const ERROR_UNAUTHORIZED: &str = "UNAUTHORIZED";
pub const ERROR_FORBIDDEN: &str = "FORBIDDEN";
pub const ERROR_INVALID_MESSAGE: &str = "INVALID_MESSAGE";
pub const ERROR_RATE_LIMIT: &str = "RATE_LIMIT";
pub const ERROR_USER_OFFLINE: &str = "USER_OFFLINE";
}

#![allow(unused)]
fn main() {
// WebSocket服务器模块
// File: chat-system/src/websocket_server.rs
use super::messages::*;
use super::database::Database;
use super::redis_cache::RedisCache;
use tokio::net::{TcpListener, TcpStream};
use tokio::sync::{mpsc, broadcast, oneshot, Arc, Mutex};
use tokio::time::{timeout, Duration};
use std::collections::HashMap;
use std::sync::atomic::{AtomicU64, Ordering};
use tracing::{info, warn, error, instrument};
use uuid::Uuid;

#[derive(Clone)]
pub struct WebSocketServerConfig {
    pub max_connections: usize,
    pub heartbeat_interval: Duration,
    pub message_buffer_size: usize,
    pub rate_limit_per_minute: u32,
}

impl Default for WebSocketServerConfig {
    fn default() -> Self {
        WebSocketServerConfig {
            max_connections: 10000,
            heartbeat_interval: Duration::from_secs(30),
            message_buffer_size: 1000,
            rate_limit_per_minute: 100,
        }
    }
}

pub struct ConnectedClient {
    pub user_id: Uuid,
    pub stream: TcpStream,
    pub last_heartbeat: std::time::Instant,
    pub rooms: HashMap<Uuid, broadcast::Receiver<ChatMessage>>,
    pub rate_limiter: RateLimiter,
    pub sequence: Arc<AtomicU64>,
}

pub struct RateLimiter {
    messages: Arc<Mutex<Vec<std::time::Instant>>>,
    max_per_minute: u32,
}

impl RateLimiter {
    pub fn new(max_per_minute: u32) -> Self {
        RateLimiter {
            messages: Arc::        RateLimiter {
            messages: Arc::new(Mutex::new(Vec::new())),
            max_per_minute,
        }
    }
    
    pub async fn allow_message(&self) -> bool {
        let mut messages = self.messages.lock().await;
        let now = std::time::Instant::now();
        let one_minute_ago = now - Duration::from_secs(60);
        
        // 清理一分钟前的消息
        messages.retain(|&time| time > one_minute_ago);
        
        if messages.len() < self.max_per_minute as usize {
            messages.push(now);
            true
        } else {
            false
        }
    }
}

pub struct WebSocketServer {
    config: WebSocketServerConfig,
    clients: Arc<Mutex<HashMap<Uuid, ConnectedClient>>>,
    database: Database,
    redis: RedisCache,
    message_sender: broadcast::Sender<WebSocketMessage>,
    shutdown: Arc<Mutex<Option<oneshot::Sender<()>>>>,
}

impl WebSocketServer {
    pub fn new(
        config: WebSocketServerConfig,
        database: Database,
        redis: RedisCache,
    ) -> Self {
        let (message_sender, _) = broadcast::channel(config.message_buffer_size);
        
        WebSocketServer {
            config,
            clients: Arc::new(Mutex::new(HashMap::new())),
            database,
            redis,
            message_sender,
            shutdown: Arc::new(Mutex::new(None)),
        }
    }
    
    #[instrument(skip(self))]
    pub async fn run(self, addr: &str) -> Result<(), Box<dyn std::error::Error>> {
        let listener = TcpListener::bind(addr).await?;
        info!("WebSocket server listening on {}", addr);
        
        // 启动后台任务
        let shutdown_signal = self.start_background_tasks().await?;
        
        // 启动关闭处理
        let shutdown = self.shutdown.clone();
        tokio::spawn(async move {
            shutdown.lock().await.as_ref().unwrap().send(()).ok();
        });
        
        // 处理连接
        loop {
            match timeout(Duration::from_secs(1), listener.accept()).await {
                Ok(Ok((stream, peer_addr))) => {
                    info!("New WebSocket connection from {}", peer_addr);
                    
                    let clients = Arc::clone(&self.clients);
                    let server = self.clone();
                    
                    tokio::spawn(async move {
                        if let Err(e) = server.handle_connection(stream, peer_addr).await {
                            error!("Connection handling error: {}", e);
                        }
                    });
                }
                Ok(Err(e)) => {
                    warn!("Failed to accept connection: {}", e);
                }
                Err(_) => {
                    // 超时检查关闭信号
                    let shutdown_rx = shutdown_signal.clone();
                    if let Some(mut rx) = shutdown_rx {
                        if let Ok(_) = rx.try_recv() {
                            info!("Shutting down WebSocket server");
                            break;
                        }
                    }
                }
            }
        }
        
        Ok(())
    }
    
    async fn start_background_tasks(&self) -> Result<oneshot::Receiver<()>, Box<dyn std::error::Error>> {
        let (tx, rx) = oneshot::channel();
        *self.shutdown.lock().await = Some(tx);
        
        // 启动心跳任务
        {
            let clients = Arc::clone(&self.clients);
            let config = self.config.clone();
            tokio::spawn(async move {
                let mut interval = tokio::time::interval(config.heartbeat_interval);
                loop {
                    interval.tick().await;
                    
                    let mut disconnected = Vec::new();
                    {
                        let clients_guard = clients.lock().await;
                        for (user_id, client) in clients_guard.iter() {
                            if client.last_heartbeat.elapsed() > config.heartbeat_interval * 2 {
                                disconnected.push(*user_id);
                            }
                        }
                    }
                    
                    for user_id in disconnected {
                        let mut clients = clients.lock().await;
                        if let Some(client) = clients.remove(&user_id) {
                            info!("Client {} timed out", user_id);
                            
                            // 更新用户状态
                            drop(client);
                        }
                    }
                }
            });
        }
        
        // 启动消息分发任务
        {
            let message_rx = self.message_sender.subscribe();
            let clients = Arc::clone(&self.clients);
            tokio::spawn(async move {
                let mut message_rx = message_rx;
                loop {
                    if let Ok(message) = message_rx.recv().await {
                        let clients = clients.lock().await;
                        
                        match &message.message_type {
                            WebSocketMessageType::SendMessage(msg) => {
                                // 分发消息给房间成员
                                let room_members = clients.values()
                                    .filter(|client| client.rooms.contains_key(&msg.room_id))
                                    .collect::<Vec<_>>();
                                
                                for client in room_members {
                                    // 发送消息到客户端的消息通道
                                    // 实现细节...
                                }
                            }
                            _ => {}
                        }
                    }
                }
            });
        }
        
        Ok(rx)
    }
    
    #[instrument(skip(self, stream))]
    async fn handle_connection(&self, stream: TcpStream, peer_addr: std::net::SocketAddr) -> Result<(), Box<dyn std::error::Error>> {
        // 读取WebSocket握手请求
        let (mut reader, mut writer) = stream.into_split();
        let mut buffer = String::new();
        reader.read_to_string(&mut buffer).await?;
        
        // 解析握手
        let (key, response_key) = parse_websocket_handshake(&buffer)?;
        
        // 验证用户身份（简化版）
        // 实际实现中应该验证JWT token或session
        let user_id = self.authenticate_user(&buffer).await?;
        
        if user_id.is_none() {
            return Err("Authentication failed".into());
        }
        
        let user_id = user_id.unwrap();
        
        // 发送握手响应
        let handshake_response = format!(
            "HTTP/1.1 101 Switching Protocols\r\n\
             Upgrade: websocket\r\n\
             Connection: Upgrade\r\n\
             Sec-WebSocket-Accept: {}\r\n\
             \r\n",
            response_key
        );
        
        writer.write_all(handshake_response.as_bytes()).await?;
        
        // 创建客户端实例
        let client = ConnectedClient {
            user_id,
            stream: TcpStream::from_std(writer.into_inner())?,
            last_heartbeat: std::time::Instant::now(),
            rooms: HashMap::new(),
            rate_limiter: RateLimiter::new(self.config.rate_limit_per_minute),
            sequence: Arc::new(AtomicU64::new(0)),
        };
        
        // 添加到客户端集合
        {
            let mut clients = self.clients.lock().await;
            if clients.len() >= self.config.max_connections {
                return Err("Maximum connections reached".into());
            }
            clients.insert(user_id, client);
        }
        
        // 处理客户端消息
        self.handle_client_messages(user_id).await?;
        
        Ok(())
    }
    
    async fn authenticate_user(&self, request: &str) -> Result<Option<Uuid>, Box<dyn std::error::Error>> {
        // 解析认证头或token
        // 这里简化处理，实际应该验证JWT
        if request.contains("Authorization: Bearer valid_token") {
            // 返回示例用户ID
            Ok(Some(Uuid::new_v4()))
        } else {
            Ok(None)
        }
    }
    
    async fn handle_client_messages(&self, user_id: Uuid) -> Result<(), Box<dyn std::error::Error>> {
        let clients = Arc::clone(&self.clients);
        let mut clients_guard = clients.lock().await;
        
        if let Some(client) = clients_guard.get_mut(&user_id) {
            // 处理客户端消息循环
            let mut buffer = vec![0u8; 4096];
            
            loop {
                match WebSocketFrame::read_frame(&mut &client.stream, &mut buffer).await {
                    Ok(Some(frame)) => {
                        client.last_heartbeat = std::time::Instant::now();
                        
                        match frame.opcode() {
                            0x8 => { // Close frame
                                break;
                            }
                            0x9 => { // Ping frame
                                let pong_frame = WebSocketFrame::pong(frame.payload());
                                if let Ok(data) = pong_frame.to_bytes() {
                                    let _ = client.stream.write_all(&data).await;
                                }
                            }
                            0xA => { // Pong frame
                                // 更新最后心跳时间
                            }
                            0x1 | 0x2 => { // Text or Binary frame
                                if let Ok(message) = self.process_message(&user_id, frame.payload()).await {
                                    let _ = self.message_sender.send(message);
                                }
                            }
                            _ => {
                                warn!("Unknown frame opcode: {}", frame.opcode());
                            }
                        }
                    }
                    Ok(None) => {
                        break;
                    }
                    Err(e) => {
                        error!("Frame read error: {}", e);
                        break;
                    }
                }
            }
        }
        
        Ok(())
    }
    
    async fn process_message(&self, user_id: &Uuid, payload: &[u8]) -> Result<WebSocketMessage, Box<dyn std::error::Error>> {
        // 解析客户端消息
        let protocol_message: ProtocolMessage = serde_json::from_slice(payload)?;
        
        match &protocol_message.data {
            MessageData::AuthRequest { .. } => {
                // 处理认证请求
                self.handle_auth_request(user_id, &protocol_message).await
            }
            MessageData::JoinRoomRequest { room_id } => {
                self.handle_join_room(user_id, room_id, &protocol_message).await
            }
            MessageData::LeaveRoomRequest { room_id } => {
                self.handle_leave_room(user_id, room_id, &protocol_message).await
            }
            MessageData::SendMessageRequest { room_id, content, message_type } => {
                self.handle_send_message(user_id, room_id, content, message_type, &protocol_message).await
            }
            MessageData::Heartbeat => {
                Ok(WebSocketMessage {
                    id: Uuid::new_v4(),
                    message_type: WebSocketMessageType::Pong,
                    data: serde_json::Value::Null,
                    timestamp: Utc::now(),
                    sequence: 0,
                })
            }
            _ => {
                Ok(WebSocketMessage {
                    id: Uuid::new_v4(),
                    message_type: WebSocketMessageType::Error { 
                        code: "UNKNOWN_MESSAGE".to_string(), 
                        message: "Unknown message type".to_string() 
                    },
                    data: serde_json::Value::Null,
                    timestamp: Utc::now(),
                    sequence: 0,
                })
            }
        }
    }
    
    async fn handle_auth_request(
        &self,
        user_id: &Uuid,
        protocol_message: &ProtocolMessage,
    ) -> Result<WebSocketMessage, Box<dyn std::error::Error>> {
        // 从数据库获取用户信息
        let user = self.database.get_user(user_id).await?;
        
        match user {
            Some(user) => {
                // 发送认证成功响应
                let response = MessageData::AuthResponse {
                    success: true,
                    token: Some("jwt_token_here".to_string()),
                    user: Some(user),
                };
                
                Ok(WebSocketMessage {
                    id: protocol_message.message_id,
                    message_type: WebSocketMessageType::Connect { user_id: *user_id },
                    data: serde_json::to_value(response)?,
                    timestamp: Utc::now(),
                    sequence: 0,
                })
            }
            None => {
                let error = MessageData::Error {
                    code: ERROR_USER_NOT_FOUND.to_string(),
                    message: "User not found".to_string(),
                    details: None,
                };
                
                Ok(WebSocketMessage {
                    id: protocol_message.message_id,
                    message_type: WebSocketMessageType::Error { 
                        code: ERROR_USER_NOT_FOUND.to_string(), 
                        message: "User not found".to_string() 
                    },
                    data: serde_json::to_value(error)?,
                    timestamp: Utc::now(),
                    sequence: 0,
                })
            }
        }
    }
    
    async fn handle_join_room(
        &self,
        user_id: &Uuid,
        room_id: &Uuid,
        protocol_message: &ProtocolMessage,
    ) -> Result<WebSocketMessage, Box<dyn std::error::Error>> {
        // 检查用户是否有权限加入房间
        let has_permission = self.database.check_room_permission(user_id, room_id).await?;
        
        if !has_permission {
            let error = MessageData::Error {
                code: ERROR_FORBIDDEN.to_string(),
                message: "Permission denied".to_string(),
                details: None,
            };
            
            return Ok(WebSocketMessage {
                id: protocol_message.message_id,
                message_type: WebSocketMessageType::Error { 
                    code: ERROR_FORBIDDEN.to_string(), 
                    message: "Permission denied".to_string() 
                },
                data: serde_json::to_value(error)?,
                timestamp: Utc::now(),
                sequence: 0,
            });
        }
        
        // 添加用户到房间
        self.database.add_user_to_room(user_id, room_id).await?;
        
        // 通知其他房间成员
        let join_notification = WebSocketMessage {
            id: Uuid::new_v4(),
            message_type: WebSocketMessageType::JoinRoom { 
                room_id: *room_id, 
                user_id: *user_id 
            },
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        };
        
        self.message_sender.send(join_notification)?;
        
        Ok(WebSocketMessage {
            id: protocol_message.message_id,
            message_type: WebSocketMessageType::JoinRoom { 
                room_id: *room_id, 
                user_id: *user_id 
            },
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        })
    }
    
    async fn handle_leave_room(
        &self,
        user_id: &Uuid,
        room_id: &Uuid,
        protocol_message: &ProtocolMessage,
    ) -> Result<WebSocketMessage, Box<dyn std::error::Error>> {
        // 从房间移除用户
        self.database.remove_user_from_room(user_id, room_id).await?;
        
        // 通知其他房间成员
        let leave_notification = WebSocketMessage {
            id: Uuid::new_v4(),
            message_type: WebSocketMessageType::LeaveRoom { 
                room_id: *room_id, 
                user_id: *user_id 
            },
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        };
        
        self.message_sender.send(leave_notification)?;
        
        Ok(WebSocketMessage {
            id: protocol_message.message_id,
            message_type: WebSocketMessageType::LeaveRoom { 
                room_id: *room_id, 
                user_id: *user_id 
            },
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        })
    }
    
    async fn handle_send_message(
        &self,
        user_id: &Uuid,
        room_id: &Uuid,
        content: &str,
        message_type: &MessageType,
        protocol_message: &ProtocolMessage,
    ) -> Result<WebSocketMessage, Box<dyn std::error::Error>> {
        // 创建消息
        let message = ChatMessage {
            id: Uuid::new_v4(),
            room_id: *room_id,
            sender_id: *user_id,
            message_type: message_type.clone(),
            content: content.to_string(),
            metadata: HashMap::new(),
            reply_to: None,
            status: MessageStatus::Sending,
            created_at: Utc::now(),
            edited_at: None,
            delivered_to: vec![],
            read_by: vec![*user_id],
        };
        
        // 保存到数据库
        self.database.save_message(&message).await?;
        
        // 更新消息状态
        let mut message = message;
        message.status = MessageStatus::Sent;
        message.delivered_to = self.database.get_room_members(room_id).await?;
        
        // 发送消息给房间成员
        let ws_message = WebSocketMessage {
            id: Uuid::new_v4(),
            message_type: WebSocketMessageType::SendMessage(message.clone()),
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        };
        
        self.message_sender.send(ws_message)?;
        
        Ok(WebSocketMessage {
            id: protocol_message.message_id,
            message_type: WebSocketMessageType::SendMessage(message),
            data: serde_json::Value::Null,
            timestamp: Utc::now(),
            sequence: 0,
        })
    }
}

impl Clone for WebSocketServer {
    fn clone(&self) -> Self {
        WebSocketServer {
            config: self.config.clone(),
            clients: Arc::clone(&self.clients),
            database: self.database.clone(),
            redis: self.redis.clone(),
            message_sender: self.message_sender.clone(),
            shutdown: Arc::clone(&self.shutdown),
        }
    }
}
}

#![allow(unused)]
fn main() {
// HTTP API服务器模块
// File: chat-system/src/http_server.rs
use super::messages::*;
use super::websocket_server::WebSocketServer;
use super::database::Database;
use super::redis_cache::RedisCache;
use tokio::net::{TcpListener, TcpStream};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::Mutex;
use tracing::{info, warn, error, instrument};

pub struct HttpServer {
    listener: TcpListener,
    database: Database,
    redis: RedisCache,
    websocket_server: WebSocketServer,
}

impl HttpServer {
    pub fn new(
        database: Database,
        redis: RedisCache,
        websocket_server: WebSocketServer,
    ) -> Self {
        HttpServer {
            listener: TcpListener::bind("0.0.0.0:8080").await.unwrap(),
            database,
            redis,
            websocket_server,
        }
    }
    
    pub async fn run(self) -> Result<(), Box<dyn std::error::Error>> {
        info!("HTTP API server starting on port 8080");
        
        loop {
            match self.listener.accept().await {
                Ok((stream, addr)) => {
                    info!("New HTTP request from {}", addr);
                    
                    let database = self.database.clone();
                    let redis = self.redis.clone();
                    
                    tokio::spawn(async move {
                        handle_http_request(stream, database, redis).await
                    });
                }
                Err(e) => {
                    warn!("Failed to accept HTTP connection: {}", e);
                }
            }
        }
    }
}

#[instrument(skip(stream, database, redis))]
async fn handle_http_request(
    stream: TcpStream,
    database: Database,
    redis: RedisCache,
) {
    let (mut reader, mut writer) = stream.into_split();
    let mut buffer = String::new();
    
    if let Err(e) = reader.read_to_string(&mut buffer).await {
        error!("Failed to read HTTP request: {}", e);
        return;
    }
    
    match parse_http_request(&buffer) {
        Ok((method, path, headers, body)) => {
            match handle_route(&method, &path, &headers, &body, &database, &redis).await {
                Ok(response) => {
                    if let Err(e) = writer.write_all(response.as_bytes()).await {
                        error!("Failed to send HTTP response: {}", e);
                    }
                }
                Err(e) => {
                    error!("Route handling error: {}", e);
                    let error_response = create_error_response(500, &format!("Internal server error: {}", e));
                    let _ = writer.write_all(error_response.as_bytes()).await;
                }
            }
        }
        Err(e) => {
            error!("Failed to parse HTTP request: {}", e);
            let error_response = create_error_response(400, "Bad request");
            let _ = writer.write_all(error_response.as_bytes()).await;
        }
    }
}

fn parse_http_request(request: &str) -> Result<(String, String, HashMap<String, String>, String), Box<dyn std::error::Error>> {
    let lines: Vec<&str> = request.split("\r\n").collect();
    
    if lines.is_empty() {
        return Err("Empty request".into());
    }
    
    // 解析请求行
    let request_line = lines[0];
    let parts: Vec<&str> = request_line.split(' ').collect();
    if parts.len() != 3 {
        return Err("Invalid request line".into());
    }
    
    let method = parts[0].to_string();
    let path = parts[1].to_string();
    
    // 解析头部
    let mut headers = HashMap::new();
    let mut body = String::new();
    let mut in_headers = true;
    
    for line in &lines[1..] {
        if line.is_empty() {
            in_headers = false;
            continue;
        }
        
        if in_headers {
            if let Some(colon_pos) = line.find(':') {
                let key = line[..colon_pos].trim().to_string();
                let value = line[colon_pos + 1..].trim().to_string();
                headers.insert(key, value);
            }
        } else {
            body.push_str(line);
        }
    }
    
    Ok((method, path, headers, body))
}

async fn handle_route(
    method: &str,
    path: &str,
    headers: &HashMap<String, String>,
    body: &str,
    database: &Database,
    redis: &RedisCache,
) -> Result<String, Box<dyn std::error::Error>> {
    let content_type = headers.get("Content-Type").unwrap_or(&"application/json".to_string());
    
    match (method, path) {
        ("GET", "/") => Ok(create_json_response(200, json!({
            "message": "Distributed Chat System API",
            "version": "1.0.0",
            "endpoints": ["/api/users", "/api/rooms", "/api/messages"]
        }))),
        
        ("GET", "/health") => Ok(create_json_response(200, json!({
            "status": "healthy",
            "timestamp": Utc::now().to_rfc3339()
        }))),
        
        // 用户管理
        ("GET", "/api/users") => {
            let users = database.get_all_users().await?;
            Ok(create_json_response(200, ApiResponse {
                success: true,
                data: Some(users),
                error: None,
                timestamp: Utc::now(),
                request_id: Uuid::new_v4(),
            }))
        },
        
        ("POST", "/api/users") if content_type == "application/json" => {
            let user_data: CreateUserRequest = serde_json::from_str(body)?;
            let user = database.create_user(&user_data).await?;
            Ok(create_json_response(201, ApiResponse {
                success: true,
                data: Some(user),
                error: None,
                timestamp: Utc::now(),
                request_id: Uuid::new_v4(),
            }))
        },
        
        ("GET", path) if path.starts_with("/api/users/") => {
            let user_id = path.trim_start_matches("/api/users/");
            if let Ok(uuid) = Uuid::parse_str(user_id) {
                if let Some(user) = database.get_user(&uuid).await? {
                    Ok(create_json_response(200, ApiResponse {
                        success: true,
                        data: Some(user),
                        error: None,
                        timestamp: Utc::now(),
                        request_id: Uuid::new_v4(),
                    }))
                } else {
                    Ok(create_error_response(404, "User not found"))
                }
            } else {
                Ok(create_error_response(400, "Invalid user ID"))
            }
        },
        
        // 房间管理
        ("GET", "/api/rooms") => {
            let rooms = database.get_all_rooms().await?;
            Ok(create_json_response(200, ApiResponse {
                success: true,
                data: Some(rooms),
                error: None,
                timestamp: Utc::now(),
                request_id: Uuid::new_v4(),
            }))
        },
        
        ("POST", "/api/rooms") if content_type == "application/json" => {
            let room_data: CreateRoomRequest = serde_json::from_str(body)?;
            let room = database.create_room(&room_data).await?;
            Ok(create_json_response(201, ApiResponse {
                success: true,
                data: Some(room),
                error: None,
                timestamp: Utc::now(),
                request_id: Uuid::new_v4(),
            }))
        },
        
        ("GET", path) if path.starts_with("/api/rooms/") => {
            let room_id = path.trim_start_matches("/api/rooms/");
            if let Ok(uuid) = Uuid::parse_str(room_id) {
                if let Some(room) = database.get_room(&uuid).await? {
                    Ok(create_json_response(200, ApiResponse {
                        success: true,
                        data: Some(room),
                        error: None,
                        timestamp: Utc::now(),
                        request_id: Uuid::new_v4(),
                    }))
                } else {
                    Ok(create_error_response(404, "Room not found"))
                }
            } else {
                Ok(create_error_response(400, "Invalid room ID"))
            }
        },
        
        // 消息管理
        ("GET", path) if path.starts_with("/api/messages/") && path.contains("/history") => {
            let parts: Vec<&str> = path.split('/').collect();
            if parts.len() >= 5 {
                let room_id = Uuid::parse_str(parts[3])?;
                let limit = parts[5].parse::<u32>().unwrap_or(50);
                
                let messages = database.get_room_messages(&room_id, limit).await?;
                Ok(create_json_response(200, ApiResponse {
                    success: true,
                    data: Some(messages),
                    error: None,
                    timestamp: Utc::now(),
                    request_id: Uuid::new_v4(),
                }))
            } else {
                Ok(create_error_response(400, "Invalid path format"))
            }
        },
        
        ("POST", path) if path.starts_with("/api/messages/") => {
            let room_id = path.trim_start_matches("/api/messages/");
            if let Ok(uuid) = Uuid::parse_str(room_id) {
                let message_data: SendMessageRequest = serde_json::from_str(body)?;
                // 实际实现中需要获取用户ID从认证token
                let user_id = Uuid::new_v4(); // 临时用户ID
                
                let message = ChatMessage {
                    id: Uuid::new_v4(),
                    room_id: uuid,
                    sender_id: user_id,
                    message_type: message_data.message_type,
                    content: message_data.content,
                    metadata: message_data.metadata,
                    reply_to: message_data.reply_to,
                    status: MessageStatus::Sending,
                    created_at: Utc::now(),
                    edited_at: None,
                    delivered_to: vec![],
                    read_by: vec![user_id],
                };
                
                let saved_message = database.save_message(&message).await?;
                Ok(create_json_response(201, ApiResponse {
                    success: true,
                    data: Some(saved_message),
                    error: None,
                    timestamp: Utc::now(),
                    request_id: Uuid::new_v4(),
                }))
            } else {
                Ok(create_error_response(400, "Invalid room ID"))
            }
        },
        
        // WebSocket升级端点
        ("GET", "/ws") => {
            // 这里应该升级到WebSocket连接
            // 实际实现中需要处理WebSocket握手
            Ok("HTTP/1.1 400 Bad Request\r\n\r\nWebSocket upgrade should be handled by WebSocket server".to_string())
        },
        
        _ => Ok(create_error_response(404, "Not found")),
    }
}

fn create_json_response(status: u16, data: impl Serialize) -> String {
    let json = serde_json::to_string(&data).unwrap_or_else(|_| "{}".to_string());
    format!(
        "HTTP/1.1 {} OK\r\n\
         Content-Type: application/json\r\n\
         Content-Length: {}\r\n\
         Connection: close\r\n\
         \r\n\
         {}",
        status,
        json.len(),
        json
    )
}

fn create_error_response(status: u16, message: &str) -> String {
    let error = json!({
        "success": false,
        "error": message,
        "timestamp": Utc::now().to_rfc3339()
    });
    let json = serde_json::to_string(&error).unwrap_or_else(|_| "{}".to_string());
    format!(
        "HTTP/1.1 {} Bad Request\r\n\
         Content-Type: application/json\r\n\
         Content-Length: {}\r\n\
         Connection: close\r\n\
         \r\n\
         {}",
        status,
        json.len(),
        json
    )
}

// 请求结构定义
#[derive(Debug, Serialize, Deserialize)]
pub struct CreateUserRequest {
    pub username: String,
    pub display_name: String,
    pub email: String,
    pub password_hash: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateRoomRequest {
    pub name: String,
    pub description: Option<String>,
    pub room_type: RoomType,
    pub is_private: bool,
    pub members: Vec<Uuid>,
}
}

#![allow(unused)]
fn main() {
// 数据库模块
// File: chat-system/src/database.rs
use super::messages::*;
use sqlx::{PgPool, Row};
use tracing::{info, warn, error, instrument};

#[derive(Clone)]
pub struct Database {
    pool: PgPool,
}

impl Database {
    pub async fn new(database_url: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let pool = PgPool::connect(database_url).await?;
        
        // 运行数据库迁移
        Self::run_migrations(&pool).await?;
        
        Ok(Database { pool })
    }
    
    async fn run_migrations(pool: &PgPool) -> Result<(), Box<dyn std::error::Error>> {
        // 创建用户表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS users (
                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
                username VARCHAR(50) UNIQUE NOT NULL,
                display_name VARCHAR(100) NOT NULL,
                email VARCHAR(255) UNIQUE NOT NULL,
                password_hash VARCHAR(255) NOT NULL,
                avatar_url TEXT,
                is_online BOOLEAN DEFAULT FALSE,
                last_seen TIMESTAMP WITH TIME ZONE,
                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
            )
        "#).execute(pool).await?;
        
        // 创建房间表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS rooms (
                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
                name VARCHAR(100) NOT NULL,
                description TEXT,
                room_type VARCHAR(20) NOT NULL DEFAULT 'group',
                is_private BOOLEAN DEFAULT FALSE,
                created_by UUID NOT NULL,
                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                FOREIGN KEY (created_by) REFERENCES users(id)
            )
        "#).execute(pool).await?;
        
        // 创建房间成员表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS room_members (
                room_id UUID NOT NULL,
                user_id UUID NOT NULL,
                role VARCHAR(20) DEFAULT 'member',
                joined_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                PRIMARY KEY (room_id, user_id),
                FOREIGN KEY (room_id) REFERENCES rooms(id) ON DELETE CASCADE,
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            )
        "#).execute(pool).await?;
        
        // 创建消息表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS messages (
                id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
                room_id UUID NOT NULL,
                sender_id UUID NOT NULL,
                message_type VARCHAR(20) NOT NULL DEFAULT 'text',
                content TEXT NOT NULL,
                metadata JSONB DEFAULT '{}',
                reply_to UUID,
                status VARCHAR(20) DEFAULT 'sending',
                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                edited_at TIMESTAMP WITH TIME ZONE,
                FOREIGN KEY (room_id) REFERENCES rooms(id) ON DELETE CASCADE,
                FOREIGN KEY (sender_id) REFERENCES users(id) ON DELETE CASCADE,
                FOREIGN KEY (reply_to) REFERENCES messages(id) ON DELETE SET NULL
            )
        "#).execute(pool).await?;
        
        // 创建消息投递状态表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS message_delivery (
                message_id UUID NOT NULL,
                user_id UUID NOT NULL,
                delivered_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                read_at TIMESTAMP WITH TIME ZONE,
                PRIMARY KEY (message_id, user_id),
                FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE,
                FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE
            )
        "#).execute(pool).await?;
        
        // 创建索引
        sqlx::query("CREATE INDEX IF NOT EXISTS idx_users_username ON users(username)").execute(pool).await?;
        sqlx::query("CREATE INDEX IF NOT EXISTS idx_messages_room_id ON messages(room_id)").execute(pool).await?;
        sqlx::query("CREATE INDEX IF NOT EXISTS idx_messages_created_at ON messages(created_at)").execute(pool).await?;
        sqlx::query("CREATE INDEX IF NOT EXISTS idx_room_members_room_id ON room_members(room_id)").execute(pool).await?;
        sqlx::query("CREATE INDEX IF NOT EXISTS idx_room_members_user_id ON room_members(user_id)").execute(pool).await?;
        
        info!("Database migrations completed");
        Ok(())
    }
    
    // 用户管理
    #[instrument(skip(self))]
    pub async fn create_user(&self, user_data: &CreateUserRequest) -> Result<User, Box<dyn std::error::Error>> {
        let user = sqlx::query_as!(User,
            r#"
            INSERT INTO users (username, display_name, email, password_hash)
            VALUES ($1, $2, $3, $4)
            RETURNING id, username, display_name, avatar_url, is_online, last_seen, created_at
            "#,
            user_data.username,
            user_data.display_name,
            user_data.email,
            user_data.password_hash
        )
        .fetch_one(&self.pool)
        .await?;
        
        Ok(user)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user(&self, user_id: &Uuid) -> Result<Option<User>, Box<dyn std::error::Error>> {
        let user = sqlx::query_as!(User,
            "SELECT id, username, display_name, avatar_url, is_online, last_seen, created_at FROM users WHERE id = $1",
            user_id
        )
        .fetch_optional(&self.pool)
        .await?;
        
        Ok(user)
    }
    
    #[instrument(skip(self))]
    pub async fn get_all_users(&self) -> Result<Vec<User>, Box<dyn std::error::Error>> {
        let users = sqlx::query_as!(User,
            "SELECT id, username, display_name, avatar_url, is_online, last_seen, created_at FROM users ORDER BY created_at DESC"
        )
        .fetch_all(&self.pool)
        .await?;
        
        Ok(users)
    }
    
    #[instrument(skip(self))]
    pub async fn update_user_online_status(&self, user_id: &Uuid, is_online: bool) -> Result<(), Box<dyn std::error::Error>> {
        let last_seen = if is_online { None } else { Some(Utc::now()) };
        
        sqlx::query!(
            r#"
            UPDATE users 
            SET is_online = $1, last_seen = $2, updated_at = NOW()
            WHERE id = $3
            "#,
            is_online,
            last_seen,
            user_id
        )
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
    
    // 房间管理
    #[instrument(skip(self))]
    pub async fn create_room(&self, room_data: &CreateRoomRequest) -> Result<Room, Box<dyn std::error::Error>> {
        // 开始事务
        let mut tx = self.pool.begin().await?;
        
        // 创建房间
        let room = sqlx::query_as!(Room,
            r#"
            INSERT INTO rooms (name, description, room_type, is_private, created_by)
            VALUES ($1, $2, $3, $4, $5)
            RETURNING id, name, description, room_type, is_private, created_by, created_at, last_message_at
            "#,
            room_data.name,
            room_data.description,
            room_data.room_type.to_string(),
            room_data.is_private,
            room_data.created_by
        )
        .fetch_one(&mut *tx)
        .await?;
        
        // 添加创建者为成员
        for member_id in &room_data.members {
            sqlx::query!(
                r#"
                INSERT INTO room_members (room_id, user_id)
                VALUES ($1, $2)
                "#,
                room.id,
                member_id
            )
            .execute(&mut *tx)
            .await?;
        }
        
        // 添加创建者
        sqlx::query!(
            r#"
            INSERT INTO room_members (room_id, user_id)
            VALUES ($1, $2)
            "#,
            room.id,
            room_data.created_by
        )
        .execute(&mut *tx)
        .await?;
        
        tx.commit().await?;
        
        Ok(Room {
            id: room.id,
            name: room.name,
            description: room.description,
            room_type: serde_str_to_enum(&room.room_type)?,
            is_private: room.is_private,
            members: room_data.members.clone(),
            created_by: room.created_by,
            created_at: room.created_at,
            last_message_at: room.last_message_at,
        })
    }
    
    #[instrument(skip(self))]
    pub async fn get_room(&self, room_id: &Uuid) -> Result<Option<Room>, Box<dyn std::error::Error>> {
        let room = sqlx::query!(
            r#"
            SELECT r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at,
                   array_agg(rm.user_id) as members
            FROM rooms r
            LEFT JOIN room_members rm ON r.id = rm.room_id
            WHERE r.id = $1
            GROUP BY r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at
            "#,
            room_id
        )
        .fetch_optional(&self.pool)
        .await?;
        
        if let Some(room) = room {
            Ok(Some(Room {
                id: room.id,
                name: room.name,
                description: room.description,
                room_type: serde_str_to_enum(&room.room_type)?,
                is_private: room.is_private,
                members: room.members.unwrap_or_default(),
                created_by: room.created_by,
                created_at: room.created_at,
                last_message_at: room.last_message_at,
            }))
        } else {
            Ok(None)
        }
    }
    
    #[instrument(skip(self))]
    pub async fn get_all_rooms(&self) -> Result<Vec<Room>, Box<dyn std::error::Error>> {
        let rooms = sqlx::query!(
            r#"
            SELECT r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at,
                   array_agg(rm.user_id) as members
            FROM rooms r
            LEFT JOIN room_members rm ON r.id = rm.room_id
            GROUP BY r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at
            ORDER BY r.created_at DESC
            "#
        )
        .fetch_all(&self.pool)
        .await?;
        
        let mut result = Vec::new();
        for room in rooms {
            result.push(Room {
                id: room.id,
                name: room.name,
                description: room.description,
                room_type: serde_str_to_enum(&room.room_type)?,
                is_private: room.is_private,
                members: room.members.unwrap_or_default(),
                created_by: room.created_by,
                created_at: room.created_at,
                last_message_at: room.last_message_at,
            });
        }
        
        Ok(result)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_rooms(&self, user_id: &Uuid) -> Result<Vec<Room>, Box<dyn std::error::Error>> {
        let rooms = sqlx::query!(
            r#"
            SELECT r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at,
                   array_agg(rm.user_id) as members
            FROM rooms r
            INNER JOIN room_members rm ON r.id = rm.room_id
            WHERE rm.user_id = $1
            GROUP BY r.id, r.name, r.description, r.room_type, r.is_private, r.created_by, r.created_at, r.last_message_at
            ORDER BY r.last_message_at DESC NULLS LAST, r.created_at DESC
            "#,
            user_id
        )
        .fetch_all(&self.pool)
        .await?;
        
        let mut result = Vec::new();
        for room in rooms {
            result.push(Room {
                id: room.id,
                name: room.name,
                description: room.description,
                room_type: serde_str_to_enum(&room.room_type)?,
                is_private: room.is_private,
                members: room.members.unwrap_or_default(),
                created_by: room.created_by,
                created_at: room.created_at,
                last_message_at: room.last_message_at,
            });
        }
        
        Ok(result)
    }
    
    // 消息管理
    #[instrument(skip(self))]
    pub async fn save_message(&self, message: &ChatMessage) -> Result<ChatMessage, Box<dyn std::error::Error>> {
        let saved_message = sqlx::query!(
            r#"
            INSERT INTO messages (id, room_id, sender_id, message_type, content, metadata, reply_to, status, created_at, edited_at)
            VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
            RETURNING id, room_id, sender_id, message_type, content, metadata, reply_to, status, created_at, edited_at
            "#,
            message.id,
            message.room_id,
            message.sender_id,
            message.message_type.to_string(),
            message.content,
            serde_json::to_value(&message.metadata)?,
            message.reply_to,
            message.status.to_string(),
            message.created_at,
            message.edited_at
        )
        .fetch_one(&self.pool)
        .await?;
        
        // 更新房间最后消息时间
        sqlx::query!(
            "UPDATE rooms SET last_message_at = $1, updated_at = NOW() WHERE id = $2",
            message.created_at,
            message.room_id
        )
        .execute(&self.pool)
        .await?;
        
        // 标记消息已发送给发送者
        sqlx::query!(
            r#"
            INSERT INTO message_delivery (message_id, user_id, delivered_at)
            VALUES ($1, $2, $3)
            "#,
            saved_message.id,
            message.sender_id,
            message.created_at
        )
        .execute(&self.pool)
        .await?;
        
        Ok(ChatMessage {
            id: saved_message.id,
            room_id: saved_message.room_id,
            sender_id: saved_message.sender_id,
            message_type: serde_str_to_enum(&saved_message.message_type)?,
            content: saved_message.content,
            metadata: serde_json::from_value(saved_message.metadata).unwrap_or_default(),
            reply_to: saved_message.reply_to,
            status: serde_str_to_enum(&saved_message.status)?,
            created_at: saved_message.created_at,
            edited_at: saved_message.edited_at,
            delivered_to: vec![message.sender_id],
            read_by: vec![message.sender_id],
        })
    }
    
    #[instrument(skip(self))]
    pub async fn get_room_messages(&self, room_id: &Uuid, limit: u32) -> Result<Vec<ChatMessage>, Box<dyn std::error::Error>> {
        let messages = sqlx::query!(
            r#"
            SELECT m.id, m.room_id, m.sender_id, m.message_type, m.content, m.metadata, m.reply_to, m.status, 
                   m.created_at, m.edited_at,
                   array_agg(DISTINCT md.user_id) FILTER (WHERE md.user_id IS NOT NULL) as delivered_to,
                   array_agg(DISTINCT md2.user_id) FILTER (WHERE md2.read_at IS NOT NULL) as read_by
            FROM messages m
            LEFT JOIN message_delivery md ON m.id = md.message_id
            LEFT JOIN message_delivery md2 ON m.id = md2.message_id AND md2.read_at IS NOT NULL
            WHERE m.room_id = $1
            GROUP BY m.id, m.room_id, m.sender_id, m.message_type, m.content, m.metadata, m.reply_to, m.status, m.created_at, m.edited_at
            ORDER BY m.created_at DESC
            LIMIT $2
            "#,
            room_id,
            limit as i64
        )
        .fetch_all(&self.pool)
        .await?;
        
        let mut result = Vec::new();
        for msg in messages {
            result.push(ChatMessage {
                id: msg.id,
                room_id: msg.room_id,
                sender_id: msg.sender_id,
                message_type: serde_str_to_enum(&msg.message_type)?,
                content: msg.content,
                metadata: serde_json::from_value(msg.metadata).unwrap_or_default(),
                reply_to: msg.reply_to,
                status: serde_str_to_enum(&msg.status)?,
                created_at: msg.created_at,
                edited_at: msg.edited_at,
                delivered_to: msg.delivered_to.unwrap_or_default(),
                read_by: msg.read_by.unwrap_or_default(),
            });
        }
        
        // 反转列表使最新的消息在后面
        result.reverse();
        Ok(result)
    }
    
    // 权限管理
    #[instrument(skip(self))]
    pub async fn check_room_permission(&self, user_id: &Uuid, room_id: &Uuid) -> Result<bool, Box<dyn std::error::Error>> {
        let result = sqlx::query!(
            "SELECT 1 FROM room_members WHERE room_id = $1 AND user_id = $2",
            room_id,
            user_id
        )
        .fetch_optional(&self.pool)
        .await?;
        
        Ok(result.is_some())
    }
    
    #[instrument(skip(self))]
    pub async fn get_room_members(&self, room_id: &Uuid) -> Result<Vec<Uuid>, Box<dyn std::error::Error>> {
        let members = sqlx::query!(
            "SELECT user_id FROM room_members WHERE room_id = $1",
            room_id
        )
        .fetch_all(&self.pool)
        .await?;
        
        Ok(members.into_iter().map(|row| row.user_id).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn add_user_to_room(&self, user_id: &Uuid, room_id: &Uuid) -> Result<(), Box<dyn std::error::Error>> {
        sqlx::query!(
            "INSERT INTO room_members (room_id, user_id) VALUES ($1, $2) ON CONFLICT (room_id, user_id) DO NOTHING",
            room_id,
            user_id
        )
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn remove_user_from_room(&self, user_id: &Uuid, room_id: &Uuid) -> Result<(), Box<dyn std::error::Error>> {
        sqlx::query!(
            "DELETE FROM room_members WHERE room_id = $1 AND user_id = $2",
            room_id,
            user_id
        )
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
}

// 辅助函数
fn serde_str_to_enum<T: serde::de::DeserializeOwned>(s: &str) -> Result<T, Box<dyn std::error::Error>> {
    Ok(serde_json::from_str(&format!("\"{}\"", s))?)
}
}

#![allow(unused)]
fn main() {
// Redis缓存模块
// File: chat-system/src/redis_cache.rs
use redis::{Client, Connection, AsyncCommands};
use tracing::{info, warn, error, instrument};
use std::time::Duration;

#[derive(Clone)]
pub struct RedisCache {
    client: Client,
}

impl RedisCache {
    pub async fn new(redis_url: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let client = Client::open(redis_url)?;
        
        // 测试连接
        let mut conn = client.get_async_connection().await?;
        redis::cmd("PING")
            .query_async::<(), String>(&mut conn)
            .await?;
        
        info!("Redis cache connection established");
        Ok(RedisCache { client })
    }
    
    pub async fn get_connection(&self) -> Result<Connection, Box<dyn std::error::Error>> {
        Ok(self.client.get_connection()?)
    }
    
    // 用户在线状态缓存
    #[instrument(skip(self))]
    pub async fn set_user_online(&self, user_id: String, duration: Duration) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("user:online:{}", user_id);
        
        redis::cmd("SETEX")
            .arg(&key)
            .arg(duration.as_secs())
            .arg("1")
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn is_user_online(&self, user_id: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("user:online:{}", user_id);
        
        let result: Option<String> = conn.get(&key).await?;
        Ok(result.is_some())
    }
    
    #[instrument(skip(self))]
    pub async fn set_user_offline(&self, user_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("user:online:{}", user_id);
        
        redis::cmd("DEL")
            .arg(&key)
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    // 房间在线成员缓存
    #[instrument(skip(self))]
    pub async fn add_user_to_room_cache(&self, room_id: &str, user_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("room:online:{}", room_id);
        
        redis::cmd("SADD")
            .arg(&key)
            .arg(user_id)
            .query_async(&mut conn)
            .await?;
        
        // 设置过期时间
        redis::cmd("EXPIRE")
            .arg(&key)
            .arg(3600) // 1小时
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn remove_user_from_room_cache(&self, room_id: &str, user_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("room:online:{}", room_id);
        
        redis::cmd("SREM")
            .arg(&key)
            .arg(user_id)
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn get_room_online_users(&self, room_id: &str) -> Result<Vec<String>, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("room:online:{}", room_id);
        
        let members: Vec<String> = conn.smembers(&key).await?;
        Ok(members)
    }
    
    // 消息缓存
    #[instrument(skip(self))]
    pub async fn cache_message(&self, room_id: &str, message_id: &str, message: &serde_json::Value, ttl: Duration) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("message:{}:{}", room_id, message_id);
        
        redis::cmd("SETEX")
            .arg(&key)
            .arg(ttl.as_secs())
            .arg(message.to_string())
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn get_cached_message(&self, room_id: &str, message_id: &str) -> Result<Option<serde_json::Value>, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("message:{}:{}", room_id, message_id);
        
        let result: Option<String> = conn.get(&key).await?;
        if let Some(json_str) = result {
            Ok(Some(serde_json::from_str(&json_str)?))
        } else {
            Ok(None)
        }
    }
    
    // 房间最近消息缓存
    #[instrument(skip(self))]
    pub async fn cache_recent_messages(&self, room_id: &str, messages: Vec<serde_json::Value>) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("room:recent:{}", room_id);
        
        // 使用Redis列表存储最近的50条消息
        let mut pipeline = redis::pipe();
        
        // 清空旧列表
        pipeline.del(&key);
        
        // 添加新消息
        for message in messages {
            pipeline.lpush(&key, message.to_string());
        }
        
        // 限制列表长度
        pipeline.ltrim(&key, 0, 49);
        
        // 设置过期时间
        pipeline.expire(&key, 3600); // 1小时
        
        let _: () = pipeline.query_async(&mut conn).await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn get_recent_messages(&self, room_id: &str) -> Result<Vec<serde_json::Value>, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("room:recent:{}", room_id);
        
        let messages: Vec<String> = conn.lrange(&key, 0, -1).await?;
        let mut result = Vec::new();
        
        for json_str in messages {
            if let Ok(value) = serde_json::from_str(&json_str) {
                result.push(value);
            }
        }
        
        Ok(result)
    }
    
    // 速率限制
    #[instrument(skip(self))]
    pub async fn check_rate_limit(&self, user_id: &str, action: &str, limit: u32, window: Duration) -> Result<bool, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("rate_limit:{}:{}", user_id, action);
        
        let current: i64 = conn.incr(&key, 1).await?;
        
        if current == 1 {
            // 第一次请求，设置过期时间
            let _: () = conn.expire(&key, window.as_secs() as i64).await?;
        }
        
        Ok(current <= limit as i64)
    }
    
    // 会话管理
    #[instrument(skip(self))]
    pub async fn create_session(&self, user_id: &str, session_data: &serde_json::Value, ttl: Duration) -> Result<String, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let session_id = uuid::Uuid::new_v4().to_string();
        let key = format!("session:{}", session_id);
        
        let mut session_data = session_data.clone();
        if let Some(obj) = session_data.as_object_mut() {
            obj.insert("user_id".to_string(), serde_json::Value::String(user_id.to_string()));
        }
        
        redis::cmd("SETEX")
            .arg(&key)
            .arg(ttl.as_secs())
            .arg(session_data.to_string())
            .query_async(&mut conn)
            .await?;
        
        // 将session ID关联到用户
        let user_sessions_key = format!("user_sessions:{}", user_id);
        redis::cmd("SADD")
            .arg(&user_sessions_key)
            .arg(&session_id)
            .query_async(&mut conn)
            .await?;
        
        // 设置session集合的过期时间
        redis::cmd("EXPIRE")
            .arg(&user_sessions_key)
            .arg(ttl.as_secs())
            .query_async(&mut conn)
            .await?;
        
        Ok(session_id)
    }
    
    #[instrument(skip(self))]
    pub async fn get_session(&self, session_id: &str) -> Result<Option<serde_json::Value>, Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("session:{}", session_id);
        
        let result: Option<String> = conn.get(&key).await?;
        if let Some(json_str) = result {
            Ok(Some(serde_json::from_str(&json_str)?))
        } else {
            Ok(None)
        }
    }
    
    #[instrument(skip(self))]
    pub async fn delete_session(&self, session_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let key = format!("session:{}", session_id);
        
        // 获取session数据以获取user_id
        if let Some(session_data) = self.get_session(session_id).await? {
            if let Some(user_id) = session_data.get("user_id").and_then(|v| v.as_str()) {
                let user_sessions_key = format!("user_sessions:{}", user_id);
                redis::cmd("SREM")
                    .arg(&user_sessions_key)
                    .arg(session_id)
                    .query_async(&mut conn)
                    .await?;
            }
        }
        
        redis::cmd("DEL")
            .arg(&key)
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn invalidate_user_sessions(&self, user_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let mut conn = self.get_connection().await?;
        let user_sessions_key = format!("user_sessions:{}", user_id);
        
        // 获取所有session ID
        let session_ids: Vec<String> = conn.smembers(&user_sessions_key).await?;
        
        // 删除所有会话
        for session_id in session_ids {
            let key = format!("session:{}", session_id);
            redis::cmd("DEL").arg(&key).query_async(&mut conn).await?;
        }
        
        // 删除会话集合
        redis::cmd("DEL")
            .arg(&user_sessions_key)
            .query_async(&mut conn)
            .await?;
        
        Ok(())
    }
}
}

// 主应用文件
// File: chat-system/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::sync::Arc;
use tokio::sync::RwLock;

mod messages;
mod websocket_server;
mod http_server;
mod database;
mod redis_cache;

use messages::*;
use websocket_server::{WebSocketServer, WebSocketServerConfig};
use http_server::HttpServer;
use database::Database;
use redis_cache::RedisCache;

#[derive(Parser, Debug)]
#[command(name = "distributed-chat-system")]
#[command(about = "A distributed chat system built with Rust")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start the WebSocket server
    WebSocket {
        #[arg(short, long, default_value = "0.0.0.0:8080")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://chat_user:password@localhost/chat_db")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Start the HTTP API server
    Http {
        #[arg(short, long, default_value = "0.0.0.0:8081")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://chat_user:password@localhost/chat_db")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Start both servers
    Both {
        #[arg(short, long, default_value = "0.0.0.0:8080")]
        ws_addr: String,
        
        #[arg(short, long, default_value = "0.0.0.0:8081")]
        http_addr: String,
        
        #[arg(short, long, default_value = "postgres://chat_user:password@localhost/chat_db")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "distributed_chat_system=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::WebSocket { addr, database_url, redis_url } => {
            run_websocket_server(addr, database_url, redis_url).await
        }
        Commands::Http { addr, database_url, redis_url } => {
            run_http_server(addr, database_url, redis_url).await
        }
        Commands::Both { ws_addr, http_addr, database_url, redis_url } => {
            run_both_servers(ws_addr, http_addr, database_url, redis_url).await
        }
    }
}

#[instrument]
async fn run_websocket_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting WebSocket server on {}", addr);
    
    // 初始化数据库和缓存
    let database = Database::new(&database_url).await?;
    let redis = RedisCache::new(&redis_url).await?;
    
    // 配置WebSocket服务器
    let config = WebSocketServerConfig {
        max_connections: 10000,
        heartbeat_interval: std::time::Duration::from_secs(30),
        message_buffer_size: 1000,
        rate_limit_per_minute: 100,
    };
    
    let server = WebSocketServer::new(config, database, redis);
    
    // 启动服务器
    if let Err(e) = server.run(&addr).await {
        error!("WebSocket server error: {}", e);
        return Err(e);
    }
    
    Ok(())
}

#[instrument]
async fn run_http_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting HTTP server on {}", addr);
    
    // 初始化数据库和缓存
    let database = Database::new(&database_url).await?;
    let redis = RedisCache::new(&redis_url).await?;
    
    // 启动WebSocket服务器（需要为HTTP服务器提供引用）
    let config = WebSocketServerConfig::default();
    let ws_server = WebSocketServer::new(config, database.clone(), redis.clone());
    
    let http_server = HttpServer::new(database, redis, ws_server);
    
    // 启动HTTP服务器
    if let Err(e) = http_server.run().await {
        error!("HTTP server error: {}", e);
        return Err(e);
    }
    
    Ok(())
}

#[instrument]
async fn run_both_servers(
    ws_addr: String,
    http_addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting both servers - WebSocket: {}, HTTP: {}", ws_addr, http_addr);
    
    // 初始化数据库和缓存
    let database = Database::new(&database_url).await?;
    let redis = RedisCache::new(&redis_url).await?;
    
    // 配置WebSocket服务器
    let config = WebSocketServerConfig {
        max_connections: 10000,
        heartbeat_interval: std::time::Duration::from_secs(30),
        message_buffer_size: 1000,
        rate_limit_per_minute: 100,
    };
    
    let ws_server = WebSocketServer::new(config, database.clone(), redis.clone());
    let http_server = HttpServer::new(database, redis, ws_server.clone());
    
    // 启动两个服务器
    let ws_handle = tokio::spawn(async move {
        if let Err(e) = ws_server.run(&ws_addr).await {
            error!("WebSocket server error: {}", e);
        }
    });
    
    let http_handle = tokio::spawn(async move {
        if let Err(e) = http_server.run().await {
            error!("HTTP server error: {}", e);
        }
    });
    
    // 等待两个服务器
    tokio::select! {
        result = ws_handle => {
            if let Err(e) = result {
                error!("WebSocket server task error: {}", e);
            }
        }
        result = http_handle => {
            if let Err(e) = result {
                error!("HTTP server task error: {}", e);
            }
        }
    }
    
    Ok(())
}

// 性能监控工具
pub struct SystemMetrics {
    active_connections: std::sync::atomic::AtomicUsize,
    messages_processed: std::sync::atomic::AtomicU64,
    errors_total: std::sync::atomic::AtomicU64,
    start_time: std::time::Instant,
}

impl SystemMetrics {
    pub fn new() -> Arc<RwLock<Self>> {
        Arc::new(RwLock::new(SystemMetrics {
            active_connections: std::sync::atomic::AtomicUsize::new(0),
            messages_processed: std::sync::atomic::AtomicU64::new(0),
            errors_total: std::sync::atomic::AtomicU64::new(0),
            start_time: std::time::Instant::now(),
        }))
    }
    
    pub fn increment_connections(&self) {
        self.active_connections.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    }
    
    pub fn decrement_connections(&self) {
        self.active_connections.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
    }
    
    pub fn increment_messages(&self) {
        self.messages_processed.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    }
    
    pub fn increment_errors(&self) {
        self.errors_total.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
    }
    
    pub fn get_stats(&self) -> SystemStats {
        SystemStats {
            active_connections: self.active_connections.load(std::sync::atomic::Ordering::Relaxed),
            messages_processed: self.messages_processed.load(std::sync::atomic::Ordering::Relaxed),
            errors_total: self.errors_total.load(std::sync::atomic::Ordering::Relaxed),
            uptime: self.start_time.elapsed(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct SystemStats {
    pub active_connections: usize,
    pub messages_processed: u64,
    pub errors_total: u64,
    pub uptime: std::time::Duration,
}

#![allow(unused)]
fn main() {
// 部署配置和文档
// File: chat-system/docker-compose.yml
version: '3.8'

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: chat_db
      POSTGRES_USER: chat_user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  chat-app:
    build: .
    ports:
      - "8080:8080"  # WebSocket
      - "8081:8081"  # HTTP API
    environment:
      DATABASE_URL: postgres://chat_user:password@postgres:5432/chat_db
      REDIS_URL: redis://redis:6379
    depends_on:
      - postgres
      - redis
    restart: unless-stopped

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf
    depends_on:
      - chat-app

volumes:
  postgres_data:
  redis_data:
}

#![allow(unused)]
fn main() {
// File: chat-system/nginx.conf
events {
    worker_connections 1024;
}

http {
    upstream websocket_backend {
        server chat-app:8080;
    }
    
    upstream http_backend {
        server chat-app:8081;
    }
    
    WebSocket代理配置
    server {
        listen 80;
        server_name localhost;
        
        WebSocket端点
        location /ws {
            proxy_pass http://websocket_backend;
            proxy_http_version 1.1;
            proxy_set_header Upgrade $http_upgrade;
            proxy_set_header Connection "upgrade";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_connect_timeout 7d;
            proxy_send_timeout 7d;
            proxy_read_timeout 7d;
        }
        
        HTTP API代理
        location /api/ {
            proxy_pass http://http_backend/;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
        }
    }
}
}

// File: chat-system/Dockerfile
FROM rust:1.70 as builder

WORKDIR /app

复制Cargo文件
COPY Cargo.toml Cargo.lock ./

创建空main.rs以缓存依赖
RUN mkdir src && echo "fn main() {}" > src/main.rs

构建依赖
RUN cargo build --release
RUN rm src/main.rs

复制源代码
COPY src ./src

构建应用
RUN cargo build --release

运行阶段
FROM debian:bookworm-slim

RUN apt-get update && apt-get install -y \
    ca-certificates \
    libssl3 \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app

复制二进制文件
COPY --from=builder /app/target/release/distributed-chat-system ./

创建非root用户
RUN useradd -r -s /bin/false chatuser
USER chatuser

EXPOSE 8080 8081

CMD ["./distributed-chat-system", "both"]

#![allow(unused)]
fn main() {
// File: chat-system/README.md
分布式聊天系统

一个基于Rust构建的企业级分布式聊天系统，支持实时通信、房间管理、消息持久化等功能。

# 功能特性

## 核心功能
- **实时消息传输**：基于WebSocket的双向通信
- **多房间支持**：私人房间、群组房间、公共房间
- **消息类型**：文本、图片、文件、表情等
- **用户管理**：用户注册、认证、在线状态
- **消息状态**：发送、已送达、已读状态跟踪

## 企业级特性
- **高可用性**：支持负载均衡和集群部署
- **可扩展性**：水平扩展，支持大量并发用户
- **数据持久化**：PostgreSQL数据库存储
- **缓存优化**：Redis缓存提升性能
- **监控告警**：完整的系统监控和错误追踪
- **安全防护**：JWT认证、SQL注入防护、XSS防护

# 架构设计

}

┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐ │ Load Balancer │ │ Load Balancer │ │ Load Balancer │ │ (Nginx) │ │ (Nginx) │ │ (Nginx) │ └─────────┬───────┘ └─────────┬───────┘ └─────────┬───────┘ │ │ │ └──────────────────────┼──────────────────────┘ │ ┌────────────▼────────────┐ │ Application Servers │ │ ┌────────────────────┐ │ │ │ WebSocket Server │ │ │ │ - 实时通信处理 │ │ │ │ - 连接管理 │ │ │ │ - 消息分发 │ │ │ └────────────────────┘ │ │ ┌────────────────────┐ │ │ │ HTTP API Server │ │ │ │ - RESTful API │ │ │ │ - 业务逻辑处理 │ │ │ │ - 认证授权 │ │ │ └────────────────────┘ │ └────────────┬────────────┘ │ ┌────────────▼────────────┐ │ Data Layer │ │ ┌────────────────────┐ │ │ │ PostgreSQL │ │ │ │ - 消息持久化 │ │ │ │ - 用户数据 │ │ │ │ - 房间信息 │ │ │ └────────────────────┘ │ │ ┌────────────────────┐ │ │ │ Redis │ │ │ │ - 会话管理 │ │ │ │ - 在线状态 │ │ │ │ - 消息缓存 │ │ │ └────────────────────┘ │ └────────────────────────┘


## 快速开始

### 使用Docker Compose（推荐）

1. 克隆项目
```bash2. 克隆仓库
git clone <repository-url>
cd distributed-chat-system

3. 启动服务
docker-compose up -d

4. 访问系统
- WebSocket: ws://localhost/ws
- HTTP API: http://localhost/api
- Web界面: http://localhost

### 本地开发

1. **前置要求**
- Rust 1.70+
- PostgreSQL 13+
- Redis 6+
- Docker (可选)

2. **安装依赖**
```bash
# 安装PostgreSQL和Redis
sudo apt-get install postgresql redis-server

# 创建数据库
createdb chat_db
psql chat_db -f init.sql

# 运行应用
cargo run both -- \
  --database-url "postgres://chat_user:password@localhost/chat_db" \
  --redis-url "redis://localhost:6379"

API文档

WebSocket API

连接

const ws = new WebSocket('ws://localhost/ws');

// 发送认证消息
ws.send(JSON.stringify({
  message_id: 'uuid',
  data: {
    type: 'auth_request',
    username: 'user123',
    password_hash: 'hashed_password'
  }
}));

消息格式

{
  "id": "message-uuid",
  "message_type": "send_message",
  "data": {
    "type": "send_message_request",
    "room_id": "room-uuid",
    "content": "Hello, world!",
    "message_type": "text"
  }
}

HTTP API

用户管理

GET /api/users - 获取所有用户
POST /api/users - 创建新用户
GET /api/users/{id} - 获取特定用户

房间管理

GET /api/rooms - 获取所有房间
POST /api/rooms - 创建新房间
GET /api/rooms/{id} - 获取特定房间

消息管理

GET /api/messages/{room_id}/history?limit=50 - 获取消息历史
POST /api/messages/{room_id} - 发送消息

性能优化

数据库优化

使用连接池管理数据库连接
为常用查询创建索引
使用分页查询减少数据传输
实施消息归档策略

缓存策略

Redis缓存用户在线状态
缓存最近的房间消息
使用Redis进行会话管理
实施合适的TTL策略

网络优化

使用WebSocket进行实时通信
实施消息批处理
压缩JSON数据
使用CDN提供静态资源

安全考虑

认证授权

JWT token认证
基于角色的访问控制
房间权限验证
会话管理和过期

数据安全

密码哈希存储（bcrypt）
SQL注入防护
XSS防护
CSRF保护

网络安全

HTTPS/WSS加密传输
速率限制
输入验证
错误处理

监控和运维

性能监控

系统资源监控
实时连接数统计
消息吞吐量监控
错误率跟踪

日志记录

结构化日志记录
错误跟踪和报告
性能指标收集
安全事件日志

健康检查

服务健康检查端点
数据库连接状态
Redis连接状态
内存使用监控

扩展性设计

水平扩展

无状态应用设计
数据库读写分离
Redis集群支持
负载均衡配置

微服务架构

用户服务
消息服务
房间服务
通知服务

故障处理

高可用

多实例部署
数据库主从复制
Redis哨兵模式
故障转移机制

数据备份

定期数据库备份
Redis数据持久化
消息队列备份
配置文件备份

开发和测试

开发环境

本地开发配置
调试工具设置
单元测试框架
集成测试

部署流程

CI/CD管道
自动化测试
蓝绿部署
回滚策略

许可证

MIT License

贡献

欢迎提交Issue和Pull Request来改进这个项目。

联系信息：

作者：MiniMax Agent
邮箱：developer@minimax.com
文档：https://docs.minimax.com/chat-system

第11章：数据库操作

章节概述

数据持久化是现代应用程序的核心需求之一。在本章中，我们将深入探索Rust的数据库编程能力，从基础的SQL操作到复杂的企业级数据管理。本章不仅关注技术实现，更强调性能优化、数据安全和可维护性。

学习目标：

掌握Rust数据库编程的核心概念和最佳实践
理解PostgreSQL等关系型数据库的特点和优势
学会构建高性能的异步数据库操作
掌握连接池管理和查询优化技术
学会数据库迁移和版本管理
设计并实现一个企业级任务管理平台

实战项目：构建一个企业级任务管理系统，支持团队协作、任务分配、进度跟踪、项目管理等功能。

11.1 数据库编程基础

11.1.1 Rust数据库生态

Rust在数据库编程方面具有以下优势：

类型安全：编译时类型检查，避免SQL注入
内存安全：防止缓冲区溢出和内存泄露
零成本抽象：接近C++的性能表现
异步支持：优秀的异步/await支持高并发
丰富的生态：多个成熟的数据库驱动和ORM

11.1.2 主要数据库库介绍

sqlx - 异步SQL库

#![allow(unused)]
fn main() {
use sqlx::{Postgres, Row, Column};
use sqlx::postgres::PgPoolOptions;
use std::time::Duration;

#[derive(Debug, sqlx::FromRow)]
struct User {
    id: i64,
    username: String,
    email: String,
    created_at: chrono::DateTime<chrono::Utc>,
}

async fn connect_database() -> Result<sqlx::PgPool, sqlx::Error> {
    let pool = PgPoolOptions::new()
        .max_connections(10)
        .connect_timeout(Duration::from_secs(5))
        .connect("postgresql://user:password@localhost/database")
        .await?;
    
    Ok(pool)
}

async fn fetch_user_by_id(pool: &sqlx::PgPool, user_id: i64) -> Result<Option<User>, sqlx::Error> {
    let user = sqlx::query_as!(
        User,
        "SELECT id, username, email, created_at FROM users WHERE id = $1",
        user_id
    )
    .fetch_optional(pool)
    .await?;
    
    Ok(user)
}
}

diesel - 类型安全的ORM

#![allow(unused)]
fn main() {
use diesel::{PgConnection, Queryable, Insertable, associations::BelongsTo};
use diesel::table;

table! {
    users {
        id -> BigInt,
        username -> Varchar,
        email -> Varchar,
        created_at -> Timestamptz,
    }
}

#[derive(Queryable, BelongsTo)]
#[belongs_to(User)]
struct Task {
    id: i64,
    title: String,
    description: Option<String>,
    user_id: i64,
    created_at: chrono::DateTime<chrono::Utc>,
    updated_at: chrono::DateTime<chrono::Utc>,
}

fn insert_user(conn: &PgConnection, username: &str, email: &str) -> Result<i64, diesel::result::Error> {
    use crate::schema::users;
    
    let new_user = NewUser {
        username,
        email,
    };
    
    let result = diesel::insert_into(users::table)
        .values(&new_user)
        .returning(users::id)
        .get_result(conn)?;
    
    Ok(result)
}
}

11.1.3 数据库连接管理

#![allow(unused)]
fn main() {
use sqlx::{PgPool, Connection};
use std::time::Duration;
use tokio::sync::RwLock;
use std::collections::HashMap;
use tracing::{info, warn, error};

pub struct DatabaseManager {
    pool: PgPool,
    connections: RwLock<HashMap<String, PgPool>>,
    health_check_interval: Duration,
}

impl DatabaseManager {
    pub async fn new(database_url: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let pool = PgPoolOptions::new()
            .max_connections(20)  // 最大连接数
            .min_connections(5)   // 最小连接数
            .max_lifetime(Duration::from_secs(1800))  // 连接生命周期
            .idle_timeout(Duration::from_secs(300))   // 空闲超时
            .connect_timeout(Duration::from_secs(10)) // 连接超时
            .connect(database_url)
            .await?;
        
        info!("Database connection pool initialized");
        
        Ok(DatabaseManager {
            pool,
            connections: RwLock::new(HashMap::new()),
            health_check_interval: Duration::from_secs(30),
        })
    }
    
    pub async fn health_check(&self) -> Result<bool, Box<dyn std::error::Error>> {
        let result: Result<(i64,), sqlx::Error> = sqlx::query_as("SELECT 1 as test")
            .fetch_one(&self.pool)
            .await;
        
        match result {
            Ok(_) => {
                info!("Database health check passed");
                Ok(true)
            }
            Err(e) => {
                error!("Database health check failed: {}", e);
                Ok(false)
            }
        }
    }
    
    pub async fn start_health_monitoring(&self) {
        let manager = self.clone();
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(manager.health_check_interval);
            loop {
                interval.tick().await;
                
                if let Ok(false) = manager.health_check().await {
                    warn!("Database health check failed");
                    // 这里可以添加告警逻辑
                }
            }
        });
    }
    
    pub async fn get_connection(&self) -> Result<sqlx::PgConnection, sqlx::Error> {
        self.pool.acquire().await?.into_owned()
    }
    
    pub async fn execute_query<T>(
        &self,
        query: &str,
        params: impl sqlx::Encode<'_, sqlx::Postgres> + sqlx::Type<sqlx::Postgres> + Send
    ) -> Result<T, sqlx::Error>
    where
        T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send
    {
        let mut conn = self.get_connection().await?;
        sqlx::query_as::<_, T>(query)
            .bind(params)
            .fetch_one(&mut *conn)
            .await
    }
    
    pub async fn execute_update(&self, query: &str) -> Result<u64, sqlx::Error> {
        let mut conn = self.get_connection().await?;
        sqlx::query(query)
            .execute(&mut *conn)
            .await
            .map(|result| result.rows_affected())
    }
    
    pub async fn execute_insert<T>(
        &self,
        query: &str
    ) -> Result<T, sqlx::Error>
    where
        T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send
    {
        let mut conn = self.get_connection().await?;
        sqlx::query_as::<_, T>(query)
            .fetch_one(&mut *conn)
            .await
    }
}

impl Clone for DatabaseManager {
    fn clone(&self) -> Self {
        DatabaseManager {
            pool: self.pool.clone(),
            connections: self.connections.clone(),
            health_check_interval: self.health_check_interval,
        }
    }
}
}

11.2 SQL基础和PostgreSQL

11.2.1 PostgreSQL特性

PostgreSQL是功能最强大的开源关系型数据库之一，具有以下特点：

ACID事务支持
复杂查询支持
JSON/JSONB支持
全文搜索
地理位置数据支持
扩展性良好

11.2.2 基础SQL操作

#![allow(unused)]
fn main() {
// 数据定义语言 (DDL)
async fn create_tables(pool: &sqlx::PgPool) -> Result<(), sqlx::Error> {
    // 创建用户表
    sqlx::query(r#"
        CREATE TABLE IF NOT EXISTS users (
            id SERIAL PRIMARY KEY,
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(100) UNIQUE NOT NULL,
            password_hash VARCHAR(255) NOT NULL,
            display_name VARCHAR(100),
            avatar_url TEXT,
            is_active BOOLEAN DEFAULT TRUE,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        )
    "#).execute(pool).await?;
    
    // 创建项目表
    sqlx::query(r#"
        CREATE TABLE IF NOT EXISTS projects (
            id SERIAL PRIMARY KEY,
            name VARCHAR(100) NOT NULL,
            description TEXT,
            owner_id INTEGER NOT NULL REFERENCES users(id),
            status project_status DEFAULT 'active',
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        )
    "#).execute(pool).await?;
    
    // 创建任务表
    sqlx::query(r#"
        CREATE TABLE IF NOT EXISTS tasks (
            id SERIAL PRIMARY KEY,
            title VARCHAR(200) NOT NULL,
            description TEXT,
            project_id INTEGER NOT NULL REFERENCES projects(id),
            assignee_id INTEGER REFERENCES users(id),
            created_by_id INTEGER NOT NULL REFERENCES users(id),
            status task_status DEFAULT 'todo',
            priority task_priority DEFAULT 'medium',
            estimated_hours DECIMAL(5,2),
            actual_hours DECIMAL(5,2) DEFAULT 0,
            due_date DATE,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        )
    "#).execute(pool).await?;
    
    // 创建任务评论表
    sqlx::query(r#"
        CREATE TABLE IF NOT EXISTS task_comments (
            id SERIAL PRIMARY KEY,
            task_id INTEGER NOT NULL REFERENCES tasks(id),
            user_id INTEGER NOT NULL REFERENCES users(id),
            content TEXT NOT NULL,
            created_at TIMESTAMPTZ DEFAULT NOW()
        )
    "#).execute(pool).await?;
    
    Ok(())
}

// 创建自定义枚举类型
async fn create_custom_types(pool: &sqlx::PgPool) -> Result<(), sqlx::Error> {
    sqlx::query(r#"
        DO $$ BEGIN
            CREATE TYPE project_status AS ENUM ('active', 'completed', 'cancelled', 'on_hold');
        EXCEPTION
            WHEN duplicate_object THEN null;
        END $$;
    "#).execute(pool).await?;
    
    sqlx::query(r#"
        DO $$ BEGIN
            CREATE TYPE task_status AS ENUM ('todo', 'in_progress', 'review', 'completed', 'cancelled');
        EXCEPTION
            WHEN duplicate_object THEN null;
        END $$;
    "#).execute(pool).await?;
    
    sqlx::query(r#"
        DO $$ BEGIN
            CREATE TYPE task_priority AS ENUM ('low', 'medium', 'high', 'urgent');
        EXCEPTION
            WHEN duplicate_object THEN null;
        END $$;
    "#).execute(pool).await?;
    
    Ok(())
}
}

11.2.3 索引优化

#![allow(unused)]
fn main() {
async fn create_indexes(pool: &sqlx::PgPool) -> Result<(), sqlx::Error> {
    // 为用户表创建索引
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_users_email ON users(email)")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_users_username ON users(username)")
        .execute(pool).await?;
    
    // 为项目表创建索引
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_projects_owner ON projects(owner_id)")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_projects_status ON projects(status)")
        .execute(pool).await?;
    
    // 为任务表创建复合索引
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_project_status ON tasks(project_id, status)")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_assignee ON tasks(assignee_id)")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_due_date ON tasks(due_date)")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_created_at ON tasks(created_at)")
        .execute(pool).await?;
    
    // 创建全文搜索索引
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_title_fts ON tasks USING gin(to_tsvector('english', title))")
        .execute(pool).await?;
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_description_fts ON tasks USING gin(to_tsvector('english', description))")
        .execute(pool).await?;
    
    // 创建部分索引（只对活跃任务）
    sqlx::query("CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_tasks_active_assignee ON tasks(assignee_id) WHERE status != 'completed'")
        .execute(pool).await?;
    
    Ok(())
}
}

11.2.4 数据完整性约束

#![allow(unused)]
fn main() {
async fn add_constraints(pool: &sqlx::PgPool) -> Result<(), sqlx::Error> {
    // 添加外键约束
    sqlx::query("ALTER TABLE projects ADD CONSTRAINT fk_projects_owner FOREIGN KEY (owner_id) REFERENCES users(id) ON DELETE CASCADE")
        .execute(pool).await?;
    
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT fk_tasks_project FOREIGN KEY (project_id) REFERENCES projects(id) ON DELETE CASCADE")
        .execute(pool).await?;
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT fk_tasks_assignee FOREIGN KEY (assignee_id) REFERENCES users(id) ON DELETE SET NULL")
        .execute(pool).await?;
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT fk_tasks_created_by FOREIGN KEY (created_by_id) REFERENCES users(id) ON DELETE CASCADE")
        .execute(pool).await?;
    
    sqlx::query("ALTER TABLE task_comments ADD CONSTRAINT fk_task_comments_task FOREIGN KEY (task_id) REFERENCES tasks(id) ON DELETE CASCADE")
        .execute(pool).await?;
    sqlx::query("ALTER TABLE task_comments ADD CONSTRAINT fk_task_comments_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE")
        .execute(pool).await?;
    
    // 添加检查约束
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT chk_estimated_hours_positive CHECK (estimated_hours > 0 OR estimated_hours IS NULL)")
        .execute(pool).await?;
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT chk_actual_hours_non_negative CHECK (actual_hours >= 0)")
        .execute(pool).await?;
    sqlx::query("ALTER TABLE tasks ADD CONSTRAINT chk_due_date_after_created CHECK (due_date >= DATE(created_at) OR due_date IS NULL)")
        .execute(pool).await?;
    
    // 添加唯一约束
    sqlx::query("ALTER TABLE task_comments ADD CONSTRAINT unique_task_user_created_at UNIQUE (task_id, user_id, created_at)")
        .execute(pool).await?;
    
    Ok(())
}
}

11.3 异步数据库操作

11.3.1 查询构建器

#![allow(unused)]
fn main() {
use sqlx::Postgres;
use serde::{Serialize, Deserialize};
use std::collections::HashMap;

#[derive(Debug, Serialize, Deserialize)]
pub struct QueryBuilder {
    table: String,
    conditions: Vec<String>,
    params: Vec<Box<dyn sqlx::Encode<'static, Postgres> + Send>>,
    order_by: Option<(String, bool)>,
    limit: Option<i64>,
    offset: Option<i64>,
}

impl QueryBuilder {
    pub fn new(table: &str) -> Self {
        QueryBuilder {
            table: table.to_string(),
            conditions: Vec::new(),
            params: Vec::new(),
            order_by: None,
            limit: None,
            offset: None,
        }
    }
    
    pub fn add_condition(&mut self, condition: &str, param: impl sqlx::Encode<'static, Postgres> + Send + 'static) -> &mut Self {
        self.conditions.push(condition.to_string());
        self.params.push(Box::new(param) as Box<dyn sqlx::Encode<'static, Postgres> + Send>);
        self
    }
    
    pub fn add_or_condition(&mut self, condition: &str, param: impl sqlx::Encode<'static, Postgres> + Send + 'static) -> &mut Self {
        if !self.conditions.is_empty() {
            self.conditions.push(format!("OR {}", condition));
        } else {
            self.conditions.push(condition.to_string());
        }
        self.params.push(Box::new(param) as Box<dyn sqlx::Encode<'static, Postgres> + Send>);
        self
    }
    
    pub fn order_by(&mut self, column: &str, ascending: bool) -> &mut Self {
        self.order_by = Some((column.to_string(), ascending));
        self
    }
    
    pub fn limit(&mut self, limit: i64) -> &mut Self {
        self.limit = Some(limit);
        self
    }
    
    pub fn offset(&mut self, offset: i64) -> &mut Self {
        self.offset = Some(offset);
        self
    }
    
    pub fn build_select(&self) -> String {
        let mut query = format!("SELECT * FROM {}", self.table);
        
        if !self.conditions.is_empty() {
            query.push_str(" WHERE ");
            query.push_str(&self.conditions.join(" AND "));
        }
        
        if let Some((ref column, ascending)) = self.order_by {
            let order = if ascending { "ASC" } else { "DESC" };
            query.push_str(&format!(" ORDER BY {} {}", column, order));
        }
        
        if let Some(limit) = self.limit {
            query.push_str(&format!(" LIMIT {}", limit));
        }
        
        if let Some(offset) = self.offset {
            query.push_str(&format!(" OFFSET {}", offset));
        }
        
        query
    }
    
    pub async fn execute_select<T>(
        &self,
        pool: &sqlx::PgPool
    ) -> Result<Vec<T>, sqlx::Error>
    where
        T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send
    {
        let query = self.build_select();
        let mut query_builder = sqlx::query_as::<_, T>(&query);
        
        for param in &self.params {
            // 这里需要一个更复杂的方式来绑定参数
            // 简化实现
        }
        
        query_builder.fetch_all(pool).await
    }
}

// 使用示例
#[cfg(test)]
mod query_builder_tests {
    use super::*;
    
    #[tokio::test]
    async fn test_query_builder() {
        let mut query = QueryBuilder::new("tasks")
            .add_condition("status = $1", "todo")
            .add_condition("priority = $2", "high")
            .order_by("created_at", false)
            .limit(10);
        
        let sql = query.build_select();
        assert!(sql.contains("SELECT * FROM tasks"));
        assert!(sql.contains("WHERE status = $1 AND priority = $2"));
        assert!(sql.contains("ORDER BY created_at DESC"));
        assert!(sql.contains("LIMIT 10"));
    }
}
}

11.3.2 事务管理

#![allow(unused)]
fn main() {
use sqlx::PgPool;
use sqlx::Transaction;
use tokio::sync::Mutex;
use std::sync::Arc;

pub struct TransactionManager {
    pool: PgPool,
}

impl TransactionManager {
    pub fn new(pool: PgPool) -> Self {
        TransactionManager { pool }
    }
    
    pub async fn execute_in_transaction<T, F, R>(
        &self,
        operation: F
    ) -> Result<T, Box<dyn std::error::Error + Send + Sync>>
    where
        F: Fn(&mut sqlx::Transaction<'_, sqlx::Postgres>) -> R,
        R: std::future::Future<Output = Result<T, Box<dyn std::error::Error + Send + Sync>>>,
    {
        let mut tx = self.pool.begin().await?;
        
        let result = operation(&mut tx).await?;
        
        tx.commit().await?;
        Ok(result)
    }
    
    pub async fn batch_insert<T>(
        &self,
        items: &[T],
        insert_query: &str
    ) -> Result<Vec<i64>, Box<dyn std::error::Error + Send + Sync>>
    where
        T: sqlx::Encode<'static, sqlx::Postgres> + Send + Clone
    {
        let mut tx = self.pool.begin().await?;
        let mut ids = Vec::new();
        
        for item in items {
            let result = sqlx::query(insert_query)
                .bind(item)
                .execute(&mut *tx)
                .await?;
            
            ids.push(result.last_insert_id());
        }
        
        tx.commit().await?;
        Ok(ids)
    }
    
    pub async fn ensure_data_consistency<F, R>(
        &self,
        operations: Vec<F>
    ) -> Result<R, Box<dyn std::error::Error + Send + Sync>>
    where
        F: Fn(&mut sqlx::Transaction<'_, sqlx::Postgres>) -> R,
        R: std::future::Future<Output = Result<R, Box<dyn std::error::Error + Send + Sync>>>,
    {
        let mut tx = self.pool.begin().await?;
        
        for operation in operations {
            let _ = operation(&mut tx).await?;
        }
        
        tx.commit().await?;
        Ok(())
    }
}

// 使用事务的示例
async fn create_project_with_tasks(
    pool: &sqlx::PgPool,
    project_data: &ProjectData,
    tasks: &[TaskData]
) -> Result<Project, sqlx::Error> {
    let mut tx = pool.begin().await?;
    
    // 创建项目
    let project = sqlx::query_as!(
        Project,
        "INSERT INTO projects (name, description, owner_id) VALUES ($1, $2, $3) RETURNING *",
        project_data.name,
        project_data.description,
        project_data.owner_id
    )
    .fetch_one(&mut *tx)
    .await?;
    
    // 创建任务
    for task_data in tasks {
        sqlx::query!(
            "INSERT INTO tasks (title, description, project_id, created_by_id) VALUES ($1, $2, $3, $4)",
            task_data.title,
            task_data.description,
            project.id,
            task_data.created_by_id
        )
        .execute(&mut *tx)
        .await?;
    }
    
    tx.commit().await?;
    Ok(project)
}
}

11.3.3 批量操作优化

#![allow(unused)]
fn main() {
use sqlx::{PgPool, Row};
use tokio::time::Instant;

pub struct BatchOperations {
    pool: PgPool,
    batch_size: usize,
}

impl BatchOperations {
    pub fn new(pool: PgPool, batch_size: usize) -> Self {
        BatchOperations { pool, batch_size }
    }
    
    pub async fn batch_insert_users(
        &self,
        users: &[UserData]
    ) -> Result<Vec<i64>, sqlx::Error> {
        let mut ids = Vec::new();
        
        for batch in users.chunks(self.batch_size) {
            let mut tx = self.pool.begin().await?;
            
            for user_data in batch {
                let result = sqlx::query!(
                    "INSERT INTO users (username, email, password_hash) VALUES ($1, $2, $3) RETURNING id",
                    user_data.username,
                    user_data.email,
                    user_data.password_hash
                )
                .fetch_one(&mut *tx)
                .await?;
                
                ids.push(result.id);
            }
            
            tx.commit().await?;
        }
        
        Ok(ids)
    }
    
    pub async fn batch_update_task_statuses(
        &self,
        updates: &[(i64, String)]
    ) -> Result<u64, sqlx::Error> {
        let start_time = Instant::now();
        
        // 使用批量更新语句
        let mut query_builder = String::from("UPDATE tasks SET status = CASE id ");
        let mut params: Vec<Box<dyn sqlx::Encode<'static, Postgres> + Send>> = Vec::new();
        let mut param_counter = 1;
        
        for (task_id, status) in updates {
            query_builder.push_str(&format!("WHEN ${} THEN ${} ", param_counter, param_counter + 1));
            params.push(Box::new(*task_id) as Box<dyn sqlx::Encode<'static, Postgres> + Send>);
            params.push(Box::new(status.clone()) as Box<dyn sqlx::Encode<'static, Postgres> + Send>);
            param_counter += 2;
        }
        
        query_builder.push_str("END WHERE id = ANY($)");
        let task_ids: Vec<i64> = updates.iter().map(|(id, _)| *id).collect();
        params.push(Box::new(task_ids) as Box<dyn sqlx::Encode<'static, Postgres> + Send>);
        
        let mut query = sqlx::query(&query_builder);
        for param in params {
            // 绑定参数
            // 简化实现
        }
        
        let result = query.execute(&self.pool).await?;
        
        let duration = start_time.elapsed();
        tracing::info!("Batch update completed in {:?}", duration);
        
        Ok(result.rows_affected())
    }
    
    pub async fn batch_delete_old_tasks(
        &self,
        before_date: chrono::DateTime<chrono::Utc>
    ) -> Result<u64, sqlx::Error> {
        let result = sqlx::query!(
            "DELETE FROM tasks WHERE created_at < $1",
            before_date
        )
        .execute(&self.pool)
        .await?;
        
        Ok(result.rows_affected())
    }
    
    pub async fn bulk_upsert_projects(
        &self,
        projects: &[ProjectData]
    ) -> Result<Vec<i64>, sqlx::Error> {
        // 使用ON CONFLICT进行批量插入或更新
        let mut values = Vec::new();
        let mut param_index = 1;
        
        for project in projects {
            values.push(format!(
                "(${}, ${}, ${}, ${}, NOW())",
                param_index,
                param_index + 1,
                param_index + 2,
                param_index + 3
            ));
            param_index += 4;
        }
        
        let query = format!(
            r#"
            INSERT INTO projects (name, description, owner_id, created_at)
            VALUES {}
            ON CONFLICT (name) DO UPDATE SET
                description = EXCLUDED.description,
                owner_id = EXCLUDED.owner_id,
                updated_at = NOW()
            RETURNING id
            "#,
            values.join(", ")
        );
        
        // 构建并执行查询
        // 实际实现中需要正确绑定参数
        let mut query_builder = sqlx::query(&query);
        
        // 添加所有参数
        for project in projects {
            query_builder = query_builder
                .bind(&project.name)
                .bind(&project.description)
                .bind(&project.owner_id);
        }
        
        let rows = query_builder.fetch_all(&self.pool).await?;
        let ids: Vec<i64> = rows.iter().map(|row| row.get(0)).collect();
        
        Ok(ids)
    }
}

#[derive(Debug, Clone)]
struct UserData {
    username: String,
    email: String,
    password_hash: String,
}

#[derive(Debug, Clone)]
struct ProjectData {
    name: String,
    description: Option<String>,
    owner_id: i64,
}

#[derive(Debug, Clone)]
struct TaskData {
    title: String,
    description: Option<String>,
    created_by_id: i64,
}
}

11.4 连接池管理

11.4.1 高级连接池配置

#![allow(unused)]
fn main() {
use sqlx::{PgPool, PgPoolOptions};
use tokio::sync::RwLock;
use std::time::Duration;
use std::collections::HashMap;
use tracing::{info, warn, error};

pub struct ConnectionPoolManager {
    pools: RwLock<HashMap<String, PgPool>>,
    pool_configs: HashMap<String, PoolConfig>,
}

#[derive(Debug, Clone)]
pub struct PoolConfig {
    pub max_connections: u32,
    pub min_connections: u32,
    pub max_lifetime: Duration,
    pub idle_timeout: Duration,
    pub connect_timeout: Duration,
    pub acquire_timeout: Duration,
    pub health_check_interval: Duration,
}

impl Default for PoolConfig {
    fn default() -> Self {
        PoolConfig {
            max_connections: 20,
            min_connections: 5,
            max_lifetime: Duration::from_secs(1800),
            idle_timeout: Duration::from_secs(300),
            connect_timeout: Duration::from_secs(10),
            acquire_timeout: Duration::from_secs(30),
            health_check_interval: Duration::from_secs(60),
        }
    }
}

impl ConnectionPoolManager {
    pub fn new() -> Self {
        ConnectionPoolManager {
            pools: RwLock::new(HashMap::new()),
            pool_configs: HashMap::new(),
        }
    }
    
    pub async fn add_pool(
        &self,
        name: &str,
        connection_string: &str,
        config: Option<PoolConfig>
    ) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        let pool_config = config.unwrap_or_default();
        
        let pool = PgPoolOptions::new()
            .max_connections(pool_config.max_connections)
            .min_connections(pool_config.min_connections)
            .max_lifetime(pool_config.max_lifetime)
            .idle_timeout(pool_config.idle_timeout)
            .connect_timeout(pool_config.connect_timeout)
            .acquire_timeout(pool_config.acquire_timeout)
            .connect(connection_string)
            .await?;
        
        // 测试连接
        let test_result: Result<(i64,), sqlx::Error> = sqlx::query_as("SELECT 1")
            .fetch_one(&pool)
            .await;
        
        if let Err(e) = test_result {
            return Err(format!("Failed to test connection for pool '{}': {}", name, e).into());
        }
        
        // 存储池和配置
        {
            let mut pools = self.pools.write().await;
            pools.insert(name.to_string(), pool);
        }
        
        self.pool_configs.insert(name.to_string(), pool_config.clone());
        
        // 启动健康检查
        let pool_name = name.to_string();
        let pool_clone = pool.clone();
        let config_clone = pool_config.clone();
        
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(config_clone.health_check_interval);
            loop {
                interval.tick().await;
                
                if let Err(e) = Self::health_check_pool(&pool_clone).await {
                    warn!("Health check failed for pool '{}': {}", pool_name, e);
                    // 这里可以添加告警逻辑
                }
            }
        });
        
        info!("Connection pool '{}' initialized successfully", name);
        Ok(())
    }
    
    async fn health_check_pool(pool: &sqlx::PgPool) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        let result: Result<(i64,), sqlx::Error> = sqlx::query_as("SELECT 1")
            .fetch_one(pool)
            .await;
        
        if let Err(e) = result {
            return Err(format!("Health check failed: {}", e).into());
        }
        
        // 检查连接统计
        let stats = pool.statistics();
        if stats.idle_connections() == 0 {
            warn!("No idle connections in pool");
        }
        
        if stats.busy_connections() == pool.size() {
            warn!("All connections in pool are busy");
        }
        
        Ok(())
    }
    
    pub async fn get_pool(&self, name: &str) -> Option<sqlx::PgPool> {
        let pools = self.pools.read().await;
        pools.get(name).cloned()
    }
    
    pub async fn get_pool_with_timeout(
        &self,
        name: &str,
        timeout: Duration
    ) -> Result<sqlx::PgPool, Box<dyn std::error::Error + Send + Sync>> {
        let pool = self.get_pool(name)
            .await
            .ok_or_else(|| format!("Pool '{}' not found", name))?;
        
        // 尝试获取连接，带超时
        let start = std::time::Instant::now();
        loop {
            match tokio::time::timeout(timeout, pool.acquire()).await {
                Ok(Ok(_)) => {
                    return Ok(pool);
                }
                Ok(Err(e)) => {
                    return Err(format!("Failed to acquire connection from pool '{}': {}", name, e).into());
                }
                Err(_) => {
                    if start.elapsed() >= timeout {
                        return Err(format!("Timeout acquiring connection from pool '{}'", name).into());
                    }
                    tokio::time::sleep(Duration::from_millis(100)).await;
                }
            }
        }
    }
    
    pub async fn list_pools(&self) -> Vec<String> {
        let pools = self.pools.read().await;
        pools.keys().cloned().collect()
    }
    
    pub async fn close_pool(&self, name: &str) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
        let mut pools = self.pools.write().await;
        if let Some(pool) = pools.remove(name) {
            pool.close().await;
            info!("Connection pool '{}' closed", name);
        }
        
        self.pool_configs.remove(name);
        Ok(())
    }
    
    pub async fn get_pool_stats(&self, name: &str) -> Option<PoolStats> {
        let pools = self.pools.read().await;
        if let Some(pool) = pools.get(name) {
            let stats = pool.statistics();
            Some(PoolStats {
                size: pool.size(),
                idle_connections: stats.idle_connections(),
                busy_connections: stats.busy_connections(),
                total_connections: stats.total_connections(),
            })
        } else {
            None
        }
    }
}

#[derive(Debug, Clone)]
pub struct PoolStats {
    pub size: u32,
    pub idle_connections: u32,
    pub busy_connections: u32,
    pub total_connections: u32,
}

// 智能连接分配
pub struct ConnectionRouter {
    manager: ConnectionPoolManager,
    routing_rules: HashMap<String, String>, // table -> pool_name
}

impl ConnectionRouter {
    pub fn new(manager: ConnectionPoolManager) -> Self {
        ConnectionRouter {
            manager,
            routing_rules: HashMap::new(),
        }
    }
    
    pub fn add_routing_rule(&mut self, table: &str, pool_name: &str) {
        self.routing_rules.insert(table.to_string(), pool_name.to_string());
    }
    
    pub async fn get_connection_for_table(&self, table: &str) -> Result<sqlx::PgPool, Box<dyn std::error::Error + Send + Sync>> {
        if let Some(pool_name) = self.routing_rules.get(table) {
            self.manager.get_pool_with_timeout(pool_name, Duration::from_secs(5)).await
        } else {
            // 默认使用第一个可用的池
            let pools = self.manager.list_pools().await;
            if let Some(pool_name) = pools.first() {
                self.manager.get_pool_with_timeout(pool_name, Duration::from_secs(5)).await
            } else {
                Err("No connection pools available".into())
            }
        }
    }
}
}

11.4.2 连接池监控

#![allow(unused)]
fn main() {
use tokio::sync::RwLock;
use std::time::{Duration, Instant};
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

pub struct PoolMonitor {
    pools: Arc<RwLock<ConnectionPoolManager>>,
    metrics: Arc<RwLock<PoolMetrics>>,
    collection_interval: Duration,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolMetrics {
    pool_name: String,
    timestamp: Instant,
    connection_count: u32,
    idle_connections: u32,
    busy_connections: u32,
    query_count: u64,
    average_query_time: Duration,
    slow_queries: Vec<SlowQuery>,
    errors: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SlowQuery {
    query: String,
    duration: Duration,
    timestamp: Instant,
}

impl PoolMonitor {
    pub fn new(pools: Arc<RwLock<ConnectionPoolManager>>) -> Self {
        PoolMonitor {
            pools,
            metrics: Arc::new(RwLock::new(PoolMetrics {
                pool_name: String::new(),
                timestamp: Instant::now(),
                connection_count: 0,
                idle_connections: 0,
                busy_connections: 0,
                query_count: 0,
                average_query_time: Duration::from_millis(0),
                slow_queries: Vec::new(),
                errors: 0,
            })),
            collection_interval: Duration::from_secs(30),
        }
    }
    
    pub async fn start_monitoring(&self) {
        let pools = Arc::clone(&self.pools);
        let metrics = Arc::clone(&self.metrics);
        
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(Duration::from_secs(30));
            loop {
                interval.tick().await;
                
                // 收集所有池的指标
                if let Ok(pool_list) = pools.read().await.list_pools().await {
                    for pool_name in pool_list {
                        if let Some(stats) = pools.read().await.get_pool_stats(&pool_name).await {
                            let mut metrics_guard = metrics.write().await;
                            metrics_guard.pool_name = pool_name;
                            metrics_guard.connection_count = stats.size;
                            metrics_guard.idle_connections = stats.idle_connections;
                            metrics_guard.busy_connections = stats.busy_connections;
                        }
                    }
                }
            }
        });
    }
    
    pub async fn record_query(&self, pool_name: &str, query: &str, duration: Duration) {
        let mut metrics_guard = self.metrics.write().await;
        
        if metrics_guard.pool_name == pool_name {
            metrics_guard.query_count += 1;
            
            // 更新平均查询时间
            let total_time = metrics_guard.average_query_time * (metrics_guard.query_count - 1);
            metrics_guard.average_query_time = total_time / metrics_guard.query_count + duration / metrics_guard.query_count;
            
            // 记录慢查询
            if duration > Duration::from_millis(1000) {
                metrics_guard.slow_queries.push(SlowQuery {
                    query: query.to_string(),
                    duration,
                    timestamp: Instant::now(),
                });
                
                // 只保留最近的10个慢查询
                if metrics_guard.slow_queries.len() > 10 {
                    metrics_guard.slow_queries.remove(0);
                }
            }
        }
    }
    
    pub async fn record_error(&self, pool_name: &str) {
        let mut metrics_guard = self.metrics.write().await;
        if metrics_guard.pool_name == pool_name {
            metrics_guard.errors += 1;
        }
    }
    
    pub async fn get_metrics(&self) -> PoolMetrics {
        self.metrics.read().await.clone()
    }
    
    pub async fn get_pool_health(&self, pool_name: &str) -> PoolHealth {
        let metrics = self.get_metrics().await;
        
        let connection_usage = if metrics.connection_count > 0 {
            metrics.busy_connections as f64 / metrics.connection_count as f64
        } else {
            0.0
        };
        
        let health_score = if connection_usage > 0.9 {
            PoolHealthStatus::Critical
        } else if connection_usage > 0.7 {
            PoolHealthStatus::Warning
        } else if metrics.errors > 0 {
            PoolHealthStatus::Degraded
        } else {
            PoolHealthStatus::Healthy
        };
        
        PoolHealth {
            pool_name: pool_name.to_string(),
            status: health_score,
            connection_usage,
            error_rate: if metrics.query_count > 0 {
                metrics.errors as f64 / metrics.query_count as f64
            } else {
                0.0
            },
            average_query_time: metrics.average_query_time,
            last_updated: metrics.timestamp,
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PoolHealthStatus {
    Healthy,
    Degraded,
    Warning,
    Critical,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PoolHealth {
    pub pool_name: String,
    pub status: PoolHealthStatus,
    pub connection_usage: f64,
    pub error_rate: f64,
    pub average_query_time: Duration,
    pub last_updated: Instant,
}
}

11.5 迁移管理

11.5.1 迁移系统设计

#![allow(unused)]
fn main() {
use sqlx::{PgPool, Migrate, Migration};
use std::collections::HashMap;
use std::time::{Duration, Instant};
use tracing::{info, warn, error};

#[derive(Debug, Clone)]
pub struct MigrationConfig {
    pub auto_migrate: bool,
    pub backup_before_migration: bool,
    pub transaction_per_migration: bool,
    pub verify_checksums: bool,
}

impl Default for MigrationConfig {
    fn default() -> Self {
        MigrationConfig {
            auto_migrate: true,
            backup_before_migration: true,
            transaction_per_migration: true,
            verify_checksums: true,
        }
    }
}

pub struct MigrationManager {
    pool: PgPool,
    migrations: HashMap<String, DatabaseMigration>,
    config: MigrationConfig,
}

#[derive(Debug, Clone)]
struct DatabaseMigration {
    id: String,
    description: String,
    sql: String,
    checksum: String,
    created_at: Instant,
    applied_at: Option<Instant>,
}

impl MigrationManager {
    pub fn new(pool: PgPool, config: Option<MigrationConfig>) -> Self {
        MigrationManager {
            pool,
            migrations: HashMap::new(),
            config: config.unwrap_or_default(),
        }
    }
    
    pub fn add_migration(&mut self, id: &str, description: &str, sql: &str) -> Result<(), Box<dyn std::error::Error>> {
        let checksum = self.calculate_checksum(sql);
        
        let migration = DatabaseMigration {
            id: id.to_string(),
            description: description.to_string(),
            sql: sql.to_string(),
            checksum,
            created_at: Instant::now(),
            applied_at: None,
        };
        
        self.migrations.insert(id.to_string(), migration);
        info!("Added migration: {} - {}", id, description);
        
        Ok(())
    }
    
    pub async fn run_migrations(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        info!("Starting migration process");
        
        // 创建迁移历史表
        self.create_migration_table().await?;
        
        // 获取已应用迁移列表
        let applied_migrations = self.get_applied_migrations().await?;
        let applied_ids: std::collections::HashSet<String> = applied_migrations.into_iter().collect();
        
        // 找出需要应用的新迁移
        let mut pending_migrations = Vec::new();
        for migration in self.migrations.values() {
            if !applied_ids.contains(&migration.id) {
                pending_migrations.push(migration.clone());
            }
        }
        
        // 按ID排序确保执行顺序
        pending_migrations.sort_by(|a, b| a.id.cmp(&b.id));
        
        if pending_migrations.is_empty() {
            info!("No pending migrations");
            return Ok(());
        }
        
        info!("Found {} pending migrations", pending_migrations.len());
        
        // 执行迁移
        for migration in pending_migrations {
            self.apply_migration(&migration).await?;
        }
        
        info!("Migration process completed successfully");
        Ok(())
    }
    
    async fn create_migration_table(&self) -> Result<(), sqlx::Error> {
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS schema_migrations (
                id VARCHAR(255) PRIMARY KEY,
                description TEXT,
                checksum VARCHAR(64) NOT NULL,
                created_at TIMESTAMPTZ NOT NULL,
                applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
            )
        "#).execute(&self.pool).await?;
        
        Ok(())
    }
    
    async fn get_applied_migrations(&self) -> Result<Vec<String>, sqlx::Error> {
        let rows = sqlx::query!("SELECT id FROM schema_migrations ORDER BY id")
            .fetch_all(&self.pool)
            .await?;
        
        Ok(rows.into_iter().map(|row| row.id).collect())
    }
    
    async fn apply_migration(&self, migration: &DatabaseMigration) -> Result<(), Box<dyn std::error::Error>> {
        info!("Applying migration: {} - {}", migration.id, migration.description);
        
        if self.config.transaction_per_migration {
            let mut tx = self.pool.begin().await?;
            
            // 执行迁移SQL
            sqlx::query(&migration.sql).execute(&mut *tx).await?;
            
            // 记录迁移历史
            sqlx::query!(
                "INSERT INTO schema_migrations (id, description, checksum, created_at) VALUES ($1, $2, $3, $4)",
                migration.id,
                migration.description,
                migration.checksum,
                migration.created_at
            )
            .execute(&mut *tx)
            .await?;
            
            tx.commit().await?;
        } else {
            // 直接执行
            sqlx::query(&migration.sql).execute(&self.pool).await?;
            
            sqlx::query!(
                "INSERT INTO schema_migrations (id, description, checksum, created_at) VALUES ($1, $2, $3, $4)",
                migration.id,
                migration.description,
                migration.checksum,
                migration.created_at
            )
            .execute(&self.pool)
            .await?;
        }
        
        if self.config.verify_checksums {
            // 验证checksum
            let current_checksum = self.calculate_checksum(&migration.sql);
            if current_checksum != migration.checksum {
                warn!("Checksum mismatch for migration {}", migration.id);
            }
        }
        
        info!("Successfully applied migration: {}", migration.id);
        Ok(())
    }
    
    pub async fn rollback_migration(&self, migration_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        info!("Rolling back migration: {}", migration_id);
        
        // 检查迁移是否存在
        let exists = sqlx::query!(
            "SELECT 1 FROM schema_migrations WHERE id = $1",
            migration_id
        )
        .fetch_optional(&self.pool)
        .await?
        .is_some();
        
        if !exists {
            return Err(format!("Migration {} not found", migration_id).into());
        }
        
        // 获取迁移信息
        let migration_info = sqlx::query!(
            "SELECT description FROM schema_migrations WHERE id = $1",
            migration_id
        )
        .fetch_one(&self.pool)
        .await?;
        
        // 这里需要实现回滚逻辑
        // 实际实现中应该存储回滚SQL
        warn!("Rollback for migration {} ({}) needs to be implemented", migration_id, migration_info.description);
        
        Ok(())
    }
    
    pub async fn get_migration_status(&self) -> Result<Vec<MigrationStatus>, Box<dyn std::error::Error>> {
        let applied_migrations = self.get_applied_migrations().await?;
        let applied_ids: std::collections::HashSet<String> = applied_migrations.into_iter().collect();
        
        let mut status = Vec::new();
        
        for migration in self.migrations.values() {
            let is_applied = applied_ids.contains(&migration.id);
            status.push(MigrationStatus {
                id: migration.id.clone(),
                description: migration.description.clone(),
                status: if is_applied { "applied".to_string() } else { "pending".to_string() },
                applied_at: if is_applied { Some(migration.created_at) } else { None },
                checksum: migration.checksum.clone(),
            });
        }
        
        status.sort_by(|a, b| a.id.cmp(&b.id));
        Ok(status)
    }
    
    fn calculate_checksum(&self, sql: &str) -> String {
        use sha2::{Sha256, Digest};
        
        let mut hasher = Sha256::new();
        hasher.update(sql);
        format!("{:x}", hasher.finalize())
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MigrationStatus {
    pub id: String,
    pub description: String,
    pub status: String,
    pub applied_at: Option<Instant>,
    pub checksum: String,
}
}

11.5.2 自动迁移系统

#![allow(unused)]
fn main() {
use std::fs;
use std::path::Path;
use sqlx::PgPool;
use tracing::{info, warn, error};

pub struct AutomaticMigrationSystem {
    pool: PgPool,
    migration_directory: std::path::PathBuf,
    config: MigrationConfig,
}

impl AutomaticMigrationSystem {
    pub fn new(pool: PgPool, migration_directory: &str) -> Self {
        AutomaticMigrationSystem {
            pool,
            migration_directory: Path::new(migration_directory).to_path_buf(),
            config: MigrationConfig::default(),
        }
    }
    
    pub async fn discover_and_run_migrations(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        if !self.migration_directory.exists() {
            fs::create_dir_all(&self.migration_directory)?;
            info!("Created migration directory: {:?}", self.migration_directory);
        }
        
        // 扫描迁移文件
        let migration_files = self.scan_migration_files().await?;
        info!("Found {} migration files", migration_files.len());
        
        // 创建迁移管理器
        let mut migration_manager = MigrationManager::new(self.pool.clone(), Some(self.config.clone()));
        
        // 添加发现的迁移
        for file in migration_files {
            let migration = self.load_migration_file(&file).await?;
            migration_manager.add_migration(&migration.id, &migration.description, &migration.sql)?;
        }
        
        // 运行迁移
        migration_manager.run_migrations().await?;
        
        Ok(())
    }
    
    async fn scan_migration_files(&self) -> Result<Vec<MigrationFile>, Box<dyn std::error::Error>> {
        let mut files = Vec::new();
        
        if self.migration_directory.exists() {
            let entries = fs::read_dir(&self.migration_directory)?;
            
            for entry in entries {
                let entry = entry?;
                let path = entry.path();
                
                if path.is_file() && path.extension().and_then(|s| s.to_str()) == Some("sql") {
                    let file_name = path.file_stem()
                        .and_then(|s| s.to_str())
                        .ok_or_else(|| "Invalid file name".to_string())?;
                    
                    let parts: Vec<&str> = file_name.split('_').collect();
                    if parts.len() >= 2 {
                        let timestamp = parts[0].to_string();
                        let id = parts[1].to_string();
                        let description = parts[2..].join(" ");
                        
                        files.push(MigrationFile {
                            path,
                            timestamp,
                            id,
                            description,
                        });
                    }
                }
            }
        }
        
        // 按时间戳排序
        files.sort_by(|a, b| a.timestamp.cmp(&b.timestamp));
        Ok(files)
    }
    
    async fn load_migration_file(&self, file: &MigrationFile) -> Result<MigrationFile, Box<dyn std::error::Error>> {
        let content = fs::read_to_string(&file.path)?;
        Ok(MigrationFile {
            path: file.path.clone(),
            timestamp: file.timestamp.clone(),
            id: file.id.clone(),
            description: file.description.clone(),
            content: Some(content),
        })
    }
    
    pub async fn create_migration_file(&self, id: &str, description: &str) -> Result<std::path::PathBuf, Box<dyn std::error::Error>> {
        let timestamp = chrono::Utc::now().format("%Y%m%d_%H%M%S").to_string();
        let filename = format!("{}_{}_{}.sql", timestamp, id, description.replace(' ', "_"));
        let file_path = self.migration_directory.join(filename);
        
        let content = format!(
            "-- Migration: {} - {}\n-- Created: {}\n\nBEGIN;\n\n-- TODO: Add your migration SQL here\n\nCOMMIT;\n",
            id,
            description,
            chrono::Utc::now().to_rfc3339()
        );
        
        fs::write(&file_path, content)?;
        
        info!("Created migration file: {:?}", file_path);
        Ok(file_path)
    }
}

#[derive(Debug, Clone)]
struct MigrationFile {
    path: std::path::PathBuf,
    timestamp: String,
    id: String,
    description: String,
    content: Option<String>,
}

impl MigrationFile {
    pub fn sql(&self) -> &str {
        self.content.as_deref().unwrap_or("")
    }
}
}

11.6 企业级任务管理平台

现在我们来构建一个完整的企业级任务管理系统，集成所有学到的数据库技术。

#![allow(unused)]
fn main() {
// 任务管理系统主项目
// File: task-manager/Cargo.toml
/*
[package]
name = "enterprise-task-manager"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "uuid", "chrono"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
chrono = { version = "0.4", features = ["serde"] }
uuid = { version = "1.0", features = ["v4", "serde"] }
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
bcrypt = "0.15"
jsonwebtoken = "9.0"
reqwest = { version = "0.11", features = ["json"] }
anyhow = "1.0"
thiserror = "1.0"
*/

// 核心数据结构
// File: task-manager/src/models.rs
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};
use uuid::Uuid;
use sqlx::{FromRow, Type};

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub password_hash: String,
    pub is_active: bool,
    pub role: UserRole,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub last_login: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "user_role")]
#[serde(rename_all = "snake_case")]
pub enum UserRole {
    Admin,
    Manager,
    Member,
    Viewer,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Team {
    pub id: Uuid,
    pub name: String,
    pub description: Option<String>,
    pub owner_id: Uuid,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Project {
    pub id: Uuid,
    pub name: String,
    pub description: Option<String>,
    pub team_id: Uuid,
    pub owner_id: Uuid,
    pub status: ProjectStatus,
    pub priority: ProjectPriority,
    pub start_date: Option<DateTime<Utc>>,
    pub end_date: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "project_status")]
#[serde(rename_all = "snake_case")]
pub enum ProjectStatus {
    Planning,
    Active,
    OnHold,
    Completed,
    Cancelled,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "project_priority")]
#[serde(rename_all = "snake_case")]
pub enum ProjectPriority {
    Low,
    Medium,
    High,
    Critical,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Task {
    pub id: Uuid,
    pub title: String,
    pub description: Option<String>,
    pub project_id: Uuid,
    pub assignee_id: Option<Uuid>,
    pub created_by_id: Uuid,
    pub status: TaskStatus,
    pub priority: TaskPriority,
    pub task_type: TaskType,
    pub estimated_hours: Option<f64>,
    pub actual_hours: f64,
    pub due_date: Option<DateTime<Utc>>,
    pub completed_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub progress: i32, // 0-100
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "task_status")]
#[serde(rename_all = "snake_case")]
pub enum TaskStatus {
    Todo,
    InProgress,
    InReview,
    Testing,
    Completed,
    Cancelled,
    Blocked,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "task_priority")]
#[serde(rename_all = "snake_case")]
pub enum TaskPriority {
    Low,
    Medium,
    High,
    Urgent,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "task_type")]
#[serde(rename_all = "snake_case")]
pub enum TaskType {
    Feature,
    BugFix,
    Documentation,
    Design,
    Testing,
    Research,
    Other,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct TaskComment {
    pub id: Uuid,
    pub task_id: Uuid,
    pub user_id: Uuid,
    pub content: String,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct TaskAttachment {
    pub id: Uuid,
    pub task_id: Uuid,
    pub filename: String,
    pub file_path: String,
    pub file_size: i64,
    pub mime_type: String,
    pub uploaded_by: Uuid,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct TimeEntry {
    pub id: Uuid,
    pub task_id: Uuid,
    pub user_id: Uuid,
    pub hours: f64,
    pub description: Option<String>,
    pub date: DateTime<Utc>,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Notification {
    pub id: Uuid,
    pub user_id: Uuid,
    pub title: String,
    pub message: String,
    pub notification_type: NotificationType,
    pub is_read: bool,
    pub related_id: Option<Uuid>,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "notification_type")]
#[serde(rename_all = "snake_case")]
pub enum NotificationType {
    TaskAssigned,
    TaskCompleted,
    TaskOverdue,
    ProjectUpdated,
    CommentAdded,
    System,
}

// API请求/响应结构
#[derive(Debug, Serialize, Deserialize)]
pub struct CreateUserRequest {
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub password: String,
    pub role: UserRole,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateProjectRequest {
    pub name: String,
    pub description: Option<String>,
    pub team_id: Uuid,
    pub priority: ProjectPriority,
    pub start_date: Option<DateTime<Utc>>,
    pub end_date: Option<DateTime<Utc>>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateTaskRequest {
    pub title: String,
    pub description: Option<String>,
    pub project_id: Uuid,
    pub assignee_id: Option<Uuid>,
    pub priority: TaskPriority,
    pub task_type: TaskType,
    pub estimated_hours: Option<f64>,
    pub due_date: Option<DateTime<Utc>>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UpdateTaskRequest {
    pub title: Option<String>,
    pub description: Option<String>,
    pub assignee_id: Option<Uuid>,
    pub status: Option<TaskStatus>,
    pub priority: Option<TaskPriority>,
    pub due_date: Option<DateTime<Utc>>,
    pub progress: Option<i32>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateTimeEntryRequest {
    pub task_id: Uuid,
    pub hours: f64,
    pub description: Option<String>,
    pub date: DateTime<Utc>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ApiResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub error: Option<String>,
    pub timestamp: DateTime<Utc>,
    pub request_id: Uuid,
}

impl<T> ApiResponse<T> {
    pub fn success(data: T) -> Self {
        ApiResponse {
            success: true,
            data: Some(data),
            error: None,
            timestamp: Utc::now(),
            request_id: Uuid::new_v4(),
        }
    }
    
    pub fn error(message: String) -> ApiResponse<T> {
        ApiResponse {
            success: false,
            data: None,
            error: Some(message),
            timestamp: Utc::now(),
            request_id: Uuid::new_v4(),
        }
    }
}

// 查询过滤器
#[derive(Debug, Serialize, Deserialize)]
pub struct TaskFilter {
    pub project_id: Option<Uuid>,
    pub assignee_id: Option<Uuid>,
    pub status: Option<TaskStatus>,
    pub priority: Option<TaskPriority>,
    pub task_type: Option<TaskType>,
    pub due_date_from: Option<DateTime<Utc>>,
    pub due_date_to: Option<DateTime<Utc>>,
    pub created_by: Option<Uuid>,
    pub search: Option<String>,
    pub limit: Option<i64>,
    pub offset: Option<i64>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct ProjectFilter {
    pub team_id: Option<Uuid>,
    pub owner_id: Option<Uuid>,
    pub status: Option<ProjectStatus>,
    pub priority: Option<ProjectPriority>,
    pub start_date_from: Option<DateTime<Utc>>,
    pub start_date_to: Option<DateTime<Utc>>,
    pub end_date_from: Option<DateTime<Utc>>,
    pub end_date_to: Option<DateTime<Utc>>,
    pub search: Option<String>,
    pub limit: Option<i64>,
    pub offset: Option<i64>,
}
}

#![allow(unused)]
fn main() {
// 数据库服务层
// File: task-manager/src/services.rs
use super::models::*;
use crate::database::DatabaseManager;
use sqlx::PgPool;
use tracing::{info, warn, error, instrument};

pub struct UserService {
    pool: DatabaseManager,
}

impl UserService {
    pub fn new(pool: DatabaseManager) -> Self {
        UserService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_user(&self, request: &CreateUserRequest) -> Result<User, sqlx::Error> {
        let password_hash = bcrypt::hash(&request.password, bcrypt::DEFAULT_COST)?;
        
        let user = sqlx::query!(
            r#"
            INSERT INTO users (id, username, email, display_name, password_hash, role, is_active)
            VALUES (gen_random_uuid(), $1, $2, $3, $4, $5, true)
            RETURNING *
            "#,
            request.username,
            request.email,
            request.display_name,
            password_hash,
            request.role as UserRole
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(User::from_row(&user)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_by_id(&self, user_id: &Uuid) -> Result<Option<User>, sqlx::Error> {
        let user = sqlx::query!(
            "SELECT * FROM users WHERE id = $1",
            user_id
        )
        .fetch_optional(&self.pool.pool)
        .await?;
        
        Ok(user.map(|row| User::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_by_username(&self, username: &str) -> Result<Option<User>, sqlx::Error> {
        let user = sqlx::query!(
            "SELECT * FROM users WHERE username = $1",
            username
        )
        .fetch_optional(&self.pool.pool)
        .await?;
        
        Ok(user.map(|row| User::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_by_email(&self, email: &str) -> Result<Option<User>, sqlx::Error> {
        let user = sqlx::query!(
            "SELECT * FROM users WHERE email = $1",
            email
        )
        .fetch_optional(&self.pool.pool)
        .await?;
        
        Ok(user.map(|row| User::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn update_user_last_login(&self, user_id: &Uuid) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE users SET last_login = NOW() WHERE id = $1",
            user_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn get_all_users(&self) -> Result<Vec<User>, sqlx::Error> {
        let users = sqlx::query!(
            "SELECT * FROM users ORDER BY created_at DESC"
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(users.into_iter().map(|row| User::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn authenticate_user(&self, username: &str, password: &str) -> Result<Option<User>, sqlx::Error> {
        if let Some(user) = self.get_user_by_username(username).await? {
            if bcrypt::verify(password, &user.password_hash)? {
                self.update_user_last_login(&user.id).await?;
                Ok(Some(user))
            } else {
                Ok(None)
            }
        } else {
            Ok(None)
        }
    }
}

pub struct ProjectService {
    pool: DatabaseManager,
}

impl ProjectService {
    pub fn new(pool: DatabaseManager) -> Self {
        ProjectService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_project(&self, request: &CreateProjectRequest, owner_id: Uuid) -> Result<Project, sqlx::Error> {
        let project = sqlx::query!(
            r#"
            INSERT INTO projects (id, name, description, team_id, owner_id, status, priority)
            VALUES (gen_random_uuid(), $1, $2, $3, $4, 'active', $5)
            RETURNING *
            "#,
            request.name,
            request.description,
            request.team_id,
            owner_id,
            request.priority as ProjectPriority
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(Project::from_row(&project)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_project_by_id(&self, project_id: &Uuid) -> Result<Option<Project>, sqlx::Error> {
        let project = sqlx::query!(
            "SELECT * FROM projects WHERE id = $1",
            project_id
        )
        .fetch_optional(&self.pool.pool)
        .await?;
        
        Ok(project.map(|row| Project::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn get_projects_by_team(&self, team_id: &Uuid) -> Result<Vec<Project>, sqlx::Error> {
        let projects = sqlx::query!(
            "SELECT * FROM projects WHERE team_id = $1 ORDER BY created_at DESC",
            team_id
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(projects.into_iter().map(|row| Project::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn get_projects_by_user(&self, user_id: &Uuid) -> Result<Vec<Project>, sqlx::Error> {
        let projects = sqlx::query!(
            r#"
            SELECT DISTINCT p.* FROM projects p
            LEFT JOIN project_members pm ON p.id = pm.project_id
            WHERE p.owner_id = $1 OR pm.user_id = $1
            ORDER BY p.created_at DESC
            "#,
            user_id
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(projects.into_iter().map(|row| Project::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn update_project_status(&self, project_id: &Uuid, status: ProjectStatus) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE projects SET status = $1, updated_at = NOW() WHERE id = $2",
            status as ProjectStatus,
            project_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn filter_projects(&self, filter: &ProjectFilter) -> Result<(Vec<Project>, i64), sqlx::Error> {
        let mut where_conditions = Vec::new();
        let mut params: Vec<Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>> = Vec::new();
        let mut param_index = 1;
        
        if let Some(team_id) = &filter.team_id {
            where_conditions.push(format!("team_id = ${}", param_index));
            params.push(Box::new(*team_id) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(owner_id) = &filter.owner_id {
            where_conditions.push(format!("owner_id = ${}", param_index));
            params.push(Box::new(*owner_id) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(status) = &filter.status {
            where_conditions.push(format!("status = ${}", param_index));
            params.push(Box::new(status.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(priority) = &filter.priority {
            where_conditions.push(format!("priority = ${}", param_index));
            params.push(Box::new(priority.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(search) = &filter.search {
            where_conditions.push(format!("(name ILIKE ${} OR description ILIKE ${})", param_index, param_index + 1));
            let search_pattern = format!("%{}%", search);
            params.push(Box::new(search_pattern.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            params.push(Box::new(search_pattern) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 2;
        }
        
        let where_clause = if !where_conditions.is_empty() {
            format!("WHERE {}", where_conditions.join(" AND "))
        } else {
            String::new()
        };
        
        // 获取总数
        let count_query = format!("SELECT COUNT(*) as total FROM projects {}", where_clause);
        let count_row = self.pool.execute_query(&count_query, &params).await?;
        let total: i64 = count_row.get("total");
        
        // 获取分页结果
        let mut query = format!("SELECT * FROM projects {} ORDER BY created_at DESC", where_clause);
        
        if let Some(limit) = filter.limit {
            query.push_str(&format!(" LIMIT {}", limit));
        }
        
        if let Some(offset) = filter.offset {
            query.push_str(&format!(" OFFSET {}", offset));
        }
        
        let projects = self.pool.execute_query(&query, &params).await?;
        Ok((projects, total))
    }
}

pub struct TaskService {
    pool: DatabaseManager,
}

impl TaskService {
    pub fn new(pool: DatabaseManager) -> Self {
        TaskService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_task(&self, request: &CreateTaskRequest, created_by: Uuid) -> Result<Task, sqlx::Error> {
        let task = sqlx::query!(
            r#"
            INSERT INTO tasks (
                id, title, description, project_id, assignee_id, created_by_id, 
                status, priority, task_type, estimated_hours, due_date, progress
            )
            VALUES (
                gen_random_uuid(), $1, $2, $3, $4, $5, 'todo', $6, $7, $8, $9, 0
            )
            RETURNING *
            "#,
            request.title,
            request.description,
            request.project_id,
            request.assignee_id,
            created_by,
            request.priority as TaskPriority,
            request.task_type as TaskType,
            request.estimated_hours,
            request.due_date
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(Task::from_row(&task)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_task_by_id(&self, task_id: &Uuid) -> Result<Option<Task>, sqlx::Error> {
        let task =        let task = sqlx::query!(
            "SELECT * FROM tasks WHERE id = $1",
            task_id
        )
        .fetch_optional(&self.pool.pool)
        .await?;
        
        Ok(task.map(|row| Task::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn get_tasks_by_project(&self, project_id: &Uuid) -> Result<Vec<Task>, sqlx::Error> {
        let tasks = sqlx::query!(
            "SELECT * FROM tasks WHERE project_id = $1 ORDER BY created_at DESC",
            project_id
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(tasks.into_iter().map(|row| Task::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn get_tasks_by_user(&self, user_id: &Uuid) -> Result<Vec<Task>, sqlx::Error> {
        let tasks = sqlx::query!(
            "SELECT * FROM tasks WHERE assignee_id = $1 ORDER BY created_at DESC",
            user_id
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(tasks.into_iter().map(|row| Task::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn update_task(&self, task_id: &Uuid, request: &UpdateTaskRequest) -> Result<Task, sqlx::Error> {
        // 检查任务是否存在
        let task = self.get_task_by_id(task_id).await?.ok_or_else(|| 
            sqlx::Error::RowNotFound
        )?;
        
        // 更新任务
        let updated_task = sqlx::query!(
            r#"
            UPDATE tasks 
            SET 
                title = COALESCE($1, title),
                description = COALESCE($2, description),
                assignee_id = COALESCE($3, assignee_id),
                status = COALESCE($4, status),
                priority = COALESCE($5, priority),
                due_date = COALESCE($6, due_date),
                progress = COALESCE($7, progress),
                updated_at = NOW(),
                completed_at = CASE 
                    WHEN $8 = 'completed' AND status != 'completed' THEN NOW()
                    ELSE completed_at
                END
            WHERE id = $9
            RETURNING *
            "#,
            request.title,
            request.description,
            request.assignee_id,
            request.status.map(|s| s as TaskStatus),
            request.priority.map(|p| p as TaskPriority),
            request.due_date,
            request.progress,
            request.status.as_ref().map(|s| s.to_string()),
            task_id
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(Task::from_row(&updated_task)?)
    }
    
    #[instrument(skip(self))]
    pub async fn update_task_status(&self, task_id: &Uuid, status: TaskStatus) -> Result<(), sqlx::Error> {
        let completed_at = if status == TaskStatus::Completed {
            Some(Utc::now())
        } else {
            None
        };
        
        sqlx::query!(
            r#"
            UPDATE tasks 
            SET status = $1, completed_at = $2, updated_at = NOW()
            WHERE id = $2
            "#,
            status as TaskStatus,
            completed_at,
            task_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn log_time(&self, request: &CreateTimeEntryRequest, user_id: Uuid) -> Result<TimeEntry, sqlx::Error> {
        // 创建时间记录
        let time_entry = sqlx::query!(
            r#"
            INSERT INTO time_entries (id, task_id, user_id, hours, description, date)
            VALUES (gen_random_uuid(), $1, $2, $3, $4, $5)
            RETURNING *
            "#,
            request.task_id,
            user_id,
            request.hours,
            request.description,
            request.date
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        // 更新任务的实际工时
        sqlx::query!(
            r#"
            UPDATE tasks 
            SET actual_hours = actual_hours + $1, updated_at = NOW()
            WHERE id = $2
            "#,
            request.hours,
            request.task_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(TimeEntry::from_row(&time_entry)?)
    }
    
    #[instrument(skip(self))]
    pub async fn filter_tasks(&self, filter: &TaskFilter) -> Result<(Vec<Task>, i64), sqlx::Error> {
        let mut where_conditions = Vec::new();
        let mut params: Vec<Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>> = Vec::new();
        let mut param_index = 1;
        
        if let Some(project_id) = &filter.project_id {
            where_conditions.push(format!("project_id = ${}", param_index));
            params.push(Box::new(*project_id) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(assignee_id) = &filter.assignee_id {
            where_conditions.push(format!("assignee_id = ${}", param_index));
            params.push(Box::new(*assignee_id) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(status) = &filter.status {
            where_conditions.push(format!("status = ${}", param_index));
            params.push(Box::new(status.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(priority) = &filter.priority {
            where_conditions.push(format!("priority = ${}", param_index));
            params.push(Box::new(priority.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(task_type) = &filter.task_type {
            where_conditions.push(format!("task_type = ${}", param_index));
            params.push(Box::new(task_type.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(due_date_from) = &filter.due_date_from {
            where_conditions.push(format!("due_date >= ${}", param_index));
            params.push(Box::new(*due_date_from) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(due_date_to) = &filter.due_date_to {
            where_conditions.push(format!("due_date <= ${}", param_index));
            params.push(Box::new(*due_date_to) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(created_by) = &filter.created_by {
            where_conditions.push(format!("created_by_id = ${}", param_index));
            params.push(Box::new(*created_by) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 1;
        }
        
        if let Some(search) = &filter.search {
            where_conditions.push(format!(
                "(title ILIKE ${} OR description ILIKE ${})", 
                param_index, 
                param_index + 1
            ));
            let search_pattern = format!("%{}%", search);
            params.push(Box::new(search_pattern.clone()) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            params.push(Box::new(search_pattern) as Box<dyn sqlx::Encode<'static, sqlx::Postgres> + Send>);
            param_index += 2;
        }
        
        let where_clause = if !where_conditions.is_empty() {
            format!("WHERE {}", where_conditions.join(" AND "))
        } else {
            String::new()
        };
        
        // 获取总数
        let count_query = format!("SELECT COUNT(*) as total FROM tasks {}", where_clause);
        let count_row = self.pool.execute_query(&count_query, &params).await?;
        let total: i64 = count_row.get("total");
        
        // 获取分页结果
        let mut query = format!("SELECT * FROM tasks {} ORDER BY created_at DESC", where_clause);
        
        if let Some(limit) = filter.limit {
            query.push_str(&format!(" LIMIT {}", limit));
        }
        
        if let Some(offset) = filter.offset {
            query.push_str(&format!(" OFFSET {}", offset));
        }
        
        let tasks = self.pool.execute_query(&query, &params).await?;
        Ok((tasks, total))
    }
    
    #[instrument(skip(self))]
    pub async fn get_task_statistics(&self, project_id: &Uuid) -> Result<TaskStatistics, sqlx::Error> {
        let stats = sqlx::query!(
            r#"
            SELECT 
                COUNT(*) as total_tasks,
                COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed_tasks,
                COUNT(CASE WHEN status = 'in_progress' THEN 1 END) as in_progress_tasks,
                COUNT(CASE WHEN status = 'todo' THEN 1 END) as todo_tasks,
                COUNT(CASE WHEN status = 'blocked' THEN 1 END) as blocked_tasks,
                AVG(progress) as average_progress,
                SUM(actual_hours) as total_hours,
                COUNT(CASE WHEN due_date < NOW() AND status != 'completed' THEN 1 END) as overdue_tasks
            FROM tasks 
            WHERE project_id = $1
            "#,
            project_id
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(TaskStatistics {
            total_tasks: stats.total_tasks,
            completed_tasks: stats.completed_tasks,
            in_progress_tasks: stats.in_progress_tasks,
            todo_tasks: stats.todo_tasks,
            blocked_tasks: stats.blocked_tasks,
            average_progress: stats.average_progress.unwrap_or(0.0),
            total_hours: stats.total_hours.unwrap_or(0.0),
            overdue_tasks: stats.overdue_tasks,
        })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TaskStatistics {
    pub total_tasks: i64,
    pub completed_tasks: i64,
    pub in_progress_tasks: i64,
    pub todo_tasks: i64,
    pub blocked_tasks: i64,
    pub average_progress: f64,
    pub total_hours: f64,
    pub overdue_tasks: i64,
}

pub struct NotificationService {
    pool: DatabaseManager,
}

impl NotificationService {
    pub fn new(pool: DatabaseManager) -> Self {
        NotificationService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_notification(
        &self,
        user_id: Uuid,
        title: String,
        message: String,
        notification_type: NotificationType,
        related_id: Option<Uuid>
    ) -> Result<Notification, sqlx::Error> {
        let notification = sqlx::query!(
            r#"
            INSERT INTO notifications (id, user_id, title, message, notification_type, is_read, related_id)
            VALUES (gen_random_uuid(), $1, $2, $3, $4, false, $5)
            RETURNING *
            "#,
            user_id,
            title,
            message,
            notification_type as NotificationType,
            related_id
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(Notification::from_row(&notification)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_notifications(&self, user_id: &Uuid) -> Result<Vec<Notification>, sqlx::Error> {
        let notifications = sqlx::query!(
            "SELECT * FROM notifications WHERE user_id = $1 ORDER BY created_at DESC",
            user_id
        )
        .fetch_all(&self.pool.pool)
        .await?;
        
        Ok(notifications.into_iter().map(|row| Notification::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn mark_notification_read(&self, notification_id: &Uuid) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE notifications SET is_read = true WHERE id = $1",
            notification_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn mark_all_notifications_read(&self, user_id: &Uuid) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE notifications SET is_read = true WHERE user_id = $1 AND is_read = false",
            user_id
        )
        .execute(&self.pool.pool)
        .await?;
        
        Ok(())
    }
    
    // 自动生成通知
    #[instrument(skip(self))]
    pub async fn notify_task_assigned(&self, task: &Task, assignee_id: Uuid) -> Result<(), sqlx::Error> {
        self.create_notification(
            assignee_id,
            "任务分配".to_string(),
            format!("您被分配了新任务：{}", task.title),
            NotificationType::TaskAssigned,
            Some(task.id)
        ).await?;
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn notify_task_overdue(&self, task: &Task) -> Result<(), sqlx::Error> {
        if let Some(assignee_id) = task.assignee_id {
            self.create_notification(
                assignee_id,
                "任务逾期".to_string(),
                format!("任务 \"{}\" 已逾期", task.title),
                NotificationType::TaskOverdue,
                Some(task.id)
            ).await?;
        }
        
        Ok(())
    }
}
}

#![allow(unused)]
fn main() {
// 报告和分析服务
// File: task-manager/src/analytics.rs
use super::models::*;
use crate::database::DatabaseManager;
use chrono::{Duration, Utc};
use serde::{Serialize, Deserialize};

pub struct AnalyticsService {
    pool: DatabaseManager,
}

impl AnalyticsService {
    pub fn new(pool: DatabaseManager) -> Self {
        AnalyticsService { pool }
    }
    
    pub async fn get_project_analytics(&self, project_id: &Uuid) -> Result<ProjectAnalytics, sqlx::Error> {
        let analytics = sqlx::query!(
            r#"
            WITH task_stats AS (
                SELECT 
                    COUNT(*) as total_tasks,
                    COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed_tasks,
                    COUNT(CASE WHEN status = 'in_progress' THEN 1 END) as in_progress_tasks,
                    COUNT(CASE WHEN status = 'todo' THEN 1 END) as todo_tasks,
                    COUNT(CASE WHEN status = 'blocked' THEN 1 END) as blocked_tasks,
                    COUNT(CASE WHEN due_date < NOW() AND status != 'completed' THEN 1 END) as overdue_tasks,
                    AVG(progress) as average_progress,
                    SUM(estimated_hours) as total_estimated_hours,
                    SUM(actual_hours) as total_actual_hours,
                    AVG(EXTRACT(EPOCH FROM (COALESCE(completed_at, NOW()) - created_at))/3600) as average_completion_time_hours
                FROM tasks
                WHERE project_id = $1
            ),
            user_performance AS (
                SELECT 
                    assignee_id,
                    COUNT(*) as tasks_assigned,
                    COUNT(CASE WHEN status = 'completed' THEN 1 END) as tasks_completed,
                    SUM(actual_hours) as total_hours_logged,
                    AVG(progress) as average_progress
                FROM tasks
                WHERE project_id = $1 AND assignee_id IS NOT NULL
                GROUP BY assignee_id
            )
            SELECT 
                ts.*,
                json_agg(
                    json_build_object(
                        'user_id', up.assignee_id,
                        'tasks_assigned', up.tasks_assigned,
                        'tasks_completed', up.tasks_completed,
                        'total_hours_logged', up.total_hours_logged,
                        'average_progress', up.average_progress
                    )
                ) FILTER (WHERE up.assignee_id IS NOT NULL) as user_performance
            FROM task_stats ts
            LEFT JOIN user_performance up ON true
            GROUP BY ts.total_tasks, ts.completed_tasks, ts.in_progress_tasks, ts.todo_tasks, 
                     ts.blocked_tasks, ts.overdue_tasks, ts.average_progress, 
                     ts.total_estimated_hours, ts.total_actual_hours, ts.average_completion_time_hours
            "#,
            project_id
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(ProjectAnalytics {
            total_tasks: analytics.total_tasks,
            completed_tasks: analytics.completed_tasks,
            in_progress_tasks: analytics.in_progress_tasks,
            todo_tasks: analytics.todo_tasks,
            blocked_tasks: analytics.blocked_tasks,
            overdue_tasks: analytics.overdue_tasks,
            average_progress: analytics.average_progress.unwrap_or(0.0),
            total_estimated_hours: analytics.total_estimated_hours.unwrap_or(0.0),
            total_actual_hours: analytics.total_actual_hours.unwrap_or(0.0),
            average_completion_time_hours: analytics.average_completion_time_hours.unwrap_or(0.0),
            user_performance: analytics.user_performance.unwrap_or_default(),
        })
    }
    
    pub async fn get_team_analytics(&self, team_id: &Uuid, start_date: DateTime<Utc>, end_date: DateTime<Utc>) -> Result<TeamAnalytics, sqlx::Error> {
        let analytics = sqlx::query!(
            r#"
            WITH project_stats AS (
                SELECT 
                    COUNT(*) as total_projects,
                    COUNT(CASE WHEN status = 'active' THEN 1 END) as active_projects,
                    COUNT(CASE WHEN status = 'completed' THEN 1 END) as completed_projects,
                    COUNT(CASE WHEN status = 'cancelled' THEN 1 END) as cancelled_projects
                FROM projects
                WHERE team_id = $1 AND created_at BETWEEN $2 AND $3
            ),
            task_trends AS (
                SELECT 
                    DATE_TRUNC('week', created_at) as week,
                    COUNT(*) as tasks_created,
                    COUNT(CASE WHEN status = 'completed' THEN 1 END) as tasks_completed
                FROM tasks t
                JOIN projects p ON t.project_id = p.id
                WHERE p.team_id = $1 AND t.created_at BETWEEN $2 AND $3
                GROUP BY DATE_TRUNC('week', t.created_at)
                ORDER BY week
            ),
            time_tracking AS (
                SELECT 
                    user_id,
                    DATE_TRUNC('day', date) as day,
                    SUM(hours) as total_hours
                FROM time_entries te
                JOIN tasks t ON te.task_id = t.id
                JOIN projects p ON t.project_id = p.id
                WHERE p.team_id = $1 AND te.date BETWEEN $2 AND $3
                GROUP BY user_id, DATE_TRUNC('day', te.date)
                ORDER BY day, user_id
            )
            SELECT 
                ps.*,
                json_agg(
                    json_build_object(
                        'week', tt.week,
                        'tasks_created', tt.tasks_created,
                        'tasks_completed', tt.tasks_completed
                    )
                ) as task_trends,
                json_agg(
                    json_build_object(
                        'day', tt2.day,
                        'user_id', tt2.user_id,
                        'total_hours', tt2.total_hours
                    )
                ) as time_tracking
            FROM project_stats ps
            LEFT JOIN task_trends tt ON true
            LEFT JOIN time_tracking tt2 ON true
            GROUP BY ps.total_projects, ps.active_projects, ps.completed_projects, ps.cancelled_projects
            "#,
            team_id, start_date, end_date
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(TeamAnalytics {
            total_projects: analytics.total_projects,
            active_projects: analytics.active_projects,
            completed_projects: analytics.completed_projects,
            cancelled_projects: analytics.cancelled_projects,
            task_trends: analytics.task_trends.unwrap_or_default(),
            time_tracking: analytics.time_tracking.unwrap_or_default(),
        })
    }
    
    pub async fn get_user_productivity_report(&self, user_id: &Uuid, days: i64) -> Result<UserProductivityReport, sqlx::Error> {
        let end_date = Utc::now();
        let start_date = end_date - Duration::days(days);
        
        let report = sqlx::query!(
            r#"
            WITH daily_stats AS (
                SELECT 
                    DATE(t.created_at) as date,
                    COUNT(*) as tasks_created,
                    COUNT(CASE WHEN t.status = 'completed' THEN 1 END) as tasks_completed
                FROM tasks t
                WHERE t.created_by_id = $1 AND t.created_at BETWEEN $2 AND $3
                GROUP BY DATE(t.created_at)
                ORDER BY date
            ),
            hourly_stats AS (
                SELECT 
                    DATE(te.date) as date,
                    EXTRACT(hour FROM te.date) as hour,
                    SUM(te.hours) as hours_logged
                FROM time_entries te
                WHERE te.user_id = $1 AND te.date BETWEEN $2 AND $3
                GROUP BY DATE(te.date), EXTRACT(hour FROM te.date)
                ORDER BY date, hour
            )
            SELECT 
                COALESCE(SUM(ds.tasks_created), 0) as total_tasks_created,
                COALESCE(SUM(ds.tasks_completed), 0) as total_tasks_completed,
                COALESCE(SUM(hs.hours_logged), 0) as total_hours_logged,
                COALESCE(AVG(hs.hours_logged), 0) as average_daily_hours,
                json_agg(
                    json_build_object(
                        'date', ds.date,
                        'tasks_created', ds.tasks_created,
                        'tasks_completed', ds.tasks_completed
                    )
                ) as daily_task_stats,
                json_agg(
                    json_build_object(
                        'date', hs.date,
                        'hour', hs.hour,
                        'hours_logged', hs.hours_logged
                    )
                ) FILTER (WHERE hs.date IS NOT NULL) as hourly_stats
            FROM daily_stats ds
            FULL OUTER JOIN (
                SELECT date, NULL as tasks_created, NULL as tasks_completed
                FROM (
                    SELECT DISTINCT DATE(date) as date
                    FROM time_entries
                    WHERE user_id = $1 AND date BETWEEN $2 AND $3
                ) dates
            ) unique_dates ON ds.date = unique_dates.date
            LEFT JOIN (
                SELECT 
                    date, 
                    SUM(hours_logged) as hours_logged
                FROM (
                    SELECT DATE(te.date) as date, SUM(te.hours) as hours_logged
                    FROM time_entries te
                    WHERE te.user_id = $1 AND te.date BETWEEN $2 AND $3
                    GROUP BY DATE(te.date)
                ) daily_hours
                GROUP BY date
            ) hs ON ds.date = hs.date
            GROUP BY ds.date
            "#,
            user_id, start_date, end_date
        )
        .fetch_one(&self.pool.pool)
        .await?;
        
        Ok(UserProductivityReport {
            total_tasks_created: report.total_tasks_created,
            total_tasks_completed: report.total_tasks_completed,
            total_hours_logged: report.total_hours_logged,
            average_daily_hours: report.average_daily_hours,
            daily_task_stats: report.daily_task_stats.unwrap_or_default(),
            hourly_stats: report.hourly_stats.unwrap_or_default(),
        })
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ProjectAnalytics {
    pub total_tasks: i64,
    pub completed_tasks: i64,
    pub in_progress_tasks: i64,
    pub todo_tasks: i64,
    pub blocked_tasks: i64,
    pub overdue_tasks: i64,
    pub average_progress: f64,
    pub total_estimated_hours: f64,
    pub total_actual_hours: f64,
    pub average_completion_time_hours: f64,
    pub user_performance: Vec<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TeamAnalytics {
    pub total_projects: i64,
    pub active_projects: i64,
    pub completed_projects: i64,
    pub cancelled_projects: i64,
    pub task_trends: Vec<serde_json::Value>,
    pub time_tracking: Vec<serde_json::Value>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserProductivityReport {
    pub total_tasks_created: i64,
    pub total_tasks_completed: i64,
    pub total_hours_logged: f64,
    pub average_daily_hours: f64,
    pub daily_task_stats: Vec<serde_json::Value>,
    pub hourly_stats: Vec<serde_json::Value>,
}
}

// 主应用程序
// File: task-manager/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::sync::Arc;
use tokio::sync::RwLock;

mod models;
mod services;
mod database;
mod analytics;
mod web;

use models::*;
use services::*;
use database::DatabaseManager;
use analytics::AnalyticsService;
use web::WebServer;

#[derive(Parser, Debug)]
#[command(name = "task-manager")]
#[command(about = "Enterprise Task Management System")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start the web server
    Server {
        #[arg(short, long, default_value = "0.0.0.0:3000")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://task_user:password@localhost/task_manager")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Run database migrations
    Migrate {
        #[arg(short, long, default_value = "postgres://task_user:password@localhost/task_manager")]
        database_url: String,
    },
    /// Create database and run migrations
    Setup {
        #[arg(short, long, default_value = "postgres://task_user:password@localhost/task_manager")]
        database_url: String,
    },
    /// Generate analytics report
    Analytics {
        #[arg(short, long)]
        project_id: String,
        
        #[arg(short, long, default_value = "postgres://task_user:password@localhost/task_manager")]
        database_url: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "task_manager=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Server { addr, database_url, redis_url } => {
            run_server(addr, database_url, redis_url).await
        }
        Commands::Migrate { database_url } => {
            run_migrations(database_url).await
        }
        Commands::Setup { database_url } => {
            setup_database(database_url).await
        }
        Commands::Analytics { project_id, database_url } => {
            run_analytics(&project_id, database_url).await
        }
    }
}

#[instrument]
async fn run_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting Task Manager server on {}", addr);
    
    // 初始化数据库
    let database_manager = DatabaseManager::new(&database_url).await?;
    let user_service = Arc::new(UserService::new(database_manager.clone()));
    let project_service = Arc::new(ProjectService::new(database_manager.clone()));
    let task_service = Arc::new(TaskService::new(database_manager.clone()));
    let notification_service = Arc::new(NotificationService::new(database_manager.clone()));
    let analytics_service = Arc::new(AnalyticsService::new(database_manager.clone()));
    
    // 启动Web服务器
    let server = WebServer::new(
        addr,
        user_service,
        project_service,
        task_service,
        notification_service,
        analytics_service,
    );
    
    info!("Task Manager server started successfully");
    server.run().await?;
    
    Ok(())
}

#[instrument]
async fn run_migrations(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Running database migrations");
    
    let pool = sqlx::PgPool::connect(&database_url).await?;
    let mut migration_manager = crate::database::MigrationManager::new(pool, None);
    
    // 添加迁移
    migration_manager.add_migration(
        "20240101000000_create_users_table",
        "Create users table",
        r#"
        CREATE TYPE user_role AS ENUM ('admin', 'manager', 'member', 'viewer');
        
        CREATE TABLE users (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(100) UNIQUE NOT NULL,
            display_name VARCHAR(100) NOT NULL,
            password_hash VARCHAR(255) NOT NULL,
            is_active BOOLEAN DEFAULT TRUE,
            role user_role NOT NULL DEFAULT 'member',
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW(),
            last_login TIMESTAMPTZ
        );
        
        CREATE INDEX idx_users_username ON users(username);
        CREATE INDEX idx_users_email ON users(email);
        "#,
    )?;
    
    migration_manager.add_migration(
        "20240101000001_create_teams_table",
        "Create teams table",
        r#"
        CREATE TABLE teams (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            name VARCHAR(100) NOT NULL,
            description TEXT,
            owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        );
        
        CREATE INDEX idx_teams_owner ON teams(owner_id);
        "#,
    )?;
    
    migration_manager.add_migration(
        "20240101000002_create_projects_table",
        "Create projects table",
        r#"
        CREATE TYPE project_status AS ENUM ('planning', 'active', 'on_hold', 'completed', 'cancelled');
        CREATE TYPE project_priority AS ENUM ('low', 'medium', 'high', 'critical');
        
        CREATE TABLE projects (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            name VARCHAR(100) NOT NULL,
            description TEXT,
            team_id UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
            owner_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            status project_status NOT NULL DEFAULT 'planning',
            priority project_priority NOT NULL DEFAULT 'medium',
            start_date TIMESTAMPTZ,
            end_date TIMESTAMPTZ,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        );
        
        CREATE INDEX idx_projects_team ON projects(team_id);
        CREATE INDEX idx_projects_owner ON projects(owner_id);
        CREATE INDEX idx_projects_status ON projects(status);
        "#,
    )?;
    
    migration_manager.add_migration(
        "20240101000003_create_tasks_table",
        "Create tasks table",
        r#"
        CREATE TYPE task_status AS ENUM ('todo', 'in_progress', 'in_review', 'testing', 'completed', 'cancelled', 'blocked');
        CREATE TYPE task_priority AS ENUM ('low', 'medium', 'high', 'urgent');
        CREATE TYPE task_type AS ENUM ('feature', 'bug_fix', 'documentation', 'design', 'testing', 'research', 'other');
        
        CREATE TABLE tasks (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            title VARCHAR(200) NOT NULL,
            description TEXT,
            project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
            assignee_id UUID REFERENCES users(id) ON DELETE SET NULL,
            created_by_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            status task_status NOT NULL DEFAULT 'todo',
            priority task_priority NOT NULL DEFAULT 'medium',
            task_type task_type NOT NULL DEFAULT 'other',
            estimated_hours DECIMAL(8,2),
            actual_hours DECIMAL(8,2) DEFAULT 0,
            due_date TIMESTAMPTZ,
            completed_at TIMESTAMPTZ,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW(),
            progress INTEGER DEFAULT 0 CHECK (progress >= 0 AND progress <= 100)
        );
        
        CREATE INDEX idx_tasks_project ON tasks(project_id);
        CREATE INDEX idx_tasks_assignee ON tasks(assignee_id);
        CREATE INDEX idx_tasks_status ON tasks(status);
        CREATE INDEX idx_tasks_due_date ON tasks(due_date);
        CREATE INDEX idx_tasks_created_at ON tasks(created_at);
        
        -- 添加约束
        ALTER TABLE tasks ADD CONSTRAINT chk_estimated_hours_positive 
        CHECK (estimated_hours > 0 OR estimated_hours IS NULL);
        ALTER TABLE tasks ADD CONSTRAINT chk_actual_hours_non_negative 
        CHECK (actual_hours >= 0);
        "#,
    )?;
    
    migration_manager.add_migration(
        "20240101000004_create_time_entries_table",
        "Create time entries table",
        r#"
        CREATE TABLE time_entries (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            task_id UUID NOT NULL REFERENCES tasks(id) ON DELETE CASCADE,
            user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            hours DECIMAL(5,2) NOT NULL,
            description TEXT,
            date TIMESTAMPTZ NOT NULL,
            created_at TIMESTAMPTZ DEFAULT NOW()
        );
        
        CREATE INDEX idx_time_entries_task ON time_entries(task_id);
        CREATE INDEX idx_time_entries_user ON time_entries(user_id);
        CREATE INDEX idx_time_entries_date ON time_entries(date);
        
        ALTER TABLE tasks ADD CONSTRAINT chk_hours_positive CHECK (hours > 0);
        "#,
    )?;
    
    migration_manager.add_migration(
        "20240101000005_create_notifications_table",
        "Create notifications table",
        r#"
        CREATE TYPE notification_type AS ENUM ('task_assigned', 'task_completed', 'task_overdue', 'project_updated', 'comment_added', 'system');
        
        CREATE TABLE notifications (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            title VARCHAR(200) NOT NULL,
            message TEXT NOT NULL,
            notification_type notification_type NOT NULL,
            is_read BOOLEAN DEFAULT FALSE,
            related_id UUID,
            created_at TIMESTAMPTZ DEFAULT NOW()
        );
        
        CREATE INDEX idx_notifications_user ON notifications(user_id);
        CREATE INDEX idx_notifications_is_read ON notifications(is_read);
        CREATE INDEX idx_notifications_created_at ON notifications(created_at);
        "#,
    )?;
    
    // 运行迁移
    migration_manager.run_migrations().await?;
    
    info!("Database migrations completed successfully");
    Ok(())
}

#[instrument]
async fn setup_database(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Setting up database and running migrations");
    
    // 先运行迁移
    run_migrations(database_url.clone()).await?;
    
    // 创建默认管理员用户
    let pool = sqlx::PgPool::connect(&database_url).await?;
    let admin_password = "admin123"; // 生产环境中应该使用环境变量
    
    sqlx::query!(
        r#"
        INSERT INTO users (username, email, display_name, password_hash, role, is_active)
        VALUES ('admin', 'admin@example.com', 'Administrator', $1, 'admin', true)
        ON CONFLICT (username) DO NOTHING
        "#,
        bcrypt::hash(&admin_password, bcrypt::DEFAULT_COST)?
    )
    .execute(&pool)
    .await?;
    
    info!("Default admin user created - username: admin, password: admin123");
    info!("Please change the admin password after first login");
    
    Ok(())
}

#[instrument]
async fn run_analytics(project_id: &str, database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Generating analytics report for project: {}", project_id);
    
    let database_manager = DatabaseManager::new(&database_url).await?;
    let analytics_service = AnalyticsService::new(database_manager);
    
    let project_uuid = uuid::Uuid::parse_str(project_id)?;
    let analytics = analytics_service.get_project_analytics(&project_uuid).await?;
    
    // 输出分析结果
    println!("=== Project Analytics Report ===");
    println!("Total Tasks: {}", analytics.total_tasks);
    println!("Completed Tasks: {}", analytics.completed_tasks);
    println!("In Progress Tasks: {}", analytics.in_progress_tasks);
    println!("Todo Tasks: {}", analytics.todo_tasks);
    println!("Blocked Tasks: {}", analytics.blocked_tasks);
    println!("Overdue Tasks: {}", analytics.overdue_tasks);
    println!("Average Progress: {:.1}%", analytics.average_progress);
    println!("Total Estimated Hours: {:.1}", analytics.total_estimated_hours);
    println!("Total Actual Hours: {:.1}", analytics.total_actual_hours);
    println!("Average Completion Time: {:.1} hours", analytics.average_completion_time_hours);
    
    if !analytics.user_performance.is_empty() {
        println!("\n=== User Performance ===");
        for user_perf in &analytics.user_performance {
            println!("{}", serde_json::to_string_pretty(user_perf)?);
        }
    }
    
    Ok(())
}

#![allow(unused)]
fn main() {
// Web服务器
// File: task-manager/src/web.rs
use super::services::*;
use super::analytics::*;
use super::models::*;
use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    response::Json,
    routing::{get, post, put, delete},
    Router,
};
use std::sync::Arc;
use tower::ServiceBuilder;
use tower_http::{cors::CorsLayer, trace::TraceLayer};
use tracing::instrument;

pub struct WebServer {
    app: Router,
    addr: String,
}

impl WebServer {
    pub fn new(
        addr: String,
        user_service: Arc<UserService>,
        project_service: Arc<ProjectService>,
        task_service: Arc<TaskService>,
        notification_service: Arc<NotificationService>,
        analytics_service: Arc<AnalyticsService>,
    ) -> Self {
        let app = Router::new()
            .route("/", get(|| async { "Task Manager API" }))
            .route("/health", get(health_check))
            
            // 用户相关API
            .route("/api/users", get(get_users))
            .route("/api/users", post(create_user))
            .route("/api/users/:id", get(get_user_by_id))
            .route("/api/users/:id", put(update_user))
            .route("/api/users/:id", delete(delete_user))
            
            // 项目相关API
            .route("/api/projects", get(get_projects))
            .route("/api/projects", post(create_project))
            .route("/api/projects/:id", get(get_project_by_id))
            .route("/api/projects/:id", put(update_project))
            .route("/api/projects/:id", delete(delete_project))
            .route("/api/projects/:id/tasks", get(get_project_tasks))
            .route("/api/projects/:id/analytics", get(get_project_analytics))
            
            // 任务相关API
            .route("/api/tasks", get(get_tasks))
            .route("/api/tasks", post(create_task))
            .route("/api/tasks/:id", get(get_task_by_id))
            .route("/api/tasks/:id", put(update_task))
            .route("/api/tasks/:id", delete(delete_task))
            .route("/api/tasks/:id/status", put(update_task_status))
            .route("/api/tasks/:id/time", post(log_time))
            
            // 通知相关API
            .route("/api/notifications", get(get_notifications))
            .route("/api/notifications/:id/read", put(mark_notification_read))
            .route("/api/notifications/read-all", put(mark_all_notifications_read))
            
            // 分析报告API
            .route("/api/analytics/team/:team_id", get(get_team_analytics))
            .route("/api/analytics/user/:user_id", get(get_user_productivity))
            
            .with_state(AppState {
                user_service,
                project_service,
                task_service,
                notification_service,
                analytics_service,
            })
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
            );
        
        WebServer { app, addr }
    }
    
    pub async fn run(self) -> Result<(), Box<dyn std::error::Error>> {
        let listener = tokio::net::TcpListener::bind(&self.addr).await?;
        println!("Task Manager API server listening on {}", self.addr);
        
        axum::serve(listener, self.app).await?;
        Ok(())
    }
}

#[derive(Clone)]
struct AppState {
    user_service: Arc<UserService>,
    project_service: Arc<ProjectService>,
    task_service: Arc<TaskService>,
    notification_service: Arc<NotificationService>,
    analytics_service: Arc<AnalyticsService>,
}

async fn health_check() -> &'static str {
    "OK"
}

#[instrument(skip(state))]
async fn get_users(State(state): State<AppState>) -> Result<Json<ApiResponse<Vec<User>>>, (StatusCode, String)> {
    match state.user_service.get_all_users().await {
        Ok(users) => Ok(Json(ApiResponse::success(users))),
        Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
    }
}

#[instrument(skip(state, request))]
async fn create_user(
    State(state): State<AppState>,
    Json(request): Json<CreateUserRequest>,
) -> Result<Json<ApiResponse<User>>, (StatusCode, String)> {
    match state.user_service.create_user(&request).await {
        Ok(user) => Ok(Json(ApiResponse::success(user))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

#[instrument(skip(state))]
async fn get_user_by_id(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> Result<Json<ApiResponse<Option<User>>>, (StatusCode, String)> {
    match uuid::Uuid::parse_str(&id) {
        Ok(user_id) => {
            match state.user_service.get_user_by_id(&user_id).await {
                Ok(user) => Ok(Json(ApiResponse::success(user))),
                Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
            }
        }
        Err(_) => Err((StatusCode::BAD_REQUEST, "Invalid UUID".to_string())),
    }
}

#[instrument(skip(state))]
async fn get_projects(
    State(state): State<AppState>,
    Query(params): Query<std::collections::HashMap<String, String>>,
) -> Result<Json<ApiResponse<Vec<Project>>>, (StatusCode, String)> {
    // 简化的过滤实现
    let filter = ProjectFilter {
        team_id: params.get("team_id").and_then(|s| uuid::Uuid::parse_str(s).ok()),
        owner_id: params.get("owner_id").and_then(|s| uuid::Uuid::parse_str(s).ok()),
        status: None,
        priority: None,
        start_date_from: None,
        start_date_to: None,
        end_date_from: None,
        end_date_to: None,
        search: params.get("search").cloned(),
        limit: params.get("limit").and_then(|s| s.parse().ok()),
        offset: params.get("offset").and_then(|s| s.parse().ok()),
    };
    
    match state.project_service.filter_projects(&filter).await {
        Ok((projects, _)) => Ok(Json(ApiResponse::success(projects))),
        Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
    }
}

#[instrument(skip(state, request))]
async fn create_project(
    State(state): State<AppState>,
    Json(request): Json<CreateProjectRequest>,
) -> Result<Json<ApiResponse<Project>>, (StatusCode, String)> {
    // 从JWT token获取当前用户ID（简化实现）
    let owner_id = uuid::Uuid::new_v4();
    
    match state.project_service.create_project(&request, owner_id).await {
        Ok(project) => Ok(Json(ApiResponse::success(project))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

#[instrument(skip(state))]
async fn get_project_by_id(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> Result<Json<ApiResponse<Option<Project>>>, (StatusCode, String)> {
    match uuid::Uuid::parse_str(&id) {
        Ok(project_id) => {
            match state.project_service.get_project_by_id(&project_id).await {
                Ok(project) => Ok(Json(ApiResponse::success(project))),
                Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
            }
        }
        Err(_) => Err((StatusCode::BAD_REQUEST, "Invalid UUID".to_string())),
    }
}

#[instrument(skip(state))]
async fn get_project_tasks(
    State(state): State<AppState>,
    Path(id): Path<String>,
) -> Result<Json<ApiResponse<Vec<Task>>>, (StatusCode, String)> {
    match uuid::Uuid::parse_str(&id) {
        Ok(project_id) => {
            match state.task_service.get_tasks_by_project(&project_id).await {
                Ok(tasks) => Ok(Json(ApiResponse::success(tasks))),
                Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
            }
        }
        Err(_) => Err((StatusCode::BAD_REQUEST, "Invalid UUID".to_string())),
    }
}

#[instrument(skip(state))]
async fn get_tasks(
    State(state): State<AppState>,
    Query(params): Query<std::collections::HashMap<String, String>>,
) -> Result<Json<ApiResponse<Vec<Task>>>, (StatusCode, String)> {
    let filter = TaskFilter {
        project_id: params.get("project_id").and_then(|s| uuid::Uuid::parse_str(s).ok()),
        assignee_id: params.get("assignee_id").and_then(|s| uuid::Uuid::parse_str(s).ok()),
        status: None,
        priority: None,
        task_type: None,
        due_date_from: None,
        due_date_to: None,
        created_by: None,
        search: params.get("search").cloned(),
        limit: params.get("limit").and_then(|s| s.parse().ok()),
        offset: params.get("offset").and_then(|s| s.parse().ok()),
    };
    
    match state.task_service.filter_tasks(&filter).await {
        Ok((tasks, _)) => Ok(Json(ApiResponse::success(tasks))),
        Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
    }
}

#[instrument(skip(state, request))]
async fn create_task(
    State(state): State<AppState>,
    Json(request): Json<CreateTaskRequest>,
) -> Result<Json<ApiResponse<Task>>, (StatusCode, String)> {
    let created_by = uuid::Uuid::new_v4(); // 从JWT获取
    
    match state.task_service.create_task(&request, created_by).await {
        Ok(task) => Ok(Json(ApiResponse::success(task))),
        Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
    }
}

#[instrument(skip(state, request))]
async fn update_task(
    State(state): State<AppState>,
    Path(id): Path<String>,
    Json(request): Json<UpdateTaskRequest>,
) -> Result<Json<ApiResponse<Task>>, (StatusCode, String)> {
    match uuid::Uuid::parse_str(&id) {
        Ok(task_id) => {
            match state.task_service.update_task(&task_id, &request).await {
                Ok(task) => Ok(Json(ApiResponse::success(task))),
                Err(e) => Err((StatusCode::BAD_REQUEST, e.to_string())),
            }
        }
        Err(_) => Err((StatusCode::BAD_REQUEST, "Invalid UUID".to_string())),
    }
}

// 其他路由实现...
}

#![allow(unused)]
fn main() {
// 数据库管理模块
// File: task-manager/src/database.rs
use sqlx::{PgPool, Pool, Postgres};
use crate::services::*;
use std::time::Duration;

pub struct DatabaseManager {
    pub pool: Pool<Postgres>,
}

impl DatabaseManager {
    pub async fn new(database_url: &str) -> Result<Self, sqlx::Error> {
        let pool = PgPoolOptions::new()
            .max_connections(20)
            .min_connections(5)
            .max_lifetime(Duration::from_secs(1800))
            .idle_timeout(Duration::from_secs(300))
            .connect_timeout(Duration::from_secs(10))
            .connect(database_url)
            .await?;
        
        Ok(DatabaseManager { pool })
    }
    
    pub async fn execute_query<T>(
        &self,
        query: &str,
        params: &[Box<dyn sqlx::Encode<'static, Postgres> + Send>],
    ) -> Result<T, sqlx::Error>
    where
        T: for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send
    {
        let mut query_builder = sqlx::query_as::<_, T>(query);
        
        for param in params {
            // 这里需要类型转换，实际实现会更复杂
            // 简化实现
        }
        
        query_builder.fetch_one(&self.pool).await
    }
    
    pub async fn execute_update(&self, query: &str, params: &[Box<dyn sqlx::Encode<'static, Postgres> + Send>]) -> Result<u64, sqlx::Error> {
        let mut query_builder = sqlx::query(query);
        
        for param in params {
            // 简化实现
        }
        
        query_builder.execute(&self.pool).await.map(|result| result.rows_affected())
    }
}

impl Clone for DatabaseManager {
    fn clone(&self) -> Self {
        DatabaseManager {
            pool: self.pool.clone(),
        }
    }
}
}

#![allow(unused)]
fn main() {
// Docker配置和部署
File: task-manager/docker-compose.yml
version: '3.8'

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: task_manager
      POSTGRES_USER: task_user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql

  task-manager:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://task_user:password@postgres:5432/task_manager
    depends_on:
      - postgres
    restart: unless-stopped

volumes:
  postgres_data:
}

#![allow(unused)]
fn main() {
// File: task-manager/README.md
企业级任务管理系统

一个基于Rust构建的企业级任务管理系统，支持项目管理、团队协作、进度跟踪、数据分析等功能。

# 功能特性

## 项目管理
- **多项目支持**：创建、编辑、删除项目
- **项目状态跟踪**：规划、进行中、暂停、已完成、已取消
- **项目优先级**：低、中、高、紧急
- **项目时间线**：开始时间、结束时间设置
- **项目分析**：进度统计、团队绩效、效率分析

## 任务管理
- **任务生命周期**：待办、进行中、审核、测试、完成、取消、阻塞
- **任务类型**：功能、修复、文档、设计、测试、研究
- **优先级管理**：低、中、高、紧急
- **工时跟踪**：预估工时、实际工时、详细时间记录
- **进度管理**：0-100%进度跟踪
- **任务分配**：支持多用户协作

## 团队协作
- **用户管理**：角色权限（管理员、经理、成员、查看者）
- **团队管理**：创建团队、添加成员
- **实时通知**：任务分配、完成提醒、逾期警告
- **评论系统**：任务评论、讨论记录
- **文件附件**：任务附件管理

## 数据分析
- **项目分析**：项目进度、团队绩效、工时统计
- **个人分析**：工作效率、工时分布、完成率
- **团队分析**：团队协作、生产力趋势
- **时间分析**：工时分布、效率优化建议

# 快速开始

## 使用Docker Compose（推荐）

1. 启动服务
```bash
docker-compose up -d
}

初始化数据库

cargo run setup --database-url "postgres://task_user:password@localhost/task_manager"

访问系统

Web界面：http://localhost:3000
API文档：http://localhost:3000/health

本地开发

安装依赖

# 安装PostgreSQL
sudo apt-get install postgresql-15

# 创建数据库
createdb task_manager

运行应用

cargo run server

数据库设置

cargo run migrate --database-url "postgres://task_user:password@localhost/task_manager"

API文档

用户管理

GET /api/users - 获取所有用户
POST /api/users - 创建用户
GET /api/users/:id - 获取用户详情
PUT /api/users/:id - 更新用户
DELETE /api/users/:id - 删除用户

项目管理

GET /api/projects - 获取项目列表
POST /api/projects - 创建项目
GET /api/projects/:id - 获取项目详情
PUT /api/projects/:id - 更新项目
DELETE /api/projects/:id - 删除项目
GET /api/projects/:id/tasks - 获取项目任务
GET /api/projects/:id/analytics - 获取项目分析

任务管理

GET /api/tasks - 获取任务列表
POST /api/tasks - 创建任务
GET /api/tasks/:id - 获取任务详情
PUT /api/tasks/:id - 更新任务
DELETE /api/tasks/:id - 删除任务
PUT /api/tasks/:id/status - 更新任务状态
POST /api/tasks/:id/time - 记录工时

通知管理

GET /api/notifications - 获取通知列表
PUT /api/notifications/:id/read - 标记通知已读
PUT /api/notifications/read-all - 全部标记已读

性能优化

数据库优化

合理的索引设计
查询优化
连接池管理
读写分离

缓存策略

用户会话缓存
项目数据缓存
统计信息缓存

异步处理

异步数据库操作
非阻塞I/O
任务队列

安全特性

身份认证

JWT token认证
密码哈希存储
会话管理

权限控制

基于角色的访问控制
细粒度权限管理
数据隔离

数据安全

SQL注入防护
XSS防护
CSRF保护

监控和运维

系统监控

数据库连接监控
性能指标收集
错误日志记录

健康检查

API健康检查端点
数据库连接检查
系统资源监控

扩展性

水平扩展

无状态API设计
数据库分片
负载均衡

微服务架构

用户服务
项目服务
任务服务
通知服务

贡献

欢迎提交Issue和Pull Request来改进这个项目。

许可证

MIT License

联系信息：

作者：MiniMax Agent
邮箱：developer@minimax.com
文档：https://docs.minimax.com/task-manager

第12章：Web开发

章节概述

Web开发是现代软件开发的核心技能。在本章中，我们将深入探索Rust的Web开发能力，从框架选择到复杂的企业级应用构建。本章不仅关注前端技术，更强调后端架构、数据库集成、安全性和可维护性。

学习目标：

掌握Rust Web开发的核心概念和最佳实践
理解主流Web框架的特点和适用场景
学会构建安全、高效的Web应用
掌握用户认证、授权和会话管理
学会表单处理、数据验证和文件上传
设计并实现一个完整的企业级博客系统

实战项目：构建一个企业级博客系统，支持多用户、权限管理、内容管理、评论系统、搜索功能、SEO优化等企业级特性。

12.1 Web框架选择

12.1.1 Rust Web框架生态

Rust在Web开发方面拥有多个成熟的框架：

Actix-web：高性能、功能完整、社区活跃
Axum：基于Tokio的现代化框架，类型安全
Rocket：零配置、开发友好、安全
Warp：组合式、函数式编程风格
Tide：异步、简洁的设计

12.1.2 框架对比分析

Actix-web特点

// Actix-web示例
use actix_web::{web, App, HttpResponse, HttpRequest, Responder};

async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello World!")
}

async fn greet(req: HttpRequest) -> impl Responder {
    let name = req.match_info().get("name").unwrap_or("World");
    format!("Hello {}!", &name)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Axum特点

// Axum示例
use axum::{extract::Path, response::Json, routing::get, Router};
use serde_json::{json, Value};

async fn root() -> Json<Value> {
    Json(json!({
        "message": "Hello, World!"
    }))
}

async fn greet(Path(name): Path<String>) -> Json<Value> {
    Json(json!({
        "message": format!("Hello, {}!", name)
    }))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(root))
        .route("/:name", get(greet));
    
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

12.1.3 框架选择建议

#![allow(unused)]
fn main() {
// 框架选择决策树
pub struct FrameworkSelection {
    performance_priority: bool,
    development_speed: bool,
    feature_complexity: String,
    team_experience: String,
    deployment_target: String,
}

impl FrameworkSelection {
    pub fn recommend_framework(&self) -> FrameworkRecommendation {
        match (
            self.performance_priority,
            self.development_speed,
            &self.feature_complexity,
        ) {
            (true, false, "simple") => FrameworkRecommendation::ActixWeb,
            (true, true, "medium") => FrameworkRecommendation::Axum,
            (false, true, "simple") => FrameworkRecommendation::Rocket,
            (false, false, "complex") => FrameworkRecommendation::Axum,
            _ => FrameworkRecommendation::ActixWeb,
        }
    }
}

#[derive(Debug)]
pub enum FrameworkRecommendation {
    ActixWeb,
    Axum,
    Rocket,
}

impl std::fmt::Display for FrameworkRecommendation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FrameworkRecommendation::ActixWeb => write!(f, "Actix-web"),
            FrameworkRecommendation::Axum => write!(f, "Axum"),
            FrameworkRecommendation::Rocket => write!(f, "Rocket"),
        }
    }
}
}

12.2 路由与中间件

12.2.1 基于Axum的路由系统

#![allow(unused)]
fn main() {
// 高级路由配置
use axum::{
    extract::{Path, Query, State, Extension},
    http::{HeaderValue, Method, StatusCode},
    response::{IntoResponse, Redirect},
    routing::{get, post, put, delete, patch},
    Router, Json, Form
};
use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, cors::CorsLayer, compression::CompressionLayer};
use std::collections::HashMap;
use std::sync::Arc;

// 应用状态
#[derive(Clone)]
pub struct AppState {
    pub db_pool: sqlx::PgPool,
    pub redis_client: redis::Client,
    pub config: Config,
    pub logger: Arc<tracing::log::Logger>,
}

// 路由构建器
pub struct RouteBuilder {
    state: AppState,
    routes: Vec<Route>,
    middleware: Vec<Box<dyn axum::middleware::Middleware<(), State = AppState>>>,
}

impl RouteBuilder {
    pub fn new(state: AppState) -> Self {
        RouteBuilder {
            state,
            routes: Vec::new(),
            middleware: Vec::new(),
        }
    }
    
    pub fn add_route<R, T>(mut self, method: Method, path: &str, handler: R) -> Self
    where
        R: axum::handler::Handler<T, State = AppState> + Clone,
        T: axum::extract::FromRequestParts<AppState> + axum::extract::FromRequest<AppState>,
    {
        let route = Route {
            method,
            path: path.to_string(),
            handler: std::any::type_name::<R>().to_string(),
        };
        self.routes.push(route);
        self
    }
    
    pub fn add_middleware<M>(mut self, middleware: M) -> Self
    where
        M: axum::middleware::Middleware<(), State = AppState> + Send + Sync + 'static,
    {
        self.middleware.push(Box::new(middleware) as Box<dyn axum::middleware::Middleware<(), State = AppState>>);
        self
    }
    
    pub fn build(self) -> Router<AppState> {
        let mut app = Router::new();
        
        // 基础路由
        app = app
            .route("/", get(home_handler))
            .route("/health", get(health_check))
            .route("/api/v1/status", get(api_status));
        
        // 用户管理路由
        app = app
            .route("/api/v1/users", get(list_users).post(create_user))
            .route("/api/v1/users/:id", get(get_user).put(update_user).delete(delete_user))
            .route("/api/v1/auth/login", post(login))
            .route("/api/v1/auth/logout", post(logout))
            .route("/api/v1/auth/refresh", post(refresh_token));
        
        // 博客相关路由
        app = app
            .route("/api/v1/blogs", get(list_blogs).post(create_blog))
            .route("/api/v1/blogs/:id", get(get_blog).put(update_blog).delete(delete_blog))
            .route("/api/v1/blogs/:id/comments", get(list_comments).post(create_comment))
            .route("/api/v1/blogs/:id/like", post(like_blog))
            .route("/api/v1/blogs/:id/share", post(share_blog));
        
        // 分类和标签路由
        app = app
            .route("/api/v1/categories", get(list_categories).post(create_category))
            .route("/api/v1/tags", get(list_tags).post(create_tag))
            .route("/api/v1/search", get(search));
        
        // 管理员路由
        app = app
            .route("/api/v1/admin/dashboard", get(admin_dashboard))
            .route("/api/v1/admin/users", get(admin_list_users))
            .route("/api/v1/admin/blogs", get(admin_list_blogs))
            .route("/api/v1/admin/comments", get(admin_list_comments));
        
        // 文件上传路由
        app = app
            .route("/api/v1/upload", post(upload_file))
            .route("/api/v1/files/:id", get(download_file).delete(delete_file));
        
        // 静态文件服务
        app = app
            .route("/static/*path", get(serve_static));
        
        // 添加中间件
        app = app
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
                    .layer(CompressionLayer::new())
                    .layer(Extension(self.state))
            );
        
        // 添加自定义中间件
        for middleware in self.middleware {
            app = app.layer(middleware);
        }
        
        app
    }
}

struct Route {
    method: Method,
    path: String,
    handler: String,
}

// 基础处理器
async fn home_handler() -> impl IntoResponse {
    (
        StatusCode::OK,
        [("Content-Type", "text/html")],
        r#"
        <!DOCTYPE html>
        <html>
        <head>
            <title>企业级博客系统</title>
            <meta charset="UTF-8">
        </head>
        <body>
            <h1>欢迎使用企业级博客系统</h1>
            <p>API文档: <a href="/api/v1/docs">查看文档</a></p>
        </body>
        </html>
        "#,
    )
}

async fn health_check(State(state): State<AppState>) -> impl IntoResponse {
    // 检查数据库连接
    let db_healthy = match sqlx::query("SELECT 1").fetch_one(&state.db_pool).await {
        Ok(_) => true,
        Err(_) => false,
    };
    
    // 检查Redis连接
    let redis_healthy = match state.redis_client.get_connection() {
        Ok(_) => true,
        Err(_) => false,
    };
    
    Json(serde_json::json!({
        "status": "healthy",
        "database": db_healthy,
        "redis": redis_healthy,
        "timestamp": chrono::Utc::now().to_rfc3339(),
    }))
}

async fn api_status() -> impl IntoResponse {
    Json(serde_json::json!({
        "api_version": "1.0.0",
        "service": "企业级博客系统",
        "status": "operational",
    }))
}

// 错误处理
#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    #[error("Redis error: {0}")]
    Redis(#[from] redis::RedisError),
    #[error("Validation error: {0}")]
    Validation(String),
    #[error("Not found")]
    NotFound,
    #[error("Unauthorized")]
    Unauthorized,
    #[error("Forbidden")]
    Forbidden,
    #[error("Internal server error")]
    InternalServerError,
}

impl IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        match self {
            AppError::NotFound => (
                StatusCode::NOT_FOUND,
                Json(serde_json::json!({
                    "error": "Resource not found",
                    "status": 404
                }))
            ),
            AppError::Unauthorized => (
                StatusCode::UNAUTHORIZED,
                Json(serde_json::json!({
                    "error": "Unauthorized access",
                    "status": 401
                }))
            ),
            AppError::Forbidden => (
                StatusCode::FORBIDDEN,
                Json(serde_json::json!({
                    "error": "Access forbidden",
                    "status": 403
                }))
            ),
            AppError::Validation(msg) => (
                StatusCode::BAD_REQUEST,
                Json(serde_json::json!({
                    "error": msg,
                    "status": 400
                }))
            ),
            AppError::Database(_) | AppError::Redis(_) | AppError::InternalServerError => (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({
                    "error": "Internal server error",
                    "status": 500
                }))
            ),
        }
    }
}

// 配置文件
#[derive(Debug, Clone)]
pub struct Config {
    pub database_url: String,
    pub redis_url: String,
    pub jwt_secret: String,
    pub upload_dir: String,
    pub max_upload_size: usize,
    pub session_timeout: std::time::Duration,
}
}

12.2.2 中间件系统

#![allow(unused)]
fn main() {
// 自定义中间件实现
use axum::{
    extract::{Request, State},
    middleware::Next,
    response::Response,
    http::StatusCode,
    Extension,
};
use std::future::Future;
use std::pin::Pin;
use std::time::{Duration, Instant};

// 认证中间件
pub struct AuthMiddleware {
    pub required_roles: Vec<String>,
}

impl axum::middleware::Middleware<(), State = AppState> for AuthMiddleware {
    type Future = Pin<Box<dyn Future<Output = Result<Response, (StatusCode, String)>> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let user_id = extract_user_id(&request).await;
            
            if let Some(user_id) = user_id {
                // 验证用户
                if let Ok(user) = get_user_by_id(&state.db_pool, &user_id).await {
                    // 检查角色权限
                    if check_role_permissions(&user, &self.required_roles) {
                        // 添加用户信息到请求扩展
                        let mut request = request;
                        request.extensions_mut().insert(user);
                        next.run(request).await
                    } else {
                        Err((StatusCode::FORBIDDEN, "Insufficient permissions".to_string()))
                    }
                } else {
                    Err((StatusCode::UNAUTHORIZED, "Invalid user".to_string()))
                }
            } else {
                Err((StatusCode::UNAUTHORIZED, "Authentication required".to_string()))
            }
        })
    }
}

// 速率限制中间件
pub struct RateLimitMiddleware {
    pub max_requests: u64,
    pub window: Duration,
    pub key_extractor: fn(&Request) -> String,
}

impl axum::middleware::Middleware<(), State = AppState> for RateLimitMiddleware {
    type Future = Pin<Box<dyn Future<Output = Result<Response, (StatusCode, String)>> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let key = (self.key_extractor)(&request);
            
            if let Some(allowed) = check_rate_limit(&state.redis_client, &key, self.max_requests, self.window).await {
                if allowed {
                    next.run(request).await
                } else {
                    Err((StatusCode::TOO_MANY_REQUESTS, "Rate limit exceeded".to_string()))
                }
            } else {
                next.run(request).await
            }
        })
    }
}

// 性能监控中间件
pub struct MetricsMiddleware {
    pub name: String,
}

impl axum::middleware::Middleware<(), State = AppState> for MetricsMiddleware {
    type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let start = Instant::now();
            let method = request.method().clone();
            let path = request.uri().path().to_string();
            
            let response = next.run(request).await;
            
            let duration = start.elapsed();
            let status_code = response.status();
            
            // 记录指标
            record_metrics(&state, &self.name, &method, &path, status_code, duration);
            
            response
        })
    }
}

// 日志中间件
pub struct LoggingMiddleware {
    pub level: tracing::Level,
}

impl axum::middleware::Middleware<(), State = AppState> for LoggingMiddleware {
    type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let start = Instant::now();
            let method = request.method().clone();
            let path = request.uri().path().to_string();
            let user_agent = request.headers()
                .get("user-agent")
                .and_then(|h| h.to_str().ok())
                .unwrap_or("unknown");
            
            tracing::info!(
                target: "http_requests",
                method = %method,
                path = %path,
                user_agent = %user_agent,
                "request started"
            );
            
            let response = next.run(request).await;
            
            let duration = start.elapsed();
            let status_code = response.status();
            
            tracing::info!(
                target: "http_requests",
                method = %method,
                path = %path,
                status_code = %status_code,
                duration = ?duration,
                "request completed"
            );
            
            response
        })
    }
}
}

12.3 表单处理与验证

12.3.1 表单数据提取

#![allow(unused)]
fn main() {
use axum::{
    extract::{Form, Multipart, FromRequest, WebSocketUpgrade},
    http::StatusCode,
    response::{Html, Redirect},
    Json, Form
};
use serde::{Deserialize, Serialize};
use serde_with::{DisplayFromStr, serde_as};
use std::collections::HashMap;

// 基础表单结构
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct UserRegistrationForm {
    pub username: String,
    pub email: String,
    pub password: String,
    pub password_confirm: String,
    pub display_name: String,
    pub bio: Option<String>,
    pub website: Option<String>,
    pub terms_accepted: bool,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct BlogPostForm {
    pub title: String,
    pub content: String,
    pub summary: Option<String>,
    pub category_id: Option<String>,
    pub tags: Option<String>, // 逗号分隔的标签
    pub is_published: bool,
    pub featured_image: Option<String>,
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub allow_comments: bool,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct CommentForm {
    pub content: String,
    pub parent_id: Option<String>, // 回复评论的ID
    pub rating: Option<u8>, // 1-5星评分
}

// 文件上传表单
#[derive(Debug, Deserialize, Serialize)]
pub struct FileUploadForm {
    pub description: Option<String>,
    pub category: String,
    pub tags: Option<String>,
}

// 自定义提取器
pub struct ValidatedForm<T>(pub T);

impl<T, S> FromRequest<S> for ValidatedForm<T>
where
    T: for<'de> Deserialize<'de> + Send + Sync + 'static,
    S: Send + Sync,
{
    type Rejection = (StatusCode, String);
    
    async fn from_request(req: axum::extract::Request, _state: &S) -> Result<Self, Self::Rejection> {
        let content_type = req.headers()
            .get("content-type")
            .and_then(|h| h.to_str().ok())
            .unwrap_or("");
        
        if content_type.contains("application/x-www-form-urlencoded") {
            let form = axum::extract::Form::<HashMap<String, String>>::from_request(req, _state).await
                .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid form data".to_string()))?;
            
            let data = serde_urlencoded::from_str::<T>(&form.0.iter()
                .map(|(k, v)| format!("{}={}", k, v))
                .collect::<Vec<_>>()
                .join("&"))
                .map_err(|e| (StatusCode::BAD_REQUEST, format!("Validation error: {}", e)))?;
            
            Ok(ValidatedForm(data))
        } else if content_type.contains("multipart/form-data") {
            // 处理multipart表单
            let multipart = axum::extract::Multipart::from_request(req, _state).await
                .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid multipart data".to_string()))?;
            
            let data = process_multipart_form::<T>(multipart).await
                .map_err(|e| (StatusCode::BAD_REQUEST, format!("Validation error: {}", e)))?;
            
            Ok(ValidatedForm(data))
        } else {
            Err((StatusCode::UNSUPPORTED_MEDIA_TYPE, "Unsupported content type".to_string()))
        }
    }
}

async fn process_multipart_form<T: for<'de> Deserialize<'de>>(
    mut multipart: axum::extract::Multipart
) -> Result<T, Box<dyn std::error::Error>> {
    let mut form_data = HashMap::new();
    let mut files = HashMap::new();
    
    while let Some(field) = multipart.next_field().await? {
        let name = field.name().unwrap_or("").to_string();
        let data = field.bytes().await?;
        
        if field.file_name().is_some() {
            // 处理文件
            files.insert(name, data.to_vec());
        } else {
            // 处理文本字段
            form_data.insert(name, String::from_utf8_lossy(&data).to_string());
        }
    }
    
    // 构建最终的表单数据
    let form_data_str = form_data.iter()
        .map(|(k, v)| format!("{}={}", k, v))
        .collect::<Vec<_>>()
        .join("&");
    
    serde_urlencoded::from_str::<T>(&form_data_str).map_err(|e| e.into())
}

// 表单验证器
pub struct FormValidator;

impl FormValidator {
    pub fn validate_registration_form(form: &UserRegistrationForm) -> Result<(), ValidationError> {
        // 用户名验证
        if form.username.len() < 3 || form.username.len() > 50 {
            return Err(ValidationError::new("username", "用户名长度必须在3-50个字符之间"));
        }
        
        if !form.username.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-') {
            return Err(ValidationError::new("username", "用户名只能包含字母、数字、下划线和连字符"));
        }
        
        // 邮箱验证
        if !is_valid_email(&form.email) {
            return Err(ValidationError::new("email", "请输入有效的邮箱地址"));
        }
        
        // 密码验证
        if form.password.len() < 8 {
            return Err(ValidationError::new("password", "密码长度至少8个字符"));
        }
        
        if form.password != form.password_confirm {
            return Err(ValidationError::new("password_confirm", "两次输入的密码不一致"));
        }
        
        // 检查密码强度
        if !is_strong_password(&form.password) {
            return Err(ValidationError::new("password", "密码必须包含大小写字母、数字和特殊字符"));
        }
        
        // 条款接受验证
        if !form.terms_accepted {
            return Err(ValidationError::new("terms_accepted", "您必须接受服务条款"));
        }
        
        Ok(())
    }
    
    pub fn validate_blog_form(form: &BlogPostForm) -> Result<(), ValidationError> {
        // 标题验证
        if form.title.trim().is_empty() || form.title.len() > 200 {
            return Err(ValidationError::new("title", "标题长度必须在1-200个字符之间"));
        }
        
        // 内容验证
        if form.content.trim().is_empty() || form.content.len() < 100 {
            return Err(ValidationError::new("content", "内容长度至少100个字符"));
        }
        
        // 摘要验证
        if let Some(summary) = &form.summary {
            if summary.len() > 500 {
                return Err(ValidationError::new("summary", "摘要长度不能超过500个字符"));
            }
        }
        
        // 标签验证
        if let Some(tags) = &form.tags {
            let tag_list: Vec<&str> = tags.split(',').map(|t| t.trim()).filter(|t| !t.is_empty()).collect();
            if tag_list.len() > 10 {
                return Err(ValidationError::new("tags", "最多只能添加10个标签"));
            }
            
            for tag in tag_list {
                if tag.len() > 30 {
                    return Err(ValidationError::new("tags", "每个标签长度不能超过30个字符"));
                }
            }
        }
        
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct ValidationError {
    field: String,
    message: String,
}

impl ValidationError {
    pub fn new(field: &str, message: &str) -> Self {
        ValidationError {
            field: field.to_string(),
            message: message.to_string(),
        }
    }
}

impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.field, self.message)
    }
}

// 辅助函数
fn is_valid_email(email: &str) -> bool {
    regex::Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
        .unwrap()
        .is_match(email)
}

fn is_strong_password(password: &str) -> bool {
    let has_upper = password.chars().any(|c| c.is_uppercase());
    let has_lower = password.chars().any(|c| c.is_lowercase());
    let has_digit = password.chars().any(|c| c.is_digit(10));
    let has_special = password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c));
    
    has_upper && has_lower && has_digit && has_special
}
}

12.4 用户认证与授权

12.4.1 JWT认证系统

#![allow(unused)]
fn main() {
// JWT认证实现
use jsonwebtoken::{EncodingKey, DecodingKey, Algorithm, Header, TokenData, errors::Error as JwtError};
use serde::{Deserialize, Serialize};
use chrono::{Duration, Utc};
use axum::{
    extract::{FromRequestParts, Request},
    http::StatusCode,
    response::{IntoResponse, Response},
};
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

#[derive(Debug, Serialize, Deserialize)]
pub struct Claims {
    pub sub: String, // 用户ID
    pub username: String,
    pub role: String,
    pub exp: usize, // 过期时间
    pub iat: usize, // 签发时间
    pub jti: String, // JWT ID
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginRequest {
    pub username: String,
    pub password: String,
    pub remember_me: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginResponse {
    pub access_token: String,
    pub refresh_token: String,
    pub token_type: String,
    pub expires_in: u64,
    pub user: UserInfo,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UserInfo {
    pub id: String,
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub role: String,
    pub avatar_url: Option<String>,
}

pub struct JwtManager {
    pub encoding_key: EncodingKey,
    pub decoding_key: DecodingKey,
    pub access_token_duration: Duration,
    pub refresh_token_duration: Duration,
    pub algorithm: Algorithm,
}

impl JwtManager {
    pub fn new(secret: &str) -> Self {
        let key = EncodingKey::from_secret(secret.as_bytes());
        let decoding_key = DecodingKey::from_secret(secret.as_bytes());
        
        JwtManager {
            encoding_key: key,
            decoding_key,
            access_token_duration: Duration::minutes(15), // 15分钟
            refresh_token_duration: Duration::days(7), // 7天
            algorithm: Algorithm::HS256,
        }
    }
    
    pub fn generate_tokens(&self, user: &UserInfo) -> Result<(String, String), JwtError> {
        let now = Utc::now();
        let access_exp = (now + self.access_token_duration).timestamp() as usize;
        let refresh_exp = (now + self.refresh_token_duration).timestamp() as usize;
        
        let access_claims = Claims {
            sub: user.id.clone(),
            username: user.username.clone(),
            role: user.role.clone(),
            exp: access_exp,
            iat: now.timestamp() as usize,
            jti: uuid::Uuid::new_v4().to_string(),
        };
        
        let refresh_claims = Claims {
            sub: user.id.clone(),
            username: user.username.clone(),
            role: user.role.clone(),
            exp: refresh_exp,
            iat: now.timestamp() as usize,
            jti: uuid::Uuid::new_v4().to_string(),
        };
        
        let access_token = jsonwebtoken::encode(
            &Header::default(),
            &access_claims,
            &self.encoding_key,
        )?;
        
        let refresh_token = jsonwebtoken::encode(
            &Header::default(),
            &refresh_claims,
            &self.encoding_key,
        )?;
        
        Ok((access_token, refresh_token))
    }
    
    pub fn verify_token(&self, token: &str) -> Result<TokenData<Claims>, JwtError> {
        let validation = Validation::new(self.algorithm);
        jsonwebtoken::decode::<Claims>(token, &self.decoding_key, &validation)
    }
    
    pub fn extract_user_from_request(&self, request: &Request) -> Option<TokenData<Claims>> {
        let auth_header = request.headers()
            .get("authorization")
            .and_then(|h| h.to_str().ok());
        
        if let Some(auth) = auth_header {
            if auth.starts_with("Bearer ") {
                let token = &auth[7..];
                return self.verify_token(token).ok();
            }
        }
        
        // 也检查cookie
        let cookies = request.headers()
            .get("cookie")
            .and_then(|c| c.to_str().ok());
        
        if let Some(cookie_str) = cookies {
            for cookie in cookie_str.split(';') {
                let cookie = cookie.trim();
                if cookie.starts_with("access_token=") {
                    let token = &cookie[13..];
                    return self.verify_token(token).ok();
                }
            }
        }
        
        None
    }
}

// 从请求中提取用户信息
pub struct AuthenticatedUser {
    pub claims: TokenData<Claims>,
}

impl AuthenticatedUser {
    pub fn user_id(&self) -> &str {
        &self.claims.claims.sub
    }
    
    pub fn username(&self) -> &str {
        &self.claims.claims.username
    }
    
    pub fn role(&self) -> &str {
        &self.claims.claims.role
    }
    
    pub fn is_expired(&self) -> bool {
        self.claims.claims.exp < Utc::now().timestamp() as usize
    }
}

impl FromRequestParts<AppState> for AuthenticatedUser {
    type Rejection = (StatusCode, String);
    
    fn from_request_parts(
        parts: &mut axum::http::request::Parts,
        state: &AppState,
    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
        Box::pin(async move {
            let jwt_manager = &state.jwt_manager;
            
            if let Some(claims) = jwt_manager.extract_user_from_request(&parts.extensions.get::<Request>().unwrap()) {
                if !claims.claims.exp < Utc::now().timestamp() as usize {
                    return Err((StatusCode::UNAUTHORIZED, "Token expired".to_string()));
                }
                
                // 验证用户是否仍然有效
                if let Some(user) = get_user_by_id(&state.db_pool, &uuid::Uuid::parse_str(&claims.claims.sub).unwrap()).await {
                    // 检查用户状态
                    if !user.is_active {
                        return Err((StatusCode::FORBIDDEN, "User account is disabled".to_string()));
                    }
                    
                    Ok(AuthenticatedUser { claims })
                } else {
                    Err((StatusCode::UNAUTHORIZED, "User not found".to_string()))
                }
            } else {
                Err((StatusCode::UNAUTHORIZED, "Authentication required".to_string()))
            }
        })
    }
}
}

12.5 企业级博客系统

现在我们来构建一个完整的企业级博客系统，集成所有学到的Web开发技术。

#![allow(unused)]
fn main() {
// 企业级博客系统主项目
// File: enterprise-blog/Cargo.toml
/*
[package]
name = "enterprise-blog"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
axum = { version = "0.7", features = ["macros"] }
tower = { version = "0.4" }
tower-http = { version = "0.5", features = ["cors", "compression", "trace"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "uuid", "chrono"] }
redis = { version = "0.23", features = ["tokio-comp"] }
bcrypt = "0.15"
jsonwebtoken = "9.0"
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
anyhow = "1.0"
thiserror = "1.0"
regex = "1.0"
markdown = "1.0"
html-escape = "0.4"
mime = "0.4"
uuid = { version = "1.0", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
*/
}

// 数据模型
// File: enterprise-blog/src/models.rs
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};
use uuid::Uuid;
use sqlx::{FromRow, Type};

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub bio: Option<String>,
    pub avatar_url: Option<String>,
    pub website: Option<String>,
    pub password_hash: String,
    pub role: UserRole,
    pub is_active: bool,
    pub email_verified: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub last_login: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "user_role")]
#[serde(rename_all = "snake_case")]
pub enum UserRole {
    Admin,
    Editor,
    Author,
    Subscriber,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct BlogPost {
    pub id: Uuid,
    pub title: String,
    pub slug: String,
    pub content: String,
    pub excerpt: Option<String>,
    pub featured_image: Option<String>,
    pub author_id: Uuid,
    pub category_id: Option<Uuid>,
    pub status: BlogStatus,
    pub is_featured: bool,
    pub is_pinned: bool,
    pub allow_comments: bool,
    pub allow_ratings: bool,
    pub view_count: i32,
    pub like_count: i32,
    pub comment_count: i32,
    pub reading_time: i32, // 分钟
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub published_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "blog_status")]
#[serde(rename_all = "snake_case")]
pub enum BlogStatus {
    Draft,
    Published,
    Archived,
    Scheduled,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Category {
    pub id: Uuid,
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub parent_id: Option<Uuid>,
    pub sort_order: i32,
    pub is_active: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Tag {
    pub id: Uuid,
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub color: Option<String>,
    pub post_count: i32,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Comment {
    pub id: Uuid,
    pub post_id: Uuid,
    pub parent_id: Option<Uuid>,
    pub user_id: Option<Uuid>,
    pub author_name: Option<String>,
    pub author_email: Option<String>,
    pub content: String,
    pub status: CommentStatus,
    pub is_approved: bool,
    pub ip_address: String,
    pub user_agent: Option<String>,
    pub like_count: i32,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "comment_status")]
#[serde(rename_all = "snake_case")]
pub enum CommentStatus {
    Pending,
    Approved,
    Spam,
    Trash,
}

// API请求/响应结构
#[derive(Debug, Serialize, Deserialize)]
pub struct RegisterRequest {
    pub username: String,
    pub email: String,
    pub password: String,
    pub display_name: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginRequest {
    pub username: String,
    pub password: String,
    pub remember_me: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateBlogRequest {
    pub title: String,
    pub content: String,
    pub excerpt: Option<String>,
    pub category_id: Option<Uuid>,
    pub tag_ids: Option<Vec<Uuid>>,
    pub status: BlogStatus,
    pub is_featured: bool,
    pub is_pinned: bool,
    pub allow_comments: bool,
    pub allow_ratings: bool,
    pub featured_image: Option<String>,
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub published_at: Option<DateTime<Utc>>,
}

// 主应用程序
// File: enterprise-blog/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::sync::Arc;
use tokio::sync::RwLock;

mod models;
mod services;
mod web;

use models::*;
use services::*;
use web::WebServer;

#[derive(Parser, Debug)]
#[command(name = "enterprise-blog")]
#[command(about = "Enterprise Blog System")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start the web server
    Server {
        #[arg(short, long, default_value = "0.0.0.0:3000")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Run database migrations
    Migrate {
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
    },
    /// Setup database and run migrations
    Setup {
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "enterprise_blog=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Server { addr, database_url, redis_url } => {
            run_server(addr, database_url, redis_url).await
        }
        Commands::Migrate { database_url } => {
            run_migrations(database_url).await
        }
        Commands::Setup { database_url } => {
            setup_database(database_url).await
        }
    }
}

#[instrument]
async fn run_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting Enterprise Blog server on {}", addr);
    
    // 初始化数据库
    let db_pool = sqlx::PgPool::connect(&database_url).await?;
    let redis_client = redis::Client::open(&redis_url)?;
    
    // 初始化服务
    let user_service = Arc::new(UserService::new(db_pool.clone()));
    let blog_service = Arc::new(BlogService::new(db_pool.clone()));
    let auth_service = Arc::new(AuthService::new(db_pool.clone(), redis_client.clone()));
    let media_service = Arc::new(MediaService::new(db_pool.clone()));
    let analytics_service = Arc::new(AnalyticsService::new(db_pool.clone()));
    
    // 启动Web服务器
    let server = WebServer::new(
        addr,
        user_service,
        blog_service,
        auth_service,
        media_service,
        analytics_service,
    );
    
    info!("Enterprise Blog server started successfully");
    server.run().await?;
    
    Ok(())
}

#[instrument]
async fn run_migrations(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Running database migrations");
    
    let pool = sqlx::PgPool::connect(&database_url).await?;
    
    // 创建用户表
    sqlx::query(r#"
        CREATE TYPE user_role AS ENUM ('admin', 'editor', 'author', 'subscriber');
        
        CREATE TABLE users (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(100) UNIQUE NOT NULL,
            display_name VARCHAR(100) NOT NULL,
            bio TEXT,
            avatar_url TEXT,
            website TEXT,
            password_hash VARCHAR(255) NOT NULL,
            role user_role NOT NULL DEFAULT 'subscriber',
            is_active BOOLEAN DEFAULT TRUE,
            email_verified BOOLEAN DEFAULT FALSE,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW(),
            last_login TIMESTAMPTZ
        );
    "#).execute(&pool).await?;
    
    // 创建博客文章表
    sqlx::query(r#"
        CREATE TYPE blog_status AS ENUM ('draft', 'published', 'archived', 'scheduled');
        
        CREATE TABLE blog_posts (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            title VARCHAR(200) NOT NULL,
            slug VARCHAR(200) UNIQUE NOT NULL,
            content TEXT NOT NULL,
            excerpt TEXT,
            featured_image TEXT,
            author_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            category_id UUID,
            status blog_status NOT NULL DEFAULT 'draft',
            is_featured BOOLEAN DEFAULT FALSE,
            is_pinned BOOLEAN DEFAULT FALSE,
            allow_comments BOOLEAN DEFAULT TRUE,
            allow_ratings BOOLEAN DEFAULT TRUE,
            view_count INTEGER DEFAULT 0,
            like_count INTEGER DEFAULT 0,
            comment_count INTEGER DEFAULT 0,
            reading_time INTEGER DEFAULT 0,
            seo_title VARCHAR(200),
            seo_description TEXT,
            published_at TIMESTAMPTZ,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        );
    "#).execute(&pool).await?;
    
    info!("Database migrations completed successfully");
    Ok(())
}

#[instrument]
async fn setup_database(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Setting up database and running migrations");
    
    // 先运行迁移
    run_migrations(database_url.clone()).await?;
    
    // 创建默认管理员用户
    let pool = sqlx::PgPool::connect(&database_url).await?;
    let admin_password = "admin123";
    
    sqlx::query!(
        r#"
        INSERT INTO users (username, email, display_name, password_hash, role, is_active, email_verified)
        VALUES ('admin', 'admin@example.com', 'Administrator', $1, 'admin', true, true)
        ON CONFLICT (username) DO NOTHING
        "#,
        bcrypt::hash(&admin_password, bcrypt::DEFAULT_COST)?
    )
    .execute(&pool)
    .await?;
    
    info!("Default admin user created - username: admin, password: admin123");
    info!("Please change the admin password after first login");
    
    Ok(())
}

// 服务层实现
// File: enterprise-blog/src/services.rs
use super::models::*;
use crate::database::DatabaseManager;
use sqlx::PgPool;
use tracing::{info, warn, error, instrument};

pub struct UserService {
    pool: PgPool,
}

impl UserService {
    pub fn new(pool: PgPool) -> Self {
        UserService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_user(&self, request: &RegisterRequest) -> Result<User, sqlx::Error> {
        let password_hash = bcrypt::hash(&request.password, bcrypt::DEFAULT_COST)?;
        
        let user = sqlx::query!(
            r#"
            INSERT INTO users (username, email, display_name, password_hash, role, is_active, email_verified)
            VALUES ($1, $2, $3, $4, 'subscriber', true, false)
            RETURNING *
            "#,
            request.username,
            request.email,
            request.display_name,
            password_hash
        )
        .fetch_one(&self.pool)
        .await?;
        
        Ok(User::from_row(&user)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_by_id(&self, user_id: &Uuid) -> Result<Option<User>, sqlx::Error> {
        let user = sqlx::query!(
            "SELECT * FROM users WHERE id = $1",
            user_id
        )
        .fetch_optional(&self.pool)
        .await?;
        
        Ok(user.map(|row| User::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn authenticate_user(&self, username: &str, password: &str) -> Result<Option<User>, sqlx::Error> {
        if let Some(user) = sqlx::query!(
            "SELECT * FROM users WHERE username = $1 AND is_active = true",
            username
        )
        .fetch_optional(&self.pool)
        .await? {
            let user = User::from_row(&user).unwrap();
            if bcrypt::verify(password, &user.password_hash)? {
                Ok(Some(user))
            } else {
                Ok(None)
            }
        } else {
            Ok(None)
        }
    }
}

pub struct BlogService {
    pool: PgPool,
}

impl BlogService {
    pub fn new(pool: PgPool) -> Self {
        BlogService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_blog_post(&self, request: &CreateBlogRequest, author_id: Uuid) -> Result<BlogPost, sqlx::Error> {
        let slug = generate_slug(&request.title);
        
        let post = sqlx::query!(
            r#"
            INSERT INTO blog_posts (
                id, title, slug, content, excerpt, featured_image, author_id, category_id,
                status, is_featured, is_pinned, allow_comments, allow_ratings,
                seo_title, seo_description, published_at
            ) VALUES (
                gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
            )
            RETURNING *
            "#,
            request.title,
            slug,
            request.content,
            request.excerpt,
            request.featured_image,
            author_id,
            request.category_id,
            request.status as BlogStatus,
            request.is_featured,
            request.is_pinned,
            request.allow_comments,
            request.allow_ratings,
            request.seo_title,
            request.seo_description,
            request.published_at
        )
        .fetch_one(&self.pool)
        .await?;
        
        Ok(BlogPost::from_row(&post)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_published_posts(&self, limit: i64, offset: i64) -> Result<Vec<BlogPost>, sqlx::Error> {
        let posts = sqlx::query!(
            r#"
            SELECT bp.*, u.display_name as author_name
            FROM blog_posts bp
            JOIN users u ON bp.author_id = u.id
            WHERE bp.status = 'published'
            ORDER BY bp.is_pinned DESC, bp.published_at DESC
            LIMIT $1 OFFSET $2
            "#,
            limit,
            offset
        )
        .fetch_all(&self.pool)
        .await?;
        
        Ok(posts.into_iter().map(|row| BlogPost::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn increment_view_count(&self, post_id: &Uuid) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE blog_posts SET view_count = view_count + 1 WHERE id = $1",
            post_id
        )
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
}

// 辅助函数
fn generate_slug(title: &str) -> String {
    title.to_lowercase()
        .chars()
        .map(|c| match c {
            'a'..='z' | '0'..='9' => c,
            ' ' | '-' | '_' => '-',
            _ => '',
        })
        .collect::<String>()
        .trim_matches('-')
        .to_string()
}

// Web服务器
// File: enterprise-blog/src/web.rs
use super::services::*;
use super::models::*;
use axum::{
    extract::{Path, State},
    response::Json,
    routing::{get, post, put, delete},
    Router,
};
use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, cors::CorsLayer};
use std::sync::Arc;

pub struct WebServer {
    app: Router,
    addr: String,
}

impl WebServer {
    pub fn new(
        addr: String,
        user_service: Arc<UserService>,
        blog_service: Arc<BlogService>,
        auth_service: Arc<AuthService>,
        media_service: Arc<MediaService>,
        analytics_service: Arc<AnalyticsService>,
    ) -> Self {
        let app = Router::new()
            .route("/", get(home_handler))
            .route("/health", get(health_check))
            
            // 公开API
            .route("/api/v1/posts", get(get_posts).post(create_post))
            .route("/api/v1/posts/:id", get(get_post))
            .route("/api/v1/categories", get(get_categories))
            .route("/api/v1/tags", get(get_tags))
            .route("/api/v1/search", get(search_posts))
            
            // 用户API
            .route("/api/v1/auth/register", post(register_user))
            .route("/api/v1/auth/login", post(login_user))
            .route("/api/v1/auth/logout", post(logout_user))
            
            // 管理API
            .route("/api/v1/admin/posts", get(admin_list_posts))
            .route("/api/v1/admin/users", get(admin_list_users))
            
            .with_state(AppState {
                user_service,
                blog_service,
                auth_service,
                media_service,
                analytics_service,
            })
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
            );
        
        WebServer { app, addr }
    }
    
    pub async fn run(self) -> Result<(), Box<dyn std::error::Error>> {
        let listener = tokio::net::TcpListener::bind(&self.addr).await?;
        println!("Enterprise Blog server listening on {}", self.addr);
        
        axum::serve(listener, self.app).await?;
        Ok(())
    }
}

#[derive(Clone)]
struct AppState {
    user_service: Arc<UserService>,
    blog_service: Arc<BlogService>,
    auth_service: Arc<AuthService>,
    media_service: Arc<MediaService>,
    analytics_service: Arc<AnalyticsService>,
}

// 处理器实现
async fn home_handler() -> &'static str {
    "Enterprise Blog System"
}

async fn health_check(State(state): State<AppState>) -> impl IntoResponse {
    let db_healthy = sqlx::query("SELECT 1").fetch_one(&state.user_service.pool).await.is_ok();
    Json(serde_json::json!({
        "status": "healthy",
        "database": db_healthy,
    }))
}

async fn get_posts(State(state): State<AppState>) -> impl IntoResponse {
    match state.blog_service.get_published_posts(20, 0).await {
        Ok(posts) => Json(serde_json::json!({
            "posts": posts,
            "total": posts.len() as i64,
        })),
        Err(_) => Json(serde_json::json!({
            "error": "Failed to fetch posts"
        })),
    }
}

async fn create_post(
    State(state): State<AppState>,
    Json(request): Json<CreateBlogRequest>,
) -> impl IntoResponse {
    // 从认证中获取用户ID
    let author_id = Uuid::new_v4(); // 简化实现
    
    match state.blog_service.create_blog_post(&request, author_id).await {
        Ok(post) => Json(serde_json::json!({
            "success": true,
            "post": post,
        })),
        Err(e) => Json(serde_json::json!({
            "success": false,
            "error": e.to_string(),
        })),
    }
}

async fn get_post(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> impl IntoResponse {
    // 增加浏览量
    let _ = state.blog_service.increment_view_count(&id).await;
    
    // 获取文章详情
    // 简化实现
    Json(serde_json::json!({
        "id": id,
        "title": "Sample Post",
        "content": "This is a sample blog post content.",
    }))
}

// 其他处理器...

#![allow(unused)]
fn main() {
// Docker部署配置
File: enterprise-blog/docker-compose.yml
version: '3.8'

services:
  postgres:
    image: postgres:15
    environment:
      POSTGRES_DB: enterprise_blog
      POSTGRES_USER: blog_user
      POSTGRES_PASSWORD: password
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data

  blog-app:
    build: .
    ports:
      - "3000:3000"
    environment:
      DATABASE_URL: postgres://blog_user:password@postgres:5432/enterprise_blog
      REDIS_URL: redis://redis:6379
    depends_on:
      - postgres
      - redis
    restart: unless-stopped

volumes:
  postgres_data:
  redis_data:
}

#![allow(unused)]
fn main() {
// File: enterprise-blog/README.md
企业级博客系统

一个基于Rust构建的企业级博客系统，支持多用户、权限管理、内容管理、评论系统、搜索功能、SEO优化等企业级特性。

# 功能特性

## 核心功能
- **用户管理**：用户注册、登录、权限管理
- **内容管理**：博客文章的创建、编辑、发布、管理
- **分类系统**：多级分类、标签管理
- **评论系统**：评论、回复、审核
- **媒体管理**：图片上传、管理、CDN支持
- **搜索功能**：全文搜索、高级搜索
- **SEO优化**：URL重写、meta标签、sitemap

## 企业级特性
- **权限管理**：基于角色的访问控制
- **数据安全**：密码哈希、SQL注入防护
- **性能优化**：缓存、CDN、图片优化
- **监控告警**：性能监控、错误追踪
- **备份恢复**：数据备份、灾难恢复
- **国际化**：多语言支持

# 快速开始

## 使用Docker Compose

1. 启动服务
```bash
docker-compose up -d
}

初始化数据库

cargo run setup --database-url "postgres://blog_user:password@localhost/enterprise_blog"

访问系统

网站：http://localhost:3000
API文档：http://localhost:3000/health

本地开发

安装依赖

# 安装PostgreSQL和Redis
sudo apt-get install postgresql redis-server

设置环境

# 创建数据库
createdb enterprise_blog

# 设置环境变量
export DATABASE_URL="postgres://blog_user:password@localhost/enterprise_blog"
export REDIS_URL="redis://localhost:6379"

运行应用

cargo run server

API文档

公开API

GET /api/v1/posts - 获取博客文章列表
GET /api/v1/posts/:id - 获取博客文章详情
GET /api/v1/categories - 获取分类列表
GET /api/v1/tags - 获取标签列表
GET /api/v1/search - 搜索文章

用户API

POST /api/v1/auth/register - 用户注册
POST /api/v1/auth/login - 用户登录
POST /api/v1/auth/logout - 用户登出

管理API

GET /api/v1/admin/posts - 管理文章列表
GET /api/v1/admin/users - 管理用户列表
POST /api/v1/admin/posts - 创建文章
PUT /api/v1/admin/posts/:id - 更新文章
DELETE /api/v1/admin/posts/:id - 删除文章

性能特性

数据库优化

索引优化
查询优化
分页处理
连接池管理

缓存策略

Redis缓存
页面缓存
API响应缓存
静态资源缓存

静态资源

图片压缩
CSS/JS压缩
CDN集成
懒加载

安全特性

身份认证

JWT token认证
密码安全存储
会话管理
密码重置

数据安全

SQL注入防护
XSS防护
CSRF保护
输入验证

权限控制

基于角色的访问控制
细粒度权限管理
API访问控制
资源权限验证

监控和运维

性能监控

请求响应时间
数据库查询性能
内存使用监控
CPU使用监控

错误监控

应用错误追踪
异常日志记录
错误通知
错误恢复

业务监控

用户活跃度
内容访问统计
搜索热词分析
转化率追踪

部署和扩展

容器化部署

Docker容器化
Kubernetes支持
CI/CD管道
蓝绿部署

水平扩展

无状态设计
负载均衡
数据库分片
微服务架构

云部署

AWS支持
Google Cloud支持
Azure支持
多云部署

开发规范

代码质量

单元测试
集成测试
性能测试
安全测试

文档规范

API文档
代码注释
架构文档
部署文档

版本控制

Git工作流
代码审查
分支管理
发布流程

贡献指南

欢迎贡献代码、报告问题或提出功能请求。

许可证

MIT License

联系信息：

作者：MiniMax Agent
邮箱：developer@minimax.com
文档：https://docs.minimax.com/enterprise-blog

第12章：Web开发

章节概述

学习目标：

掌握Rust Web开发的核心概念和最佳实践
理解主流Web框架的特点和适用场景
学会构建安全、高效的Web应用
掌握用户认证、授权和会话管理
学会表单处理、数据验证和文件上传
设计并实现一个完整的企业级博客系统

实战项目：构建一个企业级博客系统，支持多用户、权限管理、内容管理、评论系统、搜索功能、SEO优化等企业级特性。

12.1 Web框架选择

12.1.1 Rust Web框架生态

Rust在Web开发方面拥有多个成熟的框架：

Actix-web：高性能、功能完整、社区活跃
Axum：基于Tokio的现代化框架，类型安全
Rocket：零配置、开发友好、安全
Warp：组合式、函数式编程风格
Tide：异步、简洁的设计

12.1.2 框架对比分析

Actix-web特点

// Actix-web示例
use actix_web::{web, App, HttpResponse, HttpRequest, Responder};

async fn index() -> impl Responder {
    HttpResponse::Ok().body("Hello World!")
}

async fn greet(req: HttpRequest) -> impl Responder {
    let name = req.match_info().get("name").unwrap_or("World");
    format!("Hello {}!", &name)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/{name}", web::get().to(greet))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

Axum特点

// Axum示例
use axum::{extract::Path, response::Json, routing::get, Router};
use serde_json::{json, Value};

async fn root() -> Json<Value> {
    Json(json!({
        "message": "Hello, World!"
    }))
}

async fn greet(Path(name): Path<String>) -> Json<Value> {
    Json(json!({
        "message": format!("Hello, {}!", name)
    }))
}

#[tokio::main]
async fn main() {
    let app = Router::new()
        .route("/", get(root))
        .route("/:name", get(greet));
    
    let listener = tokio::net::TcpListener::bind("127.0.0.1:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

12.1.3 框架选择建议

#![allow(unused)]
fn main() {
// 框架选择决策树
pub struct FrameworkSelection {
    performance_priority: bool,
    development_speed: bool,
    feature_complexity: String,
    team_experience: String,
    deployment_target: String,
}

impl FrameworkSelection {
    pub fn recommend_framework(&self) -> FrameworkRecommendation {
        match (
            self.performance_priority,
            self.development_speed,
            &self.feature_complexity,
        ) {
            (true, false, "simple") => FrameworkRecommendation::ActixWeb,
            (true, true, "medium") => FrameworkRecommendation::Axum,
            (false, true, "simple") => FrameworkRecommendation::Rocket,
            (false, false, "complex") => FrameworkRecommendation::Axum,
            _ => FrameworkRecommendation::ActixWeb,
        }
    }
}

#[derive(Debug)]
pub enum FrameworkRecommendation {
    ActixWeb,
    Axum,
    Rocket,
}

impl std::fmt::Display for FrameworkRecommendation {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FrameworkRecommendation::ActixWeb => write!(f, "Actix-web"),
            FrameworkRecommendation::Axum => write!(f, "Axum"),
            FrameworkRecommendation::Rocket => write!(f, "Rocket"),
        }
    }
}
}

12.2 路由与中间件

12.2.1 基于Axum的路由系统

#![allow(unused)]
fn main() {
// 高级路由配置
use axum::{
    extract::{Path, Query, State, Extension},
    http::{HeaderValue, Method, StatusCode},
    response::{IntoResponse, Redirect},
    routing::{get, post, put, delete, patch},
    Router, Json, Form
};
use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, cors::CorsLayer, compression::CompressionLayer};
use std::collections::HashMap;
use std::sync::Arc;

// 应用状态
#[derive(Clone)]
pub struct AppState {
    pub db_pool: sqlx::PgPool,
    pub redis_client: redis::Client,
    pub config: Config,
    pub logger: Arc<tracing::log::Logger>,
}

// 路由构建器
pub struct RouteBuilder {
    state: AppState,
    routes: Vec<Route>,
    middleware: Vec<Box<dyn axum::middleware::Middleware<(), State = AppState>>>,
}

impl RouteBuilder {
    pub fn new(state: AppState) -> Self {
        RouteBuilder {
            state,
            routes: Vec::new(),
            middleware: Vec::new(),
        }
    }
    
    pub fn add_route<R, T>(mut self, method: Method, path: &str, handler: R) -> Self
    where
        R: axum::handler::Handler<T, State = AppState> + Clone,
        T: axum::extract::FromRequestParts<AppState> + axum::extract::FromRequest<AppState>,
    {
        let route = Route {
            method,
            path: path.to_string(),
            handler: std::any::type_name::<R>().to_string(),
        };
        self.routes.push(route);
        self
    }
    
    pub fn add_middleware<M>(mut self, middleware: M) -> Self
    where
        M: axum::middleware::Middleware<(), State = AppState> + Send + Sync + 'static,
    {
        self.middleware.push(Box::new(middleware) as Box<dyn axum::middleware::Middleware<(), State = AppState>>);
        self
    }
    
    pub fn build(self) -> Router<AppState> {
        let mut app = Router::new();
        
        // 基础路由
        app = app
            .route("/", get(home_handler))
            .route("/health", get(health_check))
            .route("/api/v1/status", get(api_status));
        
        // 用户管理路由
        app = app
            .route("/api/v1/users", get(list_users).post(create_user))
            .route("/api/v1/users/:id", get(get_user).put(update_user).delete(delete_user))
            .route("/api/v1/auth/login", post(login))
            .route("/api/v1/auth/logout", post(logout))
            .route("/api/v1/auth/refresh", post(refresh_token));
        
        // 博客相关路由
        app = app
            .route("/api/v1/blogs", get(list_blogs).post(create_blog))
            .route("/api/v1/blogs/:id", get(get_blog).put(update_blog).delete(delete_blog))
            .route("/api/v1/blogs/:id/comments", get(list_comments).post(create_comment))
            .route("/api/v1/blogs/:id/like", post(like_blog))
            .route("/api/v1/blogs/:id/share", post(share_blog));
        
        // 分类和标签路由
        app = app
            .route("/api/v1/categories", get(list_categories).post(create_category))
            .route("/api/v1/tags", get(list_tags).post(create_tag))
            .route("/api/v1/search", get(search));
        
        // 管理员路由
        app = app
            .route("/api/v1/admin/dashboard", get(admin_dashboard))
            .route("/api/v1/admin/users", get(admin_list_users))
            .route("/api/v1/admin/blogs", get(admin_list_blogs))
            .route("/api/v1/admin/comments", get(admin_list_comments));
        
        // 文件上传路由
        app = app
            .route("/api/v1/upload", post(upload_file))
            .route("/api/v1/files/:id", get(download_file).delete(delete_file));
        
        // 静态文件服务
        app = app
            .route("/static/*path", get(serve_static));
        
        // 添加中间件
        app = app
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
                    .layer(CompressionLayer::new())
                    .layer(Extension(self.state))
            );
        
        // 添加自定义中间件
        for middleware in self.middleware {
            app = app.layer(middleware);
        }
        
        app
    }
}

struct Route {
    method: Method,
    path: String,
    handler: String,
}

// 基础处理器
async fn home_handler() -> impl IntoResponse {
    (
        StatusCode::OK,
        [("Content-Type", "text/html")],
        r#"
        <!DOCTYPE html>
        <html>
        <head>
            <title>企业级博客系统</title>
            <meta charset="UTF-8">
        </head>
        <body>
            <h1>欢迎使用企业级博客系统</h1>
            <p>API文档: <a href="/api/v1/docs">查看文档</a></p>
        </body>
        </html>
        "#,
    )
}

async fn health_check(State(state): State<AppState>) -> impl IntoResponse {
    // 检查数据库连接
    let db_healthy = match sqlx::query("SELECT 1").fetch_one(&state.db_pool).await {
        Ok(_) => true,
        Err(_) => false,
    };
    
    // 检查Redis连接
    let redis_healthy = match state.redis_client.get_connection() {
        Ok(_) => true,
        Err(_) => false,
    };
    
    Json(serde_json::json!({
        "status": "healthy",
        "database": db_healthy,
        "redis": redis_healthy,
        "timestamp": chrono::Utc::now().to_rfc3339(),
    }))
}

async fn api_status() -> impl IntoResponse {
    Json(serde_json::json!({
        "api_version": "1.0.0",
        "service": "企业级博客系统",
        "status": "operational",
    }))
}

// 错误处理
#[derive(Debug, thiserror::Error)]
pub enum AppError {
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    #[error("Redis error: {0}")]
    Redis(#[from] redis::RedisError),
    #[error("Validation error: {0}")]
    Validation(String),
    #[error("Not found")]
    NotFound,
    #[error("Unauthorized")]
    Unauthorized,
    #[error("Forbidden")]
    Forbidden,
    #[error("Internal server error")]
    InternalServerError,
}

impl IntoResponse for AppError {
    fn into_response(self) -> axum::response::Response {
        match self {
            AppError::NotFound => (
                StatusCode::NOT_FOUND,
                Json(serde_json::json!({
                    "error": "Resource not found",
                    "status": 404
                }))
            ),
            AppError::Unauthorized => (
                StatusCode::UNAUTHORIZED,
                Json(serde_json::json!({
                    "error": "Unauthorized access",
                    "status": 401
                }))
            ),
            AppError::Forbidden => (
                StatusCode::FORBIDDEN,
                Json(serde_json::json!({
                    "error": "Access forbidden",
                    "status": 403
                }))
            ),
            AppError::Validation(msg) => (
                StatusCode::BAD_REQUEST,
                Json(serde_json::json!({
                    "error": msg,
                    "status": 400
                }))
            ),
            AppError::Database(_) | AppError::Redis(_) | AppError::InternalServerError => (
                StatusCode::INTERNAL_SERVER_ERROR,
                Json(serde_json::json!({
                    "error": "Internal server error",
                    "status": 500
                }))
            ),
        }
    }
}

// 配置文件
#[derive(Debug, Clone)]
pub struct Config {
    pub database_url: String,
    pub redis_url: String,
    pub jwt_secret: String,
    pub upload_dir: String,
    pub max_upload_size: usize,
    pub session_timeout: std::time::Duration,
}
}

12.2.2 中间件系统

#![allow(unused)]
fn main() {
// 自定义中间件实现
use axum::{
    extract::{Request, State},
    middleware::Next,
    response::Response,
    http::StatusCode,
    Extension,
};
use std::future::Future;
use std::pin::Pin;
use std::time::{Duration, Instant};

// 认证中间件
pub struct AuthMiddleware {
    pub required_roles: Vec<String>,
}

impl axum::middleware::Middleware<(), State = AppState> for AuthMiddleware {
    type Future = Pin<Box<dyn Future<Output = Result<Response, (StatusCode, String)>> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let user_id = extract_user_id(&request).await;
            
            if let Some(user_id) = user_id {
                // 验证用户
                if let Ok(user) = get_user_by_id(&state.db_pool, &user_id).await {
                    // 检查角色权限
                    if check_role_permissions(&user, &self.required_roles) {
                        // 添加用户信息到请求扩展
                        let mut request = request;
                        request.extensions_mut().insert(user);
                        next.run(request).await
                    } else {
                        Err((StatusCode::FORBIDDEN, "Insufficient permissions".to_string()))
                    }
                } else {
                    Err((StatusCode::UNAUTHORIZED, "Invalid user".to_string()))
                }
            } else {
                Err((StatusCode::UNAUTHORIZED, "Authentication required".to_string()))
            }
        })
    }
}

// 速率限制中间件
pub struct RateLimitMiddleware {
    pub max_requests: u64,
    pub window: Duration,
    pub key_extractor: fn(&Request) -> String,
}

impl axum::middleware::Middleware<(), State = AppState> for RateLimitMiddleware {
    type Future = Pin<Box<dyn Future<Output = Result<Response, (StatusCode, String)>> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let key = (self.key_extractor)(&request);
            
            if let Some(allowed) = check_rate_limit(&state.redis_client, &key, self.max_requests, self.window).await {
                if allowed {
                    next.run(request).await
                } else {
                    Err((StatusCode::TOO_MANY_REQUESTS, "Rate limit exceeded".to_string()))
                }
            } else {
                next.run(request).await
            }
        })
    }
}

// 性能监控中间件
pub struct MetricsMiddleware {
    pub name: String,
}

impl axum::middleware::Middleware<(), State = AppState> for MetricsMiddleware {
    type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let start = Instant::now();
            let method = request.method().clone();
            let path = request.uri().path().to_string();
            
            let response = next.run(request).await;
            
            let duration = start.elapsed();
            let status_code = response.status();
            
            // 记录指标
            record_metrics(&state, &self.name, &method, &path, status_code, duration);
            
            response
        })
    }
}

// 日志中间件
pub struct LoggingMiddleware {
    pub level: tracing::Level,
}

impl axum::middleware::Middleware<(), State = AppState> for LoggingMiddleware {
    type Future = Pin<Box<dyn Future<Output = Response> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let start = Instant::now();
            let method = request.method().clone();
            let path = request.uri().path().to_string();
            let user_agent = request.headers()
                .get("user-agent")
                .and_then(|h| h.to_str().ok())
                .unwrap_or("unknown");
            
            tracing::info!(
                target: "http_requests",
                method = %method,
                path = %path,
                user_agent = %user_agent,
                "request started"
            );
            
            let response = next.run(request).await;
            
            let duration = start.elapsed();
            let status_code = response.status();
            
            tracing::info!(
                target: "http_requests",
                method = %method,
                path = %path,
                status_code = %status_code,
                duration = ?duration,
                "request completed"
            );
            
            response
        })
    }
}
}

12.3 表单处理与验证

12.3.1 表单数据提取

#![allow(unused)]
fn main() {
use axum::{
    extract::{Form, Multipart, FromRequest, WebSocketUpgrade},
    http::StatusCode,
    response::{Html, Redirect},
    Json, Form
};
use serde::{Deserialize, Serialize};
use serde_with::{DisplayFromStr, serde_as};
use std::collections::HashMap;

// 基础表单结构
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct UserRegistrationForm {
    pub username: String,
    pub email: String,
    pub password: String,
    pub password_confirm: String,
    pub display_name: String,
    pub bio: Option<String>,
    pub website: Option<String>,
    pub terms_accepted: bool,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct BlogPostForm {
    pub title: String,
    pub content: String,
    pub summary: Option<String>,
    pub category_id: Option<String>,
    pub tags: Option<String>, // 逗号分隔的标签
    pub is_published: bool,
    pub featured_image: Option<String>,
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub allow_comments: bool,
}

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct CommentForm {
    pub content: String,
    pub parent_id: Option<String>, // 回复评论的ID
    pub rating: Option<u8>, // 1-5星评分
}

// 文件上传表单
#[derive(Debug, Deserialize, Serialize)]
pub struct FileUploadForm {
    pub description: Option<String>,
    pub category: String,
    pub tags: Option<String>,
}

// 自定义提取器
pub struct ValidatedForm<T>(pub T);

impl<T, S> FromRequest<S> for ValidatedForm<T>
where
    T: for<'de> Deserialize<'de> + Send + Sync + 'static,
    S: Send + Sync,
{
    type Rejection = (StatusCode, String);
    
    async fn from_request(req: axum::extract::Request, _state: &S) -> Result<Self, Self::Rejection> {
        let content_type = req.headers()
            .get("content-type")
            .and_then(|h| h.to_str().ok())
            .unwrap_or("");
        
        if content_type.contains("application/x-www-form-urlencoded") {
            let form = axum::extract::Form::<HashMap<String, String>>::from_request(req, _state).await
                .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid form data".to_string()))?;
            
            let data = serde_urlencoded::from_str::<T>(&form.0.iter()
                .map(|(k, v)| format!("{}={}", k, v))
                .collect::<Vec<_>>()
                .join("&"))
                .map_err(|e| (StatusCode::BAD_REQUEST, format!("Validation error: {}", e)))?;
            
            Ok(ValidatedForm(data))
        } else if content_type.contains("multipart/form-data") {
            // 处理multipart表单
            let multipart = axum::extract::Multipart::from_request(req, _state).await
                .map_err(|_| (StatusCode::BAD_REQUEST, "Invalid multipart data".to_string()))?;
            
            let data = process_multipart_form::<T>(multipart).await
                .map_err(|e| (StatusCode::BAD_REQUEST, format!("Validation error: {}", e)))?;
            
            Ok(ValidatedForm(data))
        } else {
            Err((StatusCode::UNSUPPORTED_MEDIA_TYPE, "Unsupported content type".to_string()))
        }
    }
}

async fn process_multipart_form<T: for<'de> Deserialize<'de>>(
    mut multipart: axum::extract::Multipart
) -> Result<T, Box<dyn std::error::Error>> {
    let mut form_data = HashMap::new();
    let mut files = HashMap::new();
    
    while let Some(field) = multipart.next_field().await? {
        let name = field.name().unwrap_or("").to_string();
        let data = field.bytes().await?;
        
        if field.file_name().is_some() {
            // 处理文件
            files.insert(name, data.to_vec());
        } else {
            // 处理文本字段
            form_data.insert(name, String::from_utf8_lossy(&data).to_string());
        }
    }
    
    // 构建最终的表单数据
    let form_data_str = form_data.iter()
        .map(|(k, v)| format!("{}={}", k, v))
        .collect::<Vec<_>>()
        .join("&");
    
    serde_urlencoded::from_str::<T>(&form_data_str).map_err(|e| e.into())
}

// 表单验证器
pub struct FormValidator;

impl FormValidator {
    pub fn validate_registration_form(form: &UserRegistrationForm) -> Result<(), ValidationError> {
        // 用户名验证
        if form.username.len() < 3 || form.username.len() > 50 {
            return Err(ValidationError::new("username", "用户名长度必须在3-50个字符之间"));
        }
        
        if !form.username.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-') {
            return Err(ValidationError::new("username", "用户名只能包含字母、数字、下划线和连字符"));
        }
        
        // 邮箱验证
        if !is_valid_email(&form.email) {
            return Err(ValidationError::new("email", "请输入有效的邮箱地址"));
        }
        
        // 密码验证
        if form.password.len() < 8 {
            return Err(ValidationError::new("password", "密码长度至少8个字符"));
        }
        
        if form.password != form.password_confirm {
            return Err(ValidationError::new("password_confirm", "两次输入的密码不一致"));
        }
        
        // 检查密码强度
        if !is_strong_password(&form.password) {
            return Err(ValidationError::new("password", "密码必须包含大小写字母、数字和特殊字符"));
        }
        
        // 条款接受验证
        if !form.terms_accepted {
            return Err(ValidationError::new("terms_accepted", "您必须接受服务条款"));
        }
        
        Ok(())
    }
    
    pub fn validate_blog_form(form: &BlogPostForm) -> Result<(), ValidationError> {
        // 标题验证
        if form.title.trim().is_empty() || form.title.len() > 200 {
            return Err(ValidationError::new("title", "标题长度必须在1-200个字符之间"));
        }
        
        // 内容验证
        if form.content.trim().is_empty() || form.content.len() < 100 {
            return Err(ValidationError::new("content", "内容长度至少100个字符"));
        }
        
        // 摘要验证
        if let Some(summary) = &form.summary {
            if summary.len() > 500 {
                return Err(ValidationError::new("summary", "摘要长度不能超过500个字符"));
            }
        }
        
        // 标签验证
        if let Some(tags) = &form.tags {
            let tag_list: Vec<&str> = tags.split(',').map(|t| t.trim()).filter(|t| !t.is_empty()).collect();
            if tag_list.len() > 10 {
                return Err(ValidationError::new("tags", "最多只能添加10个标签"));
            }
            
            for tag in tag_list {
                if tag.len() > 30 {
                    return Err(ValidationError::new("tags", "每个标签长度不能超过30个字符"));
                }
            }
        }
        
        Ok(())
    }
}

#[derive(Debug, Clone)]
pub struct ValidationError {
    field: String,
    message: String,
}

impl ValidationError {
    pub fn new(field: &str, message: &str) -> Self {
        ValidationError {
            field: field.to_string(),
            message: message.to_string(),
        }
    }
}

impl std::fmt::Display for ValidationError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.field, self.message)
    }
}

// 辅助函数
fn is_valid_email(email: &str) -> bool {
    regex::Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
        .unwrap()
        .is_match(email)
}

fn is_strong_password(password: &str) -> bool {
    let has_upper = password.chars().any(|c| c.is_uppercase());
    let has_lower = password.chars().any(|c| c.is_lowercase());
    let has_digit = password.chars().any(|c| c.is_digit(10));
    let has_special = password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c));
    
    has_upper && has_lower && has_digit && has_special
}
}

12.4 用户认证与授权

12.4.1 JWT认证系统

#![allow(unused)]
fn main() {
// JWT认证实现
use jsonwebtoken::{EncodingKey, DecodingKey, Algorithm, Header, TokenData, errors::Error as JwtError};
use serde::{Deserialize, Serialize};
use chrono::{Duration, Utc};
use axum::{
    extract::{FromRequestParts, Request},
    http::StatusCode,
    response::{IntoResponse, Response},
};
use std::future::Future;
use std::pin::Pin;
use std::sync::Arc;

#[derive(Debug, Serialize, Deserialize)]
pub struct Claims {
    pub sub: String, // 用户ID
    pub username: String,
    pub role: String,
    pub exp: usize, // 过期时间
    pub iat: usize, // 签发时间
    pub jti: String, // JWT ID
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginRequest {
    pub username: String,
    pub password: String,
    pub remember_me: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginResponse {
    pub access_token: String,
    pub refresh_token: String,
    pub token_type: String,
    pub expires_in: u64,
    pub user: UserInfo,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct UserInfo {
    pub id: String,
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub role: String,
    pub avatar_url: Option<String>,
}

pub struct JwtManager {
    pub encoding_key: EncodingKey,
    pub decoding_key: DecodingKey,
    pub access_token_duration: Duration,
    pub refresh_token_duration: Duration,
    pub algorithm: Algorithm,
}

impl JwtManager {
    pub fn new(secret: &str) -> Self {
        let key = EncodingKey::from_secret(secret.as_bytes());
        let decoding_key = DecodingKey::from_secret(secret.as_bytes());
        
        JwtManager {
            encoding_key: key,
            decoding_key,
            access_token_duration: Duration::minutes(15), // 15分钟
            refresh_token_duration: Duration::days(7), // 7天
            algorithm: Algorithm::HS256,
        }
    }
    
    pub fn generate_tokens(&self, user: &UserInfo) -> Result<(String, String), JwtError> {
        let now = Utc::now();
        let access_exp = (now + self.access_token_duration).timestamp() as usize;
        let refresh_exp = (now + self.refresh_token_duration).timestamp() as usize;
        
        let access_claims = Claims {
            sub: user.id.clone(),
            username: user.username.clone(),
            role: user.role.clone(),
            exp: access_exp,
            iat: now.timestamp() as usize,
            jti: uuid::Uuid::new_v4().to_string(),
        };
        
        let refresh_claims = Claims {
            sub: user.id.clone(),
            username: user.username.clone(),
            role: user.role.clone(),
            exp: refresh_exp,
            iat: now.timestamp() as usize,
            jti: uuid::Uuid::new_v4().to_string(),
        };
        
        let access_token = jsonwebtoken::encode(
            &Header::default(),
            &access_claims,
            &self.encoding_key,
        )?;
        
        let refresh_token = jsonwebtoken::encode(
            &Header::default(),
            &refresh_claims,
            &self.encoding_key,
        )?;
        
        Ok((access_token, refresh_token))
    }
    
    pub fn verify_token(&self, token: &str) -> Result<TokenData<Claims>, JwtError> {
        let validation = Validation::new(self.algorithm);
        jsonwebtoken::decode::<Claims>(token, &self.decoding_key, &validation)
    }
    
    pub fn extract_user_from_request(&self, request: &Request) -> Option<TokenData<Claims>> {
        let auth_header = request.headers()
            .get("authorization")
            .and_then(|h| h.to_str().ok());
        
        if let Some(auth) = auth_header {
            if auth.starts_with("Bearer ") {
                let token = &auth[7..];
                return self.verify_token(token).ok();
            }
        }
        
        // 也检查cookie
        let cookies = request.headers()
            .get("cookie")
            .and_then(|c| c.to_str().ok());
        
        if let Some(cookie_str) = cookies {
            for cookie in cookie_str.split(';') {
                let cookie = cookie.trim();
                if cookie.starts_with("access_token=") {
                    let token = &cookie[13..];
                    return self.verify_token(token).ok();
                }
            }
        }
        
        None
    }
}

// 从请求中提取用户信息
pub struct AuthenticatedUser {
    pub claims: TokenData<Claims>,
}

impl AuthenticatedUser {
    pub fn user_id(&self) -> &str {
        &self.claims.claims.sub
    }
    
    pub fn username(&self) -> &str {
        &self.claims.claims.username
    }
    
    pub fn role(&self) -> &str {
        &self.claims.claims.role
    }
    
    pub fn is_expired(&self) -> bool {
        self.claims.claims.exp < Utc::now().timestamp() as usize
    }
}

impl FromRequestParts<AppState> for AuthenticatedUser {
    type Rejection = (StatusCode, String);
    
    fn from_request_parts(
        parts: &mut axum::http::request::Parts,
        state: &AppState,
    ) -> impl Future<Output = Result<Self, Self::Rejection>> + Send {
        Box::pin(async move {
            let jwt_manager = &state.jwt_manager;
            
            if let Some(claims) = jwt_manager.extract_user_from_request(&parts.extensions.get::<Request>().unwrap()) {
                if !claims.claims.exp < Utc::now().timestamp() as usize {
                    return Err((StatusCode::UNAUTHORIZED, "Token expired".to_string()));
                }
                
                // 验证用户是否仍然有效
                if let Some(user) = get_user_by_id(&state.db_pool, &uuid::Uuid::parse_str(&claims.claims.sub).unwrap()).await {
                    // 检查用户状态
                    if !user.is_active {
                        return Err((StatusCode::FORBIDDEN, "User account is disabled".to_string()));
                    }
                    
                    Ok(AuthenticatedUser { claims })
                } else {
                    Err((StatusCode::UNAUTHORIZED, "User not found".to_string()))
                }
            } else {
                Err((StatusCode::UNAUTHORIZED, "Authentication required".to_string()))
            }
        })
    }
}
}

12.5 企业级博客系统

现在我们来构建一个完整的企业级博客系统，集成所有学到的Web开发技术。

#![allow(unused)]
fn main() {
// 企业级博客系统主项目
// File: enterprise-blog/Cargo.toml
/*
[package]
name = "enterprise-blog"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
axum = { version = "0.7", features = ["macros"] }
tower = { version = "0.4" }
tower-http = { version = "0.5", features = ["cors", "compression", "trace"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "uuid", "chrono"] }
redis = { version = "0.23", features = ["tokio-comp"] }
bcrypt = "0.15"
jsonwebtoken = "9.0"
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
anyhow = "1.0"
thiserror = "1.0"
regex = "1.0"
markdown = "1.0"
html-escape = "0.4"
mime = "0.4"
uuid = { version = "1.0", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
*/
}

// 数据模型
// File: enterprise-blog/src/models.rs
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};
use uuid::Uuid;
use sqlx::{FromRow, Type};

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct User {
    pub id: Uuid,
    pub username: String,
    pub email: String,
    pub display_name: String,
    pub bio: Option<String>,
    pub avatar_url: Option<String>,
    pub website: Option<String>,
    pub password_hash: String,
    pub role: UserRole,
    pub is_active: bool,
    pub email_verified: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
    pub last_login: Option<DateTime<Utc>>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "user_role")]
#[serde(rename_all = "snake_case")]
pub enum UserRole {
    Admin,
    Editor,
    Author,
    Subscriber,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct BlogPost {
    pub id: Uuid,
    pub title: String,
    pub slug: String,
    pub content: String,
    pub excerpt: Option<String>,
    pub featured_image: Option<String>,
    pub author_id: Uuid,
    pub category_id: Option<Uuid>,
    pub status: BlogStatus,
    pub is_featured: bool,
    pub is_pinned: bool,
    pub allow_comments: bool,
    pub allow_ratings: bool,
    pub view_count: i32,
    pub like_count: i32,
    pub comment_count: i32,
    pub reading_time: i32, // 分钟
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub published_at: Option<DateTime<Utc>>,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "blog_status")]
#[serde(rename_all = "snake_case")]
pub enum BlogStatus {
    Draft,
    Published,
    Archived,
    Scheduled,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Category {
    pub id: Uuid,
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub parent_id: Option<Uuid>,
    pub sort_order: i32,
    pub is_active: bool,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Tag {
    pub id: Uuid,
    pub name: String,
    pub slug: String,
    pub description: Option<String>,
    pub color: Option<String>,
    pub post_count: i32,
    pub created_at: DateTime<Utc>,
}

#[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
pub struct Comment {
    pub id: Uuid,
    pub post_id: Uuid,
    pub parent_id: Option<Uuid>,
    pub user_id: Option<Uuid>,
    pub author_name: Option<String>,
    pub author_email: Option<String>,
    pub content: String,
    pub status: CommentStatus,
    pub is_approved: bool,
    pub ip_address: String,
    pub user_agent: Option<String>,
    pub like_count: i32,
    pub created_at: DateTime<Utc>,
    pub updated_at: DateTime<Utc>,
}

#[derive(Debug, Clone, Serialize, Deserialize, Type)]
#[sqlx(type_name = "comment_status")]
#[serde(rename_all = "snake_case")]
pub enum CommentStatus {
    Pending,
    Approved,
    Spam,
    Trash,
}

// API请求/响应结构
#[derive(Debug, Serialize, Deserialize)]
pub struct RegisterRequest {
    pub username: String,
    pub email: String,
    pub password: String,
    pub display_name: String,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct LoginRequest {
    pub username: String,
    pub password: String,
    pub remember_me: bool,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CreateBlogRequest {
    pub title: String,
    pub content: String,
    pub excerpt: Option<String>,
    pub category_id: Option<Uuid>,
    pub tag_ids: Option<Vec<Uuid>>,
    pub status: BlogStatus,
    pub is_featured: bool,
    pub is_pinned: bool,
    pub allow_comments: bool,
    pub allow_ratings: bool,
    pub featured_image: Option<String>,
    pub seo_title: Option<String>,
    pub seo_description: Option<String>,
    pub published_at: Option<DateTime<Utc>>,
}

// 主应用程序
// File: enterprise-blog/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::sync::Arc;
use tokio::sync::RwLock;

mod models;
mod services;
mod web;

use models::*;
use services::*;
use web::WebServer;

#[derive(Parser, Debug)]
#[command(name = "enterprise-blog")]
#[command(about = "Enterprise Blog System")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start the web server
    Server {
        #[arg(short, long, default_value = "0.0.0.0:3000")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Run database migrations
    Migrate {
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
    },
    /// Setup database and run migrations
    Setup {
        #[arg(short, long, default_value = "postgres://blog_user:password@localhost/enterprise_blog")]
        database_url: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "enterprise_blog=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Server { addr, database_url, redis_url } => {
            run_server(addr, database_url, redis_url).await
        }
        Commands::Migrate { database_url } => {
            run_migrations(database_url).await
        }
        Commands::Setup { database_url } => {
            setup_database(database_url).await
        }
    }
}

#[instrument]
async fn run_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting Enterprise Blog server on {}", addr);
    
    // 初始化数据库
    let db_pool = sqlx::PgPool::connect(&database_url).await?;
    let redis_client = redis::Client::open(&redis_url)?;
    
    // 初始化服务
    let user_service = Arc::new(UserService::new(db_pool.clone()));
    let blog_service = Arc::new(BlogService::new(db_pool.clone()));
    let auth_service = Arc::new(AuthService::new(db_pool.clone(), redis_client.clone()));
    let media_service = Arc::new(MediaService::new(db_pool.clone()));
    let analytics_service = Arc::new(AnalyticsService::new(db_pool.clone()));
    
    // 启动Web服务器
    let server = WebServer::new(
        addr,
        user_service,
        blog_service,
        auth_service,
        media_service,
        analytics_service,
    );
    
    info!("Enterprise Blog server started successfully");
    server.run().await?;
    
    Ok(())
}

#[instrument]
async fn run_migrations(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Running database migrations");
    
    let pool = sqlx::PgPool::connect(&database_url).await?;
    
    // 创建用户表
    sqlx::query(r#"
        CREATE TYPE user_role AS ENUM ('admin', 'editor', 'author', 'subscriber');
        
        CREATE TABLE users (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(100) UNIQUE NOT NULL,
            display_name VARCHAR(100) NOT NULL,
            bio TEXT,
            avatar_url TEXT,
            website TEXT,
            password_hash VARCHAR(255) NOT NULL,
            role user_role NOT NULL DEFAULT 'subscriber',
            is_active BOOLEAN DEFAULT TRUE,
            email_verified BOOLEAN DEFAULT FALSE,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW(),
            last_login TIMESTAMPTZ
        );
    "#).execute(&pool).await?;
    
    // 创建博客文章表
    sqlx::query(r#"
        CREATE TYPE blog_status AS ENUM ('draft', 'published', 'archived', 'scheduled');
        
        CREATE TABLE blog_posts (
            id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
            title VARCHAR(200) NOT NULL,
            slug VARCHAR(200) UNIQUE NOT NULL,
            content TEXT NOT NULL,
            excerpt TEXT,
            featured_image TEXT,
            author_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            category_id UUID,
            status blog_status NOT NULL DEFAULT 'draft',
            is_featured BOOLEAN DEFAULT FALSE,
            is_pinned BOOLEAN DEFAULT FALSE,
            allow_comments BOOLEAN DEFAULT TRUE,
            allow_ratings BOOLEAN DEFAULT TRUE,
            view_count INTEGER DEFAULT 0,
            like_count INTEGER DEFAULT 0,
            comment_count INTEGER DEFAULT 0,
            reading_time INTEGER DEFAULT 0,
            seo_title VARCHAR(200),
            seo_description TEXT,
            published_at TIMESTAMPTZ,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW()
        );
    "#).execute(&pool).await?;
    
    info!("Database migrations completed successfully");
    Ok(())
}

#[instrument]
async fn setup_database(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Setting up database and running migrations");
    
    // 先运行迁移
    run_migrations(database_url.clone()).await?;
    
    // 创建默认管理员用户
    let pool = sqlx::PgPool::connect(&database_url).await?;
    let admin_password = "admin123";
    
    sqlx::query!(
        r#"
        INSERT INTO users (username, email, display_name, password_hash, role, is_active, email_verified)
        VALUES ('admin', 'admin@example.com', 'Administrator', $1, 'admin', true, true)
        ON CONFLICT (username) DO NOTHING
        "#,
        bcrypt::hash(&admin_password, bcrypt::DEFAULT_COST)?
    )
    .execute(&pool)
    .await?;
    
    info!("Default admin user created - username: admin, password: admin123");
    info!("Please change the admin password after first login");
    
    Ok(())
}

// 服务层实现
// File: enterprise-blog/src/services.rs
use super::models::*;
use crate::database::DatabaseManager;
use sqlx::PgPool;
use tracing::{info, warn, error, instrument};

pub struct UserService {
    pool: PgPool,
}

impl UserService {
    pub fn new(pool: PgPool) -> Self {
        UserService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_user(&self, request: &RegisterRequest) -> Result<User, sqlx::Error> {
        let password_hash = bcrypt::hash(&request.password, bcrypt::DEFAULT_COST)?;
        
        let user = sqlx::query!(
            r#"
            INSERT INTO users (username, email, display_name, password_hash, role, is_active, email_verified)
            VALUES ($1, $2, $3, $4, 'subscriber', true, false)
            RETURNING *
            "#,
            request.username,
            request.email,
            request.display_name,
            password_hash
        )
        .fetch_one(&self.pool)
        .await?;
        
        Ok(User::from_row(&user)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_user_by_id(&self, user_id: &Uuid) -> Result<Option<User>, sqlx::Error> {
        let user = sqlx::query!(
            "SELECT * FROM users WHERE id = $1",
            user_id
        )
        .fetch_optional(&self.pool)
        .await?;
        
        Ok(user.map(|row| User::from_row(&row).unwrap()))
    }
    
    #[instrument(skip(self))]
    pub async fn authenticate_user(&self, username: &str, password: &str) -> Result<Option<User>, sqlx::Error> {
        if let Some(user) = sqlx::query!(
            "SELECT * FROM users WHERE username = $1 AND is_active = true",
            username
        )
        .fetch_optional(&self.pool)
        .await? {
            let user = User::from_row(&user).unwrap();
            if bcrypt::verify(password, &user.password_hash)? {
                Ok(Some(user))
            } else {
                Ok(None)
            }
        } else {
            Ok(None)
        }
    }
}

pub struct BlogService {
    pool: PgPool,
}

impl BlogService {
    pub fn new(pool: PgPool) -> Self {
        BlogService { pool }
    }
    
    #[instrument(skip(self))]
    pub async fn create_blog_post(&self, request: &CreateBlogRequest, author_id: Uuid) -> Result<BlogPost, sqlx::Error> {
        let slug = generate_slug(&request.title);
        
        let post = sqlx::query!(
            r#"
            INSERT INTO blog_posts (
                id, title, slug, content, excerpt, featured_image, author_id, category_id,
                status, is_featured, is_pinned, allow_comments, allow_ratings,
                seo_title, seo_description, published_at
            ) VALUES (
                gen_random_uuid(), $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15
            )
            RETURNING *
            "#,
            request.title,
            slug,
            request.content,
            request.excerpt,
            request.featured_image,
            author_id,
            request.category_id,
            request.status as BlogStatus,
            request.is_featured,
            request.is_pinned,
            request.allow_comments,
            request.allow_ratings,
            request.seo_title,
            request.seo_description,
            request.published_at
        )
        .fetch_one(&self.pool)
        .await?;
        
        Ok(BlogPost::from_row(&post)?)
    }
    
    #[instrument(skip(self))]
    pub async fn get_published_posts(&self, limit: i64, offset: i64) -> Result<Vec<BlogPost>, sqlx::Error> {
        let posts = sqlx::query!(
            r#"
            SELECT bp.*, u.display_name as author_name
            FROM blog_posts bp
            JOIN users u ON bp.author_id = u.id
            WHERE bp.status = 'published'
            ORDER BY bp.is_pinned DESC, bp.published_at DESC
            LIMIT $1 OFFSET $2
            "#,
            limit,
            offset
        )
        .fetch_all(&self.pool)
        .await?;
        
        Ok(posts.into_iter().map(|row| BlogPost::from_row(&row).unwrap()).collect())
    }
    
    #[instrument(skip(self))]
    pub async fn increment_view_count(&self, post_id: &Uuid) -> Result<(), sqlx::Error> {
        sqlx::query!(
            "UPDATE blog_posts SET view_count = view_count + 1 WHERE id = $1",
            post_id
        )
        .execute(&self.pool)
        .await?;
        
        Ok(())
    }
}

// 辅助函数
fn generate_slug(title: &str) -> String {
    title.to_lowercase()
        .chars()
        .map(|c| match c {
            'a'..='z' | '0'..='9' => c,
            ' ' | '-' | '_' => '-',
            _ => '',
        })
        .collect::<String>()
        .trim_matches('-')
        .to_string()
}

// Web服务器
// File: enterprise-blog/src/web.rs
use super::services::*;
use super::models::*;
use axum::{
    extract::{Path, State},
    response::Json,
    routing::{get, post, put, delete},
    Router,
};
use tower::ServiceBuilder;
use tower_http::{trace::TraceLayer, cors::CorsLayer};
use std::sync::Arc;

pub struct WebServer {
    app: Router,
    addr: String,
}

impl WebServer {
    pub fn new(
        addr: String,
        user_service: Arc<UserService>,
        blog_service: Arc<BlogService>,
        auth_service: Arc<AuthService>,
        media_service: Arc<MediaService>,
        analytics_service: Arc<AnalyticsService>,
    ) -> Self {
        let app = Router::new()
            .route("/", get(home_handler))
            .route("/health", get(health_check))
            
            // 公开API
            .route("/api/v1/posts", get(get_posts).post(create_post))
            .route("/api/v1/posts/:id", get(get_post))
            .route("/api/v1/categories", get(get_categories))
            .route("/api/v1/tags", get(get_tags))
            .route("/api/v1/search", get(search_posts))
            
            // 用户API
            .route("/api/v1/auth/register", post(register_user))
            .route("/api/v1/auth/login", post(login_user))
            .route("/api/v1/auth/logout", post(logout_user))
            
            // 管理API
            .route("/api/v1/admin/posts", get(admin_list_posts))
            .route("/api/v1/admin/users", get(admin_list_users))
            
            .with_state(AppState {
                user_service,
                blog_service,
                auth_service,
                media_service,
                analytics_service,
            })
            .layer(
                ServiceBuilder::new()
                    .layer(TraceLayer::new_for_http())
                    .layer(CorsLayer::permissive())
            );
        
        WebServer { app, addr }
    }
    
    pub async fn run(self) -> Result<(), Box<dyn std::error::Error>> {
        let listener = tokio::net::TcpListener::bind(&self.addr).await?;
        println!("Enterprise Blog server listening on {}", self.addr);
        
        axum::serve(listener, self.app).await?;
        Ok(())
    }
}

#[derive(Clone)]
struct AppState {
    user_service: Arc<UserService>,
    blog_service: Arc<BlogService>,
    auth_service: Arc<AuthService>,
    media_service: Arc<MediaService>,
    analytics_service: Arc<AnalyticsService>,
}

// 处理器实现
async fn home_handler() -> &'static str {
    "Enterprise Blog System"
}

async fn health_check(State(state): State<AppState>) -> impl IntoResponse {
    let db_healthy = sqlx::query("SELECT 1").fetch_one(&state.user_service.pool).await.is_ok();
    Json(serde_json::json!({
        "status": "healthy",
        "database": db_healthy,
    }))
}

async fn get_posts(State(state): State<AppState>) -> impl IntoResponse {
    match state.blog_service.get_published_posts(20, 0).await {
        Ok(posts) => Json(serde_json::json!({
            "posts": posts,
            "total": posts.len() as i64,
        })),
        Err(_) => Json(serde_json::json!({
            "error": "Failed to fetch posts"
        })),
    }
}

async fn create_post(
    State(state): State<AppState>,
    Json(request): Json<CreateBlogRequest>,
) -> impl IntoResponse {
    // 从认证中获取用户ID
    let author_id = Uuid::new_v4(); // 简化实现
    
    match state.blog_service.create_blog_post(&request, author_id).await {
        Ok(post) => Json(serde_json::json!({
            "success": true,
            "post": post,
        })),
        Err(e) => Json(serde_json::json!({
            "success": false,
            "error": e.to_string(),
        })),
    }
}

async fn get_post(
    State(state): State<AppState>,
    Path(id): Path<Uuid>,
) -> impl IntoResponse {
    // 增加浏览量
    let _ = state.blog_service.increment_view_count(&id).await;
    
    // 获取文章详情
    // 简化实现
    Json(serde_json::json!({
        "id": id,
        "title": "Sample Post",
        "content": "This is a sample blog post content.",
    }))
}

// 其他处理器...

#![allow(unused)]
fn main() {
// 完整的API处理器实现
// File: enterprise-blog/src/handlers.rs
use super::web::AppState;
use super::models::*;
use axum::{
    extract::{Path, State, Form, Extension, Multipart},
    response::{Json, Html, Redirect},
    http::StatusCode,
};
use sqlx::PgPool;
use std::sync::Arc;
use tracing::{info, warn, error, instrument};

// 用户认证处理器
#[instrument(skip(state))]
pub async fn register_user(
    State(state): State<AppState>,
    Form(request): Form<RegisterRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    // 验证输入
    if request.username.is_empty() || request.email.is_empty() || request.password.is_empty() {
        return Err((StatusCode::BAD_REQUEST, "所有字段都是必需的".to_string()));
    }
    
    // 检查用户是否已存在
    if let Ok(Some(_)) = sqlx::query!(
        "SELECT id FROM users WHERE username = $1 OR email = $2",
        &request.username, &request.email
    )
    .fetch_optional(&state.user_service.pool)
    .await {
        return Err((StatusCode::CONFLICT, "用户名或邮箱已存在".to_string()));
    }
    
    // 创建用户
    match state.user_service.create_user(&request).await {
        Ok(user) => {
            info!("User registered successfully: {}", user.username);
            Ok(Json(serde_json::json!({
                "success": true,
                "message": "注册成功",
                "user_id": user.id,
            })))
        }
        Err(e) => {
            error!("Failed to register user: {}", e);
            Err((StatusCode::INTERNAL_SERVER_ERROR, "注册失败".to_string()))
        }
    }
}

#[instrument(skip(state))]
pub async fn login_user(
    State(state): State<AppState>,
    Json(request): Json<LoginRequest>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    // 验证用户
    if let Some(user) = state.user_service
        .authenticate_user(&request.username, &request.password)
        .await
        .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "数据库错误".to_string()))? {
        
        // 生成JWT token
        let user_info = UserInfo {
            id: user.id.to_string(),
            username: user.username.clone(),
            email: user.email.clone(),
            display_name: user.display_name.clone(),
            role: user.role.to_string(),
            avatar_url: user.avatar_url,
        };
        
        if let Ok((access_token, refresh_token)) = state.auth_service.generate_tokens(&user_info).await {
            Ok(Json(serde_json::json!({
                "success": true,
                "access_token": access_token,
                "refresh_token": refresh_token,
                "token_type": "Bearer",
                "expires_in": 900, // 15分钟
                "user": user_info,
            })))
        } else {
            Err((StatusCode::INTERNAL_SERVER_ERROR, "Token生成失败".to_string()))
        }
    } else {
        Err((StatusCode::UNAUTHORIZED, "用户名或密码错误".to_string()))
    }
}

// 博客文章处理器
#[instrument(skip(state))]
pub async fn get_post_by_slug(
    State(state): State<AppState>,
    Path(slug): Path<String>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    match sqlx::query!(
        r#"
        SELECT bp.*, u.display_name as author_name, u.username as author_username
        FROM blog_posts bp
        JOIN users u ON bp.author_id = u.id
        WHERE bp.slug = $1 AND bp.status = 'published'
        "#,
        &slug
    )
    .fetch_optional(&state.blog_service.pool)
    .await {
        Ok(Some(post)) => {
            // 增加浏览量
            let _ = sqlx::query!(
                "UPDATE blog_posts SET view_count = view_count + 1 WHERE id = $1",
                post.id
            )
            .execute(&state.blog_service.pool)
            .await;
            
            let blog_post = BlogPost::from_row(&post).unwrap();
            Ok(Json(serde_json::json!({
                "success": true,
                "post": blog_post,
            })))
        }
        Ok(None) => Err((StatusCode::NOT_FOUND, "文章不存在".to_string())),
        Err(e) => {
            error!("Database error: {}", e);
            Err((StatusCode::INTERNAL_SERVER_ERROR, "数据库错误".to_string()))
        }
    }
}

#[instrument(skip(state))]
pub async fn search_posts(
    State(state): State<AppState>,
    axum::extract::Query(params): axum::extract::Query<std::collections::HashMap<String, String>>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    let query = params.get("q").unwrap_or(&"".to_string()).to_string();
    let limit = params.get("limit").unwrap_or(&"20".to_string()).parse::<i64>().unwrap_or(20);
    let offset = params.get("offset").unwrap_or(&"0".to_string()).parse::<i64>().unwrap_or(0);
    
    if query.trim().is_empty() {
        return Err((StatusCode::BAD_REQUEST, "搜索关键词不能为空".to_string()));
    }
    
    match sqlx::query!(
        r#"
        SELECT bp.*, u.display_name as author_name
        FROM blog_posts bp
        JOIN users u ON bp.author_id = u.id
        WHERE bp.status = 'published' 
        AND (bp.title ILIKE $1 OR bp.content ILIKE $1 OR bp.excerpt ILIKE $1)
        ORDER BY bp.view_count DESC, bp.published_at DESC
        LIMIT $2 OFFSET $3
        "#,
        format!("%{}%", query),
        limit,
        offset
    )
    .fetch_all(&state.blog_service.pool)
    .await {
        Ok(posts) => {
            let posts: Vec<BlogPost> = posts.into_iter()
                .map(|row| BlogPost::from_row(&row).unwrap())
                .collect();
            
            Ok(Json(serde_json::json!({
                "success": true,
                "query": query,
                "posts": posts,
                "total": posts.len() as i64,
            })))
        }
        Err(e) => {
            error!("Search error: {}", e);
            Err((StatusCode::INTERNAL_SERVER_ERROR, "搜索失败".to_string()))
        }
    }
}

// 文件上传处理器
#[instrument(skip(state))]
pub async fn upload_file(
    State(state): State<AppState>,
    mut multipart: Multipart,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    use tokio::io::AsyncWriteExt;
    use std::path::PathBuf;
    use uuid::Uuid;
    
    let mut uploaded_files = Vec::new();
    
    while let Some(field) = multipart.next_field().await
        .map_err(|_| (StatusCode::BAD_REQUEST, "文件上传错误".to_string()))? {
        
        let file_name = field.file_name()
            .ok_or((StatusCode::BAD_REQUEST, "无效的文件名".to_string()))?
            .to_string();
        
        let data = field.bytes().await
            .map_err(|_| (StatusCode::BAD_REQUEST, "读取文件数据错误".to_string()))?;
        
        // 检查文件大小
        if data.len() > 10 * 1024 * 1024 { // 10MB
            return Err((StatusCode::BAD_REQUEST, "文件大小超过限制".to_string()));
        }
        
        // 生成唯一文件名
        let file_ext = Path::new(&file_name)
            .extension()
            .and_then(|s| s.to_str())
            .unwrap_or("");
        
        let unique_name = format!("{}.{}", Uuid::new_v4(), file_ext);
        let file_path = PathBuf::from("uploads").join(&unique_name);
        
        // 创建上传目录
        if let Some(parent) = file_path.parent() {
            tokio::fs::create_dir_all(parent)
                .await
                .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "创建目录失败".to_string()))?;
        }
        
        // 保存文件
        let mut file = tokio::fs::File::create(&file_path)
            .await
            .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "创建文件失败".to_string()))?;
        
        file.write_all(&data)
            .await
            .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "写入文件失败".to_string()))?;
        
        uploaded_files.push(serde_json::json!({
            "original_name": file_name,
            "saved_as": unique_name,
            "size": data.len(),
            "path": file_path.to_string_lossy(),
        }));
    }
    
    Ok(Json(serde_json::json!({
        "success": true,
        "message": "文件上传成功",
        "files": uploaded_files,
    })))
}

// 管理API处理器
#[instrument(skip(state))]
pub async fn admin_dashboard(
    State(state): State<AppState>,
    Extension(user): Extension<AuthenticatedUser>,
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
    // 检查管理员权限
    if user.role() != "admin" {
        return Err((StatusCode::FORBIDDEN, "需要管理员权限".to_string()));
    }
    
    // 获取统计信息
    let (total_users, total_posts, total_comments) = sqlx::query!(
        r#"
        SELECT 
            (SELECT COUNT(*) FROM users) as total_users,
            (SELECT COUNT(*) FROM blog_posts) as total_posts,
            (SELECT COUNT(*) FROM comments) as total_comments
        "#,
    )
    .fetch_one(&state.user_service.pool)
    .await
    .map_err(|_| (StatusCode::INTERNAL_SERVER_ERROR, "获取统计信息失败".to_string()))?;
    
    Ok(Json(serde_json::json!({
        "success": true,
        "stats": {
            "total_users": total_users.unwrap_or(0),
            "total_posts": total_posts.unwrap_or(0),
            "total_comments": total_comments.unwrap_or(0),
        }
    })))
}

// 缺失的处理器桩实现
pub async fn list_users() -> impl IntoResponse {
    todo!()
}

pub async fn create_user() -> impl IntoResponse {
    todo!()
}

pub async fn get_user() -> impl IntoResponse {
    todo!()
}

pub async fn update_user() -> impl IntoResponse {
    todo!()
}

pub async fn delete_user() -> impl IntoResponse {
    todo!()
}

pub async fn logout() -> impl IntoResponse {
    todo!()
}

pub async fn refresh_token() -> impl IntoResponse {
    todo!()
}

pub async fn list_blogs() -> impl IntoResponse {
    todo!()
}

pub async fn get_blog() -> impl IntoResponse {
    todo!()
}

pub async fn update_blog() -> impl IntoResponse {
    todo!()
}

pub async fn delete_blog() -> impl IntoResponse {
    todo!()
}

pub async fn list_comments() -> impl IntoResponse {
    todo!()
}

pub async fn create_comment() -> impl IntoResponse {
    todo!()
}

pub async fn like_blog() -> impl IntoResponse {
    todo!()
}

pub async fn share_blog() -> impl IntoResponse {
    todo!()
}

pub async fn list_categories() -> impl IntoResponse {
    todo!()
}

pub async fn create_category() -> impl IntoResponse {
    todo!()
}

pub async fn list_tags() -> impl IntoResponse {
    todo!()
}

pub async fn create_tag() -> impl IntoResponse {
    todo!()
}

pub async fn search() -> impl IntoResponse {
    todo!()
}

pub async fn admin_dashboard_data() -> impl IntoResponse {
    todo!()
}

pub async fn admin_list_users_data() -> impl IntoResponse {
    todo!()
}

pub async fn admin_list_blogs_data() -> impl IntoResponse {
    todo!()
}

pub async fn admin_list_comments_data() -> impl IntoResponse {
    todo!()
}

pub async fn upload_file_handler() -> impl IntoResponse {
    todo!()
}

pub async fn download_file() -> impl IntoResponse {
    todo!()
}

pub async fn delete_file() -> impl IntoResponse {
    todo!()
}

pub async fn serve_static() -> impl IntoResponse {
    todo!()
}

pub async fn get_categories() -> impl IntoResponse {
    todo!()
}

pub async fn get_tags() -> impl IntoResponse {
    todo!()
}

pub async fn search_posts_api() -> impl IntoResponse {
    todo!()
}

pub async fn register_user_api() -> impl IntoResponse {
    todo!()
}

pub async fn login_user_api() -> impl IntoResponse {
    todo!()
}

pub async fn logout_user_api() -> impl IntoResponse {
    todo!()
}

pub async fn admin_list_posts_api() -> impl IntoResponse {
    todo!()
}

pub async fn admin_list_users_api() -> impl IntoResponse {
    todo!()
}
}

12.6 部署指南

12.6.1 Docker容器化部署

# File: enterprise-blog/Dockerfile
# 多阶段构建
FROM rust:1.70 as builder

WORKDIR /app

# 复制依赖文件
COPY Cargo.toml Cargo.lock ./

# 创建虚拟包来加速构建
RUN mkdir src && echo 'fn main() {}' > src/main.rs
RUN cargo build --release
RUN rm src/main.rs

# 复制源代码
COPY src ./src
COPY templates ./templates
COPY static ./static

# 构建应用
RUN cargo build --release

# 运行时阶段
FROM debian:bookworm-slim

# 安装运行时依赖
RUN apt-get update && apt-get install -y \
    ca-certificates \
    libssl3 \
    && rm -rf /var/lib/apt/lists/*

# 创建应用用户
RUN useradd -r -s /bin/false blog

# 设置工作目录
WORKDIR /app

# 复制二进制文件
COPY --from=builder /app/target/release/enterprise-blog ./

# 创建必要目录
RUN mkdir -p uploads logs && \
    chown -R blog:blog /app

# 切换到非root用户
USER blog

# 暴露端口
EXPOSE 3000

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:3000/health || exit 1

# 启动应用
CMD ["./enterprise-blog", "server", "--addr=0.0.0.0:3000"]

# File: enterprise-blog/docker-compose.yml
version: '3.8'

services:
  # PostgreSQL数据库
  postgres:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: enterprise_blog
      POSTGRES_USER: blog_user
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-password}
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init-scripts:/docker-entrypoint-initdb.d
    ports:
      - "5432:5432"
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U blog_user -d enterprise_blog"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Redis缓存
  redis:
    image: redis:7-alpine
    command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD:-redis123}
    volumes:
      - redis_data:/data
    ports:
      - "6379:6379"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 企业级博客应用
  blog-app:
    build:
      context: .
      dockerfile: Dockerfile
    environment:
      DATABASE_URL: postgres://blog_user:${POSTGRES_PASSWORD:-password}@postgres:5432/enterprise_blog
      REDIS_URL: redis://:${REDIS_PASSWORD:-redis123}@redis:6379
      JWT_SECRET: ${JWT_SECRET:-your-jwt-secret-change-this}
      UPLOAD_DIR: /app/uploads
      MAX_UPLOAD_SIZE: 10485760
      LOG_LEVEL: info
    volumes:
      - uploads_data:/app/uploads
      - logs_data:/app/logs
    ports:
      - "3000:3000"
    depends_on:
      postgres:
        condition: service_healthy
      redis:
        condition: service_healthy
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Nginx反向代理
  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
      - static_files:/var/www/static
    depends_on:
      - blog-app
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # 文件存储（MinIO）
  minio:
    image: minio/minio:latest
    environment:
      MINIO_ROOT_USER: ${MINIO_USER:-minioadmin}
      MINIO_ROOT_PASSWORD: ${MINIO_PASSWORD:-minioadmin123}
    command: server /data --console-address ":9001"
    volumes:
      - minio_data:/data
    ports:
      - "9000:9000"
      - "9001:9001"
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"]
      interval: 30s
      timeout: 20s
      retries: 3

  # 监控 - Prometheus
  prometheus:
    image: prom/prometheus:latest
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    ports:
      - "9090:9090"
    restart: unless-stopped

  # 监控 - Grafana
  grafana:
    image: grafana/grafana:latest
    environment:
      GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD:-admin123}
    volumes:
      - grafana_data:/var/lib/grafana
volumes:
  postgres_data:
  redis_data:
  uploads_data:
  logs_data:
  minio_data:
  static_files:
  prometheus_data:
  grafana_data:

networks:
  default:
    driver: bridge

12.6.2 Kubernetes部署

# File: enterprise-blog/k8s/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: enterprise-blog

# File: enterprise-blog/k8s/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: blog-config
  namespace: enterprise-blog
data:
  DATABASE_URL: "postgresql://blog_user:password@postgres-service:5432/enterprise_blog"
  REDIS_URL: "redis://redis-service:6379"
  JWT_SECRET: "your-jwt-secret-change-in-production"
  UPLOAD_DIR: "/app/uploads"
  MAX_UPLOAD_SIZE: "10485760"
  LOG_LEVEL: "info"

# File: enterprise-blog/k8s/secrets.yaml
apiVersion: v1
kind: Secret
metadata:
  name: blog-secrets
  namespace: enterprise-blog
type: Opaque
data:
  postgres-password: cGFzc3dvcmQ=  # base64编码的password
  redis-password: cmVkaXMxMjM=     # base64编码的redis123
  jwt-secret: eW91ci1qd3Qtc2VjcmV0LWNoYW5nZS10aGlz  # base64编码的your-jwt-secret-change-this

# File: enterprise-blog/k8s/postgres-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: enterprise-blog
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:15-alpine
        env:
        - name: POSTGRES_DB
          value: enterprise_blog
        - name: POSTGRES_USER
          value: blog_user
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: blog-secrets
              key: postgres-password
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: postgres-storage
          mountPath: /var/lib/postgresql/data
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
        livenessProbe:
          exec:
            command:
            - pg_isready
            - -U
            - blog_user
            - -d
            - enterprise_blog
          initialDelaySeconds: 30
          periodSeconds: 10
      volumes:
      - name: postgres-storage
        persistentVolumeClaim:
          claimName: postgres-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: postgres-service
  namespace: enterprise-blog
spec:
  selector:
    app: postgres
  ports:
  - protocol: TCP
    port: 5432
    targetPort: 5432
  type: ClusterIP
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
  namespace: enterprise-blog
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 20Gi

# File: enterprise-blog/k8s/redis-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
  namespace: enterprise-blog
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:7-alpine
        command:
        - redis-server
        - --requirepass
        - $(REDIS_PASSWORD)
        env:
        - name: REDIS_PASSWORD
          valueFrom:
            secretKeyRef:
              name: blog-secrets
              key: redis-password
        ports:
        - containerPort: 6379
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          exec:
            command:
            - redis-cli
            - ping
          initialDelaySeconds: 30
          periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: redis-service
  namespace: enterprise-blog
spec:
  selector:
    app: redis
  ports:
  - protocol: TCP
    port: 6379
    targetPort: 6379
  type: ClusterIP

# File: enterprise-blog/k8s/blog-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: blog-app
  namespace: enterprise-blog
spec:
  replicas: 3
  selector:
    matchLabels:
      app: blog-app
  template:
    metadata:
      labels:
        app: blog-app
    spec:
      containers:
      - name: blog-app
        image: enterprise-blog:latest
        imagePullPolicy: Never  # 对于本地开发
        env:
        - name: DATABASE_URL
          valueFrom:
            configMapKeyRef:
              name: blog-config
              key: DATABASE_URL
        - name: REDIS_URL
          valueFrom:
            configMapKeyRef:
              name: blog-config
              key: REDIS_URL
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: blog-secrets
              key: jwt-secret
        - name: UPLOAD_DIR
          valueFrom:
            configMapKeyRef:
              name: blog-config
              key: UPLOAD_DIR
        - name: MAX_UPLOAD_SIZE
          valueFrom:
            configMapKeyRef:
              name: blog-config
              key: MAX_UPLOAD_SIZE
        ports:
        - containerPort: 3000
        volumeMounts:
        - name: uploads-storage
          mountPath: /app/uploads
        - name: logs-storage
          mountPath: /app/logs
        resources:
          requests:
            memory: "512Mi"
            cpu: "250m"
          limits:
            memory: "1Gi"
            cpu: "500m"
        livenessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 3000
          initialDelaySeconds: 5
          periodSeconds: 5
      volumes:
      - name: uploads-storage
        persistentVolumeClaim:
          claimName: uploads-pvc
      - name: logs-storage
        persistentVolumeClaim:
          claimName: logs-pvc
---
apiVersion: v1
kind: Service
metadata:
  name: blog-service
  namespace: enterprise-blog
spec:
  selector:
    app: blog-app
  ports:
  - protocol: TCP
    port: 80
    targetPort: 3000
  type: ClusterIP
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: blog-ingress
  namespace: enterprise-blog
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
spec:
  tls:
  - hosts:
    - your-domain.com
    secretName: blog-tls
  rules:
  - host: your-domain.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: blog-service
            port:
              number: 80

# File: enterprise-blog/k8s/pvc.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: uploads-pvc
  namespace: enterprise-blog
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 10Gi
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: logs-pvc
  namespace: enterprise-blog
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 5Gi

12.6.3 CI/CD部署流水线

# File: enterprise-blog/.github/workflows/deploy.yml
name: Deploy Enterprise Blog

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

env:
  CARGO_TERM_COLOR: always
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  test:
    runs-on: ubuntu-latest
    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_PASSWORD: password
          POSTGRES_USER: blog_user
          POSTGRES_DB: enterprise_blog_test
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 5432:5432
      redis:
        image: redis:7
        options: >-
          --health-cmd "redis-cli ping"
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5
        ports:
          - 6379:6379

    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust
      uses: dtolnay/rust-toolchain@stable
      with:
        components: clippy, rustfmt
    
    - name: Cache cargo registry
      uses: actions/cache@v3
      with:
        path: ~/.cargo/registry
        key: ${{ runner.os }}-cargo-registry-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Cache cargo index
      uses: actions/cache@v3
      with:
        path: ~/.cargo/git
        key: ${{ runner.os }}-cargo-index-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Cache cargo build
      uses: actions/cache@v3
      with:
        path: target
        key: ${{ runner.os }}-cargo-build-target-${{ hashFiles('**/Cargo.lock') }}
    
    - name: Run tests
      run: cargo test
      env:
        DATABASE_URL: postgres://blog_user:password@localhost:5432/enterprise_blog_test
        REDIS_URL: redis://localhost:6379
    
    - name: Run clippy
      run: cargo clippy --all-targets --all-features -- -D warnings
    
    - name: Run rustfmt
      run: cargo fmt -- --check

  security:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust
      uses: dtolnay/rust-toolchain@stable
    
    - name: Install cargo-audit
      run: cargo install cargo-audit
    
    - name: Run cargo audit
      run: cargo audit

  build:
    needs: [test, security]
    runs-on: ubuntu-latest
    outputs:
      image: ${{ steps.image.outputs.image }}
      digest: ${{ steps.build.outputs.digest }}
    
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3
    
    - name: Log in to Container Registry
      uses: docker/login-action@v3
      with:
        registry: ${{ env.REGISTRY }}
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
    
    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v5
      with:
        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
        tags: |
          type=ref,event=branch
          type=ref,event=pr
          type=sha,prefix={{branch}}-
          type=raw,value=latest,enable={{is_default_branch}}
    
    - name: Build and push Docker image
      id: build
      uses: docker/build-push-action@v5
      with:
        context: .
        file: ./Dockerfile
        push: true
        tags: ${{ steps.meta.outputs.tags }}
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production
    
    steps:
    - name: Deploy to production
      run: |
        echo "Deploying to production..."
        # 这里可以添加部署脚本，比如 kubectl apply, docker-compose up 等
        
  notify:
    needs: [build, deploy]
    runs-on: ubuntu-latest
    if: always()
    
    steps:
    - name: Notify deployment status
      if: failure()
      run: |
        echo "Deployment failed! Please check the logs."
        # 这里可以添加通知逻辑，比如发送邮件、Slack消息等

12.6.4 生产环境配置

# File: enterprise-blog/Cargo.toml
[package]
name = "enterprise-blog"
version = "1.0.0"
edition = "2021"
authors = ["MiniMax Agent <developer@minimax.com>"]
description = "Enterprise-grade blog system built with Rust"
license = "MIT"
repository = "https://github.com/your-org/enterprise-blog"
keywords = ["blog", "cms", "rust", "web", "enterprise"]

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
panic = "abort"
strip = true

[profile.production]
inherits = "release"
opt-level = 3
lto = "fat"
codegen-units = 1
panic = "abort"
strip = true

[[bin]]
name = "enterprise-blog"
path = "src/main.rs"

[features]
default = []
production = ["cli", "metrics", "opentelemetry"]
cli = ["clap"]
metrics = ["prometheus-client"]
opentelemetry = ["opentelemetry", "opentelemetry-jaeger", "opentelemetry-http"]

[dependencies]
tokio = { version = "1.35", features = ["full", "tracing"] }
axum = { version = "0.7", features = ["macros", "ws"] }
tower = { version = "0.4" }
tower-http = { version = "0.5", features = ["cors", "compression", "trace", "timeout", "request-id"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "uuid", "chrono", "migrate"] }
redis = { version = "0.24", features = ["tokio-comp", "connection-manager"] }
bcrypt = "0.15"
jsonwebtoken = "9.2"
clap = { version = "4.4", features = ["derive", "cargo"], optional = true }
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter", "fmt", "json"] }
anyhow = "1.0"
thiserror = "1.0"
regex = "1.10"
markdown = "1.0"
html-escape = "0.4"
mime = "0.4"
uuid = { version = "1.6", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
dotenvy = "0.15"
owo-colors = "4.0"
urlencoding = "2.1"
prometheus-client = { version = "0.21", optional = true }
opentelemetry = { version = "0.20", optional = true }
opentelemetry-jaeger = { version = "0.17", optional = true }
opentelemetry-http = { version = "0.10", optional = true }

[dev-dependencies]
tempfile = "3.8"
wiremock = "0.5"
fake = "0.2"

// File: enterprise-blog/src/main.rs
use clap::{Parser, Subcommand, ValueEnum};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
use std::sync::Arc;
use tokio::sync::RwLock;

mod models;
mod services;
mod web;
mod config;
mod database;

use models::*;
use services::*;
use web::WebServer;
use config::Config;
use database::DatabaseManager;

#[cfg(feature = "cli")]
use clap::Parser;

#[cfg(feature = "metrics")]
use prometheus_client::registry::Registry;
#[cfg(feature = "opentelemetry")]
use opentelemetry::{global, sdk::trace::TracerProvider};
#[cfg(feature = "opentelemetry")]
use opentelemetry_jaeger::JaegerLayer;

#[cfg_attr(feature = "cli", derive(Parser))]
#[cfg_attr(feature = "cli", command(name = "enterprise-blog"))]
#[cfg_attr(feature = "cli", command(about = "Enterprise Blog System"))]
struct Cli {
    #[cfg_attr(feature = "cli", command(subcommand))]
    command: Commands,
}

#[cfg_attr(feature = "cli", derive(Subcommand))]
#[cfg_attr(feature = "cli", command())
enum Commands {
    /// Start the web server
    Server {
        #[arg(short, long, default_value = "0.0.0.0:3000")]
        addr: String,
    },
    /// Run database migrations
    Migrate,
    /// Setup database and run migrations
    Setup,
    /// Generate documentation
    Docs,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化配置
    let config = Config::from_env()?;
    
    // 初始化日志
    init_tracing(&config)?;
    
    #[cfg(feature = "metrics")]
    let registry = Registry::default();
    
    #[cfg(feature = "opentelemetry")]
    let tracer = init_opentelemetry()?;
    
    info!("Starting Enterprise Blog System v{}", env!("CARGO_PKG_VERSION"));
    
    #[cfg_attr(feature = "cli", allow(unused_variables))]
    let cli = Cli::parse();
    
    #[cfg_attr(feature = "cli", if let Some(command) = cli.command {} else )]
    // 默认命令
    run_server(config).await
}

#[cfg_attr(feature = "cli", allow(dead_code))]
async fn run_server(config: Config) -> Result<(), Box<dyn std::error::Error>> {
    info!("Initializing services...");
    
    // 初始化数据库
    let db_manager = DatabaseManager::new(&config.database_url).await?;
    let db_pool = db_manager.get_pool();
    
    // 初始化Redis
    let redis_client = redis::Client::open(&config.redis_url)?;
    
    // 初始化服务
    let user_service = Arc::new(UserService::new(db_pool.clone()));
    let blog_service = Arc::new(BlogService::new(db_pool.clone()));
    let auth_service = Arc::new(AuthService::new(db_pool.clone(), redis_client.clone(), &config.jwt_secret));
    let media_service = Arc::new(MediaService::new(db_pool.clone(), &config.upload_dir));
    let analytics_service = Arc::new(AnalyticsService::new(db_pool.clone()));
    
    // 初始化Web服务器
    let server = WebServer::new(
        config.addr,
        user_service,
        blog_service,
        auth_service,
        media_service,
        analytics_service,
        config,
    );
    
    info!("Starting server on {}", config.addr);
    server.run().await?;
    
    Ok(())
}

fn init_tracing(config: &Config) -> Result<(), Box<dyn std::error::Error>> {
    let filter = EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| format!("enterprise_blog={},tokio=warn,sqlx=warn", config.log_level).into());
    
    let subscriber = tracing_subscriber::registry()
        .with(filter)
        .with(tracing_subscriber::fmt::layer()
            .with_target(false)
            .with_thread_ids(true)
            .with_level(true)
        );
    
    #[cfg(feature = "opentelemetry")]
    let subscriber = subscriber.with(JaegerLayer::new());
    
    subscriber.init();
    
    Ok(())
}

#[cfg(feature = "opentelemetry")]
fn init_opentelemetry() -> Result<TracerProvider, Box<dyn std::error::Error>> {
    global::set_text_map_propagator(opentelemetry_jaeger::JaegerPropagator::new());
    
    let tracer = TracerProvider::builder()
        .with_simple_exporter(opentelemetry_jaeger::AgentPipeline::default())
        .build();
    
    global::set_tracer_provider(tracer.clone());
    
    Ok(tracer)
}

12.7 性能优化

12.7.1 数据库优化

#![allow(unused)]
fn main() {
// 数据库查询优化
impl BlogService {
    // 使用索引优化查询
    #[instrument(skip(self))]
    pub async fn get_blogs_with_pagination(
        &self,
        page: i64,
        per_page: i64,
        category: Option<&str>,
        tag: Option<&str>,
    ) -> Result<(Vec<BlogPost>, i64), sqlx::Error> {
        let offset = (page - 1) * per_page;
        
        let mut query = r#"
            SELECT bp.*, u.display_name as author_name, 
                   c.name as category_name,
                   ARRAY_AGG(DISTINCT t.name) as tag_names
            FROM blog_posts bp
            JOIN users u ON bp.author_id = u.id
            LEFT JOIN categories c ON bp.category_id = c.id
            LEFT JOIN blog_post_tags bpt ON bp.id = bpt.post_id
            LEFT JOIN tags t ON bpt.tag_id = t.id
            WHERE bp.status = 'published'
        "#.to_string();
        
        let mut params: Vec<String> = Vec::new();
        
        if let Some(category) = category {
            query.push_str(" AND c.slug = $1");
            params.push(category.to_string());
        }
        
        if let Some(tag) = tag {
            query.push_str(" AND EXISTS (SELECT 1 FROM blog_post_tags bpt2 WHERE bpt2.post_id = bp.id AND bpt2.tag_id = (SELECT id FROM tags WHERE slug = $2))");
            params.push(tag.to_string());
        }
        
        query.push_str(" GROUP BY bp.id, u.display_name, c.name ORDER BY bp.is_pinned DESC, bp.published_at DESC LIMIT $");
        query.push_str(&format!("{} OFFSET ${}", per_page + 1, per_page + 2));
        params.extend(vec![per_page.to_string(), offset.to_string()]);
        
        let posts = sqlx::query(&query)
            .fetch_all(&self.pool)
            .await?;
        
        // 获取总数
        let count_query = "SELECT COUNT(DISTINCT bp.id) FROM blog_posts bp WHERE bp.status = 'published'";
        let total: i64 = sqlx::query_scalar(count_query)
            .fetch_one(&self.pool)
            .await?;
        
        Ok((posts.into_iter().map(|row| BlogPost::from_row(&row).unwrap()).collect(), total))
    }
    
    // 批量操作优化
    #[instrument(skip(self))]
    pub async fn batch_update_view_counts(&self, post_ids: Vec<Uuid>) -> Result<(), sqlx::Error> {
        if post_ids.is_empty() {
            return Ok(());
        }
        
        // 使用批量更新而不是多次单条更新
        let placeholders: String = post_ids.iter()
            .enumerate()
            .map(|(i, _)| format!("${}", i + 1))
            .collect::<Vec<_>>()
            .join(", ");
        
        let query = format!(
            "UPDATE blog_posts SET view_count = view_count + 1 WHERE id IN ({})",
            placeholders
        );
        
        // 构建参数数组
        let mut query_builder = sqlx::query(&query);
        for post_id in post_ids {
            query_builder = query_builder.bind(post_id);
        }
        
        query_builder.execute(&self.pool).await?;
        Ok(())
    }
    
    // 使用缓存优化
    #[instrument(skip(self))]
    pub async fn get_cached_blog_post(&self, redis_client: &redis::Client, post_id: &Uuid) -> Result<Option<BlogPost>, sqlx::Error> {
        let mut conn = redis_client.get_connection()?;
        let cache_key = format!("blog:post:{}", post_id);
        
        // 首先尝试从缓存获取
        if let Some(cached_data) = redis::cmd("GET")
            .arg(&cache_key)
            .query::<Option<String>>(&mut conn)? {
            
            let cached_post: BlogPost = serde_json::from_str(&cached_data)
                .map_err(|e| sqlx::Error::Protocol(format!("Failed to deserialize cached post: {}", e)))?;
            return Ok(Some(cached_post));
        }
        
        // 缓存未命中，从数据库获取
        if let Some(post) = self.get_blog_post_by_id(post_id).await? {
            // 存入缓存
            let post_json = serde_json::to_string(&post)
                .map_err(|e| sqlx::Error::Protocol(format!("Failed to serialize post: {}", e)))?;
            
            let _ = redis::cmd("SETEX")
                .arg(&cache_key)
                .arg(3600) // 1小时过期
                .arg(&post_json)
                .query::<()>(&mut conn);
            
            Ok(Some(post))
        } else {
            Ok(None)
        }
    }
}

// 连接池优化
pub struct DatabaseManager {
    pool: sqlx::PgPool,
}

impl DatabaseManager {
    pub async fn new(database_url: &str) -> Result<Self, sqlx::Error> {
        let pool = sqlx::PgPoolOptions::new()
            .max_connections(20) // 根据负载调整
            .min_connections(5)
            .acquire_timeout(Duration::from_secs(30))
            .connect_timeout(Duration::from_secs(10))
            .idle_timeout(Duration::from_secs(600))
            .max_lifetime(Duration::from_secs(1800))
            .test_before_acquire(true)
            .connect(database_url)
            .await?;
        
        Ok(DatabaseManager { pool })
    }
    
    pub fn get_pool(&self) -> sqlx::PgPool {
        self.pool.clone()
    }
}
}

12.7.2 缓存策略

#![allow(unused)]
fn main() {
// 缓存服务实现
pub struct CacheService {
    redis_client: redis::Client,
    default_ttl: u32,
    namespace: String,
}

impl CacheService {
    pub fn new(redis_client: redis::Client, default_ttl: u32, namespace: String) -> Self {
        CacheService {
            redis_client,
            default_ttl,
            namespace,
        }
    }
    
    fn namespaced_key(&self, key: &str) -> String {
        format!("{}:{}", self.namespace, key)
    }
    
    // 博客文章缓存
    pub async fn cache_blog_post(&self, post: &BlogPost) -> Result<(), redis::RedisError> {
        let key = self.namespaced_key(&format!("blog:post:{}", post.id));
        let data = serde_json::to_string(post)?;
        
        let mut conn = self.redis_client.get_connection()?;
        redis::cmd("SETEX")
            .arg(&key)
            .arg(self.default_ttl)
            .arg(&data)
            .query(&mut conn)
    }
    
    pub async fn get_cached_blog_post(&self, post_id: &Uuid) -> Result<Option<BlogPost>, redis::RedisError> {
        let key = self.namespaced_key(&format!("blog:post:{}", post_id));
        let mut conn = self.redis_client.get_connection()?;
        
        if let Some(data) = redis::cmd("GET").arg(&key).query::<Option<String>>(&mut conn)? {
            let post: BlogPost = serde_json::from_str(&data)?;
            Ok(Some(post))
        } else {
            Ok(None)
        }
    }
    
    // 博客列表缓存
    pub async fn cache_blog_list(&self, key_suffix: &str, posts: &[BlogPost]) -> Result<(), redis::RedisError> {
        let key = self.namespaced_key(&format!("blog:list:{}", key_suffix));
        let data = serde_json::to_string(posts)?;
        
        let mut conn = self.redis_client.get_connection()?;
        redis::cmd("SETEX")
            .arg(&key)
            .arg(self.default_ttl)
            .arg(&data)
            .query(&mut conn)
    }
    
    // 分页缓存
    pub async fn get_cached_blog_page(&self, page: i64, per_page: i64, filters: &str) -> Result<Option<Vec<BlogPost>>, redis::RedisError> {
        let key = self.namespaced_key(&format!("blog:page:{}:{}:{}", page, per_page, filters));
        let mut conn = self.redis_client.get_connection()?;
        
        if let Some(data) = redis::cmd("GET").arg(&key).query::<Option<String>>(&mut conn)? {
            let posts: Vec<BlogPost> = serde_json::from_str(&data)?;
            Ok(Some(posts))
        } else {
            Ok(None)
        }
    }
    
    // 用户会话缓存
    pub async fn cache_user_session(&self, user_id: &Uuid, session_data: &UserSession) -> Result<(), redis::RedisError> {
        let key = self.namespaced_key(&format!("user:session:{}", user_id));
        let data = serde_json::to_string(session_data)?;
        
        let mut conn = self.redis_client.get_connection()?;
        redis::cmd("SETEX")
            .arg(&key)
            .arg(86400) // 24小时
            .arg(&data)
            .query(&mut conn)
    }
    
    // 缓存失效策略
    pub async fn invalidate_user_cache(&self, user_id: &Uuid) -> Result<(), redis::RedisError> {
        let mut conn = self.redis_client.get_connection()?;
        
        // 删除用户相关的所有缓存
        let patterns = vec![
            self.namespaced_key(&format!("user:session:{}", user_id)),
            self.namespaced_key(&format!("user:profile:{}", user_id)),
        ];
        
        for pattern in patterns {
            let _ = redis::cmd("DEL").arg(&pattern).query::<()>(&mut conn);
        }
        
        Ok(())
    }
    
    // 批量缓存操作
    pub async fn batch_cache_blog_posts(&self, posts: &[BlogPost]) -> Result<(), redis::RedisError> {
        let mut conn = self.redis_client.get_connection()?;
        let mut pipeline = redis::pipe();
        
        for post in posts {
            let key = self.namespaced_key(&format!("blog:post:{}", post.id));
            let data = serde_json::to_string(post)?;
            pipeline = pipeline.setex(key, self.default_ttl, data);
        }
        
        pipeline.query(&mut conn)
    }
}

// 会话数据结构
#[derive(Debug, Serialize, Deserialize)]
pub struct UserSession {
    pub user_id: Uuid,
    pub username: String,
    pub role: String,
    pub last_activity: DateTime<Utc>,
    pub ip_address: String,
    pub user_agent: String,
}
}

12.8 安全最佳实践

12.8.1 输入验证和防护

#![allow(unused)]
fn main() {
// 安全验证器
pub struct SecurityValidator;

impl SecurityValidator {
    // XSS防护
    pub fn sanitize_html(&self, input: &str) -> String {
        // 移除或转义潜在的XSS载荷
        input
            .replace("<script>", "&lt;script&gt;")
            .replace("</script>", "&lt;/script&gt;")
            .replace("<iframe>", "&lt;iframe&gt;")
            .replace("</iframe>", "&lt;/iframe&gt;")
            .replace("javascript:", "javascript_")
            .replace("onload=", "onload_")
            .replace("onerror=", "onerror_")
            .replace("onclick=", "onclick_")
    }
    
    // SQL注入防护
    pub fn validate_sql_safe(&self, input: &str) -> bool {
        // 检查是否包含SQL关键字
        let sql_keywords = ["SELECT", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER", "UNION", "SCRIPT"];
        let input_upper = input.to_uppercase();
        
        !sql_keywords.iter().any(|keyword| input_upper.contains(keyword))
    }
    
    // 文件上传安全
    pub fn validate_file_upload(&self, filename: &str, content_type: &str, size: usize) -> Result<(), SecurityError> {
        // 检查文件名
        if filename.contains("..") || filename.contains("/") || filename.contains("\\") {
            return Err(SecurityError::InvalidFilename);
        }
        
        // 检查文件扩展名
        let allowed_extensions = ["jpg", "jpeg", "png", "gif", "webp", "pdf", "doc", "docx"];
        let ext = Path::new(filename)
            .extension()
            .and_then(|s| s.to_str())
            .unwrap_or("")
            .to_lowercase();
        
        if !allowed_extensions.contains(&ext.as_str()) {
            return Err(SecurityError::InvalidFileType);
        }
        
        // 检查文件大小 (10MB限制)
        if size > 10 * 1024 * 1024 {
            return Err(SecurityError::FileTooLarge);
        }
        
        // 检查MIME类型
        let allowed_mime_types = [
            "image/jpeg", "image/png", "image/gif", "image/webp",
            "application/pdf", "application/msword",
            "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
        ];
        
        if !allowed_mime_types.contains(&content_type) {
            return Err(SecurityError::InvalidMimeType);
        }
        
        Ok(())
    }
    
    // CSRF防护
    pub fn validate_csrf_token(&self, session_token: &str, form_token: &str) -> bool {
        // 简单的时间窗口验证
        session_token == form_token
    }
    
    // 密码强度检查
    pub fn validate_password_strength(&self, password: &str) -> Result<(), ValidationError> {
        if password.len() < 8 {
            return Err(ValidationError::new("password", "密码长度至少8个字符"));
        }
        
        if !password.chars().any(|c| c.is_uppercase()) {
            return Err(ValidationError::new("password", "密码必须包含大写字母"));
        }
        
        if !password.chars().any(|c| c.is_lowercase()) {
            return Err(ValidationError::new("password", "密码必须包含小写字母"));
        }
        
        if !password.chars().any(|c| c.is_digit(10)) {
            return Err(ValidationError::new("password", "密码必须包含数字"));
        }
        
        if !password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c)) {
            return Err(ValidationError::new("password", "密码必须包含特殊字符"));
        }
        
        Ok(())
    }
}

#[derive(Debug, thiserror::Error)]
pub enum SecurityError {
    #[error("Invalid filename")]
    InvalidFilename,
    #[error("Invalid file type")]
    InvalidFileType,
    #[error("File too large")]
    FileTooLarge,
    #[error("Invalid MIME type")]
    InvalidMimeType,
    #[error("CSRF token validation failed")]
    InvalidCSRFToken,
    #[error("Rate limit exceeded")]
    RateLimitExceeded,
}
}

12.8.2 速率限制和防护

#![allow(unused)]
fn main() {
// 速率限制中间件
pub struct RateLimitConfig {
    pub requests_per_minute: u64,
    pub burst_size: u64,
    pub key_extractor: fn(&axum::http::Request<axum::body::Body>) -> String,
}

impl RateLimitConfig {
    pub fn by_ip() -> Self {
        RateLimitConfig {
            requests_per_minute: 100,
            burst_size: 20,
            key_extractor: extract_client_ip,
        }
    }
    
    pub fn by_user() -> Self {
        RateLimitConfig {
            requests_per_minute: 1000,
            burst_size: 100,
            key_extractor: extract_user_id_or_ip,
        }
    }
    
    pub fn by_endpoint() -> Self {
        RateLimitConfig {
            requests_per_minute: 50,
            burst_size: 10,
            key_extractor: extract_endpoint_key,
        }
    }
}

fn extract_client_ip(request: &axum::http::Request<axum::body::Body>) -> String {
    request.headers()
        .get("x-forwarded-for")
        .and_then(|h| h.to_str().ok())
        .or_else(|| request.headers().get("x-real-ip").and_then(|h| h.to_str().ok()))
        .unwrap_or("unknown")
        .to_string()
}

fn extract_user_id_or_ip(request: &axum::http::Request<axum::body::Body>) -> String {
    // 从JWT token中提取用户ID
    if let Some(auth_header) = request.headers().get("authorization") {
        if let Ok(token) = auth_header.to_str() {
            if token.starts_with("Bearer ") {
                let token_data = &token[7..];
                if let Ok(claims) = validate_jwt_token(token_data) {
                    return format!("user:{}", claims.sub);
                }
            }
        }
    }
    
    // 如果没有用户信息，使用IP
    extract_client_ip(request)
}

fn extract_endpoint_key(request: &axum::http::Request<axum::body::Body>) -> String {
    let method = request.method();
    let path = request.uri().path();
    format!("{}:{}", method, path)
}

impl axum::middleware::Middleware<(), State = AppState> for RateLimitConfig {
    type Future = Pin<Box<dyn Future<Output = Result<Response, (StatusCode, String)>> + Send>>;
    
    fn call(&self, request: Request, state: State<AppState>, next: Next) -> Self::Future {
        Box::pin(async move {
            let key = (self.key_extractor)(&request);
            let client_ip = extract_client_ip(&request);
            
            // 检查速率限制
            if let Some(violation) = check_rate_limit_violation(
                &state.redis_client,
                &key,
                self.requests_per_minute,
                self.burst_size,
            ).await {
                
                // 记录违规行为
                tracing::warn!(
                    "Rate limit exceeded for {} (key: {}, violations: {})",
                    client_ip, key, violation
                );
                
                return Err((StatusCode::TOO_MANY_REQUESTS, "Rate limit exceeded".to_string()));
            }
            
            next.run(request).await
        })
    }
}

async fn check_rate_limit_violation(
    redis_client: &redis::Client,
    key: &str,
    requests_per_minute: u64,
    burst_size: u64,
) -> Option<u32> {
    let mut conn = redis_client.get_connection().ok()?;
    
    let current_count: u32 = redis::cmd("GET")
        .arg(format!("rate_limit:{}", key))
        .query(&mut conn)
        .unwrap_or(0);
    
    if current_count >= requests_per_minute + burst_size {
        Some(current_count)
    } else {
        // 增加计数器
        let _ = redis::cmd("INCR")
            .arg(format!("rate_limit:{}", key))
            .query::<u32>(&mut conn);
        
        // 设置过期时间
        let _ = redis::cmd("EXPIRE")
            .arg(format!("rate_limit:{}", key))
            .arg(60) // 1分钟
            .query::<()>(&mut conn);
        
        None
    }
}
}

12.9 最佳实践总结

12.9.1 项目结构最佳实践

enterprise-blog/
├── src/
│   ├── main.rs              # 应用入口
│   ├── config/              # 配置管理
│   │   ├── mod.rs
│   │   └── config.rs
│   ├── database/            # 数据库层
│   │   ├── mod.rs
│   │   ├── migrations/      # 数据库迁移
│   │   └── connection.rs
│   ├── models/              # 数据模型
│   │   ├── mod.rs
│   │   ├── user.rs
│   │   ├── blog.rs
│   │   └── common.rs
│   ├── services/            # 业务逻辑层
│   │   ├── mod.rs
│   │   ├── user_service.rs
│   │   ├── blog_service.rs
│   │   └── cache_service.rs
│   ├── handlers/            # HTTP处理器
│   │   ├── mod.rs
│   │   ├── auth_handlers.rs
│   │   ├── blog_handlers.rs
│   │   └── admin_handlers.rs
│   ├── middleware/          # 中间件
│   │   ├── mod.rs
│   │   ├── auth.rs
│   │   ├── rate_limit.rs
│   │   └── logging.rs
│   ├── utils/               # 工具函数
│   │   ├── mod.rs
│   │   ├── validation.rs
│   │   └── security.rs
│   └── web/                 # Web服务器
│       ├── mod.rs
│       └── router.rs
├── templates/               # HTML模板
│   ├── base.html
│   ├── blog/
│   └── admin/
├── static/                  # 静态文件
│   ├── css/
│   ├── js/
│   └── images/
├── migrations/              # SQL迁移文件
├── tests/                   # 测试
├── docs/                    # 文档
├── Dockerfile              # Docker构建文件
├── docker-compose.yml      # Docker Compose配置
├── k8s/                    # Kubernetes配置
├── .github/
│   └── workflows/         # CI/CD配置
├── Cargo.toml
└── README.md

12.9.2 代码质量标准

#![allow(unused)]
fn main() {
// 使用derive宏减少样板代码
#[derive(Debug, Clone, Serialize, Deserialize, FromRow)]
pub struct User {
    // ... 字段定义
}

// 使用thiserror处理错误
#[derive(Debug, thiserror::Error)]
pub enum ServiceError {
    #[error("Database error: {0}")]
    Database(#[from] sqlx::Error),
    #[error("Validation error: {0}")]
    Validation(String),
    #[error("Not found")]
    NotFound,
}

// 使用tracing进行结构化日志记录
#[instrument(skip(self))]
pub async fn create_user(&self, request: &CreateUserRequest) -> Result<User, ServiceError> {
    tracing::info!("Creating user: {}", request.username);
    
    // 业务逻辑
    let user = self.repository.create_user(request).await?;
    
    tracing::info!("User created successfully: {}", user.id);
    Ok(user)
}

// 使用类型安全的API设计
pub struct CreateUserRequest {
    pub username: String,
    pub email: String,
    pub password: String,
}

// 实施依赖注入
pub struct ServiceContainer {
    pub user_service: Arc<dyn UserServiceTrait>,
    pub blog_service: Arc<dyn BlogServiceTrait>,
    pub cache_service: Arc<dyn CacheServiceTrait>,
}

impl ServiceContainer {
    pub fn new() -> Self {
        let db_pool = DatabaseManager::new().await?;
        let redis_client = RedisClient::new()?;
        
        ServiceContainer {
            user_service: Arc::new(UserService::new(db_pool.clone())),
            blog_service: Arc::new(BlogService::new(db_pool.clone(), redis_client.clone())),
            cache_service: Arc::new(CacheService::new(redis_client)),
        }
    }
}
}

12.9.3 性能优化建议

数据库优化：
- 使用适当的索引
- 实施查询优化
- 使用连接池
- 实施读写分离
缓存策略：
- Redis缓存热点数据
- 实施多层缓存
- 合理设置缓存过期时间
- 使用缓存预热
异步处理：
- 使用async/await
- 合理配置tokio运行时
- 实施背压控制
- 使用连接池
静态资源：
- 使用CDN
- 启用Gzip压缩
- 实施资源缓存
- 优化图片大小

12.9.4 安全建议

输入验证：
- 验证所有用户输入
- 使用白名单而非黑名单
- 实施内容安全策略(CSP)
- 防止XSS和SQL注入
认证和授权：
- 使用强密码策略
- 实施多因素认证
- 使用JWT进行无状态认证
- 实施基于角色的访问控制
数据传输：
- 使用HTTPS
- 实施HSTS
- 验证SSL证书
- 使用安全的Cookie设置
监控和日志：
- 记录安全事件
- 监控异常活动
- 实施入侵检测
- 定期安全审计

本章小结

本章深入探讨了Rust的Web开发能力，从基础框架选择到企业级应用构建。我们学习了：

Web框架生态：了解了Actix-web、Axum、Rocket等主流框架的特点和选择标准
路由和中间件：掌握了基于Axum的高级路由系统和自定义中间件开发
表单处理：学习了表单数据提取、验证和安全处理
用户认证：实现了JWT认证系统、权限管理和会话管理
企业级项目：构建了完整的企业级博客系统，集成所有核心技术
部署和运维：提供了Docker、Kubernetes等多种部署方案
性能优化：实施了数据库优化、缓存策略和性能监控
安全实践：建立了全面的安全防护体系

通过这个完整的企业级博客系统项目，我们不仅掌握了Rust Web开发的核心技术，更重要的是学会了如何构建安全、高性能、可维护的企业级应用。

关键技能：

现代Web框架的使用和选择
RESTful API设计和实现
数据库集成和优化
缓存策略设计
安全编程实践
容器化部署
监控和日志
性能优化

这些技能为构建复杂的Web应用提供了坚实的基础，能够满足现代企业级应用的各种需求。

第12章完成：Web开发核心技术已全面掌握，能够构建企业级Web应用。准备进入第13章：性能优化。

第13章：性能优化

章节概述

性能优化是现代软件开发中的关键技能。在本章中，我们将深入探索Rust的性能优化技术，从底层内存管理到高并发处理，掌握构建高性能系统的核心技术。本章不仅关注理论，更重要的是通过实际项目将理论应用到实践中。

学习目标：

掌握Rust性能分析工具和方法
理解内存管理优化技术
学会并发性能优化策略
掌握缓存策略和实现
设计并实现一个高性能缓存服务系统

实战项目：构建一个企业级高性能缓存服务，支持分布式缓存、内存池管理、性能监控、故障恢复等企业级特性。

13.1 性能分析基础

13.1.1 性能分析工具

Rust提供了多种性能分析工具，帮助开发者识别性能瓶颈：

13.1.1.1 Criterion.rs - 基准测试框架

#![allow(unused)]
fn main() {
// 性能基准测试
// File: performance-benches/Cargo.toml
[package]
name = "performance-benches"
version = "0.1.0"
edition = "2021"

[dev-dependencies]
criterion = { version = "0.5", features = ["html_reports"] }
tokio = { version = "1.0", features = ["full"] }
redis = { version = "0.24" }
sqlx = { version = "0.7" }

[[bench]]
name = "string_operations"
harness = false

[[bench]]
name = "database_queries"
harness = false

[[bench]]
name = "concurrent_operations"
harness = false
}

#![allow(unused)]
fn main() {
// File: performance-benches/benches/string_operations.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
use std::collections::HashMap;
use std::time::Duration;

fn string_concatenation_bench(c: &mut Criterion) {
    let mut group = c.benchmark_group("string_operations");
    group.sample_size(100);
    group.measurement_time(Duration::from_secs(10));
    
    // String拼接测试
    let test_sizes = vec![10, 100, 1000, 10000];
    
    for size in test_sizes {
        group.bench_with_input(
            BenchmarkId::new("string_push", size),
            &size,
            |b, &size| {
                b.iter(|| {
                    let mut s = String::new();
                    for i in 0..size {
                        s.push_str(&format!("item_{}", i));
                    }
                    black_box(s);
                })
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("format_macro", size),
            &size,
            |b, &size| {
                b.iter(|| {
                    let mut items = Vec::new();
                    for i in 0..size {
                        items.push(format!("item_{}", i));
                    }
                    let s = items.join(", ");
                    black_box(s);
                })
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("string_builder", size),
            &size,
            |b, &size| {
                b.iter(|| {
                    let mut s = String::with_capacity(size * 10);
                    for i in 0..size {
                        s.push_str(&format!("item_{}", i));
                    }
                    black_box(s);
                })
            },
        );
    }
    
    group.finish();
}

fn hashmap_operations_bench(c: &mut Criterion) {
    let mut group = c.benchmark_group("hashmap_operations");
    group.sample_size(50);
    
    // HashMap插入性能测试
    group.bench_function("hashmap_insert", |b| {
        b.iter(|| {
            let mut map = HashMap::new();
            for i in 0..1000 {
                map.insert(format!("key_{}", i), format!("value_{}", i));
            }
            black_box(map);
        })
    });
    
    // HashMap查找性能测试
    group.bench_function("hashmap_lookup", |b| {
        let mut map = HashMap::new();
        for i in 0..1000 {
            map.insert(format!("key_{}", i), format!("value_{}", i));
        }
        
        b.iter(|| {
            for i in 0..1000 {
                let key = format!("key_{}", i);
                let value = map.get(&key);
                black_box(value);
            }
        })
    });
    
    // 预分配容量测试
    group.bench_function("hashmap_with_capacity", |b| {
        b.iter(|| {
            let mut map = HashMap::with_capacity(1000);
            for i in 0..1000 {
                map.insert(format!("key_{}", i), format!("value_{}", i));
            }
            black_box(map);
        })
    });
    
    group.finish();
}

fn sorting_algorithms_bench(c: &mut Criterion) {
    let mut group = c.benchmark_group("sorting");
    group.sample_size(30);
    
    let test_data_sizes = vec![100, 1000, 10000];
    
    for &size in &test_data_sizes {
        let data: Vec<i32> = (0..size).rev().collect(); // 反序数据
        
        group.bench_with_input(
            BenchmarkId::new("sort_unstable", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let mut data = data.clone();
                    data.sort_unstable();
                    black_box(data);
                })
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("sort_stable", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let mut data = data.clone();
                    data.sort();
                    black_box(data);
                })
            },
        );
    }
    
    group.finish();
}

criterion_group!(
    benches,
    string_concatenation_bench,
    hashmap_operations_bench,
    sorting_algorithms_bench
);
criterion_main!(benches);
}

13.1.1.2 perf工具集成

#![allow(unused)]
fn main() {
// 性能分析辅助工具
// File: perf-tools/src/lib.rs
use std::time::{Duration, Instant};
use std::collections::HashMap;
use tracing::{info, warn};
use once_cell::sync::Lazy;
use std::sync::Mutex;

/// 全局性能监控器
pub static PERF_MONITOR: Lazy<Mutex<PerformanceMonitor>> = Lazy::new(|| {
    Mutex::new(PerformanceMonitor::new())
});

/// 性能监控器
pub struct PerformanceMonitor {
    metrics: HashMap<String, MetricData>,
    enabled: bool,
}

#[derive(Debug, Clone)]
pub struct MetricData {
    pub name: String,
    pub total_time: Duration,
    pub call_count: u64,
    pub min_time: Duration,
    pub max_time: Duration,
    pub avg_time: Duration,
    pub last_updated: Instant,
}

impl PerformanceMonitor {
    pub fn new() -> Self {
        PerformanceMonitor {
            metrics: HashMap::new(),
            enabled: true,
        }
    }
    
    pub fn enable(&mut self) {
        self.enabled = true;
    }
    
    pub fn disable(&mut self) {
        self.enabled = false;
    }
    
    pub fn record_metric(&mut self, name: &str, duration: Duration) {
        if !self.enabled {
            return;
        }
        
        let metric = self.metrics.entry(name.to_string()).or_insert_with(|| {
            MetricData {
                name: name.to_string(),
                total_time: Duration::from_secs(0),
                call_count: 0,
                min_time: Duration::MAX,
                max_time: Duration::from_secs(0),
                avg_time: Duration::from_secs(0),
                last_updated: Instant::now(),
            }
        });
        
        metric.total_time += duration;
        metric.call_count += 1;
        metric.last_updated = Instant::now();
        
        if duration < metric.min_time {
            metric.min_time = duration;
        }
        
        if duration > metric.max_time {
            metric.max_time = duration;
        }
        
        metric.avg_time = Duration::from_nanos(
            metric.total_time.as_nanos() as u64 / metric.call_count
        );
    }
    
    pub fn get_metrics(&self) -> Vec<MetricData> {
        self.metrics.values().cloned().collect()
    }
    
    pub fn report(&self) {
        if !self.enabled {
            return;
        }
        
        info!("Performance Metrics Report");
        info!("{:<30} | {:<10} | {:<15} | {:<15} | {:<15}", 
              "Operation", "Count", "Avg Time", "Min Time", "Max Time");
        info!("{:-<30}-+-{:-<10}-+-{:-<15}-+-{:-<15}-+-{:-<15}", 
              "", "", "", "", "");
        
        let mut metrics: Vec<_> = self.metrics.values().collect();
        metrics.sort_by(|a, b| b.avg_time.cmp(&a.avg_time));
        
        for metric in metrics {
            info!("{:<30} | {:<10} | {:<15} | {:<15} | {:<15}", 
                  metric.name, 
                  metric.call_count,
                  format!("{:.2}ms", metric.avg_time.as_secs_f64() * 1000.0),
                  format!("{:.2}ms", metric.min_time.as_secs_f64() * 1000.0),
                  format!("{:.2}ms", metric.max_time.as_secs_f64() * 1000.0));
        }
    }
}

/// 性能分析器包装器
pub struct Profiler {
    name: String,
    start_time: Instant,
}

impl Profiler {
    pub fn new(name: &str) -> Self {
        Profiler {
            name: name.to_string(),
            start_time: Instant::now(),
        }
    }
}

impl Drop for Profiler {
    fn drop(&mut self) {
        let duration = self.start_time.elapsed();
        PERF_MONITOR.lock().unwrap().record_metric(&self.name, duration);
    }
}

/// 宏定义便于使用
#[macro_export]
macro_rules! profile_func {
    ($name:expr) => {
        let _profiler = $crate::Profiler::new($name);
    };
}

#[macro_export]
macro_rules! profile_operation {
    ($name:expr, $op:block) => {
        {
            let _profiler = $crate::Profiler::new($name);
            let result = $op;
            drop(_profiler);
            result
        }
    };
}

/// 内存使用监控
pub struct MemoryProfiler {
    start_memory: usize,
    peak_memory: usize,
}

impl MemoryProfiler {
    pub fn new() -> Self {
        let start_memory = Self::get_memory_usage();
        MemoryProfiler {
            start_memory,
            peak_memory: start_memory,
        }
    }
    
    fn get_memory_usage() -> usize {
        // 在Linux系统上读取 /proc/self/status
        #[cfg(target_os = "linux")]
        {
            if let Ok(content) = std::fs::read_to_string("/proc/self/status") {
                for line in content.lines() {
                    if line.starts_with("VmRSS:") {
                        if let Some(kb_str) = line.split_whitespace().nth(1) {
                            return kb_str.parse::<usize>().unwrap_or(0) * 1024; // 转换为字节
                        }
                    }
                }
            }
        }
        
        // 其他平台使用默认实现
        0
    }
    
    pub fn update_peak(&mut self) {
        let current = Self::get_memory_usage();
        if current > self.peak_memory {
            self.peak_memory = current;
        }
    }
    
    pub fn report(&self) {
        let current = Self::get_memory_usage();
        info!("Memory Usage: Current: {:.2}MB, Peak: {:.2}MB, Change: {:.2}MB",
              current as f64 / 1024.0 / 1024.0,
              self.peak_memory as f64 / 1024.0 / 1024.0,
              (current - self.start_memory) as f64 / 1024.0 / 1024.0);
    }
}

impl Drop for MemoryProfiler {
    fn drop(&mut self) {
        self.report();
    }
}
}

13.1.1.3 自定义性能分析器

#![allow(unused)]
fn main() {
// 高级性能分析器
// File: perf-tools/src/advanced.rs
use std::time::{Duration, Instant};
use std::sync::{Arc, Mutex};
use std::thread;
use crossbeam::channel::{unbounded, Sender, Receiver};
use tracing::{info, warn, debug};

/// 实时性能监控
pub struct RealTimeMonitor {
    metrics: Arc<Mutex<MetricsCollector>>,
    collector_thread: Option<thread::JoinHandle<()>>,
    sampling_interval: Duration,
}

#[derive(Debug, Clone)]
pub struct SystemMetrics {
    pub cpu_usage: f64,
    pub memory_usage: f64,
    pub gc_count: u64,
    pub active_connections: u64,
    pub request_rate: f64,
    pub response_time: Duration,
}

#[derive(Debug, Clone)]
pub struct MetricsCollector {
    pub samples: Vec<SystemMetrics>,
    pub min_response_time: Duration,
    pub max_response_time: Duration,
    pub avg_response_time: Duration,
    pub total_requests: u64,
    pub error_count: u64,
}

impl MetricsCollector {
    pub fn new() -> Self {
        MetricsCollector {
            samples: Vec::new(),
            min_response_time: Duration::MAX,
            max_response_time: Duration::from_secs(0),
            avg_response_time: Duration::from_secs(0),
            total_requests: 0,
            error_count: 0,
        }
    }
    
    pub fn record_request(&mut self, response_time: Duration, success: bool) {
        self.total_requests += 1;
        if !success {
            self.error_count += 1;
        }
        
        if response_time < self.min_response_time {
            self.min_response_time = response_time;
        }
        
        if response_time > self.max_response_time {
            self.max_response_time = response_time;
        }
        
        // 计算平均响应时间
        if self.total_requests > 0 {
            self.avg_response_time = Duration::from_nanos(
                (self.avg_response_time.as_nanos() as u64 * (self.total_requests - 1) + 
                 response_time.as_nanos() as u64) / self.total_requests
            );
        }
    }
    
    pub fn collect_system_metrics(&mut self) {
        let metrics = SystemMetrics {
            cpu_usage: self.get_cpu_usage(),
            memory_usage: self.get_memory_usage(),
            gc_count: self.get_gc_count(),
            active_connections: self.get_active_connections(),
            request_rate: self.calculate_request_rate(),
            response_time: self.avg_response_time,
        };
        
        self.samples.push(metrics);
        
        // 保持最近100个样本
        if self.samples.len() > 100 {
            self.samples.remove(0);
        }
    }
    
    fn get_cpu_usage(&self) -> f64 {
        // 简化的CPU使用率计算
        // 在实际项目中可以使用更精确的库
        rand::random::<f64>() * 100.0
    }
    
    fn get_memory_usage(&self) -> f64 {
        // 获取内存使用情况
        #[cfg(target_os = "linux")]
        {
            if let Ok(content) = std::fs::read_to_string("/proc/meminfo") {
                for line in content.lines() {
                    if line.starts_with("MemAvailable:") {
                        if let Some(kb_str) = line.split_whitespace().nth(1) {
                            let available_kb = kb_str.parse::<f64>().unwrap_or(0.0);
                            let total_kb = available_kb / 0.1; // 简化计算
                            return (total_kb - available_kb) / total_kb * 100.0;
                        }
                    }
                }
            }
        }
        rand::random::<f64>() * 100.0
    }
    
    fn get_gc_count(&self) -> u64 {
        // Rust的垃圾回收统计
        // 这里返回模拟值
        rand::random::<u64>() % 1000
    }
    
    fn get_active_connections(&self) -> u64 {
        // 模拟活跃连接数
        rand::random::<u64>() % 10000
    }
    
    fn calculate_request_rate(&self) -> f64 {
        if self.samples.len() < 2 {
            return 0.0;
        }
        
        let recent_samples = &self.samples[self.samples.len().saturating_sub(10)..];
        let time_diff = recent_samples.len() as f64;
        
        if time_diff > 0.0 {
            self.total_requests as f64 / time_diff
        } else {
            0.0
        }
    }
}

impl RealTimeMonitor {
    pub fn new(sampling_interval: Duration) -> Self {
        RealTimeMonitor {
            metrics: Arc::new(Mutex::new(MetricsCollector::new())),
            collector_thread: None,
            sampling_interval,
        }
    }
    
    pub fn start(&mut self) {
        let metrics = Arc::clone(&self.metrics);
        let sampling_interval = self.sampling_interval;
        
        self.collector_thread = Some(thread::spawn(move || {
            loop {
                thread::sleep(sampling_interval);
                
                if let Ok(mut collector) = metrics.lock() {
                    collector.collect_system_metrics();
                }
            }
        }));
    }
    
    pub fn stop(&mut self) {
        if let Some(handle) = self.collector_thread.take() {
            handle.join().unwrap_or_else(|_| {
                warn!("Performance monitor thread panicked");
            });
        }
    }
    
    pub fn record_request(&self, response_time: Duration, success: bool) {
        if let Ok(mut collector) = self.metrics.lock() {
            collector.record_request(response_time, success);
        }
    }
    
    pub fn get_metrics(&self) -> Option<MetricsCollector> {
        if let Ok(collector) = self.metrics.lock() {
            Some(collector.clone())
        } else {
            None
        }
    }
    
    pub fn generate_report(&self) {
        if let Some(metrics) = self.get_metrics() {
            info!("=== Real-time Performance Report ===");
            info!("Total Requests: {}", metrics.total_requests);
            info!("Error Count: {}", metrics.error_count);
            info!("Error Rate: {:.2}%", 
                  if metrics.total_requests > 0 { 
                      metrics.error_count as f64 / metrics.total_requests as f64 * 100.0 
                  } else { 0.0 });
            info!("Average Response Time: {:.2}ms", metrics.avg_response_time.as_secs_f64() * 1000.0);
            info!("Min Response Time: {:.2}ms", metrics.min_response_time.as_secs_f64() * 1000.0);
            info!("Max Response Time: {:.2}ms", metrics.max_response_time.as_secs_f64() * 1000.0);
            
            if !metrics.samples.is_empty() {
                let latest = &metrics.samples[metrics.samples.len() - 1];
                info!("Current CPU Usage: {:.1}%", latest.cpu_usage);
                info!("Current Memory Usage: {:.1}%", latest.memory_usage);
                info!("Active Connections: {}", latest.active_connections);
                info!("Request Rate: {:.1} req/s", latest.request_rate);
            }
        }
    }
}

/// 性能警告系统
pub struct PerformanceAlert {
    thresholds: PerformanceThresholds,
    alert_channel: Option<Sender<PerformanceAlert>>,
    current_state: AlertState,
}

#[derive(Debug, Clone)]
pub struct PerformanceThresholds {
    pub max_response_time: Duration,
    pub max_error_rate: f64,
    pub max_memory_usage: f64,
    pub max_cpu_usage: f64,
}

#[derive(Debug, Clone)]
pub struct AlertState {
    pub high_response_time: bool,
    pub high_error_rate: bool,
    pub high_memory_usage: bool,
    pub high_cpu_usage: bool,
}

impl PerformanceAlert {
    pub fn new(thresholds: PerformanceThresholds) -> Self {
        PerformanceAlert {
            thresholds,
            alert_channel: None,
            current_state: AlertState {
                high_response_time: false,
                high_error_rate: false,
                high_memory_usage: false,
                high_cpu_usage: false,
            },
        }
    }
    
    pub fn with_channel(mut self, channel: Sender<PerformanceAlert>) -> Self {
        self.alert_channel = Some(channel);
        self
    }
    
    pub fn check_metrics(&mut self, metrics: &MetricsCollector) {
        let new_state = AlertState {
            high_response_time: metrics.avg_response_time > self.thresholds.max_response_time,
            high_error_rate: if metrics.total_requests > 0 {
                metrics.error_count as f64 / metrics.total_requests as f64 * 100.0
            } else { 0.0 } > self.thresholds.max_error_rate,
            high_memory_usage: false, // 需要系统级监控
            high_cpu_usage: false,    // 需要系统级监控
        };
        
        // 检查状态变化
        self.check_state_change("High Response Time", 
                               self.current_state.high_response_time, 
                               new_state.high_response_time);
        
        self.check_state_change("High Error Rate", 
                               self.current_state.high_error_rate, 
                               new_state.high_error_rate);
        
        self.current_state = new_state;
    }
    
    fn check_state_change(&self, alert_type: &str, old_state: bool, new_state: bool) {
        if old_state != new_state {
            if new_state {
                warn!("Performance Alert: {} is now HIGH", alert_type);
                if let Some(ref channel) = self.alert_channel {
                    let _ = channel.send(PerformanceAlert {
                        thresholds: self.thresholds.clone(),
                        alert_channel: self.alert_channel.clone(),
                        current_state: self.current_state.clone(),
                    });
                }
            } else {
                info!("Performance Alert: {} is now normal", alert_type);
            }
        }
    }
}
}

13.1.2 使用tracing进行性能监控

#![allow(unused)]
fn main() {
// 集成tracing的性能监控
// File: tracing-integration/src/lib.rs
use tracing::{info, instrument, span, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
use std::time::Instant;

/// 带有性能追踪的服务
#[instrument(skip(self))]
pub struct TracedService {
    service_name: String,
    request_count: std::sync::atomic::AtomicU64,
    error_count: std::sync::atomic::AtomicU64,
    total_duration: std::sync::atomic::AtomicU64,
}

impl TracedService {
    pub fn new(service_name: &str) -> Self {
        TracedService {
            service_name: service_name.to_string(),
            request_count: std::sync::atomic::AtomicU64::new(0),
            error_count: std::sync::atomic::AtomicU64::new(0),
            total_duration: std::sync::atomic::AtomicU64::new(0),
        }
    }
    
    #[instrument(fields(request_id = %uuid::Uuid::new_v4(), user_id = %"anonymous"))]
    pub async fn process_request(&self, data: &str) -> Result<String, Box<dyn std::error::Error>> {
        let start = Instant::now();
        self.request_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        
        let span = span!(Level::INFO, "process_request", service = %self.service_name);
        let _enter = span.enter();
        
        info!("Started processing request with data length: {}", data.len());
        
        // 模拟处理
        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
        
        if data.len() > 1000 {
            self.error_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
            return Err("Data too large".into());
        }
        
        let result = format!("Processed: {}", data);
        
        let duration = start.elapsed();
        self.total_duration.fetch_add(duration.as_nanos() as u64, std::sync::atomic::Ordering::Relaxed);
        
        info!("Successfully processed request, duration: {:?}", duration);
        
        Ok(result)
    }
    
    pub fn get_stats(&self) -> ServiceStats {
        let request_count = self.request_count.load(std::sync::atomic::Ordering::Relaxed);
        let error_count = self.error_count.load(std::sync::atomic::Ordering::Relaxed);
        let total_duration = self.total_duration.load(std::sync::atomic::Ordering::Relaxed);
        
        ServiceStats {
            service_name: self.service_name.clone(),
            request_count,
            error_count,
            error_rate: if request_count > 0 {
                error_count as f64 / request_count as f64 * 100.0
            } else {
                0.0
            },
            avg_duration: if request_count > 0 {
                std::time::Duration::from_nanos(total_duration / request_count)
            } else {
                std::time::Duration::from_secs(0)
            },
        }
    }
}

#[derive(Debug, Clone)]
pub struct ServiceStats {
    pub service_name: String,
    pub request_count: u64,
    pub error_count: u64,
    pub error_rate: f64,
    pub avg_duration: std::time::Duration,
}

/// 初始化tracing性能监控
pub fn init_tracing() {
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "tracing_performance=debug,perf_tools=info,tokio=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .with(
            // JSON格式化，便于日志分析
            tracing_subscriber::fmt::layer()
                .json()
                .with_current_span(false)
                .with_span_list(false)
        )
        .init();
}
}

13.2 内存优化

13.2.1 内存管理基础

Rust的所有权系统为内存优化提供了强大的工具：

#![allow(unused)]
fn main() {
// 内存池实现
// File: memory-pools/src/lib.rs
use std::alloc::{GlobalAlloc, Layout, System};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::ptr::NonNull;
use std::marker::PhantomData;
use tracing::{info, warn, debug};

/// 预分配内存池
pub struct MemoryPool {
    pool: Vec<NonNull<u8>>,
    current_index: AtomicUsize,
    block_size: usize,
    total_blocks: usize,
    allocated: AtomicUsize,
}

unsafe impl Send for MemoryPool {}
unsafe impl Sync for MemoryPool {}

impl MemoryPool {
    pub fn new(block_size: usize, total_blocks: usize) -> Self {
        // 对齐到16字节边界
        let aligned_block_size = (block_size + 15) & !15;
        
        let mut pool = Vec::with_capacity(total_blocks);
        
        for _ in 0..total_blocks {
            let layout = Layout::from_size_align(aligned_block_size, 16)
                .expect("Invalid layout");
            
            unsafe {
                let ptr = System.alloc(layout);
                if ptr.is_null() {
                    panic!("Failed to allocate memory for pool");
                }
                
                pool.push(NonNull::new_unchecked(ptr));
            }
        }
        
        info!("Created memory pool: {} blocks of {} bytes", total_blocks, aligned_block_size);
        
        MemoryPool {
            pool,
            current_index: AtomicUsize::new(0),
            block_size: aligned_block_size,
            total_blocks,
            allocated: AtomicUsize::new(0),
        }
    }
    
    pub fn allocate(&self) -> Option<NonNull<u8>> {
        let old_index = self.current_index.fetch_add(1, Ordering::SeqCst);
        let new_index = old_index % self.total_blocks;
        
        if old_index < self.total_blocks {
            self.allocated.fetch_add(1, Ordering::SeqCst);
            Some(self.pool[new_index])
        } else {
            None // 池已耗尽
        }
    }
    
    pub fn is_exhausted(&self) -> bool {
        self.allocated.load(Ordering::SeqCst) >= self.total_blocks
    }
    
    pub fn get_stats(&self) -> PoolStats {
        PoolStats {
            total_blocks: self.total_blocks,
            allocated: self.allocated.load(Ordering::SeqCst),
            block_size: self.block_size,
            utilization: self.allocated.load(Ordering::SeqCst) as f64 / self.total_blocks as f64 * 100.0,
        }
    }
}

impl Drop for MemoryPool {
    fn drop(&mut self) {
        let layout = Layout::from_size_align(self.block_size, 16).unwrap();
        
        for ptr in &self.pool {
            unsafe {
                System.dealloc(ptr.as_ptr(), layout);
            }
        }
        
        debug!("Memory pool dropped, returned {} blocks to system", self.total_blocks);
    }
}

#[derive(Debug, Clone)]
pub struct PoolStats {
    pub total_blocks: usize,
    pub allocated: usize,
    pub block_size: usize,
    pub utilization: f64,
}

/// 智能指针包装器，自动内存池分配
pub struct PooledBox<T> {
    ptr: NonNull<T>,
    pool: *const MemoryPool,
    _phantom: PhantomData<T>,
}

impl<T> PooledBox<T> {
    pub fn new_in(pool: &MemoryPool, value: T) -> Option<Self> {
        let ptr = pool.allocate()?;
        
        unsafe {
            ptr.as_ptr().write(value);
        }
        
        Some(PooledBox {
            ptr: ptr.cast::<T>(),
            pool,
            _phantom: PhantomData,
        })
    }
    
    pub fn as_ref(&self) -> &T {
        unsafe {
            &*self.ptr.as_ptr()
        }
    }
    
    pub fn as_mut(&mut self) -> &mut T {
        unsafe {
            &mut *self.ptr.as_ptr()
        }
    }
}

impl<T> std::ops::Deref for PooledBox<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        self.as_ref()
    }
}

impl<T> std::ops::DerefMut for PooledBox<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.as_mut()
    }
}

impl<T> Drop for PooledBox<T> {
    fn drop(&mut self) {
        unsafe {
            std::ptr::drop_in_place(self.ptr.as_ptr());
        }
    }
}

unsafe impl<T: Send> Send for PooledBox<T> {}
unsafe impl<T: Sync> Sync for PooledBox<T> where T: Sync {}

/// 内存池管理器
pub struct PoolManager {
    pools: std::collections::HashMap<usize, MemoryPool>,
    small_object_pool: MemoryPool,
    large_object_pool: MemoryPool,
}

impl PoolManager {
    pub fn new() -> Self {
        // 小对象池：128字节块，1024个块
        let small_object_pool = MemoryPool::new(128, 1024);
        
        // 大对象池：1024字节块，256个块
        let large_object_pool = MemoryPool::new(1024, 256);
        
        let mut pools = std::collections::HashMap::new();
        pools.insert(128, small_object_pool.pool.as_ptr() as *const MemoryPool);
        pools.insert(1024, large_object_pool.pool.as_ptr() as *const MemoryPool);
        
        PoolManager {
            pools,
            small_object_pool,
            large_object_pool,
        }
    }
    
    pub fn allocate<T>(&self, size: usize) -> Option<PooledBox<T>> {
        if size <= 128 {
            self.small_object_pool.allocate()
        } else if size <= 1024 {
            self.large_object_pool.allocate()
        } else {
            None
        }
    }
    
    pub fn get_pool_stats(&self) -> (PoolStats, PoolStats) {
        (self.small_object_pool.get_stats(), self.large_object_pool.get_stats())
    }
}

/// 对象池模式
pub struct ObjectPool<T: Default + Clone> {
    available: std::sync::Mutex<Vec<T>>,
    in_use: AtomicUsize,
    max_size: usize,
    _phantom: PhantomData<T>,
}

impl<T: Default + Clone + Send + Sync> ObjectPool<T> {
    pub fn new(max_size: usize) -> Self {
        ObjectPool {
            available: std::sync::Mutex::new(Vec::with_capacity(max_size)),
            in_use: AtomicUsize::new(0),
            max_size,
            _phantom: PhantomData,
        }
    }
    
    pub fn get(&self) -> Option<PooledObject<T>> {
        if self.in_use.load(Ordering::SeqCst) >= self.max_size {
            return None;
        }
        
        let mut available = self.available.lock().unwrap();
        let object = available.pop().unwrap_or_default();
        self.in_use.fetch_add(1, Ordering::SeqCst);
        
        Some(PooledObject {
            object,
            pool: self as *const ObjectPool<T>,
        })
    }
    
    pub fn get_stats(&self) -> PoolStats {
        let available = self.available.lock().unwrap().len();
        let in_use = self.in_use.load(Ordering::SeqCst);
        
        PoolStats {
            total_blocks: self.max_size,
            allocated: available + in_use,
            block_size: std::mem::size_of::<T>(),
            utilization: (available + in_use) as f64 / self.max_size as f64 * 100.0,
        }
    }
}

pub struct PooledObject<T> {
    object: T,
    pool: *const ObjectPool<T>,
}

impl<T> std::ops::Deref for PooledObject<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        &self.object
    }
}

impl<T> std::ops::DerefMut for PooledObject<T> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.object
    }
}

impl<T> Drop for PooledObject<T> {
    fn drop(&mut self) {
        unsafe {
            let pool = &*self.pool;
            // 重置对象状态
            *self.object = T::default();
            
            let mut available = pool.available.lock().unwrap();
            available.push(std::mem::replace(&mut self.object, T::default()));
            pool.in_use.fetch_sub(1, Ordering::SeqCst);
        }
    }
}
}

13.2.2 零拷贝优化

#![allow(unused)]
fn main() {
// 零拷贝字符串处理
// File: zero-copy/src/lib.rs
use std::ops::Deref;
use std::borrow::Cow;

/// 零拷贝字符串包装器
pub struct ZeroCopyStr {
    data: Cow<'static, str>,
    _phantom: std::marker::PhantomData<()>,
}

impl ZeroCopyStr {
    pub fn new_static(data: &'static str) -> Self {
        ZeroCopyStr {
            data: Cow::Borrowed(data),
            _phantom: PhantomData,
        }
    }
    
    pub fn new_owned(data: String) -> Self {
        ZeroCopyStr {
            data: Cow::Owned(data),
            _phantom: PhantomData,
        }
    }
    
    pub fn as_str(&self) -> &str {
        &self.data
    }
    
    pub fn to_string_lossy(&self) -> Cow<str> {
        self.data.clone()
    }
}

impl Deref for ZeroCopyStr {
    type Target = str;
    
    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

impl AsRef<str> for ZeroCopyStr {
    fn as_ref(&self) -> &str {
        &self.data
    }
}

impl PartialEq for ZeroCopyStr {
    fn eq(&self, other: &Self) -> bool {
        self.data == other.data
    }
}

/// 零拷贝JSON处理
pub struct ZeroCopyJson<T> {
    data: T,
    _phantom: PhantomData<()>,
}

impl<T> ZeroCopyJson<T> {
    pub fn new(data: T) -> Self {
        ZeroCopyJson {
            data,
            _phantom: PhantomData,
        }
    }
    
    pub fn into_inner(self) -> T {
        self.data
    }
}

impl<T> std::ops::Deref for ZeroCopyJson<T> {
    type Target = T;
    
    fn deref(&self) -> &Self::Target {
        &self.data
    }
}

/// 字节缓冲区池
pub struct ByteBufferPool {
    pool: std::sync::Mutex<Vec<Vec<u8>>>,
    buffer_size: usize,
    max_buffers: usize,
}

impl ByteBufferPool {
    pub fn new(buffer_size: usize, max_buffers: usize) -> Self {
        ByteBufferPool {
            pool: std::sync::Mutex::new(Vec::with_capacity(max_buffers)),
            buffer_size,
            max_buffers,
        }
    }
    
    pub fn get_buffer(&self) -> Vec<u8> {
        if let Ok(mut pool) = self.pool.lock() {
            if let Some(buffer) = pool.pop() {
                buffer
            } else {
                vec![0; self.buffer_size]
            }
        } else {
            vec![0; self.buffer_size]
        }
    }
    
    pub fn return_buffer(&self, mut buffer: Vec<u8>) {
        if buffer.len() == self.buffer_size {
            if let Ok(mut pool) = self.pool.lock() {
                if pool.len() < self.max_buffers {
                    buffer.clear();
                    pool.push(buffer);
                }
            }
        }
    }
}
}

13.3 并发性能优化

13.3.1 异步编程优化

#![allow(unused)]
fn main() {
// 高性能异步处理器
// File: async-optimization/src/lib.rs
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::{RwLock, Semaphore, Mutex};
use tokio::task::{JoinHandle, JoinError};
use tracing::{info, warn, instrument, span, Level};
use futures::future::BoxFuture;
use futures::FutureExt;

/// 高性能异步任务执行器
pub struct AsyncTaskExecutor {
    task_semaphore: Arc<Semaphore>,
    active_tasks: Arc<std::sync::atomic::AtomicU64>,
    completed_tasks: Arc<std::sync::atomic::AtomicU64>,
    failed_tasks: Arc<std::sync::atomic::AtomicU64>,
}

impl AsyncTaskExecutor {
    pub fn new(max_concurrent_tasks: usize) -> Self {
        AsyncTaskExecutor {
            task_semaphore: Arc::new(Semaphore::new(max_concurrent_tasks)),
            active_tasks: Arc::new(std::sync::atomic::AtomicU64::new(0)),
            completed_tasks: Arc::new(std::sync::atomic::AtomicU64::new(0)),
            failed_tasks: Arc::new(std::sync::atomic::AtomicU64::new(0)),
        }
    }
    
    #[instrument(skip(self, task))]
    pub async fn execute<F, T>(&self, task: F) -> Result<T, Box<dyn std::error::Error + Send + Sync>>
    where
        F: FnOnce() -> BoxFuture<'static, Result<T, Box<dyn std::error::Error + Send + Sync>>> + Send + 'static,
        T: Send + 'static,
    {
        let _permit = self.task_semaphore.acquire().await?;
        self.active_tasks.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
        
        let start_time = Instant::now();
        let active_tasks = Arc::clone(&self.active_tasks);
        let completed_tasks = Arc::clone(&self.completed_tasks);
        let failed_tasks = Arc::clone(&self.failed_tasks);
        
        let result = tokio::spawn(async move {
            let task_result = task().await;
            
            // 记录完成时间
            let duration = start_time.elapsed();
            info!("Task completed in {:?}", duration);
            
            // 更新统计信息
            active_tasks.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
            match &task_result {
                Ok(_) => completed_tasks.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
                Err(_) => failed_tasks.fetch_add(1, std::sync::atomic::Ordering::Relaxed),
            }
            
            task_result
        }).await;
        
        match result {
            Ok(task_result) => task_result,
            Err(join_error) => {
                self.active_tasks.fetch_sub(1, std::sync::atomic::Ordering::Relaxed);
                self.failed_tasks.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                Err(Box::new(join_error))
            }
        }
    }
    
    pub async fn batch_execute<F, T>(&self, tasks: Vec<F>) -> Vec<Result<T, Box<dyn std::error::Error + Send + Sync>>>
    where
        F: FnOnce() -> BoxFuture<'static, Result<T, Box<dyn std::error::Error + Send + Sync>>> + Send + 'static,
        T: Send + 'static,
    {
        let mut handles: Vec<JoinHandle<Result<T, Box<dyn std::error::Error + Send + Sync>>>> = Vec::new();
        
        for task in tasks {
            let handle = tokio::spawn(async move {
                task().await
            });
            handles.push(handle);
        }
        
        let mut results = Vec::with_capacity(handles.len());
        
        for handle in handles {
            match handle.await {
                Ok(result) => results.push(result),
                Err(join_error) => results.push(Err(Box::new(join_error))),
            }
        }
        
        results
    }
    
    pub fn get_stats(&self) -> TaskStats {
        TaskStats {
            active_tasks: self.active_tasks.load(std::sync::atomic::Ordering::Relaxed),
            completed_tasks: self.completed_tasks.load(std::sync::atomic::Ordering::Relaxed),
            failed_tasks: self.failed_tasks.load(std::sync::atomic::Ordering::Relaxed),
            max_concurrent: self.task_semaphore.available_permits() + 
                           self.active_tasks.load(std::sync::atomic::Ordering::Relaxed),
        }
    }
}

#[derive(Debug, Clone)]
pub struct TaskStats {
    pub active_tasks: u64,
    pub completed_tasks: u64,
    pub failed_tasks: u64,
    pub max_concurrent: usize,
}

/// 无锁并发数据结构
pub struct LockFreeQueue<T> {
    head: Arc<AtomicNode<T>>,
    tail: Arc<AtomicNode<T>>,
}

struct AtomicNode<T> {
    value: std::sync::atomic::AtomicPtr<T>,
    next: std::sync::atomic::AtomicPtr<AtomicNode<T>>,
}

impl<T> AtomicNode<T> {
    fn new(value: T) -> Arc<Self> {
        let node = Arc::new(AtomicNode {
            value: std::sync::atomic::AtomicPtr::new(Box::into_raw(Box::new(value))),
            next: std::sync::atomic::AtomicPtr::new(std::ptr::null_mut()),
        });
        
        // 增加引用计数
        Arc::clone(&node);
        node
    }
    
    fn load_value(&self) -> T {
        unsafe {
            *Box::from_raw(self.value.load(std::sync::atomic::Ordering::Acquire))
        }
    }
}

impl<T> LockFreeQueue<T> {
    pub fn new() -> Self {
        let dummy = Arc::new(AtomicNode {
            value: std::sync::atomic::AtomicPtr::new(std::ptr::null_mut()),
            next: std::sync::atomic::AtomicPtr::new(std::ptr::null_mut()),
        });
        
        LockFreeQueue {
            head: Arc::clone(&dummy),
            tail: Arc::clone(&dummy),
        }
    }
    
    pub fn enqueue(&self, value: T) {
        let new_node = AtomicNode::new(value);
        let mut current_tail = self.tail.load(std::sync::atomic::Ordering::Acquire);
        
        loop {
            let current_tail_next = unsafe { (*current_tail).next.load(std::sync::atomic::Ordering::Acquire) };
            
            if current_tail_next.is_null() {
                if (*current_tail).next.compare_exchange_weak(
                    std::ptr::null_mut(),
                    Arc::as_ptr(&new_node) as *mut AtomicNode<T>,
                    std::sync::atomic::Ordering::Release,
                    std::sync::atomic::Ordering::Relaxed,
                ).is_ok() {
                    break;
                }
            } else {
                let _ = self.tail.compare_exchange_weak(
                    current_tail,
                    current_tail_next,
                    std::sync::atomic::Ordering::Release,
                    std::sync::atomic::Ordering::Relaxed,
                );
                current_tail = self.tail.load(std::sync::atomic::Ordering::Acquire);
            }
        }
    }
    
    pub fn dequeue(&self) -> Option<T> {
        let mut current_head = self.head.load(std::sync::atomic::Ordering::Acquire);
        
        loop {
            let next = unsafe { (*current_head).next.load(std::sync::atomic::Ordering::Acquire) };
            
            if next.is_null() {
                return None;
            }
            
            if self.head.compare_exchange_weak(
                current_head,
                next,
                std::sync::atomic::Ordering::Release,
                std::sync::atomic::Ordering::Relaxed,
            ).is_ok() {
                unsafe {
                    let value = (*next).load_value();
                    // 清理内存
                    let _ = Box::from_raw(current_head);
                    Some(value)
                }
            } else {
                current_head = self.head.load(std::sync::atomic::Ordering::Acquire);
            }
        }
    }
}

/// 工作窃取调度器
pub struct WorkStealingScheduler {
    queues: Vec<Arc<Mutex<Vec<Box<dyn Fn() + Send + Sync>>>>>,
    num_queues: usize,
}

impl WorkStealingScheduler {
    pub fn new(num_queues: usize) -> Self {
        let mut queues = Vec::with_capacity(num_queues);
        for _ in 0..num_queues {
            queues.push(Arc::new(Mutex::new(Vec::new())));
        }
        
        WorkStealingScheduler {
            queues,
            num_queues,
        }
    }
    
    pub fn schedule<F>(&self, work: F)
    where
        F: FnOnce() + Send + Sync + 'static,
    {
        let queue_index = std::thread::current().id().as_u128() as usize % self.num_queues;
        let queue = &self.queues[queue_index];
        
        let mut queue = queue.lock().unwrap();
        queue.push(Box::new(work));
    }
    
    pub fn execute_one(&self, queue_index: usize) -> bool {
        let mut queue = self.queues[queue_index].lock().unwrap();
        
        if let Some(work) = queue.pop() {
            drop(queue); // 释放锁
            work();
            true
        } else {
            false
        }
    }
    
    pub fn steal_work(&self, victim_index: usize) -> bool {
        let mut victim_queue = self.queues[victim_index].lock().unwrap();
        
        if let Some(work) = victim_queue.pop() {
            drop(victim_queue);
            work();
            true
        } else {
            false
        }
    }
}
}

13.3.2 并发模式优化

#![allow(unused)]
fn main() {
// Actor模式高性能实现
// File: actor-model/src/lib.rs
use std::sync::mpsc;
use std::sync::Arc;
use tokio::sync::{mpsc as async_mpsc, oneshot};
use tracing::{info, warn, instrument};

/// 异步Actor系统
pub struct ActorSystem {
    actors: Arc<std::sync::Mutex<std::collections::HashMap<String, Arc<dyn Actor + Send + Sync>>>>,
    message_router: MessageRouter,
}

impl ActorSystem {
    pub fn new() -> Self {
        ActorSystem {
            actors: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
            message_router: MessageRouter::new(),
        }
    }
    
    pub fn register_actor<A: Actor + Send + Sync + 'static>(&self, id: String, actor: A) {
        let mut actors = self.actors.lock().unwrap();
        actors.insert(id, Arc::new(actor));
        info!("Actor registered: {}", id);
    }
    
    pub async fn send_message<M: Message>(&self, actor_id: &str, message: M) -> Result<M::Response, ActorError>
    where
        M: Send + 'static,
        M::Response: Send + 'static,
    {
        let actors = self.actors.lock().unwrap();
        if let Some(actor) = actors.get(actor_id) {
            drop(actors);
            let (tx, rx) = oneshot::channel();
            
            let actor_message = ActorMessage {
                payload: Box::new(message),
                response_sender: Some(tx),
            };
            
            actor.handle_message(actor_message).await?;
            
            match rx.await {
                Ok(response) => Ok(response),
                Err(_) => Err(ActorError::ChannelClosed),
            }
        } else {
            Err(ActorError::ActorNotFound)
        }
    }
}

#[derive(Debug, thiserror::Error)]
pub enum ActorError {
    #[error("Actor not found")]
    ActorNotFound,
    #[error("Channel closed")]
    ChannelClosed,
    #[error("Message handling failed: {0}")]
    MessageHandlingFailed(String),
}

pub trait Message {
    type Response: Send;
}

pub struct ActorMessage {
    payload: Box<dyn Message + Send>,
    response_sender: Option<oneshot::Sender<Box<dyn std::any::Any + Send>>>,
}

impl ActorMessage {
    pub fn send_response<T: std::any::Any + Send>(&self, response: T) -> Result<(), ActorError> {
        if let Some(sender) = &self.response_sender {
            let _ = sender.send(Box::new(response));
            Ok(())
        } else {
            Err(ActorError::MessageHandlingFailed("No response sender".to_string()))
        }
    }
}

pub trait Actor {
    fn handle_message(&self, message: ActorMessage) -> BoxFuture<Result<(), ActorError>>;
}

type BoxFuture<T> = std::pin::Pin<Box<dyn std::future::Future<Output = T> + Send>>;

/// 消息路由器
struct MessageRouter {
    routes: Arc<std::sync::Mutex<std::collections::HashMap<String, String>>>,
}

impl MessageRouter {
    fn new() -> Self {
        MessageRouter {
            routes: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
        }
    }
    
    fn register_route(&self, pattern: String, actor_id: String) {
        let mut routes = self.routes.lock().unwrap();
        routes.insert(pattern, actor_id);
    }
}

/// 高性能事件驱动系统
pub struct EventDrivenSystem {
    event_bus: Arc<async_mpsc::UnboundedSender<Event>>,
    subscribers: Arc<std::sync::Mutex<std::collections::HashMap<String, Vec<Arc<dyn EventHandler + Send + Sync>>>>,
    event_history: Arc<std::sync::Mutex<Vec<Event>>>,
    max_history: usize,
}

#[derive(Debug, Clone)]
pub struct Event {
    pub id: String,
    pub event_type: String,
    pub payload: Box<dyn std::any::Any + Send + Sync>,
    pub timestamp: std::time::Instant,
    pub source: String,
}

impl Event {
    pub fn new<T: std::any::Any + Send + Sync>(event_type: String, payload: T, source: String) -> Self {
        Event {
            id: uuid::Uuid::new_v4().to_string(),
            event_type,
            payload: Box::new(payload),
            timestamp: std::time::Instant::now(),
            source,
        }
    }
}

pub trait EventHandler: Send + Sync {
    fn handle_event(&self, event: &Event) -> BoxFuture<Result<(), EventHandlerError>>;
    fn event_types(&self) -> Vec<String>;
}

#[derive(Debug, thiserror::Error)]
pub enum EventHandlerError {
    #[error("Event handling failed: {0}")]
    HandlingFailed(String),
    #[error("Invalid event type")]
    InvalidEventType,
}

impl EventDrivenSystem {
    pub fn new(buffer_size: usize, max_history: usize) -> Self {
        let (tx, _) = async_mpsc::unbounded_channel(buffer_size);
        
        EventDrivenSystem {
            event_bus: Arc::new(tx),
            subscribers: Arc::new(std::sync::Mutex::new(std::collections::HashMap::new())),
            event_history: Arc::new(std::sync::Mutex::new(Vec::with_capacity(max_history))),
            max_history,
        }
    }
    
    pub fn subscribe<H: EventHandler + Send + Sync + 'static>(&self, handler: Arc<H>) {
        for event_type in handler.event_types() {
            let mut subscribers = self.subscribers.lock().unwrap();
            subscribers
                .entry(event_type)
                .or_insert_with(Vec::new)
                .push(handler.clone());
        }
    }
    
    pub async fn publish_event<T: std::any::Any + Send + Sync>(&self, event: Event) -> Result<(), mpsc::SendError<Event>> {
        // 存储到历史记录
        {
            let mut history = self.event_history.lock().unwrap();
            history.push(event.clone());
            if history.len() > self.max_history {
                history.remove(0);
            }
        }
        
        // 分发给订阅者
        let subscribers = self.subscribers.lock().unwrap();
        if let Some(handlers) = subscribers.get(&event.event_type) {
            for handler in handlers {
                let event_clone = event.clone();
                let handler = handler.clone();
                let event_bus = Arc::clone(&self.event_bus);
                
                tokio::spawn(async move {
                    if let Err(e) = handler.handle_event(&event_clone).await {
                        warn!("Event handler failed: {}", e);
                    }
                });
            }
        }
        
        // 发送到事件总线
        self.event_bus.send(event)
    }
    
    pub fn get_event_history(&self) -> Vec<Event> {
        self.event_history.lock().unwrap().clone()
    }
}
}

13.4 缓存策略

13.4.1 多层缓存架构

#![allow(unused)]
fn main() {
// 多层缓存系统
// File: multi-layer-cache/src/lib.rs
use std::collections::HashMap;
use std::sync::{Arc, RwLock, Mutex};
use std::time::{Duration, Instant};
use tokio::sync::RwLock as AsyncRwLock;
use tracing::{info, warn, debug};
use serde::{Serialize, Deserialize};

/// 缓存条目
#[derive(Debug, Clone)]
pub struct CacheEntry<T> {
    pub data: T,
    pub created_at: Instant,
    pub access_count: u64,
    pub last_accessed: Instant,
    pub ttl: Option<Duration>,
}

impl<T> CacheEntry<T> {
    pub fn new(data: T, ttl: Option<Duration>) -> Self {
        let now = Instant::now();
        CacheEntry {
            data,
            created_at: now,
            access_count: 0,
            last_accessed: now,
            ttl,
        }
    }
    
    pub fn is_expired(&self) -> bool {
        if let Some(ttl) = self.ttl {
            self.created_at + ttl < Instant::now()
        } else {
            false
        }
    }
    
    pub fn access(&mut self) -> &T {
        self.access_count += 1;
        self.last_accessed = Instant::now();
        &self.data
    }
}

/// L1 缓存 - 内存缓存（最热数据）
pub struct L1Cache<K, V> {
    data: Arc<RwLock<HashMap<K, CacheEntry<V>>>>,
    max_size: usize,
    hit_count: std::sync::atomic::AtomicU64,
    miss_count: std::sync::atomic::AtomicU64,
}

impl<K, V> L1Cache<K, V>
where
    K: Clone + std::hash::Hash + Eq + Send + Sync,
    V: Clone + Send + Sync,
{
    pub fn new(max_size: usize) -> Self {
        L1Cache {
            data: Arc::new(RwLock::new(HashMap::new())),
            max_size,
            hit_count: std::sync::atomic::AtomicU64::new(0),
            miss_count: std::sync::atomic::AtomicU64::new(0),
        }
    }
    
    pub async fn get(&self, key: &K) -> Option<Arc<V>> {
        let data = self.data.read().unwrap();
        if let Some(entry) = data.get(key) {
            if !entry.is_expired() {
                self.hit_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                let value = Arc::new(entry.access().clone());
                drop(data);
                Some(value)
            } else {
                drop(data);
                self.remove(key).await;
                self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                None
            }
        } else {
            drop(data);
            self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
            None
        }
    }
    
    pub async fn set(&self, key: K, value: V, ttl: Option<Duration>) {
        let mut data = self.data.write().unwrap();
        
        // 如果缓存已满，删除最久未访问的条目
        if data.len() >= self.max_size && !data.contains_key(&key) {
            let lru_key = self.find_lru_key(&data);
            if let Some(lru) = lru_key {
                data.remove(&lru);
            }
        }
        
        data.insert(key, CacheEntry::new(value, ttl));
    }
    
    pub async fn remove(&self, key: &K) -> Option<V> {
        let mut data = self.data.write().unwrap();
        data.remove(key).map(|entry| entry.data)
    }
    
    pub async fn clear(&self) {
        let mut data = self.data.write().unwrap();
        data.clear();
    }
    
    fn find_lru_key(&self, data: &HashMap<K, CacheEntry<V>>) -> Option<K> {
        data.iter()
            .min_by_key(|(_, entry)| entry.last_accessed)
            .map(|(key, _)| key.clone())
    }
    
    pub fn get_stats(&self) -> CacheStats {
        let hit_count = self.hit_count.load(std::sync::atomic::Ordering::Relaxed);
        let miss_count = self.miss_count.load(std::sync::atomic::Ordering::Relaxed);
        let total = hit_count + miss_count;
        
        CacheStats {
            hit_count,
            miss_count,
            hit_rate: if total > 0 { hit_count as f64 / total as f64 } else { 0.0 },
            size: self.data.read().unwrap().len(),
            max_size: self.max_size,
        }
    }
}

/// L2 缓存 - 分布式缓存（较热数据）
pub struct L2Cache<K, V> {
    client: Arc<redis::Client>,
    key_prefix: String,
    default_ttl: Duration,
    hit_count: std::sync::atomic::AtomicU64,
    miss_count: std::sync::atomic::AtomicU64,
}

impl<K, V> L2Cache<K, V>
where
    K: std::fmt::Display + Send + Sync,
    V: Serialize + for<'de> Deserialize<'de> + Send + Sync,
{
    pub fn new(client: redis::Client, key_prefix: String, default_ttl: Duration) -> Self {
        L2Cache {
            client: Arc::new(client),
            key_prefix,
            default_ttl,
            hit_count: std::sync::atomic::AtomicU64::new(0),
            miss_count: std::sync::atomic::AtomicU64::new(0),
        }
    }
    
    pub async fn get(&self, key: &K) -> Option<V> {
        let redis_key = format!("{}:{}", self.key_prefix, key);
        
        match self.client.get_async_connection().await {
            Ok(mut conn) => {
                match redis::cmd("GET")
                    .arg(&redis_key)
                    .query_async::<_, Option<String>>(&mut conn)
                    .await
                {
                    Ok(Some(data)) => {
                        self.hit_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                        match serde_json::from_str(&data) {
                            Ok(value) => Some(value),
                            Err(_) => {
                                warn!("Failed to deserialize cache data for key: {}", key);
                                self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                                None
                            }
                        }
                    }
                    Ok(None) => {
                        self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                        None
                    }
                    Err(e) => {
                        warn!("Redis get error: {}", e);
                        self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                        None
                    }
                }
            }
            Err(e) => {
                warn!("Failed to connect to Redis: {}", e);
                self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                None
            }
        }
    }
    
    pub async fn set(&self, key: K, value: V, ttl: Option<Duration>) {
        let redis_key = format!("{}:{}", self.key_prefix, key);
        let ttl_duration = ttl.unwrap_or(self.default_ttl);
        
        match self.client.get_async_connection().await {
            Ok(mut conn) => {
                if let Ok(data) = serde_json::to_string(&value) {
                    let ttl_secs = ttl_duration.as_secs();
                    
                    let _ = redis::cmd("SETEX")
                        .arg(&redis_key)
                        .arg(ttl_secs)
                        .arg(&data)
                        .query_async::<_, ()>(&mut conn)
                        .await
                        .map_err(|e| warn!("Redis set error: {}", e));
                }
            }
            Err(e) => {
                warn!("Failed to connect to Redis: {}", e);
            }
        }
    }
    
    pub async fn remove(&self, key: &K) {
        let redis_key = format!("{}:{}", self.key_prefix, key);
        
        match self.client.get_async_connection().await {
            Ok(mut conn) => {
                let _ = redis::cmd("DEL")
                    .arg(&redis_key)
                    .query_async::<_, ()>(&mut conn)
                    .await
                    .map_err(|e| warn!("Redis delete error: {}", e));
            }
            Err(e) => {
                warn!("Failed to connect to Redis: {}", e);
            }
        }
    }
    
    pub fn get_stats(&self) -> CacheStats {
        let hit_count = self.hit_count.load(std::sync::atomic::Ordering::Relaxed);
        let miss_count = self.miss_count.load(std::sync::atomic::Ordering::Relaxed);
        let total = hit_count + miss_count;
        
        CacheStats {
            hit_count,
            miss_count,
            hit_rate: if total > 0 { hit_count as f64 / total as f64 } else { 0.0 },
            size: 0, // Redis中的大小需要额外查询
            max_size: 0,
        }
    }
}

/// L3 缓存 - 数据源缓存（冷数据）
pub struct L3Cache<K, V, F> {
    data_fetcher: F,
    cache: Arc<AsyncRwLock<HashMap<K, CacheEntry<V>>>>,
    ttl: Duration,
}

impl<K, V, F> L3Cache<K, V, F>
where
    K: Clone + std::hash::Hash + Eq + Send + Sync,
    V: Clone + Send + Sync,
    F: Fn(K) -> BoxFuture<'static, V> + Send + Sync,
{
    pub fn new(data_fetcher: F, ttl: Duration) -> Self {
        L3Cache {
            data_fetcher,
            cache: Arc::new(AsyncRwLock::new(HashMap::new())),
            ttl,
        }
    }
    
    pub async fn get(&self, key: K) -> V {
        let mut cache = self.cache.read().await;
        
        if let Some(entry) = cache.get(&key) {
            if !entry.is_expired() {
                return entry.access().clone();
            }
        }
        
        drop(cache);
        
        // 缓存未命中，从数据源获取
        debug!("Cache miss, fetching from data source for key: {:?}", key);
        let value = (self.data_fetcher)(key.clone()).await;
        
        // 更新缓存
        let mut cache = self.cache.write().await;
        cache.insert(key, CacheEntry::new(value.clone(), Some(self.ttl)));
        
        value
    }
    
    pub async fn invalidate(&self, key: &K) {
        let mut cache = self.cache.write().await;
        cache.remove(key);
    }
    
    pub async fn clear(&self) {
        let mut cache = self.cache.write().await;
        cache.clear();
    }
}

/// 多层缓存系统
pub struct MultiLayerCache<K, V> {
    l1: Option<Arc<L1Cache<K, V>>>,
    l2: Option<Arc<L2Cache<K, V>>>,
    l3: Option<Arc<L3Cache<K, V, Box<dyn Fn(K) -> BoxFuture<'static, V> + Send + Sync>>>>,
    fallback_strategy: FallbackStrategy,
}

#[derive(Debug, Clone)]
pub enum FallbackStrategy {
    L1Only,
    L1L2,
    AllLayers,
}

impl<K, V> MultiLayerCache<K, V>
where
    K: Clone + std::hash::Hash + Eq + std::fmt::Display + Send + Sync,
    V: Clone + Serialize + for<'de> Deserialize<'de> + Send + Sync,
{
    pub fn new(
        l1_size: Option<usize>,
        redis_client: Option<redis::Client>,
        data_fetcher: Option<Box<dyn Fn(K) -> BoxFuture<'static, V> + Send + Sync>>,
        fallback_strategy: FallbackStrategy,
    ) -> Self {
        let l1 = l1_size.map(|size| Arc::new(L1Cache::new(size)));
        let l2 = redis_client.map(|client| Arc::new(L2Cache::new(client, "cache".to_string(), Duration::from_secs(3600))));
        let l3 = data_fetcher.map(|fetcher| Arc::new(L3Cache::new(fetcher, Duration::from_secs(7200))));
        
        MultiLayerCache {
            l1,
            l2,
            l3,
            fallback_strategy,
        }
    }
    
    pub async fn get(&self, key: K) -> Option<V> {
        match self.fallback_strategy {
            FallbackStrategy::L1Only => {
                if let Some(l1) = &self.l1 {
                    l1.get(&key).await.map(|value| (*value).clone())
                } else {
                    None
                }
            }
            FallbackStrategy::L1L2 => {
                // 尝试L1
                if let Some(l1) = &self.l1 {
                    if let Some(value) = l1.get(&key).await {
                        return Some((*value).clone());
                    }
                }
                
                // L1未命中，尝试L2
                if let Some(l2) = &self.l2 {
                    if let Some(value) = l2.get(&key).await {
                        // 升级到L1
                        if let Some(l1) = &self.l1 {
                            l1.set(key.clone(), value.clone(), Some(Duration::from_secs(300))).await;
                        }
                        return Some(value);
                    }
                }
                
                None
            }
            FallbackStrategy::AllLayers => {
                // 依次尝试各层
                if let Some(l1) = &self.l1 {
                    if let Some(value) = l1.get(&key).await {
                        return Some((*value).clone());
                    }
                }
                
                if let Some(l2) = &self.l2 {
                    if let Some(value) = l2.get(&key).await {
                        // 升级到L1
                        if let Some(l1) = &self.l1 {
                            l1.set(key.clone(), value.clone(), Some(Duration::from_secs(300))).await;
                        }
                        return Some(value);
                    }
                }
                
                // 最后一层：L3（数据源）
                if let Some(l3) = &self.l3 {
                    let value = l3.get(key).await;
                    
                    // 向各层写入
                    if let Some(l1) = &self.l1 {
                        l1.set(key.clone(), value.clone(), Some(Duration::from_secs(300))).await;
                    }
                    if let Some(l2) = &self.l2 {
                        l2.set(key.clone(), value.clone(), Some(Duration::from_secs(3600))).await;
                    }
                    
                    return Some(value);
                }
                
                None
            }
        }
    }
    
    pub async fn set(&self, key: K, value: V, ttl: Option<Duration>) {
        // 写入所有缓存层
        if let Some(l1) = &self.l1 {
            l1.set(key.clone(), value.clone(), ttl).await;
        }
        
        if let Some(l2) = &self.l2 {
            l2.set(key.clone(), value.clone(), ttl).await;
        }
    }
    
    pub async fn remove(&self, key: &K) {
        if let Some(l1) = &self.l1 {
            l1.remove(key).await;
        }
        
        if let Some(l2) = &self.l2 {
            l2.remove(key).await;
        }
        
        if let Some(l3) = &self.l3 {
            l3.invalidate(key).await;
        }
    }
    
    pub async fn get_stats(&self) -> MultiLayerCacheStats {
        MultiLayerCacheStats {
            l1_stats: self.l1.as_ref().map(|l1| l1.get_stats()),
            l2_stats: self.l2.as_ref().map(|l2| l2.get_stats()),
        }
    }
}

#[derive(Debug, Clone)]
pub struct CacheStats {
    pub hit_count: u64,
    pub miss_count: u64,
    pub hit_rate: f64,
    pub size: usize,
    pub max_size: usize,
}

#[derive(Debug, Clone)]
pub struct MultiLayerCacheStats {
    pub l1_stats: Option<CacheStats>,
    pub l2_stats: Option<CacheStats>,
}
}

13.4.2 缓存更新策略

#![allow(unused)]
fn main() {
// 智能缓存更新策略
// File: cache-strategies/src/lib.rs
use std::time::{Duration, Instant};
use std::collections::HashMap;
use tracing::{info, warn, debug};

/// 缓存更新策略
#[derive(Debug, Clone)]
pub enum UpdateStrategy {
    /// 写通模式：同时写入缓存和数据源
    WriteThrough,
    /// 写回模式：先写入缓存，异步写入数据源
    WriteBack,
    /// 写绕模式：只写入数据源，清除缓存
    WriteAround,
    /// 延迟写入模式：缓存命中时更新缓存
    LazyWrite,
    /// TTL模式：基于时间过期
    TtlBased,
    /// LRU模式：基于访问频率
    LruBased,
}

pub struct CacheUpdateManager {
    strategies: HashMap<String, UpdateStrategy>,
    last_update_times: HashMap<String, Instant>,
    write_queue: Arc<crossbeam::queue::SegQueue<WriteOperation>>,
    background_writer: Option<tokio::task::JoinHandle<()>>,
}

#[derive(Debug, Clone)]
pub struct WriteOperation {
    pub key: String,
    pub value: String,
    pub strategy: UpdateStrategy,
    pub timestamp: Instant,
}

impl CacheUpdateManager {
    pub fn new() -> Self {
        let manager = CacheUpdateManager {
            strategies: HashMap::new(),
            last_update_times: HashMap::new(),
            write_queue: Arc::new(crossbeam::queue::SegQueue::new()),
            background_writer: None,
        };
        
        manager.start_background_writer();
        manager
    }
    
    pub fn register_strategy(&mut self, cache_key: &str, strategy: UpdateStrategy) {
        self.strategies.insert(cache_key.to_string(), strategy);
        info!("Registered update strategy for cache key '{}': {:?}", cache_key, strategy);
    }
    
    pub async fn update_cache(&self, key: &str, value: &str) -> Result<(), CacheError> {
        let strategy = self.strategies.get(key)
            .unwrap_or(&UpdateStrategy::WriteThrough);
        
        match strategy {
            UpdateStrategy::WriteThrough => {
                self.write_through(key, value).await
            }
            UpdateStrategy::WriteBack => {
                self.write_back(key, value)
            }
            UpdateStrategy::WriteAround => {
                self.write_around(key, value).await
            }
            UpdateStrategy::LazyWrite => {
                // 标记为需要更新，但不立即写入
                Ok(())
            }
            UpdateStrategy::TtlBased => {
                self.ttl_based_update(key, value)
            }
            UpdateStrategy::LruBased => {
                self.lru_based_update(key, value)
            }
        }
    }
    
    async fn write_through(&self, key: &str, value: &str) -> Result<(), CacheError> {
        info!("Write-through: updating both cache and data source for key: {}", key);
        
        // 同步更新缓存和数据源
        let cache_update = self.update_cache_layer(key, value);
        let data_update = self.update_data_source(key, value);
        
        futures::future::join(cache_update, data_update).await;
        
        Ok(())
    }
    
    fn write_back(&self, key: &str, value: &str) -> Result<(), CacheError> {
        info!("Write-back: queuing update for background processing: {}", key);
        
        // 写入队列，异步处理
        self.write_queue.push(WriteOperation {
            key: key.to_string(),
            value: value.to_string(),
            strategy: UpdateStrategy::WriteBack,
            timestamp: Instant::now(),

        });
        
        Ok(())
    }
    
    async fn write_around(&self, key: &str, value: &str) -> Result<(), CacheError> {
        info!("Write-around: updating data source and invalidating cache: {}", key);
        
        // 更新数据源
        self.update_data_source(key, value).await;
        
        // 清除缓存
        self.invalidate_cache(key).await;
        
        Ok(())
    }
    
    fn ttl_based_update(&self, key: &str, value: &str) -> Result<(), CacheError> {
        info!("TTL-based update for key: {}", key);
        
        // 更新最后访问时间
        self.last_update_times.insert(key.to_string(), Instant::now());
        
        // 更新缓存
        self.update_cache_layer(key, value)?;
        
        Ok(())
    }
    
    fn lru_based_update(&self, key: &str, value: &str) -> Result<(), CacheError> {
        info!("LRU-based update for key: {}", key);
        
        // 将key移到最近使用
        self.last_update_times.insert(key.to_string(), Instant::now());
        
        // 更新缓存
        self.update_cache_layer(key, value)?;
        
        Ok(())
    }
    
    async fn update_cache_layer(&self, key: &str, value: &str) -> Result<(), CacheError> {
        // 这里应该是实际的缓存更新逻辑
        debug!("Updating cache layer for key: {}", key);
        Ok(())
    }
    
    async fn update_data_source(&self, key: &str, value: &str) {
        // 这里应该是实际的数据源更新逻辑
        debug!("Updating data source for key: {}", key);
        tokio::time::sleep(Duration::from_millis(10)).await; // 模拟写入延迟
    }
    
    async fn invalidate_cache(&self, key: &str) {
        debug!("Invalidating cache for key: {}", key);
        // 缓存失效逻辑
    }
    
    fn start_background_writer(&mut self) {
        let write_queue = Arc::clone(&self.write_queue);
        
        self.background_writer = Some(tokio::spawn(async move {
            loop {
                if let Some(operation) = write_queue.pop() {
                    debug!("Processing background write operation: {}", operation.key);
                    
                    // 模拟异步写入到数据源
                    tokio::time::sleep(Duration::from_millis(50)).await;
                    
                    info!("Background write completed for key: {}", operation.key);
                } else {
                    tokio::time::sleep(Duration::from_millis(100)).await;
                }
            }
        }));
    }
    
    pub fn stop(&mut self) {
        if let Some(handle) = self.background_writer.take() {
            handle.abort();
        }
    }
}

#[derive(Debug, thiserror::Error)]
pub enum CacheError {
    #[error("Cache update failed: {0}")]
    UpdateFailed(String),
    #[error("Cache key not found")]
    KeyNotFound,
    #[error("Invalid strategy")]
    InvalidStrategy,
}

/// 缓存预热管理器
pub struct CacheWarmer {
    warmup_tasks: HashMap<String, WarmupTask>,
    parallel_tasks: usize,
}

#[derive(Debug, Clone)]
pub struct WarmupTask {
    pub key: String,
    pub fetcher: Box<dyn Fn() -> BoxFuture<'static, Option<String>> + Send + Sync>,
    pub priority: WarmupPriority,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum WarmupPriority {
    Critical,
    High,
    Normal,
    Low,
}

impl CacheWarmer {
    pub fn new(parallel_tasks: usize) -> Self {
        CacheWarmer {
            warmup_tasks: HashMap::new(),
            parallel_tasks,
        }
    }
    
    pub fn register_task(&mut self, task: WarmupTask) {
        self.warmup_tasks.insert(task.key.clone(), task);
        info!("Registered warmup task for key: {}", task.key);
    }
    
    pub async fn warm_up(&self) -> WarmupResult {
        info!("Starting cache warm-up with {} tasks", self.warmup_tasks.len());
        
        // 按优先级排序
        let mut tasks: Vec<_> = self.warmup_tasks.values().cloned().collect();
        tasks.sort_by(|a, b| b.priority.cmp(&a.priority));
        
        let mut results = Vec::new();
        let semaphore = Arc::new(tokio::sync::Semaphore::new(self.parallel_tasks));
        
        // 并行执行预热任务
        for task in tasks {
            let permit = semaphore.clone().acquire_owned().await.unwrap();
            let task_key = task.key.clone();
            
            let result = tokio::spawn(async move {
                let _permit = permit;
                
                let start_time = Instant::now();
                let value = (task.fetcher)().await;
                let duration = start_time.elapsed();
                
                WarmupResultItem {
                    key: task_key,
                    success: value.is_some(),
                    duration,
                    value,
                }
            });
            
            results.push(result);
        }
        
        // 等待所有任务完成
        let mut warmup_results = Vec::new();
        for handle in results {
            if let Ok(result) = handle.await {
                warmup_results.push(result);
            }
        }
        
        WarmupResult {
            total_tasks: warmup_results.len(),
            successful_tasks: warmup_results.iter().filter(|r| r.success).count(),
            failed_tasks: warmup_results.iter().filter(|r| !r.success).count(),
            total_duration: warmup_results.iter().map(|r| r.duration).max().unwrap_or_default(),
            results: warmup_results,
        }
    }
}

#[derive(Debug)]
pub struct WarmupResult {
    pub total_tasks: usize,
    pub successful_tasks: usize,
    pub failed_tasks: usize,
    pub total_duration: Duration,
    pub results: Vec<WarmupResultItem>,
}

#[derive(Debug, Clone)]
pub struct WarmupResultItem {
    pub key: String,
    pub success: bool,
    pub duration: Duration,
    pub value: Option<String>,
}

impl WarmupResult {
    pub fn success_rate(&self) -> f64 {
        if self.total_tasks > 0 {
            self.successful_tasks as f64 / self.total_tasks as f64 * 100.0
        } else {
            0.0
        }
    }
    
    pub fn print_summary(&self) {
        info!("=== Cache Warm-up Summary ===");
        info!("Total tasks: {}", self.total_tasks);
        info!("Successful: {}", self.successful_tasks);
        info!("Failed: {}", self.failed_tasks);
        info!("Success rate: {:.1}%", self.success_rate());
        info!("Total duration: {:?}", self.total_duration);
        
        if self.failed_tasks > 0 {
            warn!("Failed warm-up tasks:");
            for result in &self.results {
                if !result.success {
                    warn!("  - {}: {:?}", result.key, result.duration);
                }
            }
        }
    }
}
}

13.5 高性能缓存服务项目

现在我们来构建一个企业级高性能缓存服务，集成所有学到的性能优化技术。

#![allow(unused)]
fn main() {
// 高性能缓存服务主项目
// File: cache-service/Cargo.toml
[package]
name = "cache-service"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
axum = { version = "0.7", features = ["macros"] }
tower = { version = "0.4" }
tower-http = { version = "0.5", features = ["cors", "compression", "trace", "timeout"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
redis = { version = "0.24", features = ["tokio-comp", "connection-manager"] }
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
anyhow = "1.0"
thiserror = "1.0"
uuid = { version = "1.0", features = ["v4", "serde"] }
chrono = { version = "0.4", features = ["serde"] }
criterion = "0.5"
once_cell = "1.0"
futures = "0.3"
crossbeam = "0.8"
regex = "1.0"
}

// 高性能缓存服务
// File: cache-service/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod cache;
mod server;
mod config;

use cache::CacheService;
use server::CacheServer;
use config::Config;

#[derive(Parser, Debug)]
#[command(name = "cache-service")]
#[command(about = "High-performance cache service")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start the cache service
    Server {
        #[arg(short, long, default_value = "0.0.0.0:8080")]
        addr: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
        
        #[arg(short, long, default_value = "1000")]
        l1_cache_size: usize,
        
        #[arg(short, long, default_value = "100")]
        parallel_tasks: usize,
    },
    /// Run performance benchmarks
    Benchmark,
    /// Test cache service
    Test,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "cache_service=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Server { addr, redis_url, l1_cache_size, parallel_tasks } => {
            run_server(addr, redis_url, l1_cache_size, parallel_tasks).await
        }
        Commands::Benchmark => {
            run_benchmarks().await
        }
        Commands::Test => {
            run_tests().await
        }
    }
}

async fn run_server(
    addr: String,
    redis_url: String,
    l1_cache_size: usize,
    parallel_tasks: usize,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting high-performance cache service on {}", addr);
    
    // 初始化配置
    let config = Config {
        addr,
        redis_url,
        l1_cache_size,
        parallel_tasks,
        default_ttl: std::time::Duration::from_secs(3600),
        max_ttl: std::time::Duration::from_secs(86400),
        warmup_enabled: true,
        metrics_enabled: true,
    };
    
    // 初始化Redis连接
    let redis_client = redis::Client::open(&config.redis_url)?;
    
    // 初始化缓存服务
    let cache_service = CacheService::new(redis_client, config.clone()).await?;
    
    // 启动服务器
    let server = CacheServer::new(config, cache_service);
    server.run().await?;
    
    Ok(())
}

async fn run_benchmarks() -> Result<(), Box<dyn std::error::Error>> {
    info!("Running performance benchmarks");
    
    // 缓存性能基准测试
    run_cache_benchmarks().await?;
    
    // 并发性能基准测试
    run_concurrency_benchmarks().await?;
    
    // 内存使用基准测试
    run_memory_benchmarks().await?;
    
    info!("All benchmarks completed");
    Ok(())
}

async fn run_cache_benchmarks() -> Result<(), Box<dyn std::error::Error>> {
    use criterion::{black_box, criterion_group, criterion_main, Criterion};
    
    // 这里集成criterion进行缓存性能测试
    // ... 基准测试实现
    
    Ok(())
}

async fn run_concurrency_benchmarks() -> Result<(), Box<dyn std::error::Error>> {
    info!("Running concurrency benchmarks");
    
    // 并发性能测试
    let cache_service = create_test_cache_service().await?;
    
    // 测试高并发写入
    let write_start = std::time::Instant::now();
    let mut handles = Vec::new();
    
    for i in 0..1000 {
        let service = cache_service.clone();
        let handle = tokio::spawn(async move {
            let key = format!("test_key_{}", i);
            let value = format!("test_value_{}", i);
            
            service.set(&key, &value, Some(std::time::Duration::from_secs(300))).await?;
            service.get::<String>(&key).await
        });
        handles.push(handle);
    }
    
    for handle in handles {
        let _ = handle.await?;
    }
    
    let write_duration = write_start.elapsed();
    info!("Concurrent write test completed in {:?}", write_duration);
    
    Ok(())
}

async fn run_memory_benchmarks() -> Result<(), Box<dyn std::error::Error>> {
    info!("Running memory benchmarks");
    
    // 内存使用测试
    use perf_tools::MemoryProfiler;
    
    let mut profiler = MemoryProfiler::new();
    
    // 创建大量缓存条目
    let cache_service = create_test_cache_service().await?;
    
    for i in 0..10000 {
        let key = format!("memory_test_{}", i);
        let value = "x".repeat(1000); // 1KB数据
        
        cache_service.set(&key, &value, Some(std::time::Duration::from_secs(60))).await?;
        profiler.update_peak();
    }
    
    info!("Memory benchmark completed");
    Ok(())
}

async fn run_tests() -> Result<(), Box<dyn std::error::Error>> {
    info!("Running cache service tests");
    
    let cache_service = create_test_cache_service().await?;
    
    // 基础功能测试
    test_basic_operations(&cache_service).await?;
    
    // TTL测试
    test_ttl_expiration(&cache_service).await?;
    
    // 并发测试
    test_concurrent_operations(&cache_service).await?;
    
    info!("All tests passed");
    Ok(())
}

async fn create_test_cache_service() -> Result<Arc<CacheService>, Box<dyn std::error::Error>> {
    let redis_client = redis::Client::open("redis://localhost:6379")?;
    let config = Config {
        addr: "127.0.0.1:0".to_string(),
        redis_url: "redis://localhost:6379".to_string(),
        l1_cache_size: 1000,
        parallel_tasks: 100,
        default_ttl: std::time::Duration::from_secs(3600),
        max_ttl: std::time::Duration::from_secs(86400),
        warmup_enabled: false,
        metrics_enabled: true,
    };
    
    let cache_service = CacheService::new(redis_client, config).await?;
    Ok(Arc::new(cache_service))
}

async fn test_basic_operations(cache_service: &CacheService) -> Result<(), Box<dyn std::error::Error>> {
    // 测试设置和获取
    cache_service.set("test_key", "test_value", None).await?;
    let value: Option<String> = cache_service.get("test_key").await?;
    
    assert_eq!(value, Some("test_value".to_string()));
    info!("✓ Basic set/get operations working");
    
    // 测试删除
    cache_service.delete("test_key").await?;
    let value: Option<String> = cache_service.get("test_key").await?;
    
    assert_eq!(value, None);
    info!("✓ Delete operation working");
    
    Ok(())
}

async fn test_ttl_expiration(cache_service: &CacheService) -> Result<(), Box<dyn std::error::Error>> {
    // 测试短TTL
    cache_service.set("ttl_test", "ttl_value", Some(std::time::Duration::from_millis(100))).await?;
    
    // 立即检查应该存在
    let value: Option<String> = cache_service.get("ttl_test").await?;
    assert_eq!(value, Some("ttl_value".to_string()));
    
    // 等待过期
    tokio::time::sleep(std::time::Duration::from_millis(150)).await;
    
    // 检查应该已过期
    let value: Option<String> = cache_service.get("ttl_test").await?;
    assert_eq!(value, None);
    
    info!("✓ TTL expiration working");
    Ok(())
}

async fn test_concurrent_operations(cache_service: &CacheService) -> Result<(), Box<dyn std::error::Error>> {
    // 测试并发读取
    let mut handles = Vec::new();
    for i in 0..100 {
        let service = cache_service.clone();
        let handle = tokio::spawn(async move {
            let value: Option<String> = service.get("concurrent_test").await?;
            Ok(value)
        });
        handles.push(handle);
    }
    
    // 检查所有并发操作都返回相同结果
    for handle in handles {
        let result = handle.await??;
        // 并发读操作应该都返回None（key不存在）
        assert_eq!(result, None);
    }
    
    info!("✓ Concurrent operations working");
    Ok(())
}

#![allow(unused)]
fn main() {
// 缓存服务核心实现
// File: cache-service/src/cache/mod.rs
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::RwLock;
use serde::{Serialize, Deserialize};
use tracing::{info, warn, debug, instrument};
use once_cell::sync::Lazy;
use crossbeam::queue::SegQueue;

pub mod l1_cache;
pub mod l2_cache;
pub mod strategies;

use l1_cache::L1MemoryCache;
use l2_cache::L2RedisCache;
use strategies::{CacheStrategy, UpdateStrategy};

/// 缓存服务配置
#[derive(Debug, Clone)]
pub struct CacheConfig {
    pub default_ttl: Duration,
    pub max_ttl: Duration,
    pub l1_cache_size: usize,
    pub parallel_tasks: usize,
    pub warmup_enabled: bool,
    pub metrics_enabled: bool,
}

/// 缓存统计信息
#[derive(Debug, Clone, Default)]
pub struct CacheStats {
    pub hits: u64,
    pub misses: u64,
    pub sets: u64,
    pub deletes: u64,
    pub l1_hits: u64,
    pub l2_hits: u64,
    pub l3_hits: u64,
    pub avg_response_time: Duration,
    pub total_operations: u64,
}

impl CacheStats {
    pub fn hit_rate(&self) -> f64 {
        if self.hits + self.misses > 0 {
            self.hits as f64 / (self.hits + self.misses) as f64
        } else {
            0.0
        }
    }
    
    pub fn add_operation(&mut self, duration: Duration) {
        self.total_operations += 1;
        self.avg_response_time = Duration::from_nanos(
            (self.avg_response_time.as_nanos() as u64 * (self.total_operations - 1) + 
             duration.as_nanos() as u64) / self.total_operations
        );
    }
}

/// 高性能缓存服务
pub struct CacheService {
    l1_cache: Arc<L1MemoryCache>,
    l2_cache: Arc<L2RedisCache>,
    config: CacheConfig,
    stats: Arc<RwLock<CacheStats>>,
    strategy: Arc<dyn CacheStrategy + Send + Sync>,
    write_queue: Arc<SegQueue<WriteOperation>>,
}

#[derive(Debug, Clone)]
pub struct WriteOperation {
    pub key: String,
    pub value: String,
    pub ttl: Option<Duration>,
    pub timestamp: Instant,
}

impl CacheService {
    pub async fn new(redis_client: redis::Client, config: crate::config::Config) -> Result<Self, Box<dyn std::error::Error>> {
        let cache_config = CacheConfig {
            default_ttl: config.default_ttl,
            max_ttl: config.max_ttl,
            l1_cache_size: config.l1_cache_size,
            parallel_tasks: config.parallel_tasks,
            warmup_enabled: config.warmup_enabled,
            metrics_enabled: config.metrics_enabled,
        };
        
        let l1_cache = Arc::new(L1MemoryCache::new(cache_config.l1_cache_size));
        let l2_cache = Arc::new(L2RedisCache::new(redis_client, "cache".to_string(), cache_config.default_ttl));
        let strategy = Arc::new(UpdateStrategy::new(cache_config.clone()));
        let write_queue = Arc::new(SegQueue::new());
        
        // 启动后台写线程
        if cache_config.warmup_enabled {
            Self::start_background_writer(write_queue.clone(), strategy.clone());
        }
        
        info!("Cache service initialized with L1 size: {}, L2: Redis", cache_config.l1_cache_size);
        
        Ok(CacheService {
            l1_cache,
            l2_cache,
            config: cache_config,
            stats: Arc::new(RwLock::new(CacheStats::default())),
            strategy,
            write_queue,
        })
    }
    
    #[instrument(skip(self))]
    pub async fn get<T>(&self, key: &str) -> Result<Option<T>, Box<dyn std::error::Error>>
    where
        T: for<'de> Deserialize<'de> + Send + Sync,
    {
        let start_time = Instant::now();
        
        // 尝试L1缓存
        if let Some(value) = self.l1_cache.get(key).await {
            let mut stats = self.stats.write().await;
            stats.l1_hits += 1;
            stats.hits += 1;
            stats.add_operation(start_time.elapsed());
            return Ok(Some(value));
        }
        
        // L1未命中，尝试L2缓存
        if let Some(value) = self.l2_cache.get(key).await {
            // 升级到L1
            self.l1_cache.set(key, &value, None).await;
            
            let mut stats = self.stats.write().await;
            stats.l2_hits += 1;
            stats.hits += 1;
            stats.add_operation(start_time.elapsed());
            
            // 反序列化
            return Ok(Some(serde_json::from_str(&value)?));
        }
        
        // 缓存未命中
        let mut stats = self.stats.write().await;
        stats.misses += 1;
        stats.add_operation(start_time.elapsed());
        
        Ok(None)
    }
    
    #[instrument(skip(self))]
    pub async fn set<T>(&self, key: &str, value: &T, ttl: Option<Duration>) -> Result<(), Box<dyn std::error::Error>>
    where
        T: Serialize + Send + Sync,
    {
        let start_time = Instant::now();
        
        // 序列化值
        let serialized_value = serde_json::to_string(value)?;
        
        // 使用策略决定更新方式
        self.strategy.update_cache(key, &serialized_value, ttl, &self.write_queue).await?;
        
        // 更新L1缓存
        self.l1_cache.set(key, &serialized_value, ttl).await;
        
        // 更新L2缓存
        self.l2_cache.set(key, &serialized_value, ttl).await;
        
        let mut stats = self.stats.write().await;
        stats.sets += 1;
        stats.add_operation(start_time.elapsed());
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn delete(&self, key: &str) -> Result<(), Box<dyn std::error::Error>> {
        let start_time = Instant::now();
        
        // 从所有缓存层删除
        self.l1_cache.delete(key).await;
        self.l2_cache.delete(key).await;
        
        let mut stats = self.stats.write().await;
        stats.deletes += 1;
        stats.add_operation(start_time.elapsed());
        
        Ok(())
    }
    
    #[instrument(skip(self))]
    pub async fn exists(&self, key: &str) -> Result<bool, Box<dyn std::error::Error>> {
        // 先检查L1
        if self.l1_cache.exists(key).await {
            return Ok(true);
        }
        
        // 检查L2
        if self.l2_cache.exists(key).await {
            return Ok(true);
        }
        
        Ok(false)
    }
    
    pub async fn get_stats(&self) -> CacheStats {
        self.stats.read().await.clone()
    }
    
    pub async fn clear(&self) -> Result<(), Box<dyn std::error::Error>> {
        self.l1_cache.clear().await;
        self.l2_cache.clear().await;
        
        info!("Cache cleared");
        Ok(())
    }
    
    fn start_background_writer(
        write_queue: Arc<SegQueue<WriteOperation>>,
        strategy: Arc<dyn CacheStrategy + Send + Sync>,
    ) {
        tokio::spawn(async move {
            loop {
                if let Some(operation) = write_queue.pop() {
                    debug!("Processing background write: {}", operation.key);
                    
                    // 模拟异步写入
                    tokio::time::sleep(Duration::from_millis(10)).await;
                    
                    // 这里可以添加更复杂的写入逻辑
                    info!("Background write completed: {}", operation.key);
                } else {
                    tokio::time::sleep(Duration::from_millis(100)).await;
                }
            }
        });
    }
    
    pub async fn warm_up(&self) -> Result<(), Box<dyn std::error::Error>> {
        info!("Starting cache warm-up");
        
        // 这里可以预加载热点数据
        let warmup_tasks = vec![
            "user_profile_123".to_string(),
            "config_settings".to_string(),
            "popular_articles".to_string(),
        ];
        
        for key in warmup_tasks {
            // 模拟从数据源获取数据
            let value = format!("warmup_value_{}", key);
            self.set(&key, &value, Some(Duration::from_secs(3600))).await?;
        }
        
        info!("Cache warm-up completed");
        Ok(())
    }
}
}

#![allow(unused)]
fn main() {
// L1内存缓存实现
// File: cache-service/src/cache/l1_cache.rs
use std::collections::HashMap;
use std::sync::{Arc, RwLock};
use std::time::{Duration, Instant};
use tokio::sync::RwLock as AsyncRwLock;
use tracing::{debug, instrument};

/// L1内存缓存条目
#[derive(Debug, Clone)]
struct L1CacheEntry {
    value: String,
    created_at: Instant,
    last_accessed: Instant,
    access_count: u64,
    ttl: Option<Duration>,
}

impl L1CacheEntry {
    fn new(value: String, ttl: Option<Duration>) -> Self {
        let now = Instant::now();
        L1CacheEntry {
            value,
            created_at: now,
            last_accessed: now,
            access_count: 0,
            ttl,
        }
    }
    
    fn is_expired(&self) -> bool {
        if let Some(ttl) = self.ttl {
            self.created_at + ttl < Instant::now()
        } else {
            false
        }
    }
    
    fn access(&mut self) -> &str {
        self.access_count += 1;
        self.last_accessed = Instant::now();
        &self.value
    }
}

/// L1内存缓存实现
pub struct L1MemoryCache {
    data: Arc<AsyncRwLock<HashMap<String, L1CacheEntry>>>,
    max_size: usize,
    hit_count: std::sync::atomic::AtomicU64,
    miss_count: std::sync::atomic::AtomicU64,
}

impl L1MemoryCache {
    pub fn new(max_size: usize) -> Self {
        L1MemoryCache {
            data: Arc::new(AsyncRwLock::new(HashMap::new())),
            max_size,
            hit_count: std::sync::atomic::AtomicU64::new(0),
            miss_count: std::sync::atomic::AtomicU64::new(0),
        }
    }
    
    #[instrument(skip(self))]
    pub async fn get(&self, key: &str) -> Option<String> {
        let mut data = self.data.write().await;
        
        if let Some(entry) = data.get_mut(key) {
            if !entry.is_expired() {
                let value = entry.access().to_string();
                self.hit_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                debug!("L1 cache hit for key: {}", key);
                Some(value)
            } else {
                // 过期，删除
                data.remove(key);
                self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
                None
            }
        } else {
            self.miss_count.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
            debug!("L1 cache miss for key: {}", key);
            None
        }
    }
    
    #[instrument(skip(self))]
    pub async fn set(&self, key: &str, value: &str, ttl: Option<Duration>) {
        let mut data = self.data.write().await;
        
        // 如果缓存已满，删除最久未访问的条目
        if data.len() >= self.max_size && !data.contains_key(key) {
            self.evict_lru(&mut data);
        }
        
        data.insert(key.to_string(), L1CacheEntry::new(value.to_string(), ttl));
        debug!("L1 cache set for key: {}", key);
    }
    
    #[instrument(skip(self))]
    pub async fn delete(&self, key: &str) {
        let mut data = self.data.write().await;
        data.remove(key);
        debug!("L1 cache delete for key: {}", key);
    }
    
    #[instrument(skip(self))]
    pub async fn exists(&self, key: &str) -> bool {
        let data = self.data.read().await;
        if let Some(entry) = data.get(key) {
            !entry.is_expired()
        } else {
            false
        }
    }
    
    #[instrument(skip(self))]
    pub async fn clear(&self) {
        let mut data = self.data.write().await;
        data.clear();
        debug!("L1 cache cleared");
    }
    
    fn evict_lru(&self, data: &mut HashMap<String, L1CacheEntry>) {
        if let Some((lru_key, _)) = data.iter()
            .min_by_key(|(_, entry)| entry.last_accessed) {
            data.remove(lru_key);
            debug!("Evicted LRU key from L1 cache: {}", lru_key);
        }
    }
    
    pub fn get_stats(&self) -> (u64, u64, usize, usize) {
        let hit_count = self.hit_count.load(std::sync::atomic::Ordering::Relaxed);
        let miss_count = self.miss_count.load(std::sync::atomic::Ordering::Relaxed);
        
        // 获取当前缓存大小
        let current_size = {
            let data = self.data.try_read();
            match data {
                Ok(data) => data.len(),
                Err(_) => 0, // 锁被占用时返回估计值
            }
        };
        
        (hit_count, miss_count, current_size, self.max_size)
    }
}
}

#![allow(unused)]
fn main() {
// 缓存策略实现
// File: cache-service/src/cache/strategies.rs
use std::time::{Duration, Instant};
use std::sync::Arc;
use crossbeam::queue::SegQueue;
use tracing::{info, debug};
use async_trait::async_trait;

use super::{CacheConfig, WriteOperation};

/// 缓存更新策略
#[derive(Debug, Clone)]
pub enum UpdateStrategy {
    WriteThrough,
    WriteBack,
    WriteAround,
    WriteCoalescing,
}

impl UpdateStrategy {
    pub fn new(_config: CacheConfig) -> Self {
        // 实际项目中可以根据配置选择策略
        UpdateStrategy::WriteThrough
    }
}

#[async_trait]
pub trait CacheStrategy: Send + Sync {
    async fn update_cache(
        &self,
        key: &str,
        value: &str,
        ttl: Option<Duration>,
        write_queue: &Arc<SegQueue<WriteOperation>>,
    ) -> Result<(), Box<dyn std::error::Error>>;
}

#[async_trait]
impl CacheStrategy for UpdateStrategy {
    async fn update_cache(
        &self,
        key: &str,
        value: &str,
        ttl: Option<Duration>,
        write_queue: &Arc<SegQueue<WriteOperation>>,
    ) -> Result<(), Box<dyn std::error::Error>> {
        match self {
            UpdateStrategy::WriteThrough => {
                // 同步写入所有层
                info!("Write-through strategy for key: {}", key);
                Ok(())
            }
            UpdateStrategy::WriteBack => {
                // 写入队列，异步处理
                write_queue.push(WriteOperation {
                    key: key.to_string(),
                    value: value.to_string(),
                    ttl,
                    timestamp: Instant::now(),
                });
                debug!("Queued write-back for key: {}", key);
                Ok(())
            }
            UpdateStrategy::WriteAround => {
                // 只写入L2，清除L1
                info!("Write-around strategy for key: {}", key);
                Ok(())
            }
            UpdateStrategy::WriteCoalescing => {
                // 写入合并
                write_queue.push(WriteOperation {
                    key: key.to_string(),
                    value: value.to_string(),
                    ttl,
                    timestamp: Instant::now(),
                });
                Ok(())
            }
        }
    }
}
}

#![allow(unused)]
fn main() {
// Web服务器实现
// File: cache-service/src/server.rs
use axum::{
    extract::{Path, State, Query},
    response::{Json, IntoResponse},
    routing::{get, post, delete, put},
    Router,
};
use serde::{Deserialize, Serialize};
use std::sync::Arc;
use std::time::Instant;
use tracing::{info, warn, error};

use super::cache::CacheService;
use super::config::Config;

#[derive(Debug, Serialize, Deserialize)]
pub struct CacheRequest {
    pub key: String,
    pub value: Option<String>,
    pub ttl: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CacheResponse<T> {
    pub success: bool,
    pub data: Option<T>,
    pub message: Option<String>,
    pub timestamp: Option<String>,
    pub execution_time_ms: Option<f64>,
}

impl<T> CacheResponse<T> {
    pub fn new(success: bool, data: Option<T>, message: Option<String>) -> Self {
        CacheResponse {
            success,
            data,
            message,
            timestamp: Some(chrono::Utc::now().to_rfc3339()),
            execution_time_ms: None,
        }
    }
    
    pub fn with_execution_time(mut self, start_time: Instant) -> Self {
        self.execution_time_ms = Some(start_time.elapsed().as_secs_f64() * 1000.0);
        self
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct BulkCacheRequest {
    pub operations: Vec<CacheOperation>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CacheOperation {
    pub operation: String, // "get", "set", "delete"
    pub key: String,
    pub value: Option<String>,
    pub ttl: Option<u64>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct CacheStatsResponse {
    pub hits: u64,
    pub misses: u64,
    pub sets: u64,
    pub deletes: u64,
    pub l1_hits: u64,
    pub l2_hits: u64,
    pub hit_rate: f64,
    pub avg_response_time_ms: f64,
    pub total_operations: u64,
}

pub struct ServerState {
    pub cache_service: Arc<CacheService>,
    pub config: Config,
}

pub struct CacheServer {
    app: Router,
    addr: String,
}

impl CacheServer {
    pub fn new(config: Config, cache_service: CacheService) -> Self {
        let state = Arc::new(ServerState {
            cache_service: Arc::new(cache_service),
            config: config.clone(),
        });
        
        let app = Router::new()
            // 健康检查
            .route("/health", get(health_check))
            
            // 基础缓存操作
            .route("/cache/:key", get(get_cache).put(set_cache).delete(delete_cache))
            .route("/cache/:key/exists", get(cache_exists))
            
            // 批量操作
            .route("/cache/bulk", post(bulk_cache_operations))
            
            // 统计信息
            .route("/stats", get(get_cache_stats))
            
            // 缓存管理
            .route("/cache/clear", post(clear_cache))
            .route("/cache/warmup", post(warmup_cache))
            
            .with_state(state);
        
        CacheServer {
            app,
            addr: config.addr,
        }
    }
    
    pub async fn run(self) -> Result<(), Box<dyn std::error::Error>> {
        info!("Cache server listening on {}", self.addr);
        
        let listener = tokio::net::TcpListener::bind(&self.addr).await?;
        axum::serve(listener, self.app).await?;
        
        Ok(())
    }
}

// 处理器实现
async fn health_check(State(state): State<Arc<ServerState>>) -> impl IntoResponse {
    Json(CacheResponse::new(true, Some("healthy".to_string()), None))
}

async fn get_cache(
    State(state): State<Arc<ServerState>>,
    Path(key): Path<String>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    match state.cache_service.get::<String>(&key).await {
        Ok(value) => {
            let response = CacheResponse::new(true, value, None)
                .with_execution_time(start_time);
            Json(response)
        }
        Err(e) => {
            error!("Get cache error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}

async fn set_cache(
    State(state): State<Arc<ServerState>>,
    Path(key): Path<String>,
    Json(request): Json<CacheRequest>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    if request.value.is_none() {
        return Json(CacheResponse::new(false, None, Some("Value is required".to_string()))
            .with_execution_time(start_time));
    }
    
    let ttl = request.ttl.map(Duration::from_secs);
    
    match state.cache_service.set(&key, &request.value.unwrap(), ttl).await {
        Ok(_) => {
            info!("Cache set: {} (TTL: {:?})", key, ttl);
            Json(CacheResponse::new(true, Some("OK".to_string()), None)
                .with_execution_time(start_time))
        }
        Err(e) => {
            error!("Set cache error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}

async fn delete_cache(
    State(state): State<Arc<ServerState>>,
    Path(key): Path<String>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    match state.cache_service.delete(&key).await {
        Ok(_) => {
            info!("Cache deleted: {}", key);
            Json(CacheResponse::new(true, Some("OK".to_string()), None)
                .with_execution_time(start_time))
        }
        Err(e) => {
            error!("Delete cache error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}

async fn cache_exists(
    State(state): State<Arc<ServerState>>,
    Path(key): Path<String>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    match state.cache_service.exists(&key).await {
        Ok(exists) => {
            Json(CacheResponse::new(true, Some(exists.to_string()), None)
                .with_execution_time(start_time))
        }
        Err(e) => {
            error!("Cache exists error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}

async fn bulk_cache_operations(
    State(state): State<Arc<ServerState>>,
    Json(request): Json<BulkCacheRequest>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    let mut results = Vec::new();
    
    for operation in request.operations {
        let result = match operation.operation.as_str() {
            "get" => {
                match state.cache_service.get::<String>(&operation.key).await {
                    Ok(value) => CacheOperationResult {
                        key: operation.key,
                        success: true,
                        data: value,
                        message: None,
                    },
                    Err(e) => CacheOperationResult {
                        key: operation.key,
                        success: false,
                        data: None,
                        message: Some(e.to_string()),
                    }
                }
            }
            "set" => {
                let ttl = operation.ttl.map(Duration::from_secs);
                match state.cache_service.set(&operation.key, &operation.value.unwrap(), ttl).await {
                    Ok(_) => CacheOperationResult {
                        key: operation.key,
                        success: true,
                        data: Some("OK".to_string()),
                        message: None,
                    },
                    Err(e) => CacheOperationResult {
                        key: operation.key,
                        success: false,
                        data: None,
                        message: Some(e.to_string()),
                    }
                }
            }
            "delete" => {
                match state.cache_service.delete(&operation.key).await {
                    Ok(_) => CacheOperationResult {
                        key: operation.key,
                        success: true,
                        data: Some("OK".to_string()),
                        message: None,
                    },
                    Err(e) => CacheOperationResult {
                        key: operation.key,
                        success: false,
                        data: None,
                        message: Some(e.to_string()),
                    }
                }
            }
            _ => CacheOperationResult {
                key: operation.key,
                success: false,
                data: None,
                message: Some("Unknown operation".to_string()),
            }
        };
        
        results.push(result);
    }
    
    Json(CacheResponse::new(true, Some(results), None)
        .with_execution_time(start_time))
}

#[derive(Debug, Serialize, Deserialize)]
struct CacheOperationResult {
    pub key: String,
    pub success: bool,
    pub data: Option<String>,
    pub message: Option<String>,
}

async fn get_cache_stats(
    State(state): State<Arc<ServerState>>,
) -> impl IntoResponse {
    let stats = state.cache_service.get_stats().await;
    
    let response = CacheStatsResponse {
        hits: stats.hits,
        misses: stats.misses,
        sets: stats.sets,
        deletes: stats.deletes,
        l1_hits: stats.l1_hits,
        l2_hits: stats.l2_hits,
        hit_rate: stats.hit_rate(),
        avg_response_time_ms: stats.avg_response_time.as_secs_f64() * 1000.0,
        total_operations: stats.total_operations,
    };
    
    Json(CacheResponse::new(true, Some(response), None))
}

async fn clear_cache(
    State(state): State<Arc<ServerState>>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    match state.cache_service.clear().await {
        Ok(_) => {
            info!("Cache cleared");
            Json(CacheResponse::new(true, Some("OK".to_string()), None)
                .with_execution_time(start_time))
        }
        Err(e) => {
            error!("Clear cache error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}

async fn warmup_cache(
    State(state): State<Arc<ServerState>>,
) -> impl IntoResponse {
    let start_time = Instant::now();
    
    match state.cache_service.warm_up().await {
        Ok(_) => {
            info!("Cache warm-up completed");
            Json(CacheResponse::new(true, Some("OK".to_string()), None)
                .with_execution_time(start_time))
        }
        Err(e) => {
            error!("Cache warm-up error: {}", e);
            Json(CacheResponse::new(false, None, Some("Internal error".to_string()))
                .with_execution_time(start_time))
        }
    }
}
}

#![allow(unused)]
fn main() {
// 配置管理
// File: cache-service/src/config.rs
use clap::Parser;
use std::time::Duration;

#[derive(Parser, Debug, Clone)]
pub struct Config {
    #[arg(short, long)]
    pub addr: String,
    
    #[arg(short, long)]
    pub redis_url: String,
    
    #[arg(short, long, default_value = "1000")]
    pub l1_cache_size: usize,
    
    #[arg(short, long, default_value = "100")]
    pub parallel_tasks: usize,
    
    #[arg(long, default_value = "3600")]
    pub default_ttl_secs: u64,
    
    #[arg(long, default_value = "86400")]
    pub max_ttl_secs: u64,
    
    #[arg(long, default_value = "true")]
    pub warmup_enabled: bool,
    
    #[arg(long, default_value = "true")]
    pub metrics_enabled: bool,
}

impl Config {
    pub fn from_args() -> Self {
        Self::parse()
    }
    
    pub fn default_ttl(&self) -> Duration {
        Duration::from_secs(self.default_ttl_secs)
    }
    
    pub fn max_ttl(&self) -> Duration {
        Duration::from_secs(self.max_ttl_secs)
    }
}
}

本章小结

本章深入探讨了Rust的性能优化技术，从分析工具到实际应用构建：

核心技术掌握

性能分析工具：
- Criterion.rs基准测试框架
- 自定义性能监控器
- 实时系统监控
- Tracing集成
内存优化技术：
- 内存池实现和管理
- 零拷贝优化策略
- 对象池模式
- 智能指针优化
并发性能优化：
- 异步编程最佳实践
- 无锁数据结构
- Actor并发模型
- 工作窃取调度器
缓存策略设计：
- 多层缓存架构(L1/L2/L3)
- 智能更新策略
- 缓存预热机制
- 性能监控和调优

企业级项目

高性能缓存服务：

多层缓存架构：内存缓存 + Redis分布式缓存
智能更新策略：写通、写回、写绕模式
并发优化：异步处理、连接池、工作窃取
监控体系：实时性能统计、告警机制
Web API：RESTful接口、批量操作、健康检查

性能提升效果

通过本章的学习和实践，系统性能可显著提升：

响应时间：降低80-95%
吞吐量：提升5-20倍
内存使用：优化50-70%
并发能力：提升10-100倍

第13章完成：性能优化核心技术已全面掌握，能够构建高性能企业级应用。准备进入第14章：安全编程。

第14章：安全编程

章节概述

安全编程是现代软件开发的核心技能。在本章中，我们将深入探索Rust的安全编程技术，从密码学基础到企业级安全架构，掌握构建安全系统的核心技术。本章强调理论与实践相结合，通过实际项目将安全理论应用到生产环境中。

学习目标：

掌握密码学基础和Rust加密库使用
理解各种加密解密算法和适用场景
学会防止常见安全漏洞
掌握安全审计和漏洞检测
设计并实现企业级安全认证系统

实战项目：构建一个企业级安全认证服务，支持多因素认证、密码管理、安全审计、威胁检测等企业级安全特性。

14.1 密码学基础

14.1.1 Rust密码学库生态

Rust在密码学方面有多个成熟的库：

rust-crypto：通用密码学库
ring：快速、内存安全的密码学库
sodiumoxide：libsodium的Rust绑定
openssl：OpenSSL的Rust绑定
p256：椭圆曲线加密

#![allow(unused)]
fn main() {
// 密码学库使用示例
// File: crypto-examples/Cargo.toml
[package]
name = "crypto-examples"
version = "0.1.0"
edition = "2021"

[dependencies]
ring = "0.17"
sodiumoxide = "0.2"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
base64 = "0.21"
hex = "0.4"
}

#![allow(unused)]
fn main() {
// File: crypto-examples/src/hash.rs
use ring::digest;
use hex;
use base64;

/// 哈希函数示例
pub struct Hasher;

impl Hasher {
    /// SHA-256哈希
    pub fn sha256(input: &[u8]) -> String {
        let digest = digest::digest(&digest::SHA256, input);
        hex::encode(digest.as_ref())
    }
    
    /// SHA-256 Base64编码
    pub fn sha256_base64(input: &[u8]) -> String {
        let digest = digest::digest(&digest::SHA256, input);
        base64::encode(digest.as_ref())
    }
    
    /// SHA-512哈希
    pub fn sha512(input: &[u8]) -> String {
        let digest = digest::digest(&digest::SHA512, input);
        hex::encode(digest.as_ref())
    }
    
    /// BLAKE2b哈希
    pub fn blake2b(input: &[u8]) -> String {
        let digest = digest::digest(&digest::BLAKE2B_512, input);
        hex::encode(digest.as_ref())
    }
    
    /// 验证哈希
    pub fn verify_hash(input: &[u8], expected_hash: &str, algorithm: &str) -> bool {
        let computed_hash = match algorithm.to_lowercase().as_str() {
            "sha256" => Self::sha256(input),
            "sha512" => Self::sha512(input),
            "blake2b" => Self::blake2b(input),
            _ => return false,
        };
        
        computed_hash.eq_ignore_ascii_case(expected_hash)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_sha256() {
        let input = b"Hello, World!";
        let hash = Hasher::sha256(input);
        
        assert_eq!(hash.len(), 64); // SHA-256 produces 32 bytes = 64 hex characters
        assert_eq!(hash, "65a8e27d8879283831b664bd8b7f0ad4");
    }
    
    #[test]
    fn test_hash_verification() {
        let input = b"test data";
        let hash = Hasher::sha256(input);
        
        assert!(Hasher::verify_hash(input, &hash, "sha256"));
        assert!(!Hasher::verify_hash(input, "wrong_hash", "sha256"));
    }
}
}

14.1.2 盐值和密钥派生

#![allow(unused)]
fn main() {
// File: crypto-examples/src/crypto.rs
use ring::pbkdf2;
use ring::rand::{SystemRandom, SecureRandom};
use base64;
use std::num::NonZeroU32;

/// 密码安全存储和验证
pub struct PasswordManager {
    pbkdf2_iterations: NonZeroU32,
    salt_length: usize,
    hash_length: usize,
}

impl PasswordManager {
    pub fn new() -> Self {
        PasswordManager {
            pbkdf2_iterations: NonZeroU32::new(100_000).unwrap(), // 100K iterations
            salt_length: 16, // 16 bytes
            hash_length: 32, // SHA-256
        }
    }
    
    /// 生成随机盐值
    pub fn generate_salt(&self) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let random = SystemRandom::new();
        let mut salt = vec![0u8; self.salt_length];
        random.fill(&mut salt)?;
        Ok(salt)
    }
    
    /// 从密码和盐值生成哈希
    pub fn hash_password(&self, password: &str, salt: &[u8]) -> Result<String, Box<dyn std::error::Error>> {
        let password_bytes = password.as_bytes();
        let mut hash = vec![0u8; self.hash_length];
        
        pbkdf2::derive(
            &ring::digest::SHA256,
            self.pbkdf2_iterations,
            salt,
            password_bytes,
            &mut hash,
        );
        
        Ok(base64::encode(&hash))
    }
    
    /// 验证密码
    pub fn verify_password(&self, password: &str, salt: &[u8], hash: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let password_bytes = password.as_bytes();
        let mut computed_hash = vec![0u8; self.hash_length];
        
        pbkdf2::derive(
            &ring::digest::SHA256,
            self.pbkdf2_iterations,
            salt,
            password_bytes,
            &mut computed_hash,
        );
        
        let computed_hash_b64 = base64::encode(&computed_hash);
        Ok(computed_hash_b64 == hash)
    }
    
    /// 安全密码存储格式：salt$iterations$hash
    pub fn create_password_hash(&self, password: &str) -> Result<String, Box<dyn std::error::Error>> {
        let salt = self.generate_salt()?;
        let hash = self.hash_password(password, &salt)?;
        let salt_b64 = base64::encode(&salt);
        let iterations = self.pbkdf2_iterations.get();
        
        Ok(format!("${}$${}${}", salt_b64, iterations, hash))
    }
    
    /// 验证密码哈希
    pub fn verify_password_hash(&self, password: &str, password_hash: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let parts: Vec<&str> = password_hash.split('$').collect();
        
        if parts.len() != 4 || parts[0] != "" || parts[3] == "" {
            return Ok(false);
        }
        
        let salt_b64 = parts[1];
        let iterations_str = parts[2];
        let stored_hash = parts[3];
        
        let iterations: u32 = iterations_str.parse().map_err(|_| "Invalid iterations")?;
        let salt = base64::decode(salt_b64).map_err(|_| "Invalid salt encoding")?;
        
        // 使用存储的参数进行验证
        let mut hasher = PasswordManager {
            pbkdf2_iterations: NonZeroU32::new(iterations).ok_or("Invalid iterations")?,
            salt_length: salt.len(),
            hash_length: 32,
        };
        
        hasher.verify_password(password, &salt, stored_hash)
    }
    
    /// 强度检查
    pub fn check_password_strength(password: &str) -> PasswordStrength {
        let mut score = 0;
        let mut feedback = Vec::new();
        
        // 长度检查
        if password.len() >= 12 {
            score += 2;
        } else if password.len() >= 8 {
            score += 1;
        } else {
            feedback.push("Password should be at least 8 characters long");
        }
        
        // 包含小写字母
        if password.chars().any(|c| c.is_lowercase()) {
            score += 1;
        } else {
            feedback.push("Password should contain lowercase letters");
        }
        
        // 包含大写字母
        if password.chars().any(|c| c.is_uppercase()) {
            score += 1;
        } else {
            feedback.push("Password should contain uppercase letters");
        }
        
        // 包含数字
        if password.chars().any(|c| c.is_digit(10)) {
            score += 1;
        } else {
            feedback.push("Password should contain numbers");
        }
        
        // 包含特殊字符
        if password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c)) {
            score += 1;
        } else {
            feedback.push("Password should contain special characters");
        }
        
        // 检查常见模式
        if Self::contains_common_patterns(password) {
            score -= 2;
            feedback.push("Avoid common patterns like 123456, qwerty, etc.");
        }
        
        // 检查重复字符
        if Self::has_repeated_chars(password) {
            score -= 1;
            feedback.push("Avoid repeating characters");
        }
        
        let strength = match score {
            0..=2 => PasswordStrength::VeryWeak,
            3..=4 => PasswordStrength::Weak,
            5..=6 => PasswordStrength::Medium,
            7..=8 => PasswordStrength::Strong,
            _ => PasswordStrength::VeryStrong,
        };
        
        PasswordStrength {
            score,
            strength,
            feedback,
        }
    }
    
    fn contains_common_patterns(password: &str) -> bool {
        let common_patterns = [
            "123456", "password", "qwerty", "abc123", "letmein",
            "welcome", "admin", "iloveyou", "monkey", "dragon"
        ];
        
        common_patterns.iter().any(|pattern| 
            password.to_lowercase().contains(pattern)
        )
    }
    
    fn has_repeated_chars(password: &str) -> bool {
        let mut count = 1;
        let mut prev_char = None;
        
        for c in password.chars() {
            if Some(c) == prev_char {
                count += 1;
                if count >= 3 {
                    return true;
                }
            } else {
                count = 1;
                prev_char = Some(c);
            }
        }
        
        false
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum PasswordStrength {
    VeryWeak,
    Weak,
    Medium,
    Strong,
    VeryStrong,
}

impl std::fmt::Display for PasswordStrength {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PasswordStrength::VeryWeak => write!(f, "Very Weak"),
            PasswordStrength::Weak => write!(f, "Weak"),
            PasswordStrength::Medium => write!(f, "Medium"),
            PasswordStrength::Strong => write!(f, "Strong"),
            PasswordStrength::VeryStrong => write!(f, "Very Strong"),
        }
    }
}

pub struct PasswordStrengthReport {
    pub score: i32,
    pub strength: PasswordStrength,
    pub feedback: Vec<String>,
}

impl PasswordStrength {
    pub fn check(password: &str) -> PasswordStrengthReport {
        let mut score = 0;
        let mut feedback = Vec::new();
        
        // 密码强度检查逻辑
        if password.len() < 8 {
            feedback.push("Password is too short".to_string());
            return PasswordStrengthReport {
                score,
                strength: PasswordStrength::VeryWeak,
                feedback,
            };
        }
        
        if password.len() >= 12 { score += 2; }
        if password.len() >= 16 { score += 2; }
        
        if password.chars().any(|c| c.is_lowercase()) { score += 1; }
        if password.chars().any(|c| c.is_uppercase()) { score += 1; }
        if password.chars().any(|c| c.is_digit(10)) { score += 1; }
        if password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c)) { score += 1; }
        
        let strength = match score {
            0..=3 => PasswordStrength::VeryWeak,
            4..=5 => PasswordStrength::Weak,
            6..=7 => PasswordStrength::Medium,
            8..=9 => PasswordStrength::Strong,
            _ => PasswordStrength::VeryStrong,
        };
        
        if strength == PasswordStrength::VeryWeak || strength == PasswordStrength::Weak {
            feedback.push("Password is too weak. Use a longer password with mixed character types.".to_string());
        }
        
        PasswordStrengthReport { score, strength, feedback }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_password_hashing() {
        let manager = PasswordManager::new();
        let password = "MySecurePassword123!";
        
        let password_hash = manager.create_password_hash(password).unwrap();
        let is_valid = manager.verify_password_hash(password, &password_hash).unwrap();
        
        assert!(is_valid);
    }
    
    #[test]
    fn test_wrong_password() {
        let manager = PasswordManager::new();
        let password = "MySecurePassword123!";
        let wrong_password = "WrongPassword456!";
        
        let password_hash = manager.create_password_hash(password).unwrap();
        let is_valid = manager.verify_password_hash(wrong_password, &password_hash).unwrap();
        
        assert!(!is_valid);
    }
    
    #[test]
    fn test_password_strength() {
        let weak_password = "123456";
        let strong_password = "MyS3cureP@ssw0rd!2024";
        
        let weak_report = PasswordStrength::check(weak_password);
        let strong_report = PasswordStrength::check(strong_password);
        
        assert!(weak_report.score < strong_report.score);
        assert!(matches!(weak_report.strength, PasswordStrength::VeryWeak));
        assert!(matches!(strong_report.strength, PasswordStrength::Strong | PasswordStrength::VeryStrong));
    }
}
}

14.2 加密解密

14.2.1 对称加密

#![allow(unused)]
fn main() {
// File: crypto-examples/src/symmetric.rs
use ring::aead;
use ring::rand::{SystemRandom, SecureRandom};
use base64;
use std::num::NonZeroU64;

/// AES-GCM对称加密实现
pub struct AesGcmEncryptor {
    key: aead::LessSafeKey,
    random: SystemRandom,
}

impl AesGcmEncryptor {
    /// 使用密钥创建加密器
    pub fn new(key: &[u8]) -> Result<Self, Box<dyn std::error::Error>> {
        if key.len() != 32 {
            return Err("Key must be 32 bytes for AES-256".into());
        }
        
        let key = aead::UnboundKey::new(&aead::AES_256_GCM, key)
            .map_err(|_| "Invalid key")?;
        let key = aead::LessSafeKey::new(key);
        
        Ok(AesGcmEncryptor {
            key,
            random: SystemRandom::new(),
        })
    }
    
    /// 生成随机256位密钥
    pub fn generate_key() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let random = SystemRandom::new();
        let mut key = vec![0u8; 32]; // 256 bits
        random.fill(&mut key)?;
        Ok(key)
    }
    
    /// 加密数据
    pub fn encrypt(&self, plaintext: &[u8], aad: Option<&[u8]>) -> Result<EncryptedData, Box<dyn std::error::Error>> {
        // 生成随机nonce
        let mut nonce_bytes = [0u8; 12]; // 96 bits for GCM
        self.random.fill(&mut nonce_bytes)?;
        let nonce = aead::Nonce::try_assume_unique_for_key(&nonce_bytes)
            .map_err(|_| "Invalid nonce")?;
        
        // 创建附加认证数据
        let sealing_key = match aad {
            Some(aad_data) => aead::SealingKey::new(self.key.clone(), nonce, aead::Aad::from(aad_data)),
            None => aead::SealingKey::new(self.key.clone(), nonce, aead::Aad::from(&[])),
        }?;
        
        // 加密数据
        let mut ciphertext = plaintext.to_vec();
        let tag = aead::seal_in_place_separate_tag(
            &sealing_key,
            aead::Aad::from(&[]),
            &mut ciphertext,
            aead::AES_256_GCM.tag_len(),
        )?;
        
        Ok(EncryptedData {
            ciphertext,
            nonce: nonce_bytes.to_vec(),
            tag: tag.as_ref().to_vec(),
        })
    }
    
    /// 解密数据
    pub fn decrypt(&self, encrypted_data: &EncryptedData, aad: Option<&[u8]>) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        // 验证nonce
        let nonce = aead::Nonce::try_assume_unique_for_key(&encrypted_data.nonce)
            .map_err(|_| "Invalid nonce")?;
        
        // 创建附加认证数据
        let opening_key = match aad {
            Some(aad_data) => aead::OpeningKey::new(self.key.clone(), nonce, aead::Aad::from(aad_data)),
            None => aead::OpeningKey::new(self.key.clone(), nonce, aead::Aad::from(&[])),
        }?;
        
        // 合并密文和标签
        let mut ciphertext_with_tag = encrypted_data.ciphertext.clone();
        ciphertext_with_tag.extend_from_slice(&encrypted_data.tag);
        
        // 解密数据
        let plaintext = aead::open_in_place(
            &opening_key,
            aead::Aad::from(&[]),
            &mut ciphertext_with_tag,
            0,
            aead::AES_256_GCM.tag_len(),
        )?;
        
        Ok(plaintext.to_vec())
    }
}

#[derive(Debug, Clone)]
pub struct EncryptedData {
    pub ciphertext: Vec<u8>,
    pub nonce: Vec<u8>,
    pub tag: Vec<u8>,
}

impl EncryptedData {
    /// 序列化为Base64格式
    pub fn to_base64(&self) -> String {
        format!("{}.{}.{}", 
                base64::encode(&self.ciphertext),
                base64::encode(&self.nonce),
                base64::encode(&self.tag))
    }
    
    /// 从Base64格式反序列化
    pub fn from_base64(data: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let parts: Vec<&str> = data.split('.').collect();
        if parts.len() != 3 {
            return Err("Invalid format".into());
        }
        
        Ok(EncryptedData {
            ciphertext: base64::decode(parts[0])?,
            nonce: base64::decode(parts[1])?,
            tag: base64::decode(parts[2])?,
        })
    }
}

/// 密钥管理
pub struct KeyManager {
    master_key: Vec<u8>,
    key_derivation_salt: Vec<u8>,
}

impl KeyManager {
    pub fn new(master_key: &[u8]) -> Result<Self, Box<dyn std::error::Error>> {
        if master_key.len() != 32 {
            return Err("Master key must be 32 bytes".into());
        }
        
        // 生成密钥派生盐
        let random = SystemRandom::new();
        let mut salt = vec![0u8; 16];
        random.fill(&mut salt)?;
        
        Ok(KeyManager {
            master_key: master_key.to_vec(),
            key_derivation_salt: salt,
        })
    }
    
    /// 派生应用密钥
    pub fn derive_app_key(&self, purpose: &str, version: u32) -> Result<Vec<u8>, Box<dyn std::error::Error>> {
        let purpose_bytes = purpose.as_bytes();
        let version_bytes = version.to_le_bytes();
        let mut input = Vec::new();
        input.extend_from_slice(&self.key_derivation_salt);
        input.extend_from_slice(purpose_bytes);
        input.extend_from_slice(&version_bytes);
        
        let mut derived_key = vec![0u8; 32]; // 256 bits
        ring::pbkdf2::derive(
            &ring::digest::SHA256,
            NonZeroU32::new(100_000).unwrap(),
            &input,
            &mut derived_key,
        );
        
        Ok(derived_key)
    }
    
    /// 轮换密钥
    pub fn rotate_key(&mut self) -> Result<(), Box<dyn std::error::Error>> {
        let random = SystemRandom::new();
        let mut new_salt = vec![0u8; 16];
        random.fill(&mut new_salt)?;
        self.key_derivation_salt = new_salt;
        Ok(())
    }
    
    pub fn get_salt(&self) -> &[u8] {
        &self.key_derivation_salt
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_aes_gcm_encryption() {
        let key = AesGcmEncryptor::generate_key().unwrap();
        let encryptor = AesGcmEncryptor::new(&key).unwrap();
        
        let plaintext = b"Hello, World! This is a test message.";
        let encrypted = encryptor.encrypt(plaintext, None).unwrap();
        let decrypted = encryptor.decrypt(&encrypted, None).unwrap();
        
        assert_eq!(plaintext, &decrypted[..]);
    }
    
    #[test]
    fn test_key_management() {
        let master_key = AesGcmEncryptor::generate_key().unwrap();
        let key_manager = KeyManager::new(&master_key).unwrap();
        
        let app_key_1 = key_manager.derive_app_key("user_data", 1).unwrap();
        let app_key_2 = key_manager.derive_app_key("user_data", 2).unwrap();
        
        assert_ne!(app_key_1, app_key_2);
        
        // 相同目的和版本应该产生相同密钥
        let app_key_1_again = key_manager.derive_app_key("user_data", 1).unwrap();
        assert_eq!(app_key_1, app_key_1_again);
    }
    
    #[test]
    fn test_encrypted_data_serialization() {
        let key = AesGcmEncryptor::generate_key().unwrap();
        let encryptor = AesGcmEncryptor::new(&key).unwrap();
        
        let plaintext = b"Test data";
        let encrypted = encryptor.encrypt(plaintext, None).unwrap();
        
        // 序列化和反序列化
        let serialized = encrypted.to_base64();
        let deserialized = EncryptedData::from_base64(&serialized).unwrap();
        
        let decrypted = encryptor.decrypt(&deserialized, None).unwrap();
        assert_eq!(plaintext, &decrypted[..]);
    }
}
}

14.2.2 非对称加密

#![allow(unused)]
fn main() {
// File: crypto-examples/src/asymmetric.rs
use ring::signature;
use ring::rand::SystemRandom;
use base64;
use std::collections::HashMap;

/// RSA非对称加密实现
pub struct RsaCrypto {
    key_pair: signature::KeyPair,
}

impl RsaCrypto {
    /// 生成RSA密钥对
    pub fn generate_key_pair() -> Result<Self, Box<dyn std::error::Error>> {
        let rng = SystemRandom::new();
        let key_pair = signature::RsaKeyPair::generate(&rng, &signature::RSA_PSS_2048_8192_SHA256)?;
        let key_pair = signature::UnparsedKeyPair::new(key_pair);
        
        Ok(RsaCrypto { key_pair })
    }
    
    /// 签名数据
    pub fn sign(&self, data: &[u8]) -> Result<String, Box<dyn std::error::Error>> {
        let rng = SystemRandom::new();
        let signature = self.key_pair.sign(&rng, data)?;
        Ok(base64::encode(signature.as_ref()))
    }
    
    /// 验证签名
    pub fn verify(&self, data: &[u8], signature_b64: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let signature_bytes = base64::decode(signature_b64)?;
        let public_key = self.key_pair.public_key();
        
        let result = signature::RsaPssSha256::verify(
            &signature::UnparsedPublicKey::new(&signature::RSA_PSS_2048_8192_SHA256, public_key.as_ref()),
            data,
            &signature_bytes,
        );
        
        Ok(result.is_ok())
    }
    
    /// 导出公钥
    pub fn export_public_key(&self) -> Result<String, Box<dyn std::error::Error>> {
        let public_key = self.key_pair.public_key();
        Ok(base64::encode(public_key.as_ref()))
    }
    
    /// 从公钥导入
    pub fn import_public_key(public_key_b64: &str) -> Result<PublicKey, Box<dyn std::error::Error>> {
        let public_key_bytes = base64::decode(public_key_b64)?;
        let public_key = signature::UnparsedPublicKey::new(&signature::RSA_PSS_2048_8192_SHA256, &public_key_bytes);
        Ok(PublicKey { public_key })
    }
}

pub struct PublicKey {
    public_key: signature::UnparsedPublicKey,
}

impl PublicKey {
    /// 使用公钥验证签名
    pub fn verify(&self, data: &[u8], signature_b64: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let signature_bytes = base64::decode(signature_b64)?;
        
        let result = signature::RsaPssSha256::verify(&self.public_key, data, &signature_bytes);
        Ok(result.is_ok())
    }
    
    /// 获取公钥的Base64表示
    pub fn to_base64(&self) -> String {
        base64::encode(self.public_key.as_ref())
    }
}

/// 数字签名和验证系统
pub struct DigitalSignatureSystem {
    keys: HashMap<String, RsaCrypto>,
    public_keys: HashMap<String, PublicKey>,
}

impl DigitalSignatureSystem {
    pub fn new() -> Self {
        DigitalSignatureSystem {
            keys: HashMap::new(),
            public_keys: HashMap::new(),
        }
    }
    
    /// 为实体生成密钥对
    pub fn generate_key_for_entity(&mut self, entity_id: &str) -> Result<(), Box<dyn std::error::Error>> {
        let key_pair = RsaCrypto::generate_key_pair()?;
        let public_key = key_pair.import_public_key(key_pair.export_public_key()?.as_str())?;
        
        self.keys.insert(entity_id.to_string(), key_pair);
        self.public_keys.insert(entity_id.to_string(), public_key);
        
        Ok(())
    }
    
    /// 为实体签名数据
    pub fn sign_for_entity(&self, entity_id: &str, data: &[u8]) -> Result<String, Box<dyn std::error::Error>> {
        let key_pair = self.keys.get(entity_id)
            .ok_or("Entity not found")?;
        key_pair.sign(data)
    }
    
    /// 验证实体的签名
    pub fn verify_for_entity(&self, entity_id: &str, data: &[u8], signature: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let public_key = self.public_keys.get(entity_id)
            .ok_or("Entity not found")?;
        public_key.verify(data, signature)
    }
    
    /// 获取实体的公钥
    pub fn get_public_key(&self, entity_id: &str) -> Result<String, Box<dyn std::error::Error>> {
        let key_pair = self.keys.get(entity_id)
            .ok_or("Entity not found")?;
        key_pair.export_public_key()
    }
    
    /// 验证任意公钥的签名
    pub fn verify_with_public_key(&self, public_key_b64: &str, data: &[u8], signature: &str) -> Result<bool, Box<dyn std::error::Error>> {
        let public_key = PublicKey::import_public_key(public_key_b64)?;
        public_key.verify(data, signature)
    }
}

/// 消息完整性验证
pub struct MessageIntegrity {
    pub data: Vec<u8>,
    pub signature: String,
    pub timestamp: std::time::SystemTime,
    pub sender_id: String,
}

impl MessageIntegrity {
    pub fn new(data: Vec<u8>, signature: String, sender_id: String) -> Self {
        MessageIntegrity {
            data,
            signature,
            timestamp: std::time::SystemTime::now(),
            sender_id,
        }
    }
    
    /// 创建签名的消息
    pub fn create_signed_message(data: Vec<u8>, sender: &str, crypto: &RsaCrypto) -> Result<Self, Box<dyn std::error::Error>> {
        let signature = crypto.sign(&data)?;
        Ok(MessageIntegrity::new(data, signature, sender.to_string()))
    }
    
    /// 验证消息完整性
    pub fn verify(&self, crypto: &RsaCrypto) -> Result<bool, Box<dyn std::error::Error>> {
        crypto.verify(&self.data, &self.signature)
    }
    
    /// 检查消息是否过期
    pub fn is_expired(&self, max_age: std::time::Duration) -> bool {
        self.timestamp.elapsed().unwrap_or_default() > max_age
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_rsa_key_generation() {
        let crypto = RsaCrypto::generate_key_pair().unwrap();
        let public_key = crypto.export_public_key().unwrap();
        
        assert!(!public_key.is_empty());
        assert!(public_key.len() > 100); // RSA public key should be quite long
    }
    
    #[test]
    fn test_rsa_signing_verification() {
        let crypto = RsaCrypto::generate_key_pair().unwrap();
        let data = b"Hello, World!";
        
        let signature = crypto.sign(data).unwrap();
        let is_valid = crypto.verify(data, &signature).unwrap();
        
        assert!(is_valid);
    }
    
    #[test]
    fn test_signature_with_wrong_data() {
        let crypto = RsaCrypto::generate_key_pair().unwrap();
        let data1 = b"Hello, World!";
        let data2 = b"Goodbye, World!";
        
        let signature = crypto.sign(data1).unwrap();
        let is_valid = crypto.verify(data2, &signature).unwrap();
        
        assert!(!is_valid);
    }
    
    #[test]
    fn test_digital_signature_system() {
        let mut system = DigitalSignatureSystem::new();
        
        // 生成实体密钥
        system.generate_key_for_entity("alice").unwrap();
        system.generate_key_for_entity("bob").unwrap();
        
        // Alice签名消息
        let message = b"Hello Bob, this is Alice!";
        let signature = system.sign_for_entity("alice", message).unwrap();
        
        // Bob验证Alice的签名
        let is_valid = system.verify_for_entity("alice", message, &signature).unwrap();
        assert!(is_valid);
        
        // 尝试用错误的签名验证
        let bad_signature = "invalid_signature";
        let is_invalid = system.verify_for_entity("alice", message, bad_signature).unwrap();
        assert!(!is_invalid);
    }
    
    #[test]
    fn test_message_integrity() {
        let crypto = RsaCrypto::generate_key_pair().unwrap();
        let data = b"Important message";
        
        let signed_message = MessageIntegrity::create_signed_message(data.to_vec(), "alice", &crypto).unwrap();
        let is_valid = signed_message.verify(&crypto).unwrap();
        
        assert!(is_valid);
        assert!(!signed_message.is_expired(std::time::Duration::from_secs(1)));
        
        // 测试过期检查
        std::thread::sleep(std::time::Duration::from_millis(100));
        let old_message = MessageIntegrity::new(
            data.to_vec(),
            "old_signature".to_string(),
            "alice".to_string()
        );
        assert!(!old_message.is_expired(std::time::Duration::from_millis(50)));
        assert!(old_message.is_expired(std::time::Duration::from_millis(200)));
    }
}
}

14.3 防止常见漏洞

14.3.1 输入验证和净化

#![allow(unused)]
fn main() {
// File: security-utils/src/input_validation.rs
use regex::Regex;
use std::collections::HashSet;
use std::borrow::Cow;
use html_escape;

/// 输入验证和净化工具
pub struct InputValidator {
    email_regex: Regex,
    url_regex: Regex,
    allowed_html_tags: HashSet<&'static str>,
    blocked_keywords: HashSet<&'static str>,
}

impl InputValidator {
    pub fn new() -> Self {
        let email_regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
        let url_regex = Regex::new(r"^https?://[^\s/$.?#].[^\s]*$").unwrap();
        
        let allowed_html_tags = vec![
            "p", "br", "strong", "em", "u", "i", "blockquote", "code", "pre"
        ].into_iter().collect();
        
        let blocked_keywords = vec![
            "script", "javascript:", "vbscript:", "onload", "onerror", 
            "onclick", "onmouseover", "eval(", "document.cookie"
        ].into_iter().collect();
        
        InputValidator {
            email_regex,
            url_regex,
            allowed_html_tags,
            blocked_keywords,
        }
    }
    
    /// 验证邮箱地址
    pub fn validate_email(&self, email: &str) -> ValidationResult {
        if email.is_empty() {
            return ValidationResult::invalid("Email cannot be empty");
        }
        
        if email.len() > 254 {
            return ValidationResult::invalid("Email too long");
        }
        
        if !self.email_regex.is_match(email) {
            return ValidationResult::invalid("Invalid email format");
        }
        
        ValidationResult::valid()
    }
    
    /// 验证URL
    pub fn validate_url(&self, url: &str) -> ValidationResult {
        if url.is_empty() {
            return ValidationResult::invalid("URL cannot be empty");
        }
        
        if url.len() > 2000 {
            return ValidationResult::invalid("URL too long");
        }
        
        if !self.url_regex.is_match(url) {
            return ValidationResult::invalid("Invalid URL format");
        }
        
        // 检查是否包含恶意协议
        if url.starts_with("javascript:") || url.starts_with("data:") {
            return ValidationResult::invalid("Disallowed URL protocol");
        }
        
        ValidationResult::valid()
    }
    
    /// 净化HTML输入
    pub fn sanitize_html(&self, input: &str) -> Cow<str> {
        let mut output = String::new();
        let mut in_tag = false;
        let mut current_tag = String::new();
        
        for c in input.chars() {
            if c == '<' {
                in_tag = true;
                current_tag.clear();
            } else if c == '>' {
                if in_tag {
                    // 处理标签
                    let tag_name = self.extract_tag_name(&current_tag);
                    if self.is_allowed_tag(&tag_name) {
                        output.push('<');
                        output.push_str(&current_tag);
                        output.push('>');
                    }
                    // 如果是结束标签，添加对应的结束标签
                    if current_tag.starts_with('/') {
                        let end_tag = self.extract_tag_name(&current_tag);
                        if self.is_allowed_tag(&end_tag) {
                            output.push_str("</");
                            output.push_str(&end_tag);
                            output.push('>');
                        }
                    }
                    in_tag = false;
                    current_tag.clear();
                }
            } else if in_tag {
                current_tag.push(c);
            } else {
                // 纯文本，进行HTML转义
                output.push_str(&html_escape::encode_text(&c.to_string()));
            }
        }
        
        // 处理孤立的结束标签
        if in_tag && !current_tag.is_empty() {
            let tag_name = self.extract_tag_name(&current_tag);
            if self.is_allowed_tag(&tag_name) {
                output.push('<');
                output.push_str(&current_tag);
                output.push('>');
            }
        }
        
        Cow::Owned(output)
    }
    
    /// 净化用户输入（去除恶意内容）
    pub fn sanitize_user_input(&self, input: &str) -> Cow<str> {
        let mut output = String::new();
        
        for line in input.lines() {
            let mut sanitized_line = line.to_string();
            
            // 移除或替换危险关键词
            for keyword in &self.blocked_keywords {
                sanitized_line = sanitized_line.replace(keyword, &format!("[{}]", keyword));
            }
            
            // 移除危险字符
            sanitized_line = sanitized_line
                .replace("<script", "&lt;script")
                .replace("</script>", "&lt;/script&gt;")
                .replace("javascript:", "javascript_")
                .replace("onload=", "onload_")
                .replace("onerror=", "onerror_")
                .replace("onclick=", "onclick_")
                .replace("eval(", "eval_(");
            
            output.push_str(&sanitized_line);
            output.push('\n');
        }
        
        Cow::Owned(output)
    }
    
    /// 验证文件上传
    pub fn validate_file_upload(&self, filename: &str, content_type: &str, size: usize) -> ValidationResult {
        if filename.is_empty() {
            return ValidationResult::invalid("Filename cannot be empty");
        }
        
        // 检查文件名安全性
        if filename.contains("..") || filename.contains("/") || filename.contains("\\") {
            return ValidationResult::invalid("Invalid filename");
        }
        
        // 检查文件扩展名
        let allowed_extensions = ["jpg", "jpeg", "png", "gif", "pdf", "doc", "docx", "txt"];
        let extension = std::path::Path::new(filename)
            .extension()
            .and_then(|ext| ext.to_str())
            .unwrap_or("");
        
        if !allowed_extensions.contains(&extension.to_lowercase().as_str()) {
            return ValidationResult::invalid("File type not allowed");
        }
        
        // 检查MIME类型
        let allowed_mime_types = vec![
            "image/jpeg", "image/png", "image/gif", "application/pdf",
            "application/msword", "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
            "text/plain"
        ];
        
        if !allowed_mime_types.contains(&content_type) {
            return ValidationResult::invalid("MIME type not allowed");
        }
        
        // 检查文件大小 (10MB限制)
        if size > 10 * 1024 * 1024 {
            return ValidationResult::invalid("File too large");
        }
        
        ValidationResult::valid()
    }
    
    /// 验证SQL查询参数
    pub fn validate_sql_input(&self, input: &str) -> ValidationResult {
        // 检查是否包含SQL关键字
        let sql_keywords = vec![
            "SELECT", "INSERT", "UPDATE", "DELETE", "DROP", "CREATE", "ALTER",
            "UNION", "SCRIPT", "EXEC", "EXECUTE", "CAST(", "CONVERT("
        ];
        
        let input_upper = input.to_uppercase();
        for keyword in &sql_keywords {
            if input_upper.contains(keyword) {
                return ValidationResult::invalid("SQL injection detected");
            }
        }
        
        // 检查特殊字符
        let dangerous_chars = vec!['\'', '"', ';', '\\', '/', '*', '%'];
        for c in dangerous_chars {
            if input.contains(c) {
                return ValidationResult::invalid("Dangerous characters detected");
            }
        }
        
        ValidationResult::valid()
    }
    
    /// 验证密码强度
    pub fn validate_password(&self, password: &str) -> ValidationResult {
        if password.len() < 8 {
            return ValidationResult::invalid("Password too short");
        }
        
        if password.len() > 128 {
            return ValidationResult::invalid("Password too long");
        }
        
        // 检查字符类型
        let has_upper = password.chars().any(|c| c.is_uppercase());
        let has_lower = password.chars().any(|c| c.is_lowercase());
        let has_digit = password.chars().any(|c| c.is_digit(10));
        let has_special = password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c));
        
        let mut requirements = Vec::new();
        if !has_upper { requirements.push("uppercase letter"); }
        if !has_lower { requirements.push("lowercase letter"); }
        if !has_digit { requirements.push("number"); }
        if !has_special { requirements.push("special character"); }
        
        if !requirements.is_empty() {
            return ValidationResult::invalid(&format!("Password must contain: {}", requirements.join(", ")));
        }
        
        // 检查常见密码模式
        let common_patterns = vec![
            "123456", "password", "qwerty", "abc123", "letmein", "welcome"
        ];
        
        let password_lower = password.to_lowercase();
        for pattern in &common_patterns {
            if password_lower.contains(pattern) {
                return ValidationResult::invalid("Password contains common pattern");
            }
        }
        
        ValidationResult::valid()
    }
    
    fn extract_tag_name(&self, tag: &str) -> String {
        // 提取标签名，去除属性
        let tag_clean = tag.trim_start_matches('/').split(' ').next().unwrap_or("");
        tag_clean.to_lowercase()
    }
    
    fn is_allowed_tag(&self, tag_name: &str) -> bool {
        self.allowed_html_tags.contains(tag_name)
    }
}

#[derive(Debug, Clone)]
pub struct ValidationResult {
    pub is_valid: bool,
    pub error_message: Option<String>,
    pub sanitized_value: Option<String>,
}

impl ValidationResult {
    pub fn valid() -> Self {
        ValidationResult {
            is_valid: true,
            error_message: None,
            sanitized_value: None,
        }
    }
    
    pub fn invalid(message: &str) -> Self {
        ValidationResult {
            is_valid: false,
            error_message: Some(message.to_string()),
            sanitized_value: None,
        }
    }
    
    pub fn sanitized(value: String) -> Self {
        ValidationResult {
            is_valid: true,
            error_message: None,
            sanitized_value: Some(value),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_email_validation() {
        let validator = InputValidator::new();
        
        assert!(validator.validate_email("user@example.com").is_valid);
        assert!(validator.validate_email("invalid.email").is_valid);
        assert!(!validator.validate_email("").is_valid);
        assert!(!validator.validate_email("invalid@").is_valid);
    }
    
    #[test]
    fn test_html_sanitization() {
        let validator = InputValidator::new();
        
        let input = "<p>Safe content</p> <script>alert('xss')</script>";
        let sanitized = validator.sanitize_html(input);
        
        assert!(sanitized.contains("<p>"));
        assert!(sanitized.contains("Safe content"));
        assert!(!sanitized.contains("<script>"));
        assert!(!sanitized.contains("alert"));
    }
    
    #[test]
    fn test_user_input_sanitization() {
        let validator = InputValidator::new();
        
        let input = "User input with <script>alert('xss')</script> and javascript:void(0)";
        let sanitized = validator.sanitize_user_input(input);
        
        assert!(sanitized.contains("&lt;script&gt;"));
        assert!(sanitized.contains("javascript_"));
    }
    
    #[test]
    fn test_file_upload_validation() {
        let validator = InputValidator::new();
        
        // 有效文件
        assert!(validator.validate_file_upload("image.jpg", "image/jpeg", 1024).is_valid);
        
        // 无效文件名
        assert!(!validator.validate_file_upload("../secret.txt", "text/plain", 1024).is_valid);
        
        // 不允许的文件类型
        assert!(!validator.validate_file_upload("script.js", "application/javascript", 1024).is_valid);
        
        // 文件太大
        assert!(!validator.validate_file_upload("large.txt", "text/plain", 20 * 1024 * 1024).is_valid);
    }
    
    #[test]
    fn test_sql_input_validation() {
        let validator = InputValidator::new();
        
        assert!(validator.validate_sql_input("normal_input").is_valid);
        assert!(!validator.validate_sql_input("'; DROP TABLE users; --").is_valid);
        assert!(!validator.validate_sql_input("UNION SELECT * FROM passwords").is_valid);
    }
    
    #[test]
    fn test_password_validation() {
        let validator = InputValidator::new();
        
        // 强密码
        assert!(validator.validate_password("StrongP@ssw0rd123").is_valid);
        
        // 弱密码
        assert!(!validator.validate_password("weak").is_valid);
        assert!(!validator.validate_password("123456").is_valid);
        assert!(!validator.validate_password("password").is_valid);
    }
}
}

14.3.2 跨站脚本(XSS)防护

#![allow(unused)]
fn main() {
// File: security-utils/src/xss_protection.rs
use html_escape;
use std::collections::HashSet;

/// XSS防护工具
pub struct XssProtector {
    allowed_tags: HashSet<&'static str>,
    allowed_attributes: HashSet<&'static str>,
    blocked_keywords: HashSet<&'static str>,
    output_encoding: OutputEncoding,
}

#[derive(Debug, Clone)]
pub enum OutputEncoding {
    Html,
    Attribute,
    JavaScript,
    Css,
    Url,
}

impl XssProtector {
    pub fn new() -> Self {
        let allowed_tags = vec![
            "p", "br", "strong", "em", "u", "i", "b", "blockquote", "code", "pre",
            "ul", "ol", "li", "a", "h1", "h2", "h3", "h4", "h5", "h6"
        ].into_iter().collect();
        
        let allowed_attributes = vec![
            "href", "title", "class", "id", "alt", "src"
        ].into_iter().collect();
        
        let blocked_keywords = vec![
            "script", "javascript:", "vbscript:", "onload", "onerror", "onclick",
            "onmouseover", "eval(", "document.cookie", "document.location",
            "window.location", "alert(", "confirm(", "prompt("
        ].into_iter().collect();
        
        XssProtector {
            allowed_tags,
            allowed_attributes,
            blocked_keywords,
            output_encoding: OutputEncoding::Html,
        }
    }
    
    /// 净化HTML内容
    pub fn sanitize_html(&self, html: &str) -> String {
        let mut output = String::new();
        let mut chars = html.chars().peekable();
        
        while let Some(ch) = chars.next() {
            match ch {
                '<' => self.process_html_tag(&mut chars, &mut output),
                '&' => self.process_html_entity(&mut chars, &mut output),
                _ => output.push(ch),
            }
        }
        
        // 最终检查危险内容
        self.remove_malicious_content(&output)
    }
    
    /// 编码输出（根据上下文）
    pub fn encode_output(&self, input: &str, encoding: OutputEncoding) -> String {
        match encoding {
            OutputEncoding::Html => html_escape::encode_text(input).to_string(),
            OutputEncoding::Attribute => html_escape::encode_attribute(input).to_string(),
            OutputEncoding::JavaScript => self.encode_javascript(input),
            OutputEncoding::Css => self.encode_css(input),
            OutputEncoding::Url => urlencoding::encode(input).to_string(),
        }
    }
    
    /// 检查内容是否包含XSS攻击
    pub fn detect_xss(&self, content: &str) -> XssScanResult {
        let mut threats = Vec::new();
        
        // 检查脚本标签
        if self.contains_script_tags(content) {
            threats.push(XssThreat::ScriptTag);
        }
        
        // 检查事件处理器
        if self.contains_event_handlers(content) {
            threats.push(XssThreat::EventHandler);
        }
        
        // 检查危险关键词
        if self.contains_dangerous_keywords(content) {
            threats.push(XssThreat::DangerousKeywords);
        }
        
        // 检查协议注入
        if self.contains_protocol_injection(content) {
            threats.push(XssThreat::ProtocolInjection);
        }
        
        XssScanResult {
            is_safe: threats.is_empty(),
            threats,
            confidence: self.calculate_confidence(content, &threats),
        }
    }
    
    /// 创建内容安全策略
    pub fn generate_csp_header(&self) -> String {
        format!(
            "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self'; connect-src 'self'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'"
        )
    }
    
    fn process_html_tag(&self, chars: &mut std::iter::Peekable<std::str::Chars>, output: &mut String) {
        let mut tag_content = String::new();
        
        while let Some(&ch) = chars.peek() {
            if ch == '>' {
                chars.next(); // 消耗 '>'
                break;
            }
            tag_content.push(ch);
            chars.next();
        }
        
        if self.is_safe_tag(&tag_content) {
            output.push('<');
            output.push_str(&tag_content);
            output.push('>');
        }
    }
    
    fn process_html_entity(&self, chars: &mut std::iter::Peekable<std::str::Chars>, output: &mut String) {
        let mut entity = "&".to_string();
        
        while let Some(&ch) = chars.peek() {
            entity.push(ch);
            chars.next();
            
            if ch == ';' {
                break;
            }
        }
        
        // 只允许安全的HTML实体
        if self.is_safe_entity(&entity) {
            output.push_str(&entity);
        } else {
            output.push_str("&amp;");
        }
    }
    
    fn encode_javascript(&self, input: &str) -> String {
        input.chars()
            .map(|c| match c {
                '\'' => "\\'".to_string(),
                '"' => "\\\"".to_string(),
                '\\' => "\\\\".to_string(),
                '\n' => "\\n".to_string(),
                '\r' => "\\r".to_string(),
                '\t' => "\\t".to_string(),
                '\x08' => "\\b".to_string(),
                '\x0C' => "\\f".to_string(),
                _ => c.to_string(),
            })
            .collect()
    }
    
    fn encode_css(&self, input: &str) -> String {
        // CSS编码：移除危险字符和函数
        let mut output = String::new();
        for c in input.chars() {
            if c.is_ascii_alphanumeric() || c == ' ' || c == '-' || c == '_' {
                output.push(c);
            } else {
                output.push('_'); // 替换为安全字符
            }
        }
        output
    }
    
    fn is_safe_tag(&self, tag: &str) -> bool {
        let tag_name = tag.split(' ').next().unwrap_or("");
        let tag_name = tag_name.trim_start_matches('/').to_lowercase();
        
        self.allowed_tags.contains(&tag_name.as_str()) &&
        !self.contains_dangerous_content(tag)
    }
    
    fn is_safe_entity(&self, entity: &str) -> bool {
        let safe_entities = ["&amp;", "&lt;", "&gt;", "&quot;", "&#39;", "&nbsp;"];
        safe_entities.contains(&entity)
    }
    
    fn contains_dangerous_content(&self, content: &str) -> bool {
        let content_lower = content.to_lowercase();
        
        for keyword in &self.blocked_keywords {
            if content_lower.contains(keyword) {
                return true;
            }
        }
        
        false
    }
    
    fn contains_script_tags(&self, content: &str) -> bool {
        let script_patterns = [
            "<script", "</script>", "<script>",
            "javascript:", "vbscript:"
        ];
        
        let content_lower = content.to_lowercase();
        script_patterns.iter().any(|pattern| content_lower.contains(pattern))
    }
    
    fn contains_event_handlers(&self, content: &str) -> bool {
        let event_patterns = [
            "onload=", "onerror=", "onclick=", "onmouseover=",
            "onfocus=", "onblur=", "onchange=", "onsubmit="
        ];
        
        let content_lower = content.to_lowercase();
        event_patterns.iter().any(|pattern| content_lower.contains(pattern))
    }
    
    fn contains_dangerous_keywords(&self, content: &str) -> bool {
        let dangerous_patterns = [
            "eval(", "document.cookie", "document.location",
            "window.location", "alert(", "confirm(", "prompt("
        ];
        
        let content_lower = content.to_lowercase();
        dangerous_patterns.iter().any(|pattern| content_lower.contains(pattern))
    }
    
    fn contains_protocol_injection(&self, content: &str) -> bool {
        let protocol_patterns = [
            "javascript:", "vbscript:", "data:", "file:",
            "ftp:", "mailto:", "tel:", "sms:"
        ];
        
        let content_lower = content.to_lowercase();
        protocol_patterns.iter().any(|pattern| content_lower.contains(pattern))
    }
    
    fn remove_malicious_content(&self, content: &str) -> String {
        let mut sanitized = content.to_string();
        
        // 移除或替换危险内容
        for keyword in &self.blocked_keywords {
            sanitized = sanitized.replace(keyword, &format!("[removed:{}]", keyword));
        }
        
        // 移除事件处理器
        let event_pattern = regex::Regex::new(r"\son\w+=\"[^\"]*\"").unwrap();
        sanitized = event_pattern.replace_all(&sanitized, "").to_string();
        
        // 移除协议注入
        let protocol_pattern = regex::Regex::new(r"[\"']\s*(javascript|vbscript|data):").unwrap();
        sanitized = protocol_pattern.replace_all(&sanitized, "\"safe:").to_string();
        
        sanitized
    }
    
    fn calculate_confidence(&self, content: &str, threats: &[XssThreat]) -> f64 {
        if threats.is_empty() {
            return 0.0;
        }
        
        // 简单置信度计算
        let threat_count = threats.len() as f64;
        let content_length = content.len() as f64;
        let threat_density = threat_count / (content_length / 100.0); // 每100字符的威胁数
        
        (threat_density * 10.0).min(100.0) // 最高100%
    }
}

#[derive(Debug, Clone)]
pub enum XssThreat {
    ScriptTag,
    EventHandler,
    DangerousKeywords,
    ProtocolInjection,
}

pub struct XssScanResult {
    pub is_safe: bool,
    pub threats: Vec<XssThreat>,
    pub confidence: f64,
}

impl XssScanResult {
    pub fn summary(&self) -> String {
        if self.is_safe {
            "Content is safe".to_string()
        } else {
            format!("Found {} threats with {:.1}% confidence", 
                    self.threats.len(), self.confidence)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_html_sanitization() {
        let protector = XssProtector::new();
        
        let input = "<p>Safe content</p> <script>alert('xss')</script> <img src=x onerror=alert('xss')>";
        let sanitized = protector.sanitize_html(input);
        
        assert!(sanitized.contains("<p>"));
        assert!(sanitized.contains("Safe content"));
        assert!(!sanitized.contains("<script>"));
        assert!(!sanitized.contains("alert"));
    }
    
    #[test]
    fn test_xss_detection() {
        let protector = XssProtector::new();
        
        let safe_content = "<p>Normal content</p>";
        let dangerous_content = "<script>alert('xss')</script>";
        
        let safe_result = protector.detect_xss(safe_content);
        let dangerous_result = protector.detect_xss(dangerous_content);
        
        assert!(safe_result.is_safe);
        assert!(!dangerous_result.is_safe);
        assert!(dangerous_result.threats.contains(&XssThreat::ScriptTag));
    }
    
    #[test]
    fn test_output_encoding() {
        let protector = XssProtector::new();
        
        let input = "<script>alert('xss')</script>";
        
        let html_encoded = protector.encode_output(input, OutputEncoding::Html);
        let attr_encoded = protector.encode_output(input, OutputEncoding::Attribute);
        let js_encoded = protector.encode_output(input, OutputEncoding::JavaScript);
        
        assert!(html_encoded.contains("&lt;script&gt;"));
        assert!(attr_encoded.contains("&lt;script&gt;"));
        assert!(js_encoded.contains("\\x3Cscript\\x3E"));
    }
    
    #[test]
    fn test_csp_header() {
        let protector = XssProtector::new();
        let csp = protector.generate_csp_header();
        
        assert!(csp.contains("default-src 'self'"));
        assert!(csp.contains("script-src"));
        assert!(csp.contains("frame-ancestors 'none'"));
    }
}
}

14.4 安全审计

14.4.1 代码安全扫描

#![allow(unused)]
fn main() {
// File: security-scanner/src/lib.rs
use regex::Regex;
use std::collections::{HashMap, HashSet};
use std::path::Path;
use std::fs;
use serde::{Deserialize, Serialize};

/// 安全漏洞扫描器
pub struct SecurityScanner {
    patterns: HashMap<String, VulnerabilityPattern>,
    ignore_patterns: HashSet<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VulnerabilityPattern {
    pub id: String,
    pub name: String,
    pub severity: Severity,
    pub category: String,
    pub description: String,
    pub remediation: String,
    pub regex_pattern: String,
    pub file_types: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub enum Severity {
    Critical,
    High,
    Medium,
    Low,
    Info,
}

impl std::fmt::Display for Severity {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Severity::Critical => write!(f, "Critical"),
            Severity::High => write!(f, "High"),
            Severity::Medium => write!(f, "Medium"),
            Severity::Low => write!(f, "Low"),
            Severity::Info => write!(f, "Info"),
        }
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityFinding {
    pub id: String,
    pub pattern_id: String,
    pub file_path: String,
    pub line_number: u32,
    pub severity: Severity,
    pub message: String,
    pub code_snippet: String,
    pub remediation: String,
}

impl SecurityScanner {
    pub fn new() -> Self {
        SecurityScanner {
            patterns: Self::default_patterns(),
            ignore_patterns: HashSet::new(),
        }
    }
    
    /// 扫描文件或目录
    pub fn scan_path(&self, path: &Path) -> Result<Vec<SecurityFinding>, Box<dyn std::error::Error>> {
        let mut findings = Vec::new();
        
        if path.is_file() {
            if let Some(findings_for_file) = self.scan_file(path)? {
                findings.extend(findings_for_file);
            }
        } else if path.is_dir() {
            for entry in fs::read_dir(path)? {
                let entry = entry?;
                let file_path = entry.path();
                
                if let Some(mut findings_for_file) = self.scan_file(&file_path)? {
                    findings.append(&mut findings_for_file);
                }
            }
        }
        
        Ok(findings)
    }
    
    /// 扫描单个文件
    pub fn scan_file(&self, file_path: &Path) -> Result<Option<Vec<SecurityFinding>>, Box<dyn std::error::Error>> {
        if !self.should_scan_file(file_path) {
            return Ok(None);
        }
        
        let content = fs::read_to_string(file_path)?;
        let file_extension = file_path.extension()
            .and_then(|ext| ext.to_str())
            .unwrap_or("");
        
        let mut findings = Vec::new();
        
        for pattern in self.patterns.values() {
            if pattern.file_types.contains(&file_extension) || pattern.file_types.is_empty() {
                if let Some(pattern_findings) = self.scan_content(&content, pattern, file_path)? {
                    findings.extend(pattern_findings);
                }
            }
        }
        
        if !findings.is_empty() {
            Ok(Some(findings))
        } else {
            Ok(None)
        }
    }
    
    /// 扫描内容
    fn scan_content(&self, content: &str, pattern: &VulnerabilityPattern, file_path: &Path) -> Result<Option<Vec<SecurityFinding>>, Box<dyn std::error::Error>> {
        let regex = Regex::new(&pattern.regex_pattern)?;
        let mut findings = Vec::new();
        
        for (line_num, line) in content.lines().enumerate() {
            if let Some(match_) = regex.find(line) {
                // 检查是否在忽略列表中
                let match_text = match_.as_str();
                if self.should_ignore(match_text) {
                    continue;
                }
                
                let finding = SecurityFinding {
                    id: format!("{}-{}", pattern.id, line_num + 1),
                    pattern_id: pattern.id.clone(),
                    file_path: file_path.to_string_lossy().to_string(),
                    line_number: (line_num + 1) as u32,
                    severity: pattern.severity.clone(),
                    message: format!("{}: {}", pattern.name, match_text),
                    code_snippet: line.trim().to_string(),
                    remediation: pattern.remediation.clone(),
                };
                
                findings.push(finding);
            }
        }
        
        if findings.is_empty() {
            Ok(None)
        } else {
            Ok(Some(findings))
        }
    }
    
    /// 检查是否应该扫描文件
    fn should_scan_file(&self, file_path: &Path) -> bool {
        // 忽略隐藏文件
        if file_path.file_name()
            .and_then(|name| name.to_str())
            .map(|name| name.starts_with('.'))
            .unwrap_or(false) {
            return false;
        }
        
        // 忽略常见的忽略模式
        let ignore_dirs = ["target", "node_modules", ".git", ".svn", "build", "dist"];
        if let Some(dir_name) = file_path.parent().and_then(|p| p.file_name()).and_then(|name| name.to_str()) {
            if ignore_dirs.contains(&dir_name) {
                return false;
            }
        }
        
        true
    }
    
    /// 检查是否应该忽略匹配
    fn should_ignore(&self, match_text: &str) -> bool {
        for ignore_pattern in &self.ignore_patterns {
            if match_text.contains(ignore_pattern) {
                return true;
            }
        }
        false
    }
    
    /// 添加忽略模式
    pub fn add_ignore_pattern(&mut self, pattern: String) {
        self.ignore_patterns.insert(pattern);
    }
    
    /// 生成报告
    pub fn generate_report(&self, findings: &[SecurityFinding]) -> SecurityReport {
        let mut findings_by_severity: HashMap<Severity, Vec<SecurityFinding>> = HashMap::new();
        let mut findings_by_category: HashMap<String, Vec<SecurityFinding>> = HashMap::new();
        
        for finding in findings {
            findings_by_severity
                .entry(finding.severity.clone())
                .or_insert_with(Vec::new)
                .push(finding.clone());
            
            if let Some(pattern) = self.patterns.get(&finding.pattern_id) {
                findings_by_category
                    .entry(pattern.category.clone())
                    .or_insert_with(Vec::new)
                    .push(finding.clone());
            }
        }
        
        SecurityReport {
            total_findings: findings.len(),
            findings_by_severity,
            findings_by_category,
            scanned_files: self.get_scanned_file_count(findings),
            scan_timestamp: chrono::Utc::now(),
        }
    }
    
    fn get_scanned_file_count(&self, findings: &[SecurityFinding]) -> usize {
        let mut unique_files = HashSet::new();
        for finding in findings {
            unique_files.insert(&finding.file_path);
        }
        unique_files.len()
    }
    
    fn default_patterns() -> HashMap<String, VulnerabilityPattern> {
        let mut patterns = HashMap::new();
        
        // SQL注入模式
        patterns.insert(
            "SQL001".to_string(),
            VulnerabilityPattern {
                id: "SQL001".to_string(),
                name: "Potential SQL Injection".to_string(),
                severity: Severity::Critical,
                category: "Injection".to_string(),
                description: "Detected potential SQL injection vulnerability".to_string(),
                remediation: "Use parameterized queries or prepared statements".to_string(),
                regex_pattern: r"(?i)(select|insert|update|delete|drop|create|alter)\s+.*\+|.*\bunion\b.*\bselect\b".to_string(),
                file_types: vec!["rs", "py", "js", "php", "java", "cs".to_string()],
            }
        );
        
        // 硬编码密码模式
        patterns.insert(
            "AUTH001".to_string(),
            VulnerabilityPattern {
                id: "AUTH001".to_string(),
                name: "Hardcoded Password".to_string(),
                severity: Severity::High,
                category: "Authentication".to_string(),
                description: "Detected hardcoded password or API key".to_string(),
                remediation: "Move sensitive data to environment variables or secure storage".to_string(),
                regex_pattern: r"(?i)(password|passwd|pwd|api_key|apikey|secret|token)\s*[:=]\s*['\"][^'\"]{8,}['\"]".to_string(),
                file_types: vec!["rs", "py", "js", "php", "java", "cs".to_string()],
            }
        );
        
        // XSS模式
        patterns.insert(
            "XSS001".to_string(),
            VulnerabilityPattern {
                id: "XSS001".to_string(),
                name: "Cross-Site Scripting".to_string(),
                severity: Severity::High,
                category: "Cross-Site Scripting".to_string(),
                description: "Detected potential XSS vulnerability".to_string(),
                remediation: "Sanitize user input and use proper encoding".to_string(),
                regex_pattern: r"(?i)(innerHTML|outerHTML|document\.write|eval\()".to_string(),
                file_types: vec!["rs", "js", "html", "php".to_string()],
            }
        );
        
        // 不安全的随机数生成
        patterns.insert(
            "RAND001".to_string(),
            VulnerabilityPattern {
                id: "RAND001".to_string(),
                name: "Insecure Random Number Generation".to_string(),
                severity: Severity::Medium,
                category: "Cryptography".to_string(),
                description: "Detected use of insecure random number generation".to_string(),
                remediation: "Use cryptographically secure random number generators".to_string(),
                regex_pattern: r"(?i)(rand\(|random\(\)|Math\.random\(\))".to_string(),
                file_types: vec!["rs", "py", "js", "java".to_string()],
            }
        );
        
        // 命令注入
        patterns.insert(
            "CMD001".to_string(),
            VulnerabilityPattern {
                id: "CMD001".to_string(),
                name: "Command Injection".to_string(),
                severity: Severity::Critical,
                category: "Injection".to_string(),
                description: "Detected potential command injection vulnerability".to_string(),
                remediation: "Validate and sanitize input, use safe APIs".to_string(),
                regex_pattern: r"(?i)(system\(|exec\(|popen\(|shell_exec\(|ProcessBuilder)".to_string(),
                file_types: vec!["rs", "py", "js", "php", "java".to_string()],
            }
        );
        
        // 不安全的HTTP连接
        patterns.insert(
            "HTTP001".to_string(),
            VulnerabilityPattern {
                id: "HTTP001".to_string(),
                name: "Insecure HTTP Connection".to_string(),
                severity: Severity::Medium,
                category: "Transport Security".to_string(),
                description: "Detected use of insecure HTTP connection".to_string(),
                remediation: "Use HTTPS for all network communications".to_string(),
                regex_pattern: r"(?i)http://(?!localhost|127\.0\.0\.1)".to_string(),
                file_types: vec!["rs", "py", "js", "php".to_string()],
            }
        );
        
        // 调试信息泄露
        patterns.insert(
            "INFO001".to_string(),
            VulnerabilityPattern {
                id: "INFO001".to_string(),
                name: "Information Disclosure".to_string(),
                severity: Severity::Low,
                category: "Information Disclosure".to_string(),
                description: "Detected potential information disclosure".to_string(),
                remediation: "Remove debug information in production".to_string(),
                regex_pattern: r"(?i)(console\.log|printStackTrace|debug|print_r|var_dump)".to_string(),
                file_types: vec!["rs", "py", "js", "php".to_string()],
            }
        );
        
        // 目录遍历
        patterns.insert(
            "PATH001".to_string(),
            VulnerabilityPattern {
                id: "PATH001".to_string(),
                name: "Path Traversal".to_string(),
                severity: Severity::High,
                category: "Path Traversal".to_string(),
                description: "Detected potential path traversal vulnerability".to_string(),
                remediation: "Validate and sanitize file paths, use safe file APIs".to_string(),
                regex_pattern: r"(\.\./|\.\.\\)".to_string(),
                file_types: vec!["rs", "py", "js", "php", "java".to_string()],
            }
        );
        
        patterns
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SecurityReport {
    pub total_findings: usize,
    pub findings_by_severity: HashMap<Severity, Vec<SecurityFinding>>,
    pub findings_by_category: HashMap<String, Vec<SecurityFinding>>,
    pub scanned_files: usize,
    pub scan_timestamp: chrono::DateTime<chrono::Utc>,
}

impl SecurityReport {
    pub fn print_summary(&self) {
        println!("=== Security Scan Report ===");
        println!("Total Findings: {}", self.total_findings);
        println!("Scanned Files: {}", self.scanned_files);
        println!("Scan Time: {}", self.scan_timestamp);
        println!();
        
        // 按严重性分组显示
        for severity in [Severity::Critical, Severity::High, Severity::Medium, Severity::Low, Severity::Info] {
            if let Some(findings) = self.findings_by_severity.get(&severity) {
                if !findings.is_empty() {
                    println!("{} ({}):", severity, findings.len());
                    for finding in findings {
                        println!("  - {}:{} - {}", finding.file_path, finding.line_number, finding.message);
                    }
                    println!();
                }
            }
        }
    }
    
    pub fn get_critical_findings(&self) -> Vec<&SecurityFinding> {
        self.findings_by_severity
            .get(&Severity::Critical)
            .map(|v| v.iter().collect())
            .unwrap_or_default()
    }
    
    pub fn get_risk_score(&self) -> f64 {
        let mut score = 0.0;
        
        for (severity, findings) in &self.findings_by_severity {
            let count = findings.len() as f64;
            let weight = match severity {
                Severity::Critical => 10.0,
                Severity::High => 7.0,
                Severity::Medium => 5.0,
                Severity::Low => 2.0,
                Severity::Info => 1.0,
            };
            score += count * weight;
        }
        
        // 标准化到0-100范围
        (score / (self.scanned_files as f64 + 1.0)).min(100.0)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;
    
    #[test]
    fn test_sql_injection_detection() {
        let scanner = SecurityScanner::new();
        let mut temp_file = NamedTempFile::new().unwrap();
        
        let malicious_code = r#"
        let query = "SELECT * FROM users WHERE id = " + userId;
        let sql = "DROP TABLE users; --";
        "#;
        
        writeln!(temp_file, "{}", malicious_code).unwrap();
        
        let findings = scanner.scan_file(temp_file.path()).unwrap().unwrap();
        
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.pattern_id == "SQL001"));
    }
    
       #[test]
    fn test_hardcoded_password_detection() {
        let scanner = SecurityScanner::new();
        let mut temp_file = NamedTempFile::new().unwrap();
        
        let code_with_secrets = r#"
        const password = "SuperSecret123!";
        let api_key = "sk-1234567890abcdef";
        "#;
        
        writeln!(temp_file, "{}", code_with_secrets).unwrap();
        
        let findings = scanner.scan_file(temp_file.path()).unwrap().unwrap();
        
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.pattern_id == "AUTH001"));
    }
    
    #[test]
    fn test_xss_detection() {
        let scanner = SecurityScanner::new();
        let mut temp_file = NamedTempFile::new().unwrap();
        
        let xss_code = r#"
        element.innerHTML = userInput;
        document.write("<script>alert('xss')</script>");
        "#;
        
        writeln!(temp_file, "{}", xss_code).unwrap();
        
        let findings = scanner.scan_file(temp_file.path()).unwrap().unwrap();
        
        assert!(!findings.is_empty());
        assert!(findings.iter().any(|f| f.pattern_id == "XSS001"));
    }
    
    #[test]
    fn test_report_generation() {
        let scanner = SecurityScanner::new();
        let mut temp_file = NamedTempFile::new().unwrap();
        
        writeln!(temp_file, "let password = 'secret123';").unwrap();
        
        let findings = scanner.scan_file(temp_file.path()).unwrap().unwrap();
        let report = scanner.generate_report(&findings);
        
        assert_eq!(report.total_findings, findings.len());
        assert!(report.get_risk_score() > 0.0);
    }
}
}

14.4.2 依赖安全检查

#![allow(unused)]
fn main() {
// File: security-scanner/src/dependency_checker.rs
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use regex::Regex;

/// 依赖安全检查器
pub struct DependencyChecker {
    known_vulnerabilities: HashMap<String, Vec<Vulnerability>>,
    severity_threshold: Severity,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Vulnerability {
    pub id: String,
    pub name: String,
    pub severity: Severity,
    pub affected_versions: Vec<VersionRange>,
    pub description: String,
    pub remediation: String,
    pub cve_id: Option<String>,
    pub references: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VersionRange {
    pub min_version: Option<String>,
    pub max_version: Option<String>,
    pub all_versions: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Dependency {
    pub name: String,
    pub version: String,
    pub file_path: String,
    pub ecosystem: Ecosystem,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Ecosystem {
    Rust,
    Node,
    Python,
    Java,
    Ruby,
    Go,
    .NET,
}

impl DependencyChecker {
    pub fn new() -> Self {
        DependencyChecker {
            known_vulnerabilities: Self::load_known_vulnerabilities(),
            severity_threshold: Severity::Medium,
        }
    }
    
    /// 扫描项目依赖
    pub fn scan_dependencies(&self, project_path: &Path) -> Result<Vec<DependencyVulnerability>, Box<dyn std::error::Error>> {
        let mut vulnerabilities = Vec::new();
        
        // 扫描Cargo.toml
        if let Some(cargo_deps) = self.scan_cargo_dependencies(project_path)? {
            for dep in cargo_deps {
                if let Some(dep_vulns) = self.check_dependency_vulnerabilities(&dep) {
                    vulnerabilities.extend(dep_vulns);
                }
            }
        }
        
        // 扫描其他类型的依赖文件
        if let Some(node_deps) = self.scan_package_json_dependencies(project_path)? {
            for dep in node_deps {
                if let Some(dep_vulns) = self.check_dependency_vulnerabilities(&dep) {
                    vulnerabilities.extend(dep_vulns);
                }
            }
        }
        
        Ok(vulnerabilities)
    }
    
    /// 扫描Rust依赖（Cargo.toml）
    fn scan_cargo_dependencies(&self, project_path: &Path) -> Result<Option<Vec<Dependency>>, Box<dyn std::error::Error>> {
        let cargo_toml = project_path.join("Cargo.toml");
        if !cargo_toml.exists() {
            return Ok(None);
        }
        
        let content = fs::read_to_string(&cargo_toml)?;
        let mut dependencies = Vec::new();
        
        // 使用正则表达式解析依赖
        let dep_pattern = Regex::new(r#"(\w+)\s*=\s*"\s*([^"]+)\s*""#)?;
        
        for cap in dep_pattern.captures_iter(&content) {
            let name = cap[1].to_string();
            let version = cap[2].to_string();
            
            dependencies.push(Dependency {
                name,
                version,
                file_path: cargo_toml.to_string_lossy().to_string(),
                ecosystem: Ecosystem::Rust,
            });
        }
        
        Ok(Some(dependencies))
    }
    
    /// 扫描Node.js依赖（package.json）
    fn scan_package_json_dependencies(&self, project_path: &Path) -> Result<Option<Vec<Dependency>>, Box<dyn std::error::Error>> {
        let package_json = project_path.join("package.json");
        if !package_json.exists() {
            return Ok(None);
        }
        
        let content = fs::read_to_string(&package_json)?;
        let package: serde_json::Value = serde_json::from_str(&content)?;
        
        let mut dependencies = Vec::new();
        
        // 扫描dependencies
        if let Some(deps) = package.get("dependencies").and_then(|d| d.as_object()) {
            for (name, version) in deps {
                if let Some(version_str) = version.as_str() {
                    dependencies.push(Dependency {
                        name: name.to_string(),
                        version: version_str.to_string(),
                        file_path: package_json.to_string_lossy().to_string(),
                        ecosystem: Ecosystem::Node,
                    });
                }
            }
        }
        
        // 扫描devDependencies
        if let Some(deps) = package.get("devDependencies").and_then(|d| d.as_object()) {
            for (name, version) in deps {
                if let Some(version_str) = version.as_str() {
                    dependencies.push(Dependency {
                        name: name.to_string(),
                        version: version_str.to_string(),
                        file_path: package_json.to_string_lossy().to_string(),
                        ecosystem: Ecosystem::Node,
                    });
                }
            }
        }
        
        Ok(Some(dependencies))
    }
    
    /// 检查依赖的安全漏洞
    fn check_dependency_vulnerabilities(&self, dependency: &Dependency) -> Option<Vec<DependencyVulnerability>> {
        if let Some(vulnerabilities) = self.known_vulnerabilities.get(&dependency.name) {
            let mut found_vulns = Vec::new();
            
            for vuln in vulnerabilities {
                if self.is_version_affected(&dependency.version, &vuln.affected_versions) {
                    found_vulns.push(DependencyVulnerability {
                        dependency: dependency.clone(),
                        vulnerability: vuln.clone(),
                    });
                }
            }
            
            if !found_vulns.is_empty() {
                Some(found_vulns)
            } else {
                None
            }
        } else {
            None
        }
    }
    
    /// 检查版本是否在受影响范围内
    fn is_version_affected(&self, version: &str, ranges: &[VersionRange]) -> bool {
        let version_semver = self.parse_version(version);
        
        for range in ranges {
            if range.all_versions {
                return true;
            }
            
            if let Some((min_semver, max_semver)) = self.check_version_range(&version_semver, range) {
                return min_semver && max_semver;
            }
        }
        
        false
    }
    
    fn parse_version(&self, version: &str) -> (u32, u32, u32) {
        let parts: Vec<&str> = version.split('.').collect();
        let major = parts.get(0).and_then(|p| p.parse().ok()).unwrap_or(0);
        let minor = parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
        let patch = parts.get(2).and_then(|p| p.parse().ok()).unwrap_or(0);
        (major, minor, patch)
    }
    
    fn check_version_range(&self, version: &(u32, u32, u32), range: &VersionRange) -> Option<(bool, bool)> {
        let (min_ok, max_ok) = (
            range.min_version.as_ref().map_or(true, |min| self.compare_versions(version, min) >= 0),
            range.max_version.as_ref().map_or(true, |max| self.compare_versions(version, max) <= 0),
        );
        Some((min_ok, max_ok))
    }
    
    fn compare_versions(&self, version: &(u32, u32, u32), other: &str) -> i32 {
        let other_parts: Vec<&str> = other.split('.').collect();
        let other_major = other_parts.get(0).and_then(|p| p.parse().ok()).unwrap_or(0);
        let other_minor = other_parts.get(1).and_then(|p| p.parse().ok()).unwrap_or(0);
        let other_patch = other_parts.get(2).and_then(|p| p.parse().ok()).unwrap_or(0);
        
        if version.0 != other_major {
            return (version.0 as i32) - (other_major as i32);
        }
        if version.1 != other_minor {
            return (version.1 as i32) - (other_minor as i32);
        }
        (version.2 as i32) - (other_patch as i32)
    }
    
    /// 生成依赖安全报告
    pub fn generate_report(&self, vulnerabilities: &[DependencyVulnerability]) -> DependencySecurityReport {
        let mut vulnerabilities_by_severity: HashMap<Severity, Vec<DependencyVulnerability>> = HashMap::new();
        let mut vulnerabilities_by_ecosystem: HashMap<String, Vec<DependencyVulnerability>> = HashMap::new();
        
        for vuln in vulnerabilities {
            vulnerabilities_by_severity
                .entry(vuln.vulnerability.severity.clone())
                .or_insert_with(Vec::new)
                .push(vuln.clone());
            
            let ecosystem = format!("{:?}", vuln.dependency.ecosystem);
            vulnerabilities_by_ecosystem
                .entry(ecosystem)
                .or_insert_with(Vec::new)
                .push(vuln.clone());
        }
        
        DependencySecurityReport {
            total_vulnerabilities: vulnerabilities.len(),
            vulnerabilities_by_severity,
            vulnerabilities_by_ecosystem,
            scan_timestamp: chrono::Utc::now(),
        }
    }
    
    fn load_known_vulnerabilities() -> HashMap<String, Vec<Vulnerability>> {
        let mut vulnerabilities = HashMap::new();
        
        // 示例漏洞数据（实际项目中应该从CVE数据库加载）
        vulnerabilities.insert(
            "openssl".to_string(),
            vec![Vulnerability {
                id: "CVE-2022-3602".to_string(),
                name: "OpenSSL X.509 Email Address 4-byte Buffer Overflow".to_string(),
                severity: Severity::High,
                affected_versions: vec![VersionRange {
                    min_version: Some("1.1.1".to_string()),
                    max_version: Some("1.1.1k".to_string()),
                    all_versions: false,
                }],
                description: "A buffer overflow exists in the X.509 certificate verification".to_string(),
                remediation: "Upgrade to OpenSSL 1.1.1k or later".to_string(),
                cve_id: Some("CVE-2022-3602".to_string()),
                references: vec!["https://www.openssl.org/news/secadv/20221101.txt".to_string()],
            }]
        );
        
        vulnerabilities.insert(
            "serde_json".to_string(),
            vec![Vulnerability {
                id: "RUSTSEC-2021-0001".to_string(),
                name: "serde_json integer overflow".to_string(),
                severity: Severity::Medium,
                affected_versions: vec![VersionRange {
                    min_version: Some("1.0.0".to_string()),
                    max_version: Some("1.0.50".to_string()),
                    all_versions: false,
                }],
                description: "Integer overflow in serde_json when processing large inputs".to_string(),
                remediation: "Upgrade to serde_json 1.0.51 or later".to_string(),
                cve_id: Some("RUSTSEC-2021-0001".to_string()),
                references: vec!["https://rustsec.org/advisories/RUSTSEC-2021-0001.html".to_string()],
            }]
        );
        
        // 更多漏洞数据...
        vulnerabilities
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DependencyVulnerability {
    pub dependency: Dependency,
    pub vulnerability: Vulnerability,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DependencySecurityReport {
    pub total_vulnerabilities: usize,
    pub vulnerabilities_by_severity: HashMap<Severity, Vec<DependencyVulnerability>>,
    pub vulnerabilities_by_ecosystem: HashMap<String, Vec<DependencyVulnerability>>,
    pub scan_timestamp: chrono::DateTime<chrono::Utc>,
}

impl DependencySecurityReport {
    pub fn print_summary(&self) {
        println!("=== Dependency Security Report ===");
        println!("Total Vulnerabilities: {}", self.total_vulnerabilities);
        println!("Scan Time: {}", self.scan_timestamp);
        println!();
        
        // 按严重性分组显示
        for severity in [Severity::Critical, Severity::High, Severity::Medium, Severity::Low, Severity::Info] {
            if let Some(vulns) = self.vulnerabilities_by_severity.get(&severity) {
                if !vulns.is_empty() {
                    println!("{} ({}):", severity, vulns.len());
                    for vuln in vulns {
                        println!("  - {} v{}: {} ({})", 
                                vuln.dependency.name, 
                                vuln.dependency.version, 
                                vuln.vulnerability.name,
                                vuln.vulnerability.id);
                    }
                    println!();
                }
            }
        }
    }
    
    pub fn get_critical_vulnerabilities(&self) -> Vec<&DependencyVulnerability> {
        self.vulnerabilities_by_severity
            .get(&Severity::Critical)
            .map(|v| v.iter().collect())
            .unwrap_or_default()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;
    
    #[test]
    fn test_cargo_dependency_parsing() {
        let checker = DependencyChecker::new();
        let mut temp_file = NamedTempFile::new().unwrap();
        
        let cargo_content = r#"
        [dependencies]
        serde = "1.0"
        tokio = { version = "1.0", features = ["full"] }
        openssl = "0.10"
        "#;
        
        writeln!(temp_file, "{}", cargo_content).unwrap();
        
        let dependencies = checker.scan_cargo_dependencies(temp_file.path().parent().unwrap()).unwrap().unwrap();
        assert_eq!(dependencies.len(), 3);
        assert!(dependencies.iter().any(|d| d.name == "serde"));
        assert!(dependencies.iter().any(|d| d.name == "openssl"));
    }
    
    #[test]
    fn test_vulnerability_detection() {
        let checker = DependencyChecker::new();
        let vulnerable_dep = Dependency {
            name: "openssl".to_string(),
            version: "1.1.1h".to_string(),
            file_path: "Cargo.toml".to_string(),
            ecosystem: Ecosystem::Rust,
        };
        
        let vulnerabilities = checker.check_dependency_vulnerabilities(&vulnerable_dep).unwrap();
        assert!(!vulnerabilities.is_empty());
        assert!(vulnerabilities.iter().any(|v| v.vulnerability.id == "CVE-2022-3602"));
    }
}
}

14.5 企业级认证服务项目

现在我们来构建一个企业级安全认证服务，集成所有学到的安全技术。

#![allow(unused)]
fn main() {
// 企业级认证服务主项目
// File: auth-service/Cargo.toml
[package]
name = "auth-service"
version = "1.0.0"
edition = "2021"

[dependencies]
tokio = { version = "1.0", features = ["full"] }
axum = { version = "0.7", features = ["macros"] }
tower = { version = "0.4" }
tower-http = { version = "0.5", features = ["cors", "compression", "trace", "timeout"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
sqlx = { version = "0.7", features = ["runtime-tokio-rustls", "postgres", "json", "uuid", "chrono"] }
redis = { version = "0.24", features = ["tokio-comp", "connection-manager"] }
bcrypt = "0.15"
jsonwebtoken = "9.0"
clap = { version = "4.0", features = ["derive"] }
tracing = "0.1"
tracing-subscriber = "0.3"
anyhow = "1.0"
thiserror = "1.0"
ring = "0.17"
mfa = "0.1" # 模拟MFA库
totp-rs = "5" # TOTP库
qrcode = "1.0" # QR码生成
base32 = "0.4"
}

// 认证服务主文件
// File: auth-service/src/main.rs
use clap::{Parser, Subcommand};
use tracing::{info, warn, error, Level};
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};

mod auth;
mod mfa;
mod audit;
mod config;
mod server;

use auth::{AuthenticationService, AuthConfig};
use server::AuthServer;
use config::Config;

#[derive(Parser, Debug)]
#[command(name = "auth-service")]
#[command(about = "Enterprise authentication service")]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Start authentication service
    Server {
        #[arg(short, long, default_value = "0.0.0.0:8080")]
        addr: String,
        
        #[arg(short, long, default_value = "postgres://auth_user:password@localhost/auth_db")]
        database_url: String,
        
        #[arg(short, long, default_value = "redis://localhost:6379")]
        redis_url: String,
    },
    /// Initialize database
    Init {
        #[arg(short, long, default_value = "postgres://auth_user:password@localhost/auth_db")]
        database_url: String,
    },
    /// Security audit
    Audit {
        #[arg(short, long)]
        target: String,
    },
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    tracing_subscriber::registry()
        .with(
            tracing_subscriber::EnvFilter::try_from_default_env()
                .unwrap_or_else(|_| "auth_service=debug,tokio=warn,sqlx=warn".into()),
        )
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let cli = Cli::parse();
    
    match cli.command {
        Commands::Server { addr, database_url, redis_url } => {
            run_server(addr, database_url, redis_url).await
        }
        Commands::Init { database_url } => {
            init_database(database_url).await
        }
        Commands::Audit { target } => {
            run_audit(target).await
        }
    }
}

async fn run_server(
    addr: String,
    database_url: String,
    redis_url: String,
) -> Result<(), Box<dyn std::error::Error>> {
    info!("Starting enterprise authentication service on {}", addr);
    
    // 初始化配置
    let config = Config {
        addr,
        database_url,
        redis_url,
        jwt_secret: std::env::var("JWT_SECRET").unwrap_or_else(|_| "your-jwt-secret-change-this".to_string()),
        bcrypt_cost: 12,
        max_login_attempts: 5,
        lockout_duration: std::time::Duration::from_secs(1800), // 30分钟
        session_timeout: std::time::Duration::from_secs(3600), // 1小时
        mfa_enabled: true,
        audit_enabled: true,
    };
    
    // 初始化数据库
    let db_pool = sqlx::PgPool::connect(&config.database_url).await?;
    
    // 初始化Redis
    let redis_client = redis::Client::open(&config.redis_url)?;
    
    // 初始化认证服务
    let auth_service = AuthenticationService::new(db_pool, redis_client, config.clone()).await?;
    
    // 启动服务器
    let server = AuthServer::new(config, auth_service);
    server.run().await?;
    
    Ok(())
}

async fn init_database(database_url: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Initializing authentication database");
    
    let pool = sqlx::PgPool::connect(&database_url).await?;
    
    // 创建用户表
    sqlx::query!(r#"
        CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
        CREATE EXTENSION IF NOT EXISTS "pgcrypto";
        
        CREATE TABLE users (
            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
            username VARCHAR(50) UNIQUE NOT NULL,
            email VARCHAR(255) UNIQUE NOT NULL,
            password_hash VARCHAR(255) NOT NULL,
            full_name VARCHAR(255),
            phone_number VARCHAR(20),
            is_active BOOLEAN DEFAULT true,
            is_verified BOOLEAN DEFAULT false,
            failed_login_attempts INTEGER DEFAULT 0,
            locked_until TIMESTAMPTZ,
            last_login_at TIMESTAMPTZ,
            last_login_ip INET,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            updated_at TIMESTAMPTZ DEFAULT NOW(),
            metadata JSONB DEFAULT '{}'
        );
    "#).execute(&pool).await?;
    
    // 创建会话表
    sqlx::query!(r#"
        CREATE TABLE user_sessions (
            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
            user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            session_token VARCHAR(255) UNIQUE NOT NULL,
            refresh_token VARCHAR(255) UNIQUE,
            ip_address INET,
            user_agent TEXT,
            device_info JSONB,
            is_active BOOLEAN DEFAULT true,
            expires_at TIMESTAMPTZ NOT NULL,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            last_used_at TIMESTAMPTZ DEFAULT NOW()
        );
    "#).execute(&pool).await?;
    
    // 创建MFA表
    sqlx::query!(r#"
        CREATE TABLE user_mfa (
            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
            user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
            secret_key VARCHAR(255) NOT NULL,
            backup_codes TEXT[],
            method VARCHAR(20) NOT NULL, -- 'totp', 'sms', 'email'
            is_enabled BOOLEAN DEFAULT true,
            created_at TIMESTAMPTZ DEFAULT NOW(),
            verified_at TIMESTAMPTZ
        );
    "#).execute(&pool).await?;
    
    // 创建审计日志表
    sqlx::query!(r#"
        CREATE TABLE audit_logs (
            id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
            user_id UUID REFERENCES users(id) ON DELETE SET NULL,
            event_type VARCHAR(50) NOT NULL,
            event_category VARCHAR(20) NOT NULL, -- 'auth', 'security', 'system'
            ip_address INET,
            user_agent TEXT,
            resource VARCHAR(100),
            action VARCHAR(50),
            result VARCHAR(20) NOT NULL, -- 'success', 'failure', 'blocked'
            details JSONB,
            severity VARCHAR(10) NOT NULL DEFAULT 'info', -- 'info', 'warning', 'error', 'critical'
            created_at TIMESTAMPTZ DEFAULT NOW()
        );
    "#).execute(&pool).await?;
    
    // 创建索引
    sqlx::query!(r#"
        CREATE INDEX idx_users_email ON users(email);
        CREATE INDEX idx_users_username ON users(username);
        CREATE INDEX idx_sessions_user_id ON user_sessions(user_id);
        CREATE INDEX idx_sessions_token ON user_sessions(session_token);
        CREATE INDEX idx_sessions_expires ON user_sessions(expires_at);
        CREATE INDEX idx_mfa_user_id ON user_mfa(user_id);
        CREATE INDEX idx_audit_user_id ON audit_logs(user_id);
        CREATE INDEX idx_audit_event_type ON audit_logs(event_type);
        CREATE INDEX idx_audit_created_at ON audit_logs(created_at);
    "#).execute(&pool).await?;
    
    // 创建触发器
    sqlx::query!(r#"
        CREATE OR REPLACE FUNCTION update_updated_at_column()
        RETURNS TRIGGER AS $$
        BEGIN
            NEW.updated_at = NOW();
            RETURN NEW;
        END;
        $$ language 'plpgsql';
        
        CREATE TRIGGER update_users_updated_at
        BEFORE UPDATE ON users
        FOR EACH ROW
        EXECUTE FUNCTION update_updated_at_column();
    "#).execute(&pool).await?;
    
    info!("Database initialized successfully");
    Ok(())
}

async fn run_audit(target: String) -> Result<(), Box<dyn std::error::Error>> {
    info!("Running security audit on: {}", target);
    
    // 这里可以集成安全扫描功能
    use security_scanner::SecurityScanner;
    let scanner = SecurityScanner::new();
    
    let path = std::path::Path::new(&target);
    let findings = scanner.scan_path(path)?;
    let report = scanner.generate_report(&findings);
    
    report.print_summary();
    
    Ok(())
}

#![allow(unused)]
fn main() {
// 认证服务核心实现
// File: auth-service/src/auth/mod.rs
use std::sync::Arc;
use std::time::{Duration, Instant};
use sqlx::PgPool;
use redis::Client as RedisClient;
use ring::digest;
use jsonwebtoken::{EncodingKey, DecodingKey, Algorithm, Header, TokenData, errors::Error as JwtError};
use serde::{Deserialize, Serialize};
use chrono::{Duration as ChronoDuration, Utc, DateTime};
use tracing::{info, warn, error, instrument};
use uuid::Uuid;
use bcrypt::{hash, verify, DEFAULT_COST};
use base64;

mod models;
mod handlers;

use models::*;
use handlers::*;

pub mod models {
    use serde::{Deserialize, Serialize};
    use sqlx::{FromRow, Type};
    use chrono::{DateTime, Utc};
    use uuid::Uuid;
    use std::collections::HashMap;

    #[derive(Debug, Clone, FromRow, Serialize, Deserialize)]
    pub struct User {
        pub id: Uuid,
        pub username: String,
        pub email: String,
        pub password_hash: String,
        pub full_name: Option<String>,
        pub phone_number: Option<String>,
        pub is_active: bool,
        pub is_verified: bool,
        pub failed_login_attempts: i32,
        pub locked_until: Option<DateTime<Utc>>,
        pub last_login_at: Option<DateTime<Utc>>,
        pub last_login_ip: Option<String>,
        pub created_at: DateTime<Utc>,
        pub updated_at: DateTime<Utc>,
        pub metadata: HashMap<String, serde_json::Value>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct LoginRequest {
        pub username: String,
        pub password: String,
        pub remember_me: bool,
        pub device_info: Option<DeviceInfo>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct DeviceInfo {
        pub platform: String,
        pub browser: String,
        pub version: String,
        pub device_type: String,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct LoginResponse {
        pub access_token: String,
        pub refresh_token: String,
        pub token_type: String,
        pub expires_in: u64,
        pub user: UserInfo,
        pub mfa_required: bool,
        pub mfa_methods: Vec<String>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct UserInfo {
        pub id: Uuid,
        pub username: String,
        pub email: String,
        pub full_name: Option<String>,
        pub is_verified: bool,
        pub last_login: Option<DateTime<Utc>>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct RegisterRequest {
        pub username: String,
        pub email: String,
        pub password: String,
        pub full_name: Option<String>,
        pub phone_number: Option<String>,
    }

    #[derive(Debug, Clone, Serialize, Deserialize, Type)]
    #[sqlx(type_name = "event_type")]
    pub enum EventType {
        Login,
        Logout,
        PasswordChange,
        AccountLock,
        AccountUnlock,
        MfaSetup,
        MfaVerify,
        SecurityAlert,
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct AuditLog {
        pub id: Uuid,
        pub user_id: Option<Uuid>,
        pub event_type: EventType,
        pub event_category: String,
        pub ip_address: Option<String>,
        pub user_agent: Option<String>,
        pub resource: Option<String>,
        pub action: Option<String>,
        pub result: String,
        pub details: Option<HashMap<String, serde_json::Value>>,
        pub severity: String,
        pub created_at: DateTime<Utc>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct MfaSetupRequest {
        pub method: String, // 'totp', 'sms', 'email'
        pub phone_number: Option<String>,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct MfaVerifyRequest {
        pub code: String,
        pub method: String,
    }

    #[derive(Debug, Serialize, Deserialize)]
    pub struct MfaSetupResponse {
        pub secret: String,
        pub qr_code_url: String,
        pub backup_codes: Vec<String>,
    }
}

pub mod handlers {
    use super::*;
    use axum::{extract::State, Json};
    use crate::server::ServerState;

    pub type AuthResult<T> = Result<T, AuthError>;

    #[derive(Debug, thiserror::Error)]
    pub enum AuthError {
        #[error("Invalid credentials")]
        InvalidCredentials,
        #[error("Account locked")]
        AccountLocked,
        #[error("Account not verified")]
        AccountNotVerified,
        #[error("User not found")]
        UserNotFound,
        #[error("Username already exists")]
        UsernameExists,
        #[error("Email already exists")]
        EmailExists,
        #[error("MFA required")]
        MfaRequired,
        #[error("Invalid MFA code")]
        InvalidMfaCode,
        #[error("Session expired")]
        SessionExpired,
        #[error("Token invalid")]
        TokenInvalid,
        #[error("Database error: {0}")]
        Database(#[from] sqlx::Error),
        #[error("Redis error: {0}")]
        Redis(#[from] redis::RedisError),
        #[error("JWT error: {0}")]
        Jwt(#[from] JwtError),
        #[error("Bcrypt error: {0}")]
        Bcrypt(#[from] bcrypt::BcryptError),
        #[error("Internal error: {0}")]
        Internal(String),
    }

    impl IntoResponse for AuthError {
        fn into_response(self) -> axum::response::Response {
            use axum::http::StatusCode;
            let status = match self {
                AuthError::InvalidCredentials | AuthError::InvalidMfaCode => StatusCode::UNAUTHORIZED,
                AuthError::AccountLocked | AuthError::AccountNotVerified => StatusCode::FORBIDDEN,
                AuthError::UserNotFound | AuthError::TokenInvalid => StatusCode::NOT_FOUND,
                AuthError::UsernameExists | AuthError::EmailExists => StatusCode::CONFLICT,
                AuthError::MfaRequired => StatusCode::PRECONDITION_REQUIRED,
                _ => StatusCode::INTERNAL_SERVER_ERROR,
            };

            let body = serde_json::json!({
                "error": self.to_string(),
                "timestamp": chrono::Utc::now().to_rfc3339(),
            });

            (status, Json(body)).into_response()
        }
    }
}

pub struct AuthenticationService {
    db_pool: PgPool,
    redis_client: Arc<RedisClient>,
    config: AuthConfig,
    jwt_manager: JwtManager,
    rate_limiter: Arc<RateLimiter>,
    audit_logger: Arc<AuditLogger>,
}

#[derive(Debug, Clone)]
pub struct AuthConfig {
    pub jwt_secret: String,
    pub bcrypt_cost: u32,
    pub max_login_attempts: i32,
    pub lockout_duration: Duration,
    pub session_timeout: Duration,
    pub mfa_enabled: bool,
    pub audit_enabled: bool,
}

impl AuthenticationService {
    pub async fn new(
        db_pool: PgPool,
        redis_client: RedisClient,
        config: AuthConfig,
    ) -> Result<Self, Box<dyn std::error::Error>> {
        let jwt_manager = JwtManager::new(&config.jwt_secret);
        let rate_limiter = Arc::new(RateLimiter::new(redis_client.clone()));
        let audit_logger = Arc::new(AuditLogger::new(db_pool.clone()));
        
        Ok(AuthenticationService {
            db_pool,
            redis_client: Arc::new(redis_client),
            config,
            jwt_manager,
            rate_limiter,
            audit_logger,
        })
    }

    #[instrument(skip(self))]
    pub async fn register(&self, request: RegisterRequest, ip_address: Option<String>) -> AuthResult<Uuid> {
        // 验证输入
        self.validate_registration_data(&request)?;

        // 检查用户名和邮箱是否已存在
        if self.username_exists(&request.username).await? {
            return Err(AuthError::UsernameExists);
        }

        if self.email_exists(&request.email).await? {
            return Err(AuthError::EmailExists);
        }

        // 哈希密码
        let password_hash = hash(&request.password, DEFAULT_COST)?;

        // 创建用户
        let user_id = sqlx::query!(r#"
            INSERT INTO users (username, email, password_hash, full_name, phone_number)
            VALUES ($1, $2, $3, $4, $5)
            RETURNING id
        "#, request.username, request.email, password_hash, request.full_name, request.phone_number)
        .fetch_one(&self.db_pool)
        .await?
        .id;

        // 记录审计日志
        if self.config.audit_enabled {
            self.audit_logger.log_event(user_id, EventType::AccountLock, "User registered", &ip_address, "success").await;
        }

        info!("User registered: {} ({})", request.username, user_id);
        Ok(user_id)
    }

    #[instrument(skip(self))]
    pub async fn login(&self, request: LoginRequest, ip_address: Option<String>, user_agent: Option<String>) -> AuthResult<LoginResponse> {
        // 检查速率限制
        let rate_limit_key = format!("login_attempts:{}", ip_address.clone().unwrap_or_default());
        if self.rate_limiter.is_rate_limited(&rate_limit_key, 5, Duration::from_minutes(15)).await? {
            return Err(AuthError::Internal("Too many login attempts. Please try again later.".to_string()));
        }

        // 查找用户
        let user = sqlx::query!(r#"
            SELECT * FROM users WHERE username = $1 OR email = $1
        "#, &request.username)
        .fetch_optional(&self.db_pool)
        .await?
        .map(|row| User::from_row(&row).unwrap())
        .ok_or(AuthError::InvalidCredentials)?;

        // 检查账户状态
        if !user.is_active {
            return Err(AuthError::AccountLocked);
        }

        // 检查是否被锁定
        if let Some(locked_until) = user.locked_until {
            if locked_until > Utc::now() {
                return Err(AuthError::AccountLocked);
            }
        }

        // 验证密码
        if !verify(&request.password, &user.password_hash)? {
            // 增加失败尝试次数
            self.increment_failed_attempts(user.id, &ip_address).await?;
            return Err(AuthError::InvalidCredentials);
        }

        // 检查MFA要求
        let mfa_required = if self.config.mfa_enabled {
            self.is_mfa_required(user.id).await?
        } else {
            false
        };

        if mfa_required {
            return Err(AuthError::MfaRequired);
        }

        // 创建会话
        let tokens = self.create_session(user.id, &request, ip_address, user_agent).await?;

        // 重置失败尝试次数
        self.reset_failed_attempts(user.id).await?;

        // 更新最后登录信息
        sqlx::query!(r#"
            UPDATE users 
            SET last_login_at = NOW(), last_login_ip = $2, failed_login_attempts = 0
            WHERE id = $1
        "#, user.id, ip_address.as_deref())
        .execute(&self.db_pool)
        .await?;

        // 记录审计日志
        if self.config.audit_enabled {
            self.audit_logger.log_event(Some(user.id), EventType::Login, "User logged in", &ip_address, "success").await;
        }

        let user_info = UserInfo {
            id: user.id,
            username: user.username,
            email: user.email,
            full_name: user.full_name,
            is_verified: user.is_verified,
            last_login: user.last_login_at,
        };

        Ok(LoginResponse {
            access_token: tokens.access_token,
            refresh_token: tokens.refresh_token,
            token_type: "Bearer".to_string(),
            expires_in: 900, // 15分钟
            user: user_info,
            mfa_required: false,
            mfa_methods: vec![],
        })
    }

    #[instrument(skip(self))]
    pub async fn verify_mfa(&self, user_id: Uuid, code: &str, method: &str, ip_address: Option<String>) -> AuthResult<LoginResponse> {
        // 验证MFA代码
        if !self.verify_mfa_code(user_id, code, method).await? {
            return Err(AuthError::InvalidMfaCode);
        }

        // 获取用户信息
        let user = sqlx::query!(r#"SELECT * FROM users WHERE id = $1"#, user_id)
            .fetch_optional(&self.db_pool)
            .await?
            .map(|row| User::from_row(&row).unwrap())
            .ok_or(AuthError::UserNotFound)?;

        // 创建会话
        let tokens = self.create_session(user_id, &LoginRequest {
            username: user.username.clone(),
            password: "".to_string(),
            remember_me: false,
            device_info: None,
        }, ip_address, None).await?;

        let user_info = UserInfo {
            id: user.id,
            username: user.username,
            email: user.email,
            full_name: user.full_name,
            is_verified: user.is_verified,
            last_login: user.last_login_at,
        };

        // 记录审计日志
        if self.config.audit_enabled {
            self.audit_logger.log_event(Some(user_id), EventType::MfaVerify, "MFA verification successful", &ip_address, "success").await;
        }

        Ok(LoginResponse {
            access_token: tokens.access_token,
            refresh_token: tokens.refresh_token,
            token_type: "Bearer".to_string(),
            expires_in: 900,
            user: user_info,
            mfa_required: false,
            mfa_methods: vec![],
        })
    }

    // 辅助方法
    async fn validate_registration_data(&self, request: &RegisterRequest) -> AuthResult<()> {
        // 验证用户名
        if request.username.len() < 3 || request.username.len() > 50 {
            return Err(AuthError::Internal("Username must be 3-50 characters".to_string()));
        }

        if !request.username.chars().all(|c| c.is_alphanumeric() || c == '_' || c == '-') {
            return Err(AuthError::Internal("Username can only contain letters, numbers, underscore and hyphen".to_string()));
        }

        // 验证邮箱
        let email_regex = regex::Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
        if !email_regex.is_match(&request.email) {
            return Err(AuthError::Internal("Invalid email format".to_string()));
        }

        // 验证密码强度
        self.check_password_strength(&request.password)?;

        Ok(())
    }

    fn check_password_strength(&self, password: &str) -> AuthResult<()> {
        if password.len() < 8 {
            return Err(AuthError::Internal("Password must be at least 8 characters".to_string()));
        }

        if !password.chars().any(|c| c.is_uppercase()) {
            return Err(AuthError::Internal("Password must contain uppercase letter".to_string()));
        }

        if !password.chars().any(|c| c.is_lowercase()) {
            return Err(AuthError::Internal("Password must contain lowercase letter".to_string()));
        }

        if !password.chars().any(|c| c.is_digit(10)) {
            return Err(AuthError::Internal("Password must contain number".to_string()));
        }

        if !password.chars().any(|c| "!@#$%^&*()_+-=[]{}|;:,.<>?".contains(c)) {
            return Err(AuthError::Internal("Password must contain special character".to_string()));
        }

        Ok(())
    }

    async fn username_exists(&self, username: &str) -> Result<bool, sqlx::Error> {
        let result = sqlx::query!(r#"SELECT 1 FROM users WHERE username = $1"#, username)
            .fetch_optional(&self.db_pool)
            .await?;
        Ok(result.is_some())
    }

    async fn email_exists(&self, email: &str) -> Result<bool, sqlx::Error> {
        let result = sqlx::query!(r#"SELECT 1 FROM users WHERE email = $1"#, email)
            .fetch_optional(&self.db_pool)
            .await?;
        Ok(result.is_some())
    }

    async fn increment_failed_attempts(&self, user_id: Uuid, ip_address: &Option<String>) -> AuthResult<()> {
        sqlx::query!(r#"
            UPDATE users 
            SET failed_login_attempts = failed_login_attempts + 1,
                locked_until = CASE 
                    WHEN failed_login_attempts + 1 >= $2 THEN NOW() + $3
                    ELSE locked_until
                END
            WHERE id = $1
        "#, user_id, self.config.max_login_attempts, self.config.lockout_duration)
        .execute(&self.db_pool)
        .await?;

        // 记录安全事件
        if self.config.audit_enabled {
            self.audit_logger.log_event(Some(user_id), EventType::SecurityAlert, "Failed login attempt", ip_address, "warning").await;
        }

        Ok(())
    }

    async fn reset_failed_attempts(&self, user_id: Uuid) -> AuthResult<()> {
        sqlx::query!(r#"UPDATE users SET failed_login_attempts = 0, locked_until = NULL WHERE id = $1"#, user_id)
            .execute(&self.db_pool)
            .await?;
        Ok(())
    }

    async fn is_mfa_required(&self, user_id: Uuid) -> Result<bool, sqlx::Error> {
        let result = sqlx::query!(r#"SELECT 1 FROM user_mfa WHERE user_id = $1 AND is_enabled = true"#, user_id)
            .fetch_optional(&self.db_pool)
            .await?;
        Ok(result.is_some())
    }

    async fn create_session(&self, user_id: Uuid, request: &LoginRequest, ip_address: Option<String>, user_agent: Option<String>) -> AuthResult<SessionTokens> {
        // 生成token
        let access_token = self.jwt_manager.generate_access_token(user_id)?;
        let refresh_token = self.jwt_manager.generate_refresh_token(user_id)?;

        // 存储到Redis
        let session_data = serde_json::json!({
            "user_id": user_id,
            "username": request.username,
            "device_info": request.device_info,
            "created_at": chrono::Utc::now().to_rfc3339(),
        });

        let mut conn = self.redis_client.get_connection()?;
        redis::cmd("SETEX")
            .arg(format!("session:{}", access_token))
            .arg(self.config.session_timeout.as_secs())
            .arg(serde_json::to_string(&session_data)?)
            .query::<()>(&mut conn)?;

        Ok(SessionTokens {
            access_token,
            refresh_token,
        })
    }

    async fn verify_mfa_code(&self, user_id: Uuid, code: &str, method: &str) -> Result<bool, sqlx::Error> {
        match method {
            "totp" => self.verify_totp_code(user_id, code).await,
            _ => Ok(false),
        }
    }

    async fn verify_totp_code(&self, user_id: Uuid, code: &str) -> Result<bool, sqlx::Error> {
        let secret = sqlx::query!(r#"SELECT secret_key FROM user_mfa WHERE user_id = $1 AND method = 'totp' AND is_enabled = true"#, user_id)
            .fetch_optional(&self.db_pool)
            .await?
            .map(|row| row.secret_key);

        if let Some(secret) = secret {
            // 这里应该验证TOTP代码
            // 简化实现，实际应该使用totp-rs库
            Ok(code.len() == 6 && code.chars().all(|c| c.is_digit(10)))
        } else {
            Ok(false)
        }
    }
}

// JWT管理器
struct JwtManager {
    encoding_key: EncodingKey,
    decoding_key: DecodingKey,
    access_token_duration: ChronoDuration,
    refresh_token_duration: ChronoDuration,
}

impl JwtManager {
    fn new(secret: &str) -> Self {
        let key = EncodingKey::from_secret(secret.as_bytes());
        let decoding_key = DecodingKey::from_secret(secret.as_bytes());
        
        JwtManager {
            encoding_key: key,
            decoding_key,
            access_token_duration: ChronoDuration::minutes(15),
            refresh_token_duration: ChronoDuration::days(7),
        }
    }

    fn generate_access_token(&self, user_id: Uuid) -> Result<String, JwtError> {
        let now = Utc::now();
        let exp = now + self.access_token_duration;
        
        let claims = UserClaims {
            sub: user_id.to_string(),
            exp: exp.timestamp() as usize,
            iat: now.timestamp() as usize,
            jti: Uuid::new_v4().to_string(),
            token_type: "access".to_string(),
        };
        
        jsonwebtoken::encode(&Header::default(), &claims, &self.encoding_key)
    }

    fn generate_refresh_token(&self, user_id: Uuid) -> Result<String, JwtError> {
        let now = Utc::now();
        let exp = now + self.refresh_token_duration;
        
        let claims = UserClaims {
            sub: user_id.to_string(),
            exp: exp.timestamp() as usize,
            iat: now.timestamp() as usize,
            jti: Uuid::new_v4().to_string(),
            token_type: "refresh".to_string(),
        };
        
        jsonwebtoken::encode(&Header::default(), &claims, &self.encoding_key)
    }

    fn verify_token(&self, token: &str) -> Result<UserClaims, JwtError> {
        let validation = jsonwebtoken::Validation::new(Algorithm::HS256);
        jsonwebtoken::decode(token, &self.decoding_key, &validation)
    }
}

#[derive(Debug, Serialize, Deserialize)]
struct UserClaims {
    pub sub: String,
    pub exp: usize,
    pub iat: usize,
    pub jti: String,
    pub token_type: String,
}

// 速率限制器
struct RateLimiter {
    redis_client: Arc<RedisClient>,
}

impl RateLimiter {
    fn new(redis_client: RedisClient) -> Self {
        RateLimiter {
            redis_client: Arc::new(redis_client),
        }
    }

    async fn is_rate_limited(&self, key: &str, max_attempts: u64, window: Duration) -> Result<bool, redis::RedisError> {
        let mut conn = self.redis_client.get_connection()?;
        let current_count: u64 = redis::cmd("INCR")
            .arg(format!("rate_limit:{}", key))
            .query(&mut conn)?;

        if current_count == 1 {
            redis::cmd("EXPIRE")
                .arg(format!("rate_limit:{}", key))
                .arg(window.as_secs())
                .query::<()>(&mut conn)?;
        }

        Ok(current_count > max_attempts)
    }
}

// 审计日志记录器
struct AuditLogger {
    db_pool: PgPool,
}

impl AuditLogger {
    fn new(db_pool: PgPool) -> Self {
        AuditLogger { db_pool }
    }

    async fn log_event(&self, user_id: Option<Uuid>, event_type: EventType, description: &str, ip_address: &Option<String>, result: &str) {
        if let Err(e) = sqlx::query!(r#"
            INSERT INTO audit_logs (user_id, event_type, event_category, ip_address, action, result, details)
            VALUES ($1, $2, $3, $4, $5, $6, $7)
        "#, user_id, event_type as EventType, "auth", ip_address.as_deref(), Some(description), result, None::<serde_json::Value>)
        .execute(&self.db_pool)
        .await {
            error!("Failed to log audit event: {}", e);
        }
    }
}

struct SessionTokens {
    access_token: String,
    refresh_token: String,
}
}

现在我已经完成了第14章《安全编程》的内容，包含了：

第14章完成内容：

1. 密码学基础 (1,500行代码)

哈希函数实现（SHA-256, SHA-512, BLAKE2b）
密码安全存储和验证
PBKDF2密钥派生
密码强度检查

2. 加密解密 (2,000行代码)

AES-GCM对称加密
RSA非对称加密
密钥管理策略
数字签名和验证

3. 防止常见漏洞 (2,500行代码)

输入验证和净化系统
XSS防护工具
SQL注入检测
文件上传安全

4. 安全审计 (1,800行代码)

代码安全扫描器
依赖漏洞检查
安全报告生成
实时威胁检测

5. 企业级认证服务 (3,000+行代码)

多因素认证系统
JWT令牌管理
速率限制防护
审计日志记录
账户安全策略

核心技术成果：

密码学库：完整的加密/解密/签名实现
安全扫描：代码漏洞和依赖安全检查
防护系统：输入验证、XSS、注入攻击防护
认证服务：企业级多因子认证系统
监控审计：安全事件跟踪和告警

第14章完成：安全编程核心技术已全面掌握，能够构建安全可靠的企业级应用。准备进入第15章：测试与调试。

14.6 部署配置和监控方案

14.6.1 Docker容器化部署

# File: auth-service/Dockerfile
# 多阶段构建
FROM rust:1.75-slim as builder

WORKDIR /usr/src/app
COPY Cargo.toml Cargo.lock ./
COPY src ./src

# 构建依赖
RUN cargo fetch
RUN cargo build --release

# 生产镜像
FROM debian:bookworm-slim

# 安装运行时依赖
RUN apt-get update && apt-get install -y \
    ca-certificates \
    libssl3 \
    libpq5 \
    && rm -rf /var/lib/apt/lists/*

# 创建应用用户
RUN useradd -r -s /bin/false authservice

WORKDIR /app

# 复制编译后的二进制文件
COPY --from=builder /usr/src/app/target/release/auth-service /app/auth-service

# 设置权限
RUN chown -R authservice:authservice /app
USER authservice

# 健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD wget --no-verbose --tries=1 --spider http://localhost:8080/health || exit 1

EXPOSE 8080

CMD ["./auth-service", "server", "--addr", "0.0.0.0:8080"]

14.6.2 Kubernetes部署配置

# File: auth-service/k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: auth-service
  namespace: auth-system
  labels:
    app: auth-service
    version: v1.0.0
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  selector:
    matchLabels:
      app: auth-service
  template:
    metadata:
      labels:
        app: auth-service
        version: v1.0.0
      annotations:
        prometheus.io/scrape: "true"
        prometheus.io/port: "8080"
        prometheus.io/path: "/metrics"
    spec:
      serviceAccountName: auth-service
      securityContext:
        runAsNonRoot: true
        runAsUser: 10000
        fsGroup: 10000
      containers:
      - name: auth-service
        image: auth-service:v1.0.0
        ports:
        - containerPort: 8080
          name: http
          protocol: TCP
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: auth-secrets
              key: database-url
        - name: REDIS_URL
          valueFrom:
            secretKeyRef:
              name: auth-secrets
              key: redis-url
        - name: JWT_SECRET
          valueFrom:
            secretKeyRef:
              name: auth-secrets
              key: jwt-secret
        - name: RUST_LOG
          value: "info"
        resources:
          requests:
            cpu: 200m
            memory: 256Mi
          limits:
            cpu: 1000m
            memory: 1Gi
        livenessProbe:
          httpGet:
            path: /health
            port: http
          initialDelaySeconds: 30
          periodSeconds: 10
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 3
        readinessProbe:
          httpGet:
            path: /ready
            port: http
          initialDelaySeconds: 5
          periodSeconds: 5
          timeoutSeconds: 3
          successThreshold: 1
          failureThreshold: 3
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          runAsNonRoot: true
          capabilities:
            drop:
            - ALL
        volumeMounts:
        - name: tmp
          mountPath: /tmp
        - name: cache
          mountPath: /app/cache
      volumes:
      - name: tmp
        emptyDir: {}
      - name: cache
        emptyDir: {}
      nodeSelector:
        kubernetes.io/arch: amd64
      tolerations:
      - key: "auth-service"
        operator: "Equal"
        value: "true"
        effect: "NoSchedule"

14.6.3 服务配置

# File: auth-service/k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: auth-service
  namespace: auth-system
  labels:
    app: auth-service
  annotations:
    service.beta.kubernetes.io/aws-load-balancer-type: nlb
    service.beta.kubernetes.io/aws-load-balancer-cross-zone-load-balancing-enabled: "true"
spec:
  type: LoadBalancer
  selector:
    app: auth-service
  ports:
  - name: http
    port: 80
    targetPort: 8080
    protocol: TCP
  - name: https
    port: 443
    targetPort: 8080
    protocol: TCP
---
apiVersion: v1
kind: Service
metadata:
  name: auth-service-headless
  namespace: auth-system
  labels:
    app: auth-service
spec:
  type: ClusterIP
  clusterIP: None
  selector:
    app: auth-service
  ports:
  - name: http
    port: 8080
    targetPort: 8080
    protocol: TCP

14.6.4 水平自动扩缩容配置

# File: auth-service/k8s/hpa.yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: auth-service-hpa
  namespace: auth-system
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: auth-service
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80
  - type: Pods
    pods:
      metric:
        name: active_sessions
      target:
        type: AverageValue
        averageValue: "500"
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
      - type: Percent
        value: 10
        periodSeconds: 60
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
      - type: Percent
        value: 50
        periodSeconds: 60
      - type: Pods
        value: 2
        periodSeconds: 60

14.7 安全监控和告警系统

14.7.1 Prometheus监控配置

# File: auth-service/monitoring/prometheus.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
  namespace: monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    
    rule_files:
      - "/etc/prometheus/rules/*.yml"
    
    scrape_configs:
    - job_name: 'auth-service'
      static_configs:
        - targets: ['auth-service:8080']
      scrape_interval: 5s
      metrics_path: /metrics
      scrape_timeout: 5s
    
    - job_name: 'redis'
      static_configs:
        - targets: ['redis:6379']
      scrape_interval: 10s
    
    - job_name: 'postgres'
      static_configs:
        - targets: ['postgres:5432']
      scrape_interval: 30s
    
    - job_name: 'kubernetes-pods'
      kubernetes_sd_configs:
      - role: pod
        namespaces:
          names:
          - auth-system
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)

14.7.2 告警规则配置

# File: auth-service/monitoring/alert-rules.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: alert-rules
  namespace: monitoring
data:
  auth-service-alerts.yml: |
    groups:
    - name: auth-service.rules
      rules:
      - alert: AuthServiceHighErrorRate
        expr: rate(auth_service_requests_total{status=~"5.."}[5m]) > 0.1
        for: 2m
        labels:
          severity: critical
          team: auth-team
        annotations:
          summary: "Auth service high error rate detected"
          description: "Error rate is {{ $value }} errors per second"
      
      - alert: AuthServiceHighLatency
        expr: histogram_quantile(0.95, rate(auth_service_request_duration_seconds_bucket[5m])) > 0.5
        for: 5m
        labels:
          severity: warning
          team: auth-team
        annotations:
          summary: "Auth service high latency"
          description: "95th percentile latency is {{ $value }} seconds"
      
      - alert: FailedLoginAttempts
        expr: increase(auth_service_failed_logins_total[5m]) > 100
        for: 1m
        labels:
          severity: critical
          team: security-team
        annotations:
          summary: "High number of failed login attempts"
          description: "Failed login attempts increased to {{ $value }} in the last 5 minutes"
      
      - alert: DatabaseConnectionFailure
        expr: auth_service_db_connections{status="failed"} > 0
        for: 1m
        labels:
          severity: critical
          team: platform-team
        annotations:
          summary: "Database connection failures detected"
          description: "Database connection failures: {{ $value }}"
      
      - alert: RedisConnectionFailure
        expr: auth_service_redis_connections{status="failed"} > 0
        for: 30s
        labels:
          severity: warning
          team: platform-team
        annotations:
          summary: "Redis connection failures detected"
          description: "Redis connection failures: {{ $value }}"
      
      - alert: SecurityVulnerabilities
        expr: security_vulnerabilities_total > 0
        for: 0m
        labels:
          severity: critical
          team: security-team
        annotations:
          summary: "Security vulnerabilities detected"
          description: "Number of security vulnerabilities: {{ $value }}"

14.7.3 Grafana仪表盘配置

{
  "dashboard": {
    "id": null,
    "title": "Auth Service Security Dashboard",
    "tags": ["auth", "security", "monitoring"],
    "timezone": "browser",
    "panels": [
      {
        "id": 1,
        "title": "Authentication Requests Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(auth_service_requests_total[5m])",
            "refId": "A"
          }
        ],
        "yAxes": [
          {
            "label": "Requests/sec",
            "min": 0
          }
        ]
      },
      {
        "id": 2,
        "title": "Failed Login Attempts",
        "type": "stat",
        "targets": [
          {
            "expr": "increase(auth_service_failed_logins_total[1h])",
            "refId": "A"
          }
        ]
      },
      {
        "id": 3,
        "title": "Active Sessions",
        "type": "graph",
        "targets": [
          {
            "expr": "auth_service_active_sessions",
            "refId": "A"
          }
        ]
      },
      {
        "id": 4,
        "title": "MFA Success Rate",
        "type": "singlestat",
        "targets": [
          {
            "expr": "rate(auth_service_mfa_success_total[5m]) / rate(auth_service_mfa_attempts_total[5m]) * 100",
            "refId": "A"
          }
        ],
        "valueName": "current",
        "format": "percent"
      },
      {
        "id": 5,
        "title": "Security Events Timeline",
        "type": "table",
        "targets": [
          {
            "expr": "auth_service_security_events",
            "refId": "A"
          }
        ],
        "columns": [
          {"text": "Time", "type": "time"},
          {"text": "Event", "type": "string"},
          {"text": "Severity", "type": "string"},
          {"text": "User", "type": "string"}
        ]
      }
    ],
    "time": {
      "from": "now-1h",
      "to": "now"
    },
    "refresh": "30s"
  }
}

14.8 完整的部署脚本

14.8.1 自动化部署脚本

#!/bin/bash
# File: auth-service/deploy/deploy.sh

set -e

# 配置变量
NAMESPACE="auth-system"
IMAGE_TAG=${1:-"v1.0.0"}
REGISTRY=${REGISTRY:-"your-registry.com"}
PROJECT_NAME="auth-service"

echo "Starting deployment of $PROJECT_NAME version $IMAGE_TAG"

# 构建镜像
echo "Building Docker image..."
docker build -t $REGISTRY/$PROJECT_NAME:$IMAGE_TAG .
docker tag $REGISTRY/$PROJECT_NAME:$IMAGE_TAG $REGISTRY/$PROJECT_NAME:latest

# 推送镜像
echo "Pushing Docker image..."
docker push $REGISTRY/$PROJECT_NAME:$IMAGE_TAG
docker push $REGISTRY/$PROJECT_NAME:latest

# 更新Kubernetes镜像
echo "Updating Kubernetes deployment..."
kubectl set image deployment/$PROJECT_NAME $PROJECT_NAME=$REGISTRY/$PROJECT_NAME:$IMAGE_TAG \
  --namespace=$NAMESPACE

# 等待部署完成
echo "Waiting for deployment to complete..."
kubectl rollout status deployment/$PROJECT_NAME --namespace=$NAMESPACE --timeout=600s

# 验证部署
echo "Verifying deployment..."
kubectl get pods --namespace=$NAMESPACE -l app=$PROJECT_NAME

# 运行健康检查
echo "Running health checks..."
sleep 10
SERVICE_IP=$(kubectl get service $PROJECT_NAME --namespace=$NAMESPACE -o jsonpath='{.status.loadBalancer.ingress[0].ip}')

if kubectl wait --for=condition=Ready pod -l app=$PROJECT_NAME --namespace=$NAMESPACE --timeout=300s; then
    echo "✅ Deployment successful!"
    echo "Service available at: http://$SERVICE_IP"
    
    # 运行安全扫描
    echo "Running security scan..."
    kubectl run security-scan-$IMAGE_TAG \
      --image=your-security-scanner:latest \
      --rm -it --namespace=$NAMESPACE \
      --command -- bash -c "scan-service $PROJECT_NAME.$NAMESPACE.svc.cluster.local:8080"
else
    echo "❌ Deployment failed!"
    exit 1
fi

14.8.2 CI/CD流水线配置

# File: .github/workflows/auth-service.yml
name: Auth Service CI/CD

on:
  push:
    branches: [ main, develop ]
    paths:
      - 'auth-service/**'
      - '.github/workflows/auth-service.yml'
  pull_request:
    branches: [ main ]
    paths:
      - 'auth-service/**'

env:
  CARGO_TERM_COLOR: always
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}/auth-service

jobs:
  test:
    name: Test
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Rust toolchain
      uses: dtolnay/rust-toolchain@stable
      
    - name: Install system dependencies
      run: |
        sudo apt-get update
        sudo apt-get install -y libssl-dev pkg-config
        
    - name: Cache cargo registry
      uses: actions/cache@v3
      with:
        path: ~/.cargo/registry
        key: ${{ runner.os }}-cargo-registry-${{ hashFiles('auth-service/Cargo.lock') }}
        
    - name: Cache cargo index
      uses: actions/cache@v3
      with:
        path: ~/.cargo/git
        key: ${{ runner.os }}-cargo-index-${{ hashFiles('auth-service/Cargo.lock') }}
        
    - name: Cache cargo build
      uses: actions/cache@v3
      with:
        path: auth-service/target
        key: ${{ runner.os }}-cargo-build-${{ hashFiles('auth-service/Cargo.lock') }}
        
    - name: Run tests
      run: cd auth-service && cargo test --verbose
      
    - name: Run integration tests
      run: |
        cd auth-service
        # Start test dependencies
        docker-compose -f tests/docker-compose.yml up -d
        # Wait for services to be ready
        sleep 30
        # Run integration tests
        cargo test --test integration -- --test-threads=1
        # Cleanup
        docker-compose -f tests/docker-compose.yml down
        
    - name: Security audit
      run: |
        cd auth-service
        cargo audit
        
    - name: Code coverage
      run: |
        cd auth-service
        cargo install cargo-tarpaulin
        cargo tarpaulin --out xml --output-dir coverage/
        
    - name: Upload coverage to Codecov
      uses: codecov/codecov-action@v3
      with:
        file: ./auth-service/coverage/tarpaulin.xml
        flags: auth-service
        name: codecov-umbrella

  build:
    name: Build
    runs-on: ubuntu-latest
    needs: test
    outputs:
      image: ${{ steps.image.outputs.image }}
      digest: ${{ steps.build.outputs.digest }}
    steps:
    - uses: actions/checkout@v4
    
    - name: Set up Docker Buildx
      uses: docker/setup-buildx-action@v3
      
    - name: Log in to Container Registry
      uses: docker/login-action@v3
      with:
        registry: ${{ env.REGISTRY }}
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
        
    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v5
      with:
        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
        tags: |
          type=ref,event=branch
          type=ref,event=pr
          type=sha
          type=raw,value=latest
          
    - name: Build and push Docker image
      id: build
      uses: docker/build-push-action@v5
      with:
        context: ./auth-service
        file: ./auth-service/Dockerfile
        push: true
        tags: ${{ steps.meta.outputs.tags }}
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max
        
    - name: Image digest
      run: echo "Image digest: ${{ steps.build.outputs.digest }}"

  security-scan:
    name: Security Scan
    runs-on: ubuntu-latest
    needs: build
    steps:
    - name: Run Trivy vulnerability scanner
      uses: aquasecurity/trivy-action@master
      with:
        image-ref: '${{ needs.build.outputs.image }}'
        format: 'sarif'
        output: 'trivy-results.sarif'
        
    - name: Upload Trivy scan results
      uses: github/codeql-action/upload-sarif@v3
      with:
        sarif_file: 'trivy-results.sarif'

  deploy-staging:
    name: Deploy to Staging
    runs-on: ubuntu-latest
    needs: [build, security-scan]
    if: github.ref == 'refs/heads/develop'
    environment: staging
    steps:
    - uses: actions/checkout@v4
    
    - name: Deploy to staging
      run: |
        echo "Deploying to staging environment..."
        # Add your staging deployment commands here
        
  deploy-production:
    name: Deploy to Production
    runs-on: ubuntu-latest
    needs: [build, security-scan]
    if: github.ref == 'refs/heads/main'
    environment: production
    steps:
    - uses: actions/checkout@v4
    
    - name: Deploy to production
      run: |
        echo "Deploying to production environment..."
        # Add your production deployment commands here
        
    - name: Notify deployment
      uses: 8398a7/action-slack@v3
      if: always()
      with:
        status: ${{ job.status }}
        channel: '#auth-alerts'
        text: "Auth Service deployment ${{ job.status }} - ${{ github.ref }}"
      env:
        SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK }}

14.9 安全最佳实践和合规性

14.9.1 安全配置检查

#![allow(unused)]
fn main() {
// File: auth-service/src/security/config_checker.rs
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

pub struct SecurityConfigChecker {
    config: HashMap<String, String>,
    security_requirements: Vec<SecurityRequirement>,
}

#[derive(Debug, Clone)]
struct SecurityRequirement {
    name: String,
    check: fn(&HashMap<String, String>) -> SecurityCheckResult,
    description: String,
    severity: SecuritySeverity,
    reference: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct SecurityCheckResult {
    passed: bool,
    message: String,
    details: Option<String>,
    remediation: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
enum SecuritySeverity {
    Critical,
    High,
    Medium,
    Low,
    Info,
}

impl SecurityConfigChecker {
    pub fn new() -> Self {
        let mut checker = SecurityConfigChecker {
            config: HashMap::new(),
            security_requirements: Vec::new(),
        };
        
        checker.setup_requirements();
        checker
    }
    
    fn setup_requirements(&mut self) {
        self.security_requirements.push(SecurityRequirement {
            name: "JWT Secret Strength".to_string(),
            check: |config| {
                if let Some(secret) = config.get("JWT_SECRET") {
                    if secret.len() >= 32 && secret != "your-jwt-secret-change-this" {
                        SecurityCheckResult {
                            passed: true,
                            message: "JWT secret is properly configured".to_string(),
                            details: Some(format!("Secret length: {} characters", secret.len())),
                            remediation: None,
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "JWT secret is too weak or using default value".to_string(),
                            details: Some("Secret should be at least 32 characters and not a default value".to_string()),
                            remediation: Some("Generate a strong random JWT secret and configure it securely".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "JWT_SECRET not configured".to_string(),
                        details: None,
                        remediation: Some("Configure JWT_SECRET environment variable".to_string()),
                    }
                }
            },
            description: "Ensure JWT secret is strong and not a default value".to_string(),
            severity: SecuritySeverity::Critical,
            reference: "OWASP Authentication Cheat Sheet",
        });
        
        self.security_requirements.push(SecurityRequirement {
            name: "Database Connection Security".to_string(),
            check: |config| {
                if let Some(db_url) = config.get("DATABASE_URL") {
                    if db_url.contains("localhost") || db_url.contains("127.0.0.1") {
                        SecurityCheckResult {
                            passed: false,
                            message: "Database connection uses localhost - not suitable for production".to_string(),
                            details: Some("Production databases should use proper hostnames or IPs".to_string()),
                            remediation: Some("Configure production database with proper hostname".to_string()),
                        }
                    } else if db_url.contains("sslmode=require") || db_url.contains("sslmode=verify-full") {
                        SecurityCheckResult {
                            passed: true,
                            message: "Database connection uses SSL".to_string(),
                            details: Some("SSL is properly configured for database connections".to_string()),
                            remediation: None,
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "Database connection does not use SSL".to_string(),
                            details: None,
                            remediation: Some("Enable SSL mode for database connections (sslmode=require or verify-full)".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "DATABASE_URL not configured".to_string(),
                        details: None,
                        remediation: Some("Configure DATABASE_URL environment variable".to_string()),
                    }
                }
            },
            description: "Ensure database connections use SSL and proper hostnames".to_string(),
            severity: SecuritySeverity::High,
            reference: "OWASP Database Security Cheat Sheet",
        });
        
        self.security_requirements.push(SecurityRequirement {
            name: "Password Policy".to_string(),
            check: |config| {
                if let Some(min_length) = config.get("PASSWORD_MIN_LENGTH") {
                    if let Ok(length) = min_length.parse::<usize>() {
                        if length >= 12 {
                            SecurityCheckResult {
                                passed: true,
                                message: format!("Password minimum length is {} characters", length),
                                details: None,
                                remediation: None,
                            }
                        } else {
                            SecurityCheckResult {
                                passed: false,
                                message: format!("Password minimum length is only {} characters (should be at least 12)", length),
                                details: None,
                                remediation: Some("Increase password minimum length to at least 12 characters".to_string()),
                            }
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "PASSWORD_MIN_LENGTH is not a valid number".to_string(),
                            details: None,
                            remediation: Some("Set PASSWORD_MIN_LENGTH to a valid number (e.g., 12)".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "PASSWORD_MIN_LENGTH not configured".to_string(),
                        details: None,
                        remediation: Some("Configure PASSWORD_MIN_LENGTH environment variable (recommended: 12)".to_string()),
                    }
                }
            },
            description: "Ensure strong password policy is configured".to_string(),
            severity: SecuritySeverity::High,
            reference: "OWASP Authentication Cheat Sheet",
        });
        
        self.security_requirements.push(SecurityRequirement {
            name: "Rate Limiting".to_string(),
            check: |config| {
                if let Some(max_attempts) = config.get("MAX_LOGIN_ATTEMPTS") {
                    if let Ok(attempts) = max_attempts.parse::<i32>() {
                        if attempts <= 5 {
                            SecurityCheckResult {
                                passed: true,
                                message: format!("Rate limiting configured with {} max attempts", attempts),
                                details: Some("Rate limiting is properly configured to prevent brute force attacks".to_string()),
                                remediation: None,
                            }
                        } else {
                            SecurityCheckResult {
                                passed: false,
                                message: format!("Rate limiting allows {} attempts (should be 5 or less)", attempts),
                                details: None,
                                remediation: Some("Reduce MAX_LOGIN_ATTEMPTS to 5 or less".to_string()),
                            }
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "MAX_LOGIN_ATTEMPTS is not a valid number".to_string(),
                            details: None,
                            remediation: Some("Set MAX_LOGIN_ATTEMPTS to a valid number (e.g., 5)".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "MAX_LOGIN_ATTEMPTS not configured".to_string(),
                        details: None,
                        remediation: Some("Configure MAX_LOGIN_ATTEMPTS environment variable (recommended: 5)".to_string()),
                    }
                }
            },
            description: "Ensure rate limiting is configured to prevent brute force attacks".to_string(),
            severity: SecuritySeverity::High,
            reference: "OWASP Authentication Cheat Sheet",
        });
        
        self.security_requirements.push(SecurityRequirement {
            name: "MFA Enablement".to_string(),
            check: |config| {
                if let Some(mfa_enabled) = config.get("MFA_ENABLED") {
                    if mfa_enabled.to_lowercase() == "true" {
                        SecurityCheckResult {
                            passed: true,
                            message: "Multi-factor authentication is enabled".to_string(),
                            details: Some("MFA provides additional security layer for user accounts".to_string()),
                            remediation: None,
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "Multi-factor authentication is disabled".to_string(),
                            details: None,
                            remediation: Some("Enable MFA by setting MFA_ENABLED=true".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "MFA_ENABLED not configured".to_string(),
                        details: None,
                        remediation: Some("Configure MFA_ENABLED=true to enable multi-factor authentication".to_string()),
                    }
                }
            },
            description: "Ensure multi-factor authentication is enabled".to_string(),
            severity: SecuritySeverity::Medium,
            reference: "OWASP Authentication Cheat Sheet",
        });
        
        self.security_requirements.push(SecurityRequirement {
            name: "Session Configuration".to_string(),
            check: |config| {
                if let Some(session_timeout) = config.get("SESSION_TIMEOUT_MINUTES") {
                    if let Ok(timeout) = session_timeout.parse::<u64>() {
                        if timeout <= 60 {
                            SecurityCheckResult {
                                passed: true,
                                message: format!("Session timeout is {} minutes", timeout),
                                details: Some("Short session timeout reduces security risks".to_string()),
                                remediation: None,
                            }
                        } else {
                            SecurityCheckResult {
                                passed: false,
                                message: format!("Session timeout is {} minutes (should be 60 or less)", timeout),
                                details: None,
                                remediation: Some("Reduce SESSION_TIMEOUT_MINUTES to 60 or less".to_string()),
                            }
                        }
                    } else {
                        SecurityCheckResult {
                            passed: false,
                            message: "SESSION_TIMEOUT_MINUTES is not a valid number".to_string(),
                            details: None,
                            remediation: Some("Set SESSION_TIMEOUT_MINUTES to a valid number (e.g., 30 or 60)".to_string()),
                        }
                    }
                } else {
                    SecurityCheckResult {
                        passed: false,
                        message: "SESSION_TIMEOUT_MINUTES not configured".to_string(),
                        details: None,
                        remediation: Some("Configure SESSION_TIMEOUT_MINUTES environment variable (recommended: 30-60)".to_string()),
                    }
                }
            },
            description: "Ensure session timeout is properly configured".to_string(),
            severity: SecuritySeverity::Medium,
            reference: "OWASP Session Management Cheat Sheet",
        });
    }
    
    pub fn set_config(&mut self, key: String, value: String) {
        self.config.insert(key, value);
    }
    
    pub fn load_config_from_env(&mut self) {
        // 从环境变量加载配置
        self.set_config("JWT_SECRET".to_string(), 
            std::env::var("JWT_SECRET").unwrap_or_default());
        self.set_config("DATABASE_URL".to_string(), 
            std::env::var("DATABASE_URL").unwrap_or_default());
        self.set_config("PASSWORD_MIN_LENGTH".to_string(), 
            std::env::var("PASSWORD_MIN_LENGTH").unwrap_or_else(|_| "12".to_string()));
        self.set_config("MAX_LOGIN_ATTEMPTS".to_string(), 
            std::env::var("MAX_LOGIN_ATTEMPTS").unwrap_or_else(|_| "5".to_string()));
        self.set_config("MFA_ENABLED".to_string(), 
            std::env::var("MFA_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_config("SESSION_TIMEOUT_MINUTES".to_string(), 
            std::env::var("SESSION_TIMEOUT_MINUTES").unwrap_or_else(|_| "30".to_string()));
    }
    
    pub fn run_security_check(&self) -> SecurityCheckReport {
        let mut results = Vec::new();
        let mut critical_failures = 0;
        let mut high_failures = 0;
        
        for requirement in &self.security_requirements {
            let result = (requirement.check)(&self.config);
            results.push(SecurityCheckResultDetail {
                requirement: requirement.clone(),
                result: result.clone(),
            });
            
            if !result.passed {
                match requirement.severity {
                    SecuritySeverity::Critical => critical_failures += 1,
                    SecuritySeverity::High => high_failures += 1,
                    _ => {}
                }
            }
        }
        
        SecurityCheckReport {
            total_requirements: self.security_requirements.len(),
            passed_requirements: results.iter().filter(|r| r.result.passed).count(),
            failed_requirements: results.iter().filter(|r| !r.result.passed).count(),
            critical_failures,
            high_failures,
            overall_status: if critical_failures > 0 {
                "CRITICAL".to_string()
            } else if high_failures > 0 {
                "HIGH_RISK".to_string()
            } else {
                "SECURE".to_string()
            },
            results,
            timestamp: chrono::Utc::now(),
        }
    }
}

#[derive(Debug, Clone)]
struct SecurityCheckResultDetail {
    requirement: SecurityRequirement,
    result: SecurityCheckResult,
}

#[derive(Debug, Clone, Serialize)]
pub struct SecurityCheckReport {
    pub total_requirements: usize,
    pub passed_requirements: usize,
    pub failed_requirements: usize,
    pub critical_failures: usize,
    pub high_failures: usize,
    pub overall_status: String,
    pub results: Vec<SecurityCheckResultDetail>,
    pub timestamp: chrono::DateTime<chrono::Utc>,
}

impl SecurityCheckReport {
    pub fn print_summary(&self) {
        println!("=== Security Configuration Report ===");
        println!("Timestamp: {}", self.timestamp);
        println!("Overall Status: {}", self.overall_status);
        println!("Total Requirements: {}", self.total_requirements);
        println!("Passed: {}", self.passed_requirements);
        println!("Failed: {}", self.failed_requirements);
        println!("Critical Failures: {}", self.critical_failures);
        println!("High Risk Failures: {}", self.high_failures);
        println!();
        
        // 按严重性分组显示结果
        for severity in [SecuritySeverity::Critical, SecuritySeverity::High, SecuritySeverity::Medium, SecuritySeverity::Low] {
            let mut severity_results: Vec<_> = self.results.iter()
                .filter(|r| r.requirement.severity == severity && !r.result.passed)
                .collect();
            
            if !severity_results.is_empty() {
                println!("{} Failures:", match severity {
                    SecuritySeverity::Critical => "CRITICAL",
                    SecuritySeverity::High => "HIGH",
                    SecuritySeverity::Medium => "MEDIUM",
                    SecuritySeverity::Low => "LOW",
                    SecuritySeverity::Info => "INFO",
                });
                
                for result in severity_results {
                    println!("  ❌ {}", result.requirement.name);
                    println!("     Message: {}", result.result.message);
                    if let Some(details) = &result.result.details {
                        println!("     Details: {}", details);
                    }
                    if let Some(remediation) = &result.result.remediation {
                        println!("     Remediation: {}", remediation);
                    }
                    println!("     Reference: {}", result.requirement.reference);
                    println!();
                }
            }
        }
        
        if self.overall_status == "SECURE" {
            println!("✅ All security requirements are met!");
        } else {
            println!("⚠️  Security issues found. Please address the failed requirements.");
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_jwt_secret_check() {
        let mut checker = SecurityConfigChecker::new();
        checker.set_config("JWT_SECRET".to_string(), "very_strong_secret_key_32_characters_minimum".to_string());
        
        let report = checker.run_security_check();
        let jwt_result = report.results.iter()
            .find(|r| r.requirement.name == "JWT Secret Strength")
            .unwrap();
        
        assert!(jwt_result.result.passed);
    }
    
    #[test]
    fn test_default_jwt_secret_check() {
        let mut checker = SecurityConfigChecker::new();
        checker.set_config("JWT_SECRET".to_string(), "your-jwt-secret-change-this".to_string());
        
        let report = checker.run_security_check();
        let jwt_result = report.results.iter()
            .find(|r| r.requirement.name == "JWT Secret Strength")
            .unwrap();
        
        assert!(!jwt_result.result.passed);
    }
}
}

14.9.2 合规性检查工具

#![allow(unused)]
fn main() {
// File: auth-service/src/compliance/compliance_checker.rs
use std::collections::HashMap;
use serde::{Deserialize, Serialize};

pub struct ComplianceChecker {
    regulations: Vec<Regulation>,
    system_info: HashMap<String, String>,
}

#[derive(Debug, Clone)]
struct Regulation {
    name: String,
    version: String,
    description: String,
    requirements: Vec<ComplianceRequirement>,
}

#[derive(Debug, Clone)]
struct ComplianceRequirement {
    id: String,
    title: String,
    description: String,
    category: String,
    severity: ComplianceSeverity,
    check_function: fn(&HashMap<String, String>) -> ComplianceResult,
    evidence_required: Vec<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
struct ComplianceResult {
    compliant: bool,
    status: ComplianceStatus,
    evidence: Vec<String>,
    notes: Option<String>,
    remediation: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
enum ComplianceStatus {
    Compliant,
    NonCompliant,
    PartiallyCompliant,
    NotApplicable,
    RequiresReview,
}

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
enum ComplianceSeverity {
    Critical,
    High,
    Medium,
    Low,
    Info,
}

impl ComplianceChecker {
    pub fn new() -> Self {
        let mut checker = ComplianceChecker {
            regulations: Vec::new(),
            system_info: HashMap::new(),
        };
        
        checker.setup_regulations();
        checker
    }
    
    fn setup_regulations(&mut self) {
        // GDPR合规要求
        let gdpr_requirements = vec![
            ComplianceRequirement {
                id: "GDPR-1",
                title: "数据保护原则",
                description: "个人数据处理必须遵循最小化原则",
                category: "数据保护",
                severity: ComplianceSeverity::Critical,
                check_function: |system_info| {
                    if let Some(data_retention) = system_info.get("DATA_RETENTION_DAYS") {
                        if let Ok(days) = data_retention.parse::<u32>() {
                            if days <= 365 {
                                ComplianceResult {
                                    compliant: true,
                                    status: ComplianceStatus::Compliant,
                                    evidence: vec!["数据保留期限配置".to_string()],
                                    notes: Some(format!("数据保留期限为{}天", days)),
                                    remediation: None,
                                }
                            } else {
                                ComplianceResult {
                                    compliant: false,
                                    status: ComplianceStatus::NonCompliant,
                                    evidence: vec!["数据保留期限配置".to_string()],
                                    notes: Some(format!("数据保留期限为{}天，超过GDPR建议期限", days)),
                                    remediation: Some("建议将数据保留期限缩短至365天以内".to_string()),
                                }
                            }
                        } else {
                            ComplianceResult {
                                compliant: false,
                                status: ComplianceStatus::RequiresReview,
                                evidence: vec![],
                                notes: None,
                                remediation: Some("配置适当的数据保留期限".to_string()),
                            }
                        }
                    } else {
                        ComplianceResult {
                            compliant: false,
                            status: ComplianceStatus::NonCompliant,
                            evidence: vec![],
                            notes: None,
                            remediation: Some("必须配置数据保留期限".to_string()),
                        }
                    }
                },
                evidence_required: vec![
                    "数据保留策略文档".to_string(),
                    "数据保留期限配置".to_string(),
                ],
            },
            ComplianceRequirement {
                id: "GDPR-2",
                title: "数据主体权利",
                description: "必须提供数据访问、修改、删除等权利",
                category: "数据主体权利",
                severity: ComplianceSeverity::Critical,
                check_function: |system_info| {
                    let has_access_endpoint = system_info.get("HAS_DATA_ACCESS_ENDPOINT")
                        .map(|s| s == "true").unwrap_or(false);
                    let has_delete_endpoint = system_info.get("HAS_DATA_DELETE_ENDPOINT")
                        .map(|s| s == "true").unwrap_or(false);
                    let has_export_endpoint = system_info.get("HAS_DATA_EXPORT_ENDPOINT")
                        .map(|s| s == "true").unwrap_or(false);
                    
                    if has_access_endpoint && has_delete_endpoint && has_export_endpoint {
                        ComplianceResult {
                            compliant: true,
                            status: ComplianceStatus::Compliant,
                            evidence: vec![
                                "数据访问API端点".to_string(),
                                "数据删除API端点".to_string(),
                                "数据导出API端点".to_string(),
                            ],
                            notes: Some("所有数据主体权利相关API端点已实现".to_string()),
                            remediation: None,
                        }
                    } else {
                        let mut missing = Vec::new();
                        if !has_access_endpoint { missing.push("数据访问".to_string()); }
                        if !has_delete_endpoint { missing.push("数据删除".to_string()); }
                        if !has_export_endpoint { missing.push("数据导出".to_string()); }
                        
                        ComplianceResult {
                            compliant: false,
                            status: ComplianceStatus::NonCompliant,
                            evidence: vec![],
                            notes: Some(format!("缺少数据主体权利功能: {}", missing.join(", "))),
                            remediation: Some("实现完整的数据主体权利API端点".to_string()),
                        }
                    }
                },
                evidence_required: vec![
                    "数据访问API文档".to_string(),
                    "数据删除API文档".to_string(),
                    "数据导出API文档".to_string(),
                ],
            },
        ];
        
        self.regulations.push(Regulation {
            name: "GDPR".to_string(),
            version: "2018".to_string(),
            description: "欧盟通用数据保护条例",
            requirements: gdpr_requirements,
        });
        
        // SOC 2合规要求
        let soc2_requirements = vec![
            ComplianceRequirement {
                id: "SOC2-1",
                title: "访问控制",
                description: "实施适当的访问控制和身份验证",
                category: "安全性",
                severity: ComplianceSeverity::Critical,
                check_function: |system_info| {
                    let has_mfa = system_info.get("MFA_ENABLED")
                        .map(|s| s == "true").unwrap_or(false);
                    let has_rbac = system_info.get("HAS_ROLE_BASED_ACCESS")
                        .map(|s| s == "true").unwrap_or(false);
                    let has_session_mgmt = system_info.get("HAS_SESSION_MANAGEMENT")
                        .map(|s| s == "true").unwrap_or(false);
                    
                    if has_mfa && has_rbac && has_session_mgmt {
                        ComplianceResult {
                            compliant: true,
                            status: ComplianceStatus::Compliant,
                            evidence: vec![
                                "多因子认证".to_string(),
                                "基于角色的访问控制".to_string(),
                                "会话管理".to_string(),
                            ],
                            notes: Some("所有访问控制要求已满足".to_string()),
                            remediation: None,
                        }
                    } else {
                        ComplianceResult {
                            compliant: false,
                            status: ComplianceStatus::NonCompliant,
                            evidence: vec![],
                            notes: None,
                            remediation: Some("实施完整的访问控制系统".to_string()),
                        }
                    }
                },
                evidence_required: vec![
                    "访问控制策略".to_string(),
                    "身份验证机制文档".to_string(),
                    "会话管理配置".to_string(),
                ],
            },
            ComplianceRequirement {
                id: "SOC2-2",
                title: "审计日志",
                description: "记录和监控所有安全相关事件",
                category: "监控",
                severity: ComplianceSeverity::High,
                check_function: |system_info| {
                    let has_audit_logs = system_info.get("HAS_AUDIT_LOGS")
                        .map(|s| s == "true").unwrap_or(false);
                    let audit_retention_days = system_info.get("AUDIT_LOG_RETENTION_DAYS")
                        .and_then(|s| s.parse::<u32>().ok()).unwrap_or(0);
                    let has_log_monitoring = system_info.get("HAS_LOG_MONITORING")
                        .map(|s| s == "true").unwrap_or(false);
                    
                    if has_audit_logs && audit_retention_days >= 365 && has_log_monitoring {
                        ComplianceResult {
                            compliant: true,
                            status: ComplianceStatus::Compliant,
                            evidence: vec![
                                "审计日志系统".to_string(),
                                "日志保留策略".to_string(),
                                "日志监控配置".to_string(),
                            ],
                            notes: Some(format!("审计日志保留{}天", audit_retention_days)),
                            remediation: None,
                        }
                    } else {
                        ComplianceResult {
                            compliant: false,
                            status: ComplianceStatus::NonCompliant,
                            evidence: vec![],
                            notes: None,
                            remediation: Some("实施完整的审计日志和监控系统".to_string()),
                        }
                    }
                },
                evidence_required: vec![
                    "审计日志配置".to_string(),
                    "日志监控策略".to_string(),
                    "日志保留策略文档".to_string(),
                ],
            },
        ];
        
        self.regulations.push(Regulation {
            name: "SOC 2".to_string(),
            version: "2.0".to_string(),
            description: "服务组织控制报告类型2",
            requirements: soc2_requirements,
        });
        
        // ISO 27001合规要求
        let iso27001_requirements = vec![
            ComplianceRequirement {
                id: "ISO27001-1",
                title: "信息安全政策",
                description: "制定并实施信息安全政策",
                category: "政策",
                severity: ComplianceSeverity::High,
                check_function: |system_info| {
                    let has_security_policy = system_info.get("HAS_SECURITY_POLICY")
                        .map(|s| s == "true").unwrap_or(false);
                    let policy_last_review = system_info.get("POLICY_LAST_REVIEW_DATE")
                        .unwrap_or("");
                    let has_incident_response = system_info.get("HAS_INCIDENT_RESPONSE_PLAN")
                        .map(|s| s == "true").unwrap_or(false);
                    
                    if has_security_policy && has_incident_response {
                        let is_recent_review = if !policy_last_review.is_empty() {
                            // 简化检查，实际应该检查日期
                            true
                        } else {
                            false
                        };
                        
                        if is_recent_review {
                            ComplianceResult {
                                compliant: true,
                                status: ComplianceStatus::Compliant,
                                evidence: vec![
                                    "信息安全政策文档".to_string(),
                                    "事件响应计划".to_string(),
                                    "政策定期审查记录".to_string(),
                                ],
                                notes: Some("信息安全政策已实施并定期审查".to_string()),
                                remediation: None,
                            }
                        } else {
                            ComplianceResult {
                                compliant: true,
                                status: ComplianceStatus::PartiallyCompliant,
                                evidence: vec![
                                    "信息安全政策文档".to_string(),
                                    "事件响应计划".to_string(),
                                ],
                                notes: Some("政策需要定期审查更新".to_string()),
                                remediation: Some("制定政策定期审查计划".to_string()),
                            }
                        }
                    } else {
                        ComplianceResult {
                            compliant: false,
                            status: ComplianceStatus::NonCompliant,
                            evidence: vec![],
                            notes: None,
                            remediation: Some("制定完整的信息安全政策和事件响应计划".to_string()),
                        }
                    }
                },
                evidence_required: vec![
                    "信息安全政策文档".to_string(),
                    "事件响应计划".to_string(),
                    "政策审查记录".to_string(),
                ],
            },
        ];
        
        self.regulations.push(Regulation {
            name: "ISO 27001".to_string(),
            version: "2022".to_string(),
            description: "信息安全管理体系要求",
            requirements: iso27001_requirements,
        });
    }
    
    pub fn set_system_info(&mut self, key: String, value: String) {
        self.system_info.insert(key, value);
    }
    
    pub fn load_system_info(&mut self) {
        // 从环境变量和配置加载系统信息
        self.set_system_info("MFA_ENABLED".to_string(), 
            std::env::var("MFA_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_AUDIT_LOGS".to_string(), 
            std::env::var("AUDIT_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("AUDIT_LOG_RETENTION_DAYS".to_string(), 
            std::env::var("AUDIT_LOG_RETENTION_DAYS").unwrap_or_else(|_| "365".to_string()));
        self.set_system_info("HAS_ROLE_BASED_ACCESS".to_string(), 
            std::env::var("RBAC_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_SESSION_MANAGEMENT".to_string(), 
            std::env::var("SESSION_MANAGEMENT_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("DATA_RETENTION_DAYS".to_string(), 
            std::env::var("DATA_RETENTION_DAYS").unwrap_or_else(|_| "365".to_string()));
        self.set_system_info("HAS_DATA_ACCESS_ENDPOINT".to_string(), 
            std::env::var("DATA_ACCESS_ENDPOINT_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_DATA_DELETE_ENDPOINT".to_string(), 
            std::env::var("DATA_DELETE_ENDPOINT_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_DATA_EXPORT_ENDPOINT".to_string(), 
            std::env::var("DATA_EXPORT_ENDPOINT_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_SECURITY_POLICY".to_string(), 
            std::env::var("SECURITY_POLICY_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_INCIDENT_RESPONSE_PLAN".to_string(), 
            std::env::var("INCIDENT_RESPONSE_PLAN_ENABLED").unwrap_or_else(|_| "true".to_string()));
        self.set_system_info("HAS_LOG_MONITORING".to_string(), 
            std::env::var("LOG_MONITORING_ENABLED").unwrap_or_else(|_| "true".to_string()));
    }
    
    pub fn run_compliance_check(&self, regulation: Option<&str>) -> ComplianceReport {
        let mut all_results = Vec::new();
        let mut regulation_summary = HashMap::new();
        
        for reg in &self.regulations {
            if let Some(target_reg) = regulation {
                if reg.name != target_reg {
                    continue;
                }
            }
            
            let mut reg_results = Vec::new();
            let mut compliant_count = 0;
            let mut non_compliant_count = 0;
            let mut partially_compliant_count = 0;
            
            for requirement in &reg.requirements {
                let result = (requirement.check_function)(&self.system_info);
                reg_results.push(ComplianceCheckResult {
                    regulation: reg.name.clone(),
                    requirement: requirement.clone(),
                    result: result.clone(),
                });
                
                match result.status {
                    ComplianceStatus::Compliant => compliant_count += 1,
                    ComplianceStatus::NonCompliant => non_compliant_count += 1,
                    ComplianceStatus::PartiallyCompliant => partially_compliant_count += 1,
                    _ => {}
                }
            }
            
            all_results.extend(reg_results);
            
            regulation_summary.insert(reg.name.clone(), RegulationSummary {
                total_requirements: reg.requirements.len(),
                compliant: compliant_count,
                non_compliant: non_compliant_count,
                partially_compliant: partially_compliant_count,
                compliance_percentage: if reg.requirements.len() > 0 {
                    (compliant_count as f64 / reg.requirements.len() as f64) * 100.0
                } else {
                    0.0
                },
            });
        }
        
        let overall_compliance = self.calculate_overall_compliance(&regulation_summary);
        
        ComplianceReport {
            regulations: regulation_summary,
            overall_compliance,
            results: all_results,
            timestamp: chrono::Utc::now(),
        }
    }
    
    fn calculate_overall_compliance(&self, summary: &HashMap<String, RegulationSummary>) -> f64 {
        if summary.is_empty() {
            return 0.0;
        }
        
        let total_compliant: usize = summary.values().map(|s| s.compliant).sum();
        let total_requirements: usize = summary.values().map(|s| s.total_requirements).sum();
        
        if total_requirements == 0 {
            0.0
        } else {
            (total_compliant as f64 / total_requirements as f64) * 100.0
        }
    }
}

#[derive(Debug, Clone)]
struct ComplianceCheckResult {
    regulation: String,
    requirement: ComplianceRequirement,
    result: ComplianceResult,
}

#[derive(Debug, Clone)]
struct RegulationSummary {
    total_requirements: usize,
    compliant: usize,
    non_compliant: usize,
    partially_compliant: usize,
    compliance_percentage: f64,
}

#[derive(Debug, Clone, Serialize)]
pub struct ComplianceReport {
    pub regulations: HashMap<String, RegulationSummary>,
    pub overall_compliance: f64,
    pub results: Vec<ComplianceCheckResult>,
    pub timestamp: chrono::DateTime<chrono::Utc>,
}

impl ComplianceReport {
    pub fn print_summary(&self) {
        println!("=== Compliance Assessment Report ===");
        println!("Timestamp: {}", self.timestamp);
        println!("Overall Compliance: {:.2}%", self.overall_compliance);
        println!();
        
        for (regulation, summary) in &self.regulations {
            println!("--- {} (v{}) ---", regulation, 
                self.results.iter()
                    .find(|r| r.regulation == *regulation)
                    .map(|r| r.regulation.clone())
                    .unwrap_or("Unknown".to_string()));
            
            println!("Total Requirements: {}", summary.total_requirements);
            println!("Compliant: {}", summary.compliant);
            println!("Non-Compliant: {}", summary.non_compliant);
            println!("Partially Compliant: {}", summary.partially_compliant);
            println!("Compliance Rate: {:.2}%", summary.compliance_percentage);
            println!();
            
            // 显示详细结果
            let reg_results: Vec<_> = self.results.iter()
                .filter(|r| r.regulation == *regulation && !r.result.compliant)
                .collect();
            
            if !reg_results.is_empty() {
                println!("Non-Compliant Requirements:");
                for result in reg_results {
                    println!("  ❌ [{}] {}: {}", 
                        result.requirement.id,
                        result.requirement.title,
                        match result.result.status {
                            ComplianceStatus::NonCompliant => "Non-Compliant",
                            ComplianceStatus::PartiallyCompliant => "Partially Compliant",
                            _ => "Needs Review",
                        }
                    );
                    if let Some(notes) = &result.result.notes {
                        println!("     Notes: {}", notes);
                    }
                    if let Some(remediation) = &result.result.remediation {
                        println!("     Remediation: {}", remediation);
                    }
                }
                println!();
            }
        }
    }
    
    pub fn export_to_json(&self) -> String {
        serde_json::to_string_pretty(self).unwrap_or_default()
    }
    
    pub fn export_to_markdown(&self) -> String {
        let mut markdown = String::new();
        
        markdown.push_str(&format!("# Compliance Assessment Report\n\n"));
        markdown.push_str(&format!("**Timestamp:** {}\n\n", self.timestamp));
        markdown.push_str(&format!("**Overall Compliance:** {:.2}%\n\n", self.overall_compliance));
        
        for (regulation, summary) in &self.regulations {
            markdown.push_str(&format!("## {}\n\n", regulation));
            markdown.push_str(&format!("- **Total Requirements:** {}\n", summary.total_requirements));
            markdown.push_str(&format!("- **Compliant:** {}\n", summary.compliant));
            markdown.push_str(&format!("- **Non-Compliant:** {}\n", summary.non_compliant));
            markdown.push_str(&format!("- **Partially Compliant:** {}\n", summary.partially_compliant));
            markdown.push_str(&format!("- **Compliance Rate:** {:.2}%\n\n", summary.compliance_percentage));
            
            let reg_results: Vec<_> = self.results.iter()
                .filter(|r| r.regulation == *regulation && !r.result.compliant)
                .collect();
            
            if !reg_results.is_empty() {
                markdown.push_str("### Non-Compliant Requirements\n\n");
                for result in reg_results {
                    markdown.push_str(&format!("- **{}**: {}\n", 
                        result.requirement.id, result.requirement.title));
                    markdown.push_str(&format!("  - Status: {}\n", 
                        match result.result.status {
                            ComplianceStatus::NonCompliant => "Non-Compliant",
                            ComplianceStatus::PartiallyCompliant => "Partially Compliant",
                            _ => "Needs Review",
                        }
                    ));
                    if let Some(notes) = &result.result.notes {
                        markdown.push_str(&format!("  - Notes: {}\n", notes));
                    }
                    if let Some(remediation) = &result.result.remediation {
                        markdown.push_str(&format!("  - Remediation: {}\n", remediation));
                    }
                    markdown.push_str("\n");
                }
            }
        }
        
        markdown
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_gdpr_compliance_check() {
        let mut checker = ComplianceChecker::new();
        checker.set_system_info("DATA_RETENTION_DAYS".to_string(), "365".to_string());
        checker.set_system_info("HAS_DATA_ACCESS_ENDPOINT".to_string(), "true".to_string());
        checker.set_system_info("HAS_DATA_DELETE_ENDPOINT".to_string(), "true".to_string());
        checker.set_system_info("HAS_DATA_EXPORT_ENDPOINT".to_string(), "true".to_string());
        
        let report = checker.run_compliance_check(Some("GDPR"));
        
        assert!(report.regulations.contains_key("GDPR"));
        let gdpr_summary = report.regulations.get("GDPR").unwrap();
        assert!(gdpr_summary.compliance_percentage > 0.0);
    }
}
}

章节总结

第14章《安全编程》现已全面完成，总计超过6000行代码，涵盖了企业级安全编程的全生命周期解决方案：

核心技术成果：

安全基础：密码学、加密解密、漏洞防护
企业级认证：多因子认证、令牌管理、审计日志
部署监控：容器化、K8s、Prometheus/Grafana监控
CI/CD安全：自动化安全扫描、漏洞检测
合规性：GDPR/SOC 2/ISO 27001自动检查
配置管理：安全配置检查、策略文档生成

第14章已全面完成 - 掌握了企业级安全编程的完整技术栈，能够构建安全可靠的生产级应用。

现在继续完成第15章：测试与调试

第15章：测试与调试

章节概述

测试与调试是软件质量保证的核心技能。在本章中，我们将深入探索Rust的测试和调试技术，从基础单元测试到复杂的集成测试、性能测试和自动化测试系统，掌握构建高质量、可靠软件的核心技术。本章强调理论与实践相结合，通过实际项目将测试理论应用到生产环境中。

学习目标：

掌握Rust单元测试和集成测试技术
学会使用性能测试工具和基准测试
掌握调试工具和技巧
理解自动化测试系统设计
构建企业级测试框架和CI/CD集成

实战项目：构建一个企业级自动化测试系统，支持多层级测试、性能监控、测试报告生成、CI/CD集成等企业级测试特性。

15.1 单元测试基础

15.1.1 Rust测试框架概述

Rust提供了内置的测试框架，支持不同类型的测试：

#![allow(unused)]
fn main() {
// File: testing-basics/src/lib.rs
/// 基础数学计算模块
pub struct Calculator {
    precision: u32,
}

impl Calculator {
    /// 创建新的计算器
    pub fn new(precision: u32) -> Self {
        Calculator { precision }
    }
    
    /// 加法运算
    pub fn add(&self, a: f64, b: f64) -> f64 {
        (a + b).round() / (10f64.powi(self.precision as i32))
    }
    
    /// 减法运算
    pub fn subtract(&self, a: f64, b: f64) -> f64 {
        (a - b).round() / (10f64.powi(self.precision as i32))
    }
    
    /// 乘法运算
    pub fn multiply(&self, a: f64, b: f64) -> f64 {
        (a * b).round() / (10f64.powi(self.precision as i32))
    }
    
    /// 除法运算
    pub fn divide(&self, a: f64, b: f64) -> Result<f64, String> {
        if b == 0.0 {
            Err("Cannot divide by zero".to_string())
        } else {
            Ok((a / b).round() / (10f64.powi(self.precision as i32)))
        }
    }
    
    /// 计算平方根
    pub fn sqrt(&self, value: f64) -> Result<f64, String> {
        if value < 0.0 {
            Err("Cannot calculate square root of negative number".to_string())
        } else {
            Ok(value.sqrt().round() / (10f64.powi(self.precision as i32))
        }
    }
    
    /// 获取精度
    pub fn get_precision(&self) -> u32 {
        self.precision
    }
    
    /// 精度验证
    pub fn is_valid_precision(&self) -> bool {
        self.precision <= 10
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    /// 基础功能测试
    #[test]
    fn test_calculator_creation() {
        let calc = Calculator::new(2);
        assert_eq!(calc.get_precision(), 2);
        assert!(calc.is_valid_precision());
    }
    
    #[test]
    fn test_addition() {
        let calc = Calculator::new(2);
        assert_eq!(calc.add(1.234, 2.567), 3.80);
        assert_eq!(calc.add(0.0, 0.0), 0.0);
        assert_eq!(calc.add(-1.0, 1.0), 0.0);
    }
    
    #[test]
    fn test_subtraction() {
        let calc = Calculator::new(2);
        assert_eq!(calc.subtract(5.0, 3.0), 2.0);
        assert_eq!(calc.subtract(0.0, 1.0), -1.0);
    }
    
    #[test]
    fn test_multiplication() {
        let calc = Calculator::new(2);
        assert_eq!(calc.multiply(3.0, 4.0), 12.0);
        assert_eq!(calc.multiply(0.0, 100.0), 0.0);
    }
    
    #[test]
    fn test_division() {
        let calc = Calculator::new(2);
        assert_eq!(calc.divide(10.0, 2.0).unwrap(), 5.0);
        assert_eq!(calc.divide(7.0, 3.0).unwrap(), 2.33);
    }
    
    #[test]
    fn test_division_by_zero() {
        let calc = Calculator::new(2);
        assert!(calc.divide(10.0, 0.0).is_err());
    }
    
    #[test]
    fn test_square_root() {
        let calc = Calculator::new(2);
        assert_eq!(calc.sqrt(16.0).unwrap(), 4.0);
        assert_eq!(calc.sqrt(2.0).unwrap(), 1.41);
    }
    
    #[test]
    fn test_square_root_negative() {
        let calc = Calculator::new(2);
        assert!(calc.sqrt(-1.0).is_err());
    }
    
    /// 使用assert!宏的测试
    #[test]
    fn test_precision_validation() {
        let calc = Calculator::new(2);
        assert!(calc.is_valid_precision());
        
        let calc_large = Calculator::new(15);
        assert!(!calc_large.is_valid_precision());
    }
    
    /// 使用assert_eq!宏的测试
    #[test]
    fn test_precision_rounding() {
        let calc = Calculator::new(3);
        assert_eq!(calc.add(1.1234, 2.5678), 3.691);
    }
    
    /// 异常测试
    #[test]
    #[should_panic]
    fn test_invalid_calculator_creation() {
        Calculator::new(20); // 应该触发panic
    }
    
    /// 自定义错误消息的测试
    #[test]
    fn test_addition_with_custom_message() {
        let calc = Calculator::new(2);
        let result = calc.add(1.0, 2.0);
        assert_eq!(result, 3.0, "Addition should be correct for positive numbers");
    }
    
    /// 参数化测试
    #[test]
    fn test_multiple_precisions() {
        let test_cases = vec![(0.123, 0.456, 2, 0.58), (0.1234, 0.5678, 3, 0.691)];
        
        for (a, b, precision, expected) in test_cases {
            let calc = Calculator::new(precision);
            assert_eq!(calc.add(a, b), expected, "Failed for precision {}", precision);
        }
    }
}
}

15.1.2 测试输出和文档测试

#![allow(unused)]
fn main() {
// File: testing-basics/src/doc_tests.rs

/// 计算复数的模长
/// 
/// # Examples
/// 
/// ```
/// use testing_basics::complex::Complex;
/// 
/// let c = Complex::new(3.0, 4.0);
/// assert!((c.magnitude() - 5.0).abs() < f64::EPSILON);
/// ```
/// 
/// ```
/// use testing_basics::complex::Complex;
/// 
/// let c = Complex::new(0.0, 0.0);
/// assert_eq!(c.magnitude(), 0.0);
/// ```
pub struct Complex {
    real: f64,
    imaginary: f64,
}

impl Complex {
    pub fn new(real: f64, imaginary: f64) -> Self {
        Complex { real, imaginary }
    }
    
    /// 计算复数的模长
    pub fn magnitude(&self) -> f64 {
        (self.real.powi(2) + self.imaginary.powi(2)).sqrt()
    }
    
    /// 获取实部
    pub fn real(&self) -> f64 {
        self.real
    }
    
    /// 获取虚部
    pub fn imaginary(&self) -> f64 {
        self.imaginary
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_complex_magnitude() {
        let c = Complex::new(3.0, 4.0);
        assert!((c.magnitude() - 5.0).abs() < f64::EPSILON);
    }
    
    #[test]
    fn test_zero_complex() {
        let c = Complex::new(0.0, 0.0);
        assert_eq!(c.magnitude(), 0.0);
    }
    
    #[test]
    fn test_imaginary_only_complex() {
        let c = Complex::new(0.0, 3.0);
        assert_eq!(c.magnitude(), 3.0);
    }
    
    #[test]
    fn test_real_only_complex() {
        let c = Complex::new(4.0, 0.0);
        assert_eq!(c.magnitude(), 4.0);
    }
}
}

15.1.3 条件编译测试

#![allow(unused)]
fn main() {
// File: testing-basics/src/conditional_tests.rs

/// 配置管理器
pub struct Config {
    environment: String,
    debug_mode: bool,
    log_level: String,
}

impl Config {
    pub fn new(environment: &str, debug_mode: bool) -> Self {
        Config {
            environment: environment.to_string(),
            debug_mode,
            log_level: String::new(),
        }
    }
    
    pub fn environment(&self) -> &str {
        &self.environment
    }
    
    pub fn debug_mode(&self) -> bool {
        self.debug_mode
    }
    
    pub fn log_level(&self) -> &str {
        &self.log_level
    }
    
    #[cfg(test)]
    pub fn set_log_level(&mut self, level: &str) {
        self.log_level = level.to_string();
    }
    
    /// 初始化配置
    pub fn initialize(&mut self) -> Result<(), String> {
        if self.environment.is_empty() {
            return Err("Environment cannot be empty".to_string());
        }
        
        if self.debug_mode {
            self.log_level = "debug".to_string();
        } else {
            self.log_level = "info".to_string();
        }
        
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_config_creation() {
        let config = Config::new("development", true);
        assert_eq!(config.environment(), "development");
        assert!(config.debug_mode());
    }
    
    #[test]
    fn test_config_initialization_debug() {
        let mut config = Config::new("development", true);
        assert!(config.initialize().is_ok());
        assert_eq!(config.log_level(), "debug");
    }
    
    #[test]
    fn test_config_initialization_production() {
        let mut config = Config::new("production", false);
        assert!(config.initialize().is_ok());
        assert_eq!(config.log_level(), "info");
    }
    
    #[test]
    fn test_empty_environment() {
        let mut config = Config::new("", false);
        assert!(config.initialize().is_err());
    }
    
    #[cfg(test)]
    #[test]
    fn test_set_log_level() {
        let mut config = Config::new("test", false);
        config.set_log_level("error");
        assert_eq!(config.log_level(), "error");
    }
}

/// 仅在测试时使用的辅助函数
#[cfg(test)]
mod test_helpers {
    use super::*;
    
    pub fn create_test_config() -> Config {
        Config::new("test", true)
    }
    
    pub fn create_test_config_with_level(level: &str) -> Config {
        let mut config = Config::new("test", false);
        config.set_log_level(level);
        config
    }
    
    #[test]
    fn test_helpers() {
        let config = create_test_config();
        assert_eq!(config.environment(), "test");
        
        let config_with_level = create_test_config_with_level("warning");
        assert_eq!(config_with_level.log_level(), "warning");
    }
}
}

15.2 集成测试

15.2.1 模块间集成测试

#![allow(unused)]
fn main() {
// File: integration-tests/src/lib.rs

mod user_service;
mod product_service;
mod order_service;

pub use user_service::{User, UserService, UserServiceError};
pub use product_service::{Product, ProductService, ProductServiceError};
pub use order_service::{Order, OrderService, OrderServiceError};

/// 集成业务服务
pub struct BusinessService {
    user_service: UserService,
    product_service: ProductService,
    order_service: OrderService,
}

impl BusinessService {
    pub fn new() -> Self {
        BusinessService {
            user_service: UserService::new(),
            product_service: ProductService::new(),
            order_service: OrderService::new(),
        }
    }
    
    /// 创建订单 - 涉及用户验证、产品检查和订单创建
    pub fn create_order(
        &self,
        user_id: &str,
        product_ids: Vec<&str>,
        quantities: Vec<u32>,
    ) -> Result<String, BusinessServiceError> {
        // 验证用户
        let user = self.user_service.get_user(user_id)
            .map_err(|_| BusinessServiceError::UserNotFound)?;
        
        // 验证用户状态
        if !user.is_active {
            return Err(BusinessServiceError::UserInactive);
        }
        
        // 验证产品并计算总价
        let mut total_price = 0.0;
        let mut order_items = Vec::new();
        
        for (i, product_id) in product_ids.iter().enumerate() {
            let quantity = quantities[i];
            let product = self.product_service.get_product(product_id)
                .map_err(|_| BusinessServiceError::ProductNotFound)?;
            
            if !product.is_available {
                return Err(BusinessServiceError::ProductUnavailable);
            }
            
            if product.stock < quantity {
                return Err(BusinessServiceError::InsufficientStock);
            }
            
            let item_total = product.price * quantity as f64;
            total_price += item_total;
            
            order_items.push((product_id.to_string(), quantity, item_total));
        }
        
        // 创建订单
        let order_id = self.order_service.create_order(
            user_id,
            total_price,
            order_items,
        )?;
        
        // 更新产品库存
        for (i, product_id) in product_ids.iter().enumerate() {
            let quantity = quantities[i];
            self.product_service.update_stock(product_id, quantity)
                .map_err(|_| BusinessServiceError::StockUpdateFailed)?;
        }
        
        Ok(order_id)
    }
    
    /// 获取订单详情
    pub fn get_order_details(&self, order_id: &str) -> Result<OrderDetails, BusinessServiceError> {
        let order = self.order_service.get_order(order_id)
            .map_err(|_| BusinessServiceError::OrderNotFound)?;
        
        let user = self.user_service.get_user(&order.user_id)
            .map_err(|_| BusinessServiceError::UserNotFound)?;
        
        let mut items = Vec::new();
        for (product_id, quantity, price) in &order.items {
            let product = self.product_service.get_product(product_id)
                .map_err(|_| BusinessServiceError::ProductNotFound)?;
            
            items.push(OrderItem {
                product_id: product_id.clone(),
                product_name: product.name,
                quantity: *quantity,
                unit_price: product.price,
                total_price: *price,
            });
        }
        
        Ok(OrderDetails {
            order_id: order.id,
            user_name: user.name,
            user_email: user.email,
            total_amount: order.total_amount,
            status: order.status.clone(),
            created_at: order.created_at,
            items,
        })
    }
}

#[derive(Debug, Clone)]
pub struct OrderItem {
    pub product_id: String,
    pub product_name: String,
    pub quantity: u32,
    pub unit_price: f64,
    pub total_price: f64,
}

#[derive(Debug, Clone)]
pub struct OrderDetails {
    pub order_id: String,
    pub user_name: String,
    pub user_email: String,
    pub total_amount: f64,
    pub status: String,
    pub created_at: String,
    pub items: Vec<OrderItem>,
}

#[derive(Debug, Clone)]
pub enum BusinessServiceError {
    UserNotFound,
    UserInactive,
    ProductNotFound,
    ProductUnavailable,
    InsufficientStock,
    StockUpdateFailed,
    OrderNotFound,
    OrderCreationFailed,
}

impl std::fmt::Display for BusinessServiceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BusinessServiceError::UserNotFound => write!(f, "User not found"),
            BusinessServiceError::UserInactive => write!(f, "User account is inactive"),
            BusinessServiceError::ProductNotFound => write!(f, "Product not found"),
            BusinessServiceError::ProductUnavailable => write!(f, "Product is not available"),
            BusinessServiceError::InsufficientStock => write!(f, "Insufficient stock"),
            BusinessServiceError::StockUpdateFailed => write!(f, "Failed to update stock"),
            BusinessServiceError::OrderNotFound => write!(f, "Order not found"),
            BusinessServiceError::OrderCreationFailed => write!(f, "Failed to create order"),
        }
    }
}

impl std::error::Error for BusinessServiceError {}
}

#![allow(unused)]
fn main() {
// File: integration-tests/src/user_service.rs
use std::collections::HashMap;

#[derive(Debug, Clone)]
pub struct User {
    pub id: String,
    pub name: String,
    pub email: String,
    pub is_active: bool,
    pub created_at: String,
}

pub struct UserService {
    users: HashMap<String, User>,
}

impl UserService {
    pub fn new() -> Self {
        let mut service = UserService {
            users: HashMap::new(),
        };
        
        // 添加测试用户
        service.users.insert("user1".to_string(), User {
            id: "user1".to_string(),
            name: "John Doe".to_string(),
            email: "john@example.com".to_string(),
            is_active: true,
            created_at: "2024-01-01T00:00:00Z".to_string(),
        });
        
        service.users.insert("user2".to_string(), User {
            id: "user2".to_string(),
            name: "Jane Smith".to_string(),
            email: "jane@example.com".to_string(),
            is_active: false,
            created_at: "2024-01-01T00:00:00Z".to_string(),
        });
        
        service
    }
    
    pub fn get_user(&self, user_id: &str) -> Result<User, UserServiceError> {
        self.users.get(user_id)
            .cloned()
            .ok_or(UserServiceError::UserNotFound)
    }
    
    pub fn create_user(&mut self, user: User) -> Result<(), UserServiceError> {
        if self.users.contains_key(&user.id) {
            return Err(UserServiceError::UserAlreadyExists);
        }
        
        self.users.insert(user.id.clone(), user);
        Ok(())
    }
    
    pub fn update_user(&mut self, user_id: &str, updates: UserUpdates) -> Result<(), UserServiceError> {
        if let Some(user) = self.users.get_mut(user_id) {
            if let Some(name) = updates.name {
                user.name = name;
            }
            if let Some(email) = updates.email {
                user.email = email;
            }
            if let Some(is_active) = updates.is_active {
                user.is_active = is_active;
            }
            Ok(())
        } else {
            Err(UserServiceError::UserNotFound)
        }
    }
    
    pub fn delete_user(&mut self, user_id: &str) -> Result<(), UserServiceError> {
        if self.users.remove(user_id).is_some() {
            Ok(())
        } else {
            Err(UserServiceError::UserNotFound)
        }
    }
    
    pub fn list_users(&self) -> Vec<User> {
        self.users.values().cloned().collect()
    }
}

#[derive(Debug)]
pub struct UserUpdates {
    name: Option<String>,
    email: Option<String>,
    is_active: Option<bool>,
}

impl UserUpdates {
    pub fn new() -> Self {
        UserUpdates {
            name: None,
            email: None,
            is_active: None,
        }
    }
    
    pub fn with_name(mut self, name: &str) -> Self {
        self.name = Some(name.to_string());
        self
    }
    
    pub fn with_email(mut self, email: &str) -> Self {
        self.email = Some(email.to_string());
        self
    }
    
    pub fn with_active(mut self, is_active: bool) -> Self {
        self.is_active = Some(is_active);
        self
    }
}

#[derive(Debug)]
pub enum UserServiceError {
    UserNotFound,
    UserAlreadyExists,
    InvalidEmail,
    DatabaseError,
}

impl std::fmt::Display for UserServiceError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            UserServiceError::UserNotFound => write!(f, "User not found"),
            UserServiceError::UserAlreadyExists => write!(f, "User already exists"),
            UserServiceError::InvalidEmail => write!(f, "Invalid email address"),
            UserServiceError::DatabaseError => write!(f, "Database error"),
        }
    }
}

impl std::error::Error for UserServiceError {}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_get_existing_user() {
        let service = UserService::new();
        let user = service.get_user("user1").unwrap();
        assert_eq!(user.name, "John Doe");
        assert!(user.is_active);
    }
    
    #[test]
    fn test_get_non_existing_user() {
        let service = UserService::new();
        let result = service.get_user("user999");
        assert!(result.is_err());
    }
    
    #[test]
    fn test_create_user() {
        let mut service = UserService::new();
        let user = User {
            id: "user3".to_string(),
            name: "Bob Wilson".to_string(),
            email: "bob@example.com".to_string(),
            is_active: true,
            created_at: "2024-01-01T00:00:00Z".to_string(),
        };
        
        assert!(service.create_user(user).is_ok());
        assert!(service.get_user("user3").is_ok());
    }
    
    #[test]
    fn test_update_user() {
        let mut service = UserService::new();
        let updates = UserUpdates::new()
            .with_name("John Updated")
            .with_active(false);
        
        assert!(service.update_user("user1", updates).is_ok());
        let user = service.get_user("user1").unwrap();
        assert_eq!(user.name, "John Updated");
        assert!(!user.is_active);
    }
    
    #[test]
    fn test_delete_user() {
        let mut service = UserService::new();
        assert!(service.delete_user("user1").is_ok());
        assert!(service.get_user("user1").is_err());
    }
    
    #[test]
    fn test_list_users() {
        let service = UserService::new();
        let users = service.list_users();
        assert_eq!(users.len(), 2);
    }
}
}

15.2.2 数据库集成测试

#![allow(unused)]
fn main() {
// File: integration-tests/src/database_test.rs
use sqlx::{Pool, Sqlite, Row, SqlitePool};
use tempfile::TempDir;
use std::path::PathBuf;

/// 测试数据库管理器
pub struct TestDatabase {
    pool: SqlitePool,
    temp_dir: TempDir,
}

impl TestDatabase {
    pub async fn new() -> Result<Self, sqlx::Error> {
        let temp_dir = TempDir::new()?;
        let db_path: PathBuf = temp_dir.path().join("test.db");
        let connection_string = format!("sqlite://{}", db_path.display());
        
        let pool = SqlitePool::connect(&connection_string).await?;
        
        // 运行迁移
        Self::run_migrations(&pool).await?;
        
        Ok(TestDatabase {
            pool,
            temp_dir,
        })
    }
    
    async fn run_migrations(pool: &SqlitePool) -> Result<(), sqlx::Error> {
        // 创建用户表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS users (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT NOT NULL UNIQUE,
                is_active BOOLEAN DEFAULT true,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        "#).execute(pool).await?;
        
        // 创建产品表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS products (
                id TEXT PRIMARY KEY,
                name TEXT NOT NULL,
                price REAL NOT NULL,
                stock INTEGER DEFAULT 0,
                is_available BOOLEAN DEFAULT true,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        "#).execute(pool).await?;
        
        // 创建订单表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS orders (
                id TEXT PRIMARY KEY,
                user_id TEXT NOT NULL,
                total_amount REAL NOT NULL,
                status TEXT NOT NULL,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (user_id) REFERENCES users (id)
            )
        "#).execute(pool).await?;
        
        // 创建订单项目表
        sqlx::query(r#"
            CREATE TABLE IF NOT EXISTS order_items (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                order_id TEXT NOT NULL,
                product_id TEXT NOT NULL,
                quantity INTEGER NOT NULL,
                price REAL NOT NULL,
                FOREIGN KEY (order_id) REFERENCES orders (id),
                FOREIGN KEY (product_id) REFERENCES products (id)
            )
        "#).execute(pool).await?;
        
        Ok(())
    }
    
    pub fn pool(&self) -> &SqlitePool {
        &self.pool
    }
    
    pub async fn close(self) {
        self.pool.close().await;
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use uuid::Uuid;
    
    #[tokio::test]
    async fn test_user_repository() {
        let db = TestDatabase::new().await.unwrap();
        let user_id = Uuid::new_v4().to_string();
        
        // 插入用户
        sqlx::query(r#"
            INSERT INTO users (id, name, email, is_active)
            VALUES (?, ?, ?, ?)
        "#)
        .bind(&user_id)
        .bind("Test User")
        .bind("test@example.com")
        .bind(true)
        .execute(db.pool())
        .await.unwrap();
        
        // 验证用户插入
        let row = sqlx::query("SELECT * FROM users WHERE id = ?")
            .bind(&user_id)
            .fetch_one(db.pool())
            .await
            .unwrap();
        
        assert_eq!(row.get::<String, _>("name"), "Test User");
        assert_eq!(row.get::<String, _>("email"), "test@example.com");
        assert!(row.get::<bool, _>("is_active"));
        
        db.close().await;
    }
    
    #[tokio::test]
    async fn test_product_repository() {
        let db = TestDatabase::new().await.unwrap();
        let product_id = Uuid::new_v4().to_string();
        
        // 插入产品
        sqlx::query(r#"
            INSERT INTO products (id, name, price, stock, is_available)
            VALUES (?, ?, ?, ?, ?)
        "#)
        .bind(&product_id)
        .bind("Test Product")
        .bind(99.99)
        .bind(100)
        .bind(true)
        .execute(db.pool())
        .await
        .unwrap();
        
        // 验证产品插入
        let row = sqlx::query("SELECT * FROM products WHERE id = ?")
            .bind(&product_id)
            .fetch_one(db.pool())
            .await
            .unwrap();
        
        assert_eq!(row.get::<String, _>("name"), "Test Product");
        assert_eq!(row.get::<f64, _>("price"), 99.99);
        assert_eq!(row.get::<i32, _>("stock"), 100);
        assert!(row.get::<bool, _>("is_available"));
        
        db.close().await;
    }
    
    #[tokio::test]
    async fn test_order_creation_integration() {
        let db = TestDatabase::new().await.unwrap();
        let user_id = Uuid::new_v4().to_string();
        let product_id = Uuid::new_v4().to_string();
        let order_id = Uuid::new_v4().to_string();
        
        // 创建用户
        sqlx::query("INSERT INTO users (id, name, email) VALUES (?, ?, ?)")
            .bind(&user_id)
            .bind("Test User")
            .bind("test@example.com")
            .execute(db.pool())
            .await
            .unwrap();
        
        // 创建产品
        sqlx::query("INSERT INTO products (id, name, price, stock, is_available) VALUES (?, ?, ?, ?, ?)")
            .bind(&product_id)
            .bind("Test Product")
            .bind(50.0)
            .bind(100)
            .bind(true)
            .execute(db.pool())
            .await
            .unwrap();
        
        // 创建订单
        sqlx::query("INSERT INTO orders (id, user_id, total_amount, status) VALUES (?, ?, ?, ?)")
            .bind(&order_id)
            .bind(&user_id)
            .bind(150.0)
            .bind("pending")
            .execute(db.pool())
            .await
            .unwrap();
        
        // 添加订单项目
        sqlx::query("INSERT INTO order_items (order_id, product_id, quantity, price) VALUES (?, ?, ?, ?)")
            .bind(&order_id)
            .bind(&product_id)
            .bind(3)
            .bind(50.0)
            .execute(db.pool())
            .await
            .unwrap();
        
        // 验证订单创建
        let order_row = sqlx::query("SELECT * FROM orders WHERE id = ?")
            .bind(&order_id)
            .fetch_one(db.pool())
            .await
            .unwrap();
        
        assert_eq!(order_row.get::<String, _>("id"), order_id);
        assert_eq!(order_row.get::<f64, _>("total_amount"), 150.0);
        assert_eq!(order_row.get::<String, _>("status"), "pending");
        
        // 验证订单项目
        let item_rows = sqlx::query("SELECT * FROM order_items WHERE order_id = ?")
            .bind(&order_id)
            .fetch_all(db.pool())
            .await
            .unwrap();
        
        assert_eq!(item_rows.len(), 1);
        let item = &item_rows[0];
        assert_eq!(item.get::<i32, _>("quantity"), 3);
        assert_eq!(item.get::<f64, _>("price"), 50.0);
        
        db.close().await;
    }
    
    #[tokio::test]
    async fn test_concurrent_operations() {
        let db = TestDatabase::new().await.unwrap();
        let user_id = Uuid::new_v4().to_string();
        
        // 并发插入多个用户
        let mut handles = vec![];
        for i in 0..10 {
            let pool = db.pool().clone();
            let user_id = format!("{}_{}", user_id, i);
            
            let handle = tokio::spawn(async move {
                sqlx::query("INSERT INTO users (id, name, email) VALUES (?, ?, ?)")
                    .bind(&user_id)
                    .bind(format!("User {}", i))
                    .bind(format!("user{}@example.com", i))
                    .execute(&pool)
                    .await
                    .map_err(|e| e.to_string())
            });
            
            handles.push(handle);
        }
        
        // 等待所有操作完成
        for handle in handles {
            handle.await.unwrap().unwrap();
        }
        
        // 验证所有用户都被插入
        let rows = sqlx::query("SELECT COUNT(*) as count FROM users")
            .fetch_one(db.pool())
            .await
            .unwrap();
        
        assert_eq!(rows.get::<i64, _>("count"), 10);
        
        db.close().await;
    }
}
}

15.2.3 外部API集成测试

#![allow(unused)]
fn main() {
// File: integration-tests/src/api_test.rs
use reqwest::{Client, StatusCode};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// HTTP客户端配置
pub struct HttpTestClient {
    client: Client,
    base_url: String,
    auth_token: Option<String>,
}

impl HttpTestClient {
    pub fn new(base_url: &str) -> Self {
        HttpTestClient {
            client: Client::new(),
            base_url: base_url.to_string(),
            auth_token: None,
        }
    }
    
    pub fn with_auth(mut self, token: &str) -> Self {
        self.auth_token = Some(token.to_string());
        self
    }
    
    /// 设置认证令牌
    pub fn set_auth(&mut self, token: &str) {
        self.auth_token = Some(token.to_string());
    }
    
    /// 构建请求头
    fn build_headers(&self) -> reqwest::header::HeaderMap {
        let mut headers = reqwest::header::HeaderMap::new();
        
        headers.insert(
            reqwest::header::CONTENT_TYPE,
            reqwest::header::HeaderValue::from_str("application/json").unwrap(),
        );
        
        if let Some(token) = &self.auth_token {
            headers.insert(
                reqwest::header::AUTHORIZATION,
                reqwest::header::HeaderValue::from_str(&format!("Bearer {}", token)).unwrap(),
            );
        }
        
        headers
    }
    
    /// GET请求
    pub async fn get(&self, path: &str) -> Result<ApiResponse, reqwest::Error> {
        let url = format!("{}{}", self.base_url, path);
        let response = self.client
            .get(&url)
            .headers(self.build_headers())
            .send()
            .await?;
        
        self.handle_response(response).await
    }
    
    /// POST请求
    pub async fn post<T>(&self, path: &str, data: &T) -> Result<ApiResponse, reqwest::Error>
    where
        T: Serialize,
    {
        let url = format!("{}{}", self.base_url, path);
        let response = self.client
            .post(&url)
            .headers(self.build_headers())
            .json(data)
            .send()
            .await?;
        
        self.handle_response(response).await
    }
    
    /// PUT请求
    pub async fn put<T>(&self, path: &str, data: &T) -> Result<ApiResponse, reqwest::Error>
    where
        T: Serialize,
    {
        let url = format!("{}{}", self.base_url, path);
        let response = self.client
            .put(&url)
            .headers(self.build_headers())
            .json(data)
            .send()
            .await?;
        
        self.handle_response(response).await
    }
    
    /// DELETE请求
    pub async fn delete(&self, path: &str) -> Result<ApiResponse, reqwest::Error> {
        let url = format!("{}{}", self.base_url, path);
        let response = self.client
            .delete(&url)
            .headers(self.build_headers())
            .send()
            .await?;
        
        self.handle_response(response).await
    }
    
    async fn handle_response(&self, response: reqwest::Response) -> Result<ApiResponse, reqwest::Error> {
        let status = response.status();
        let text = response.text().await?;
        
        let api_response = ApiResponse {
            status_code: status.as_u16(),
            body: text,
            headers: response.headers().clone(),
        };
        
        Ok(api_response)
    }
}

/// API响应结构
#[derive(Debug, Clone)]
pub struct ApiResponse {
    pub status_code: u16,
    pub body: String,
    pub headers: reqwest::header::HeaderMap,
}

impl ApiResponse {
    pub fn is_success(&self) -> bool {
        (200..300).contains(&self.status_code)
    }
    
    pub fn is_client_error(&self) -> bool {
        (400..500).contains(&self.status_code)
    }
    
    pub fn is_server_error(&self) -> bool {
        (500..600).contains(&self.status_code)
    }
    
    pub fn json<T>(&self) -> Result<T, serde_json::Error>
    where
        T: Deserialize<'static>,
    {
        serde_json::from_str(&self.body)
    }
}

/// 测试用户结构
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct TestUser {
    pub id: Option<String>,
    pub username: String,
    pub email: String,
    pub name: String,
    pub is_active: bool,
    pub created_at: Option<String>,
}

impl TestUser {
    pub fn new(username: &str, email: &str, name: &str) -> Self {
        TestUser {
            id: None,
            username: username.to_string(),
            email: email.to_string(),
            name: name.to_string(),
            is_active: true,
            created_at: None,
        }
    }
}

/// 测试产品结构
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct TestProduct {
    pub id: Option<String>,
    pub name: String,
    pub description: Option<String>,
    pub price: f64,
    pub category: String,
    pub stock: i32,
    pub is_available: bool,
    pub created_at: Option<String>,
}

impl TestProduct {
    pub fn new(name: &str, price: f64, category: &str) -> Self {
        TestProduct {
            id: None,
            name: name.to_string(),
            description: None,
            price,
            category: category.to_string(),
            stock: 100,
            is_available: true,
            created_at: None,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use wiremock::{MockServer, Mock, ResponseTemplate};
    use wiremock::matchers::{method, path, body_json};
    
    #[tokio::test]
    async fn test_successful_api_call() {
        let mock_server = MockServer::start().await;
        
        // 设置模拟响应
        Mock::given(method("GET"))
            .and(path("/api/users"))
            .respond_with(ResponseTemplate::new(200)
                .body(r#"{"id":"1","username":"testuser","email":"test@example.com","name":"Test User","is_active":true}"#))
            .mount(&mock_server)
            .await;
        
        let client = HttpTestClient::new(&mock_server.uri());
        let response = client.get("/api/users").await.unwrap();
        
        assert!(response.is_success());
        assert_eq!(response.status_code, 200);
        
        let user: TestUser = response.json().unwrap();
        assert_eq!(user.username, "testuser");
        assert_eq!(user.email, "test@example.com");
    }
    
    #[tokio::test]
    async fn test_api_post_request() {
        let mock_server = MockServer::start().await;
        
        let test_user = TestUser::new("newuser", "new@example.com", "New User");
        
        // 设置模拟POST响应
        Mock::given(method("POST"))
            .and(path("/api/users"))
            .and(body_json(&test_user))
            .respond_with(ResponseTemplate::new(201)
                .body(r#"{"id":"123","username":"newuser","email":"new@example.com","name":"New User","is_active":true}"#))
            .mount(&mock_server)
            .await;
        
        let client = HttpTestClient::new(&mock_server.uri());
        let response = client.post("/api/users", &test_user).await.unwrap();
        
        assert!(response.is_success());
        assert_eq!(response.status_code, 201);
        
        let created_user: TestUser = response.json().unwrap();
        assert_eq!(created_user.username, "newuser");
        assert!(created_user.id.is_some());
    }
    
    #[tokio::test]
    async fn test_api_error_response() {
        let mock_server = MockServer::start().await;
        
        // 设置404响应
        Mock::given(method("GET"))
            .and(path("/api/users/999"))
            .respond_with(ResponseTemplate::new(404)
                .body(r#"{"error":"User not found","code":404}"#))
            .mount(&mock_server)
            .await;
        
        let client = HttpTestClient::new(&mock_server.uri());
        let response = client.get("/api/users/999").await.unwrap();
        
        assert!(response.is_client_error());
        assert_eq!(response.status_code, 404);
        
        let error: HashMap<String, String> = response.json().unwrap();
        assert_eq!(error.get("error"), Some(&"User not found".to_string()));
    }
    
    #[tokio::test]
    async fn test_authenticated_request() {
        let mock_server = MockServer::start().await;
        
        // 设置需要认证的端点
        Mock::given(method("GET"))
            .and(path("/api/protected"))
            .and(header("authorization", "Bearer test-token"))
            .respond_with(ResponseTemplate::new(200)
                .body(r#"{"message":"Access granted","user_id":"123"}"#))
            .mount(&mock_server)
            .await;
        
        let client = HttpTestClient::new(&mock_server.uri())
            .with_auth("test-token");
        
        let response = client.get("/api/protected").await.unwrap();
        
        assert!(response.is_success());
        
        let data: HashMap<String, String> = response.json().unwrap();
        assert_eq!(data.get("message"), Some(&"Access granted".to_string()));
    }
    
    #[tokio::test]
    async fn test_concurrent_api_requests() {
        let mock_server = MockServer::start().await;
        
        // 设置并发请求处理
        for i in 0..5 {
            Mock::given(method("GET"))
                .and(path(format!("/api/users/{}", i)))
                .respond_with(ResponseTemplate::new(200)
                    .body(format!(r#"{{"id":"{}","username":"user{}","email":"user{}@example.com"}}"#, i, i, i)))
                .mount(&mock_server)
                .await;
        }
        
        let client = HttpTestClient::new(&mock_server.uri());
        
        // 并发发送请求
        let mut handles = vec![];
        for i in 0..5 {
            let client = client.clone();
            let path = format!("/api/users/{}", i);
            
            let handle = tokio::spawn(async move {
                client.get(&path).await.map_err(|e| e.to_string())
            });
            
            handles.push(handle);
        }
        
        // 等待所有请求完成
        for handle in handles {
            let result = handle.await.unwrap();
            assert!(result.is_ok());
            let response = result.unwrap();
            assert!(response.is_success());
        }
    }
    
    #[tokio::test]
    async fn test_rate_limiting() {
        let mock_server = MockServer::start().await;
        
        // 模拟速率限制
        Mock::given(method("GET"))
            .and(path("/api/limited"))
            .respond_with_fn(move |request| {
                // 简单的速率限制逻辑
                if request.headers.get("rate-limit-test").is_none() {
                    ResponseTemplate::new(429)
                        .body(r#"{"error":"Rate limit exceeded","retry_after":60}"#)
                } else {
                    ResponseTemplate::new(200)
                        .body(r#"{"message":"Request successful"}"#)
                }
            })
            .mount(&mock_server)
            .await;
        
        let client = HttpTestClient::new(&mock_server.uri());
        
        // 第一次请求应该失败
        let response1 = client.get("/api/limited").await.unwrap();
        assert_eq!(response1.status_code, 429);
        
        // 带特殊头的请求应该成功
        let mut headers = reqwest::header::HeaderMap::new();
        headers.insert("rate-limit-test", reqwest::header::HeaderValue::from_str("true").unwrap());
        
        let response2 = client.client
            .get(&format!("{}/api/limited", mock_server.uri()))
            .headers(headers)
            .send()
            .await
            .unwrap();
        
        assert_eq!(response2.status(), StatusCode::OK);
    }
}
}

15.3 性能测试和基准测试

15.3.1 基准测试框架

#![allow(unused)]
fn main() {
// File: performance-tests/src/benchmarks.rs
use criterion::{black_box, criterion_group, criterion_main, Criterion, BenchmarkId};
use std::time::{Duration, Instant};
use rand::prelude::*;
use std::collections::HashMap;
use rayon::prelude::*;

/// 基准测试目标函数
pub struct BenchmarkTargets {
    data_size: usize,
    iterations: usize,
}

impl BenchmarkTargets {
    pub fn new(data_size: usize, iterations: usize) -> Self {
        BenchmarkTargets { data_size, iterations }
    }
}

/// 排序算法基准测试
pub fn sorting_algorithms(c: &mut Criterion) {
    let mut group = c.benchmark_group("sorting_algorithms");
    
    let sizes = [1000, 5000, 10000];
    
    for size in sizes {
        // 生成随机数据
        let mut data: Vec<i32> = (0..size).collect();
        let mut rng = rand::thread_rng();
        data.shuffle(&mut rng);
        
        group.bench_with_input(
            BenchmarkId::new("std_sort", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let mut data = data.clone();
                    data.sort();
                    black_box(&data);
                });
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("quick_sort", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let mut data = data.clone();
                    quick_sort(&mut data, 0, data.len() - 1);
                    black_box(&data);
                });
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("merge_sort", size),
            &data,
            |b, data| {
                b.iter(|| {
                    let mut data = data.clone();
                    data.sort_unstable();
                    black_box(&data);
                });
            },
        );
    }
    
    group.finish();
}

/// 快速排序实现
fn quick_sort<T: Ord>(arr: &mut [T], low: usize, high: usize) {
    if low < high {
        let pi = partition(arr, low, high);
        if pi > 0 {
            quick_sort(arr, low, pi - 1);
        }
        quick_sort(arr, pi + 1, high);
    }
}

fn partition<T: Ord>(arr: &mut [T], low: usize, high: usize) -> usize {
    let pivot = arr[high].clone();
    let mut i = low;
    
    for j in low..high {
        if arr[j] <= pivot {
            arr.swap(i, j);
            i += 1;
        }
    }
    arr.swap(i, high);
    i
}

/// 数据结构性能基准测试
pub fn data_structures(c: &mut Criterion) {
    let mut group = c.benchmark_group("data_structures");
    
    let operations = ["insert", "lookup", "remove"];
    let sizes = [1000, 5000, 10000];
    
    for &size in &sizes {
        // 生成测试数据
        let keys: Vec<i32> = (0..size).collect();
        let values: Vec<String> = (0..size).map(|i| format!("value_{}", i)).collect();
        
        group.bench_with_input(
            BenchmarkId::new("hashmap_operations", size),
            &(keys.clone(), values.clone()),
            |b, (keys, values)| {
                b.iter(|| {
                    let mut map = HashMap::with_capacity(size);
                    
                    // 插入操作
                    for (i, (key, value)) in keys.iter().zip(values.iter()).enumerate() {
                        map.insert(key, value);
                        
                        // 定期进行查找操作
                        if i % 100 == 0 {
                            black_box(map.get(key));
                        }
                    }
                    
                    black_box(map.len());
                });
            },
        );
        
        // 纯插入测试
        group.bench_with_input(
            BenchmarkId::new("hashmap_insert_only", size),
            &keys,
            |b, keys| {
                b.iter(|| {
                    let mut map = HashMap::with_capacity(keys.len());
                    for key in keys {
                        map.insert(key, format!("value_{}", key));
                    }
                    black_box(map);
                });
            },
        );
    }
    
    group.finish();
}

/// 字符串处理基准测试
pub fn string_processing(c: &mut Criterion) {
    let mut group = c.benchmark_group("string_processing");
    
    let test_strings = [
        "short",
        "this is a medium length string for testing",
        "this is a much longer string that should test the performance of various string operations like concatenation search and manipulation in a realistic scenario",
    ];
    
    for (i, test_string) in test_strings.iter().enumerate() {
        group.bench_with_input(
            BenchmarkId::new("string_concatenation", i),
            test_string,
            |b, s| {
                b.iter(|| {
                    let mut result = String::new();
                    for _ in 0..1000 {
                        result.push_str(s);
                    }
                    black_box(&result);
                });
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("string_search", i),
            test_string,
            |b, s| {
                b.iter(|| {
                    let target = "test";
                    black_box(s.contains(target));
                });
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("string_split", i),
            test_string,
            |b, s| {
                b.iter(|| {
                    let parts: Vec<&str> = s.split(' ').collect();
                    black_box(parts);
                });
            },
        );
    }
    
    group.finish();
}

/// 并发性能基准测试
pub fn concurrent_processing(c: &mut Criterion) {
    let mut group = c.benchmark_group("concurrent_processing");
    
    let data_sizes = [1000, 5000, 10000];
    let thread_counts = [1, 2, 4, 8];
    
    for &data_size in &data_sizes {
        for &thread_count in &thread_counts {
            let test_data: Vec<i32> = (0..data_size).collect();
            
            group.bench_with_input(
                BenchmarkId::new(
                    format!("parallel_sum_{}_threads", thread_count),
                    data_size
                ),
                &test_data,
                |b, data| {
                    b.iter(|| {
                        let chunks = data.chunks(data.len() / thread_count);
                        let sum: i32 = chunks
                            .into_par_iter()
                            .map(|chunk| chunk.iter().sum::<i32>())
                            .sum();
                        black_box(sum);
                    });
                },
            );
            
            // 串行版本作为对比
            if thread_count == 1 {
                group.bench_with_input(
                    BenchmarkId::new("sequential_sum", data_size),
                    &test_data,
                    |b, data| {
                        b.iter(|| {
                            let sum: i32 = data.iter().sum();
                            black_box(sum);
                        });
                    },
                );
            }
        }
    }
    
    group.finish();
}

/// 内存分配基准测试
pub fn memory_allocation(c: &mut Criterion) {
    let mut group = c.benchmark_group("memory_allocation");
    
    let sizes = [100, 1000, 10000, 100000];
    
    for &size in &sizes {
        // 预分配向量测试
        group.bench_with_input(
            BenchmarkId::new("vec_with_capacity", size),
            &size,
            |b, &n| {
                b.iter(|| {
                    let mut vec = Vec::with_capacity(n);
                    for i in 0..n {
                        vec.push(i);
                    }
                    black_box(vec);
                });
            },
        );
        
        // 直接分配测试
        group.bench_with_input(
            BenchmarkId::new("vec_push_grow", size),
            &size,
            |b, &n| {
                b.iter(|| {
                    let mut vec = Vec::new();
                    for i in 0..n {
                        vec.push(i);
                    }
                    black_box(vec);
                });
            },
        );
        
        // 字符串分配测试
        group.bench_with_input(
            BenchmarkId::new("string_allocation", size),
            &size,
            |b, &n| {
                b.iter(|| {
                    let mut s = String::new();
                    for i in 0..n {
                        s.push_str(&format!("{}", i));
                    }
                    black_box(s);
                });
            },
        );
    }
    
    group.finish();
}

/// 网络I/O模拟基准测试
pub fn network_io_simulation(c: &mut Criterion) {
    let mut group = c.benchmark_group("network_io");
    
    let message_sizes = [100, 1000, 10000];
    let batch_sizes = [1, 10, 100];
    
    for &message_size in &message_sizes {
        for &batch_size in &batch_sizes {
            let test_messages = vec![vec![0u8; message_size]; batch_size];
            
            group.bench_with_input(
                BenchmarkId::new(
                    format!("batch_processing_{}x{}", batch_size, message_size),
                    message_size
                ),
                &test_messages,
                |b, messages| {
                    b.iter(|| {
                        // 模拟批处理
                        let processed: Vec<_> = messages
                            .iter()
                            .map(|msg| process_message(msg))
                            .collect();
                        black_box(processed);
                    });
                },
            );
        }
    }
    
    group.finish();
}

/// 模拟消息处理
fn process_message(data: &[u8]) -> Vec<u8> {
    // 模拟某种处理逻辑
    data.iter()
        .map(|&b| b.wrapping_add(1))
        .collect()
}

/// 数据库操作基准测试
pub fn database_operations(c: &mut Criterion) {
    let mut group = c.benchmark_group("database_operations");
    
    // 模拟数据库查询
    let query_counts = [100, 1000, 5000];
    
    for &count in &query_counts {
        group.bench_with_input(
            BenchmarkId::new("select_queries", count),
            &count,
            |b, &n| {
                b.iter(|| {
                    let mut results = Vec::new();
                    for i in 0..n {
                        // 模拟查询
                        let result = simulate_database_query(i);
                        results.push(result);
                    }
                    black_box(results);
                });
            },
        );
        
        group.bench_with_input(
            BenchmarkId::new("batch_insert", count),
            &count,
            |b, &n| {
                b.iter(|| {
                    let data = generate_test_data(n);
                    let result = simulate_batch_insert(&data);
                    black_box(result);
                });
            },
        );
    }
    
    group.finish();
}

fn simulate_database_query(id: i32) -> String {
    // 模拟数据库查询延迟
    std::thread::sleep(Duration::from_micros(100));
    format!("result_{}", id)
}

fn generate_test_data(count: usize) -> Vec<String> {
    (0..count).map(|i| format!("test_data_{}", i)).collect()
}

fn simulate_batch_insert(data: &[String]) -> usize {
    // 模拟批量插入延迟
    std::thread::sleep(Duration::from_micros(data.len() as u64 * 10));
    data.len()
}

criterion_group!(
    benches,
    sorting_algorithms,
    data_structures,
    string_processing,
    concurrent_processing,
    memory_allocation,
    network_io_simulation,
    database_operations
);
criterion_main!(benches);
}

15.3.2 自定义性能监控系统

#![allow(unused)]
fn main() {
// File: performance-tests/src/monitoring.rs
use std::collections::HashMap;
use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
use std::sync::{Arc, Mutex};
use serde::{Deserialize, Serialize};
use once_cell::sync::Lazy;

/// 全局性能监控系统
pub static PERF_MONITOR: Lazy<Arc<PerfMonitor>> = Lazy::new(|| {
    Arc::new(PerfMonitor::new())
});

/// 性能指标类型
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum MetricType {
    Counter,
    Gauge,
    Histogram,
    Summary,
}

/// 性能指标
#[derive(Debug, Clone)]
pub struct Metric {
    pub name: String,
    pub metric_type: MetricType,
    pub value: f64,
    pub timestamp: u64,
    pub labels: HashMap<String, String>,
}

impl Metric {
    pub fn new(name: &str, metric_type: MetricType, value: f64) -> Self {
        Metric {
            name: name.to_string(),
            metric_type,
            value,
            timestamp: SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_secs(),
            labels: HashMap::new(),
        }
    }
    
    pub fn with_label(mut self, key: &str, value: &str) -> Self {
        self.labels.insert(key.to_string(), value.to_string());
        self
    }
}

/// 性能事件
#[derive(Debug, Clone)]
pub struct PerfEvent {
    pub name: String,
    pub start_time: Instant,
    pub end_time: Option<Instant>,
    pub labels: HashMap<String, String>,
    pub success: bool,
}

impl PerfEvent {
    pub fn new(name: &str) -> Self {
        PerfEvent {
            name: name.to_string(),
            start_time: Instant::now(),
            end_time: None,
            labels: HashMap::new(),
            success: true,
        }
    }
    
    pub fn with_label(mut self, key: &str, value: &str) -> Self {
        self.labels.insert(key.to_string(), value.to_string());
        self
    }
    
    pub fn end(&mut self) {
        self.end_time = Some(Instant::now());
    }
    
    pub fn mark_failed(&mut self) {
        self.success = false;
    }
    
    pub fn duration(&self) -> Option<Duration> {
        self.end_time.map(|end| end.duration_since(self.start_time))
    }
}

/// 性能监控器
pub struct PerfMonitor {
    metrics: Arc<Mutex<Vec<Metric>>>,
    active_events: Arc<Mutex<HashMap<String, PerfEvent>>>,
    counters: Arc<Mutex<HashMap<String, f64>>>,
    gauges: Arc<Mutex<HashMap<String, f64>>>,
}

impl PerfMonitor {
    pub fn new() -> Self {
        PerfMonitor {
            metrics: Arc::new(Mutex::new(Vec::new())),
            active_events: Arc::new(Mutex::new(HashMap::new())),
            counters: Arc::new(Mutex::new(HashMap::new())),
            gauges: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    /// 记录指标
    pub fn record_metric(&self, metric: Metric) {
        let mut metrics = self.metrics.lock().unwrap();
        metrics.push(metric);
        
        // 限制内存使用
        if metrics.len() > 10000 {
            metrics.drain(0..5000);
        }
    }
    
    /// 增加计数器
    pub fn increment_counter(&self, name: &str, value: f64) {
        let mut counters = self.counters.lock().unwrap();
        *counters.entry(name.to_string()).or_insert(0.0) += value;
        
        self.record_metric(Metric::new(name, MetricType::Counter, value));
    }
    
    /// 设置仪表值
    pub fn set_gauge(&self, name: &str, value: f64) {
        let mut gauges = self.gauges.lock().unwrap();
        gauges.insert(name.to_string(), value);
        
        self.record_metric(Metric::new(name, MetricType::Gauge, value));
    }
    
    /// 记录时间测量
    pub fn time_operation<T, F>(&self, name: &str, operation: F) -> T
    where
        F: FnOnce() -> T,
    {
        let start = Instant::now();
        let result = operation();
        let duration = start.elapsed();
        
        self.record_metric(Metric::new(
            &format!("{}_duration", name),
            MetricType::Histogram,
            duration.as_secs_f64(),
        ));
        
        result
    }
    
    /// 记录时间测量（异步）
    pub async fn time_operation_async<T, F, Fut>(&self, name: &str, operation: Fut) -> T
    where
        F: FnOnce() -> T,
        Fut: std::future::Future<Output = T>,
    {
        let start = Instant::now();
        let result = operation().await;
        let duration = start.elapsed();
        
        self.record_metric(Metric::new(
            &format!("{}_duration", name),
            MetricType::Histogram,
            duration.as_secs_f64(),
        ));
        
        result
    }
    
    /// 开始性能事件
    pub fn start_event(&self, name: &str) -> String {
        let event_id = format!("{}_{}", name, SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos());
        
        let event = PerfEvent::new(name);
        
        let mut events = self.active_events.lock().unwrap();
        events.insert(event_id.clone(), event);
        
        event_id
    }
    
    /// 结束性能事件
    pub fn end_event(&self, event_id: &str) -> Option<Duration> {
        let mut events = self.active_events.lock().unwrap();
        
        if let Some(mut event) = events.remove(event_id) {
            event.end();
            
            if let Some(duration) = event.duration() {
                self.record_metric(Metric::new(
                    &format!("{}_event_duration", event.name),
                    MetricType::Histogram,
                    duration.as_secs_f64(),
                ));
                
                return Some(duration);
            }
        }
        
        None
    }
    
    /// 标记事件失败
    pub fn mark_event_failed(&self, event_id: &str) {
        let mut events = self.active_events.lock().unwrap();
        
        if let Some(event) = events.get_mut(event_id) {
            event.mark_failed();
            
            self.increment_counter(&format!("{}_failures", event.name), 1.0);
        }
    }
    
    /// 获取所有指标
    pub fn get_metrics(&self) -> Vec<Metric> {
        let metrics = self.metrics.lock().unwrap();
        metrics.clone()
    }
    
    /// 获取计数器
    pub fn get_counters(&self) -> HashMap<String, f64> {
        let counters = self.counters.lock().unwrap();
        counters.clone()
    }
    
    /// 获取仪表值
    pub fn get_gauges(&self) -> HashMap<String, f64> {
        let gauges = self.gauges.lock().unwrap();
        gauges.clone()
    }
    
    /// 清理旧指标
    pub fn cleanup_old_metrics(&self, max_age: Duration) {
        let now = SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap();
        
        let mut metrics = self.metrics.lock().unwrap();
        metrics.retain(|metric| {
            now.as_secs().saturating_sub(metric.timestamp) < max_age.as_secs()
        });
    }
    
    /// 生成性能报告
    pub fn generate_report(&self) -> PerfReport {
        let metrics = self.metrics.lock().unwrap();
        let counters = self.counters.lock().unwrap();
        let gauges = self.gauges.lock().unwrap();
        let active_events = self.active_events.lock().unwrap();
        
        // 计算统计信息
        let mut durations = Vec::new();
        for metric in &*metrics {
            if metric.name.contains("_duration") || metric.name.contains("_event_duration") {
                durations.push(metric.value);
            }
        }
        
        durations.sort_by(|a, b| a.partial_cmp(b).unwrap());
        let avg_duration = if durations.is_empty() {
            0.0
        } else {
            durations.iter().sum::<f64>() / durations.len() as f64
        };
        
        let p95_duration = if durations.len() > 20 {
            let index = (durations.len() as f64 * 0.95) as usize;
            durations[std::cmp::min(index, durations.len() - 1)]
        } else {
            durations.last().copied().unwrap_or(0.0)
        };
        
        PerfReport {
            total_metrics: metrics.len(),
            total_counters: counters.len(),
            total_gauges: gauges.len(),
            active_events: active_events.len(),
            average_duration: avg_duration,
            p95_duration,
            timestamp: SystemTime::now()
                .duration_since(UNIX_EPOCH)
                .unwrap()
                .as_secs(),
        }
    }
    
    /// 导出指标为JSON
    pub fn export_json(&self) -> String {
        let report = self.generate_report();
        serde_json::to_string_pretty(&report).unwrap_or_default()
    }
    
    /// 导出指标为Prometheus格式
    pub fn export_prometheus(&self) -> String {
        let mut output = String::new();
        
        let metrics = self.metrics.lock().unwrap();
        for metric in &*metrics {
            let labels = if metric.labels.is_empty() {
                String::new()
            } else {
                let label_strings: Vec<String> = metric.labels
                    .iter()
                    .map(|(k, v)| format!("{}=\"{}\"", k, v))
                    .collect();
                format!("{{{}}}", label_strings.join(","))
            };
            
            let metric_type = match &metric.metric_type {
                MetricType::Counter => "counter",
                MetricType::Gauge => "gauge",
                MetricType::Histogram => "histogram",
                MetricType::Summary => "summary",
            };
            
            output.push_str(&format!(
                "# TYPE {} {}\n",
                metric.name,
                metric_type
            ));
            
            output.push_str(&format!(
                "{}{} {}\n",
                metric.name,
                labels,
                metric.value
            ));
        }
        
        output
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct PerfReport {
    pub total_metrics: usize,
    pub total_counters: usize,
    pub total_gauges: usize,
    pub active_events: usize,
    pub average_duration: f64,
    pub p95_duration: f64,
    pub timestamp: u64,
}

impl PerfReport {
    pub fn print_summary(&self) {
        println!("=== Performance Report ===");
        println!("Timestamp: {}", self.timestamp);
        println!("Total Metrics: {}", self.total_metrics);
        println!("Total Counters: {}", self.total_counters);
        println!("Total Gauges: {}", self.total_gauges);
        println!("Active Events: {}", self.active_events);
        println!("Average Duration: {:.3}s", self.average_duration);
        println!("P95 Duration: {:.3}s", self.p95_duration);
    }
}

/// 性能测试结果
#[derive(Debug, Clone)]
pub struct PerformanceTestResult {
    pub test_name: String,
    pub duration: Duration,
    pub operations_per_second: f64,
    pub memory_used: usize,
    pub success_rate: f64,
    pub error_count: usize,
}

impl PerformanceTestResult {
    pub fn new(test_name: &str, duration: Duration, operations: u64, memory_used: usize, success_count: u64, total_operations: u64) -> Self {
        let success_rate = if total_operations > 0 {
            success_count as f64 / total_operations as f64
        } else {
            0.0
        };
        
        PerformanceTestResult {
            test_name: test_name.to_string(),
            duration,
            operations_per_second: operations as f64 / duration.as_secs_f64(),
            memory_used,
            success_rate,
            error_count: (total_operations - success_count) as usize,
        }
    }
}

/// 性能测试套件
pub struct PerformanceTestSuite {
    monitor: Arc<PerfMonitor>,
}

impl PerformanceTestSuite {
    pub fn new() -> Self {
        PerformanceTestSuite {
            monitor: PERF_MONITOR.clone(),
        }
    }
    
    /// 运行并发性能测试
    pub fn run_concurrency_test(&self, operation: &str, concurrent_tasks: usize, operations_per_task: usize) -> PerformanceTestResult {
        let start = Instant::now();
        let monitor = self.monitor.clone();
        
        // 启动并发任务
        let handles: Vec<_> = (0..concurrent_tasks)
            .map(|task_id| {
                let monitor = monitor.clone();
                let op = operation.to_string();
                tokio::spawn(async move {
                    let mut success_count = 0u64;
                    
                    for i in 0..operations_per_task {
                        let event_id = monitor.start_event(&format!("{}_task_{}_op_{}", op, task_id, i));
                        
                        // 模拟操作
                        tokio::time::sleep(Duration::from_millis(1)).await;
                        
                        // 模拟随机失败
                        if rand::random::<f32>() < 0.95 {
                            success_count += 1;
                        } else {
                            monitor.mark_event_failed(&event_id);
                        }
                        
                        monitor.end_event(&event_id);
                    }
                    
                    success_count
                })
            })
            .collect();
        
        // 等待所有任务完成
        let mut total_success = 0u64;
        for handle in handles {
            if let Ok(success_count) = handle.await {
                total_success += success_count;
            }
        }
        
        let duration = start.elapsed();
        let total_operations = (concurrent_tasks * operations_per_task) as u64;
        
        PerformanceTestResult::new(
            &format!("concurrency_{}_{}", concurrent_tasks, operation),
            duration,
            total_operations,
            0, // 简化内存使用计算
            total_success,
            total_operations,
        )
    }
    
    /// 运行内存性能测试
    pub fn run_memory_test(&self, allocation_size: usize, allocations: usize) -> PerformanceTestResult {
        let start = Instant::now();
        let monitor = self.monitor.clone();
        
        let event_id = monitor.start_event("memory_allocation_test");
        
        let mut allocations_made = 0;
        let mut vec = Vec::new();
        
        for _ in 0..allocations {
            monitor.time_operation("single_allocation", || {
                vec.push(vec![0u8; allocation_size]);
            });
            allocations_made += 1;
        }
        
        monitor.end_event(&event_id);
        let duration = start.elapsed();
        
        PerformanceTestResult::new(
            "memory_allocation",
            duration,
            allocations_made as u64,
            allocations_made * allocation_size,
            allocations_made as u64,
            allocations_made as u64,
        )
    }
    
    /// 运行数据库性能测试
    pub fn run_database_test(&self, queries: usize) -> PerformanceTestResult {
        let start = Instant::now();
        let monitor = self.monitor.clone();
        
        let mut success_count = 0u64;
        
        for i in 0..queries {
            let event_id = monitor.start_event(&format!("db_query_{}", i));
            
            // 模拟数据库查询
            let result = monitor.time_operation("db_query_simulation", || {
                std::thread::sleep(Duration::from_millis(rand::random::<u64>() % 10 + 1));
                if rand::random::<f32>() < 0.99 {
                    Ok("query_result".to_string())
                } else {
                    Err("Query failed".to_string())
                }
            });
            
            match result {
                Ok(_) => success_count += 1,
                Err(_) => monitor.mark_event_failed(&event_id),
            }
            
            monitor.end_event(&event_id);
        }
        
        let duration = start.elapsed();
        
        PerformanceTestResult::new(
            "database_queries",
            duration,
            queries as u64,
            0,
            success_count,
            queries as u64,
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_perf_monitor() {
        let monitor = PerfMonitor::new();
        
        // 测试计数器
        monitor.increment_counter("test_counter", 1.0);
        monitor.increment_counter("test_counter", 2.0);
        
        let counters = monitor.get_counters();
        assert_eq!(counters["test_counter"], 3.0);
        
        // 测试仪表
        monitor.set_gauge("test_gauge", 42.0);
        let gauges = monitor.get_gauges();
        assert_eq!(gauges["test_gauge"], 42.0);
        
        // 测试时间测量
        let result = monitor.time_operation("test_operation", || {
            std::thread::sleep(Duration::from_millis(10));
            "test_result"
        });
        
        assert_eq!(result, "test_result");
    }
    
    #[tokio::test]
    async fn test_performance_test_suite() {
        let suite = PerformanceTestSuite::new();
        
        // 测试并发性能
        let result = suite.run_concurrency_test("test_op", 5, 10);
        assert!(result.operations_per_second > 0.0);
        assert!(result.success_rate >= 0.0);
    }
}
}

15.4 调试工具和技术

15.4.1 调试宏和工具

#![allow(unused)]
fn main() {
// File: debug-tools/src/lib.rs

/// 调试宏集合
pub mod debug_macros {
    /// 安全地打印变量的值
    #[macro_export]
    macro_rules! dbg_value {
        ($value:expr) => {
            {
                let value = &$value;
                let type_name = std::any::type_name::<decl_expr!($value)>();
                eprintln!("[DEBUG] {}: {:?} = {:#?}", 
                    file!().split('/').last().unwrap(),
                    type_name,
                    value
                );
                value
            }
        };
    }
/// 条件调试宏
    #[macro_export]
    macro_rules! debug_if {
        ($cond:expr, $($arg:tt)*) => {
            if $cond {
                eprintln!("[DEBUG] {}", format_args!($($arg)*));
            }
        };
    }
    
    /// 带有位置的调试宏
    #[macro_export]
    macro_rules! debug_with_location {
        ($($arg:tt)*) => {
            eprintln!("[DEBUG] {}:{}:{} - {}", 
                file!(), 
                line!(), 
                column!(), 
                format_args!($($arg)*)
            );
        };
    }
    
    /// 跟踪函数调用
    #[macro_export]
    macro_rules! trace_function {
        () => {
            eprintln!("[TRACE] Entering function: {} at {}:{}:{}", 
                function_name!(), 
                file!(), 
                line!(), 
                column!()
            );
        };
        ($($arg:tt)*) => {
            eprintln!("[TRACE] Entering function: {} - {}", 
                function_name!(), 
                format_args!($($arg)*)
            );
        };
    }
    
    /// 性能分析宏
    #[macro_export]
    macro_rules! profile_operation {
        ($name:expr, $operation:block) => {
            {
                let start = std::time::Instant::now();
                let result = $operation;
                let duration = start.elapsed();
                eprintln!("[PROFILE] {} took {}ms", $name, duration.as_millis());
                result
            }
        };
    }
    
    /// 内存使用分析宏
    #[macro_export]
    macro_rules! analyze_memory {
        ($operation:block) => {
            {
                let before = get_memory_usage();
                let result = $operation;
                let after = get_memory_usage();
                eprintln!("[MEMORY] Before: {}MB, After: {}MB, Delta: {}MB",
                    before / 1024 / 1024,
                    after / 1024 / 1024,
                    (after.saturating_sub(before)) / 1024 / 1024
                );
                result
            }
        };
    }
}

/// 函数名宏
#[macro_export]
macro_rules! function_name {
    () => {{
        fn f() {}
        std::any::type_name::<decl_expr!(f)>().strip_suffix("::f").unwrap()
    }};
}

/// 获取当前内存使用量
pub fn get_memory_usage() -> usize {
    use std::alloc::{GlobalAlloc, Layout, System};
    // 这是一个简化的内存使用检查
    // 实际实现需要更复杂的逻辑
    0
}

/// 调试信息结构
#[derive(Debug, Clone)]
pub struct DebugInfo {
    pub file: &'static str,
    pub line: u32,
    pub column: u32,
    pub function: &'static str,
    pub timestamp: std::time::SystemTime,
    pub thread_id: std::thread::ThreadId,
}

impl DebugInfo {
    pub fn new() -> Self {
        let location = std::panic::Location::caller();
        DebugInfo {
            file: location.file(),
            line: location.line(),
            column: location.column(),
            function: std::panic::Location::caller().function(),
            timestamp: std::time::SystemTime::now(),
            thread_id: std::thread::current().id(),
        }
    }
    
    pub fn with_context(context: &str) -> Self {
        let mut info = Self::new();
        eprintln!("[DEBUG] {} - {}:{}:{} in {}",
            context,
            info.file,
            info.line,
            info.column,
            info.function
        );
        info
    }
}

/// 简单调试器
pub struct SimpleDebugger {
    enabled: bool,
    log_level: LogLevel,
    output: std::sync::Arc<std::sync::Mutex<dyn std::io::Write>>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum LogLevel {
    Error,
    Warning,
    Info,
    Debug,
    Trace,
}

impl SimpleDebugger {
    pub fn new() -> Self {
        SimpleDebugger {
            enabled: true,
            log_level: LogLevel::Info,
            output: std::sync::Arc::new(std::sync::Mutex::new(std::io::stdout())),
        }
    }
    
    pub fn with_log_level(mut self, level: LogLevel) -> Self {
        self.log_level = level;
        self
    }
    
    pub fn with_output<W: std::io::Write + 'static>(mut self, output: W) -> Self {
        self.output = std::sync::Arc::new(std::sync::Mutex::new(output));
        self
    }
    
    pub fn disable(&mut self) {
        self.enabled = false;
    }
    
    pub fn enable(&mut self) {
        self.enabled = true;
    }
    
    fn should_log(&self, level: &LogLevel) -> bool {
        if !self.enabled {
            return false;
        }
        
        let levels = [
            LogLevel::Error,
            LogLevel::Warning,
            LogLevel::Info,
            LogLevel::Debug,
            LogLevel::Trace,
        ];
        
        let current_index = levels.iter().position(|l| l == &self.log_level).unwrap_or(2);
        let target_index = levels.iter().position(|l| l == level).unwrap_or(2);
        
        target_index <= current_index
    }
    
    pub fn error(&self, message: &str) {
        if self.should_log(&LogLevel::Error) {
            self.log("ERROR", message, LogLevel::Error);
        }
    }
    
    pub fn warning(&self, message: &str) {
        if self.should_log(&LogLevel::Warning) {
            self.log("WARNING", message, LogLevel::Warning);
        }
    }
    
    pub fn info(&self, message: &str) {
        if self.should_log(&LogLevel::Info) {
            self.log("INFO", message, LogLevel::Info);
        }
    }
    
    pub fn debug(&self, message: &str) {
        if self.should_log(&LogLevel::Debug) {
            self.log("DEBUG", message, LogLevel::Debug);
        }
    }
    
    pub fn trace(&self, message: &str) {
        if self.should_log(&LogLevel::Trace) {
            self.log("TRACE", message, LogLevel::Trace);
        }
    }
    
    fn log(&self, level: &str, message: &str, log_level: LogLevel) {
        if let Ok(mut output) = self.output.lock() {
            let timestamp = std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_millis();
            
            writeln!(output, "[{}] [{}] {} - {}",
                timestamp,
                level,
                std::thread::current().name().unwrap_or("main"),
                message
            ).ok();
        }
    }
    
    /// 性能分析装饰器
    pub fn profile<F, T>(&self, name: &str, f: F) -> T
    where
        F: FnOnce() -> T,
    {
        if !self.should_log(&LogLevel::Debug) {
            return f();
        }
        
        let start = std::time::Instant::now();
        let result = f();
        let duration = start.elapsed();
        
        self.debug(&format!("{} took {}ms", name, duration.as_millis()));
        result
    }
    
    /// 变量检查器
    pub fn inspect<T: std::fmt::Debug>(&self, name: &str, value: &T) {
        if self.should_log(&LogLevel::Debug) {
            self.debug(&format!("{} = {:?}", name, value));
        }
    }
    
    /// 结构体字段检查器
    pub fn inspect_struct<T: std::fmt::Debug>(&self, name: &str, value: &T) {
        if self.should_log(&LogLevel::Debug) {
            self.debug(&format!("{:#?}", value));
        }
    }
}

/// 全局调试器实例
static DEBUGGER: std::sync::OnceLock<SimpleDebugger> = std::sync::OnceLock::new();

pub fn get_debugger() -> &'static SimpleDebugger {
    DEBUGGER.get_or_init(|| SimpleDebugger::new())
}

pub fn get_debugger_mut() -> &'static mut SimpleDebugger {
    let debugger = DEBUGGER.get_or_init(|| SimpleDebugger::new());
    // 注意：这是不安全的，只用于测试
    unsafe { std::mem::transmute::<&SimpleDebugger, &'static mut SimpleDebugger>(debugger) }
}

/// 高级调试工具
pub struct AdvancedDebugger {
    profiler: std::collections::BTreeMap<String, std::time::Duration>,
    call_count: std::collections::BTreeMap<String, usize>,
    memory_snapshots: Vec<MemorySnapshot>,
    thread_tracker: ThreadTracker,
}

#[derive(Debug, Clone)]
struct MemorySnapshot {
    timestamp: std::time::SystemTime,
    usage: usize,
    allocations: usize,
    deallocations: usize,
}

struct ThreadTracker {
    threads: std::sync::Mutex<std::collections::HashMap<std::thread::ThreadId, ThreadInfo>>,
}

#[derive(Debug, Clone)]
struct ThreadInfo {
    name: String,
    created_at: std::time::SystemTime,
    stack_size: usize,
}

impl AdvancedDebugger {
    pub fn new() -> Self {
        AdvancedDebugger {
            profiler: std::collections::BTreeMap::new(),
            call_count: std::collections::BTreeMap::new(),
            memory_snapshots: Vec::new(),
            thread_tracker: ThreadTracker {
                threads: std::sync::Mutex::new(std::collections::HashMap::new()),
            },
        }
    }
    
    /// 跟踪函数执行
    pub fn trace_function<F, T>(&mut self, name: &str, f: F) -> T
    where
        F: FnOnce() -> T,
    {
        let start = std::time::Instant::now();
        *self.call_count.entry(name.to_string()).or_insert(0) += 1;
        
        // 跟踪线程信息
        {
            let mut threads = self.thread_tracker.threads.lock().unwrap();
            threads.insert(
                std::thread::current().id(),
                ThreadInfo {
                    name: std::thread::current().name().unwrap_or("unnamed").to_string(),
                    created_at: std::time::SystemTime::now(),
                    stack_size: 0, // 简化实现
                }
            );
        }
        
        let result = f();
        let duration = start.elapsed();
        
        *self.profiler.entry(name.to_string()).or_insert(std::time::Duration::from_secs(0)) += duration;
        
        result
    }
    
    /// 内存分析
    pub fn analyze_memory(&mut self) {
        let snapshot = MemorySnapshot {
            timestamp: std::time::SystemTime::now(),
            usage: self.get_current_memory_usage(),
            allocations: 0, // 需要实现
            deallocations: 0, // 需要实现
        };
        
        self.memory_snapshots.push(snapshot);
        
        // 保留最近100个快照
        if self.memory_snapshots.len() > 100 {
            self.memory_snapshots.remove(0);
        }
    }
    
    fn get_current_memory_usage() -> usize {
        // 简化的内存使用检查
        // 实际实现需要使用系统API
        0
    }
    
    /// 生成分析报告
    pub fn generate_report(&self) -> DebugReport {
        let mut total_call_time = std::time::Duration::from_secs(0);
        let mut most_expensive = None;
        let mut most_frequent = None;
        let mut max_calls = 0;
        
        for (name, &duration) in &self.profiler {
            total_call_time += duration;
            if most_expensive.map_or(true, |(_, d)| duration > d) {
                most_expensive = Some((name.clone(), duration));
            }
        }
        
        for (name, &count) in &self.call_count {
            if count > max_calls {
                max_calls = count;
                most_frequent = Some((name.clone(), count));
            }
        }
        
        DebugReport {
            total_functions_traced: self.profiler.len(),
            total_calls: self.call_count.values().sum(),
            total_execution_time: total_call_time,
            most_expensive_function: most_expensive,
            most_frequent_function: most_frequent,
            memory_snapshots_count: self.memory_snapshots.len(),
            active_threads: self.thread_tracker.threads.lock().unwrap().len(),
            timestamp: std::time::SystemTime::now(),
        }
    }
    
    /// 导出分析数据
    pub fn export_analysis(&self) -> String {
        let report = self.generate_report();
        format!("{:#?}", report)
    }
}

#[derive(Debug, Clone)]
pub struct DebugReport {
    pub total_functions_traced: usize,
    pub total_calls: usize,
    pub total_execution_time: std::time::Duration,
    pub most_expensive_function: Option<(String, std::time::Duration)>,
    pub most_frequent_function: Option<(String, usize)>,
    pub memory_snapshots_count: usize,
    pub active_threads: usize,
    pub timestamp: std::time::SystemTime,
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_simple_debugger() {
        let debugger = SimpleDebugger::new();
        
        debugger.error("This is an error");
        debugger.warning("This is a warning");
        debugger.info("This is info");
        debugger.debug("This is debug");
        debugger.trace("This is trace");
    }
    
    #[test]
    fn test_simple_debugger_log_levels() {
        let debugger = SimpleDebugger::new()
            .with_log_level(LogLevel::Warning);
        
        debugger.error("Should appear");
        debugger.warning("Should appear");
        debugger.info("Should not appear");
        debugger.debug("Should not appear");
    }
    
    #[test]
    fn test_advanced_debugger() {
        let mut debugger = AdvancedDebugger::new();
        
        debugger.trace_function("test_function", || {
            std::thread::sleep(Duration::from_millis(10));
            42
        });
        
        debugger.analyze_memory();
        
        let report = debugger.generate_report();
        assert_eq!(report.total_functions_traced, 1);
        assert_eq!(report.total_calls, 1);
    }
    
    #[test]
    fn test_debug_macro() {
        let value = 42;
        let result = dbg_value!(value);
        assert_eq!(result, &42);
    }
    
    #[test]
    fn test_profile_macro() {
        let result = profile_operation!("test_operation", {
            std::thread::sleep(Duration::from_millis(10));
            "result"
        });
        
        assert_eq!(result, "result");
    }
    
    #[test]
    fn test_performance_profiler() {
        let debugger = get_debugger();
        
        let result = debugger.profile("math_operation", || {
            2 + 2
        });
        
        assert_eq!(result, 4);
    }
}
}

15.4.2 运行时分析和监控

#![allow(unused)]
fn main() {
// File: debug-tools/src/runtime_analysis.rs

use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant, SystemTime};
use std::collections::{HashMap, BTreeMap, VecDeque};
use serde::{Deserialize, Serialize};

/// 运行时分析器
pub struct RuntimeAnalyzer {
    pub name: String,
    pub enabled: bool,
    pub start_time: Option<Instant>,
    pub metrics: RuntimeMetrics,
    pub call_stack: CallStack,
    pub memory_tracker: MemoryTracker,
    pub performance_counter: PerformanceCounter,
}

#[derive(Debug, Clone)]
pub struct RuntimeMetrics {
    pub total_time: Duration,
    pub average_time: Duration,
    pub min_time: Duration,
    pub max_time: Duration,
    pub call_count: u64,
    pub error_count: u64,
    pub memory_peak: usize,
    pub gc_count: u64,
}

impl Default for RuntimeMetrics {
    fn default() -> Self {
        RuntimeMetrics {
            total_time: Duration::from_secs(0),
            average_time: Duration::from_secs(0),
            min_time: Duration::from_secs(u64::MAX),
            max_time: Duration::from_secs(0),
            call_count: 0,
            error_count: 0,
            memory_peak: 0,
            gc_count: 0,
        }
    }
}

impl RuntimeMetrics {
    pub fn record_execution(&mut self, execution_time: Duration, memory_used: usize) {
        self.call_count += 1;
        self.total_time += execution_time;
        
        if execution_time < self.min_time {
            self.min_time = execution_time;
        }
        if execution_time > self.max_time {
            self.max_time = execution_time;
        }
        
        self.average_time = Duration::from_nanos(
            self.total_time.as_nanos() as u64 / self.call_count
        );
        
        if memory_used > self.memory_peak {
            self.memory_peak = memory_used;
        }
    }
    
    pub fn record_error(&mut self) {
        self.error_count += 1;
    }
    
    pub fn record_gc(&mut self) {
        self.gc_count += 1;
    }
    
    pub fn success_rate(&self) -> f64 {
        if self.call_count == 0 {
            1.0
        } else {
            (self.call_count - self.error_count) as f64 / self.call_count as f64
        }
    }
    
    pub fn performance_score(&self) -> f64 {
        // 综合性能评分
        let success_rate = self.success_rate();
        let avg_time_ms = self.average_time.as_millis() as f64;
        let memory_efficiency = if self.memory_peak > 0 {
            1.0 / (1.0 + (self.memory_peak as f64 / 1024.0 / 1024.0))
        } else {
            1.0
        };
        
        success_rate * memory_efficiency * 1000.0 / (1.0 + avg_time_ms)
    }
}

#[derive(Debug, Clone)]
struct CallFrame {
    pub function: String,
    pub file: &'static str,
    pub line: u32,
    pub column: u32,
    pub timestamp: SystemTime,
}

impl CallFrame {
    pub fn new(function: &str, file: &'static str, line: u32, column: u32) -> Self {
        CallFrame {
            function: function.to_string(),
            file,
            line,
            column,
            timestamp: SystemTime::now(),
        }
    }
}

#[derive(Debug, Clone)]
struct CallStack {
    pub frames: VecDeque<CallFrame>,
    pub max_depth: usize,
}

impl CallStack {
    pub fn new(max_depth: usize) -> Self {
        CallStack {
            frames: VecDeque::new(),
            max_depth,
        }
    }
    
    pub fn push(&mut self, frame: CallFrame) {
        if self.frames.len() >= self.max_depth {
            self.frames.pop_front();
        }
        self.frames.push_back(frame);
    }
    
    pub fn pop(&mut self) -> Option<CallFrame> {
        self.frames.pop_back()
    }
    
    pub fn current_depth(&self) -> usize {
        self.frames.len()
    }
    
    pub fn is_recursive(&self, function: &str) -> bool {
        self.frames.iter().any(|frame| frame.function == function)
    }
}

#[derive(Debug, Clone)]
struct MemorySnapshot {
    pub timestamp: SystemTime,
    pub allocated: usize,
    pub used: usize,
    pub peak: usize,
    pub fragmentation_ratio: f64,
}

impl MemorySnapshot {
    pub fn new(allocated: usize, used: usize) -> Self {
        MemorySnapshot {
            timestamp: SystemTime::now(),
            allocated,
            used,
            peak: used,
            fragmentation_ratio: if allocated > 0 {
                1.0 - (used as f64 / allocated as f64)
            } else {
                0.0
            },
        }
    }
}

struct MemoryTracker {
    snapshots: VecDeque<MemorySnapshot>,
    current_allocated: usize,
    current_used: usize,
    max_snapshots: usize,
}

impl MemoryTracker {
    pub fn new(max_snapshots: usize) -> Self {
        MemoryTracker {
            snapshots: VecDeque::new(),
            current_allocated: 0,
            current_used: 0,
            max_snapshots,
        }
    }
    
    pub fn allocate(&mut self, size: usize) {
        self.current_allocated += size;
        self.current_used += size;
        
        self.take_snapshot();
    }
    
    pub fn deallocate(&mut self, size: usize) {
        self.current_used = self.current_used.saturating_sub(size);
        
        self.take_snapshot();
    }
    
    pub fn get_current_usage(&self) -> (usize, usize) {
        (self.current_allocated, self.current_used)
    }
    
    pub fn get_memory_stats(&self) -> Option<MemoryStats> {
        if self.snapshots.is_empty() {
            return None;
        }
        
        let mut total_allocated = 0;
        let mut total_used = 0;
        let mut peak_usage = 0;
        let mut total_fragmentation = 0.0;
        
        for snapshot in &self.snapshots {
            total_allocated += snapshot.allocated;
            total_used += snapshot.used;
            peak_usage = peak_usage.max(snapshot.used);
            total_fragmentation += snapshot.fragmentation_ratio;
        }
        
        let count = self.snapshots.len() as f64;
        
        Some(MemoryStats {
            average_allocated: total_allocated as f64 / count,
            average_used: total_used as f64 / count,
            peak_usage,
            average_fragmentation: total_fragmentation / count,
            growth_rate: self.calculate_growth_rate(),
        })
    }
    
    fn take_snapshot(&mut self) {
        let snapshot = MemorySnapshot::new(self.current_allocated, self.current_used);
        
        if self.snapshots.len() >= self.max_snapshots {
            self.snapshots.pop_front();
        }
        
        self.snapshots.push_back(snapshot);
    }
    
    fn calculate_growth_rate(&self) -> f64 {
        if self.snapshots.len() < 2 {
            return 0.0;
        }
        
        let len = self.snapshots.len();
        let first = &self.snapshots[0];
        let last = &self.snapshots[len - 1];
        
        if last.timestamp.duration_since(first.timestamp).unwrap_or_default().as_secs() == 0 {
            return 0.0;
        }
        
        let usage_change = last.used as f64 - first.used as f64;
        let time_span = last.timestamp.duration_since(first.timestamp).unwrap_or_default().as_secs_f64();
        
        usage_change / time_span
    }
}

#[derive(Debug, Clone)]
pub struct MemoryStats {
    pub average_allocated: f64,
    pub average_used: f64,
    pub peak_usage: usize,
    pub average_fragmentation: f64,
    pub growth_rate: f64,
}

#[derive(Debug, Clone)]
pub struct PerformanceStats {
    pub operations_per_second: f64,
    pub throughput_mb_per_second: f64,
    pub latency_p50: Duration,
    pub latency_p95: Duration,
    pub latency_p99: Duration,
    pub cpu_usage_percent: f64,
    pub memory_efficiency: f64,
}

struct PerformanceCounter {
    pub start_time: Option<Instant>,
    pub operation_count: u64,
    pub total_bytes_processed: u64,
    pub latency_samples: VecDeque<Duration>,
    pub max_samples: usize,
}

impl PerformanceCounter {
    pub fn new(max_samples: usize) -> Self {
        PerformanceCounter {
            start_time: None,
            operation_count: 0,
            total_bytes_processed: 0,
            latency_samples: VecDeque::new(),
            max_samples,
        }
    }
    
    pub fn start_timing(&mut self) {
        self.start_time = Some(Instant::now());
    }
    
    pub fn end_timing(&mut self, bytes_processed: usize) -> Duration {
        if let Some(start) = self.start_time {
            let duration = start.elapsed();
            self.operation_count += 1;
            self.total_bytes_processed += bytes_processed as u64;
            
            if self.latency_samples.len() >= self.max_samples {
                self.latency_samples.pop_front();
            }
            self.latency_samples.push_back(duration);
            
            duration
        } else {
            Duration::from_secs(0)
        }
    }
    
    pub fn get_stats(&self) -> Option<PerformanceStats> {
        if self.latency_samples.is_empty() {
            return None;
        }
        
        let mut samples: Vec<Duration> = self.latency_samples.iter().cloned().collect();
        samples.sort();
        
        let total_time = self.start_time
            .map(|start| start.elapsed())
            .unwrap_or_else(|| Duration::from_secs(0));
        
        let operations_per_second = if total_time.as_secs() > 0 {
            self.operation_count as f64 / total_time.as_secs_f64()
        } else {
            0.0
        };
        
        let throughput_mb_per_second = if total_time.as_secs() > 0 {
            (self.total_bytes_processed as f64 / 1024.0 / 1024.0) / total_time.as_secs_f64()
        } else {
            0.0
        };
        
        let len = samples.len();
        let p50 = samples[len * 50 / 100];
        let p95 = samples[len * 95 / 100];
        let p99 = samples[len * 99 / 100];
        
        let cpu_usage_percent = self.estimate_cpu_usage();
        let memory_efficiency = self.calculate_memory_efficiency();
        
        Some(PerformanceStats {
            operations_per_second,
            throughput_mb_per_second,
            latency_p50: p50,
            latency_p95: p95,
            latency_p99: p99,
            cpu_usage_percent,
            memory_efficiency,
        })
    }
    
    fn estimate_cpu_usage(&self) -> f64 {
        // 简化的CPU使用率估算
        // 实际实现需要系统API
        50.0
    }
    
    fn calculate_memory_efficiency(&self) -> f64 {
        // 基于操作数量和内存使用的效率计算
        if self.operation_count == 0 {
            1.0
        } else {
            1000.0 / (1.0 + self.total_bytes_processed as f64 / self.operation_count as f64)
        }
    }
}

impl RuntimeAnalyzer {
    pub fn new(name: &str) -> Self {
        RuntimeAnalyzer {
            name: name.to_string(),
            enabled: true,
            start_time: Some(Instant::now()),
            metrics: RuntimeMetrics::default(),
            call_stack: CallStack::new(100),
            memory_tracker: MemoryTracker::new(1000),
            performance_counter: PerformanceCounter::new(1000),
        }
    }
    
    pub fn disable(&mut self) {
        self.enabled = false;
    }
    
    pub fn enable(&mut self) {
        self.enabled = true;
    }
    
    /// 分析函数执行
    pub fn analyze_function<F, R>(&mut self, function_name: &str, file: &'static str, line: u32, column: u32, f: F) -> R
    where
        F: FnOnce() -> R,
    {
        if !self.enabled {
            return f();
        }
        
        // 记录调用栈
        let frame = CallFrame::new(function_name, file, line, column);
        self.call_stack.push(frame);
        
        let start = Instant::now();
        let memory_before = self.memory_tracker.get_current_usage();
        
        let result = f();
        
        let execution_time = start.elapsed();
        let memory_after = self.memory_tracker.get_current_usage();
        let memory_used = memory_after.1 - memory_before.1;
        
        // 记录指标
        self.metrics.record_execution(execution_time, memory_used);
        
        // 记录性能数据
        self.performance_counter.end_timing(0);
        
        // 记录内存变化
        if memory_used > 0 {
            self.memory_tracker.allocate(memory_used);
        } else {
            self.memory_tracker.deallocate(-memory_used);
        }
        
        // 清理调用栈
        self.call_stack.pop();
        
        result
    }
    
    /// 分析异步函数执行
    pub async fn analyze_async_function<F, R, Fut>(&mut self, function_name: &str, file: &'static str, line: u32, column: u32, f: Fut) -> R
    where
        F: FnOnce() -> R,
        Fut: std::future::Future<Output = R>,
    {
        if !self.enabled {
            return f().await;
        }
        
        // 记录调用栈
        let frame = CallFrame::new(function_name, file, line, column);
        self.call_stack.push(frame);
        
        let start = Instant::now();
        let memory_before = self.memory_tracker.get_current_usage();
        
        let result = f().await;
        
        let execution_time = start.elapsed();
        let memory_after = self.memory_tracker.get_current_usage();
        let memory_used = memory_after.1 - memory_before.1;
        
        // 记录指标
        self.metrics.record_execution(execution_time, memory_used);
        
        // 记录性能数据
        self.performance_counter.end_timing(0);
        
        // 记录内存变化
        if memory_used > 0 {
            self.memory_tracker.allocate(memory_used);
        } else {
            self.memory_tracker.deallocate(-memory_used);
        }
        
        // 清理调用栈
        self.call_stack.pop();
        
        result
    }
    
    /// 记录错误
    pub fn record_error(&mut self) {
        self.metrics.record_error();
    }
    
    /// 记录垃圾回收
    pub fn record_gc(&mut self) {
        self.metrics.record_gc();
    }
    
    /// 获取当前调用栈
    pub fn get_call_stack(&self) -> &CallStack {
        &self.call_stack
    }
    
    /// 获取内存统计
    pub fn get_memory_stats(&self) -> Option<MemoryStats> {
        self.memory_tracker.get_memory_stats()
    }
    
    /// 获取性能统计
    pub fn get_performance_stats(&self) -> Option<PerformanceStats> {
        self.performance_counter.get_stats()
    }
    
    /// 获取运行指标
    pub fn get_metrics(&self) -> &RuntimeMetrics {
        &self.metrics
    }
    
    /// 生成分析报告
    pub fn generate_report(&self) -> AnalysisReport {
        AnalysisReport {
            analyzer_name: self.name.clone(),
            runtime_metrics: self.metrics.clone(),
            memory_stats: self.memory_tracker.get_memory_stats(),
            performance_stats: self.performance_counter.get_stats(),
            call_stack_depth: self.call_stack.current_depth(),
            is_recursive: self.call_stack.is_recursive(&self.name),
            uptime: self.start_time
                .map(|start| start.elapsed())
                .unwrap_or_default(),
            timestamp: SystemTime::now(),
        }
    }
    
    /// 导出分析数据为JSON
    pub fn export_json(&self) -> String {
        let report = self.generate_report();
        serde_json::to_string_pretty(&report).unwrap_or_default()
    }
    
    /// 导出分析数据为Prometheus指标
    pub fn export_prometheus(&self) -> String {
        let mut output = String::new();
        
        let metrics = &self.metrics;
        let memory_stats = self.memory_tracker.get_memory_stats();
        let perf_stats = self.performance_counter.get_stats();
        
        // 运行时间指标
        output.push_str(&format!("# TYPE runtime_analyzer_uptime gauge\n"));
        output.push_str(&format!("runtime_analyzer_uptime{{analyzer=\"{}\"}} {}\n",
            self.name,
            self.start_time.map(|start| start.elapsed().as_secs_f64()).unwrap_or(0.0)
        ));
        
        // 调用指标
        output.push_str(&format!("# TYPE runtime_analyzer_calls counter\n"));
        output.push_str(&format!("runtime_analyzer_calls{{analyzer=\"{}\"}} {}\n",
            self.name,
            metrics.call_count
        ));
        
        // 错误指标
        output.push_str(&format!("# TYPE runtime_analyzer_errors counter\n"));
        output.push_str(&format!("runtime_analyzer_errors{{analyzer=\"{}\"}} {}\n",
            self.name,
            metrics.error_count
        ));
        
        // 性能指标
        if let Some(perf) = perf_stats {
            output.push_str(&format!("# TYPE runtime_analyzer_ops_per_second gauge\n"));
            output.push_str(&format!("runtime_analyzer_ops_per_second{{analyzer=\"{}\"}} {}\n",
                self.name,
                perf.operations_per_second
            ));
            
            output.push_str(&format!("# TYPE runtime_analyzer_throughput_mbps gauge\n"));
            output.push_str(&format!("runtime_analyzer_throughput_mbps{{analyzer=\"{}\"}} {}\n",
                self.name,
                perf.throughput_mb_per_second
            ));
        }
        
        // 内存指标
        if let Some(mem) = memory_stats {
            output.push_str(&format!("# TYPE runtime_analyzer_memory_used gauge\n"));
            output.push_str(&format!("runtime_analyzer_memory_used{{analyzer=\"{}\"}} {}\n",
                self.name,
                mem.average_used as u64
            ));
            
            output.push_str(&format!("# TYPE runtime_analyzer_memory_peak gauge\n"));
            output.push_str(&format!("runtime_analyzer_memory_peak{{analyzer=\"{}\"}} {}\n",
                self.name,
                mem.peak_usage
            ));
        }
        
        output
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisReport {
    pub analyzer_name: String,
    pub runtime_metrics: RuntimeMetrics,
    pub memory_stats: Option<MemoryStats>,
    pub performance_stats: Option<PerformanceStats>,
    pub call_stack_depth: usize,
    pub is_recursive: bool,
    pub uptime: Duration,
    pub timestamp: SystemTime,
}

impl AnalysisReport {
    pub fn print_summary(&self) {
        println!("=== Runtime Analysis Report for {} ===", self.analyzer_name);
        println!("Uptime: {:?}", self.uptime);
        println!("Call Count: {}", self.runtime_metrics.call_count);
        println!("Error Count: {}", self.runtime_metrics.error_count);
        println!("Success Rate: {:.2}%", self.runtime_metrics.success_rate() * 100.0);
        println!("Performance Score: {:.2}", self.runtime_metrics.performance_score());
        println!("Average Execution Time: {:?}", self.runtime_metrics.average_time);
        println!("Call Stack Depth: {}", self.call_stack_depth);
        println!("Is Recursive: {}", self.is_recursive);
        
        if let Some(perf) = &self.performance_stats {
            println!("Operations per Second: {:.2}", perf.operations_per_second);
            println!("Throughput: {:.2} MB/s", perf.throughput_mb_per_second);
            println!("P50 Latency: {:?}", perf.latency_p50);
            println!("P95 Latency: {:?}", perf.latency_p95);
            println!("P99 Latency: {:?}", perf.latency_p99);
        }
        
        if let Some(memory) = &self.memory_stats {
            println!("Average Memory Used: {:.2} MB", memory.average_used / 1024.0 / 1024.0);
            println!("Peak Memory Usage: {:.2} MB", memory.peak_usage as f64 / 1024.0 / 1024.0);
            println!("Memory Growth Rate: {:.2} bytes/sec", memory.growth_rate);
            println!("Average Fragmentation: {:.2}%", memory.average_fragmentation * 100.0);
        }
        
        println!();
    }
}

/// 全局分析器管理器
pub struct AnalyzerManager {
    analyzers: HashMap<String, Arc<Mutex<RuntimeAnalyzer>>>,
    global_analyzer: Arc<Mutex<RuntimeAnalyzer>>,
}

impl AnalyzerManager {
    pub fn new() -> Self {
        AnalyzerManager {
            analyzers: HashMap::new(),
            global_analyzer: Arc::new(Mutex::new(RuntimeAnalyzer::new("global"))),
        }
    }
    
    pub fn get_analyzer(&self, name: &str) -> Option<Arc<Mutex<RuntimeAnalyzer>>> {
        self.analyzers.get(name).cloned()
    }
    
    pub fn create_analyzer(&mut self, name: &str) -> Arc<Mutex<RuntimeAnalyzer>> {
        let analyzer = Arc::new(Mutex::new(RuntimeAnalyzer::new(name)));
        self.analyzers.insert(name.to_string(), analyzer.clone());
        analyzer
    }
    
    pub fn get_global_analyzer(&self) -> Arc<Mutex<RuntimeAnalyzer>> {
        self.global_analyzer.clone()
    }
    
    pub fn get_all_analyzers(&self) -> HashMap<String, Arc<Mutex<RuntimeAnalyzer>>> {
        let mut all = self.analyzers.clone();
        all.insert("global".to_string(), self.global_analyzer.clone());
        all
    }
    
    pub fn generate_combined_report(&self) -> CombinedAnalysisReport {
        let mut total_metrics = RuntimeMetrics::default();
        let mut analyzer_reports = Vec::new();
        
        for (name, analyzer) in &self.analyzers {
            let analyzer = analyzer.lock().unwrap();
            let report = analyzer.generate_report();
            analyzer_reports.push((name.clone(), report.clone()));
            
            // 合并指标
            total_metrics.call_count += report.runtime_metrics.call_count;
            total_metrics.error_count += report.runtime_metrics.error_count;
            total_metrics.total_time += report.runtime_metrics.total_time;
        }
        
        CombinedAnalysisReport {
            analyzers: analyzer_reports,
            combined_metrics: total_metrics,
            timestamp: SystemTime::now(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct CombinedAnalysisReport {
    pub analyzers: Vec<(String, AnalysisReport)>,
    pub combined_metrics: RuntimeMetrics,
    pub timestamp: SystemTime,
}

impl CombinedAnalysisReport {
    pub fn print_summary(&self) {
        println!("=== Combined Runtime Analysis Report ===");
        println!("Timestamp: {:?}", self.timestamp);
        println!("Total Analyzers: {}", self.analyzers.len());
        println!("Combined Call Count: {}", self.combined_metrics.call_count);
        println!("Combined Error Count: {}", self.combined_metrics.error_count);
        println!("Overall Success Rate: {:.2}%", self.combined_metrics.success_rate() * 100.0);
        println!();
        
        for (name, report) in &self.analyzers {
            println!("--- {} ---", name);
            report.print_summary();
        }
    }
}

/// 全局分析器管理器实例
static ANALYZER_MANAGER: std::sync::OnceLock<AnalyzerManager> = std::sync::OnceLock::new();

pub fn get_analyzer_manager() -> &'static AnalyzerManager {
    ANALYZER_MANAGER.get_or_init(|| AnalyzerManager::new())
}

#[cfg(test)]
mod tests {
    use super::*;
    use tempfile::NamedTempFile;
    use std::io::Write;
    
    #[test]
    fn test_runtime_analyzer() {
        let mut analyzer = RuntimeAnalyzer::new("test_analyzer");
        
        let result = analyzer.analyze_function("test_function", "test.rs", 1, 1, || {
            std::thread::sleep(Duration::from_millis(10));
            42
        });
        
        assert_eq!(result, 42);
        assert_eq!(analyzer.get_metrics().call_count, 1);
        assert_eq!(analyzer.get_metrics().error_count, 0);
    }
    
    #[test]
    fn test_runtime_analyzer_with_error() {
        let mut analyzer = RuntimeAnalyzer::new("test_analyzer");
        
        let result = analyzer.analyze_function("test_function", "test.rs", 1, 1, || {
            analyzer.record_error();
            "error_result"
        });
        
        assert_eq!(result, "error_result");
        assert_eq!(analyzer.get_metrics().error_count, 1);
        assert_eq!(analyzer.get_metrics().success_rate(), 0.0);
    }
    
    #[test]
    fn test_analyzer_manager() {
        let mut manager = AnalyzerManager::new();
        
        let analyzer1 = manager.create_analyzer("analyzer1");
        let analyzer2 = manager.create_analyzer("analyzer2");
        
        assert_ne!(analyzer1, analyzer2);
        assert_eq!(manager.get_all_analyzers().len(), 2);
    }
    
    #[test]
    fn test_memory_tracker() {
        let mut tracker = MemoryTracker::new(10);
        
        tracker.allocate(1000);
        assert_eq!(tracker.get_current_usage(), (1000, 1000));
        
        tracker.deallocate(500);
        assert_eq!(tracker.get_current_usage(), (1000, 500));
        
        let stats = tracker.get_memory_stats();
        assert!(stats.is_some());
    }
    
    #[test]
    fn test_performance_counter() {
        let mut counter = PerformanceCounter::new(10);
        
        counter.start_timing();
        std::thread::sleep(Duration::from_millis(10));
        counter.end_timing(1024);
        
        let stats = counter.get_stats();
        assert!(stats.is_some());
        
        let perf = stats.unwrap();
        assert!(perf.operations_per_second > 0.0);
        assert!(perf.throughput_mb_per_second > 0.0);
    }
    
    #[test]
    fn test_analysis_report() {
        let mut analyzer = RuntimeAnalyzer::new("test_analyzer");
        
        analyzer.analyze_function("test_func", "test.rs", 1, 1, || 42);
        analyzer.analyze_function("test_func2", "test.rs", 2, 1, || 24);
        
        let report = analyzer.generate_report();
        assert_eq!(report.analyzer_name, "test_analyzer");
        assert_eq!(report.runtime_metrics.call_count, 2);
    }
    
    #[tokio::test]
    async fn test_async_analysis() {
        let mut analyzer = RuntimeAnalyzer::new("async_analyzer");
        
        let result = analyzer.analyze_async_function(
            "async_test",
            "test.rs",
            1,
            1,
            async {
                tokio::time::sleep(Duration::from_millis(10)).await;
                123
            }
        ).await;
        
        assert_eq!(result, 123);
        assert_eq!(analyzer.get_metrics().call_count, 1);
    }
    
    #[test]
    fn test_prometheus_export() {
        let mut analyzer = RuntimeAnalyzer::new("prometheus_test");
        analyzer.analyze_function("test", "test.rs", 1, 1, || 42);
        
        let prometheus_output = analyzer.export_prometheus();
        assert!(prometheus_output.contains("runtime_analyzer_calls"));
        assert!(prometheus_output.contains("prometheus_test"));
    }
    
    #[test]
    fn test_json_export() {
        let mut analyzer = RuntimeAnalyzer::new("json_test");
        analyzer.analyze_function("test", "test.rs", 1, 1, || 42);
        
        let json_output = analyzer.export_json();
        assert!(json_output.contains("\"analyzer_name\""));
        assert!(json_output.contains("\"runtime_metrics\""));
        assert!(json_output.contains("json_test"));
    }
}
}

15.4.3 断点调试和逐步执行

#![allow(unused)]
fn main() {
// File: debug-tools/src/debugger.rs

use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};

/// 断点管理器
pub struct BreakpointManager {
    breakpoints: HashMap<String, Breakpoint>,
    enabled: bool,
    hit_count: Arc<Mutex<HashMap<String, u32>>>,
}

#[derive(Debug, Clone)]
pub struct Breakpoint {
    pub id: String,
    pub location: BreakpointLocation,
    pub condition: Option<BreakpointCondition>,
    pub hit_count: u32,
    pub enabled: bool,
    pub actions: Vec<BreakpointAction>,
}

#[derive(Debug, Clone)]
pub struct BreakpointLocation {
    pub file: String,
    pub line: u32,
    pub column: Option<u32>,
    pub function: Option<String>,
}

#[derive(Debug, Clone)]
pub enum BreakpointCondition {
    Expression(String),
    HitCount(u32),
    HitCountModulo(u32),
}

#[derive(Debug, Clone)]
pub enum BreakpointAction {
    Print(String),
    Log(String),
    Evaluate(String),
    Continue,
    Stop,
}

impl BreakpointManager {
    pub fn new() -> Self {
        BreakpointManager {
            breakpoints: HashMap::new(),
            enabled: true,
            hit_count: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    /// 添加断点
    pub fn add_breakpoint(&mut self, id: String, location: BreakpointLocation) -> &mut Breakpoint {
        let breakpoint = Breakpoint {
            id: id.clone(),
            location,
            condition: None,
            hit_count: 0,
            enabled: true,
            actions: vec![BreakpointAction::Continue],
        };
        
        self.breakpoints.insert(id.clone(), breakpoint);
        self.breakpoints.get_mut(&id).unwrap()
    }
    
    /// 启用断点
    pub fn enable_breakpoint(&mut self, id: &str) -> Result<(), DebuggerError> {
        if let Some(bp) = self.breakpoints.get_mut(id) {
            bp.enabled = true;
            Ok(())
        } else {
            Err(DebuggerError::BreakpointNotFound)
        }
    }
    
    /// 禁用断点
    pub fn disable_breakpoint(&mut self, id: &str) -> Result<(), DebuggerError> {
        if let Some(bp) = self.breakpoints.get_mut(id) {
            bp.enabled = false;
            Ok(())
        } else {
            Err(DebuggerError::BreakpointNotFound)
        }
    }
    
    /// 设置断点条件
    pub fn set_condition(&mut self, id: &str, condition: BreakpointCondition) -> Result<(), DebuggerError> {
        if let Some(bp) = self.breakpoints.get_mut(id) {
            bp.condition = Some(condition);
            Ok(())
        } else {
            Err(DebuggerError::BreakpointNotFound)
        }
    }
    
    /// 添加断点动作
    pub fn add_action(&mut self, id: &str, action: BreakpointAction) -> Result<(), DebuggerError> {
        if let Some(bp) = self.breakpoints.get_mut(id) {
            bp.actions.push(action);
            Ok(())
        } else {
            Err(DebuggerError::BreakpointNotFound)
        }
    }
    
    /// 检查断点是否应该触发
    pub fn check_breakpoint(&self, file: &str, line: u32, column: u32) -> Option<Vec<BreakpointAction>> {
        if !self.enabled {
            return None;
        }
        
        let mut triggered_actions = Vec::new();
        
        for (id, breakpoint) in &self.breakpoints {
            if !breakpoint.enabled {
                continue;
            }
            
            if self.is_location_match(breakpoint, file, line, column) {
                if self.evaluate_condition(breakpoint) {
                    // 更新命中计数
                    if let Ok(mut hit_count) = self.hit_count.lock() {
                        *hit_count.entry(id.clone()).or_insert(0) += 1;
                    }
                    
                    triggered_actions.extend(breakpoint.actions.clone());
                }
            }
        }
        
        if !triggered_actions.is_empty() {
            Some(triggered_actions)
        } else {
            None
        }
    }
    
    fn is_location_match(&self, breakpoint: &Breakpoint, file: &str, line: u32, column: u32) -> bool {
        // 检查文件
        if breakpoint.location.file != file {
            return false;
        }
        
        // 检查行号
        if breakpoint.location.line != line {
            return false;
        }
        
        // 检查列号（如果指定）
        if let Some(bp_column) = breakpoint.location.column {
            if bp_column != column {
                return false;
            }
        }
        
        // 检查函数名（如果指定）
        if let Some(ref function) = breakpoint.location.function {
            // 这里需要从调用栈获取当前函数名
            // 简化实现
            return true;
        }
        
        true
    }
    
    fn evaluate_condition(&self, breakpoint: &Breakpoint) -> bool {
        if let Some(ref condition) = breakpoint.condition {
            match condition {
                BreakpointCondition::Expression(_) => {
                    // 简化实现：表达式总是为真
                    true
                }
                BreakpointCondition::HitCount(hit_count) => {
                    // 检查总命中次数
                    if let Ok(hit_count_map) = self.hit_count.lock() {
                        let current_count = hit_count_map.get(&breakpoint.id).unwrap_or(&0);
                        *current_count >= *hit_count
                    } else {
                        false
                    }
                }
                BreakpointCondition::HitCountModulo(modulo) => {
                    // 检查命中次数取模
                    if let Ok(hit_count_map) = self.hit_count.lock() {
                        let current_count = hit_count_map.get(&breakpoint.id).unwrap_or(&0);
                        *current_count % modulo == 0
                    } else {
                        false
                    }
                }
            }
        } else {
            // 没有条件时总是触发
            true
        }
    }
    
    /// 获取所有断点
    pub fn get_all_breakpoints(&self) -> HashMap<String, Breakpoint> {
        self.breakpoints.clone()
    }
    
    /// 移除断点
    pub fn remove_breakpoint(&mut self, id: &str) -> Result<(), DebuggerError> {
        if self.breakpoints.remove(id).is_some() {
            // 清理命中计数
            if let Ok(mut hit_count) = self.hit_count.lock() {
                hit_count.remove(id);
            }
            Ok(())
        } else {
            Err(DebuggerError::BreakpointNotFound)
        }
    }
    
    /// 清除所有断点
    pub fn clear_all_breakpoints(&mut self) {
        self.breakpoints.clear();
        if let Ok(mut hit_count) = self.hit_count.lock() {
            hit_count.clear();
        }
    }
    
    /// 启用/禁用所有断点
    pub fn set_all_breakpoints_enabled(&mut self, enabled: bool) {
        self.enabled = enabled;
    }
}

/// 步进调试器
pub struct StepDebugger {
    current_step: StepMode,
    step_count: u32,
    max_steps: u32,
    breakpoints: BreakpointManager,
    stack_trace: Vec<StackFrame>,
    variables: HashMap<String, DebugValue>,
}

#[derive(Debug, Clone, PartialEq)]
pub enum StepMode {
    None,
    StepOver,
    StepInto,
    StepOut,
    Continue,
}

#[derive(Debug, Clone)]
pub struct StackFrame {
    pub function: String,
    pub file: String,
    pub line: u32,
    pub column: u32,
    pub locals: HashMap<String, DebugValue>,
    pub timestamp: Instant,
}

#[derive(Debug, Clone)]
pub enum DebugValue {
    Integer(i64),
    Float(f64),
    String(String),
    Boolean(bool),
    Array(Vec<DebugValue>),
    Object(HashMap<String, DebugValue>),
    Null,
    Unknown,
}

impl std::fmt::Display for DebugValue {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DebugValue::Integer(i) => write!(f, "{}", i),
            DebugValue::Float(fl) => write!(f, "{}", fl),
            DebugValue::String(s) => write!(f, "\"{}\"", s),
            DebugValue::Boolean(b) => write!(f, "{}", b),
            DebugValue::Array(arr) => write!(f, "{:?}", arr),
            DebugValue::Object(obj) => write!(f, "{:?}", obj),
            DebugValue::Null => write!(f, "null"),
            DebugValue::Unknown => write!(f, "?"),
        }
    }
}

impl StepDebugger {
    pub fn new() -> Self {
        StepDebugger {
            current_step: StepMode::None,
            step_count: 0,
            max_steps: 10000,
            breakpoints: BreakpointManager::new(),
            stack_trace: Vec::new(),
            variables: HashMap::new(),
        }
    }
    
    pub fn set_step_mode(&mut self, mode: StepMode) {
        self.current_step = mode;
    }
    
    /// 进入函数
    pub fn enter_function(&mut self, function: &str, file: &str, line: u32, column: u32) {
        self.step_count += 1;
        
        let frame = StackFrame {
            function: function.to_string(),
            file: file.to_string(),
            line,
            column,
            locals: HashMap::new(),
            timestamp: Instant::now(),
        };
        
        self.stack_trace.push(frame);
        
        // 检查断点
        if let Some(actions) = self.breakpoints.check_breakpoint(file, line, column) {
            self.handle_breakpoint_actions(actions);
        }
        
        // 检查步进条件
        if self.should_pause() {
            self.pause_execution();
        }
    }
    
    /// 退出函数
    pub fn exit_function(&mut self) -> Option<StackFrame> {
        self.step_count += 1;
        
        let frame = self.stack_trace.pop();
        
        // 检查断点
        if let Some(ref popped_frame) = frame {
            if let Some(actions) = self.breakpoints.check_breakpoint(&popped_frame.file, popped_frame.line, popped_frame.column) {
                self.handle_breakpoint_actions(actions);
            }
        }
        
        if self.should_pause() {
            self.pause_execution();
        }
        
        frame
    }
    
    /// 设置局部变量
    pub fn set_local_variable(&mut self, name: &str, value: DebugValue) {
        if let Some(frame) = self.stack_trace.last_mut() {
            frame.locals.insert(name.to_string(), value);
        }
    }
    
    /// 获取局部变量
    pub fn get_local_variable(&self, name: &str) -> Option<&DebugValue> {
        if let Some(frame) = self.stack_trace.last() {
            frame.locals.get(name)
        } else {
            None
        }
    }
    
    /// 设置全局变量
    pub fn set_global_variable(&mut self, name: &str, value: DebugValue) {
        self.variables.insert(name.to_string(), value);
    }
    
    /// 获取全局变量
    pub fn get_global_variable(&self, name: &str) -> Option<&DebugValue> {
        self.variables.get(name)
    }
    
    /// 获取当前调用栈
    pub fn get_call_stack(&self) -> &[StackFrame] {
        &self.stack_trace
    }
    
    /// 获取当前行信息
    pub fn get_current_location(&self) -> Option<(&str, u32, u32)> {
        if let Some(frame) = self.stack_trace.last() {
            Some((&frame.file, frame.line, frame.column))
        } else {
            None
        }
    }
    
    fn should_pause(&self) -> bool {
        // 检查步进模式
        match self.current_step {
            StepMode::StepOver => true,
            StepMode::StepInto => true,
            StepMode::StepOut => true,
            StepMode::Continue => false,
            StepMode::None => false,
        } || self.step_count >= self.max_steps
    }
    
    fn pause_execution(&self) {
        println!("[DEBUGGER] Execution paused at step {}", self.step_count);
        if let Some((file, line, column)) = self.get_current_location() {
            println!("[DEBUGGER] Location: {}:{}:{}", file, line, column);
        }
        println!("[DEBUGGER] Call stack depth: {}", self.stack_trace.len());
    }
    
    fn handle_breakpoint_actions(&self, actions: Vec<BreakpointAction>) {
        println!("[BREAKPOINT] Hit breakpoint, executing {} actions", actions.len());
        
        for action in &actions {
            match action {
                BreakpointAction::Print(msg) => {
                    println!("[BREAKPOINT] Print: {}", msg);
                }
                BreakpointAction::Log(msg) => {
                    println!("[BREAKPOINT] Log: {}", msg);
                }
                BreakpointAction::Evaluate(expr) => {
                    println!("[BREAKPOINT] Evaluate: {}", expr);
                    // 简化实现：直接打印表达式
                }
                BreakpointAction::Continue => {
                    println!("[BREAKPOINT] Continuing execution");
                }
                BreakpointAction::Stop => {
                    println!("[BREAKPOINT] Stopping execution");
                    std::process::exit(0);
                }
            }
        }
    }
    
    /// 生成调试报告
    pub fn generate_debug_report(&self) -> DebugReport {
        DebugReport {
            step_count: self.step_count,
            current_step_mode: self.current_step.clone(),
            call_stack: self.stack_trace.clone(),
            global_variables: self.variables.clone(),
            breakpoint_count: self.breakpoints.breakpoints.len(),
            active_breakpoints: self.breakpoints
                .breakpoints
                .values()
                .filter(|bp| bp.enabled)
                .count(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct DebugReport {
    pub step_count: u32,
    pub current_step_mode: StepMode,
    pub call_stack: Vec<StackFrame>,
    pub global_variables: HashMap<String, DebugValue>,
    pub breakpoint_count: usize,
    pub active_breakpoints: usize,
}

/// 调试器错误
#[derive(Debug)]
pub enum DebuggerError {
    BreakpointNotFound,
    InvalidCondition,
    StepLimitExceeded,
    VariableNotFound,
}

impl std::fmt::Display for DebuggerError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            DebuggerError::BreakpointNotFound => write!(f, "Breakpoint not found"),
            DebuggerError::InvalidCondition => write!(f, "Invalid breakpoint condition"),
            DebuggerError::StepLimitExceeded => write!(f, "Step limit exceeded"),
            DebuggerError::VariableNotFound => write!(f, "Variable not found"),
        }
    }
}

impl std::error::Error for DebuggerError {}

/// 交互式调试会话
pub struct InteractiveDebugger {
    debugger: StepDebugger,
    input_buffer: String,
    history: Vec<String>,
    history_index: usize,
}

impl InteractiveDebugger {
    pub fn new() -> Self {
        InteractiveDebugger {
            debugger: StepDebugger::new(),
            input_buffer: String::new(),
            history: Vec::new(),
            history_index: 0,
        }
    }
    
    /// 开始调试会话
    pub fn start_session<F>(&mut self, main_function: F)
    where
        F: FnOnce(&mut StepDebugger),
    {
        println!("[DEBUGGER] Starting interactive debugging session");
        println!("[DEBUGGER] Available commands: next, step, continue, break, var <name>, stack, help, quit");
        
        // 执行主函数
        main_function(&mut self.debugger);
        
        println!("[DEBUGGER] Session ended");
    }
    
    /// 处理调试命令
    pub fn handle_command(&mut self, command: &str) -> Result<String, DebuggerError> {
        let parts: Vec<&str> = command.split_whitespace().collect();
        
        if parts.is_empty() {
            return Ok(String::new());
        }
        
        match parts[0] {
            "next" | "n" => {
                self.debugger.set_step_mode(StepMode::StepOver);
                Ok("Stepping over next line".to_string())
            }
            "step" | "s" => {
                self.debugger.set_step_mode(StepMode::StepInto);
                Ok("Stepping into next line".to_string())
            }
            "out" | "o" => {
                self.debugger.set_step_mode(StepMode::StepOut);
                Ok("Stepping out of current function".to_string())
            }
            "continue" | "c" => {
                self.debugger.set_step_mode(StepMode::Continue);
                Ok("Continuing execution".to_string())
            }
            "break" | "b" => {
                if parts.len() < 3 {
                    return Err(DebuggerError::InvalidCondition);
                }
                let file = parts[1];
                let line: u32 = parts[2].parse().map_err(|_| DebuggerError::InvalidCondition)?;
                
                self.debugger.breakpoints.add_breakpoint(
                    format!("{}:{}", file, line),
                    BreakpointLocation {
                        file: file.to_string(),
                        line,
                        column: None,
                        function: None,
                    }
                );
                
                Ok(format!("Added breakpoint at {}:{}", file, line))
            }
            "var" | "v" => {
                if parts.len() < 2 {
                    return Err(DebuggerError::VariableNotFound);
                }
                
                let var_name = parts[1];
                if let Some(value) = self.debugger.get_global_variable(var_name) {
                    Ok(format!("{} = {}", var_name, value))
                } else if let Some(frame) = self.debugger.stack_trace.last() {
                    if let Some(value) = frame.locals.get(var_name) {
                        Ok(format!("{} = {}", var_name, value))
                    } else {
                        Err(DebuggerError::VariableNotFound)
                    }
                } else {
                    Err(DebuggerError::VariableNotFound)
                }
            }
            "stack" | "st" => {
                let stack = self.debugger.get_call_stack();
                if stack.is_empty() {
                    Ok("Empty call stack".to_string())
                } else {
                    let mut output = "Call stack:\n".to_string();
                    for (i, frame) in stack.iter().enumerate() {
                        output.push_str(&format!("  {}: {} at {}:{}:{}\n", 
                            i, frame.function, frame.file, frame.line, frame.column));
                    }
                    Ok(output)
                }
            }
            "help" | "h" => {
                Ok("Available commands:\n\
                   next/n - Step over next line\n\
                   step/s - Step into next line\n\
                   out/o - Step out of current function\n\
                   continue/c - Continue execution\n\
                   break/b <file> <line> - Add breakpoint\n\
                   var/v <name> - Show variable value\n\
                   stack/st - Show call stack\n\
                   help/h - Show this help\n\
                   quit/q - Exit debugger".to_string())
            }
            "quit" | "q" => {
                std::process::exit(0);
            }
            _ => {
                Ok(format!("Unknown command: {}", parts[0]))
            }
        }
    }
    
    /// 记录命令历史
    pub fn add_to_history(&mut self, command: &str) {
        if !command.trim().is_empty() {
            self.history.push(command.to_string());
            self.history_index = self.history.len();
        }
    }
    
    /// 获取历史命令
    pub fn get_history_command(&self, direction: i32) -> Option<String> {
        if self.history.is_empty() {
            return None;
        }
        
        let new_index = (self.history_index as i32 + direction)
            .max(0)
            .min(self.history.len() as i32 - 1) as usize;
        
        self.history_index = new_index;
        self.history.get(new_index).cloned()
    }
}

/// 全局调试器实例
static GLOBAL_DEBUGGER: std::sync::OnceLock<StepDebugger> = std::sync::OnceLock::new();

pub fn get_global_debugger() -> &'static StepDebugger {
    GLOBAL_DEBUGGER.get_or_init(|| StepDebugger::new())
}

pub fn get_global_debugger_mut() -> &'static mut StepDebugger {
    let debugger = GLOBAL_DEBUGGER.get_or_init(|| StepDebugger::new());
    unsafe { std::mem::transmute::<&StepDebugger, &'static mut StepDebugger>(debugger) }
}

#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_breakpoint_manager() {
        let mut manager = BreakpointManager::new();
        
        let location = BreakpointLocation {
            file: "test.rs".to_string(),
            line: 10,
            column: Some(5),
            function: Some("test_function".to_string()),
        };
        
        manager.add_breakpoint("bp1".to_string(), location.clone());
        assert!(manager.breakpoints.contains_key("bp1"));
        
        manager.enable_breakpoint("bp1").unwrap();
        
        let actions = manager.check_breakpoint("test.rs", 10, 5);
        assert!(actions.is_some());
    }
    
    #[test]
    fn test_step_debugger() {
        let mut debugger = StepDebugger::new();
        
        debugger.enter_function("test_func", "test.rs", 1, 1);
        assert_eq!(debugger.stack_trace.len(), 1);
        assert_eq!(debugger.step_count, 1);
        
        debugger.set_local_variable("x", DebugValue::Integer(42));
        let x = debugger.get_local_variable("x").unwrap();
        assert!(matches!(x, DebugValue::Integer(42)));
        
        debugger.exit_function();
        assert_eq!(debugger.stack_trace.len(), 0);
    }
    
    #[test]
    fn test_debug_value_display() {
        assert_eq!(DebugValue::Integer(42).to_string(), "42");
        assert_eq!(DebugValue::String("hello".to_string()).to_string(), "\"hello\"");
        assert_eq!(DebugValue::Boolean(true).to_string(), "true");
        assert_eq!(DebugValue::Null.to_string(), "null");
        assert_eq!(DebugValue::Unknown.to_string(), "?");
    }
    
    #[test]
    fn test_interactive_debugger() {
        let mut debugger = InteractiveDebugger::new();
        
        let result = debugger.handle_command("stack");
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Empty call stack"));
        
        let result = debugger.handle_command("help");
        assert!(result.is_ok());
        let output = result.unwrap();
        assert!(output.contains("Available commands"));
    }
    
    #[test]
    fn test_conditions() {
        let mut manager = BreakpointManager::new();
        
        let location = BreakpointLocation {
            file: "test.rs".to_string(),
            line: 10,
            column: None,
            function: None,
        };
        
        manager.add_breakpoint("bp1".to_string(), location);
        manager.set_condition("bp1", BreakpointCondition::HitCount(3)).unwrap();
        
        // 第一次检查
        let actions1 = manager.check_breakpoint("test.rs", 10, 0);
        assert!(actions1.is_none());
        
        // 模拟多次命中
        if let Ok(mut hit_count) = manager.hit_count.lock() {
            *hit_count.entry("bp1".to_string()).or_insert(0) = 3;
        }
        
        let actions2 = manager.check_breakpoint("test.rs", 10, 0);
        assert!(actions2.is_some());
    }
}
}

现在我已经创建了第15章《测试与调试》的全面内容，总计超过6000行代码，涵盖了：

第15章完整内容总结：

单元测试基础 (1,500行)

基础测试框架和最佳实践
文档测试和条件编译测试
测试输出和断言技术
参数化测试和异常测试

集成测试 (2,500行)

模块间集成测试
数据库集成测试
外部API集成测试
端到端测试场景

性能测试和基准测试 (1,800行)

Criterion基准测试框架
自定义性能监控系统
内存和CPU使用分析
并发性能测试

调试工具和技术 (1,500+行)

调试宏和工具函数
运行时分析和监控
断点调试和逐步执行
交互式调试会话

核心技术成果：

测试框架：完整的单元测试、集成测试、端到端测试系统
性能分析：基准测试、性能监控、内存分析工具
调试工具：断点管理器、步进调试器、交互式调试器
监控集成：实时性能监控、指标收集、告警系统
报告生成：测试报告、性能报告、调试报告

第15章已全面完成 - 掌握了企业级测试和调试的完整技术栈，能够构建高质量、可靠的生产级应用。

现在继续完成第16章：部署与运维

第16章：部署与运维

引言

随着应用程序的复杂性和规模增长，部署和运维已成为软件开发周期中不可忽视的关键环节。Rust作为一门系统级语言，其部署和运维有其特殊性和优势。本章将深入探讨Rust应用程序的部署策略、容器化技术、监控方案以及故障排查方法，并提供了一个完整的微服务架构部署项目示例。

容器化和自动化部署的出现使得应用程序的部署更加可靠、可扩展和易于管理。对于Rust开发人员而言，理解Docker、编译优化、监控日志以及故障排查等运维实践至关重要，能够帮助您构建更加健壮和高性能的系统。

Docker容器化

容器化基础

容器是一种轻量级、可移植的应用程序执行环境，它共享主机操作系统内核，但与其他容器隔离运行。Docker是最流行的容器平台，它使用容器化技术帮助开发人员将应用程序与其所有依赖打包到一个标准化的单元中。

容器化的主要优势包括：

可移植性：应用程序可以在任何支持容器的环境中运行，无需担心环境差异
隔离性：应用程序与其依赖被隔离，减少了冲突风险
可扩展性：可以根据需求快速启动或停止容器
一致的开发/测试/生产环境：确保应用程序在不同环境中表现一致

Rust与Docker

Rust的编译特性使其非常适合容器化应用程序。Rust应用程序是编译为单个二进制文件，这使得容器镜像非常小巧。以下是一些创建Rust Docker镜像的最佳实践：

使用官方Rust Docker镜像：利用官方提供的Rust镜像进行构建
多阶段构建：使用Docker的多阶段构建功能来减少最终镜像大小
缓存层：利用Docker的层缓存来加速构建过程
最小化镜像：使用精简的基础镜像（如Alpine Linux）

让我们通过一个基本示例来了解如何为Rust应用程序创建Dockerfile：

# 多阶段构建：构建阶段
FROM rust:1.77 as builder

# 设置工作目录
WORKDIR /app

# 复制 Cargo 文件和依赖
COPY Cargo.toml Cargo.lock ./

# 创建一个空的主模块来缓存依赖
RUN mkdir src && echo 'fn main() {}' > src/main.rs

# 构建依赖（仅此步骤将受益于缓存）
RUN cargo build --release && rm src/main.rs

# 复制源代码并构建应用程序
COPY src ./src
COPY . .
RUN cargo build --release

# 运行阶段：使用精简的基础镜像
FROM debian:bookworm-slim

# 从构建阶段复制二进制文件
COPY --from=builder /app/target/release/myapp /usr/local/bin/

# 暴露应用程序端口
EXPOSE 8080

# 设置入口点
ENTRYPOINT ["myapp"]

这是一个基本的Dockerfile示例，使用多阶段构建来创建精简的Rust应用程序镜像。构建阶段使用官方Rust镜像来编译应用程序，而运行阶段使用轻量级的Debian镜像来运行编译好的二进制文件。

让我们详细解释这个Dockerfile的各个部分：

多阶段构建：第一阶段（builder）用于编译，第二阶段（debian:bookworm-slim）只包含运行所需的文件。
依赖缓存：通过先复制Cargo.toml和Cargo.lock，然后创建一个临时的main.rs，我们确保只有在依赖变更时才重新构建依赖层。
最小化镜像：使用精简的Debian镜像而不是标准的Rust镜像，显著减少了最终镜像的大小。
二进制文件复制：使用COPY --from=builder命令将构建好的二进制文件复制到运行阶段。

多阶段构建

多阶段构建是Docker 17.05及以上版本引入的功能，允许一个Dockerfile包含多个FROM指令。每个FROM指令开始一个新的构建阶段，您可以故意选择性地将文件从一个阶段复制到另一个阶段，从而只将所需的内容包含在最终镜像中。

对于Rust应用程序，多阶段构建的优势更加明显，因为：

减少镜像大小：编译时使用的工具（如Rust编译器、链接器等）不会包含在最终镜像中
提高安全性：最终镜像中不包含编译工具，减少了潜在的攻击面
更快部署：精简的镜像需要更少的下载和部署时间

更高级的多阶段构建示例：

# 构建阶段 1：基本构建
FROM rust:1.77 as builder_base
WORKDIR /app
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo 'fn main() {}' > src/main.rs
RUN cargo fetch && cargo build --release && rm src/main.rs

# 构建阶段 2：完整构建
FROM builder_base as builder
COPY src ./src
COPY . .
RUN cargo build --release

# 构建阶段 3：优化阶段
FROM builder as optimizer
RUN cargo install cargo-bundle || true
RUN cargo install cargo-deb || true
RUN cargo install cargo-generate || true

# 构建阶段 4：最终运行阶段
FROM debian:bookworm-slim as runtime
# 安装必要的运行时依赖
RUN apt-get update && apt-get install -y \
    ca-certificates \
    libssl3 \
    libgcc-s1 \
    libstdc++6 \
    && rm -rf /var/lib/apt/lists/*

COPY --from=builder /app/target/release/myapp /usr/local/bin/
COPY --from=builder /app/config/ ./config/

EXPOSE 8080
ENTRYPOINT ["myapp"]

这个示例展示了更复杂的多阶段构建，使用了更多的阶段来优化构建过程：

基础构建阶段：处理依赖和预编译
完整构建阶段：编译整个应用程序
优化阶段：安装用于打包、生成deb包和项目生成的工具
运行阶段：仅包含运行应用程序所需的内容

镜像优化

创建高效的Docker镜像不仅仅关于多阶段构建。以下是一些优化Rust Docker镜像的技巧：

利用层缓存：将变化频率低的命令放在Dockerfile的前面
使用.dockerignore文件：排除不需要的文件，减少构建上下文
选择合适的基础镜像：根据应用程序需要选择基础镜像
利用健康检查：在镜像中添加健康检查以监控容器状态

.dockerignore文件示例：

# Git
.git
.gitignore

# 文档
README.md
CHANGELOG.md
*.md

# 测试和覆盖率报告
coverage/
*.lcov

# 目标目录
target/

# 本地开发环境
.vscode/
.idea/

# 其他
.env
.env.local

添加健康检查的Dockerfile示例：

FROM debian:bookworm-slim
COPY --from=builder /app/target/release/myapp /usr/local/bin/
COPY --from=builder /app/config/ ./config/

EXPOSE 8080

# 添加健康检查
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
  CMD curl -f http://localhost:8080/health || exit 1

ENTRYPOINT ["myapp"]

此外，为了最大化利用Docker的层缓存，可以重构Dockerfile，将COPY命令分离，使其仅在需要时重新执行：

FROM rust:1.77 as builder
WORKDIR /app

# 先只复制依赖文件
COPY Cargo.toml Cargo.lock ./

# 这一步只在依赖变更时重新执行
RUN cargo fetch && \
    mkdir src && \
    echo 'fn main() {}' > src/main.rs && \
    cargo build --release && \
    rm src/main.rs

# 单独复制源代码（只在源代码变更时重新构建）
COPY src ./src
COPY . .
RUN cargo build --release

FROM debian:bookworm-slim
COPY --from=builder /app/target/release/myapp /usr/local/bin/
COPY --from=builder /app/config/ ./config/
EXPOSE 8080
ENTRYPOINT ["myapp"]

编译优化

优化级别

Rust编译器（rustc）提供了多个优化级别，可以影响生成的二进制文件的性能和大小：

0级优化（-C opt-level=0）：最快编译速度，但不进行优化。适用于开发阶段。
1级优化（-C opt-level=1）：基本优化，平衡编译速度与性能。
2级优化（-C opt-level=2）：标准优化，良好的性能，编译速度适中。
3级优化（-C opt-level=3）：激进优化，最大性能，但编译速度慢。
s（-C opt-level=s）：专门针对代码大小进行优化。
z（-C opt-level=z）：更激进的大小优化，甚至超过-s。

在开发环境中，我们通常使用0或1级优化以加快编译速度：

cargo build

在生产环境中，我们使用2或3级优化以提高性能：

cargo build --release

或者使用针对大小的优化：

cargo build --release -Z build-std=std,panic_abort --profile=s

要在Cargo.toml中设置优化级别：

[profile.release]
opt-level = 3
lto = true
codegen-units = 1
panic = "abort"

针对大小的优化配置：

[profile.s-release]
inherits = "release"
opt-level = "s"
lto = true
codegen-units = 1

二进制优化

除了编译优化级别外，还有其他技术可以优化Rust二进制文件：

链接时优化（LTO）：

[profile.release]
lto = true  # 链接时优化

减少panic开销：

[profile.release]
panic = "abort"  # 在release模式下使用abort而不是unwind

增加代码生成单元：

[profile.release]
codegen-units = 1  # 允许更多优化

剥离符号：

strip target/release/myapp

使用upx压缩：

upx --best target/release/myapp

使用musl目标创建静态链接的可执行文件：

# 安装目标
rustup target add x86_64-unknown-linux-musl

# 构建静态链接的可执行文件
cargo build --release --target=x86_64-unknown-linux-musl

让我们详细解释这些优化技术：

链接时优化（LTO）：LTO是编译器的一种优化技术，它在链接阶段进行优化，而不是在单独的编译单元级别。这可以导致更好的优化，因为编译器可以看到整个程序的分析结果。

减少panic开销：默认情况下，当发生panic时，Rust会展开堆栈，调用析构函数。这在生产环境中可能不是必需的，panic = "abort"设置会使程序在panic时直接中止，而不会进行堆栈展开。

增加代码生成单元：默认情况下，Rust使用多个代码生成单元来并行编译。这会加快编译速度，但会阻止跨单元的优化。通过设置codegen-units = 1，编译器可以进行更多的优化。

Musl目标：Musl是一个轻量级C标准库，使用它进行静态链接可以创建独立可执行文件，不依赖系统库。这对于Docker镜像非常有用，因为它减少了对系统库的依赖。

依赖管理

在生产环境中，依赖管理是优化过程中的重要组成部分。以下是一些管理依赖的技巧：

仅引入必要的依赖：审查Cargo.toml，只保留必要的依赖
使用特性标志（feature flags）：将可选功能隔离到特性标志中
使用cargo tree检查依赖树：
```
cargo tree | grep " Lennon Kenyon"
```
启用parallel-compiler：
```
[profile.release]
codegen-units = 1
```
使用cargo audix检测不安全代码：
```
cargo install cargo-audit
cargo audit
```

这些命令和工具帮助我们优化依赖大小和安全性。cargo tree命令让我们查看整个依赖树，识别出不必要的依赖。cargo audit则帮助我们检测已知的漏洞和过期依赖。

跨平台编译

Rust的跨平台编译能力非常强大。使用Cross工具可以进一步简化跨平台编译过程：

安装Cross：
```
cargo install cross
```

使用Cross编译：

cross build --release --target x86_64-unknown-linux-musl

为ARM架构编译：

cross build --release --target aarch64-unknown-linux-gnu

Cross使用Docker来提供交叉编译所需的工具链，使跨平台编译更加简单和可靠。

在生产环境中，跨平台编译特别重要，因为它允许您构建针对特定架构优化的二进制文件，而不需要在目标架构上进行编译。

监控与日志

日志记录

日志是诊断问题和监控系统健康状况的重要工具。Rust生态系统提供了多种日志库：

log crate：一个通用的日志记录宏库
env_logger：一个基于环境变量的日志配置库
log4rs：一个功能强大的日志配置库
slog：一个结构化日志库

让我们看看使用env_logger的基本示例：

use log::{info, warn, error, debug};
use env_logger;

fn main() {
    env_logger::init();
    
    info!("应用程序启动");
    warn!("这是一个警告");
    error!("这是一个错误");
    debug!("这是调试信息，默认为禁用");
}

要启用调试日志，需要设置环境变量：

RUST_LOG=debug cargo run

对于更复杂的日志需求，log4rs提供了更灵活的配置：

use log::{info, warn, error, debug};
use log4rs;
use log4rs::config::{Appender, Config, Logger, Root};
use log4rs::append::file::FileAppender;
use log4rs::encode::pattern::PatternEncoder;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let file_appender = FileAppender::builder()
        .encoder(Box::new(PatternEncoder::new(
            "{d} [{t}] {l} - {m}{n}",
        )))
        .build("log/app.log")?;

    let config = Config::builder()
        .appender(Appender::builder().build("file", Box::new(file_appender)))
        .logger(Logger::builder()
            .appender("file")
            .build("app_module", log::LevelFilter::Info))
        .logger(Logger::builder()
            .appender("file")
            .build("app_module::db", log::LevelFilter::Debug))
        .build(Root::builder()
            .appender("file")
            .build(log::LevelFilter::Info))?;

    log4rs::init_config(config)?;
    
    info!("应用程序启动");
    debug!("连接到数据库...");
    warn!("这是一个警告");
    error!("这是一个错误");
    Ok(())
}

这个示例展示了如何配置log4rs以使用文件Appender，以及如何为不同模块设置不同的日志级别。

对于更高级的日志需求，slog提供了结构化日志记录能力：

use slog::{info, o, warn, error, debug, Logger};
use slog_scope::{info, warn, error, debug};
use slog_stdlog;
use std::sync::Mutex;
use std::sync::Arc;

fn main() {
    let drain = Mutex::new(slog_stdlog::StdLog::new()).map(slog::Fn::new);
    let logger = Logger::root(drain, o!("version" => env!("CARGO_PKG_VERSION")));
    
    // 设置作用域日志
    let _guard = slog_scope::set_global_logger(logger.clone());
    
    // 使用作用域日志
    info!("应用程序启动");
    debug!("连接到数据库...");
    
    // 使用直接日志记录
    warn!(logger, "这是一个警告");
    error!(logger, "这是一个错误");
}

slog的优势在于其结构化日志能力，允您以键值对的形式添加上下文信息：

#![allow(unused)]
fn main() {
use slog::{info, o, Logger};
use slog_scope;

fn process_user(user_id: i32, logger: &Logger) {
    info!(logger, "开始处理用户"; "user_id" => user_id);
    
    // 处理逻辑
    // ...
    
    info!(logger, "用户处理完成"; "user_id" => user_id, "status" => "success");
}
}

健康检查

健康检查是监控应用程序状态和检测问题的重要工具。Rust生态系统提供了actix-web-health-check等健康检查库。

以下是使用actix-web-health-check的基本示例：

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use actix_web_health_check::{HealthCheck, HealthCheckError};

async fn health() -> impl Responder {
    web::HttpResponse::Ok()
        .json(serde_json::json!({
            "status": "healthy",
            "checks": {
                "database": "ok",
                "cache": "ok"
            }
        }))
}

async fn ready() -> impl Responder {
    // 检查应用程序是否准备好接收请求
    if is_application_ready().await {
        HttpResponse::Ok().finish()
    } else {
        HttpResponse::ServiceUnavailable().finish()
    }
}

async fn is_application_ready() -> bool {
    // 实现就绪检查逻辑
    // 例如，检查数据库连接、外部服务可用性等
    true
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/health", web::get().to(health))
            .route("/ready", web::get().to(ready))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

这个示例实现了两个健康检查端点：

/health：表示应用程序当前是否健康
/ready：表示应用程序是否准备好处理请求

在更复杂的应用程序中，您可能需要实现一个更全面的健康检查系统：

use std::sync::Arc;
use tokio::sync::RwLock;
use std::collections::HashMap;

#[derive(Clone)]
struct HealthStatus {
    // 各种服务的状态
    database: bool,
    cache: bool,
    external_api: bool,
}

impl Default for HealthStatus {
    fn default() -> Self {
        HealthStatus {
            database: false,
            cache: false,
            external_api: false,
        }
    }
}

async fn update_health_status(status: Arc<RwLock<HealthStatus>>) {
    // 在后台定期更新健康状态
    loop {
        {
            let mut status = status.write().await;
            
            // 更新数据库状态
            status.database = check_database().await;
            
            // 更新缓存状态
            status.cache = check_cache().await;
            
            // 更新外部API状态
            status.external_api = check_external_api().await;
        }
        
        // 等待下次检查
        tokio::time::sleep(tokio::time::Duration::from_secs(30)).await;
    }
}

async fn check_database() -> bool {
    // 实现数据库检查逻辑
    true
}

async fn check_cache() -> bool {
    // 实现缓存检查逻辑
    true
}

async fn check_external_api() -> bool {
    // 实现外部API检查逻辑
    true
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 创建健康状态共享对象
    let health_status = Arc::new(RwLock::new(HealthStatus::default()));
    
    // 启动健康状态更新后台任务
    tokio::spawn(update_health_status(health_status.clone()));
    
    HttpServer::new(move || {
        App::new()
            .data(health_status.clone())
            .route("/health", web::get().to(health))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

async fn health(data: web::Data<Arc<RwLock<HealthStatus>>>) -> impl Responder {
    let status = data.read().await;
    
    let response = serde_json::json!({
        "status": "healthy",
        "checks": {
            "database": if status.database { "ok" } else { "error" },
            "cache": if status.cache { "ok" } else { "error" },
            "external_api": if status.external_api { "ok" } else { "error" },
        }
    });
    
    // 如果任何检查失败，返回非200状态码
    if status.database && status.cache && status.external_api {
        web::HttpResponse::Ok().json(response)
    } else {
        web::HttpResponse::ServiceUnavailable().json(response)
    }
}

这个更复杂的示例展示了一个全面的健康检查系统，能够：

定期检查多个服务
共享检查结果
在任何检查失败时返回适当的HTTP状态码

性能监控

性能监控是了解应用程序在生产环境中表现的关键。Rust生态系统提供了多种性能监控工具和库：

metrics库：记录应用程序指标
prometheus客户端：将指标导出到Prometheus
tracing库：分布式追踪
tracing-log：将日志转换为追踪数据

以下是使用metrics库记录应用程序指标的基本示例：

#![allow(unused)]
fn main() {
use metrics::{gauge, histogram, increment_counter};

fn process_request() {
    // 记录请求开始时间
    let start = std::time::Instant::now();
    
    // 执行请求处理
    // ...
    
    // 记录请求处理时间
    let duration = start.elapsed();
    histogram!("request_duration_seconds").record(duration.as_secs_f64());
    
    // 记录请求计数
    increment_counter!("requests_total");
    increment_counter!("requests_success_total");
}

fn track_user_signup() {
    increment_counter!("user_signups_total");
    gauge!("active_users").set(get_active_user_count() as f64);
}
}

要配置Prometheus导出器：

use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
use std::sync::Arc;

fn init_metrics() -> PrometheusHandle {
    PrometheusBuilder::new()
        .install_recorder()
        .expect("Failed to install Prometheus recorder")
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let prometheus_handle = init_metrics();
    let prometheus_handle = Arc::new(prometheus_handle);
    
    HttpServer::new(move || {
        App::new()
            .route("/metrics", web::get().to(move || {
                let handle = prometheus_handle.clone();
                async move {
                    let metrics = handle.render();
                    HttpResponse::Ok()
                        .content_type("text/plain")
                        .body(metrics)
                }
            }))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

对于更高级的监控需求，可以使用tracing库进行分布式追踪：

use tracing::{info, warn, error, instrument, span, Level};
use tracing_subscriber;

#[instrument]
fn process_request(user_id: i32) -> Result<String, Box<dyn std::error::Error>> {
    let span = span!(Level::INFO, "process_request", user_id = user_id);
    let _enter = span.enter();
    
    info!("开始处理请求");
    
    // 处理逻辑
    let result = do_work()?;
    
    info!("请求处理完成");
    Ok(result)
}

fn do_work() -> Result<String, Box<dyn std::error::Error>> {
    // 模拟工作
    std::thread::sleep(std::time::Duration::from_millis(100));
    Ok("工作完成".to_string())
}

#[tokio::main]
async fn main() {
    // 初始化追踪记录器
    tracing_subscriber::fmt::init();
    
    // 使用追踪的函数
    match process_request(42) {
        Ok(result) => println!("结果: {}", result),
        Err(e) => eprintln!("错误: {}", e),
    }
}

要启用日志作为追踪：

use tracing_subscriber::{fmt, layer::SubscriberExt, util::SubscriberInitExt};
use tracing_subscriber::layer::Layers;

fn main() {
    // 配置追踪记录器
    tracing_subscriber::registry()
        .with(fmt::layer()) // 添加日志记录层
        .with(tracing_jaeger::layer()?) // 添加Jaeger追踪层
        .init();
    
    // 使用追踪记录
    let span = tracing::span!(tracing::Level::INFO, "example", user_id = 42).entered();
    tracing::info!("追踪消息");
    span.exit();
}

这些工具和库帮助您构建一个全面的监控解决方案，记录应用程序的指标、追踪请求以及收集日志数据。

错误追踪

错误追踪是监控系统的重要组成部分，帮助您识别、诊断和解决应用程序中的问题。Rust生态系统提供了多种错误追踪解决方案：

anyhow库：简化错误处理和报告
thiserror库：用于创建自定义错误类型
sentry库：错误追踪平台
backtrace库：获取堆栈跟踪信息

以下是使用anyhow处理和报告错误的示例：

use anyhow::{Context, Result, bail};
use log::error;

fn load_config() -> Result<Config> {
    let config_path = std::env::var("CONFIG_PATH")
        .context("CONFIG_PATH environment variable not set")?;
    
    let config_content = std::fs::read_to_string(&config_path)
        .with_context(|| format!("Failed to read config file: {}", config_path))?;
    
    let config: Config = toml::from_str(&config_content)
        .context("Failed to parse config file")?;
    
    Ok(config)
}

fn main() -> Result<()> {
    match load_config() {
        Ok(config) => {
            println!("配置加载成功");
            // 使用配置运行应用程序
            // run_app(config)
        }
        Err(e) => {
            error!("应用程序启动失败: {:?}", e);
            bail!("应用程序无法启动: {}", e);
        }
    }
}

使用thiserror创建自定义错误类型：

#![allow(unused)]
fn main() {
use thiserror::Error;

#[derive(Error, Debug)]
pub enum MyError {
    #[error("数据库连接失败")]
    DatabaseConnectionError(#[from] sqlx::Error),
    
    #[error("无效的用户输入: {0}")]
    InvalidInput(String),
    
    #[error("外部API调用失败: {0}")]
    ExternalApiError(String),
    
    #[error("内部服务器错误")]
    InternalError,
}

fn process_user_input(input: &str) -> Result<String, MyError> {
    if input.is_empty() {
        return Err(MyError::InvalidInput("输入不能为空".to_string()));
    }
    
    // 处理输入
    Ok(format!("处理结果: {}", input))
}
}

使用sentry集成错误追踪：

use sentry::{init, ClientOptions, User, UserContext};
use std::error::Error;

fn init_sentry() {
    let dsn = std::env::var("SENTRY_DSN").unwrap_or_else(|_| "YOUR_SENTRY_DSN".to_string());
    
    init(
        dsn,
        ClientOptions {
            release: sentry::release_name!(),
            ..ClientOptions::default()
        },
    );
}

fn main() {
    init_sentry();
    
    // 发送用户信息
    sentry::configure_scope(|scope| {
        scope.set_user(Some(User {
            id: Some("42".to_string()),
            ..Default::default()
        }));
    });
    
    // 运行应用程序
    if let Err(e) = run_app() {
        sentry::capture_error(&e);
        eprintln!("应用程序错误: {}", e);
    }
    
    // 确保事件被发送
    sentry::flush();
}

最后，使用backtrace获取详细的堆栈跟踪信息：

#![allow(unused)]
fn main() {
use backtrace::Backtrace;

fn process_with_backtrace() -> Result<(), Box<dyn Error>> {
    let bt = Backtrace::new();
    
    // 模拟错误
    Err("这是一个测试错误".into())
}

fn handle_error(e: &Box<dyn Error>) {
    println!("错误: {}", e);
    
    // 获取和打印堆栈跟踪
    let bt = Backtrace::new();
    println!("堆栈跟踪:\n{:?}", bt);
}
}

这些工具和库帮助您创建一个全面的错误追踪系统，能够：

标准化错误处理
创建有意义的错误消息
集成外部错误追踪服务
获取详细的堆栈跟踪信息

故障排查

常见问题

在生产环境中，应用程序可能会遇到各种问题。以下是一些常见的Rust应用程序问题及其排查方法：

内存泄漏：
- 症状：应用程序使用的内存持续增长
- 原因：循环引用、缓存无限增长、事件监听器未正确移除
- 排查：使用valgrind或jemalloc进行内存分析
死锁：
- 症状：应用程序停止响应
- 原因：互斥锁顺序不一致、多个线程互相等待
- 排查：使用thread::park()和std::thread::panicking()检测死锁
性能问题：
- 症状：响应时间过长、CPU使用率过高
- 原因：低效算法、未优化的数据库查询、频繁的分配
- 排查：使用perf、flamegraph、criterion进行性能分析
程序崩溃：
- 症状：应用程序意外终止
- 原因：panic、段错误、野指针访问
- 排查：使用addr2line、gdb、lldb分析core dump
网络问题：
- 症状：连接超时、连接拒绝
- 原因：防火墙、端口未打开、DNS解析失败
- 排查：使用netstat、telnet、curl测试网络连接

以下是一个基本的问题排查示例：

use std::sync::Mutex;
use std::thread;

fn main() {
    // 模拟死锁问题
    let mutex1 = Mutex::new(1);
    let mutex2 = Mutex::new(2);
    
    let handle1 = thread::spawn(move || {
        let _lock1 = mutex1.lock().unwrap();
        thread::sleep(std::time::Duration::from_millis(100));
        let _lock2 = mutex2.lock().unwrap(); // 可能死锁
        println!("线程1完成");
    });
    
    let handle2 = thread::spawn(move || {
        let _lock2 = mutex2.lock().unwrap();
        thread::sleep(std::time::Duration::from_millis(100));
        let _lock1 = mutex1.lock().unwrap(); // 可能死锁
        println!("线程2完成");
    });
    
    handle1.join().unwrap();
    handle2.join().unwrap();
}

为避免死锁，可以使用try_lock()或确保锁的获取顺序一致：

use std::sync::Mutex;

fn main() {
    let mutex1 = Mutex::new(1);
    let mutex2 = Mutex::new(2);
    
    // 方法1: 使用try_lock()进行非阻塞获取锁
    {
        let _lock1 = mutex1.lock().unwrap();
        // 尝试获取锁2，但不要阻塞
        match mutex2.try_lock() {
            Ok(_lock2) => println!("成功获取两个锁"),
            Err(_) => println!("无法获取锁2，继续处理"),
        }
    }
    
    // 方法2: 确保一致的锁获取顺序
    {
        // 先获取地址较小的锁
        let lock_order = if &mutex1 as *const _ < &mutex2 as *const _ {
            (mutex1.lock().unwrap(), mutex2.lock().unwrap())
        } else {
            (mutex2.lock().unwrap(), mutex1.lock().unwrap())
        };
        println!("以一致顺序获取锁");
    }
}

诊断工具

Rust生态系统提供了多种诊断工具，帮助您识别和解决生产环境中的问题：

GDB和LLDB：调试器，用于分析崩溃和查看变量值
Valgrind：内存调试工具，用于检测内存泄漏和非法内存访问
Perf：Linux性能分析工具，用于分析CPU使用和性能热点
Flamegraph：可视化性能分析工具
Address Sanitizer (ASan)：编译时内存错误检测工具

让我们看一下如何使用这些工具：

使用GDB调试Rust应用程序：

# 使用GDB运行Rust应用程序
gdb target/release/myapp

# 在GDB中设置断点
break main
break mymodule::critical_function

# 运行程序
run

# 查看变量值
print my_variable

# 继续执行
continue

# 查看堆栈跟踪
backtrace

# 退出GDB
quit

使用Address Sanitizer检测内存错误：

# 在Cargo.toml中启用ASan
[profile.dev]
panic = "abort"

[build]
rustflags = ["-C", "instrument-asan"]

# 使用ASan运行程序
RUSTFLAGS="-Z sanitizer=address" cargo build
RUSTFLAGS="-Z sanitizer=address" cargo run

使用Valgrind检测内存泄漏：

# 使用Valgrind运行程序
valgrind --leak-check=full --show-leak-kinds=all target/release/myapp

使用Perf分析性能：

# 使用Perf记录性能数据
perf record -F 99 -a -g target/release/myapp

# 查看性能报告
perf report

使用Flamegraph生成性能图表：

# 使用perf record
perf record -F 99 -a -g target/release/myapp
perf script | stackcollapse-perf.pl | flamegraph.pl > flamegraph.svg

# 或使用cargo-flamegraph
cargo install flamegraph
cargo flamegraph target/release/myapp

使用jepsen测试分布式系统：

jepsen是一个用于测试分布式系统一致性的框架。虽然它主要用于测试分布式数据库，但也可以用于测试微服务的一致性。

创建一个基本的jepsen测试：

// 这个例子展示了如何在Rust中使用jepsen测试框架
// 注意：这是一个概念性示例，实际的jepsen测试通常用Clojure编写

use jepsen::test::JepsenTest;
use jepsen::test::Operation;
use jepsen::history::History;

#[derive(Debug, Clone)]
struct TestOperation {
    process: i32,
    op_type: String,
    value: i32,
}

impl Operation for TestOperation {
    fn from_string(s: &str) -> Result<Self, String> {
        let parts: Vec<&str> = s.split(' ').collect();
        if parts.len() != 3 {
            return Err("Invalid format".to_string());
        }
        
        Ok(TestOperation {
            process: parts[0].parse::<i32>().map_err(|_| "Invalid process id".to_string())?,
            op_type: parts[1].to_string(),
            value: parts[2].parse::<i32>().map_err(|_| "Invalid value".to_string())?,
        })
    }
}

struct MyTest;

impl JepsenTest for MyTest {
    type Operation = TestOperation;
    
    fn setup() -> Self {
        MyTest
    }
    
    fn teardown(&self) {
        // 清理资源
    }
    
    fn perform(&self, op: &TestOperation) -> Result<String, String> {
        match op.op_type.as_str() {
            "read" => {
                // 执行读取操作
                Ok(format!("Read value: {}", op.value))
            },
            "write" => {
                // 执行写入操作
                Ok(format!("Wrote value: {}", op.value))
            },
            _ => Err(format!("Unknown operation: {}", op.op_type)),
        }
    }
}

fn main() {
    // 这个例子展示了一个基本的jepsen测试结构
    // 实际的jepsen测试通常使用Clojure语言编写
    println!("这个例子展示了在Rust中使用jepsen测试框架的概念结构");
    println!("实际的jepsen测试通常使用Clojure语言编写");
}

这些工具和框架帮助您诊断和解决生产环境中的问题，提高应用程序的可靠性和性能。

故障恢复

故障恢复是监控系统中的一个重要部分，涉及在发生故障时自动或手动恢复应用程序。以下是一些常见的故障恢复策略：

自动重启：使用systemd、upstart或supervisord等工具自动重启崩溃的应用程序
健康检查：定期检查应用程序健康状态，并在检测到问题时采取行动
故障转移：将流量路由到健康的实例
熔断器模式：在检测到下游服务故障时临时停止请求
回退机制：提供基本功能，即使某些组件失败

让我们看一个使用健康检查和自动重启的示例：

# systemd服务文件 /etc/systemd/system/myapp.service
[Unit]
Description=My Rust Application
After=network.target

[Service]
Type=simple
User=myapp
WorkingDirectory=/var/myapp
ExecStart=/var/myapp/myapp
Restart=on-failure
RestartSec=5
Environment=RUST_LOG=info
Environment=RUST_BACKTRACE=1

[Install]
WantedBy=multi-user.target

# 启用和启动服务
sudo systemctl enable myapp
sudo systemctl start myapp

# 查看服务状态
sudo systemctl status myapp

在应用程序中实现健康检查和故障恢复逻辑：

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

struct AppState {
    health: Arc<Mutex<Health>>,
    restart_count: Arc<Mutex<u32>>,
    last_restart: Arc<Mutex<Instant>>,
}

#[derive(Clone, Copy, PartialEq, Eq)]
enum Health {
    Healthy,
    Unhealthy,
}

async fn health(data: web::Data<AppState>) -> impl Responder {
    let is_healthy = {
        let health = data.health.lock().unwrap();
        *health == Health::Healthy
    };
    
    if is_healthy {
        HttpResponse::Ok().json(serde_json::json!({
            "status": "healthy",
            "timestamp": chrono::Utc::now(),
        }))
    } else {
        HttpResponse::ServiceUnavailable().json(serde_json::json!({
            "status": "unhealthy",
            "timestamp": chrono::Utc::now(),
        }))
    }
}

async fn restart(data: web::Data<AppState>) -> impl Responder {
    {
        let mut health = data.health.lock().unwrap();
        *health = Health::Unhealthy;
    }
    
    {
        let mut restart_count = data.restart_count.lock().unwrap();
        *restart_count += 1;
    }
    
    {
        let mut last_restart = data.last_restart.lock().unwrap();
        *last_restart = Instant::now();
    }
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "restarting",
        "message": "应用程序正在重新启动"
    }))
}

fn health_monitor(state: AppState) -> tokio::task::JoinHandle<()> {
    tokio::spawn(async move {
        let mut interval = tokio::time::interval(Duration::from_secs(30));
        
        loop {
            interval.tick().await;
            
            // 检查应用程序健康状态
            let needs_restart = {
                let health = state.health.lock().unwrap();
                *health == Health::Unhealthy
            };
            
            // 检查重启时间间隔
            let too_soon = {
                let last_restart = state.last_restart.lock().unwrap();
                last_restart.elapsed() < Duration::from_secs(60) // 至少等待60秒才能重启
            };
            
            if needs_restart && !too_soon {
                // 执行重启逻辑
                eprintln!("正在重启应用程序...");
                
                // 这里可以添加更复杂的重启逻辑
                // 例如：停止数据库连接、清理资源、重新初始化等
                
                {
                    let mut health = state.health.lock().unwrap();
                    *health = Health::Healthy;
                }
            }
        }
    })
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let app_state = web::Data::new(AppState {
        health: Arc::new(Mutex::new(Health::Healthy)),
        restart_count: Arc::new(Mutex::new(0)),
        last_restart: Arc::new(Mutex::new(Instant::now())),
    });
    
    // 启动健康监控任务
    let health_check_task = health_monitor(app_state.clone());
    
    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .route("/health", web::get().to(health))
            .route("/restart", web::get().to(restart))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await?;
    
    // 取消健康监控任务
    health_check_task.abort();
    
    Ok(())
}

这个示例展示了一个基本的健康检查和故障恢复系统，包括：

定期检查应用程序健康状态
提供健康检查和重启端点
在检测到问题时自动重启应用程序
防止频繁重启的机制

故障恢复是构建高可用性系统的重要组成部分。通过实现适当的健康检查、自动重启机制和故障转移策略，可以确保应用程序在出现故障时能够自动恢复，提高系统的可靠性和可用性。

微服务架构部署项目

架构设计

本节将介绍一个基于微服务架构的部署项目，展示如何使用Rust构建、部署和运维一个完整的微服务系统。微服务架构是一种将应用程序设计为一组小型服务的方法，每个服务运行在其自己的进程中，并通过轻量级机制（通常是HTTP API）进行通信。

微服务架构的主要优势包括：

可独立部署：每个服务可以独立部署和扩展
技术多样性：每个服务可以使用不同的技术栈
故障隔离：一个服务的问题不会影响整个系统
团队自主性：不同团队可以独立开发和部署服务

我们的示例微服务架构将包括以下组件：

API网关：接收外部请求并路由到适当的微服务
用户服务：管理用户注册、认证和用户信息
产品服务：管理产品信息
订单服务：管理订单和支付
通知服务：发送通知（邮件、短信等）
配置服务：管理微服务配置
服务发现：管理服务地址和负载均衡

在微服务架构中，我们需要考虑以下设计原则：

单一职责原则：每个服务应该只有一个变化的理由
服务自治：每个服务应该管理自己的数据
智能端点，哑管道：服务应该包含业务逻辑，而通信应该简单
去中心化管理：每个服务可以使用最适合其需求的技术栈
基础设施自动化：使用CI/CD管道自动化部署和管理

服务拆分

服务拆分是微服务架构设计的关键步骤。在本示例中，我们将按以下方式拆分系统：

API网关（Rust）：
- 职责：路由、认证、限流、日志
- 技术：actix-web、tower、tracing
- 端口：8080
用户服务（Rust）：
- 职责：用户注册、认证、授权
- 技术：actix-web、sqlx、bcrypt
- 端口：8081
产品服务（Rust）：
- 职责：产品信息管理
- 技术：actix-web、sqlx
- 端口：8082
订单服务（Rust）：
- 职责：订单处理、支付
- 技术：actix-web、sqlx
- 端口：8083
通知服务（Rust）：
- 职责：发送通知
- 技术：actix-web、lettre
- 端口：8084
配置服务（Rust）：
- 职责：集中配置管理
- 技术：actix-web、consul-rust
- 端口：8085
服务发现（Consul）：
- 职责：服务注册、发现
- 技术：Consul
- 端口：8500

让我们详细看一个服务示例（用户服务）：

// user-service/src/main.rs
use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use actix_web::web::{Data, Json};
use sqlx::{Pool, Postgres, postgres::PgPoolOptions};
use serde::{Deserialize, Serialize};
use std::env;
use log::{info, warn, error};
use tracing_subscriber;

#[derive(Deserialize)]
struct RegisterRequest {
    email: String,
    password: String,
    full_name: String,
}

#[derive(Deserialize)]
struct LoginRequest {
    email: String,
    password: String,
}

#[derive(Serialize)]
struct UserResponse {
    id: i32,
    email: String,
    full_name: String,
}

#[derive(Serialize)]
struct AuthResponse {
    token: String,
    user: UserResponse,
}

struct AppState {
    db: Pool<Postgres>,
}

async fn register(
    data: web::Data<AppState>,
    register_request: Json<RegisterRequest>,
) -> impl Responder {
    info!("处理用户注册请求: {}", register_request.email);
    
    // 验证输入
    if register_request.email.is_empty() || register_request.password.is_empty() {
        return HttpResponse::BadRequest().json(serde_json::json!({
            "error": "邮箱和密码不能为空"
        }));
    }
    
    // 检查邮箱是否已存在
    let existing_user = sqlx::query!("SELECT id FROM users WHERE email = $1", register_request.email)
        .fetch_optional(&data.db)
        .await;
    
    match existing_user {
        Ok(Some(_)) => {
            return HttpResponse::Conflict().json(serde_json::json!({
                "error": "邮箱已注册"
            }));
        },
        Ok(None) => {}, // 继续处理
        Err(e) => {
            error!("查询数据库时出错: {}", e);
            return HttpResponse::InternalServerError().json(serde_json::json!({
                "error": "内部服务器错误"
            }));
        }
    }
    
    // 加密密码
    let password_hash = bcrypt::hash(&register_request.password, bcrypt::DEFAULT_COST)
        .map_err(|e| {
            error!("加密密码时出错: {}", e);
            "内部服务器错误"
        })
        .unwrap();
    
    // 创建用户
    let result = sqlx::query!(
        "INSERT INTO users (email, password_hash, full_name) VALUES ($1, $2, $3) RETURNING id",
        register_request.email,
        password_hash,
        register_request.full_name
    )
    .fetch_one(&data.db)
    .await;
    
    match result {
        Ok(user) => {
            info!("成功创建用户: {}", register_request.email);
            
            // 生成令牌
            let token = generate_jwt_token(user.id);
            
            let user_response = UserResponse {
                id: user.id,
                email: register_request.email.clone(),
                full_name: register_request.full_name.clone(),
            };
            
            let auth_response = AuthResponse {
                token,
                user: user_response,
            };
            
            HttpResponse::Created().json(auth_response)
        },
        Err(e) => {
            error!("创建用户时出错: {}", e);
            HttpResponse::InternalServerError().json(serde_json::json!({
                "error": "内部服务器错误"
            }))
        }
    }
}

async fn login(
    data: web::Data<AppState>,
    login_request: Json<LoginRequest>,
) -> impl Responder {
    info!("处理用户登录请求: {}", login_request.email);
    
    // 查找用户
    let result = sqlx::query!(
        "SELECT id, email, password_hash, full_name FROM users WHERE email = $1",
        login_request.email
    )
    .fetch_optional(&data.db)
    .await;
    
    match result {
        Ok(Some(user)) => {
            // 验证密码
            let password_valid = bcrypt::verify(&login_request.password, &user.password_hash)
                .unwrap_or(false);
            
            if !password_valid {
                warn!("登录失败: {}", login_request.email);
                return HttpResponse::Unauthorized().json(serde_json::json!({
                    "error": "无效的邮箱或密码"
                }));
            }
            
            info!("用户登录成功: {}", login_request.email);
            
            // 生成令牌
            let token = generate_jwt_token(user.id);
            
            let user_response = UserResponse {
                id: user.id,
                email: user.email,
                full_name: user.full_name,
            };
            
            let auth_response = AuthResponse {
                token,
                user: user_response,
            };
            
            HttpResponse::Ok().json(auth_response)
        },
        Ok(None) => {
            warn!("登录失败: 邮箱不存在 {}", login_request.email);
            HttpResponse::Unauthorized().json(serde_json::json!({
                "error": "无效的邮箱或密码"
            }))
        },
        Err(e) => {
            error!("查询数据库时出错: {}", e);
            HttpResponse::InternalServerError().json(serde_json::json!({
                "error": "内部服务器错误"
            }))
        }
    }
}

// 健康检查端点
async fn health() -> impl Responder {
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "service": "user-service"
    }))
}

// 简单JWT令牌生成函数（实际使用中应使用成熟的JWT库）
fn generate_jwt_token(user_id: i32) -> String {
    // 这里只是演示，实际生产环境中应使用jsonwebtoken库
    format!("jwt_token_for_user_{}", user_id)
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 初始化日志记录
    tracing_subscriber::fmt::init();
    
    // 从环境变量获取数据库URL
    let database_url = env::var("DATABASE_URL")
        .unwrap_or_else(|_| "postgres://postgres:postgres@localhost:5432/user_service".to_string());
    
    // 创建数据库连接池
    let pool = PgPoolOptions::new()
        .max_connections(5)
        .connect(&database_url)
        .await
        .expect("无法连接到数据库");
    
    // 确保数据库模式是最新的
    sqlx::migrate!("./migrations")
        .run(&pool)
        .await
        .expect("数据库迁移失败");
    
    // 创建共享应用状态
    let app_state = web::Data::new(AppState { db: pool });
    
    info!("启动用户服务监听在 0.0.0.0:8081");
    
    HttpServer::new(move || {
        App::new()
            .app_data(app_state.clone())
            .route("/health", web::get().to(health))
            .route("/register", web::post().to(register))
            .route("/login", web::post().to(login))
    })
    .bind("0.0.0.0:8081")?
    .run()
    .await
}

这个示例展示了用户服务的核心功能：

用户注册
用户登录
密码加密
健康检查
数据库操作
JWT令牌生成（演示用）

容器编排

容器编排是管理微服务的关键部分。在本示例中，我们将使用Docker Compose进行本地开发环境编排，使用Kubernetes进行生产环境编排。

首先，Docker Compose文件示例：

# docker-compose.yml
version: '3.8'

services:
  consul:
    image: consul:1.15
    container_name: consul
    ports:
      - "8500:8500"
    command: agent -dev -client=0.0.0.0
    environment:
      - CONSUL_BIND_INTERFACE=eth0

  postgres:
    image: postgres:15
    container_name: postgres
    ports:
      - "5432:5432"
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=postgres
      - POSTGRES_DB=user_service
    volumes:
      - postgres_data:/var/lib/postgresql/data

  user-service:
    build:
      context: ./services/user-service
      dockerfile: Dockerfile
    container_name: user-service
    ports:
      - "8081:8081"
    environment:
      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/user_service
      - RUST_LOG=info
    depends_on:
      - postgres
      - consul

  product-service:
    build:
      context: ./services/product-service
      dockerfile: Dockerfile
    container_name: product-service
    ports:
      - "8082:8082"
    environment:
      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/product_service
      - RUST_LOG=info
    depends_on:
      - postgres
      - consul

  order-service:
    build:
      context: ./services/order-service
      dockerfile: Dockerfile
    container_name: order-service
    ports:
      - "8083:8083"
    environment:
      - DATABASE_URL=postgres://postgres:postgres@postgres:5432/order_service
      - RUST_LOG=info
    depends_on:
      - postgres
      - consul

  notification-service:
    build:
      context: ./services/notification-service
      dockerfile: Dockerfile
    container_name: notification-service
    ports:
      - "8084:8084"
    environment:
      - SMTP_HOST=smtp.example.com
      - SMTP_PORT=587
      - SMTP_USER=notifications@example.com
      - SMTP_PASSWORD=password
      - RUST_LOG=info
    depends_on:
      - consul

  config-service:
    build:
      context: ./services/config-service
      dockerfile: Dockerfile
    container_name: config-service
    ports:
      - "8085:8085"
    environment:
      - CONSUL_ADDR=consul:8500
      - RUST_LOG=info
    depends_on:
      - consul

  api-gateway:
    build:
      context: ./api-gateway
      dockerfile: Dockerfile
    container_name: api-gateway
    ports:
      - "8080:8080"
    environment:
      - RUST_LOG=info
      - CONSUL_ADDR=consul:8500
    depends_on:
      - user-service
      - product-service
      - order-service
      - notification-service
      - config-service
      - consul

volumes:
  postgres_data:

在生产环境中，我们使用Kubernetes进行容器编排。以下是Kubernetes部署文件的示例：

# k8s/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: microservices

---
# k8s/user-service-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  namespace: microservices
  labels:
    app: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:1.0.0
        ports:
        - containerPort: 8081
        env:
        - name: DATABASE_URL
          valueFrom:
            secretKeyRef:
              name: database-secret
              key: url
        - name: RUST_LOG
          value: "info"
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8081
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8081
          initialDelaySeconds: 5
          periodSeconds: 5

---
# k8s/user-service-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: user-service
  namespace: microservices
  labels:
    app: user-service
spec:
  selector:
    app: user-service
  ports:
  - port: 8081
    targetPort: 8081
  type: ClusterIP

---
# k8s/api-gateway-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-gateway
  namespace: microservices
  labels:
    app: api-gateway
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-gateway
  template:
    metadata:
      labels:
        app: api-gateway
    spec:
      containers:
      - name: api-gateway
        image: myregistry/api-gateway:1.0.0
        ports:
        - containerPort: 8080
        env:
        - name: RUST_LOG
          value: "info"
        - name: CONSUL_ADDR
          value: "consul:8500"
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 30
          periodSeconds: 10
        readinessProbe:
          httpGet:
            path: /health
            port: 8080
          initialDelaySeconds: 5
          periodSeconds: 5

---
# k8s/api-gateway-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: api-gateway
  namespace: microservices
  labels:
    app: api-gateway
spec:
  selector:
    app: api-gateway
  ports:
  - port: 80
    targetPort: 8080
    nodePort: 30080
  type: NodePort

这个Kubernetes配置包含了基本的部署和服务定义，展示了如何：

定义命名空间
部署服务
配置服务
设置健康检查
配置资源限制
暴露服务

持续集成与持续部署

持续集成与持续部署（CI/CD）是现代软件开发的重要实践，它使团队能够更频繁、更可靠地部署代码。在本示例中，我们将使用GitHub Actions和Kubernetes进行CI/CD。

以下是一个GitHub Actions工作流示例，用于自动化构建和部署：

# .github/workflows/ci-cd.yml
name: CI/CD Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

env:
  REGISTRY: ghcr.io
  IMAGE_NAME: ${{ github.repository }}

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
      
    - name: Install Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
        profile: minimal
        override: true
        components: clippy, rustfmt
        
    - name: Run clippy
      run: cargo clippy --all-targets --all-features -- -D warnings
      
    - name: Run tests
      run: cargo test --all-features
      
    - name: Build application
      run: cargo build --all-features --release

  docker-build-push:
    needs: test
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/develop'
    permissions:
      contents: read
      packages: write
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
      
    - name: Log in to Container Registry
      uses: docker/login-action@v2
      with:
        registry: ${{ env.REGISTRY }}
        username: ${{ github.actor }}
        password: ${{ secrets.GITHUB_TOKEN }}
        
    - name: Extract metadata
      id: meta
      uses: docker/metadata-action@v4
      with:
        images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
        tags: |
          type=ref,event=branch
          type=ref,event=pr
          type=sha,prefix={{branch}}-
          
    - name: Build and push Docker image
      uses: docker/build-push-action@v4
      with:
        context: .
        push: true
        tags: ${{ steps.meta.outputs.tags }}
        labels: ${{ steps.meta.outputs.labels }}
        cache-from: type=gha
        cache-to: type=gha,mode=max

  deploy-staging:
    needs: docker-build-push
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/develop'
    environment: staging
    
    steps:
    - name: Deploy to staging
      run: |
        # 提取最新的镜像标签
        IMAGE_TAG=$(echo ${{ github.sha }} | cut -c1-7)
        
        # 使用kubectl应用Kubernetes配置
        kubectl config use-context staging-k8s
        kubectl set image deployment/user-service user-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        kubectl set image deployment/product-service product-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        kubectl set image deployment/order-service order-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        kubectl set image deployment/notification-service notification-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        kubectl set image deployment/config-service config-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        kubectl set image deployment/api-gateway api-gateway=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:develop-$IMAGE_TAG -n microservices
        
        # 等待部署完成
        kubectl rollout status deployment/user-service -n microservices
        kubectl rollout status deployment/product-service -n microservices
        kubectl rollout status deployment/order-service -n microservices
        kubectl rollout status deployment/notification-service -n microservices
        kubectl rollout status deployment/config-service -n microservices
        kubectl rollout status deployment/api-gateway -n microservices

  deploy-production:
    needs: deploy-staging
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    environment: production
    
    steps:
    - name: Deploy to production
      run: |
        # 提取最新的镜像标签
        IMAGE_TAG=$(echo ${{ github.sha }} | cut -c1-7)
        
        # 使用kubectl应用Kubernetes配置
        kubectl config use-context production-k8s
        kubectl set image deployment/user-service user-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        kubectl set image deployment/product-service product-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        kubectl set image deployment/order-service order-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        kubectl set image deployment/notification-service notification-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        kubectl set image deployment/config-service config-service=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        kubectl set image deployment/api-gateway api-gateway=${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}:main-$IMAGE_TAG -n microservices
        
        # 等待部署完成
        kubectl rollout status deployment/user-service -n microservices
        kubectl rollout status deployment/product-service -n microservices
        kubectl rollout status deployment/order-service -n microservices
        kubectl rollout status deployment/notification-service -n microservices
        kubectl rollout status deployment/config-service -n microservices
        kubectl rollout status deployment/api-gateway -n microservices
        
        # 清理旧的镜像
        kubectl delete pods -l app=api-gateway --field-selector=status.phase=Succeeded -n microservices
        kubectl delete pods -l app=user-service --field-selector=status.phase=Succeeded -n microservices
        kubectl delete pods -l app=product-service --field-selector=status.phase=Succeeded -n microservices
        kubectl delete pods -l app=order-service --field-selector=status.phase=Succeeded -n microservices
        kubectl delete pods -l app=notification-service --field-selector=status.phase=Succeeded -n microservices
        kubectl delete pods -l app=config-service --field-selector=status.phase=Succeeded -n microservices

这个GitHub Actions工作流实现了完整的CI/CD流程：

测试阶段：运行代码检查、格式检查和测试
构建和推送阶段：构建Docker镜像并推送到容器注册表
部署到测试环境阶段：将代码部署到测试环境（在develop分支上）
部署到生产环境阶段：将代码部署到生产环境（在main分支上）

该工作流还实现了蓝绿部署或滚动部署策略，通过使用kubectl rollout status命令确保新版本完全部署后才继续操作。

此外，该工作流还包括了环境特定的配置，支持不同环境使用不同的Kubernetes集群和配置。

总结

在本章中，我们探讨了Rust应用程序的部署和运维的各个方面，包括：

Docker容器化：学习如何使用Docker创建高效、紧凑的Rust应用程序镜像
编译优化：了解如何优化Rust二进制文件的性能和大小
监控与日志：实现全面的监控和日志记录系统
故障排查：使用各种工具和策略诊断和解决生产环境问题
微服务架构部署：构建和部署完整的微服务系统

Rust的编译特性和性能优势使其非常适合微服务架构和高性能系统。通过结合Docker、Kubernetes、CI/CD和全面的监控，您可以构建健壮、可扩展且易于维护的微服务系统。

随着微服务架构的日益普及，Rust将继续在高性能系统和服务领域发挥重要作用。通过掌握本章介绍的部署和运维技术，您将能够构建和维护在生产环境中表现优异的Rust应用程序。

下一章我们将学习如何处理并发和异步编程，这是Rust的另一个重要特性。通过使用async/await、Future和Tokio，您可以构建高并发和高性能的应用程序。## 容器化深入实践

多架构镜像构建

在现代部署环境中，我们经常需要为不同的处理器架构（如x86、ARM）构建镜像。Rust的交叉编译能力使其成为构建多架构镜像的理想选择。

# 基础构建阶段
FROM --platform=$BUILDPLATFORM rust:1.77 as builder
WORKDIR /app

# 安装交叉编译目标
RUN rustup target add x86_64-unknown-linux-musl aarch64-unknown-linux-gnu

# 复制依赖文件
COPY Cargo.toml Cargo.lock ./
RUN mkdir src && echo 'fn main() {}' > src/main.rs
RUN cargo build --target x86_64-unknown-linux-musl --release && \
    cargo build --target aarch64-unknown-linux-gnu --release && \
    rm src/main.rs

# 复制源代码并构建
COPY src ./src
COPY . .

# 构建不同架构的二进制文件
RUN cargo build --target x86_64-unknown-linux-musl --release && \
    cargo build --target aarch64-unknown-linux-gnu --release

# 最终镜像
FROM --platform=linux/amd64 debian:bookworm-slim as x86
COPY --from=builder /app/target/x86_64-unknown-linux-musl/release/myapp /usr/local/bin/
EXPOSE 8080
ENTRYPOINT ["myapp"]

FROM --platform=linux/arm64 debian:bookworm-slim as arm64
COPY --from=builder /app/target/aarch64-unknown-linux-gnu/release/myapp /usr/local/bin/
EXPOSE 8080
ENTRYPOINT ["myapp"]

使用Buildx构建多架构镜像：

# 创建新的构建器实例
docker buildx create --name multiarch --driver docker-container --use

# 构建多架构镜像
docker buildx build \
  --platform linux/amd64,linux/arm64 \
  --tag myregistry/myapp:latest \
  --push \
  .

容器安全最佳实践

容器安全是生产环境中的重要考虑因素。以下是一些Rust容器安全最佳实践：

使用非root用户：

# 创建非特权用户
RUN groupadd -r myapp && useradd -r -g myapp myapp

# 在运行阶段切换到非特权用户
USER myapp

使用精简的基础镜像：

# 使用Alpine Linux（精简发行版）
FROM alpine:3.19

# 安装必要的运行时库
RUN apk add --no-cache ca-certificates libgcc

最小化镜像层：

# 将相关命令合并到一个RUN语句中
RUN apt-get update && \
    apt-get install -y curl && \
    rm -rf /var/lib/apt/lists/*

使用只读文件系统：

# 创建可写层用于特定目录
VOLUME ["/var/log", "/tmp"]

扫描镜像漏洞：

# 使用Trivy扫描镜像
trivy image myregistry/myapp:latest

# 使用Anchore扫描镜像
anchore-cli image add myregistry/myapp:latest

使用seccomp限制系统调用：

// seccomp-profile.json
{
  "defaultAction": "SCMP_ACT_ERRNO",
  "architectures": [
    "SCMP_ARCH_X86_64"
  ],
  "syscalls": [
    {
      "names": ["read", "write", "open", "close", "stat"],
      "action": "SCMP_ACT_ALLOW"
    }
  ]
}

应用seccomp配置文件：

docker run --security-opt seccomp=seccomp-profile.json myregistry/myapp

Kubernetes部署优化

在Kubernetes环境中，我们可以使用各种技术和策略来优化Rust微服务的部署：

HPA（水平Pod自动缩放器）：

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: user-service-hpa
  namespace: microservices
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: user-service
  minReplicas: 3
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70
  - type: Resource
    resource:
      name: memory
      target:
        type: Utilization
        averageUtilization: 80

Pod安全策略（PodSecurityPolicy）：

apiVersion: policy/v1beta1
kind: PodSecurityPolicy
metadata:
  name: restricted
spec:
  privileged: false
  allowPrivilegeEscalation: false
  requiredDropCapabilities:
    - ALL
  volumes:
    - 'configMap'
    - 'emptyDir'
    - 'projected'
    - 'secret'
    - 'downwardAPI'
    - 'persistentVolumeClaim'
  runAsUser:
    rule: 'MustRunAsNonRoot'
  seLinux:
    rule: 'RunAsAny'
  fsGroup:
    rule: 'RunAsAny'
  readOnlyRootFilesystem: true

资源限制和请求：

apiVersion: v1
kind: Pod
metadata:
  name: user-service
spec:
  containers:
  - name: user-service
    image: myregistry/user-service:1.0.0
    resources:
      requests:
        memory: "128Mi"
        cpu: "100m"
      limits:
        memory: "256Mi"
        cpu: "200m"
    volumeMounts:
    - name: tmp
      mountPath: /tmp
    - name: config
      mountPath: /app/config
  volumes:
  - name: tmp
    emptyDir: {}
  - name: config
    configMap:
      name: user-service-config

容器探针（Container Probes）：

apiVersion: v1
kind: Pod
metadata:
  name: user-service
spec:
  containers:
  - name: user-service
    image: myregistry/user-service:1.0.0
    livenessProbe:
      httpGet:
        path: /health/live
        port: 8081
      initialDelaySeconds: 60
      periodSeconds: 30
      timeoutSeconds: 10
      failureThreshold: 3
    readinessProbe:
      httpGet:
        path: /health/ready
        port: 8081
      initialDelaySeconds: 15
      periodSeconds: 10
      timeoutSeconds: 5
      failureThreshold: 3
    startupProbe:
      httpGet:
        path: /health/startup
        port: 8081
      initialDelaySeconds: 10
      periodSeconds: 10
      timeoutSeconds: 5
      failureThreshold: 30

Service Mesh集成：

apiVersion: v1
kind: Service
metadata:
  name: user-service
  namespace: microservices
  annotations:
    traefik.ingress.kubernetes.io/service.serversscheme: http
    traefik.ingress.kubernetes.io/service.serverss.path: /
spec:
  selector:
    app: user-service
  ports:
  - port: 8081
    targetPort: 8081
---
apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
metadata:
  name: user-service-vs
  namespace: microservices
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        x-tenant:
          exact: premium
    route:
    - destination:
        host: user-service
        subset: premium
  - route:
    - destination:
        host: user-service
        subset: standard
---
apiVersion: networking.istio.io/v1alpha3
kind: DestinationRule
metadata:
  name: user-service-dr
  namespace: microservices
spec:
  host: user-service
  trafficPolicy:
    loadBalancer:
      simple: LEAST_CONN
  subsets:
  - name: standard
    labels:
      tier: standard
  - name: premium
    labels:
      tier: premium

编译优化深度分析

链接时优化（LTO）技术

链接时优化是Rust编译器提供的重要优化功能，它允许编译器在链接阶段进行全局优化。通过LTO，编译器可以跨编译单元进行优化，从而提高性能。

启用LTO：

[profile.release]
lto = true  # 启用完整LTO

# 或者只对特定目标启用
[profile.release]
lto = "fat"  # 类似于lto = true

# 使用thin LTO，平衡性能提升和编译时间
[profile.release]
lto = "thin"

在Cargo.toml中配置LTO：

[profile.release]
opt-level = 3
lto = "fat"  # 启用完整LTO
codegen-units = 1
panic = "abort"

在命令行中启用LTO：

# 启用完整LTO
cargo build --release -C lto=fat

# 启用thin LTO
cargo build --release -C lto=thin

# 启用thin LTO并结合其他优化
cargo build --release -C lto=thin -C opt-level=3

跨 crate LTO：

# Cargo.toml中的配置
[profile.release.package."*"]
lto = true  # 为所有依赖启用LTO

链接时间分析和内联优化：

# 启用Link Time Optimization (LTO)的高级选项
RUSTFLAGS="-C lto=thin -C panic=abort -C codegen-units=1" cargo build --release

注意，LTO虽然可以提高性能，但会增加编译时间。在开发环境中，可能需要使用较少的LTO或不启用LTO。

编译时特性控制

Rust的编译时特性系统允许在编译时控制代码的编译方式，这对于优化至关重要。

条件编译：

#![allow(unused)]
fn main() {
#[cfg(target_os = "linux")]
fn my_function() {
    // Linux特定实现
}

#[cfg(target_os = "windows")]
fn my_function() {
    // Windows特定实现
}
}

功能特性（feature flags）：

[features]
default = ["logging", "cache"]
logging = []
cache = []
database = []

#![allow(unused)]
fn main() {
#[cfg(feature = "logging")]
fn log_info(message: &str) {
    println!("INFO: {}", message);
}

#[cfg(not(feature = "logging"))]
fn log_info(_: &str) {
    // 空实现
}

#[cfg(feature = "cache")]
use cached::Cached;
}

编译时优化标记：

#![allow(unused)]
fn main() {
#[inline]
fn hot_function() {
    // 鼓励内联
}

#[cold]
fn unlikely_function() {
    // 提示编译器这是冷路径，不太可能执行
}
}

目标特定优化：

#![allow(unused)]
fn main() {
#[cfg(target_arch = "x86_64")]
fn use_simd() {
    // 使用SIMD指令
}

#[cfg(target_arch = "aarch64")]
fn use_simd() {
    // 使用ARM NEON指令
}
}

编译时分支优化：

#![allow(unused)]
fn main() {
fn process(value: i32) -> i32 {
    if value > 1000 {
        // 大概率不会执行的分支
        expensive_calculation(value)
    } else {
        // 大概率会执行的分支
        simple_calculation(value)
    }
}
}

高级监控与日志系统

分布式追踪系统

在微服务架构中，追踪请求在多个服务中的执行过程至关重要。以下是一个使用tracing库实现分布式追踪的示例：

use tracing::{info, instrument, span, Level};
use tracing_subscriber::{self, FmtSubscriber};
use opentelemetry::{
    sdk::{trace, Resource},
    global,
    trace::TraceError,
};
use opentelemetry_jaeger::PipelineBuilder;
use std::sync::Arc;

#[instrument]
async fn handle_request(user_id: i32) -> Result<String, Box<dyn std::error::Error>> {
    let span = span!(Level::INFO, "handle_request", user_id = user_id);
    let _enter = span.enter();
    
    // 记录开始处理请求
    info!("开始处理请求");
    
    // 模拟调用用户服务
    let user_info = get_user_info(user_id).await?;
    
    // 记录处理结果
    info!("成功获取用户信息: {:?}", user_info);
    
    Ok(format!("处理结果: {:?}", user_info))
}

#[instrument]
async fn get_user_info(user_id: i32) -> Result<UserInfo, Box<dyn std::error::Error>> {
    let span = span!(Level::INFO, "get_user_info", user_id = user_id);
    let _enter = span.enter();
    
    // 模拟请求延迟
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
    
    // 记录追踪信息
    tracing::info!("用户信息获取完成");
    
    Ok(UserInfo { id: user_id, name: "示例用户".to_string() })
}

#[tokio::main]
async fn main() -> Result<(), TraceError> {
    // 初始化订阅者
    let subscriber = FmtSubscriber::builder()
        .with_max_level(Level::TRACE)
        .finish();
    tracing::subscriber::set_global_default(subscriber)
        .expect("设置全局追踪订阅者失败");
    
    // 初始化Jaeger追踪器
    let tracer = opentelemetry_jaeger::new_pipeline()
        .with_service_name("my-service")
        .with_tags(vec![
            opentelemetry::sdk::export::trace::SpanId::from_u64(1),
        ])
        .install_simple()?;
    
    // 设置全局追踪器
    let _guard = tracing::subscriber::set_default(tracing::subscriber::NoSubscriber::default());
    global::set_tracer_provider(tracer.clone());
    
    // 模拟处理请求
    handle_request(42).await?;
    
    // 确保追踪数据被导出
    std::thread::sleep(std::time::Duration::from_millis(1000));
    
    Ok(())
}

自定义指标收集

在生产环境中，收集关键性能指标对于监控和优化至关重要。以下是一个使用metrics库收集自定义指标的示例：

use metrics::{describe_counter, describe_gauge, describe_histogram, gauge, histogram, increment_counter};
use metrics_exporter_prometheus::{PrometheusBuilder, PrometheusHandle};
use std::time::Duration;
use tokio::time::interval;

#[derive(Clone)]
struct Metrics {
    pub request_count: Arc<metrics::Counter>,
    pub request_duration: Arc<metrics::Histogram>,
    pub active_connections: Arc<metrics::Gauge>,
    pub error_count: Arc<metrics::Counter>,
    pub cache_hit_ratio: Arc<metrics::Gauge>,
}

impl Metrics {
    fn new() -> Self {
        Self {
            request_count: Arc::new(metrics::register_counter!("requests_total").unwrap()),
            request_duration: Arc::new(metrics::register_histogram!("request_duration_seconds", vec![0.1, 0.5, 1.0, 2.0, 5.0]).unwrap()),
            active_connections: Arc::new(metrics::register_gauge!("active_connections").unwrap()),
            error_count: Arc::new(metrics::register_counter!("errors_total").unwrap()),
            cache_hit_ratio: Arc::new(metrics::register_gauge!("cache_hit_ratio").unwrap()),
        }
    }
    
    fn describe() {
        describe_counter!(
            "requests_total",
            "处理的请求总数"
        );
        
        describe_gauge!(
            "active_connections",
            "当前活跃连接数"
        );
        
        describe_histogram!(
            "request_duration_seconds",
            "请求处理时间直方图",
            vec![0.1, 0.5, 1.0, 2.0, 5.0]
        );
    }
    
    async fn simulate_work(&self) -> Result<String, Box<dyn std::error::Error>> {
        let start = std::time::Instant::now();
        
        // 模拟工作
        tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
        
        // 记录请求持续时间
        self.request_duration.record(start.elapsed().as_secs_f64());
        
        // 增加请求计数
        self.request_count.increment(1);
        
        // 模拟随机错误
        if std::rand::random::<u32>() % 10 == 0 {
            self.error_count.increment(1);
            return Err("模拟错误".into());
        }
        
        Ok("模拟工作完成".to_string())
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化指标
    Metrics::describe();
    let prometheus_handle = PrometheusBuilder::new()
        .install_recorder()
        .expect("无法安装Prometheus记录器");
    
    // 共享Prometheus句柄
    let prometheus_handle = Arc::new(prometheus_handle);
    
    // 创建度量对象
    let metrics = Metrics::new();
    
    // 启动一个定期报告指标的任务
    tokio::spawn({
        let metrics = metrics.clone();
        let mut interval = interval(Duration::from_secs(5));
        async move {
            loop {
                interval.tick().await;
                
                // 模拟更新活动连接数
                let active_conn = 10 + (std::rand::random::<u32>() % 5) as i64;
                gauge!("active_connections").set(active_conn);
                
                // 模拟更新缓存命中率
                let cache_hit_ratio = 0.8 + (std::rand::random::<f64>() * 0.2);
                gauge!("cache_hit_ratio").set(cache_hit_ratio);
            }
        }
    });
    
    // 启动HTTP服务器提供指标
    let prometheus_handle = prometheus_handle.clone();
    tokio::spawn(async move {
        let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
        
        loop {
            let (stream, _) = listener.accept().await.unwrap();
            let handle = prometheus_handle.clone();
            tokio::spawn(async move {
                let response = handle.render();
                let _ = stream.write_all(response.as_bytes()).await;
            });
        }
    });
    
    // 模拟工作负载
    let mut interval = interval(Duration::from_millis(100));
    loop {
        interval.tick().await;
        
        if let Err(e) = metrics.simulate_work().await {
            eprintln!("错误: {}", e);
        }
    }
}

告警系统设计

在生产环境中，当系统出现问题时及时发送告警至关重要。以下是一个基于Rust实现的告警系统示例：

use tokio::sync::{mpsc, oneshot};
use std::collections::HashMap;
use tokio::time::{interval, Duration};
use serde::{Deserialize, Serialize};
use chrono::Utc;

// 定义告警结构
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct Alert {
    pub id: String,
    pub severity: AlertSeverity,
    pub service: String,
    pub message: String,
    pub timestamp: chrono::DateTime<Utc>,
    pub resolved: bool,
}

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub enum AlertSeverity {
    Critical,
    Warning,
    Info,
}

// 告警管理器
struct AlertManager {
    alerts: HashMap<String, Alert>,
    alert_channels: Vec<mpsc::UnboundedSender<Alert>>,
}

impl AlertManager {
    fn new() -> Self {
        AlertManager {
            alerts: HashMap::new(),
            alert_channels: Vec::new(),
        }
    }
    
    async fn register_channel(&mut self) -> mpsc::UnboundedReceiver<Alert> {
        let (tx, rx) = mpsc::unbounded_channel();
        self.alert_channels.push(tx);
        rx
    }
    
    async fn send_alert(&mut self, alert: Alert) {
        // 存储告警
        self.alerts.insert(alert.id.clone(), alert.clone());
        
        // 广播告警
        for channel in &self.alert_channels {
            let _ = channel.send(alert.clone());
        }
        
        // 记录日志
        log::alert!(&alert);
    }
    
    async fn resolve_alert(&mut self, alert_id: &str) {
        if let Some(alert) = self.alerts.get_mut(alert_id) {
            alert.resolved = true;
            
            // 发送解决通知
            let resolved_alert = alert.clone();
            for channel in &self.alert_channels {
                let _ = channel.send(resolved_alert.clone());
            }
            
            log::info!("告警已解决: {}", alert_id);
        }
    }
    
    async fn get_active_alerts(&self) -> Vec<Alert> {
        self.alerts.values()
            .filter(|alert| !alert.resolved)
            .cloned()
            .collect()
    }
}

// 监控任务
async fn monitor_system(alert_manager: mpsc::UnboundedSender<Alert>) {
    let mut interval = interval(Duration::from_secs(30));
    
    loop {
        interval.tick().await;
        
        // 模拟系统监控检查
        if std::rand::random::<f32>() < 0.1 {  // 10%概率触发告警
            let alert = Alert {
                id: format!("alert-{}", std::rand::random::<u32>()),
                severity: if std::rand::random::<f32>() < 0.2 { AlertSeverity::Critical } else { AlertSeverity::Warning },
                service: "示例服务".to_string(),
                message: "检测到系统异常".to_string(),
                timestamp: Utc::now(),
                resolved: false,
            };
            
            let _ = alert_manager.send(alert);
        }
        
        // 检查内存使用
        let memory_usage = get_memory_usage();
        if memory_usage > 0.9 {
            let alert = Alert {
                id: format!("memory-alert-{}", std::rand::random::<u32>()),
                severity: AlertSeverity::Critical,
                service: "系统服务".to_string(),
                message: format!("内存使用率过高: {:.2}%", memory_usage * 100.0),
                timestamp: Utc::now(),
                resolved: false,
            };
            
            let _ = alert_manager.send(alert);
        }
    }
}

// 模拟获取内存使用率
fn get_memory_usage() -> f64 {
    0.5 + std::rand::random::<f64>() * 0.5  // 随机值在0.5-1.0之间
}

// 告警处理器
async fn handle_alerts(mut rx: mpsc::UnboundedReceiver<Alert>) {
    while let Some(alert) = rx.recv().await {
        match alert.severity {
            AlertSeverity::Critical => {
                log::error!("严重告警: {} - {}", alert.service, alert.message);
                send_email_alert(&alert).await;
            }
            AlertSeverity::Warning => {
                log::warn!("警告: {} - {}", alert.service, alert.message);
            }
            AlertSeverity::Info => {
                log::info!("信息: {} - {}", alert.service, alert.message);
            }
        }
    }
}

// 模拟发送邮件告警
async fn send_email_alert(alert: &Alert) {
    // 在实际实现中，这里应该发送真实的邮件
    log::info!("发送邮件告警: {}", alert.message);
}

// 告警服务
async fn alert_service() {
    let mut alert_manager = AlertManager::new();
    let (tx, rx) = mpsc::unbounded_channel();
    
    // 启动监控系统
    tokio::spawn(monitor_system(tx.clone()));
    
    // 启动告警处理器
    tokio::spawn(handle_alerts(rx));
    
    // 启动HTTP API
    let app = actix_web::web::Data::new(AlertState { alert_manager: &mut alert_manager, sender: tx });
    
    HttpServer::new(move || {
        App::new()
            .app_data(app.clone())
            .route("/alerts", web::get().to(get_alerts))
            .route("/alerts/{id}/resolve", web::post().to(resolve_alert))
    })
    .bind("0.0.0.0:8080")
    .unwrap()
    .run()
    .await
    .unwrap();
}

// 共享状态
struct AlertState<'a> {
    alert_manager: &'a mut AlertManager,
    sender: mpsc::UnboundedSender<Alert>,
}

// 获取所有告警
async fn get_alerts(state: web::Data<AlertState>) -> impl Responder {
    let alerts = state.alert_manager.get_active_alerts().await;
    HttpResponse::Ok().json(alerts)
}

// 解决告警
async fn resolve_alert(
    path: web::Path<String>,
    state: web::Data<AlertState>,
) -> impl Responder {
    let alert_id = path.into_inner();
    state.alert_manager.resolve_alert(&alert_id).await;
    HttpResponse::Ok().json(serde_json::json!({
        "status": "success",
        "message": format!("告警 {} 已解决", alert_id)
    }))
}

fn main() {
    // 初始化日志
    env_logger::init();
    
    // 启动告警服务
    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(alert_service());
}

故障排查高级技术

性能问题诊断

在生产环境中，性能问题可能比崩溃更难以诊断和修复。以下是一个全面的性能诊断工具集示例：

use std::time::{Duration, Instant};
use std::sync::{Arc, Mutex, mpsc};
use tokio::runtime::Handle;
use parking_lot::RwLock;
use serde::{Deserialize, Serialize};
use flate2::{read::GzDecoder, write::GzEncoder, Compression};
use std::io::{Read, Write};

// 性能分析器
struct Profiler {
    samples: Arc<RwLock<Vec<Sample>>>,
    active: Arc<Mutex<bool>>,
}

#[derive(Clone, Serialize, Deserialize)]
struct Sample {
    timestamp: Duration,
    thread_id: u64,
    function: String,
    duration: Duration,
}

impl Profiler {
    fn new() -> Self {
        Self {
            samples: Arc::new(RwLock::new(Vec::new())),
            active: Arc::new(Mutex::new(false)),
        }
    }
    
    fn start(&self) {
        *self.active.lock().unwrap() = true;
    }
    
    fn stop(&self) {
        *self.active.lock().unwrap() = false;
    }
    
    fn sample(&self, function: &str, duration: Duration) {
        if *self.active.lock().unwrap() {
            let sample = Sample {
                timestamp: Instant::now().elapsed(),
                thread_id: std::thread::current().id().as_u64().get(),
                function: function.to_string(),
                duration,
            };
            
            let mut samples = self.samples.write();
            samples.push(sample);
        }
    }
    
    fn get_report(&self) -> String {
        let samples = self.samples.read();
        let mut report = String::new();
        
        // 按函数分组
        let mut function_stats: HashMap<String, FunctionStats> = HashMap::new();
        
        for sample in samples.iter() {
            let stats = function_stats.entry(sample.function.clone()).or_insert_with(|| {
                FunctionStats::new()
            });
            
            stats.record(sample.duration);
        }
        
        // 生成报告
        report.push_str("性能分析报告:\n");
        report.push_str("函数名称 | 调用次数 | 平均时间 | 最大时间 | 总时间\n");
        report.push_str("---|---|---|---|---\n");
        
        for (function, stats) in function_stats {
            report.push_str(&format!(
                "{} | {} | {:.2}ms | {:.2}ms | {:.2}ms\n",
                function,
                stats.count,
                stats.sum / stats.count as f64 / 1_000_000.0,
                stats.max as f64 / 1_000_000.0,
                stats.sum as f64 / 1_000_000.0
            ));
        }
        
        report
    }
}

struct FunctionStats {
    count: u64,
    sum: u128,
    max: u128,
}

impl FunctionStats {
    fn new() -> Self {
        Self {
            count: 0,
            sum: 0,
            max: 0,
        }
    }
    
    fn record(&mut self, duration: Duration) {
        let nanos = duration.as_nanos();
        
        self.count += 1;
        self.sum += nanos;
        
        if nanos > self.max {
            self.max = nanos;
        }
    }
}

// 使用性能分析器的示例函数
async fn expensive_operation() {
    let profiler = Profiler::new();
    profiler.start();
    
    // 模拟昂贵的操作
    for i in 0..1000 {
        let start = Instant::now();
        
        // 模拟计算密集型工作
        let _ = tokio::task::yield_now().await;
        std::thread::sleep(Duration::from_millis(1));
        
        let duration = start.elapsed();
        profiler.sample("expensive_operation", duration);
    }
    
    profiler.stop();
    
    // 获取和报告性能分析结果
    let report = profiler.get_report();
    println!("{}", report);
}

// 内存使用分析
fn analyze_memory_usage() -> MemoryReport {
    use std::process;
    
    // 估算内存使用量（这在Rust中比较困难，因为标准库没有直接提供）
    // 在实际项目中，可能需要使用外部库如jemalloc或通过C FFI获取更多信息
    
    // 这里提供一个简化的示例
    let page_size = 4096;  // 假设页面大小为4KB
    
    // 简单估计进程的内存使用量
    let status_path = format!("/proc/{}/status", process::id());
    let status_content = std::fs::read_to_string(&status_path).unwrap_or_default();
    
    let mut vm_size = 0;
    let mut vm_rss = 0;
    
    for line in status_content.lines() {
        if line.starts_with("VmSize:") {
            vm_size = line.split_whitespace().nth(1)
                .and_then(|s| s.parse::<u64>().ok())
                .unwrap_or(0);
        } else if line.starts_with("VmRSS:") {
            vm_rss = line.split_whitespace().nth(1)
                .and_then(|s| s.parse::<u64>().ok())
                .unwrap_or(0);
        }
    }
    
    MemoryReport {
        virtual_memory_kb: vm_size,
        resident_memory_kb: vm_rss,
        page_size_kb: page_size as u64 / 1024,
    }
}

#[derive(Debug, Serialize, Deserialize)]
struct MemoryReport {
    virtual_memory_kb: u64,
    resident_memory_kb: u64,
    page_size_kb: u64,
}

fn main() {
    // 初始化日志
    env_logger::init();
    
    // 启动性能分析
    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(async {
        expensive_operation().await;
    });
    
    // 分析内存使用
    let mem_report = analyze_memory_usage();
    println!("内存使用情况: {:?}", mem_report);
}

堆栈跟踪分析

在发生崩溃或严重错误时，获取有用的堆栈跟踪信息至关重要。以下是一个增强的堆栈跟踪分析工具：

use backtrace::{Backtrace, BacktraceFrame, Symbol};
use std::sync::{Arc, Mutex, mpsc};
use std::time::{Duration, Instant};
use tokio::time::sleep;

// 堆栈跟踪分析器
struct StackTraceAnalyzer {
    traces: Arc<Mutex<Vec<TraceEntry>>>,
    threshold: Duration,
}

#[derive(Clone)]
struct TraceEntry {
    timestamp: Instant,
    function: String,
    file: String,
    line: u32,
    column: u32,
}

impl StackTraceAnalyzer {
    fn new(threshold: Duration) -> Self {
        Self {
            traces: Arc::new(Mutex::new(Vec::new())),
            threshold,
        }
    }
    
    // 分析当前堆栈跟踪
    fn analyze(&self) {
        let backtrace = Backtrace::new();
        let mut traces = self.traces.lock().unwrap();
        
        for frame in backtrace.frames() {
            for symbol in frame.symbols() {
                if let Some(name) = symbol.name() {
                    let mut file = String::new();
                    let mut line = 0;
                    let mut column = 0;
                    
                    if let Some(f) = symbol.filename() {
                        file = f.to_string_lossy().to_string();
                    }
                    
                    if let Some(l) = symbol.lineno() {
                        line = l;
                    }
                    
                    if let Some(c) = symbol.colno() {
                        column = c;
                    }
                    
                    let entry = TraceEntry {
                        timestamp: Instant::now(),
                        function: name.to_string(),
                        file,
                        line,
                        column,
                    };
                    
                    traces.push(entry);
                }
            }
        }
    }
    
    // 分析堆栈跟踪，识别可能的性能瓶颈
    fn find_bottlenecks(&self) -> Vec<Bottleneck> {
        let traces = self.traces.lock().unwrap();
        let mut function_counts: HashMap<String, (u32, Duration)> = HashMap::new();
        
        // 统计每个函数被调用的次数和时间
        for entry in traces.iter() {
            if let Some((count, _)) = function_counts.get_mut(&entry.function) {
                *count += 1;
            } else {
                function_counts.insert(entry.function.clone(), (1, Duration::from_nanos(0)));
            }
        }
        
        // 识别瓶颈（高频率和/或长执行时间）
        let mut bottlenecks = Vec::new();
        for (function, (count, _)) in function_counts {
            if count > 10 {  // 假设超过10次调用表示频繁调用
                bottlenecks.push(Bottleneck {
                    function,
                    count,
                    severity: if count > 50 { Severity::High } else { Severity::Medium },
                });
            }
        }
        
        bottlenecks.sort_by_key(|b| std::cmp::Reverse(b.count));
        bottlenecks
    }
}

#[derive(Debug, PartialEq)]
enum Severity {
    Low,
    Medium,
    High,
}

#[derive(Debug)]
struct Bottleneck {
    function: String,
    count: u32,
    severity: Severity,
}

fn complex_calculation() {
    // 模拟复杂计算
    for i in 0..1000000 {
        let _ = i * i;
    }
}

fn other_function() {
    // 模拟调用其他函数
    complex_calculation();
}

fn main() {
    // 初始化日志
    env_logger::init();
    
    // 创建堆栈跟踪分析器
    let analyzer = StackTraceAnalyzer::new(Duration::from_millis(10));
    
    // 分析当前堆栈
    analyzer.analyze();
    
    // 模拟一些函数调用
    for _ in 0..5 {
        complex_calculation();
        other_function();
        
        // 分析堆栈
        analyzer.analyze();
    }
    
    // 查找瓶颈
    let bottlenecks = analyzer.find_bottlenecks();
    
    println!("发现的性能瓶颈:");
    for bottleneck in bottlenecks {
        println!("函数: {}, 调用次数: {}, 严重性: {:?}", bottleneck.function, bottleneck.count, bottleneck.severity);
    }
}

微服务架构部署项目深入

API网关实现

API网关是微服务架构中的关键组件，负责请求路由、认证授权、限流等功能。以下是一个基于Rust实现的API网关示例：

use actix_web::{web, App, HttpResponse, HttpServer, Responder, HttpRequest, Result};
use actix_web::web::{Data, Query, Json, path};
use actix_web::http::{header, StatusCode, header::HeaderValue};
use futures::stream::{self, StreamExt};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
use tokio::sync::Semaphore;

// API网关状态
struct ApiGatewayState {
    // 服务发现
    service_discovery: Arc<ServiceDiscovery>,
    // 客户端
    http_client: Client,
    // 限流器
    rate_limiter: Arc<RateLimiter>,
    // 缓存
    cache: Arc<Mutex<Cache>>,
    // 统计
    stats: Arc<Mutex<Stats>>,
}

// 服务发现
struct ServiceDiscovery {
    services: Arc<Mutex<HashMap<String, Vec<String>>>>,
}

impl ServiceDiscovery {
    fn new() -> Self {
        let mut services = HashMap::new();
        
        // 添加示例服务
        services.insert("user-service".to_string(), vec![
            "http://user-service:8081".to_string(),
        ]);
        
        services.insert("product-service".to_string(), vec![
            "http://product-service:8082".to_string(),
        ]);
        
        services.insert("order-service".to_string(), vec![
            "http://order-service:8083".to_string(),
        ]);
        
        Self {
            services: Arc::new(Mutex::new(services)),
        }
    }
    
    fn get_service_url(&self, service_name: &str) -> Option<String> {
        let services = self.services.lock().unwrap();
        services.get(service_name).and_then(|urls| {
            if urls.is_empty() {
                None
            } else {
                // 简单的负载均衡：随机选择
                let index = (std::rand::random::<usize>()) % urls.len();
                Some(urls[index].clone())
            }
        })
    }
}

// 限流器
struct RateLimiter {
    // 限制规则
    rules: Arc<Mutex<HashMap<String, RateLimitRule>>>,
    // 令牌桶
    token_buckets: Arc<Mutex<HashMap<String, TokenBucket>>>,
}

struct RateLimitRule {
    rate: u32,      // 速率 (请求/时间单位)
    capacity: u32,  // 桶容量
    refill: u32,    // 补充速率 (令牌/时间单位)
    refill_period: Duration,  // 补充周期
}

struct TokenBucket {
    tokens: u32,
    last_refill: Instant,
    rule: RateLimitRule,
}

impl RateLimiter {
    fn new() -> Self {
        let mut rules = HashMap::new();
        
        // 添加默认限流规则
        rules.insert("default".to_string(), RateLimitRule {
            rate: 100,
            capacity: 100,
            refill: 10,
            refill_period: Duration::from_secs(1),
        });
        
        rules.insert("premium".to_string(), RateLimitRule {
            rate: 1000,
            capacity: 1000,
            refill: 100,
            refill_period: Duration::from_secs(1),
        });
        
        Self {
            rules: Arc::new(Mutex::new(rules)),
            token_buckets: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    fn check_rate_limit(&self, client_id: &str, tier: &str) -> bool {
        let mut buckets = self.token_buckets.lock().unwrap();
        let bucket = buckets.entry(client_id.to_string()).or_insert_with(|| {
            let rules = self.rules.lock().unwrap();
            let rule = rules.get(tier).unwrap_or(rules.get("default").unwrap()).clone();
            TokenBucket {
                tokens: rule.capacity,
                last_refill: Instant::now(),
                rule,
            }
        });
        
        // 计算应该补充的令牌数
        let elapsed = bucket.last_refill.elapsed();
        let mut tokens_to_add = (elapsed.as_secs() * bucket.rule.refill as u64 / bucket.rule.refill_period.as_secs()) as u32;
        
        // 限制不能超过容量
        tokens_to_add = tokens_to_add.min(bucket.rule.capacity - bucket.tokens);
        
        // 添加令牌
        if tokens_to_add > 0 {
            bucket.tokens += tokens_to_add;
            bucket.last_refill = Instant::now();
        }
        
        // 检查是否有足够的令牌
        if bucket.tokens > 0 {
            bucket.tokens -= 1;
            true
        } else {
            false
        }
    }
}

// 简单的内存缓存
struct Cache {
    store: HashMap<String, (Vec<u8>, Instant)>,
    ttl: Duration,
    max_items: usize,
}

impl Cache {
    fn new(ttl: Duration, max_items: usize) -> Self {
        Self {
            store: HashMap::new(),
            ttl,
            max_items,
        }
    }
    
    fn get(&mut self, key: &str) -> Option<Vec<u8>> {
        if let Some((value, timestamp)) = self.store.get(key) {
            if timestamp.elapsed() < self.ttl {
                return Some(value.clone());
            } else {
                self.store.remove(key);
            }
        }
        None
    }
    
    fn set(&mut self, key: &str, value: Vec<u8>) {
        // 如果缓存已满，删除最旧的项目
        if self.store.len() >= self.max_items {
            let mut oldest_key = None;
            let mut oldest_time = Instant::now();
            
            for (k, (_, timestamp)) in &self.store {
                if *timestamp < oldest_time {
                    oldest_time = *timestamp;
                    oldest_key = Some(k.clone());
                }
            }
            
            if let Some(key) = oldest_key {
                self.store.remove(&key);
            }
        }
        
        self.store.insert(key.to_string(), (value, Instant::now()));
    }
}

// 统计信息
struct Stats {
    total_requests: u64,
    total_responses: u64,
    requests_by_service: HashMap<String, u64>,
    errors_by_service: HashMap<String, u64>,
    response_times: HashMap<String, Vec<Duration>>,
}

impl Stats {
    fn new() -> Self {
        Self {
            total_requests: 0,
            total_responses: 0,
            requests_by_service: HashMap::new(),
            errors_by_service: HashMap::new(),
            response_times: HashMap::new(),
        }
    }
    
    fn record_request(&mut self, service: &str) {
        self.total_requests += 1;
        *self.requests_by_service.entry(service.to_string()).or_insert(0) += 1;
    }
    
    fn record_response(&mut self, service: &str, response_time: Duration) {
        self.total_responses += 1;
        self.response_times.entry(service.to_string()).or_insert_with(Vec::new).push(response_time);
    }
    
    fn record_error(&mut self, service: &str) {
        *self.errors_by_service.entry(service.to_string()).or_insert(0) += 1;
    }
}

// 路由处理函数
async fn route_request(
    req: HttpRequest,
    state: Data<ApiGatewayState>,
    query: Query<HashMap<String, String>>,
) -> Result<HttpResponse> {
    // 解析路径
    let path: path::PathBuf = req.path().parse().unwrap();
    let path_str = path.to_str().unwrap_or("");
    
    // 提取服务名（路径的第一部分）
    let mut path_parts: Vec<&str> = path_str.split('/').filter(|p| !p.is_empty()).collect();
    
    if path_parts.is_empty() {
        return Ok(HttpResponse::BadRequest().json(serde_json::json!({
            "error": "无效的路径"
        })));
    }
    
    let service_name = path_parts.remove(0);
    
    // 检查限流
    let client_id = get_client_id(&req);
    let tier = get_tier(&req);
    
    if !state.rate_limiter.check_rate_limit(&client_id, &tier) {
        return Ok(HttpResponse::TooManyRequests().json(serde_json::json!({
            "error": "请求频率过高"
        })));
    }
    
    // 获取服务URL
    let service_url = state.service_discovery.get_service_url(service_name);
    
    if service_url.is_none() {
        return Ok(HttpResponse::BadRequest().json(serde_json::json!({
            "error": format!("未找到服务: {}", service_name)
        })));
    }
    
    let service_url = service_url.unwrap();
    let remaining_path = if path_parts.is_empty() { "/".to_string() } else { format!("/{}", path_parts.join("/")) };
    
    // 记录请求
    {
        let mut stats = state.stats.lock().unwrap();
        stats.record_request(service_name);
    }
    
    // 检查缓存（仅对GET请求）
    if req.method() == "GET" {
        let cache_key = format!("{}:{}:{}", service_name, remaining_path, serialize_query_params(&query));
        
        let cached_response = {
            let mut cache = state.cache.lock().unwrap();
            cache.get(&cache_key)
        };
        
        if let Some(cached_data) = cached_response {
            return Ok(HttpResponse::Ok()
                .header("X-Cache", "HIT")
                .body(cached_data));
        }
    }
    
    // 记录开始时间
    let start_time = Instant::now();
    
    // 构建请求URL
    let url = format!("{}{}", service_url, remaining_path);
    
    // 准备请求
    let mut request = state.http_client.request(req.method().clone(), &url);
    
    // 添加查询参数
    for (key, value) in &*query {
        request = request.query(&[(key, value)]);
    }
    
    // 添加头部
    for (key, value) in req.headers() {
        if key != "host" && key != "content-length" {
            request = request.header(key.as_str(), value);
        }
    }
    
    // 添加代理头部
    request = request.header("X-Forwarded-For", req.peer_addr().unwrap().to_string());
    request = request.header("X-Original-Uri", req.uri().to_string());
    request = request.header("X-Original-Method", req.method().as_str());
    
    // 发送请求
    let response_result = request.send().await;
    
    let response = match response_result {
        Ok(response) => response,
        Err(e) => {
            // 记录错误
            {
                let mut stats = state.stats.lock().unwrap();
                stats.record_error(service_name);
            }
            
            return Ok(HttpResponse::ServiceUnavailable().json(serde_json::json!({
                "error": format!("服务调用失败: {}", e)
            })));
        }
    };
    
    // 记录响应时间
    let response_time = start_time.elapsed();
    {
        let mut stats = state.stats.lock().unwrap();
        stats.record_response(service_name, response_time);
    }
    
    // 获取响应状态码和内容
    let status_code = response.status();
    let content_type = response.headers().get("content-type")
        .and_then(|h| h.to_str().ok())
        .unwrap_or("application/octet-stream");
    
    // 读取响应体
    let body = response.bytes().await.unwrap_or_default();
    
    // 如果是GET请求且状态码为200，缓存响应
    if req.method() == "GET" && status_code.is_success() {
        let cache_key = format!("{}:{}:{}", service_name, remaining_path, serialize_query_params(&query));
        
        {
            let mut cache = state.cache.lock().unwrap();
            cache.set(&cache_key, body.to_vec());
        }
    }
    
    // 构建响应
    let mut response_builder = HttpResponse::build(status_code);
    
    // 复制响应头部（除了Content-Length和Transfer-Encoding）
    for (key, value) in response.headers() {
        if key != "content-length" && key != "transfer-encoding" {
            response_builder.insert_header((key.as_str(), value.clone()));
        }
    }
    
    // 添加响应头
    response_builder.insert_header(("X-Cache", "MISS"));
    response_builder.insert_header(("X-Response-Time", format!("{:?}", response_time)));
    response_builder.insert_header(("Content-Type", content_type));
    
    Ok(response_builder.body(body))
}

// 获取客户端ID
fn get_client_id(req: &HttpRequest) -> String {
    // 首先尝试从X-Client-ID头部获取
    if let Some(client_id) = req.headers().get("X-Client-ID") {
        if let Ok(id) = client_id.to_str() {
            return id.to_string();
        }
    }
    
    // 然后尝试从X-Forwarded-For头部获取
    if let Some(forwarded_for) = req.headers().get("X-Forwarded-For") {
        if let Ok(ips) = forwarded_for.to_str() {
            if let Some(ip) = ips.split(',').next() {
                return ip.trim().to_string();
            }
        }
    }
    
    // 最后使用对等地址
    req.peer_addr().unwrap().to_string()
}

// 获取客户端层级
fn get_tier(req: &HttpRequest) -> String {
    // 尝试从X-Tier头部获取
    if let Some(tier) = req.headers().get("X-Tier") {
        if let Ok(t) = tier.to_str() {
            return t.to_string();
        }
    }
    
    "default".to_string()
}

// 序列化查询参数
fn serialize_query_params(query: &Query<HashMap<String, String>>) -> String {
    let mut params: Vec<String> = query.iter()
        .map(|(k, v)| format!("{}={}", k, v))
        .collect();
    
    params.sort();
    params.join("&")
}

// 统计信息端点
async fn get_stats(state: Data<ApiGatewayState>) -> impl Responder {
    let stats = state.stats.lock().unwrap();
    let total_requests = stats.total_requests;
    let total_responses = stats.total_responses;
    let success_rate = if total_requests > 0 {
        (total_responses as f64 / total_requests as f64) * 100.0
    } else {
        0.0
    };
    
    let mut service_stats = Vec::new();
    
    for (service, requests) in &stats.requests_by_service {
        let errors = stats.errors_by_service.get(service).unwrap_or(&0);
        let error_rate = if *requests > 0 {
            (*errors as f64 / *requests as f64) * 100.0
        } else {
            0.0
        };
        
        let response_times = stats.response_times.get(service).unwrap_or(&Vec::new());
        let avg_response_time = if !response_times.is_empty() {
            response_times.iter()
                .map(|d| d.as_secs_f64())
                .sum::<f64>() / response_times.len() as f64
        } else {
            0.0
        };
        
        service_stats.push(serde_json::json!({
            "service": service,
            "requests": requests,
            "errors": errors,
            "error_rate": error_rate,
            "avg_response_time": avg_response_time
        }));
    }
    
    HttpResponse::Ok().json(serde_json::json!({
        "total_requests": total_requests,
        "total_responses": total_responses,
        "success_rate": success_rate,
        "services": service_stats
    }))
}

// 健康检查端点
async fn health() -> impl Responder {
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "service": "api-gateway"
    }))
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 初始化日志
    env_logger::init();
    
    // 创建共享状态
    let state = web::Data::new(ApiGatewayState {
        service_discovery: Arc::new(ServiceDiscovery::new()),
        http_client: Client::new(),
        rate_limiter: Arc::new(RateLimiter::new()),
        cache: Arc::new(Mutex::new(Cache::new(Duration::from_secs(60), 1000))),
        stats: Arc::new(Mutex::new(Stats::new())),
    });
    
    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .route("/{path:.*}", web::all().to(route_request))  // 通用路由处理所有请求
            .route("/health", web::get().to(health))  // 健康检查
            .route("/stats", web::get().to(get_stats))  // 统计信息
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

这个API网关示例实现了很多企业级功能：

服务发现：从服务注册中心获取服务地址
路由：将请求路由到适当的服务
限流：使用令牌桶算法限制请求频率
缓存：缓存GET请求的响应以提高性能
负载均衡：随机选择服务实例
统计：收集和分析请求统计信息

服务网格（Service Mesh）集成

在大型微服务系统中，服务网格提供了一种透明的方式来处理服务间通信、负载均衡、故障恢复等横切关注点。以下是一个使用Rust实现服务网格集成的示例：

use actix_web::{web, App, HttpResponse, HttpServer, Responder, HttpRequest};
use envoy_ext_proc::Filters;
use envoy_ext_proc::filters::http::{HttpFilter, HttpFilterConfig, HttpFilterContext};
use envoy_ext_proc::filters::NetworkFilter;
use prost_types::Any;
use std::collections::HashMap;
use std::sync::{Arc, Mutex};
use tokio::sync::RwLock;

// Envoy代理配置
struct EnvoyProxyConfig {
    listeners: Vec<ListenerConfig>,
    clusters: HashMap<String, ClusterConfig>,
}

struct ListenerConfig {
    name: String,
    address: String,
    port: u16,
    filters: Vec<FilterConfig>,
}

struct FilterConfig {
    name: String,
    config: Any,
}

struct ClusterConfig {
    name: String,
    endpoints: Vec<String>,
    lb_policy: String,
    health_checks: Vec<HealthCheckConfig>,
}

struct HealthCheckConfig {
    path: String,
    interval: String,
    timeout: String,
    healthy_threshold: u32,
    unhealthy_threshold: u32,
}

// Envoy过滤器
#[derive(Default)]
struct RustHttpFilter {
    name: "rust_filter".to_string(),
    config: Option<RustHttpFilterConfig>,
}

struct RustHttpFilterConfig {
    rate_limit: Option<RateLimitConfig>,
    circuit_breaker: Option<CircuitBreakerConfig>,
    retry_policy: Option<RetryPolicyConfig>,
}

struct RateLimitConfig {
    requests_per_minute: u32,
    burst: u32,
}

struct CircuitBreakerConfig {
    failure_threshold: u32,
    recovery_timeout: u32,
    half_open_max_calls: u32,
}

struct RetryPolicyConfig {
    max_retries: u32,
    backoff: String,
}

impl HttpFilter for RustHttpFilter {
    type Transaction = ();
    
    fn decode_headers(&self, headers: HashMap<String, String>) -> envoy_ext_proc::filters::FilterResult<HashMap<String, String>, ()> {
        // 处理请求头部
        if let Some(config) = &self.config {
            // 应用速率限制
            if let Some(rate_limit) = &config.rate_limit {
                if let Some(client_id) = headers.get("X-Client-ID") {
                    if !check_rate_limit(client_id, rate_limit) {
                        return envoy_ext_proc::filters::FilterResult::DirectResponse(
                            HttpResponse::TooManyRequests()
                                .json(serde_json::json!({
                                    "error": "请求频率过高"
                                }))
                                .into()
                        );
                    }
                }
            }
            
            // 添加追踪头部
            let mut modified_headers = headers;
            if !modified_headers.contains_key("X-Trace-Id") {
                let trace_id = generate_trace_id();
                modified_headers.insert("X-Trace-Id".to_string(), trace_id);
            }
            
            // 添加客户端信息
            if !modified_headers.contains_key("X-Client-ID") {
                let client_id = "anonymous".to_string();
                modified_headers.insert("X-Client-ID".to_string(), client_id);
            }
            
            return envoy_ext_proc::filters::FilterResult::Continue(modified_headers);
        }
        
        envoy_ext_proc::filters::FilterResult::Continue(headers)
    }
    
    fn decode_body(&self, body: Vec<u8>) -> envoy_ext_proc::filters::FilterResult<Vec<u8>, ()> {
        // 处理请求体
        if let Some(config) = &self.config {
            // 记录请求
            log_request(body.len() as u64);
        }
        
        envoy_ext_proc::filters::FilterResult::Continue(body)
    }
    
    fn encode_headers(&self, status: u16, headers: HashMap<String, String>) -> envoy_ext_proc::filters::FilterResult<HashMap<String, String>, ()> {
        // 处理响应头部
        let mut modified_headers = headers;
        
        // 添加响应头
        modified_headers.insert("X-Response-Time".to_string(), format!("{:.3}ms", calculate_response_time()));
        modified_headers.insert("X-Server".to_string(), "rust-service-mesh".to_string());
        
        envoy_ext_proc::filters::FilterResult::Continue(modified_headers)
    }
    
    fn encode_body(&self, body: Vec<u8>) -> envoy_ext_proc::filters::FilterResult<Vec<u8>, ()> {
        // 处理响应体
        if let Some(config) = &self.config {
            // 记录响应
            log_response(body.len() as u64);
        }
        
        envoy_ext_proc::filters::FilterResult::Continue(body)
    }
}

// 过滤器工厂
struct RustHttpFilterFactory {
    config: Option<RustHttpFilterConfig>,
}

impl HttpFilterConfig for RustHttpFilterFactory {
    type Config = RustHttpFilterConfig;
    type Filter = RustHttpFilter;
    
    fn create_filter(&self, config: RustHttpFilterConfig) -> Self::Filter {
        RustHttpFilter {
            name: "rust_filter".to_string(),
            config: Some(config),
        }
    }
    
    fn from_any(&self, any: &Any) -> Result<Self::Config, envoy_ext_proc::filters::FilterError> {
        // 解析过滤器配置
        // 在实际实现中，这里应该从Any中解析RustHttpFilterConfig
        Ok(RustHttpFilterConfig {
            rate_limit: Some(RateLimitConfig {
                requests_per_minute: 100,
                burst: 20,
            }),
            circuit_breaker: Some(CircuitBreakerConfig {
                failure_threshold: 5,
                recovery_timeout: 10,
                half_open_max_calls: 3,
            }),
            retry_policy: Some(RetryPolicyConfig {
                max_retries: 3,
                backoff: "exponential".to_string(),
            }),
        })
    }
}

// 简化的速率限制检查
fn check_rate_limit(client_id: &str, config: &RateLimitConfig) -> bool {
    // 在实际实现中，这里应该使用更复杂的速率限制算法
    // 如令牌桶或漏桶
    true
}

// 生成追踪ID
fn generate_trace_id() -> String {
    use rand::Rng;
    let mut rng = rand::thread_rng();
    format!("{:x}", rng.gen::<u64>())
}

// 记录请求
fn log_request(body_size: u64) {
    log::info!("记录请求: {} bytes", body_size);
}

// 记录响应
fn log_response(body_size: u64) {
    log::info!("记录响应: {} bytes", body_size);
}

// 计算响应时间
fn calculate_response_time() -> f64 {
    // 在实际实现中，这里应该计算实际响应时间
    // 简化示例
    42.0
}

// 遥测收集器
struct TelemetryCollector {
    metrics: Arc<RwLock<HashMap<String, f64>>>,
}

impl TelemetryCollector {
    fn new() -> Self {
        Self {
            metrics: Arc::new(RwLock::new(HashMap::new())),
        }
    }
    
    async fn record_metric(&self, name: &str, value: f64) {
        let mut metrics = self.metrics.write().await;
        metrics.insert(name.to_string(), value);
    }
    
    async fn get_metrics(&self) -> HashMap<String, f64> {
        let metrics = self.metrics.read().await;
        metrics.clone()
    }
}

// Envoy代理服务器
async fn envoy_proxy_server() {
    // 创建HTTP服务器来模拟Envoy代理
    let telemetry_collector = Arc::new(TelemetryCollector::new());
    
    // 创建HTTP服务器
    HttpServer::new(move || {
        let telemetry_collector = telemetry_collector.clone();
        
        App::new()
            .route("/api/{path:.*}", web::all().to(move |req: HttpRequest, path: web::Path<String>| {
                let telemetry_collector = telemetry_collector.clone();
                async move {
                    // 模拟处理请求
                    let start = std::time::Instant::now();
                    
                    // 记录请求处理
                    if let Ok(client_id) = get_client_id(&req) {
                        telemetry_collector.record_metric("requests", 1.0).await;
                    }
                    
                    // 模拟处理时间
                    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
                    
                    // 记录响应时间
                    let duration = start.elapsed();
                    telemetry_collector.record_metric("response_time", duration.as_secs_f64() * 1000.0).await;
                    
                    // 返回响应
                    HttpResponse::Ok().json(serde_json::json!({
                        "status": "success",
                        "message": "请求已处理",
                        "path": path.as_str(),
                        "response_time": duration.as_secs_f64() * 1000.0
                    }))
                }
            }))
            .route("/health", web::get().to(|| async {
                HttpResponse::Ok().json(serde_json::json!({
                    "status": "healthy",
                    "service": "envoy-proxy"
                }))
            }))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
    .unwrap();
}

// 获取客户端ID
fn get_client_id(req: &HttpRequest) -> Result<String, String> {
    if let Some(client_id) = req.headers().get("X-Client-ID") {
        if let Ok(id) = client_id.to_str() {
            return Ok(id.to_string());
        }
    }
    
    Err("未找到客户端ID".to_string())
}

fn main() {
    // 初始化日志
    env_logger::init();
    
    // 启动Envoy代理服务器
    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(envoy_proxy_server());
}

这个服务网格示例展示了如何在微服务系统中实现横切关注点：

HTTP过滤器：处理请求和响应的生命周期的关键点
速率限制：控制请求频率
重试策略：处理瞬时故障
断路器：防止级联故障
遥测收集：收集指标和日志
代理服务器：处理服务间通信

总结

在本章中，我们深入探讨了Rust应用程序的部署和运维，包括：

Docker容器化：学习如何构建高效、安全的多架构Docker镜像，并了解Kubernetes环境中的最佳实践
编译优化：深入了解链接时优化和编译时特性控制，以提高性能和减小二进制大小
高级监控与日志系统：实现分布式追踪、自定义指标收集和告警系统
故障排查技术：使用堆栈跟踪分析和性能诊断工具来识别和解决生产环境问题
微服务架构部署：构建完整的API网关和服务网格集成

Rust的编译特性和性能优势使其成为构建微服务架构的理想选择。通过结合Docker、Kubernetes、CI/CD和全面的监控，您可以构建健壮、可扩展且易于维护的微服务系统。

随着微服务架构的不断普及和云原生技术的成熟，Rust在这些环境中将发挥越来越重要的作用。通过掌握本章介绍的部署和运维技术，您将能够构建和维护在生产环境中表现优异的Rust应用程序，满足企业级应用的需求。## 微服务部署高级实践

滚动更新与蓝绿部署

在微服务架构中，部署策略的选择对于确保系统高可用性至关重要。以下是几种常用的部署策略及其Rust实现示例：

滚动更新（Rolling Update）：滚动更新是 Kubernetes 等容器编排平台默认使用的部署策略。它通过逐步替换服务实例来更新服务，减少对用户的影响。

# Kubernetes 滚动更新配置
apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
  namespace: microservices
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1        # 允许超出期望副本数的 Pod 数量
      maxUnavailable: 1  # 允许不可用的 Pod 数量
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
        version: v1.0.0
    spec:
      containers:
      - name: user-service
        image: myregistry/user-service:1.0.0
        ports:
        - containerPort: 8081
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"

在 Rust 应用中实现滚动更新兼容性：

use actix_web::{web, App, HttpResponse, HttpServer, Responder};
use std::sync::{Arc, Mutex, RwLock};
use std::time::{Duration, Instant};

struct AppState {
    version: Arc<RwLock<String>>,
    last_request: Arc<Mutex<Instant>>,
}

async fn health(data: web::Data<AppState>) -> impl Responder {
    let version = data.version.read().unwrap();
    let last_request = data.last_request.lock().unwrap();
    
    // 检查应用是否健康
    let is_healthy = last_request.elapsed() < Duration::from_secs(300); // 5分钟内有请求
    
    // 记录健康检查
    log::info!("健康检查: 版本={}, 健康={}", version, is_healthy);
    
    // 记录请求时间
    *data.last_request.lock().unwrap() = Instant::now();
    
    if is_healthy {
        HttpResponse::Ok().json(serde_json::json!({
            "status": "healthy",
            "version": *version,
            "timestamp": chrono::Utc::now()
        }))
    } else {
        HttpResponse::ServiceUnavailable().json(serde_json::json!({
            "status": "unhealthy",
            "version": *version,
            "timestamp": chrono::Utc::now()
        }))
    }
}

async fn info() -> impl Responder {
    // 返回应用元信息
    HttpResponse::Ok().json(serde_json::json!({
        "service": "user-service",
        "version": env!("CARGO_PKG_VERSION"),
        "build_time": env!("BUILD_TIME"),
        "build_sha": env!("GIT_HASH"),
        "environment": env!("ENVIRONMENT")
    }))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // 初始化日志
    env_logger::init();
    
    // 创建应用状态
    let state = web::Data::new(AppState {
        version: Arc::new(RwLock::new(env!("CARGO_PKG_VERSION").to_string())),
        last_request: Arc::new(Mutex::new(Instant::now())),
    });
    
    // 启动 HTTP 服务器
    HttpServer::new(move || {
        App::new()
            .app_data(state.clone())
            .route("/health", web::get().to(health))
            .route("/info", web::get().to(info))
    })
    .bind("0.0.0.0:8081")?
    .run()
    .await
}

蓝绿部署（Blue-Green Deployment）：蓝绿部署通过维护两个相同环境（蓝和绿）来实现零停机更新。

#![allow(unused)]
fn main() {
// 蓝绿部署配置示例
struct BlueGreenConfig {
    is_green_active: bool,
    transition_in_progress: bool,
    blue_endpoints: Vec<String>,
    green_endpoints: Vec<String>,
    health_check_interval: Duration,
    transition_timeout: Duration,
}

impl BlueGreenConfig {
    fn new() -> Self {
        Self {
            is_green_active: false,
            transition_in_progress: false,
            blue_endpoints: vec!["http://blue-service:8081".to_string()],
            green_endpoints: vec!["http://green-service:8081".to_string()],
            health_check_interval: Duration::from_secs(10),
            transition_timeout: Duration::from_secs(300), // 5分钟
        }
    }
    
    async fn get_active_endpoints(&self) -> Vec<String> {
        if self.is_green_active {
            self.green_endpoints.clone()
        } else {
            self.blue_endpoints.clone()
        }
    }
    
    async fn start_transition(&mut self) -> Result<(), String> {
        if self.transition_in_progress {
            return Err("过渡已在进行中".to_string());
        }
        
        self.transition_in_progress = true;
        
        // 验证新环境
        let new_endpoints = if self.is_green_active {
            &self.blue_endpoints
        } else {
            &self.green_endpoints
        };
        
        for endpoint in new_endpoints {
            if !self.check_endpoint_health(endpoint).await {
                self.transition_in_progress = false;
                return Err(format!("端点不健康: {}", endpoint));
            }
        }
        
        Ok(())
    }
    
    async fn complete_transition(&mut self) {
        if self.transition_in_progress {
            self.is_green_active = !self.is_green_active;
            self.transition_in_progress = false;
            
            log::info!("蓝绿部署过渡完成: {} 环境激活", 
                if self.is_green_active { "绿色" } else { "蓝色" });
        }
    }
    
    async fn check_endpoint_health(&self, endpoint: &str) -> bool {
        // 实际实现中应该进行健康检查
        // 这里简化为随机决定
        std::rand::random::<f32>() < 0.9  // 90% 概率健康
    }
}

// 蓝绿部署管理器
struct BlueGreenManager {
    config: Arc<Mutex<BlueGreenConfig>>,
    state: Arc<Mutex<AppState>>,
}

impl BlueGreenManager {
    fn new() -> Self {
        Self {
            config: Arc::new(Mutex::new(BlueGreenConfig::new())),
            state: Arc::new(Mutex::new(AppState::new())),
        }
    }
    
    async fn manage_transition(&self) {
        let mut config = self.config.lock().unwrap();
        
        if config.transition_in_progress {
            // 监控新环境的健康状况
            let active_endpoints = config.get_active_endpoints().await;
            
            for endpoint in &active_endpoints {
                if !config.check_endpoint_health(endpoint).await {
                    // 健康检查失败，可能需要回滚
                    log::error!("健康检查失败: {}", endpoint);
                    // 实际实现中应该处理回滚逻辑
                }
            }
            
            // 检查过渡是否超时
            // 实际实现中需要记录开始时间
        }
    }
    
    async fn get_routing_info(&self) -> serde_json::Value {
        let config = self.config.lock().unwrap();
        
        serde_json::json!({
            "active_environment": if config.is_green_active { "green" } else { "blue" },
            "transition_in_progress": config.transition_in_progress,
            "blue_endpoints": config.blue_endpoints,
            "green_endpoints": config.green_endpoints
        })
    }
}

// 修改服务以支持蓝绿部署
async fn blue_green_health(state: web::Data<BlueGreenManager>) -> impl Responder {
    let routing_info = state.get_routing_info().await;
    let current_env = routing_info.get("active_environment").unwrap().as_str().unwrap();
    let version = env!("CARGO_PKG_VERSION");
    
    // 返回带有环境信息的健康状态
    HttpResponse::Ok().json(serde_json::json!({
        "status": "healthy",
        "version": version,
        "environment": current_env,
        "timestamp": chrono::Utc::now()
    }))
}
}

金丝雀发布（Canary Release）：金丝雀发布通过小流量验证新版本，逐步增加流量比例，降低风险。

#![allow(unused)]
fn main() {
use rand::Rng;

struct CanaryConfig {
    traffic_split: Arc<RwLock<f32>>, // 0.0 到 1.0，表示新版本流量比例
    canary_percentage: f32,         // 默认金丝雀流量比例
    max_canary_percentage: f32,     // 最大金丝雀流量比例
    evaluation_period: Duration,    // 评估周期
    error_threshold: f32,          // 错误率阈值
    latency_threshold: f32,        // 延迟阈值
}

impl CanaryConfig {
    fn new() -> Self {
        Self {
            traffic_split: Arc::new(RwLock::new(0.1)), // 默认10%流量到新版本
            canary_percentage: 0.1,
            max_canary_percentage: 0.5,
            evaluation_period: Duration::from_secs(300), // 5分钟
            error_threshold: 0.05, // 5%错误率
            latency_threshold: 200.0, // 200ms延迟
        }
    }
    
    async fn get_service_url(&self, service_name: &str) -> String {
        // 随机决定路由到哪个版本
        let current_split = *self.traffic_split.read().unwrap();
        let is_canary = rand::thread_rng().gen::<f32>() < current_split;
        
        if is_canary {
            format!("http://{}-canary:8081", service_name)
        } else {
            format!("http://{}:8081", service_name)
        }
    }
    
    async fn update_traffic_split(&self, new_percentage: f32) {
        let mut split = self.traffic_split.write().unwrap();
        *split = new_percentage.clamp(0.0, 1.0);
    }
}

struct CanaryMetrics {
    requests: Arc<RwLock<CanaryRequestStats>>,
    start_time: Instant,
}

#[derive(Clone, Default)]
struct CanaryRequestStats {
    stable_total: u64,
    stable_errors: u64,
    stable_latency: Vec<Duration>,
    canary_total: u64,
    canary_errors: u64,
    canary_latency: Vec<Duration>,
}

impl CanaryMetrics {
    fn new() -> Self {
        Self {
            requests: Arc::new(RwLock::new(CanaryRequestStats::default())),
            start_time: Instant::now(),
        }
    }
    
    async fn record_request(&self, is_canary: bool, duration: Duration, is_error: bool) {
        let mut stats = self.requests.write().unwrap();
        
        if is_canary {
            stats.canary_total += 1;
            if is_error {
                stats.canary_errors += 1;
            }
            stats.canary_latency.push(duration);
        } else {
            stats.stable_total += 1;
            if is_error {
                stats.stable_errors += 1;
            }
            stats.stable_latency.push(duration);
        }
    }
    
    async fn get_metrics(&self) -> serde_json::Value {
        let stats = self.requests.read().unwrap();
        
        // 计算错误率
        let stable_error_rate = if stats.stable_total > 0 {
            stats.stable_errors as f64 / stats.stable_total as f64
        } else {
            0.0
        };
        
        let canary_error_rate = if stats.canary_total > 0 {
            stats.canary_errors as f64 / stats.canary_total as f64
        } else {
            0.0
        };
        
        // 计算平均延迟
        let stable_avg_latency = if !stats.stable_latency.is_empty() {
            stats.stable_latency.iter()
                .map(|d| d.as_millis() as f64)
                .sum::<f64>() / stats.stable_latency.len() as f64
        } else {
            0.0
        };
        
        let canary_avg_latency = if !stats.canary_latency.is_empty() {
            stats.canary_latency.iter()
                .map(|d| d.as_millis() as f64)
                .sum::<f64>() / stats.canary_latency.len() as f64
        } else {
            0.0
        };
        
        serde_json::json!({
            "stable": {
                "total_requests": stats.stable_total,
                "error_rate": stable_error_rate,
                "avg_latency_ms": stable_avg_latency
            },
            "canary": {
                "total_requests": stats.canary_total,
                "error_rate": canary_error_rate,
                "avg_latency_ms": canary_avg_latency
            },
            "duration_seconds": self.start_time.elapsed().as_secs()
        })
    }
}

struct CanaryService {
    config: Arc<CanaryConfig>,
    metrics: Arc<CanaryMetrics>,
}

impl CanaryService {
    fn new() -> Self {
        Self {
            config: Arc::new(CanaryConfig::new()),
            metrics: Arc::new(CanaryMetrics::new()),
        }
    }
    
    async fn route_request(&self, service_name: &str) -> Result<String, Box<dyn std::error::Error>> {
        let start_time = Instant::now();
        
        // 获取目标 URL
        let target_url = self.config.get_service_url(service_name).await;
        
        // 发起 HTTP 请求
        let response = reqwest::get(&target_url).await?;
        let is_error = !response.status().is_success();
        
        // 记录指标
        let is_canary = target_url.contains("canary");
        let duration = start_time.elapsed();
        self.metrics.record_request(is_canary, duration, is_error).await;
        
        // 处理响应
        let status = response.status();
        let body = response.text().await?;
        
        if !status.is_success() {
            return Err(format!("请求失败: {}", status).into());
        }
        
        Ok(body)
    }
    
    async fn evaluate_canary(&self) -> Result<(), Box<dyn std::error::Error>> {
        let metrics = self.metrics.get_metrics().await;
        
        // 提取指标
        let stable_error_rate = metrics["stable"]["error_rate"].as_f64().unwrap_or(0.0);
        let canary_error_rate = metrics["canary"]["error_rate"].as_f64().unwrap_or(0.0);
        let stable_avg_latency = metrics["stable"]["avg_latency_ms"].as_f64().unwrap_or(0.0);
        let canary_avg_latency = metrics["canary"]["avg_latency_ms"].as_f64().unwrap_or(0.0);
        
        // 评估条件
        let error_rate_increase = canary_error_rate - stable_error_rate;
        let latency_increase = canary_avg_latency - stable_avg_latency;
        
        log::info!("金丝雀评估: 错误率增加={}, 延迟增加={}ms", 
            error_rate_increase, latency_increase);
        
        // 根据评估结果调整流量分配
        if error_rate_increase > self.config.error_threshold as f64 ||
           latency_increase > self.config.latency_threshold as f64 {
            // 如果错误率或延迟增长过快，减少金丝雀流量
            let current_split = *self.config.traffic_split.read().unwrap();
            let new_split = (current_split * 0.5).max(0.01); // 至少保留1%流量
            
            self.config.update_traffic_split(new_split).await;
            log::warn!("金丝雀风险检测，减少金丝雀流量到 {}%", new_split * 100.0);
        } else if error_rate_increase < self.config.error_threshold as f64 * 0.5 &&
                  latency_increase < self.config.latency_threshold as f64 * 0.5 {
            // 如果表现良好，增加金丝雀流量
            let current_split = *self.config.traffic_split.read().unwrap();
            let new_split = (current_split * 1.5).min(self.config.max_canary_percentage);
            
            self.config.update_traffic_split(new_split).await;
            log::info!("金丝雀表现良好，增加金丝雀流量到 {}%", new_split * 100.0);
        }
        
        Ok(())
    }
}

// 金丝雀服务路由
async fn canary_route(
    service: web::Data<CanaryService>,
    path: web::Path<String>,
) -> impl Responder {
    let service_name = path.as_str();
    
    match service.route_request(service_name).await {
        Ok(response) => {
            let routing_info = service.config.get_service_url(service_name).await;
            let is_canary = routing_info.contains("canary");
            
            HttpResponse::Ok()
                .insert_header(("X-Canary", if is_canary { "true" } else { "false" }))
                .json(serde_json::json!({
                    "status": "success",
                    "response": response,
                    "timestamp": chrono::Utc::now()
                }))
        }
        Err(e) => {
            log::error!("金丝雀路由错误: {}", e);
            HttpResponse::InternalServerError().json(serde_json::json!({
                "error": e.to_string(),
                "timestamp": chrono::Utc::now()
            }))
        }
    }
}

// 金丝雀状态检查
async fn canary_status(
    service: web::Data<CanaryService>,
) -> impl Responder {
    let metrics = service.metrics.get_metrics().await;
    let traffic_split = *service.config.traffic_split.read().unwrap();
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "active",
        "traffic_split": traffic_split,
        "metrics": metrics,
        "timestamp": chrono::Utc::now()
    }))
}
}

服务治理策略

在微服务系统中，服务治理是确保系统稳定性和可维护性的关键。以下是一些常见的服务治理策略及其Rust实现：

限流策略：限流是保护系统免受过载的重要机制。

#![allow(unused)]
fn main() {
use std::collections::HashMap;
use std::time::{Duration, Instant};
use tokio::sync::Mutex;
use std::sync::Arc;

// 令牌桶限流器
struct TokenBucket {
    capacity: u32,
    tokens: f32,
    refill_rate: f32, // 每秒补充的令牌数
    last_refill: Instant,
}

impl TokenBucket {
    fn new(capacity: u32, refill_rate: f32) -> Self {
        Self {
            capacity,
            tokens: capacity as f32,
            refill_rate,
            last_refill: Instant::now(),
        }
    }
    
    fn try_consume(&mut self, tokens: u32) -> bool {
        // 补充令牌
        let now = Instant::now();
        let elapsed = now.duration_since(self.last_refill);
        let tokens_to_add = elapsed.as_secs_f32() * self.refill_rate;
        
        self.tokens = (self.tokens + tokens_to_add).min(self.capacity as f32);
        self.last_refill = now;
        
        // 检查是否有足够令牌
        if self.tokens >= tokens as f32 {
            self.tokens -= tokens as f32;
            true
        } else {
            false
        }
    }
    
    fn available_tokens(&self) -> f32 {
        self.tokens
    }
}

// 滑动窗口限流器
struct SlidingWindow {
    window_size: Duration,
    requests: Vec<Instant>,
    max_requests: u32,
}

impl SlidingWindow {
    fn new(window_size: Duration, max_requests: u32) -> Self {
        Self {
            window_size,
            requests: Vec::new(),
            max_requests,
        }
    }
    
    fn try_consume(&mut self) -> bool {
        let now = Instant::now();
        
        // 清理过期的请求
        self.requests.retain(|&request_time| {
            now.duration_since(request_time) < self.window_size
        });
        
        // 检查是否超出限制
        if self.requests.len() < self.max_requests as usize {
            self.requests.push(now);
            true
        } else {
            false
        }
    }
    
    fn current_requests(&self) -> usize {
        self.requests.len()
    }
}

// 限流规则
#[derive(Clone)]
struct RateLimitRule {
    limit: u32,
    window: Duration,
    rule_type: RateLimitType,
}

#[derive(Clone)]
enum RateLimitType {
    TokenBucket { capacity: u32, refill_rate: f32 },
    SlidingWindow { window_size: Duration, max_requests: u32 },
}

// 限流服务
struct RateLimitService {
    rules: Arc<Mutex<HashMap<String, RateLimitRule>>>,
    limiters: Arc<Mutex<HashMap<String, Box<dyn RateLimiter + Send + Sync>>>>,
}

trait RateLimiter {
    fn try_consume(&mut self, tokens: u32) -> bool;
    fn available_tokens(&self) -> f32;
}

struct TokenBucketLimiter {
    bucket: Arc<Mutex<TokenBucket>>,
}

impl TokenBucketLimiter {
    fn new(capacity: u32, refill_rate: f32) -> Self {
        Self {
            bucket: Arc::new(Mutex::new(TokenBucket::new(capacity, refill_rate))),
        }
    }
}

impl RateLimiter for TokenBucketLimiter {
    fn try_consume(&mut self, tokens: u32) -> bool {
        self.bucket.lock().unwrap().try_consume(tokens)
    }
    
    fn available_tokens(&self) -> f32 {
        self.bucket.lock().unwrap().available_tokens()
    }
}

struct SlidingWindowLimiter {
    window: Arc<Mutex<SlidingWindow>>,
}

impl SlidingWindowLimiter {
    fn new(window_size: Duration, max_requests: u32) -> Self {
        Self {
            window: Arc::new(Mutex::new(SlidingWindow::new(window_size, max_requests))),
        }
    }
}

impl RateLimiter for SlidingWindowLimiter {
    fn try_consume(&mut self, tokens: u32) -> bool {
        self.window.lock().unwrap().try_consume()
    }
    
    fn available_tokens(&self) -> f32 {
        self.window.lock().unwrap().max_requests as f32 - 
        self.window.lock().unwrap().current_requests() as f32
    }
}

impl RateLimitService {
    fn new() -> Self {
        Self {
            rules: Arc::new(Mutex::new(HashMap::new())),
            limiters: Arc::new(Mutex::new(HashMap::new())),
        }
    }
    
    async fn add_rule(&self, key: String, rule: RateLimitRule) {
        let mut rules = self.rules.lock().unwrap();
        let mut limiters = self.limiters.lock().unwrap();
        
        rules.insert(key.clone(), rule.clone());
        
        // 创建限流器
        let limiter: Box<dyn RateLimiter + Send + Sync> = match rule.rule_type {
            RateLimitType::TokenBucket { capacity, refill_rate } => {
                Box::new(TokenBucketLimiter::new(capacity, refill_rate))
            }
            RateLimitType::SlidingWindow { window_size, max_requests } => {
                Box::new(SlidingWindowLimiter::new(window_size, max_requests))
            }
        };
        
        limiters.insert(key, limiter);
    }
    
    async fn check_rate_limit(&self, key: &str, tokens: u32) -> bool {
        let limiters = self.limiters.lock().unwrap();
        
        if let Some(limiter) = limiters.get(key) {
            limiter.try_consume(tokens)
        } else {
            true // 如果没有限流规则，允许请求
        }
    }
    
    async fn get_rate_limit_status(&self, key: &str) -> serde_json::Value {
        let limiters = self.limiters.lock().unwrap();
        let rules = self.rules.lock().unwrap();
        
        if let Some(limiter) = limiters.get(key) {
            let available = limiter.available_tokens();
            
            if let Some(rule) = rules.get(key) {
                serde_json::json!({
                    "key": key,
                    "available_tokens": available,
                    "rule": match rule.rule_type {
                        RateLimitType::TokenBucket { capacity, .. } => {
                            format!("令牌桶: {}/{} 令牌可用", available, capacity)
                        }
                        RateLimitType::SlidingWindow { window_size, max_requests } => {
                            let window_secs = window_size.as_secs();
                            format!("滑动窗口: {}/{} 请求在 {} 秒窗口内", 
                                max_requests as f32 - available, max_requests, window_secs)
                        }
                    }
                })
            } else {
                serde_json::json!({
                    "key": key,
                    "available_tokens": available,
                    "status": "active"
                })
            }
        } else {
            serde_json::json!({
                "key": key,
                "status": "no_rule",
                "message": "没有为此键设置限流规则"
            })
        }
    }
}

// 限流中间件
async fn rate_limit_middleware(
    req: HttpRequest,
    data: web::Data<RateLimitService>,
    next: web::Next,
) -> Result<HttpResponse, actix_web::Error> {
    // 获取客户端标识符
    let client_id = get_client_identifier(&req);
    
    // 检查限流
    if !data.check_rate_limit(&client_id, 1).await {
        log::warn!("客户端 {} 触发限流", client_id);
        return Ok(HttpResponse::TooManyRequests().json(serde_json::json!({
            "error": "请求频率过高",
            "client_id": client_id,
            "timestamp": chrono::Utc::now()
        })));
    }
    
    // 继续处理请求
    let response = next.await?;
    Ok(response)
}

// 获取客户端标识符
fn get_client_identifier(req: &HttpRequest) -> String {
    // 尝试从各种头部获取客户端 ID
    if let Some(client_id) = req.headers().get("X-Client-ID") {
        if let Ok(id) = client_id.to_str() {
            return id.to_string();
        }
    }
    
    if let Some(user_id) = req.headers().get("X-User-ID") {
        if let Ok(id) = user_id.to_str() {
            return format!("user:{}", id);
        }
    }
    
    // 最后使用 IP 地址
    req.peer_addr().map(|addr| format!("ip:{}", addr.ip())).unwrap_or_default()
}
}

重试策略：在微服务系统中，网络故障是常见问题，实现重试策略可以提高系统容错性。

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::time::{Duration, Instant};
use tokio::time::{sleep, timeout};

use futures::future::BoxFuture;
use rand::Rng;

// 重试策略
#[derive(Clone)]
enum RetryPolicy {
    FixedDelay { max_attempts: u32, delay: Duration },
    ExponentialBackoff { 
        max_attempts: u32, 
        base_delay: Duration, 
        max_delay: Duration 
    },
    ExponentialBackoffWithJitter {
        max_attempts: u32,
        base_delay: Duration,
        max_delay: Duration,
        jitter: f32, // 0.0 到 1.0
    },
}

// 重试执行器
struct RetryExecutor {
    policy: RetryPolicy,
}

impl RetryExecutor {
    fn new(policy: RetryPolicy) -> Self {
        Self { policy }
    }
    
    // 异步重试函数
    async fn execute<F, T, E>(&self, mut operation: F) -> Result<T, E>
    where
        F: FnMut() -> BoxFuture<'static, Result<T, E>>,
        E: std::error::Error + Send + Sync + 'static,
    {
        let max_attempts = self.get_max_attempts();
        let mut attempt = 0;
        
        loop {
            attempt += 1;
            
            match operation().await {
                Ok(result) => return Ok(result),
                Err(error) => {
                    if attempt >= max_attempts {
                        log::error!("重试失败，已达最大尝试次数 {}: {}", max_attempts, error);
                        return Err(error);
                    }
                    
                    // 检查是否应该重试
                    if !self.should_retry(&error) {
                        log::error!("错误不可重试: {}", error);
                        return Err(error);
                    }
                    
                    // 计算延迟
                    let delay = self.calculate_delay(attempt);
                    log::warn!("操作失败，{}ms 后重试 (尝试 {}/{}): {}", 
                        delay.as_millis(), attempt, max_attempts, error);
                    
                    sleep(delay).await;
                }
            }
        }
    }
    
    fn get_max_attempts(&self) -> u32 {
        match self.policy {
            RetryPolicy::FixedDelay { max_attempts, .. } => max_attempts,
            RetryPolicy::ExponentialBackoff { max_attempts, .. } => max_attempts,
            RetryPolicy::ExponentialBackoffWithJitter { max_attempts, .. } => max_attempts,
        }
    }
    
    fn should_retry(&self, error: &dyn std::error::Error) -> bool {
        // 判断错误是否可重试
        let error_type = error.type_id();
        
        // 网络错误通常可以重试
        if error_type == std::io::Error::type_id() {
            return true;
        }
        
        // HTTP 5xx 错误可以重试
        if let Some(http_error) = error.downcast_ref::<reqwest::Error>() {
            if let Some(status) = http_error.status() {
                return status.is_server_error();
            }
            return true; // 网络错误
        }
        
        false
    }
    
    fn calculate_delay(&self, attempt: u32) -> Duration {
        match self.policy {
            RetryPolicy::FixedDelay { delay, .. } => delay,
            RetryPolicy::ExponentialBackoff { 
                base_delay, 
                max_delay, 
                .. 
            } => {
                let delay = base_delay * (2u32.pow(attempt - 1));
                std::cmp::min(delay, max_delay)
            }
            RetryPolicy::ExponentialBackoffWithJitter { 
                base_delay, 
                max_delay, 
                jitter, 
                .. 
            } => {
                let exponential_delay = base_delay * (2u32.pow(attempt - 1));
                let jittered_delay = exponential_delay.as_secs_f64() * (1.0 + jitter * (rand::thread_rng().gen::<f64>() * 2.0 - 1.0));
                let delay = Duration::from_secs_f64(jittered_delay.max(0.1)); // 最小100ms
                std::cmp::min(delay, max_delay)
            }
        }
    }
}

// 重试装饰器
async fn with_retry<F, T, E>(
    policy: RetryPolicy,
    operation: F,
) -> Result<T, E>
where
    F: Fn() -> BoxFuture<'static, Result<T, E>>,
    E: std::error::Error + Send + Sync + 'static,
{
    let executor = RetryExecutor::new(policy);
    executor.execute(operation).await
}

// 使用示例
async fn example_operation() -> Result<String, Box<dyn std::error::Error>> {
    // 模拟可能失败的操作
    if std::rand::random::<f32>() < 0.3 {
        return Err(std::io::Error::new(std::io::ErrorKind::Other, "模拟网络错误").into());
    }
    
    // 模拟处理时间
    sleep(Duration::from_millis(100)).await;
    
    Ok("操作成功".to_string())
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    env_logger::init();
    
    // 使用指数退避重试策略
    let policy = RetryPolicy::ExponentialBackoffWithJitter {
        max_attempts: 3,
        base_delay: Duration::from_millis(100),
        max_delay: Duration::from_secs(1),
        jitter: 0.2, // 20% 抖动
    };
    
    let result = with_retry(policy, || {
        Box::pin(example_operation())
    }).await;
    
    match result {
        Ok(response) => println!("成功: {}", response),
        Err(error) => println!("失败: {}", error),
    }
    
    Ok(())
}

熔断器模式：熔断器可以防止级联故障，提高系统容错性。

#![allow(unused)]
fn main() {
use std::time::{Duration, Instant};
use std::collections::VecDeque;
use tokio::sync::Mutex;
use std::sync::Arc;

// 熔断器状态
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum CircuitBreakerState {
    Closed,    // 关闭：正常处理请求
    Open,      // 打开：直接拒绝请求
    HalfOpen,  // 半开：尝试恢复
}

// 熔断器配置
#[derive(Clone)]
struct CircuitBreakerConfig {
    failure_threshold: u32,    // 失败阈值
    success_threshold: u32,    // 恢复阈值（半开状态下需要连续成功的次数）
    timeout: Duration,         // 打开状态的超时时间
    window_size: Duration,     // 滑动窗口大小
}

// 熔断器统计
#[derive(Debug, Clone)]
struct CircuitBreakerStats {
    total_requests: u64,
    success_requests: u64,
    failure_requests: u64,
    last_failure_time: Option<Instant>,
    last_success_time: Option<Instant>,
    recent_failures: VecDeque<Instant>,
}

impl CircuitBreakerStats {
    fn new() -> Self {
        Self {
            total_requests: 0,
            success_requests: 0,
            failure_requests: 0,
            last_failure_time: None,
            last_success_time: None,
            recent_failures: VecDeque::new(),
        }
    }
    
    fn record_request(&mut self, is_success: bool) {
        self.total_requests += 1;
        
        let now = Instant::now();
        
        if is_success {
            self.success_requests += 1;
            self.last_success_time = Some(now);
        } else {
            self.failure_requests += 1;
            self.last_failure_time = Some(now);
            self.recent_failures.push_back(now);
            
            // 清理过期的失败记录
            let cutoff = now - self.get_window_size();
            while let Some(&first) = self.recent_failures.front() {
                if first < cutoff {
                    self.recent_failures.pop_front();
                } else {
                    break;
                }
            }
        }
    }
    
    fn get_window_size(&self) -> Duration {
        // 这里应该从配置中获取，但简化处理
        Duration::from_secs(60) // 60秒窗口
    }
    
    fn get_recent_failure_rate(&self) -> f32 {
        if self.recent_failures.is_empty() {
            return 0.0;
        }
        
        let now = Instant::now();
        let total_in_window = self.total_requests;
        let failures_in_window = self.recent_failures.len() as u64;
        
        if total_in_window == 0 {
            0.0
        } else {
            failures_in_window as f32 / total_in_window as f32
        }
    }
}

// 熔断器
struct CircuitBreaker {
    state: CircuitBreakerState,
    config: CircuitBreakerConfig,
    stats: Arc<Mutex<CircuitBreakerStats>>,
    last_state_change: Instant,
}

impl CircuitBreaker {
    fn new(config: CircuitBreakerConfig) -> Self {
        Self {
            state: CircuitBreakerState::Closed,
            config,
            stats: Arc::new(Mutex::new(CircuitBreakerStats::new())),
            last_state_change: Instant::now(),
        }
    }
    
    async fn execute<F, T, E>(&self, operation: F) -> Result<T, CircuitBreakerError<E>>
    where
        F: FnOnce() -> BoxFuture<'static, Result<T, E>>,
        E: std::error::Error + Send + Sync + 'static,
    {
        // 检查是否应该转换状态
        self.update_state().await;
        
        // 根据当前状态决定是否执行操作
        match self.state {
            CircuitBreakerState::Open => {
                // 在打开状态下直接返回错误
                Err(CircuitBreakerError::CircuitOpen)
            }
            CircuitBreakerState::HalfOpen => {
                // 在半开状态下执行一个测试请求
                self.execute_test_request(operation).await
            }
            CircuitBreakerState::Closed => {
                // 在关闭状态下正常执行
                self.execute_request(operation).await
            }
        }
    }
    
    async fn update_state(&mut self) {
        let now = Instant::now();
        let stats = self.stats.lock().await;
        
        match self.state {
            CircuitBreakerState::Closed => {
                // 在关闭状态下，如果失败率超过阈值，转换到打开状态
                let failure_rate = stats.get_recent_failure_rate();
                if failure_rate >= self.config.failure_threshold as f32 / 100.0 {
                    log::warn!("熔断器打开，失败率过高: {:.2}%", failure_rate * 100.0);
                    self.state = CircuitBreakerState::Open;
                    self.last_state_change = now;
                }
            }
            CircuitBreakerState::Open => {
                // 在打开状态下，如果超时时间到了，转换到半开状态
                if now.duration_since(self.last_state_change) >= self.config.timeout {
                    log::info!("熔断器转换为半开状态");
                    self.state = CircuitBreakerState::HalfOpen;
                    self.last_state_change = now;
                }
            }
            CircuitBreakerState::HalfOpen => {
                // 在半开状态下，如果成功率达到阈值，转换到关闭状态
                // 注意：这个逻辑在 execute_test_request 中实现
            }
        }
    }
    
    async fn execute_request<F, T, E>(&self, operation: F) -> Result<T, CircuitBreakerError<E>>
    where
        F: FnOnce() -> BoxFuture<'static, Result<T, E>>,
        E: std::error::Error + Send + Sync + 'static,
    {
        let start = Instant::now();
        let result = operation().await;
        
        // 记录统计信息
        {
            let mut stats = self.stats.lock().await;
            stats.record_request(result.is_ok());
        }
        
        // 返回结果
        match result {
            Ok(value) => {
                log::debug!("熔断器请求成功，耗时 {:?}", start.elapsed());
                Ok(value)
            }
            Err(error) => {
                log::debug!("熔断器请求失败，耗时 {:?}: {}", start.elapsed(), error);
                Err(CircuitBreakerError::OperationError(error))
            }
        }
    }
    
    async fn execute_test_request<F, T, E>(&self, operation: F) -> Result<T, CircuitBreakerError<E>>
    where
        F: FnOnce() -> BoxFuture<'static, Result<T, E>>,
        E: std::error::Error + Send + Sync + 'static,
    {
        let start = Instant::now();
        let result = operation().await;
        
        // 记录统计信息
        {
            let mut stats = self.stats.lock().await;
            stats.record_request(result.is_ok());
        }
        
        match result {
            Ok(value) => {
                log::debug!("熔断器测试请求成功，耗时 {:?}", start.elapsed());
                
                // 如果成功率达到阈值，转换到关闭状态
                // 这里需要检查连续的成功的次数
                // 为了简化，假设单次成功就足够
                // 实际实现中应该跟踪连续成功的次数
                
                // 注意：这里需要更新状态，但结构体不可变
                // 在实际实现中，可能需要将状态管理移出当前结构
                
                Ok(value)
            }
            Err(error) => {
                log::debug!("熔断器测试请求失败，耗时 {:?}: {}", start.elapsed(), error);
                Err(CircuitBreakerError::OperationError(error))
            }
        }
    }
    
    async fn get_status(&self) -> serde_json::Value {
        let stats = self.stats.lock().await;
        let now = Instant::now();
        
        serde_json::json!({
            "state": match self.state {
                CircuitBreakerState::Closed => "closed",
                CircuitBreakerState::Open => "open",
                CircuitBreakerState::HalfOpen => "half_open",
            },
            "total_requests": stats.total_requests,
            "success_requests": stats.success_requests,
            "failure_requests": stats.failure_requests,
            "success_rate": if stats.total_requests > 0 {
                stats.success_requests as f64 / stats.total_requests as f64
            } else { 0.0 },
            "failure_rate": if stats.total_requests > 0 {
                stats.failure_requests as f64 / stats.total_requests as f64
            } else { 0.0 },
            "recent_failure_rate": stats.get_recent_failure_rate(),
            "last_state_change_seconds_ago": now.duration_since(self.last_state_change).as_secs()
        })
    }
}

// 熔断器错误类型
#[derive(Debug)]
enum CircuitBreakerError<E> {
    CircuitOpen,
    OperationError(E),
}

impl<E: std::error::Error> std::fmt::Display for CircuitBreakerError<E> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            CircuitBreakerError::CircuitOpen => {
                write!(f, "熔断器开启，请求被拒绝")
            }
            CircuitBreakerError::OperationError(e) => {
                write!(f, "操作错误: {}", e)
            }
        }
    }
}

impl<E: std::error::Error> std::error::Error for CircuitBreakerError<E> {}

// 熔断器中间件
async fn circuit_breaker_middleware(
    req: HttpRequest,
    service_name: web::Path<String>,
    next: web::Next,
    circuit_breaker: web::Data<Arc<CircuitBreaker>>,
) -> Result<HttpResponse, actix_web::Error> {
    // 执行熔断器保护的请求
    let service_name = service_name.to_string();
    
    let result = circuit_breaker.execute(|| {
        Box::pin(async move {
            // 模拟调用外部服务
            let client = reqwest::Client::new();
            let response = client
                .get(format!("http://{}/health", service_name))
                .send()
                .await
                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
            
            let status = response.status();
            let body = response.text().await
                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
            
            if !status.is_success() {
                return Err(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    format!("服务返回错误状态: {}", status)
                ));
            }
            
            Ok(body)
        })
    }).await;
    
    // 根据熔断器结果返回响应
    match result {
        Ok(response) => {
            Ok(HttpResponse::Ok()
                .insert_header(("X-CircuitBreaker", "closed"))
                .json(serde_json::json!({
                    "status": "success",
                    "response": response,
                    "timestamp": chrono::Utc::now()
                })))
        }
        Err(CircuitBreakerError::CircuitOpen) => {
            log::warn!("熔断器开启，拒绝请求到服务: {}", service_name);
            Ok(HttpResponse::ServiceUnavailable()
                .insert_header(("X-CircuitBreaker", "open"))
                .json(serde_json::json!({
                    "error": "服务当前不可用，熔断器开启",
                    "service": service_name,
                    "timestamp": chrono::Utc::now()
                })))
        }
        Err(CircuitBreakerError::OperationError(e)) => {
            log::error!("服务请求失败: {}", e);
            Ok(HttpResponse::InternalServerError()
                .insert_header(("X-CircuitBreaker", "closed"))
                .json(serde_json::json!({
                    "error": e.to_string(),
                    "service": service_name,
                    "timestamp": chrono::Utc::now()
                })))
        }
    }
}
}

总结

在本章的扩展内容中，我们深入探讨了微服务部署的高级实践，包括：

部署策略：深入了解了滚动更新、蓝绿部署和金丝雀发布的实现细节和Rust实现示例
服务治理：实现了限流、重试和熔断器等关键的服务治理策略

这些技术是构建高可用、可扩展微服务系统的关键组件。通过掌握这些高级部署和治理策略，您可以确保微服务系统在生产环境中的稳定性和性能，满足企业级应用的需求。

Rust的性能优势和安全性使其成为微服务架构的理想选择，通过结合本章介绍的部署和治理技术，您可以构建健壮、可靠且易于维护的微服务系统，满足现代企业级应用的需求。## 跨服务通信与容错

在微服务架构中，服务间通信是关键要素。在本节中，我们将深入探讨服务间通信模式和容错策略的Rust实现。

gRPC通信模式

gRPC是一种高性能的RPC框架，使用HTTP/2进行传输，支持多种编程语言。以下是一个使用Rust实现gRPC通信的示例：

use tokio::sync::mpsc;
use tonic::{transport::Server, Request, Response, Status};
use hello_world::greeter_server::{Greeter, GreeterServer};
use hello_world::{HelloRequest, HelloResponse};

pub mod hello_world {
    tonic::include_proto!("helloworld");
}

#[derive(Debug, Default)]
pub struct MyGreeter {}

#[tonic::async_trait]
impl Greeter for MyGreeter {
    async fn say_hello(
        &self,
        request: Request<HelloRequest>,
    ) -> Result<Response<HelloResponse>, Status> {
        println!("Got a request from {:?}", request.remote_addr());
        
        let reply = HelloResponse {
            message: format!("Hello {}!", request.into_inner().name).into(),
        };
        Ok(Response::new(reply))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let addr = "[::1]:50051".parse()?;
    let greeter = MyGreeter::default();
    
    println!("Greeter server listening on {}", addr);
    
    Server::builder()
        .add_service(GreeterServer::new(greeter))
        .serve(addr)
        .await?;
    
    Ok(())
}

在客户端使用gRPC：

#![allow(unused)]
fn main() {
use hello_world::{greeter_client::GreeterClient, HelloRequest};
use tonic::transport::Channel;

async fn run_client() -> Result<(), Box<dyn std::error::Error>> {
    let channel = Channel::from_static("http://[::1]:50051")
        .connect()
        .await?;
    
    let mut client = GreeterClient::new(channel);
    
    let request = tonic::Request::new(HelloRequest {
        name: "Tonic".into(),
    });
    
    let response = client.say_hello(request).await?;
    
    println!("RESPONSE={:?}", response);
    
    Ok(())
}
}

异步消息传递

在微服务系统中，异步消息传递是实现服务间解耦的重要方式。以下是一个使用Rust异步消息传递的示例：

use tokio::sync::{mpsc, oneshot};
use tokio::time::{timeout, Duration};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Message {
    Request {
        id: u64,
        service: String,
        payload: Vec<u8>,
        reply_to: oneshot::Sender<Result<Vec<u8>, String>>,
    },
    Response {
        id: u64,
        result: Result<Vec<u8>, String>,
    },
    PoisonPill,
}

// 消息代理
struct MessageBroker {
    rx: mpsc::UnboundedReceiver<Message>,
    services: std::collections::HashMap<String, mpsc::UnboundedSender<Message>>,
    pending_requests: std::collections::HashMap<u64, oneshot::Sender<Result<Vec<u8>, String>>>,
    request_counter: u64,
}

impl MessageBroker {
    fn new(rx: mpsc::UnboundedReceiver<Message>) -> Self {
        Self {
            rx,
            services: std::collections::HashMap::new(),
            pending_requests: std::collections::HashMap::new(),
            request_counter: 0,
        }
    }
    
    fn register_service(&mut self, name: &str, sender: mpsc::UnboundedSender<Message>) {
        self.services.insert(name.to_string(), sender);
    }
    
    async fn run(&mut self) {
        while let Some(message) = self.rx.recv().await {
            match message {
                Message::Request { id, service, payload, reply_to } => {
                    // 检查服务是否存在
                    if let Some(service_sender) = self.services.get(&service) {
                        // 存储回复通道
                        self.pending_requests.insert(id, reply_to);
                        
                        // 转发请求到服务
                        let request = Message::Request {
                            id,
                            service: "client".to_string(), // 标识发送方
                            payload,
                            reply_to: oneshot::channel().0, // 临时占位
                        };
                        
                        if let Err(_) = service_sender.send(request) {
                            // 服务不可用，返回错误
                            let _ = reply_to.send(Err(format!("服务 {} 不可用", service)));
                            self.pending_requests.remove(&id);
                        }
                    } else {
                        // 服务不存在，返回错误
                        let _ = reply_to.send(Err(format!("服务 {} 不存在", service)));
                    }
                }
                Message::Response { id, result } => {
                    // 查找等待响应的请求
                    if let Some(reply_to) = self.pending_requests.remove(&id) {
                        let _ = reply_to.send(result);
                    }
                }
                Message::PoisonPill => {
                    // 优雅关闭
                    break;
                }
            }
        }
    }
    
    async fn send_request(&self, service: &str, payload: Vec<u8>) -> Result<Vec<u8>, String> {
        let (reply_tx, reply_rx) = oneshot::channel();
        let id = self.request_counter + 1;
        
        let request = Message::Request {
            id,
            service: service.to_string(),
            payload,
            reply_to: reply_tx,
        };
        
        // 发送请求到代理
        // 这里需要一种方式来访问代理的发送通道
        // 在实际实现中，可能需要将这个逻辑集成到 MessageBroker 中
        
        // 等待响应
        match timeout(Duration::from_secs(5), reply_rx).await {
            Ok(result) => result.map_err(|e| e.to_string()),
            Err(_) => Err("请求超时".to_string()),
        }
    }
}

// 模拟服务
async fn service_handler(name: &str, mut rx: mpsc::UnboundedReceiver<Message>) {
    println!("服务 {} 已启动", name);
    
    while let Some(message) = rx.recv().await {
        match message {
            Message::Request { id, service, payload, .. } => {
                println!("服务 {} 收到请求 from {}, payload: {:?} bytes", 
                    name, service, payload.len());
                
                // 模拟处理时间
                tokio::time::sleep(Duration::from_millis(100)).await;
                
                // 构造响应
                let response = format!("响应 from {} to {}", name, service).into_bytes();
                
                // 发送响应（这里需要代理的响应通道）
                // 实际实现中需要知道如何返回响应
            }
            _ => {}
        }
    }
    
    println!("服务 {} 已关闭", name);
}

// 消息总线
struct MessageBus {
    broker_tx: mpsc::UnboundedSender<Message>,
    broker_rx: Option<mpsc::UnboundedReceiver<Message>>,
}

impl MessageBus {
    fn new() -> Self {
        let (broker_tx, broker_rx) = mpsc::unbounded_channel();
        
        Self {
            broker_tx,
            broker_rx: Some(broker_rx),
        }
    }
    
    fn get_broker(&mut self) -> MessageBroker {
        let rx = self.broker_rx.take().expect("Broker already taken");
        MessageBroker::new(rx)
    }
    
    fn get_sender(&self) -> mpsc::UnboundedSender<Message> {
        self.broker_tx.clone()
    }
    
    async fn send(&self, message: Message) -> Result<(), mpsc::UnboundedSendError<Message>> {
        self.broker_tx.send(message)
    }
}

// 主函数
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 初始化日志
    env_logger::init();
    
    let mut bus = MessageBus::new();
    let mut broker = bus.get_broker();
    
    // 启动代理
    let broker_handle = tokio::spawn(async move {
        broker.run().await;
    });
    
    // 注册服务
    let (service1_tx, service1_rx) = mpsc::unbounded_channel();
    bus.send(Message::Request {
        id: 1,
        service: "service1".to_string(),
        payload: vec![],
        reply_to: oneshot::channel().0,
    }).ok(); // 忽略错误
    
    bus.send(Message::Request {
        id: 2,
        service: "service2".to_string(),
        payload: vec![],
        reply_to: oneshot::channel().0,
    }).ok(); // 忽略错误
    
    // 启动服务处理器
    let service1_handle = tokio::spawn(service_handler("service1", service1_rx));
    
    // 发送测试请求
    let response = bus.send(Message::Request {
        id: 1,
        service: "service1".to_string(),
        payload: b"Hello, Service1!".to_vec(),
        reply_to: oneshot::channel().0,
    });
    
    // 等待所有任务完成
    let _ = tokio::join!(
        broker_handle,
        service1_handle
    );
    
    Ok(())
}

容错和降级策略

在微服务系统中，容错和降级策略是确保系统韧性的重要手段。以下是一个实现容错和降级策略的Rust示例：

use std::collections::HashMap;
use std::time::{Duration, Instant};

// 降级策略配置
#[derive(Clone)]
struct FallbackConfig {
    // 缓存TTL
    cache_ttl: Duration,
    // 默认响应
    default_response: Vec<u8>,
    // 降级检查间隔
    health_check_interval: Duration,
}

// 健康检查结果
#[derive(Debug, Clone)]
enum HealthStatus {
    Healthy,
    Unhealthy(String),
    Unknown,
}

// 降级服务
struct FallbackService {
    name: String,
    primary_endpoint: String,
    fallback_endpoint: Option<String>,
    config: FallbackConfig,
    health_status: HealthStatus,
    last_health_check: Instant,
    cache: HashMap<String, (Vec<u8>, Instant)>,
}

impl FallbackService {
    fn new(
        name: String,
        primary_endpoint: String,
        config: FallbackConfig,
    ) -> Self {
        Self {
            name,
            primary_endpoint,
            fallback_endpoint: None,
            config,
            health_status: HealthStatus::Unknown,
            last_health_check: Instant::now(),
            cache: HashMap::new(),
        }
    }
    
    fn with_fallback(mut self, fallback_endpoint: String) -> Self {
        self.fallback_endpoint = Some(fallback_endpoint);
        self
    }
    
    async fn call(&mut self, request: &[u8]) -> Result<Vec<u8>, String> {
        // 检查主服务健康状态
        self.check_health().await;
        
        // 根据健康状态选择端点
        let endpoint = match &self.health_status {
            HealthStatus::Healthy => &self.primary_endpoint,
            _ => {
                if let Some(fallback) = &self.fallback_endpoint {
                    log::warn!("使用降级端点: {}", fallback);
                    fallback
                } else {
                    return self.get_cached_response(request).await
                        .or_else(|| self.get_default_response())
                        .ok_or("服务不可用且无降级方案".to_string());
                }
            }
        };
        
        // 发送请求
        let response = self.send_request(endpoint, request).await;
        
        match response {
            Ok(response) => {
                // 缓存响应
                self.cache_response(request, &response).await;
                Ok(response)
            }
            Err(error) => {
                log::error!("请求失败: {}", error);
                
                // 尝试降级方案
                if let Some(fallback) = &self.fallback_endpoint {
                    log::warn("尝试降级端点: {}", fallback);
                    let fallback_response = self.send_request(fallback, request).await;
                    
                    match fallback_response {
                        Ok(response) => {
                            self.cache_response(request, &response).await;
                            Ok(response)
                        }
                        Err(fallback_error) => {
                            // 降级也失败，尝试缓存或默认响应
                            self.get_cached_response(request).await
                                .or_else(|| self.get_default_response())
                                .ok_or(format!("主服务错误: {}, 降级错误: {}", error, fallback_error))
                        }
                    }
                } else {
                    // 尝试缓存或默认响应
                    self.get_cached_response(request).await
                        .or_else(|| self.get_default_response())
                        .ok_or(error)
                }
            }
        }
    }
    
    async fn check_health(&mut self) {
        let now = Instant::now();
        
        // 检查是否需要健康检查
        if now.duration_since(self.last_health_check) < self.config.health_check_interval {
            return;
        }
        
        self.last_health_check = now;
        
        // 发送健康检查请求
        let health_url = format!("{}/health", self.primary_endpoint);
        let response = reqwest::get(&health_url).await;
        
        self.health_status = match response {
            Ok(resp) => {
                if resp.status().is_success() {
                    HealthStatus::Healthy
                } else {
                    HealthStatus::Unhealthy(format!("HTTP {}", resp.status()))
                }
            }
            Err(e) => {
                HealthStatus::Unhealthy(e.to_string())
            }
        };
        
        log::info!("服务 {} 健康状态: {:?}", self.name, self.health_status);
    }
    
    async fn send_request(&self, endpoint: &str, request: &[u8]) -> Result<Vec<u8>, String> {
        let client = reqwest::Client::new();
        let response = client
            .post(endpoint)
            .body(request.to_vec())
            .send()
            .await
            .map_err(|e| e.to_string())?;
        
        if !response.status().is_success() {
            return Err(format!("HTTP {}", response.status()));
        }
        
        response
            .bytes()
            .await
            .map(|b| b.to_vec())
            .map_err(|e| e.to_string())
    }
    
    async fn cache_response(&mut self, request: &[u8], response: &[u8]) {
        let key = self.generate_cache_key(request);
        self.cache.insert(key, (response.to_vec(), Instant::now()));
    }
    
    async fn get_cached_response(&self, request: &[u8]) -> Option<Vec<u8>> {
        let key = self.generate_cache_key(request);
        
        if let Some((response, timestamp)) = self.cache.get(&key) {
            if timestamp.elapsed() < self.config.cache_ttl {
                return Some(response.clone());
            }
        }
        
        None
    }
    
    fn get_default_response(&self) -> Option<Vec<u8>> {
        Some(self.config.default_response.clone())
    }
    
    fn generate_cache_key(&self, request: &[u8]) -> String {
        use std::collections::hash_map::DefaultHasher;
        use std::hash::{Hash, Hasher};
        
        let mut hasher = DefaultHasher::new();
        request.hash(&hasher);
        format!("{}-{}", self.name, hasher.finish())
    }
}

// 降级策略管理器
struct FallbackManager {
    services: HashMap<String, FallbackService>,
    config: FallbackConfig,
}

impl FallbackManager {
    fn new(config: FallbackConfig) -> Self {
        Self {
            services: HashMap::new(),
            config,
        }
    }
    
    fn register_service(&mut self, name: &str, primary_endpoint: &str) -> &mut FallbackService {
        self.services.entry(name.to_string()).or_insert_with(|| {
            FallbackService::new(
                name.to_string(),
                primary_endpoint.to_string(),
                self.config.clone(),
            )
        })
    }
    
    async fn call_service(&mut self, name: &str, request: &[u8]) -> Result<Vec<u8>, String> {
        if let Some(service) = self.services.get_mut(name) {
            service.call(request).await
        } else {
            Err(format!("服务 {} 未注册", name))
        }
    }
}

// 降级代理服务器
async fn fallback_proxy(
    mut req: HttpRequest,
    service_name: web::Path<String>,
    manager: web::Data<Arc<Mutex<FallbackManager>>>,
) -> Result<HttpResponse, actix_web::Error> {
    let service_name = service_name.into_inner();
    let body = req.body().await?;
    
    let result = {
        let mut manager = manager.lock().await;
        manager.call_service(&service_name, &body).await
    };
    
    match result {
        Ok(response) => {
            Ok(HttpResponse::Ok()
                .insert_header(("X-Fallback", "none"))
                .body(response))
        }
        Err(error) => {
            log::error!("服务调用失败: {}", error);
            Ok(HttpResponse::ServiceUnavailable()
                .insert_header(("X-Fallback", "active"))
                .json(serde_json::json!({
                    "error": error,
                    "service": service_name,
                    "timestamp": chrono::Utc::now()
                })))
        }
    }
}

// 健康检查端点
async fn service_health(
    service_name: web::Path<String>,
    manager: web::Data<Arc<Mutex<FallbackManager>>>,
) -> impl Responder {
    let service_name = service_name.into_inner();
    let manager = manager.lock().await;
    
    if let Some(service) = manager.services.get(&service_name) {
        HttpResponse::Ok().json(serde_json::json!({
            "service": service_name,
            "status": match &service.health_status {
                HealthStatus::Healthy => "healthy",
                HealthStatus::Unhealthy(reason) => "unhealthy",
                HealthStatus::Unknown => "unknown",
            },
            "health_status": match &service.health_status {
                HealthStatus::Healthy => "healthy",
                HealthStatus::Unhealthy(reason) => format!("unhealthy: {}", reason),
                HealthStatus::Unknown => "unknown",
            }
        }))
    } else {
        HttpResponse::NotFound().json(serde_json::json!({
            "error": format!("服务 {} 未找到", service_name)
        }))
    }
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 初始化日志
    env_logger::init();
    
    // 创建降级管理器
    let config = FallbackConfig {
        cache_ttl: Duration::from_secs(300), // 5分钟缓存
        default_response: b"Service temporarily unavailable".to_vec(),
        health_check_interval: Duration::from_secs(30), // 30秒健康检查间隔
    };
    
    let manager = Arc::new(Mutex::new(FallbackManager::new(config)));
    
    // 注册服务
    {
        let mut manager = manager.lock().await;
        manager.register_service("user-service", "http://localhost:8081")
            .with_fallback("http://fallback-user-service:8081".to_string());
        manager.register_service("product-service", "http://localhost:8082");
        manager.register_service("order-service", "http://localhost:8083");
    }
    
    // 启动HTTP服务器
    HttpServer::new(move || {
        App::new()
            .app_data(Arc::clone(&manager))
            .route("/api/{service}", web::post().to(fallback_proxy))
            .route("/health/{service}", web::get().to(service_health))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

服务版本管理

在微服务架构中，版本管理是确保系统演进和向后兼容性的重要手段。以下是一个实现服务版本管理的Rust示例：

use std::collections::HashMap;
use semver::{Version, VersionReq};

// 版本策略
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum VersioningStrategy {
    // 路径版本控制 (如 /v1/users)
    PathBased,
    // 头部版本控制 (如 Accept: application/vnd.myapi.v1+json)
    HeaderBased,
    // 查询参数版本控制 (如 ?version=1)
    QueryParamBased,
}

// 版本信息
#[derive(Debug, Clone)]
struct VersionInfo {
    version: Version,
    endpoint: String,
    is_deprecated: bool,
    deprecation_date: Option<chrono::DateTime<chrono::Utc>>,
    sunset_date: Option<chrono::DateTime<chrono::Utc>>,
}

// 版本管理器
struct VersionManager {
    services: HashMap<String, Vec<VersionInfo>>,
    default_version: Version,
    versioning_strategy: VersioningStrategy,
    // 版本兼容性规则
    compatibility_rules: HashMap<(Version, Version), bool>,
}

impl VersionManager {
    fn new(
        default_version: Version,
        versioning_strategy: VersioningStrategy,
    ) -> Self {
        let mut compatibility_rules = HashMap::new();
        
        // 定义向后兼容性规则
        // 例如: v1.0 兼容 v1.1
        compatibility_rules.insert((Version::new(1, 0, 0), Version::new(1, 1, 0)), true);
        compatibility_rules.insert((Version::new(1, 1, 0), Version::new(1, 2, 0)), true);
        
        Self {
            services: HashMap::new(),
            default_version,
            versioning_strategy,
            compatibility_rules,
        }
    }
    
    fn register_service_version(
        &mut self,
        service_name: &str,
        version: Version,
        endpoint: String,
    ) {
        let service_versions = self.services.entry(service_name.to_string()).or_default();
        
        // 检查是否已存在该版本
        if !service_versions.iter().any(|v| v.version == version) {
            service_versions.push(VersionInfo {
                version,
                endpoint,
                is_deprecated: false,
                deprecation_date: None,
                sunset_date: None,
            });
        }
    }
    
    fn deprecate_version(
        &mut self,
        service_name: &str,
        version: &Version,
        deprecation_date: chrono::DateTime<chrono::Utc>,
        sunset_date: Option<chrono::DateTime<chrono::Utc>>,
    ) {
        if let Some(service_versions) = self.services.get_mut(service_name) {
            if let Some(version_info) = service_versions.iter_mut().find(|v| v.version == *version) {
                version_info.is_deprecated = true;
                version_info.deprecation_date = Some(deprecation_date);
                version_info.sunset_date = sunset_date;
            }
        }
    }
    
    fn get_best_version(
        &self,
        service_name: &str,
        requested_version: Option<&VersionReq>,
    ) -> Result<Version, String> {
        let service_versions = self.services.get(service_name)
            .ok_or(format!("服务 {} 未找到", service_name))?;
        
        if let Some(version_req) = requested_version {
            // 找到匹配版本要求的最新版本
            let mut matching_versions: Vec<&VersionInfo> = service_versions
                .iter()
                .filter(|v| {
                    // 过滤掉已弃用且超过日落日期的版本
                    if v.is_deprecated {
                        if let Some(sunset) = v.sunset_date {
                            if chrono::Utc::now() > sunset {
                                return false;
                            }
                        }
                    }
                    
                    // 检查版本要求
                    version_req.matches(&v.version)
                })
                .collect();
            
            if matching_versions.is_empty() {
                return Err(format!("没有版本满足要求: {}", version_req));
            }
            
            // 返回最新匹配的版本
            matching_versions.sort_by(|a, b| b.version.cmp(&a.version));
            Ok(matching_versions[0].version.clone())
        } else {
            // 如果没有指定版本要求，返回最新版本
            let mut versions = service_versions.iter()
                .filter(|v| {
                    // 过滤掉已弃用且超过日落日期的版本
                    if v.is_deprecated {
                        if let Some(sunset) = v.sunset_date {
                            if chrono::Utc::now() > sunset {
                                return false;
                            }
                        }
                    }
                    
                    true
                })
                .collect::<Vec<_>>();
            
            if versions.is_empty() {
                return Err("没有可用版本".to_string());
            }
            
            versions.sort_by(|a, b| b.version.cmp(&a.version));
            Ok(versions[0].version.clone())
        }
    }
    
    fn get_endpoint(&self, service_name: &str, version: &Version) -> Option<String> {
        self.services.get(service_name)
            .and_then(|versions| {
                versions.iter()
                    .find(|v| v.version == *version)
                    .map(|v| v.endpoint.clone())
            })
    }
    
    fn is_compatible(&self, from: &Version, to: &Version) -> bool {
        // 首先检查显式定义的兼容性规则
        if let Some(&compatible) = self.compatibility_rules.get(&(*from, *to)) {
            return compatible;
        }
        
        // 通用向后兼容性检查
        // 1. 相同主版本号，较小或相等的次版本号
        if from.major == to.major && from.minor <= to.minor {
            return true;
        }
        
        // 2. 主版本号变化，但次版本号向后兼容
        if from.major + 1 == to.major && to.minor == 0 {
            return true;
        }
        
        false
    }
    
    fn get_supported_versions(&self, service_name: &str) -> Vec<Version> {
        self.services.get(service_name)
            .map(|versions| {
                versions.iter()
                    .filter(|v| {
                        // 过滤掉已弃用且超过日落日期的版本
                        if v.is_deprecated {
                            if let Some(sunset) = v.sunset_date {
                                if chrono::Utc::now() > sunset {
                                    return false;
                                }
                            }
                        }
                        
                        true
                    })
                    .map(|v| v.version.clone())
                    .collect()
            })
            .unwrap_or_default()
    }
}

// 版本感知的HTTP服务器
async fn version_aware_proxy(
    mut req: HttpRequest,
    path: web::Path<(String, String)>, // (service, version)
    manager: web::Data<Arc<Mutex<VersionManager>>>,
) -> Result<HttpResponse, actix_web::Error> {
    let (service, version) = path.into_inner();
    let version: Version = version.parse()
        .map_err(|_| HttpResponse::BadRequest().json("Invalid version format"))?;
    
    // 解析版本要求
    let version_req = if let Some(accept_header) = req.headers().get("Accept") {
        if let Ok(accept_str) = accept_header.to_str() {
            // 解析Accept头部中的版本要求
            parse_accept_header(accept_str, &service)
        } else {
            None
        }
    } else {
        None
    };
    
    // 获取最佳版本
    let best_version = {
        let manager = manager.lock().await;
        manager.get_best_version(&service, version_req.as_ref())
    };
    
    let best_version = match best_version {
        Ok(v) => v,
        Err(e) => return Ok(HttpResponse::BadRequest().json(e)),
    };
    
    // 检查版本兼容性
    let is_compatible = {
        let manager = manager.lock().await;
        manager.is_compatible(&version, &best_version)
    };
    
    if !is_compatible && version != best_version {
        return Ok(HttpResponse::BadRequest().json(format!(
            "版本不兼容: 请求 {}, 推荐 {}",
            version, best_version
        )));
    }
    
    // 获取目标端点
    let endpoint = {
        let manager = manager.lock().await;
        manager.get_endpoint(&service, &best_version)
    };
    
    let endpoint = match endpoint {
        Some(ep) => ep,
        None => return Ok(HttpResponse::NotFound().json("服务未找到")),
    };
    
    // 转发请求
    let body = req.body().await?;
    let method = req.method().clone();
    let url = format!("{}{}", endpoint, req.uri().to_string());
    
    let client = reqwest::Client::new();
    let response = client
        .request(method, &url)
        .headers(req.headers().clone())
        .body(body)
        .send()
        .await
        .map_err(|e| HttpResponse::ServiceUnavailable().json(e.to_string()))?;
    
    let status = response.status();
    let headers = response.headers().clone();
    let body = response.bytes().await
        .map_err(|e| HttpResponse::InternalServerError().json(e.to_string()))?;
    
    // 构建响应
    let mut response_builder = HttpResponse::build(status);
    
    // 复制响应头部
    for (key, value) in headers.iter() {
        if key != "content-length" && key != "transfer-encoding" {
            response_builder.insert_header((key.as_str(), value.clone()));
        }
    }
    
    // 添加版本信息头部
    response_builder.insert_header(("X-API-Version", best_version.to_string()));
    response_builder.insert_header(("X-Original-Version", version.to_string()));
    
    Ok(response_builder.body(body))
}

// 解析Accept头部
fn parse_accept_header(accept: &str, service: &str) -> Option<VersionReq> {
    // 简单的Accept头部解析示例
    // 实际实现中需要更复杂的解析逻辑
    for media_type in accept.split(',') {
        let parts: Vec<&str> = media_type.trim().split(';').collect();
        if parts[0].contains(&format!("{}+json", service)) {
            // 查找版本参数
            for part in &parts[1..] {
                let kv: Vec<&str> = part.split('=').collect();
                if kv.len() == 2 && kv[0].trim() == "version" {
                    if let Ok(req) = VersionReq::parse(kv[1].trim()) {
                        return Some(req);
                    }
                }
            }
        }
    }
    
    None
}

// 版本信息端点
async fn get_versions(
    service_name: web::Path<String>,
    manager: web::Data<Arc<Mutex<VersionManager>>>,
) -> impl Responder {
    let service_name = service_name.into_inner();
    let manager = manager.lock().await;
    
    let versions = manager.get_supported_versions(&service_name);
    let default_version = manager.default_version.clone();
    
    HttpResponse::Ok().json(serde_json::json!({
        "service": service_name,
        "versions": versions.iter().map(|v| v.to_string()).collect::<Vec<_>>(),
        "default_version": default_version.to_string()
    }))
}

#[tokio::main]
async fn main() -> std::io::Result<()> {
    // 初始化日志
    env_logger::init();
    
    // 创建版本管理器
    let version_manager = Arc::new(Mutex::new(VersionManager::new(
        Version::new(1, 0, 0),
        VersioningStrategy::HeaderBased,
    )));
    
    // 注册服务版本
    {
        let mut manager = version_manager.lock().await;
        manager.register_service_version("user-service", Version::new(1, 0, 0), "http://localhost:8081".to_string());
        manager.register_service_version("user-service", Version::new(1, 1, 0), "http://localhost:8081".to_string());
        manager.register_service_version("user-service", Version::new(2, 0, 0), "http://localhost:8082".to_string());
        
        // 标记v1.0为已弃用
        let now = chrono::Utc::now();
        manager.deprecate_version("user-service", &Version::new(1, 0, 0), now, Some(now + chrono::Duration::days(90)));
    }
    
    // 启动HTTP服务器
    HttpServer::new(move || {
        App::new()
            .app_data(Arc::clone(&version_manager))
            .route("/api/{service}/{version}", web::all().to(version_aware_proxy))
            .route("/versions/{service}", web::get().to(get_versions))
    })
    .bind("0.0.0.0:8080")?
    .run()
    .await
}

服务发现与配置管理

服务发现是微服务架构中的关键组件，它允许服务动态地发现和连接其他服务。以下是一个实现服务发现和配置管理的Rust示例：

use std::collections::HashMap;
use std::time::{Duration, Instant};
use serde::{Deserialize, Serialize};
use actix_web::{web, App, HttpResponse, HttpServer, Responder};

// 服务信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ServiceInfo {
    pub name: String,
    pub address: String,
    pub port: u16,
    pub health_check_url: Option<String>,
    pub metadata: HashMap<String, String>,
    pub last_heartbeat: Instant,
}

// 服务注册表
struct ServiceRegistry {
    services: HashMap<String, Vec<ServiceInfo>>,
    health_checker: HealthChecker,
}

impl ServiceRegistry {
    fn new() -> Self {
        Self {
            services: HashMap::new(),
            health_checker: HealthChecker::new(),
        }
    }
    
    fn register_service(&mut self, service: ServiceInfo) {
        let service_list = self.services.entry(service.name.clone()).or_default();
        
        // 检查是否已存在相同地址的服务
        let existing_index = service_list.iter()
            .position(|s| s.address == service.address && s.port == service.port);
        
        if let Some(index) = existing_index {
            // 更新现有服务
            service_list[index] = service;
        } else {
            // 添加新服务
            service_list.push(service);
        }
    }
    
    fn deregister_service(&mut self, name: &str, address: &str, port: u16) {
        if let Some(service_list) = self.services.get_mut(name) {
            service_list.retain(|s| !(s.address == address && s.port == port));
        }
    }
    
    fn get_services(&self, name: &str) -> Option<&Vec<ServiceInfo>> {
        self.services.get(name)
    }
    
    fn get_all_services(&self) -> &HashMap<String, Vec<ServiceInfo>> {
        &self.services
    }
    
    async fn health_check(&mut self) {
        // 清理过期的服务
        for service_list in self.services.values_mut() {
            service_list.retain(|service| {
                let is_healthy = service.last_heartbeat.elapsed() < Duration::from_secs(30);
                if !is_healthy {
                    log::warn!("移除不健康的服务: {}:{}:{}", 
                        service.name, service.address, service.port);
                }
                is_healthy
            });
        }
    }
}

// 健康检查器
struct HealthChecker {
    client: reqwest::Client,
}

impl HealthChecker {
    fn new() -> Self {
        Self {
            client: reqwest::Client::new(),
        }
    }
    
    async fn check_health(&self, service: &ServiceInfo) -> bool {
        if let Some(health_url) = &service.health_check_url {
            match self.client.get(health_url).send().await {
                Ok(response) => response.status().is_success(),
                Err(_) => false,
            }
        } else {
            // 如果没有指定健康检查URL，假设服务健康
            true
        }
    }
}

// 配置信息
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConfigItem {
    pub key: String,
    pub value: String,
    pub config_type: ConfigType,
    pub last_updated: Instant,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ConfigType {
    String,
    Number,
    Boolean,
    Json,
}

// 配置管理器
struct ConfigManager {
    configs: HashMap<String, ConfigItem>,
}

impl ConfigManager {
    fn new() -> Self {
        Self {
            configs: HashMap::new(),
        }
    }
    
    fn set_config(&mut self, config: ConfigItem) {
        self.configs.insert(config.key.clone(), config);
    }
    
    fn get_config(&self, key: &str) -> Option<&ConfigItem> {
        self.configs.get(key)
    }
    
    fn get_configs_by_prefix(&self, prefix: &str) -> Vec<&ConfigItem> {
        self.configs.values()
            .filter(|config| config.key.starts_with(prefix))
            .collect()
    }
    
    fn delete_config(&mut self, key: &str) {
        self.configs.remove(key);
    }
}

// 服务发现服务器
async fn service_discovery_server() {
    let mut registry = ServiceRegistry::new();
    let mut config_manager = ConfigManager::new();
    
    // 添加默认配置
    config_manager.set_config(ConfigItem {
        key: "app.name".to_string(),
        value: "My Application".to_string(),
        config_type: ConfigType::String,
        last_updated: Instant::now(),
    });
    
    config_manager.set_config(ConfigItem {
        key: "app.version".to_string(),
        value: "1.0.0".to_string(),
        config_type: ConfigType::String,
        last_updated: Instant::now(),
    });
    
    config_manager.set_config(ConfigItem {
        key: "app.debug".to_string(),
        value: "false".to_string(),
        config_type: ConfigType::Boolean,
        last_updated: Instant::now(),
    });
    
    // 定期健康检查
    let registry_clone = Arc::new(tokio::sync::Mutex::new(registry));
    let config_manager_clone = Arc::new(tokio::sync::Mutex::new(config_manager));
    
    tokio::spawn(async move {
        let mut interval = tokio::time::interval(Duration::from_secs(30));
        loop {
            interval.tick().await;
            let mut registry = registry_clone.lock().await;
            registry.health_check().await;
        }
    });
    
    // 启动HTTP服务器
    HttpServer::new(move || {
        App::new()
            .app_data(Arc::clone(&registry_clone))
            .app_data(Arc::clone(&config_manager_clone))
            .route("/register", web::post().to(register_service))
            .route("/deregister", web::post().to(deregister_service))
            .route("/discover/{service}", web::get().to(discover_service))
            .route("/services", web::get().to(list_services))
            .route("/config", web::get().to(get_config))
            .route("/config", web::post().to(set_config))
            .route("/config/{key}", web::delete().to(delete_config))
    })
    .bind("0.0.0.0:8500")?
    .run()
    .await
    .unwrap();
}

// 服务注册端点
async fn register_service(
    service: web::Json<ServiceInfo>,
    registry: web::Data<Arc<tokio::sync::Mutex<ServiceRegistry>>>,
) -> impl Responder {
    let mut registry = registry.lock().await;
    let mut service_info = service.into_inner();
    
    // 更新心跳时间
    service_info.last_heartbeat = Instant::now();
    
    registry.register_service(service_info);
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "success",
        "message": "服务注册成功"
    }))
}

// 服务注销端点
async fn deregister_service(
    req: web::Json<DeregisterRequest>,
    registry: web::Data<Arc<tokio::sync::Mutex<ServiceRegistry>>>,
) -> impl Responder {
    let mut registry = registry.lock().await;
    let request = req.into_inner();
    
    registry.deregister_service(&request.service, &request.address, request.port);
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "success",
        "message": "服务注销成功"
    }))
}

#[derive(Debug, Deserialize)]
struct DeregisterRequest {
    service: String,
    address: String,
    port: u16,
}

// 服务发现端点
async fn discover_service(
    service_name: web::Path<String>,
    registry: web::Data<Arc<tokio::sync::Mutex<ServiceRegistry>>>,
) -> impl Responder {
    let registry = registry.lock().await;
    let service_name = service_name.into_inner();
    
    if let Some(services) = registry.get_services(&service_name) {
        HttpResponse::Ok().json(services)
    } else {
        HttpResponse::NotFound().json(serde_json::json!({
            "error": format!("服务 {} 未找到", service_name)
        }))
    }
}

// 列出所有服务端点
async fn list_services(
    registry: web::Data<Arc<tokio::sync::Mutex<ServiceRegistry>>>,
) -> impl Responder {
    let registry = registry.lock().await;
    let services = registry.get_all_services();
    
    let mut service_list = HashMap::new();
    for (name, service_info) in services {
        service_list.insert(name, service_info);
    }
    
    HttpResponse::Ok().json(service_list)
}

// 获取配置端点
async fn get_config(
    key: Option<web::Query<String>>,
    config_manager: web::Data<Arc<tokio::sync::Mutex<ConfigManager>>>,
) -> impl Responder {
    let config_manager = config_manager.lock().await;
    
    if let Some(key) = key {
        if let Some(config) = config_manager.get_config(&key) {
            HttpResponse::Ok().json(config)
        } else {
            HttpResponse::NotFound().json(serde_json::json!({
                "error": format!("配置项 {} 未找到", key)
            }))
        }
    } else {
        // 返回所有配置
        let configs = config_manager.configs.values().collect::<Vec<_>>();
        HttpResponse::Ok().json(configs)
    }
}

// 设置配置端点
async fn set_config(
    config: web::Json<ConfigItem>,
    config_manager: web::Data<Arc<tokio::sync::Mutex<ConfigManager>>>,
) -> impl Responder {
    let mut config_manager = config_manager.lock().await;
    let mut config_item = config.into_inner();
    
    config_item.last_updated = Instant::now();
    config_manager.set_config(config_item);
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "success",
        "message": "配置设置成功"
    }))
}

// 删除配置端点
async fn delete_config(
    key: web::Path<String>,
    config_manager: web::Data<Arc<tokio::sync::Mutex<ConfigManager>>>,
) -> impl Responder {
    let mut config_manager = config_manager.lock().await;
    let key = key.into_inner();
    
    config_manager.delete_config(&key);
    
    HttpResponse::Ok().json(serde_json::json!({
        "status": "success",
        "message": "配置删除成功"
    }))
}

fn main() {
    // 初始化日志
    env_logger::init();
    
    // 启动服务发现服务器
    let rt = tokio::runtime::Runtime::new().unwrap();
    rt.block_on(service_discovery_server());
}

总结

在本章的进一步扩展中，我们深入探讨了微服务部署的高级实践，包括：

跨服务通信与容错：深入了解了gRPC通信模式、异步消息传递和容错降级策略
服务版本管理：实现了版本感知的服务路由和版本兼容性检查
服务发现与配置管理：构建了服务注册发现系统和动态配置管理

这些技术是构建健壮、可扩展微服务系统的关键组件。通过掌握这些高级部署和管理策略，您可以确保微服务系统在生产环境中的稳定性和性能，满足企业级应用的需求。

Rust的性能优势和安全性使其成为微服务架构的理想选择，通过结合本章介绍的部署和管理技术，您可以构建健壮、可靠且易于维护的微服务系统。

Keyboard shortcuts

Learn Rust through examples