用 Rust 实现 Redis + 本地缓存的多级缓存方案

不吃草的牛德

发布于 2026-04-23 11:37:19

1030

文章被收录于专栏：RustRust

在高性能 Web 应用中，缓存是提升响应速度、降低数据库压力的关键。多级缓存（本地缓存 + 分布式缓存如 Redis）结合了两者的优势：本地缓存速度快，Redis 提供分布式一致性。本文将带你使用 Rust 实现一个多级缓存方案，结合本地缓存库（如 moka）和 Redis 客户端（如 redis-rs），打造高效、可靠的缓存系统。

本文适合有一定 Rust 基础的开发者，想了解如何在实际项目中应用缓存机制。

为什么需要多级缓存？在高并发场景下，直接查询数据库会导致性能瓶颈。缓存可以显著降低延迟，但单一缓存方案有局限：

本地缓存（如内存中的 HashMap 或 moka）：速度极快，但受限于单机内存，且多实例间无法共享数据。
分布式缓存（如 Redis）：支持跨实例数据共享，高可用，但网络延迟较高。

多级缓存结合两者优势：

先查本地缓存，命中则直接返回，速度最快。
本地缓存未命中时，查询 Redis。
Redis 未命中时，查询数据库并回写缓存。

接下来，我们用 Rust 实现一个简单的多级缓存系统，用于缓存用户信息。项目初始化创建一个新的 Rust 项目：

cargo new multilevel-cache
cd multilevel-cache

在 Cargo.toml 中添加依赖：

[dependencies]
moka = "0.12"          # 本地缓存库
redis = { version = "0.27", features = ["tokio-comp"] } # Redis 客户端
tokio = { version = "1.40", features = ["full"] } # 异步运行时
serde = { version = "1.0", features = ["derive"] } # 序列化/反序列化
serde_json = "1.0"      # JSON 序列化

moka：高性能的本地缓存库，支持 TTL 和并发。
redis-rs：Rust 的 Redis 客户端，支持异步操作。
tokio：异步运行时，用于处理 Redis 的异步查询。
serde：用于序列化和反序列化数据。

数据模型假设我们要缓存用户信息，定义一个 User 结构体：

use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize, Clone)]
struct User {
    id: u64,
    name: String,
    email: String,
}

实现多级缓存我们将实现一个 Cache 结构体，封装本地缓存（moka）和 Redis 缓存的逻辑。1. 定义缓存结构体

use moka::future::Cache as MokaCache;
use redis::{AsyncCommands, Client};
use std::time::Duration;
struct Cache {
    local: MokaCache<String, User>, // 本地缓存
    redis: Client,                  // Redis 客户端
}
impl Cache {
    async fn new(redis_url: &str) -> Self {
        // 初始化本地缓存，设置 TTL 为 60 秒
        let local = MokaCache::builder()
            .time_to_live(Duration::from_secs(60))
            .build();
        // 初始化 Redis 客户端
        let redis = Client::open(redis_url).expect("Failed to connect to Redis");
        Cache { local, redis }
    }
}

MokaCache：配置 TTL 为 60 秒，过期后自动移除。
redis::Client：连接到 Redis 服务器（需确保 Redis 服务运行，例如 redis://localhost:6379）。

2. 实现缓存查询逻辑添加 get_user 方法，实现多级缓存查询：

impl Cache {
    async fn get_user(&self, user_id: u64) -> Option<User> {
        let key = format!("user:{}", user_id);
        // 1. 查本地缓存
        if let Some(user) = self.local.get(&key) {
            println!("Hit local cache for user: {}", user_id);
            return Some(user);
        }
        // 2. 查 Redis 缓存
        let mut conn = match self.redis.get_async_connection().await {
            Ok(conn) => conn,
            Err(_) => return None, // Redis 连接失败，返回 None
        };
        let redis_result: Option<String> = conn
            .get(&key)
            .await
            .ok();
        if let Some(json) = redis_result {
            if let Ok(user) = serde_json::from_str(&json) {
                println!("Hit Redis cache for user: {}", user_id);
                // 回写本地缓存
                self.local.insert(key.clone(), user.clone()).await;
                return Some(user);
            }
        }
        // 3. Redis 未命中，模拟查询数据库
        let user = self.query_db(user_id).await?;
        // 回写 Redis 和本地缓存
        let json = serde_json::to_string(&user).unwrap();
        conn.set_ex(&key, &json, 3600).await.ok(); // Redis TTL 为 3600 秒
        self.local.insert(key, user.clone()).await;
        println!("Fetched from DB for user: {}", user_id);
        Some(user)
    }
    // 模拟数据库查询
    async fn query_db(&self, user_id: u64) -> Option<User> {
        // 这里模拟数据库查询，实际项目中替换为数据库操作
        Some(User {
            id: user_id,
            name: format!("User{}", user_id),
            email: format!("user{}@example.com", user_id),
        })
    }
}

