Redis操作的封装类

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Redis操作的封装类，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10816字，纯文字阅读大概需要16分钟。

内容图文

            using
             System;

            using
             System.Collections.Generic;

            using
             System.Linq;

            using
             System.Text;

            using
             ServiceStack.Redis;
       

            namespace
             Com.QFGame.QNX.Community.Redis
{
    
            public
            class
             RedisBase
    {
       
        
            private
            static
            string RedisPath = System.Configuration.ConfigurationSettings.AppSettings["RedisPath"];
       
        #region -- 连接信息 --
        //10.0.18.8:6379publicstatic PooledRedisClientManager prcm = CreateManager(newstring[] { RedisPath }, newstring[] { RedisPath });
        privatestatic PooledRedisClientManager CreateManager(string[] readWriteHosts, string[] readOnlyHosts)
        { 
            // 支持读写分离，均衡负载 returnnew PooledRedisClientManager(readWriteHosts, readOnlyHosts, new RedisClientManagerConfig
            {
                MaxWritePoolSize = 5, // “写”链接池链接数 
                MaxReadPoolSize = 5, // “读”链接池链接数 
                AutoStart = true,
            });
        }
        #endregion#region -- Item --
        ///<summary>/// 设置单体
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="t"></param>///<param name="timeSpan"></param>///<returns></returns>publicstaticbool Item_Set<T>(string key, T t)
        {
            try
            {
                using (IRedisClient redis = prcm.GetClient())
                {
                    return redis.Set<T>(key, t, new TimeSpan(1, 0, 0));
                }
            }
            catch (Exception ex)
            {
                // LogInfo            }
            returnfalse;
        }
       
        ///<summary>/// 获取单体
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<returns></returns>publicstatic T Item_Get<T>(string key) where T : class
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Get<T>(key);
            }
        }
       
        ///<summary>/// 移除单体
        ///</summary>///<param name="key"></param>publicstaticbool Item_Remove(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Remove(key);
            }
        }
       
        #endregion#region -- List --
       
        publicstaticvoid List_Add<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.AddItemToList(redisTypedClient.Lists[key], t);
            }
        }
       
               
       
        publicstaticbool List_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.RemoveItemFromList(redisTypedClient.Lists[key], t) > 0;
            }
        }
        publicstaticvoid List_RemoveAll<T>(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.Lists[key].RemoveAll();
            }
        }
       
        publicstaticint List_Count(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.GetListCount(key);
            } 
        }
       
        publicstatic List<T> List_GetRange<T>(string key, int start, int count)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var c = redis.GetTypedClient<T>();
                return c.Lists[key].GetRange(start, start + count - 1);
            }
        }
       
       
        publicstatic List<T> List_GetList<T>(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var c = redis.GetTypedClient<T>();
                return c.Lists[key].GetRange(0, c.Lists[key].Count);
            }
        }
       
        publicstatic List<T> List_GetList<T>(string key, int pageIndex, int pageSize)
        {
            int start = pageSize * (pageIndex - 1);
            return List_GetRange<T>(key, start, pageSize);
        }
       
        ///<summary>/// 设置缓存过期
        ///</summary>///<param name="key"></param>///<param name="datetime"></param>publicstaticvoid List_SetExpire(string key, DateTime datetime)
        {
                using (IRedisClient redis = prcm.GetClient())
                {
                        redis.ExpireEntryAt(key, datetime);
                }
        }
        #endregion#region -- Set --
        publicstaticvoid Set_Add<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                redisTypedClient.Sets[key].Add(t);
            }
        }
        publicstaticbool Set_Contains<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.Sets[key].Contains(t);
            }
        }
        publicstaticbool Set_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var redisTypedClient = redis.GetTypedClient<T>();
                return redisTypedClient.Sets[key].Remove(t);
            }
        }
        #endregion#region -- Hash --
        ///<summary>/// 判断某个数据是否已经被缓存
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="dataKey"></param>///<returns></returns>publicstaticbool Hash_Exist<T>(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.HashContainsEntry(key, dataKey);
            }
        }
       
        ///<summary>/// 存储数据到hash表
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="dataKey"></param>///<returns></returns>publicstaticbool Hash_Set<T>(string key, string dataKey, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.SetEntryInHash(key, dataKey, value);
            }
        }
        ///<summary>/// 移除hash中的某值
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="dataKey"></param>///<returns></returns>publicstaticbool Hash_Remove(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.RemoveEntryFromHash(key, dataKey);
            }
        }
        ///<summary>/// 移除整个hash
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="dataKey"></param>///<returns></returns>publicstaticbool Hash_Remove(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.Remove(key);
            }
        }
        ///<summary>/// 从hash表获取数据
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="dataKey"></param>///<returns></returns>publicstatic T Hash_Get<T>(string key, string dataKey)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = redis.GetValueFromHash(key, dataKey);
                return ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(value);
            }
        }
        ///<summary>/// 获取整个hash的数据
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<returns></returns>publicstatic List<T> Hash_GetAll<T>(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var list = redis.GetHashValues(key);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var value = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(value);
                    }
                    return result;
                }
                returnnull;
            }
        }
        ///<summary>/// 设置缓存过期
        ///</summary>///<param name="key"></param>///<param name="datetime"></param>publicstaticvoid Hash_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }
        #endregion#region -- SortedSet --
        ///<summary>///  添加数据到 SortedSet
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="t"></param>///<param name="score"></param>publicstaticbool SortedSet_Add<T>(string key, T t, double score)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.AddItemToSortedSet(key, value, score);
            }
        }
        ///<summary>/// 移除数据从SortedSet
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="t"></param>///<returns></returns>publicstaticbool SortedSet_Remove<T>(string key, T t)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                string value = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
                return redis.RemoveItemFromSortedSet(key, value);
            }
        }
        ///<summary>/// 修剪SortedSet
        ///</summary>///<param name="key"></param>///<param name="size">保留的条数</param>///<returns></returns>publicstaticint SortedSet_Trim(string key, int size)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.RemoveRangeFromSortedSet(key, size, 9999999);
            }
        }
        ///<summary>/// 获取SortedSet的长度
        ///</summary>///<param name="key"></param>///<returns></returns>publicstaticint SortedSet_Count(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                return redis.GetSortedSetCount(key);
            }
        }
       
        ///<summary>/// 获取SortedSet的分页数据
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="pageIndex"></param>///<param name="pageSize"></param>///<returns></returns>publicstatic List<T> SortedSet_GetList<T>(string key, int pageIndex, int pageSize)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var list = redis.GetRangeFromSortedSet(key, (pageIndex - 1) * pageSize, pageIndex * pageSize - 1); 
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            returnnull;
        }
       
       
        ///<summary>/// 获取SortedSet的全部数据
        ///</summary>///<typeparam name="T"></typeparam>///<param name="key"></param>///<param name="pageIndex"></param>///<param name="pageSize"></param>///<returns></returns>publicstatic List<T> SortedSet_GetListALL<T>(string key)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                var list = redis.GetRangeFromSortedSet(key, 0, 9999999);
                if (list != null && list.Count > 0)
                {
                    List<T> result = new List<T>();
                    foreach (var item in list)
                    {
                        var data = ServiceStack.Text.JsonSerializer.DeserializeFromString<T>(item);
                        result.Add(data);
                    }
                    return result;
                }
            }
            returnnull;
        }
       
        ///<summary>/// 设置缓存过期
        ///</summary>///<param name="key"></param>///<param name="datetime"></param>publicstaticvoid SortedSet_SetExpire(string key, DateTime datetime)
        {
            using (IRedisClient redis = prcm.GetClient())
            {
                redis.ExpireEntryAt(key, datetime);
            }
        }
       
        //public static double SortedSet_GetItemScore<T>(string key,T t)
        //{
        //    using (IRedisClient redis = prcm.GetClient())
        //    {
        //        var data = ServiceStack.Text.JsonSerializer.SerializeToString<T>(t);
        //        return redis.GetItemScoreInSortedSet(key, data);
        //    }
        //    return 0;
        //}#endregion
       
    }
}

