rust 理解结构体 Deepseek

use crate::error::BinanceError;
use once_cell::sync::Lazy;
use r2d2::{ManageConnection, Pool, PooledConnection};
use redis::{Client, Commands, Connection, RedisError};

// 自定义 Redis 连接池管理器
pub struct RedisConnectionManager {
    client: Client,
}

impl RedisConnectionManager {
    pub fn new(redis_url: &str) -> Result<Self, RedisError> {
        let client = Client::open(redis_url)?;
        Ok(Self { client })
    }
}

impl ManageConnection for RedisConnectionManager {
    type Connection = Connection;
    type Error = RedisError;

    fn connect(&self) -> Result<Self::Connection, Self::Error> {
        self.client.get_connection()
    }

    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
        redis::cmd("PING").query(conn).map(|_: String| ())
    }

    fn has_broken(&self, _: &mut Self::Connection) -> bool {
        false
    }
}

// 类型别名
type RedisPool = Pool<RedisConnectionManager>;
type RedisConn = PooledConnection<RedisConnectionManager>;

// 全局 Redis 连接池（最大20连接）
static REDIS_POOL: Lazy<RedisPool> = Lazy::new(|| {
    let manager =
        RedisConnectionManager::new("redis://127.0.0.1/").expect("Failed to create Redis manager");
    Pool::builder()
        .max_size(10)
        .build(manager)
        .expect("Failed to build Redis connection pool")
});

// 连接池状态结构体 测试用
#[allow(dead_code)]
#[derive(Debug, Clone)]
pub struct PoolStatus {
    pub connections: u32,
    pub idle_connections: u32,
    pub max_size: u32,
}

pub struct RedisUtil;

impl RedisUtil {
    fn get_conn() -> Result<RedisConn, BinanceError> {
        REDIS_POOL
            .get()
            .map_err(|e| BinanceError::ApiError(format!("Get redis conn failed: {}", e)))
    }

    pub fn execute<F, T>(func: F) -> Result<T, BinanceError>
    where
        F: FnOnce(&mut RedisConn) -> Result<T, RedisError>,
    {
        let mut conn = Self::get_conn()?;
        func(&mut conn).map_err(BinanceError::RedisError)
    }

    pub fn set_string(key: &str, value: &str) -> Result<(), BinanceError> {
        Self::execute(|conn| conn.set(key, value))
    }

    pub fn get_string(key: &str) -> Option<String> {
        Self::execute(|conn| conn.get::<_, String>(key)).ok()
    }
}

pub struct RedisConnectionManager {
    client: Client,  // 持有 Redis 客户端实例
}

impl RedisConnectionManager {
    // 构造函数，根据 Redis URL 创建客户端
    pub fn new(redis_url: &str) -> Result<Self, RedisError> {
        let client = Client::open(redis_url)?;
        Ok(Self { client })
    }
}

// 为 RedisConnectionManager 实现 r2d2 的连接管理 Trait
impl ManageConnection for RedisConnectionManager {
    type Connection = Connection;  // 连接类型是 Redis 的 Connection
    type Error = RedisError;       // 错误类型为 RedisError

    // 创建新连接
    fn connect(&self) -> Result<Self::Connection, Self::Error> {
        self.client.get_connection()
    }

    // 验证连接是否有效（通过发送 PING 命令）
    fn is_valid(&self, conn: &mut Self::Connection) -> Result<(), Self::Error> {
        redis::cmd("PING").query(conn).map(|_: String| ())
    }

    // 判断连接是否已损坏（此处始终返回 false，假设连接不会主动损坏）
    fn has_broken(&self, _: &mut Self::Connection) -> bool {
        false
    }
}

pub struct RedisUtil;  // 空结构体，仅用于组织静态方法

impl RedisUtil {
    // 从全局连接池获取一个连接
    fn get_conn() -> Result<RedisConn, BinanceError> {
        REDIS_POOL
            .get()
            .map_err(|e| BinanceError::ApiError(format!("Get redis conn failed: {}", e)))
    }

    // 执行 Redis 命令的通用方法（接受闭包）
    pub fn execute<F, T>(func: F) -> Result<T, BinanceError>
    where
        F: FnOnce(&mut RedisConn) -> Result<T, RedisError>,
    {
        let mut conn = Self::get_conn()?;
        func(&mut conn).map_err(BinanceError::RedisError)
    }

    // 设置字符串键值
    pub fn set_string(key: &str, value: &str) -> Result<(), BinanceError> {
        Self::execute(|conn| conn.set(key, value))
    }

    // 获取字符串键值（返回 Option，错误时返回 None）
    pub fn get_string(key: &str) -> Option<String> {
        Self::execute(|conn| conn.get::<_, String>(key)).ok()
    }
}

type RedisPool = Pool<RedisConnectionManager>;  // 连接池类型
type RedisConn = PooledConnection<RedisConnectionManager>; // 池化连接类型

static REDIS_POOL: Lazy<RedisPool> = Lazy::new(|| {
    let manager = RedisConnectionManager::new("redis://127.0.0.1/")
        .expect("Failed to create Redis manager");
    Pool::builder()
        .max_size(10)  // 最大连接数设为10（注意：注释中的20需修正）
        .build(manager)
        .expect("Failed to build Redis connection pool")
});

RedisUtil::set_string("user:1:name", "Alice").unwrap();

let name = RedisUtil::get_string("user:1:name").unwrap_or_default();
println!("User name: {}", name); // 输出 "Alice"

let count: i64 = RedisUtil::execute(|conn| {
    conn.incr("counter", 1)
}).unwrap();