Rust操作Redis从入门到生产级应用

[dependencies]
redis = { version = "1.2", features = [
    "tokio-comp",            # 异步支持
    "connection-manager",    # 内置连接池
    "tokio-native-tls-comp",
] }
tokio = { version = "1", features = ["full"] }
anyhow = "1.0"

use anyhow::Result;
use redis::{Client, Commands};
fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 获取连接（同步连接）
    let mut conn = client.get_connection()?;
    // 字符串操作：SET / GET
    let _: () = conn.set("username", "rust_dev")?; // SET 命令，返回空元组
    let username: Option<String> = conn.get("username")?; // GET 命令，返回 Option（避免空值 panic）
    println!("获取 username: {:?}", username); // 输出：Some("rust_dev")
    // 哈希操作：HSET / HGET / HGETALL
    let _: () = conn.hset("user:1", "id", 1)?;
    let _: () = conn.hset("user:1", "name", "Alice")?;
    let user_name: Option<String> = conn.hget("user:1", "name")?;
    let user: Option<redis::Value> = conn.hgetall("user:1")?; // 获取整个哈希
    println!("获取用户名称: {:?}", user_name); // 输出：Some("Alice")
    println!("获取用户全部信息: {:?}", user);
    // 列表操作：LPUSH / LRANGE
    let _: () = conn.lpush("tasks", "learn redis")?;
    let _: () = conn.lpush("tasks", "learn rust")?;
    let tasks: Vec<String> = conn.lrange("tasks", 0, -1)?; // 获取所有列表元素
    println!("任务列表: {:?}", tasks); // 输出：["learn rust", "learn redis"]
    // 删除操作：DEL
    let _: () = conn.del("username")?;
    Ok(())
}

use anyhow::Result;
use redis::{AsyncCommands, Client};

#[tokio::main]
async fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 获取异步连接
    let mut conn = client.get_multiplexed_async_connection().await?;

    // 异步操作：与同步模式 API 一致
    let _: () = conn.set("async_key", "async_value").await?;
    let async_value: Option<String> = conn.get("async_key").await?;
    println!("异步获取值: {:?}", async_value); // 输出：Some("async_value")

    // 哈希操作（异步）
    let _: () = conn.hset("async_user:1", "age", 25).await?;
    let age: Option<i32> = conn.hget("async_user:1", "age").await?;
    println!("异步获取用户年龄: {:?}", age); // 输出：Some(25)

    Ok(())
}

use anyhow::Result;
use redis::{AsyncCommands, Client};

#[tokio::main]
async fn main() -> Result<()> {
    // 创建 Redis 客户端
    let client = Client::open("redis://127.0.0.1:6379")?;
    // 创建连接池，默认配置
    // 另外可提供 get_connection_manager_with_config 自定义最大连接数、超时时间等
    let mut conn_manager = client.get_connection_manager().await?;

    // 从连接池获取连接并执行操作（自动复用连接）
    for i in 0..5 {
        let key = format!("pool_key:{}", i);

        let _: () = conn_manager.set(&key, i).await?;
        let value: Option<i32> = conn_manager.get(&key).await?;

        println!("连接池操作 {}: {:?}", key, value);
    }

    Ok(())
}

use anyhow::Result;
use redis::{Client, pipe};

#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_connection()?;

    // 创建管道，批量执行 SET 命令（无返回值）
    pipe()
        .set("pipe_key1", "value1")
        .set("pipe_key2", "value2")
        .set("pipe_key3", "value3")
        .exec(&mut conn)?;
    println!("管道批量 SET 执行完成");

    // 批量执行 GET 命令（获取返回值）
    let (val1, val2, val3): (Option<String>, Option<String>, Option<String>) = pipe()
        .get("pipe_key1")
        .get("pipe_key2")
        .get("pipe_key3")
        .query(&mut conn)?;
    println!("管道批量 GET 结果: {:?}, {:?}, {:?}", val1, val2, val3);

    Ok(())
}

use anyhow::Result;
use redis::{Client, pipe};

#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_connection()?;

    // 开启事务
    let mut pipe = pipe();
    pipe.atomic();

    // 向事务中添加命令
    pipe.set("tx_key1", "tx_val1")
        .hset("tx_user:1", "name", "Bob")
        .lpush("tx_tasks", "finish transaction");

    // 执行事务（通过 query 发送所有命令）
    let results: Vec<redis::Value> = pipe.query(&mut conn)?;
    println!("事务执行结果: {:?}", results);

    Ok(())
}

use anyhow::Result;
use redis::{Client, Script};

// 定义结构体
#[tokio::main]
async fn main() -> Result<()> {
    let client = Client::open("redis://127.0.0.1:6379")?;
    let mut conn = client.get_multiplexed_async_connection().await?;

    // 定义 Lua 脚本：自增指定 key，返回自增后的值
    let lua_script = Script::new(
        r#"
        local key = KEYS[1]
        -- 调用 Redis 原生命令 INCR，实现自增
        return redis.call('INCR', key)
    "#,
    );

    // 执行脚本：通过 .key() 传递 KEYS 参数
    let new_val: i32 = lua_script
        .key("simple_lua_counter") // 添加 KEY
        .invoke_async(&mut conn) // 执行脚本
        .await?;
    println!("Lua 脚本执行结果（自增后）: {}", new_val); // 首次执行输出 1

    // 传递参数的简单示例，设置 key 值并返回
    let set_and_get_script = Script::new(
        r#"
        local key = KEYS[1]
        local val = ARGV[1]
        redis.call('SET', key, val)
        return val
    "#,
    );

    let result: String = set_and_get_script
        .key("lua_test_key") // 添加 KEY
        .arg("test_value") // 添加 ARG
        .invoke_async(&mut conn)
        .await?;
    println!("设置并返回值: {}", result); // 输出 test_value

    Ok(())
}