Rust存储管理库fuel-storage的使用指南

fuel-storage是一个高效、灵活的键值存储与数据持久化解决方案，专为Rust生态系统设计。它提供了简单的API和可配置的存储后端，适用于各种应用场景。

主要特性

• 简单的键值存储接口
• 支持多种存储后端（内存、文件系统等）
• 线程安全设计
• 高效的数据序列化
• 可配置的持久化策略

基本使用方法

添加依赖

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

[dependencies]
fuel-storage = "0.1"

基本示例

use fuel_storage::{Storage, MemoryStorage};

fn main() {
    // 创建内存存储实例
    let mut storage = MemoryStorage::<String, String>::new();
    
    // 存储数据
    storage.insert("key1".to_string(), "value1".to_string()).unwrap();
    
    // 获取数据
    if let Some(value) = storage.get(&"key1".to_string()).unwrap() {
        println!("Got value: {}", value);
    }
    
    // 删除数据
    storage.remove(&"key1".to_string()).unwrap();
}

持久化存储示例

fuel-storage也支持文件系统持久化：

use fuel_storage::{Storage, FileStorage};
use std::path::Path;

fn main() {
    // 创建文件存储实例
    let path = Path::new("my_storage.db");
    let mut storage = FileStorage::<String, String>::new(path).unwrap();
    
    // 存储持久化数据
    storage.insert("user:1".to_string(), "Alice".to_string()).unwrap();
    storage.insert("user:2".to_string(), "Bob".to_string()).unwrap();
    
    // 数据会被自动持久化到文件
}

高级用法

自定义序列化

use fuel_storage::{Storage, MemoryStorage};
use serde::{Serialize, Deserialize};

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

fn main() {
    let mut storage = MemoryStorage::<String, User>::new();
    
    let user = User {
        id: 1,
        name: "Charlie".to_string(),
    };
    
    storage.insert("user:1".to_string(), user).unwrap();
    
    if let Some(user) = storage.get(&"user:1".to_string()).unwrap() {
        println!("User: {:?}", user);
    }
}

批量操作

use fuel_storage::{Storage, MemoryStorage};

fn main() {
    let mut storage = MemoryStorage::<String, String>::new();
    
    // 批量插入
    let items = vec![
        ("key1".to_string(), "value1".to_string()),
        ("key2".to_string(), "value2".to_string()),
    ];
    
    storage.batch_insert(items).unwrap();
    
    // 批量获取
    let keys = vec!["key1".to_string(), "key2".to_string()];
    let values = storage.batch_get(&keys).unwrap();
    
    for (key, value) in keys.iter().zip(values.iter()) {
        if let Some(v) = value {
            println!("{}: {}", key, v);
        }
    }
}

完整示例代码

下面是一个结合内存存储和文件存储的完整示例：

use fuel_storage::{Storage, MemoryStorage, FileStorage};
use serde::{Serialize, Deserialize};
use std::path::Path;

#[derive(Serialize, Deserialize, Debug, Clone)]
struct Product {
    id: u32,
    name: String,
    price: f64,
}

fn main() {
    // 内存存储示例
    memory_storage_demo();
    
    // 文件存储示例
    file_storage_demo();
}

fn memory_storage_demo() {
    println!("=== 内存存储示例 ===");
    
    let mut mem_storage = MemoryStorage::<String, Product>::new();
    
    // 插入产品数据
    let product1 = Product {
        id: 1,
        name: "笔记本电脑".to_string(),
        price: 5999.99,
    };
    
    mem_storage.insert("product:1".to_string(), product1.clone()).unwrap();
    
    // 获取产品数据
    if let Some(product) = mem_storage.get(&"product:1".to_string()).unwrap() {
        println!("内存存储获取: {:?}", product);
    }
    
    // 批量操作
    let product2 = Product {
        id: 2,
        name: "智能手机".to_string(),
        price: 2999.99,
    };
    
    let items = vec![
        ("product:2".to_string(), product2),
    ];
    
    mem_storage.batch_insert(items).unwrap();
    
    let keys = vec!["product:1".to_string(), "product:2".to_string()];
    let values = mem_storage.batch_get(&keys).unwrap();
    
    println!("批量获取结果:");
    for (key, value) in keys.iter().zip(values.iter()) {
        if let Some(v) = value {
            println!("{}: {:?}", key, v);
        }
    }
}

fn file_storage_demo() {
    println!("\n=== 文件存储示例 ===");
    
    let path = Path::new("products.db");
    let mut file_storage = FileStorage::<String, Product>::new(path).unwrap();
    
    // 存储产品数据
    let product3 = Product {
        id: 3,
        name: "平板电脑".to_string(),
        price: 1999.99,
    };
    
    file_storage.insert("product:3".to_string(), product3).unwrap();
    
    // 从文件读取数据
    if let Some(product) = file_storage.get(&"product:3".to_string()).unwrap() {
        println!("文件存储获取: {:?}", product);
    }
    
    // 清理测试文件
    std::fs::remove_file(path).ok();
}

性能优化建议

1. 对于高频读写场景，考虑使用DashMap或RwLock包装的存储后端
2. 批量操作通常比单次操作更高效
3. 对于大型值，考虑使用压缩或分块存储

fuel-storage提供了灵活的存储解决方案，可以根据应用需求选择合适的后端和配置。