逻辑说明：

优先查询本地缓存（moka），若命中直接返回。
本地缓存未命中，查询 Redis，若命中则反序列化为 User 并回写本地缓存。
Redis 未命中，调用 query_db 模拟数据库查询，获取数据后回写 Redis 和本地缓存。
Redis 使用 SETEX 命令设置 3600 秒的 TTL。

3. 主函数与测试在 main.rs 中编写主函数，测试缓存逻辑：

#[tokio::main]
async fn main() {
    // 初始化缓存
    let cache = Cache::new("redis://localhost:6379").await;
    // 测试查询
    for _ in 0..2 {
        if let Some(user) = cache.get_user(1).await {
            println!("User: id={}, name={}, email={}", user.id, user.name, user.email);
        } else {
            println!("User not found");
        }
    }
}

运行程序（确保 Redis 服务运行）：

bash

cargo run

第一次查询输出：

Fetched from DB for user: 1
User: id=1, name=User1, email=user1@example.com

第二次查询输出：

Hit local cache for user: 1
User: id=1, name=User1, email=user1@example.com

第二次查询命中本地缓存，速度更快。如果本地缓存过期（60 秒后），会尝试命中 Redis。

最佳实践

TTL 配置：
- 本地缓存 TTL 较短（如 60 秒），适合高频访问数据。
- Redis TTL 较长（如 3600 秒），适合跨实例共享。
错误处理：
- 实际项目中，需对 Redis 连接失败、序列化错误等进行更健壮的处理，使用 Result 替代 Option。
- 示例：

asyncfnget_user(&self, user_id:u64)->Result<User,String>{
// ... 错误处理逻辑
}

3.缓存一致性：

更新数据库时，同步更新或失效 Redis 缓存（使用 DEL 命令）。
本地缓存可通过 moka 的 invalidate 方法失效：

self.local.invalidate(&key).await;

4. 性能优化：

使用连接池（如 redis-rs 的 ConnectionManager）管理 Redis 连接。
对热点数据启用本地缓存的 max_capacity 限制内存使用：

let local = MokaCache::builder()
    .time_to_live(Duration::from_secs(60))
    .max_capacity(10_000)
    .build();

序列化优化：
- 对于大对象，使用更高效的序列化格式，如 bincode，替代 JSON。
- 示例：将 serde_json 替换为 bincode。
监控与日志：
- 记录缓存命中率、查询延迟等指标，优化缓存策略。
- 使用 log 或 tracing 库添加日志。

扩展：生产环境中的注意事项

高并发：moka 是线程安全的，适合多线程环境；Redis 使用连接池避免连接瓶颈。
分布式一致性：在分布式系统中，使用 Redis 的 Pub/Sub 或 Lua 脚本确保缓存一致性。
容错：Redis 宕机时，降级到直接查询数据库，并记录错误日志。
测试：编写单元测试验证缓存命中、失效和错误处理逻辑：

#[cfg(test)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn test_cache_hit() {
        let cache = Cache::new("redis://localhost:6379").await;
        let user1 = cache.get_user(1).await.unwrap();
        let user2 = cache.get_user(1).await.unwrap();
        assert_eq!(user1.id, user2.id);
    }
}

总结通过 Rust、Moka 和 Redis，我们实现了一个高效的多级缓存系统，结合本地缓存的低延迟和 Redis 的分布式能力。本文展示了一个简单但实用的案例，涵盖了初始化、查询逻辑和最佳实践。在生产环境中，你可以根据需求调整 TTL、优化序列化或添加监控，构建更健壮的缓存系统。

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2025-10-14，如有侵权请联系 cloudcommunity@tencent.com 删除

缓存