原文：http://www.cnblogs.com/hnsongbiao/p/4949295.html

内容总结

以上是互联网集市为您收集整理的Redis操作的封装类全部内容，希望文章能够帮你解决Redis操作的封装类所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1064886.html

来源：【匿名】

【上一篇】在团800运维工作总结之redis-cluster使用【下一篇】redis可以做什么？

更多 ►

【Redis操作的封装类】教程文章相关的互联网学习教程文章

using System; using System.Collections.Generic; using System.Linq; using System.Text; using ServiceStack.Redis;namespace Com.QFGame.QNX.Community.Redis {publicclass RedisBase{privatestaticstring RedisPath = System.Configuration.ConfigurationSettings.AppSettings["RedisPath"];#region -- 连接信息 --//10.0.18.8:6379publicstatic PooledRedisClientManager prcm = CreateManager(newstring[] { RedisPath }, n...

详解StackExchange.Redis通用封装类分享【图】

前两天朋友问我，有没有使用过StackExchange.Redis，问我要个封装类，由于之前都是使用ServiceStack.Redis，由于ServiceStack.Redis v4版本后是收费版的，所以现在也很有公司都在使用StackExchange.Redis而抛弃ServiceStack.Redis了。其实个人觉得，两个驱动都不错，只是由于ServiceStack.Redis收费导致目前很多公司都是基于V3版本的使用，也有人说V3版本有很多Bug，没有维护和升级，不过至少目前我是没发现Bug。不过ServiceStack....

PHPRedis封装类完整实例【图】

本文通过摘录，旨为收藏经典。望一起分享共论。 class RedisCluster{ // 是否使用 M/S 的读写集群方案 private isUseCluster=false;//Slave句柄标记private_sn = 0; // 服务器连接句柄 private $_linkHandle = array( ‘master’=>null,// 只支持一台 Master ‘slave’=>array(),// 可以有多台 Slave );/*** 构造函数* @param boolean $isUseCluster 是否采用 M/S 方案*/ public function __construct($isUseCluster=false){$this...

PHP实现操作redis的封装类完整实例，phpredis封装实例_PHP教程

PHP实现操作redis的封装类完整实例，phpredis封装实例本文实例讲述了PHP实现操作redis的封装类。分享给大家供大家参考，具体如下： <?php /*** Redis 操作，支持 Master/Slave 的负载集群** @author jackluo*/ class RedisCluster{// 是否使用 M/S 的读写集群方案private $_isUseCluster = false;// Slave 句柄标记private $_sn = 0;// 服务器连接句柄private $_linkHandle = array(master=>null,// 只支持一台 Masterslave=>array...

redis-php两种封装类的优缺点？

php很多内置的类或扩展类比较粗糙，需要人为的封装一遍，于是有了两种封装方式， 1直接继承 2内部实例化如redis类，可以namespace lib class redis extends \Redis {} 也可以namespace lib class redis {private $_redis = null;public function __construct() {$this->_redis = new \Redis()} } 第一种方法的优点是方便，无须把所有的方法重写一遍，但是不太好统一捕捉异常，第二种就是麻烦些，需要重写一遍所有的方法，（虽然可...

PHP实现操作redis的封装类完整实例_PHP

本文实例讲述了PHP实现操作redis的封装类。分享给大家供大家参考，具体如下：<?php /*** Redis 操作，支持 Master/Slave 的负载集群** @author jackluo*/ class RedisCluster{// 是否使用 M/S 的读写集群方案private $_isUseCluster = false;// Slave 句柄标记private $_sn = 0;// 服务器连接句柄private $_linkHandle = array(master=>null,// 只支持一台 Masterslave=>array(),// 可以有多台 Slave);/*** 构造函数** @param bool...

PHP实现操作redis的封装类完整实例_php技巧

本文实例讲述了PHP实现操作redis的封装类。分享给大家供大家参考，具体如下： <?php /*** Redis 操作，支持 Master/Slave 的负载集群** @author jackluo*/ class RedisCluster{// 是否使用 M/S 的读写集群方案private $_isUseCluster = false;// Slave 句柄标记private $_sn = 0;// 服务器连接句柄private $_linkHandle = array(master=>null,// 只支持一台 Masterslave=>array(),// 可以有多台 Slave);/*** 构造函数** @param boo...

PHP实现操作redis的封装类完整实例

本文实例讲述了PHP实现操作redis的封装类。分享给大家供大家参考，具体如下： <?php /*** Redis 操作，支持 Master/Slave 的负载集群** @author jackluo*/ class RedisCluster{// 是否使用 M/S 的读写集群方案private $_isUseCluster = false;// Slave 句柄标记private $_sn = 0;// 服务器连接句柄private $_linkHandle = array(master=>null,// 只支持一台 Masterslave=>array(),// 可以有多台 Slave);/*** 构造函数** @param boo...

PHP操作redis实现的分页列表，新增，删除功能封装类与用法示例

本文实例讲述了PHP操作redis实现的分页列表，新增，删除功能封装类与用法。分享给大家供大家参考，具体如下： <?php /** redis 分页数据类库*/ class redisPage{protected $_redis;protected $_redis_ip = 127.0.0.1; //ipprotected $_redis_port = 6379; //端口protected $_redis_db = 0; //数据库号protected $_hash_prefix = my_data; //前缀名称public function __construct($ip=,$port=,$db=,$hash_prefix=){if($ip != ) $thi...

StackExchange.Redis通用封装类分享【代码】

ConnectionMultiplexer 封装首先是 ConnectionMultiplexer 的封装，ConnectionMultiplexer对象是StackExchange.Redis最中枢的对象。这个类的实例需要被整个应用程序域共享和重用的，所以不需要在每个操作中不停的创建该对象的实例，一般都是使用单例来创建和存放这个对象，这个在官网上也有说明。/// <summary>/// ConnectionMultiplexer对象管理帮助类/// </summary>public static class RedisConnectionHelp{//系统自定义Key前缀...

REDIS - 技术教程分类

Redis 教程 Redis 简介 Redis 安装 Redis 配置 Redis 数据类型 Redis 命令 Redis 键(key) Redis 字符串(String) Redis 哈希(Hash) Redis 列表(List) Redis 集合(Set) Redis 有序集合(sorted set) Redis HyperLogLog Redis 发布订阅 Redis 事务 Redis 脚本 Redis 连接 Redis 服务器 Redis GEO Redis Stream Redis 数据备份与恢复 Redis 安全 Redis 性能测试 Redis 客户端连接 Redis 分区 Redis 全部

REDIS - 最热教程

redis中批量删除key的方法 redis设置密码，取消密码 node.js利用redis数据库缓存数据 PHP swoole和redis异步任务实现方法分析 Laravel使用Redis共享Session步骤详解 mac下卸载干净redis 如何通过命令行修改redis的配置使用Port Forwarding连接k8s集群的pod（...Redis入门（七）——Redis发布订阅 Redis学习笔记2-常用数据类型