br_cache/

redis.rs

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


#[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 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))
            }
        }
    }
    /// 获取
    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 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))
        }
    }

    /// 查询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_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 = match data {
            Ok(_) => {
                true
            }
            Err(_) => {
                false
            }
        };
        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 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.clone()].to_string()] = e[index + 1].clone().into();
                    index += 2;
                }
                Ok(list)
            }
            Err(e) => Err(format!("{}", e))
        }
    }
    /// 设置对象集合
    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))
        }
    }
}