br_cache/
redis.rs

use crate::CacheBase;
use json::{array, object, JsonValue};
use log::error;
use redis::{Client, Commands, Connection, RedisResult};

#[derive(Clone)]
pub struct Redis {
    client: Client,
    db: i8,
}

impl Redis {
    pub fn connect(dsn: String) -> Result<Self, String> {
        // 读取配置
        let client = Client::open(dsn);
        match client {
            Ok(client) => Ok(Self { client, db: 0 }),
            Err(e) => Err(e.to_string()),
        }
    }
    pub fn con(&mut self) -> Result<Connection, String> {
        let conn = self.client.get_connection();
        let mut conn = match conn {
            Ok(e) => e,
            Err(_) => return Err("Connection failed.".to_string()),
        };
        redis::pipe()
            .cmd("SELECT")
            .arg(self.db)
            .exec(&mut conn)
            .unwrap();
        Ok(conn)
    }
}

impl CacheBase for Redis {
    /// 切换到指定的数据库
    fn db(&mut self, db: i8) -> &mut Self {
        self.db = db;
        self
    }

    /// 设置
    ///
    /// * expiration_date 过期时间 s 秒
    fn add(&mut self, key: &str, value: JsonValue, expiration_date: u64) -> Result<bool, String> {
        let data: RedisResult<bool> = {
            if expiration_date > 0 {
                self.con()?.set_ex(key, value.to_string(), expiration_date)
            } else {
                self.con()?.set(key, value.to_string())
            }
        };
        match data {
            Ok(e) => Ok(e),
            Err(e) => {
                error!("{}", e);
                Err(format!("设置缓存失败: {}", e))
            }
        }
    }
    /// 获取
    fn get(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<String> = self.con()?.get(key);
        match data {
            Ok(e) => {
                let res = match json::parse(&e) {
                    Ok(json) => json,
                    Err(_) => JsonValue::from(e),
                };
                Ok(res)
            }
            Err(e) => Err(format!("获取失败: {}", e)),
        }
    }
    /// 删除
    fn delete(&mut self, key: &str) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.del(key);
        match data {
            Ok(e) => Ok(e),
            Err(e) => Err(format!("delete error: {}", e)),
        }
    }
    /// 判断KEY是否存在
    fn exists(&mut self, key: &str) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.exists(key);
        match data {
            Ok(data) => Ok(data),
            Err(e) => Err(format!("判断是否存在失败: {}", e)),
        }
    }
    /// 查询KEYS获取
    fn keys(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<Vec<String>> = self.con()?.keys(key);
        match data {
            Ok(e) => Ok(JsonValue::from(e)),
            Err(e) => Err(format!("查询KEYS失败: {}", e)),
        }
    }

    /// 集合 添加
    fn set_add(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.sadd(key, value.to_string());
        match data {
            Ok(e) => Ok(e),
            Err(e) => Err(format!("集合添加: {}", e)),
        }
    }
    /// 集合 获取
    fn set_get(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<Vec<String>> = self.con()?.smembers(key);
        match data {
            Ok(e) => {
                let mut list = array![];
                for item in e.iter() {
                    let data = JsonValue::from(item.clone());
                    let json = json::parse(item).unwrap_or(data);
                    let _ = list.push(json);
                }
                Ok(list)
            }
            Err(e) => Err(format!("集合查询: {}", e)),
        }
    }
    /// 集合 删除
    fn set_delete(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.srem(key, value.to_string());
        match data {
            Ok(e) => Ok(e),
            Err(e) => Err(format!("集合删除: {}", e)),
        }
    }

    /// 设置消息队列
    fn set_message_queue(&mut self, key: &str, value: JsonValue) -> Result<bool, String> {
        let data: RedisResult<String> =
            self.con()?
                .xadd(key, "*", &[(value.to_string(), value.to_string())]);
        let res = data.is_ok();
        Ok(res)
    }

    /// 消息队列获取
    fn get_message_queue(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<Vec<String>> = self.con()?.xread(&[key], &[0]);
        match data {
            Ok(e) => Ok(JsonValue::from(e)),
            Err(e) => Err(format!("{}", e)),
        }
    }
    // /// 订阅消息
    // pub fn subscribe_s(&mut self, channel: &str, fun: fn(channel: &str, data: &str)) {
    //     let mut pubsub = self.con.as_pubsub();
    //     pubsub.subscribe(channel).unwrap();
    //     loop {
    //         let msg = pubsub.get_message().unwrap();
    //         // 消息处理
    //         let data: String = msg.get_payload().unwrap();
    //         let channel = msg.get_channel_name();
    //         fun(channel, data.as_str())
    //     }
    // }
    // /// 发布消息
    // pub fn publish(&mut self, key: &str, value: JsonValue) -> bool {
    //     let data = self.con.publish(key, value.to_string());
    //     return match data {
    //         Ok(e) => {
    //             e
    //         }
    //         Err(_e) => {
    //             false
    //         }
    //     };
    // }

    /// 设置对象集合
    fn set_object(&mut self, key: &str, field: &str, value: JsonValue) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.hset(key, field, value.to_string());
        match data {
            Ok(e) => Ok(e),
            Err(e) => Err(format!("{}", e)),
        }
    }
    /// 获取对象集合
    fn get_object(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<Vec<String>> = self.con()?.hgetall(key);
        match data {
            Ok(e) => {
                let mut list = object! {};
                let mut index = 0;
                while index < e.len() {
                    list[e[index].to_string()] = e[index + 1].clone().into();
                    index += 2;
                }
                Ok(list)
            }
            Err(e) => Err(format!("{}", e)),
        }
    }

    /// 哈希-添加
    fn add_hash(&mut self, key: &str, field: &str, value: JsonValue) -> Result<bool, String> {
        let res: RedisResult<bool> = self.con()?.hexists(key, field);
        let ists = res.unwrap_or(false);
        if ists {
            let res = self.delete_hash(key, field)?;
            if res {
                let data: RedisResult<bool> = self.con()?.hset(key, field, value.to_string());
                match data {
                    Ok(e) => Ok(e),
                    Err(e) => {
                        error!("{}", e);
                        Err(format!("设置哈希类型缓存失败: {}", e))
                    }
                }
            } else {
                Ok(false)
            }
        } else {
            let data: RedisResult<bool> = self.con()?.hset_nx(key, field, value.to_string());
            match data {
                Ok(e) => Ok(e),
                Err(e) => {
                    error!("{}", e);
                    Err(format!("设置哈希类型缓存失败: {}", e))
                }
            }
        }
    }

    fn get_hash_field_value(&mut self, key: &str, field: &str) -> Result<JsonValue, String> {
        let data: RedisResult<String> = self.con()?.hget(key, field);
        match data {
            Ok(e) => Ok(json::parse(e.as_str()).unwrap_or(JsonValue::Null)),
            Err(e) => {
                error!("{}", e);
                Err(format!("设置哈希类型缓存失败: {}", e))
            }
        }
    }

    fn get_hash_fields(&mut self, key: &str) -> Result<JsonValue, String> {
        let data: RedisResult<Vec<String>> = self.con()?.hkeys(key);
        match data {
            Ok(e) => Ok(e.into()),
            Err(e) => {
                error!("{}", e);
                Err(format!("获取哈希类型缓存失败: {}", e))
            }
        }
    }

    fn delete_hash(&mut self, key: &str, field: &str) -> Result<bool, String> {
        let data: RedisResult<bool> = self.con()?.hdel(key, field);
        match data {
            Ok(e) => Ok(e),
            Err(e) => {
                error!("{}", e);
                Err(format!("设置哈希类型缓存失败: {}", e))
            }
        }
    }
}
br_cache/redis.rs

br_cache/
redis.rs
