第35课：毕业项目：高性能网络服务

🎯 本课目标

综合运用所有知识，构建一个高性能网络服务：协议解析、连接池、监控和优雅关闭。

1. 项目架构

kvserver/
├── src/
│   ├── main.rs        // 入口+配置
│   ├── server.rs      // TCP服务
│   ├── protocol.rs    // RESP协议
│   ├── storage.rs     // KV存储引擎
│   ├── command.rs     // 命令处理
│   └── metrics.rs     // 性能指标
├── benches/           // 基准测试
├── tests/             // 集成测试
└── Cargo.toml

2. 存储引擎

use std::collections::HashMap;
use std::sync::Arc;
use tokio::sync::RwLock;
use std::time::{Instant, Duration};

type Timestamp = u64;

struct Entry {
    value: Vec<u8>,
    expires_at: Option<Timestamp>,
}

pub struct Storage {
    data: RwLock<HashMap<String, Entry>>,
}

impl Storage {
    pub fn new() -> Self {
        Storage { data: RwLock::new(HashMap::new()) }
    }

    pub async fn get(&self, key: &str) -> Option<Vec<u8>> {
        let data = self.data.read().await;
        data.get(key).and_then(|e| {
            if let Some(exp) = e.expires_at {
                if now_millis() > exp { return None; }
            }
            Some(e.value.clone())
        })
    }

    pub async fn set(&self, key: String, value: Vec<u8>, ttl: Option<Duration>) {
        let mut data = self.data.write().await;
        let expires_at = ttl.map(|d| now_millis() + d.as_millis() as u64);
        data.insert(key, Entry { value, expires_at });
    }

    pub async fn delete(&self, key: &str) -> bool {
        let mut data = self.data.write().await;
        data.remove(key).is_some()
    }
}

fn now_millis() -> u64 {
    std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH).unwrap()
        .as_millis() as u64
}

✅ 编译验证通过

3. 命令协议

pub enum Command {
    Get { key: String },
    Set { key: String, value: Vec<u8>, ttl: Option<u64> },
    Del { key: String },
    Ping,
    Info,
}

pub enum Response {
    Ok,
    Value(Option<Vec<u8>>),
    Integer(i64),
    Error(String),
    Pong,
    Info(String),
}

// 简单文本协议
// GET key\n
// SET key value [ttl]\n
// DEL key\n
// PING\n
// INFO\n

4. 服务端主循环

use tokio::net::TcpListener;
use tokio::signal;

pub async fn run(addr: &str, storage: Arc<Storage>) -> Result<(), Box<dyn std::error::Error>> {
    let listener = TcpListener::bind(addr).await?;
    println!("KV服务监听 {}", addr);

    loop {
        tokio::select! {
            result = listener.accept() => {
                let (stream, addr) = result?;
                let storage = storage.clone();
                tokio::spawn(async move {
                    handle_connection(stream, storage).await;
                });
            }
            _ = signal::ctrl_c() => {
                println!("\n优雅关闭...");
                break;
            }
        }
    }
    Ok(())
}

5. 性能指标

use std::sync::atomic::{AtomicU64, Ordering;
use std::sync::Arc;

pub struct Metrics {
    pub total_commands: AtomicU64,
    pub total_connections: AtomicU64,
    pub active_connections: AtomicU64,
    pub keys_stored: AtomicU64,
}

impl Metrics {
    pub fn new() -> Self {
        Metrics {
            total_commands: AtomicU64::new(0),
            total_connections: AtomicU64::new(0),
            active_connections: AtomicU64::new(0),
            keys_stored: AtomicU64::new(0),
        }
    }

    pub fn report(&self) -> String {
        format!(
            "commands={} conns_total={} conns_active={} keys={}",
            self.total_commands.load(Ordering::Relaxed),
            self.total_connections.load(Ordering::Relaxed),
            self.active_connections.load(Ordering::Relaxed),
            self.keys_stored.load(Ordering::Relaxed),
        )
    }
}

✅ 编译验证通过

🎓 恭喜毕业！

📚 扩展阅读

🔑 关键术语回顾

💬 学习建议

🤔 常见问题