Rust缓存管理库deno_cache_dir的使用指南

deno_cache_dir是一个用于高效管理本地缓存目录的Rust库，特别适合需要持久化缓存数据的应用场景。

功能特点

• 跨平台缓存目录位置自动处理
• 缓存目录的创建与管理
• 遵循各操作系统的缓存存储规范
• 简单的API接口

基本使用方法

添加依赖

首先在Cargo.toml中添加依赖：

[dependencies]
deno_cache_dir = "0.5"

获取缓存目录

use deno_cache_dir::CacheDir;

fn main() {
    // 获取默认缓存目录
    let cache_dir = CacheDir::new("my_app_cache");
    
    // 获取缓存目录路径
    let path = cache_dir.path();
    println!("Cache directory: {:?}", path);
}

创建缓存文件

use std::fs::File;
use std::io::Write;

fn main() -> std::io::Result<()> {
    let cache_dir = CacheDir::new("my_app_cache");
    
    // 在缓存目录中创建文件
    let mut file = File::create(cache_dir.path().join("data.bin"))?;
    file.write_all(b"some cached data")?;
    
    Ok(())
}

高级用法 - 带版本控制的缓存

use deno_cache_dir::CacheDir;

fn main() {
    // 带版本的缓存目录
    let versioned_cache = CacheDir::with_version("my_app", "v1.0");
    
    println!("Versioned cache path: {:?}", versioned_cache.path());
}

清空缓存目录

use deno_cache_dir::CacheDir;
use std::fs;

fn main() -> std::io::Result<()> {
    let cache_dir = CacheDir::new("my_app_cache");
    
    // 删除整个缓存目录
    if cache_dir.path().exists() {
        fs::remove_dir_all(cache_dir.path())?;
    }
    
    // 重新创建目录
    fs::create_dir_all(cache_dir.path())?;
    
    Ok(())
}

实际应用示例

use deno_cache_dir::CacheDir;
use std::fs;
use std::path::PathBuf;

struct AppCache {
    dir: CacheDir,
}

impl AppCache {
    fn new(name: &str) -> Self {
        Self {
            dir: CacheDir::new(name),
        }
    }
    
    fn store_data(&self, key: &str, data: &[u8]) -> std::io::Result<()> {
        let path = self.get_path(key);
        fs::write(path, data)
    }
    
    fn load_data(&self, key: &str) -> std::io::Result<Vec<u8>> {
        let path = self.get_path(key);
        fs::read(path)
    }
    
    fn get_path(&self, key: &str) -> PathBuf {
        self.dir.path().join(key)
    }
}

fn main() -> std::io::Result<()> {
    let cache = AppCache::new("my_application");
    
    // 存储数据
    cache.store_data("user_prefs", b"{theme: \"dark\"}")?;
    
    // 读取数据
    let data = cache.load_data("user_prefs")?;
    println!("Loaded data: {:?}", String::from_utf8_lossy(&data));
    
    Ok(())
}

完整示例demo

下面是一个完整的缓存管理示例，展示了如何使用deno_cache_dir实现一个简单的键值存储缓存系统：

use deno_cache_dir::CacheDir;
use std::fs;
use std::path::PathBuf;
use std::io::{self, Read, Write};
use std::time::{SystemTime, UNIX_EPOCH};

// 缓存管理结构体
struct CacheManager {
    cache_dir: CacheDir,
}

impl CacheManager {
    // 创建新的缓存管理器
    fn new(app_name: &str) -> Self {
        Self {
            cache_dir: CacheDir::new(app_name),
        }
    }
    
    // 带版本号的缓存管理器
    fn with_version(app_name: &str, version: &str) -> Self {
        Self {
            cache_dir: CacheDir::with_version(app_name, version),
        }
    }
    
    // 存储数据到缓存
    fn put(&self, key: &str, data: &[u8]) -> io::Result<()> {
        let path = self.cache_dir.path().join(key);
        fs::write(path, data)
    }
    
    // 从缓存获取数据
    fn get(&self, key: &str) -> io::Result<Vec<u8>> {
        let path = self.cache_dir.path().join(key);
        fs::read(path)
    }
    
    // 检查缓存是否存在
    fn exists(&self, key: &str) -> bool {
        let path = self.cache_dir.path().join(key);
        path.exists()
    }
    
    // 删除缓存项
    fn remove(&self, key: &str) -> io::Result<()> {
        let path = self.cache_dir.path().join(key);
        if path.exists() {
            fs::remove_file(path)
        } else {
            Ok(())
        }
    }
    
    // 清空整个缓存目录
    fn clear(&self) -> io::Result<()> {
        if self.cache_dir.path().exists() {
            fs::remove_dir_all(self.cache_dir.path())?;
            fs::create_dir_all(self.cache_dir.path())?;
        }
        Ok(())
    }
    
    // 获取缓存最后修改时间
    fn last_modified(&self, key: &str) -> io::Result<u64> {
        let path = self.cache_dir.path().join(key);
        let metadata = fs::metadata(path)?;
        let modified = metadata.modified()?;
        Ok(modified.duration_since(UNIX_EPOCH).unwrap().as_secs())
    }
}

fn main() -> io::Result<()> {
    // 创建缓存管理器
    let cache = CacheManager::new("my_app");
    
    // 存储一些数据
    cache.put("config.json", b"{\"theme\":\"dark\",\"font_size\":14}")?;
    
    // 检查数据是否存在
    if cache.exists("config.json") {
        println!("Config exists in cache");
        
        // 获取最后修改时间
        let modified = cache.last_modified("config.json")?;
        println!("Config last modified at: {}", modified);
        
        // 读取数据
        let data = cache.get("config.json")?;
        println!("Config content: {}", String::from_utf8_lossy(&data));
    }
    
    // 清理缓存
    cache.clear()?;
    println!("Cache cleared");
    
    Ok(())
}

注意事项

1. 不同操作系统有不同的缓存目录约定：

   • Linux: ~/.cache
   • macOS: ~/Library/Caches
   • Windows: %LOCALAPPDATA%

2. 缓存数据应该是可以随时重建的非关键数据

3. 对于生产环境应用，建议实现缓存失效和清理策略

deno_cache_dir简化了跨平台缓存管理的工作，让开发者可以专注于业务逻辑而不是文件系统路径处理。