幽冥狂_七

Redis 操作帮助类

首先从Nuget中添加StackExchange.Redis包

1、Redis连接对象管理帮助类

using Mvc.Base;
using Mvc.Base.Log;
using StackExchange.Redis;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace RedisApi
{
    /// 
    /// Redis连接对象管理帮助类
    /// 
    public static class RedisConnectionHelp
    {
 
        /// 
        /// 获取Redis连接字符串
        /// 
        private static readonly string RedisConnectionString = BaseMethod.GetAppValue("RedisConnectionString");
 
 
        /// 
        /// 线程锁
        /// 
        private static readonly object Locker = new object();
 
 
        /// 
        /// Redis连接对象
        /// 
        private static ConnectionMultiplexer _instance;
 
 
        /// 
        /// 获取单例连接对象
        /// 
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (Locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = GetManager();
                        }
                    }
                }
                return _instance;
            }
        }
 
 
        /// 
        /// 连接Redis
        /// 
        /// 
        private static ConnectionMultiplexer GetManager()
        {
            ConnectionMultiplexer connect = null;
            try
            {
                connect = ConnectionMultiplexer.Connect(RedisConnectionString);
            }
            catch
            {
                return null;
            }
 
            //注册事件
            connect.ConnectionFailed += MuxerConnectionFailed;
            connect.ConnectionRestored += MuxerConnectionRestored;
            connect.ErrorMessage += MuxerErrorMessage;
            connect.ConfigurationChanged += MuxerConfigurationChanged;
            connect.HashSlotMoved += MuxerHashSlotMoved;
            connect.InternalError += MuxerInternalError;
 
            return connect;
        }
 
 
        #region 注册事件
 
 
        /// 
        /// 配置更改时
        /// 
        /// 
        /// 
        private static void MuxerConfigurationChanged(object sender, EndPointEventArgs e)
        {
            LogHelper.WriteLog("Configuration changed: " + e.EndPoint);
        }
 
        /// 
        /// 发生错误时
        /// 
        /// 
        /// 
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            LogHelper.WriteLog("ErrorMessage: " + e.Message);
        }
 
        /// 
        /// 重新建立连接之前的错误
        /// 
        /// 
        /// 
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.WriteLog("ConnectionRestored: " + e.EndPoint);
        }
 
        /// 
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// 
        /// 
        /// 
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            LogHelper.WriteLog("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
        }
 
        /// 
        /// 更改集群
        /// 
        /// 
        /// 
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            LogHelper.WriteLog("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }
 
        /// 
        /// redis类库错误
        /// 
        /// 
        /// 
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            LogHelper.WriteLog("InternalError:Message" + e.Exception.Message);
        }
 
 
        #endregion 事件
 
 
    }
}

数据库连接是从config配置文件中读取的，配置示例


"RedisConnectionString" value="localhost:6000,allowadmin=true,password=8611561"/>

2、Redis操作帮助类

using Mvc.Base.Data;
using Newtonsoft.Json;
using StackExchange.Redis;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RedisApi
{
    /// 
    /// Redis操作帮助类
    /// 
    public class RedisHelper
    {
 
        /// 
        /// 数据库编号
        /// 
        private int DbNum;
 
 
        /// 
        /// 连接对象
        /// 
        private readonly ConnectionMultiplexer RedisConn;
 
 
        /// 
        /// 用构造函数创建一个Redis实例
        /// 
        /// 数据库编号
        public RedisHelper(int _DbNum)
        {
            DbNum = _DbNum;
            RedisConn = RedisConnectionHelp.Instance;
        }
 
 
 
        #region ----------------------String 操作----------------------
 
 
        /// 
        /// 添加或更新一个String值
        /// 
        /// 键
        /// 值
        /// 
        public bool StringSet(string Key, string Value)
        {
            try
            {
                return Do(db => db.StringSet(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 批量添加或更新String值
        /// 
        /// String集合
        /// 
        public bool StringSet(Dictionary<string, string> Values)
        {
            try
            {
                List> _KeyValuePair = new List>();
                foreach (var item in Values.Keys)
                {
                    _KeyValuePair.Add(new KeyValuePair(item, Values[item]));
                }
                return Do(db => db.StringSet(_KeyValuePair.ToArray()));
            }
            catch
            {
                return false;
            }
 
        }
 
 
 
 
        /// 
        /// 获取String值
        /// 
        /// Redis Key
        /// 
        public string StringGet(string Key)
        {
            try
            {
                return Do(db => db.StringGet(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 批量获取String值
        /// 
        /// Value集合
        /// 
        public List<string> StringGet(List<string> ListKey)
        {
            try
            {
                return RedisValueToList(Do(db => db.StringGet(ListToRedisKey(ListKey))));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 将指定键上的值做加法运算
        /// 
        /// 键
        /// 要增长的值(可以为负)
        /// 增长后的值
        public double StringIncrement(string Key, double Value)
        {
            try
            {
                return Do(db => db.StringIncrement(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将指定键上的值做减法运算
        /// 
        /// 键
        /// 要减少的值(可以为负)
        /// 减少后的值
        public double StringDecrement(string Key, double Value)
        {
            try
            {
                return Do(db => db.StringDecrement(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 根据键获取截取之后的值
        /// 
        /// 键
        /// 起始位置
        /// 结束位置
        /// 截取之后的值
        public string StringGetRange(string Key, long Start, long End)
        {
            try
            {
                return Do(db => db.StringGetRange(Key, Start, End));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 使键上的值追加一个字符串，若不存在该键则创建并设置为空字符串后追加 
        /// 
        /// 键
        /// 追加值
        /// 追加操作后字符串的长度
        public long StringAppend(string Key, string Value)
        {
            try
            {
                return Do(db => db.StringAppend(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region  ---------------------- Hash 操作 ----------------------
 
 
        /// 
        /// 根据键存储一对键值到Hash表
        /// 
        /// 键
        /// Hash键
        /// Hash值
        /// 
        public bool HashSet(string Key, string HashKey, string HashValue)
        {
            try
            {
                return Do(db =>
                {
                    return db.HashSet(Key, HashKey, HashValue);
                });
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 根据键存储多对键值到Hash表
        /// 
        /// 键
        /// Hash表
        /// 
        public void HashSet(string Key, Dictionary<string, string> HashData)
        {
            try
            {
                List HashTable = new List();
                foreach (string item in HashData.Keys)
                {
                    HashTable.Add(new HashEntry(item, HashData[item]));
                }
                var db = RedisConn.GetDatabase(DbNum);
                db.HashSet(Key, HashTable.ToArray());
            }
            catch
            {
 
            }
        }
 
 
 
 
        /// 
        /// 获取该键上的Hash表的元素总数
        /// 
        /// 键
        /// 
        public long HashLength(string Key)
        {
            try
            {
                return Do(db => db.HashLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将指定键上的Hash表的值做加法运算
        /// 
        /// 键
        /// HashKey
        /// 增加值，可以为负
        /// 增长后的值
        public double HashIncrement(string Key, string HashKey, double Value)
        {
            try
            {
                return Do(db => db.HashIncrement(Key, HashKey, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将指定键上的Hash表的值做减法运算
        /// 
        /// 键
        /// HashKey
        /// 减少值，可以为负
        /// 减少后的值
        public double HashDecrement(string Key, string HashKey, double Value)
        {
            try
            {
                return Do(db => db.HashDecrement(Key, HashKey, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 获取该键上的Hash表,键不存在返回0
        /// 
        /// 键
        /// 
        public Dictionary<string, string> HashGetAll(string Key)
        {
            try
            {
                HashEntry[] HashTable = Do(db => db.HashGetAll(Key));
                Dictionary<string, string> Result = new Dictionary<string, string>();
                for (int i = 0; i < HashTable.Length; i++)
                {
                    Result.Add(HashTable[i].Name, HashTable[i].Value.ToString());
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, string>();
            }
        }
 
 
 
 
        /// 
        /// 获取该键上的Hash表上的Key对应的值
        /// 
        /// 键
        /// Hash键
        /// 
        public string HashGet(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashGet(Key, HashKey));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 获取该键上的Hash表上的批量Key对应的批量值
        /// 
        /// 键
        /// Hash键集合
        /// 
        public List<string> HashGet(string Key, string[] HashKeys)
        {
            try
            {
                RedisValue[] _RedisValue = new RedisValue[HashKeys.Length];
                for (int i = 0; i < HashKeys.Length; i++)
                {
                    _RedisValue[i] = HashKeys[i];
                }
                return Do(db =>
                {
                    RedisValue[] Value = db.HashGet(Key, _RedisValue);
                    List<string> Result = new List<string>();
                    for (int i = 0; i < Value.Length; i++)
                    {
                        Result.Add(Value[i].ToString());
                    }
                    return Result;
                });
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 返回该键上的Hash表上的Key是否已经添加
        /// 
        /// 键
        /// Hash键
        /// 
        public bool HashExists(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashExists(Key, HashKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 移除该键上的Hash表上的键值
        /// 
        /// 键
        /// Hash键
        /// 
        public bool HashDelete(string Key, string HashKey)
        {
            try
            {
                return Do(db => db.HashDelete(Key, HashKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        ///  批量移除该键上的Hash表上的键值
        /// 
        /// 键
        /// Hash键集合
        /// 
        public long HashDelete(string Key, string[] HashKeys)
        {
            try
            {
                RedisValue[] _RedisValue = new RedisValue[HashKeys.Length];
                for (int i = 0; i < HashKeys.Length; i++)
                {
                    _RedisValue[i] = HashKeys[i];
                }
                return Do(db => db.HashDelete(Key, _RedisValue));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 获取该键上的Hash表上的所有Key
        /// 
        /// 键
        /// 
        public List<string> HashKeys(string Key)
        {
            try
            {
                return Do(db => RedisValueToList(db.HashKeys(Key)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
        #endregion
 
 
        #region ------------------------List  操作 ----------------------
 
 
        /// 
        /// 入队，加入到List尾部
        /// 
        /// 键
        /// 值
        public long ListRightPush(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListRightPush(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 出队，获取尾部元素并移除
        /// 
        /// 键
        /// 
        public string ListRightPop(string Key)
        {
            try
            {
                return Do(db => db.ListRightPop(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 入栈，加入到List头部
        /// 
        /// 键
        /// 值
        public long ListLeftPush(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListLeftPush(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 出栈，获取头部元素并移除
        /// 
        /// 键
        /// 
        public string ListLeftPop(string Key)
        {
            try
            {
                return Do(db => db.ListLeftPop(Key));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 移除指定List的某个元素
        /// 
        /// 键
        /// 元素值
        public long ListRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.ListRemove(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 获取指定Key的List
        /// 
        /// 键
        /// 起始位置
        /// 结束位置
        /// 
        public List<string> ListGet(string Key, long Start = 1, long End = 0)
        {
            try
            {
                Start--;
                End--;
                return RedisValueToList(Do(db => db.ListRange(Key, Start, End)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 返回存储在键列表中的索引索引中的元素。
        /// 
        /// 键
        /// 元素索引，负指数可用于指定起始于尾部的元素。-1表示最后一个元素，-2表示倒数第二个
        /// 
        public string ListGetByIndex(string Key, long Index)
        {
            try
            {
                return Do(db => db.ListGetByIndex(Key, Index));
            }
            catch
            {
                return null;
            }
        }
 
 
 
 
        /// 
        /// 获取集合中的数量
        /// 
        /// 键
        /// 
        public long ListLength(string Key)
        {
            try
            {
                return Do(redis => redis.ListLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------Set  操作-----------------------
 
 
        /// 
        /// 增加一条数据到Set集合
        /// 
        /// 键
        /// 值
        /// 
        public bool SetAdd(string Key, string Value)
        {
            try
            {
                return Do(db => db.SetAdd(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 增加多条数据到Set集合
        /// 
        /// 键
        /// 值集合
        /// 
        public long SetAdd(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SetAdd(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将多个Set集合进行运算操作，返回运算后的集合
        /// 
        /// 运算标识，0：并集去重，1：交集，2：差集
        /// 键集合
        /// 
        public List<string> SetCombine(int Operation, List<string> Keys)
        {
            try
            {
                SetOperation operation = SetOperation.Union;
                switch (Operation)
                {
                    case 1:
                        operation = SetOperation.Intersect;
                        break;
                    case 2:
                        operation = SetOperation.Difference;
                        break;
                }
 
                return RedisValueToList(Do(db => db.SetCombine(operation, ListToRedisKey(Keys))));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 将2个Set集合进行运算操作，返回运算后的集合
        /// 
        /// 运算标识，0：并集，1：交集，2：差集
        /// 集合1
        /// 集合2
        /// 
        public List<string> SetCombine(int Operation, string First, string Second)
        {
            try
            {
                SetOperation operation = SetOperation.Union;
                switch (Operation)
                {
                    case 1:
                        operation = SetOperation.Intersect;
                        break;
                    case 2:
                        operation = SetOperation.Difference;
                        break;
                }
 
                return RedisValueToList(Do(db => db.SetCombine(operation, First, Second)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 返回该Set集合的元素数量
        /// 
        /// 键
        /// 
        public long SetLength(string Key)
        {
            try
            {
                return Do(db => db.SetLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 获取该Set集合所有元素
        /// 
        /// 键
        /// 
        public List<string> SetMembers(string Key)
        {
            try
            {
                return RedisValueToList(Do(db => db.SetMembers(Key)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 删除Set集合中的某个元素
        /// 
        /// 键
        /// 值
        /// 
        public bool SetRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.SetRemove(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 批量删除Set集合中的元素
        /// 
        /// 键
        /// 值集合
        /// 
        public long SetRemove(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SetRemove(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region --------------------SortedSet  操作--------------------
 
 
        /// 
        /// 增加一条数据到SortedSet集合
        /// 
        /// 键
        /// 值
        /// 分数，作为排序依据
        /// 
        public bool SortedSetAdd(string Key, string Value, double OrderValue)
        {
            try
            {
                return Do(db => db.SortedSetAdd(Key, Value, OrderValue));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 增加多条数据到SortedSet集合
        /// 
        /// 键
        /// 元素集合{ 值，排序值 }
        /// 
        public long SortedSetAdd(string Key, Dictionary<string, double> SortedSetData)
        {
            try
            {
                List SortedSetTable = new List();
                foreach (var item in SortedSetData.Keys)
                {
                    SortedSetTable.Add(new SortedSetEntry(item, SortedSetData[item]));
                }
                return Do(db => db.SortedSetAdd(Key, SortedSetTable.ToArray()));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 返回该SortedSet集合的元素数量
        /// 
        /// 键
        /// 
        public long SortedSetLength(string Key)
        {
            try
            {
                return Do(db => db.SortedSetLength(Key));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将指定SortedSet的值的分数做加法运算
        /// 
        /// 键
        /// 值
        /// 增加值，可以为负
        /// 增长后的值
        public double SortedSetIncrement(string Key, string SortedSetValue, double Value)
        {
            try
            {
                return Do(db => db.SortedSetIncrement(Key, SortedSetValue, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 将指定SortedSet的值的分数做减法运算
        /// 
        /// 键
        /// 值
        /// 减少值，可以为负
        /// 减少后的值
        public double SortedSetDecrement(string Key, string SortedSetValue, double Value)
        {
            try
            {
                return Do(db => db.SortedSetDecrement(Key, SortedSetValue, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 返回排序后的元素的值的集合
        /// 
        /// 键
        /// 起始排名
        /// 结束排名
        /// 正序或倒序 0：低-高  1：高-低 
        /// 
        public List<string> SortedSetRangeByRank(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
                return RedisValueToList(Do(db => db.SortedSetRangeByRank(Key, Start, End, _Order)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 返回排序后的元素集合
        /// 
        /// 键
        /// 起始排名
        /// 结束排名
        /// 正序或倒序 0：低-高  1：高-低
        /// 
        public Dictionary<string, double> SortedSetRangeByRankWithScores(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
 
                SortedSetEntry[] _SortedSetEntry = Do(db => db.SortedSetRangeByRankWithScores(Key, Start, End, _Order));
                Dictionary<string, double> Result = new Dictionary<string, double>();
                foreach (var item in _SortedSetEntry)
                {
                    Result.Add(item.Element, item.Score);
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, double>();
            }
        }
 
 
 
 
        /// 
        /// 返回指定分数区间的元素的值的集合
        /// 
        /// 键
        /// 最低分
        /// 最高分
        /// 正序或倒序 0：低-高  1：高-低
        /// 
        public List<string> SortedSetRangeByScore(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
                return RedisValueToList(Do(db => db.SortedSetRangeByScore(Key, Start, End, Exclude.None, _Order)));
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// 返回指定分数区间的元素集合
        /// 
        /// 键
        /// 最低分
        /// 最高分
        /// 正序或倒序 0：低-高  1：高-低
        /// 
        public Dictionary<string, double> SortedSetRangeByScoreWithScores(string Key, long Start = 1, long End = 0, int OrderType = 0)
        {
            try
            {
                Order _Order = default(Order);
                SortedSetParm(ref Start, ref End, OrderType, ref _Order);
 
                SortedSetEntry[] _SortedSetEntry = Do(db => db.SortedSetRangeByScoreWithScores(Key, Start, End, Exclude.None, _Order));
                Dictionary<string, double> Result = new Dictionary<string, double>();
                foreach (var item in _SortedSetEntry)
                {
                    Result.Add(item.Element, item.Score);
                }
                return Result;
            }
            catch
            {
                return new Dictionary<string, double>();
            }
        }
 
 
 
 
        /// 
        /// 获取某个元素的排名
        /// 
        /// 键
        /// 值
        /// 
        public long? SortedSetRank(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetRank(Key, Value)) + 1;
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 获取某个元素的分数
        /// 
        /// 键
        /// 值
        /// 
        public double? SortedSetScore(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetScore(Key, Value));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 删除SortedSet集合中某个元素
        /// 
        /// 键
        /// 值
        /// 
        public bool SortedSetRemove(string Key, string Value)
        {
            try
            {
                return Do(db => db.SortedSetRemove(Key, Value));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 批量删除SortedSet集合中的元素
        /// 
        /// 键
        /// 值集合
        /// 
        public long SortedSetRemove(string Key, List<string> Value)
        {
            try
            {
                return Do(db => db.SortedSetRemove(Key, ListToRedisValue(Value)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 删除排名区间的元素
        /// 
        /// 键
        /// 起始排名
        /// 结束排名
        /// 
        public long SortedSetRemoveRangeByRank(string Key, long Start, long End)
        {
            try
            {
                Start--;
                End--;
                return Do(db => db.SortedSetRemoveRangeByRank(Key, Start, End));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 删除分数区间的元素
        /// 
        /// 键
        /// 最小值
        /// 最大值
        /// 
        public long SortedSetRemoveRangeByScore(string Key, double Start, double End)
        {
            try
            {
                return Do(db => db.SortedSetRemoveRangeByScore(Key, Start, End));
            }
            catch
            {
                return -1;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------Key  操作-----------------------
 
 
        /// 
        /// 删除某个键
        /// 
        /// 键
        /// 是否删除成功
        public bool KeyDelete(string Key)
        {
            try
            {
                return Do(db => db.KeyDelete(Key));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 批量删除键
        /// 
        /// 键集合
        /// 成功删除的个数
        public long KeyDelete(List<string> Keys)
        {
            try
            {
                return Do(db => db.KeyDelete(ListToRedisKey(Keys)));
            }
            catch
            {
                return -1;
            }
        }
 
 
 
 
        /// 
        /// 判断键是否存在
        /// 
        /// 键
        /// 
        public bool KeyExists(string Key)
        {
            try
            {
                return Do(db => db.KeyExists(Key));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 重新命名Key
        /// 
        /// 旧的键
        /// 新的键
        /// 
        public bool KeyRename(string Key, string NewKey)
        {
            try
            {
                return Do(db => db.KeyRename(Key, NewKey));
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 设置键的过期时间
        /// 
        /// 键
        /// 时间长度(值+类型): S:秒 M:分钟 H:小时 D:天  例：100S (100秒)
        /// 
        public bool KeyExpire(string Key, string Expiry)
        {
            try
            {
                string Type = Expiry.Substring(Expiry.Length - 1, 1).ToUpper();
                string Value = Expiry.Substring(0, Expiry.Length - 1);
                TimeSpan? Ts = default(TimeSpan?);
 
                switch (Type)
                {
                    case "S":
                        Ts = TimeSpan.FromSeconds(Convert.ToDouble(Value));
                        break;
                    case "M":
                        Ts = TimeSpan.FromMinutes(Convert.ToDouble(Value));
                        break;
                    case "H":
                        Ts = TimeSpan.FromHours(Convert.ToDouble(Value));
                        break;
                    case "D":
                        Ts = TimeSpan.FromDays(Convert.ToDouble(Value));
                        break;
                }
 
                return Do(db => db.KeyExpire(Key, Ts));
            }
            catch
            {
                return false;
            }
        }
 
 
        #endregion
 
 
        #region ------------------------辅助方法------------------------
 
 
        /// 
        /// 设置排序参数
        /// 
        /// 起始位置
        /// 结束位置
        /// 排序标识
        /// 排序类型
        private void SortedSetParm(ref  long Start, ref long End, int OrderType, ref Order _Order)
        {
            Start--;
            End--;
            _Order = OrderType == 0 ? Order.Ascending : Order.Descending;
        }
 
 
 
 
        /// 
        /// List转RedisValue
        /// 
        /// List集合
        /// 
        private RedisValue[] ListToRedisValue(List<string> List)
        {
            List _RedisValue = new List();
            try
            {
                for (int i = 0; i < List.Count; i++)
                {
                    _RedisValue.Add(List[i]);
                }
                return _RedisValue.ToArray();
            }
            catch
            {
                return new List().ToArray();
            }
        }
 
 
 
 
        /// 
        /// RedisValue转List
        /// 
        /// RedisValue数组
        /// 
        private List<string> RedisValueToList(RedisValue[] _RedisValue)
        {
            List<string> List = new List<string>();
            try
            {
                for (int i = 0; i < _RedisValue.Length; i++)
                {
                    List.Add(_RedisValue[i]);
                }
                return List;
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
 
        /// 
        /// List转RedisKey
        /// 
        /// List集合
        /// 
        private RedisKey[] ListToRedisKey(List<string> List)
        {
            List RedisKey = new List();
            try
            {
                for (int i = 0; i < List.Count; i++)
                {
                    RedisKey.Add(List[i]);
                }
                return RedisKey.ToArray();
            }
            catch
            {
                return new List().ToArray();
            }
        }
 
 
 
 
        /// 
        /// RedisKey转List
        /// 
        /// RedisKey数组
        /// 
        private List<string> RedisKeyToList(RedisKey[] _RedisKey)
        {
            List<string> List = new List<string>();
            try
            {
                for (int i = 0; i < _RedisKey.Length; i++)
                {
                    List.Add(_RedisKey[i]);
                }
                return List;
            }
            catch
            {
                return new List<string>();
            }
        }
 
 
 
        /// 
        /// 执行Redis操作
        /// 
        private T Do(Func func)
        {
            var database = RedisConn.GetDatabase(DbNum);
            return func(database);
        }
 
 
        #endregion 辅助方法
 
 
        #region 其他操作
 
 
        /// 
        /// 获取当前Redis连接状态
        /// 
        /// 
        public bool GetConnectSate()
        {
            bool RedisIsConnected = false;
 
            try
            {
                if (RedisCmd.Api != null)
                {
                    RedisIsConnected = RedisCmd.Api.RedisConn.IsConnected ? true : false;
                    return RedisIsConnected;
                }
                return false;
            }
            catch
            {
                return false;
            }
        }
 
 
 
 
        /// 
        /// 获取数据库对象
        /// 
        /// 
        public IDatabase GetDatabase()
        {
            return RedisConn.GetDatabase(DbNum);
        }
 
 
        public ITransaction CreateTransaction()
        {
            return GetDatabase().CreateTransaction();
        }
 
 
        public IServer GetServer(string hostAndPort)
        {
            return RedisConn.GetServer(hostAndPort);
        }
 
 
 
        #endregion 其他
 
 
        #region 发布订阅
 
        /// 
        /// Redis发布订阅  订阅
        /// 
        /// 
        /// 
        //public void Subscribe(string subChannel, Action handler = null)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.Subscribe(subChannel, (channel, message) =>
        //    {
        //        if (handler == null)
        //        {
        //            Console.WriteLine(subChannel + " 订阅收到消息：" + message);
        //        }
        //        else
        //        {
        //            handler(channel, message);
        //        }
        //    });
        //}
 
        /// 
        /// Redis发布订阅  发布
        /// 
        /// 
        /// 
        /// 
        /// 
        //public long Publish(string channel, T msg)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    return sub.Publish(channel, (msg));
        //}
 
        /// 
        /// Redis发布订阅  取消订阅
        /// 
        /// 
        //public void Unsubscribe(string channel)
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.Unsubscribe(channel);
        //}
 
        /// 
        /// Redis发布订阅  取消全部订阅
        /// 
        //public void UnsubscribeAll()
        //{
        //    ISubscriber sub = RedisConn.GetSubscriber();
        //    sub.UnsubscribeAll();
        //}
 
        #endregion 发布订阅
 
 
    }
}

3、存放Redis操作对象的公共类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace RedisApi
{
 
    /// 
    /// 存放Redis操作对象的公共类
    /// 
    public static class RedisCmd
    {
        /// 
        /// Redis操作对象
        /// 
        public static RedisHelper Api = null;
    }

 }

4、使用示例

新建一个Web项目，在Global.asax.cs文件中的Application_Start()方法中，添加如下代码

if (RedisCmd.Api == null) {
    RedisHelper RedisApi = new RedisHelper(0);
    RedisCmd.Api = RedisApi;
}

从Redis中查询数据示例

 if (RedisCmd.Api.KeyExists("Home_Notify"))
 {
      ViewBag.Notify = RedisCmd.Api.HashGet("Home_Notify", "Title");
      ViewBag.ID = RedisCmd.Api.HashGet("Home_Notify", "AutoID");
 }

向Redis中新增数据示例

  RedisCmd.Api.HashSet("Home_Notify", "Title", NotifyText[0].Title);
  RedisCmd.Api.HashSet("Home_Notify", "AutoID", NotifyText[0].AutoID.ToString());
  RedisCmd.Api.KeyExpire("Home_Notify", "2h");

QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
PHP环境搭建详细教程好看资源平台前端 php
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）编程经验分享开发工具服务器 ssh linux
目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
python是什么意思中文-在python中%是什么意思编程大乐趣
Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师华为od 面试 python
华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
python os 环境变量 CV矿工 python 开发语言 numpy
环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
【PG】常见数据库、表属性设置江无羡数据库
PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python 开发语言
基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
EIO国际确定性的交易（3/10）资管，资金委托安全吗？古城鹏哥
大家可能都知道资金托管，账户是自己开，钱在自己的账户上，密码是由自己掌控，别人提不走你账户的资金，每天可以看下到自己的账户，也可以看到交易流水。现金只能提到自己的银行卡中。账户由技术人员或操作人员，或者是机构团队帮你操作账户，产生盈利和收入，以获得的利润来分配盈利，技术强硬和做的时间久了过硬技术团队，会保证你的资金本金，不会让你的本金亏损的按照一定比例分配收入。所以在这个过程当中一定要看清楚技术的
Shell、Bash、Zsh这都是啥啊小白码上飞 bash linux 开发语言
Zsh和Bash都是我们常用的Shell，那先搞明白啥是shell吧。Shell作为一个单词，他是“壳”的意思，蛋壳坚果壳。之所以叫壳，是为了和计算机的“核”来区分，用它表示“为使用者提供的操作界面”。所以这个命名其实很形象，翻译成中文，直译过来叫“壳层”。个人认为这个叫法很奇怪，意译貌似也没有什么好的词汇来匹配。就还是叫shell吧。维基百科给的定义是：Incomputing,ashellisa
ios GCD _Waiting_
1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
关于Mysql 中 Row size too large (＞ 8126) 错误的解决和理解秋刀prince mysql mysql 数据库
提示：啰嗦一嘴，数据库的任何操作和验证前，一定要记得先备份！！！不会有错；文章目录问题发现一、问题导致的可能原因1、页大小2、行格式2.1compact格式2.2Redundant格式2.3Dynamic格式2.4Compressed格式3、BLOB和TEXT列二、解决办法1、修改页大小（不推荐）2、修改行格式3、修改数据类型为BLOB和TEXT列4、其他优化方式（可以参考使用）4.1合理设置数据
一文掌握python面向对象魔术方法（二）程序员neil python python 开发语言
接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
一文掌握python常用的list（列表）操作程序员neil python python 开发语言
目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
2.2.6 通知类控件 Toast、Menu 常思行
本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
【从浅识到熟知Linux】Linux发展史 Jammingpro 从浅学到熟知Linux linux 运维服务器
归属专栏：从浅学到熟知Linux个人主页：Jammingpro每日努力一点点，技术变化看得见文章前言：本篇文章记录Linux发展的历史，因在介绍Linux过程中涉及的其他操作系统及人物，本文对相关内容也有所介绍。文章目录Unix发展史Linux发展史开源Linux官网企业应用情况发行版本在学习Linux前，我们可能都会问Linux从哪里来？它是如何发展的。但在介绍Linux之前，需要先介绍一下Un
linux 发展史种树的猴子内核 java 操作系统 linux 大数据
linux发展史说明此前对linux认识模糊一知半解，近期通过学习将自己对于linux的发展总结一下方便大家日后的学习。那Linux是目前一款非常火热的开源操作系统，可是linux是什么时候出现的，又是因为什么样的原因被开发出来的呢。以下将对linux的发展历程进行详细的讲解。目录一、Linux发展背景二、UINIX的诞生三、UNIX的重要分支-BSD的诞生四、Minix的诞生五、GNU与Free
2024.9.6 Python，华为笔试题总结，字符串格式化，字符串操作，广度优先搜索解决公司组织绩效互评问题，无向图 RaidenQ python 华为 leetcode 算法力扣广度优先无向图
1.字符串格式化name="Alice"age=30formatted_string="Name:{},Age:{}".format(name,age)print(formatted_string)或者name="Alice"age=30formatted_string=f"Name:{name},Age:{age}"print(formatted_string)2.网络健康检查第一行有两个整数m
2024.9.14 Python，差分法解决区间加法，消除游戏，压缩字符串 RaidenQ python 游戏开发语言算法力扣
1.区间加法假设你有一个长度为n的数组，初始情况下所有的数字均为0，你将会被给出k个更新的操作。其中，每个操作会被表示为一个三元组：[startIndex,endIndex,inc]，你需要将子数组A[startIndex…endIndex]（包括startIndex和endIndex）增加inc。请你返回k次操作后的数组。示例:输入:length=5,updates=[[1,3,2],[2,4,
4.C_数据结构_队列荣世蓥数据结构数据结构
概述什么是队列：队列是限定在两端进行插入操作和删除操作的线性表。具有先入先出(FIFO)的特点相关名词：队尾：写入数据的一段队头：读取数据的一段空队：队列中没有数据，队头指针=队尾指针满队：队列中存满了数据，队尾指针+1=队头指针循环队列1、基本内容循环队列是以数组形式构成的队列数据结构。循环队列的结构体如下：typedefintdata_t;//队列数据类型#defineN64//队列容量typ
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
继之前的线程循环加到窗口中运行 3213213333332132 java thread JFrame JPanel
之前写了有关java线程的循环执行和结束，因为想制作成exe文件，想把执行的效果加到窗口上，所以就结合了JFrame和JPanel写了这个程序，这里直接贴出代码，在窗口上运行的效果下面有附图。 package thread; import java.awt.Graphics; import java.text.SimpleDateFormat; import java.util
linux 常用命令 BlueSkator linux 命令
1.grep 相信这个命令可以说是大家最常用的命令之一了。尤其是查询生产环境的日志，这个命令绝对是必不可少的。但之前总是习惯于使用（grep -n 关键字文件名）查出关键字以及该关键字所在的行数，然后再用（sed -n '100,200p' 文件名），去查出该关键字之后的日志内容。但其实还有更简便的办法，就是用（grep -B n、-A n、-C n 关键
php heredoc原文档和nowdoc语法 dcj3sjt126com PHP heredoc nowdoc
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body> <?
overflow的属性周华华 JavaScript
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
《我所了解的Java》——总体目录 g21121 java
准备用一年左右时间写一个系列的文章《我所了解的Java》，目录及内容会不断完善及调整。在编写相关内容时难免出现笔误、代码无法执行、名词理解错误等，请大家及时指出，我会第一时间更正。 &n
[简单]docx4j常用方法小结 53873039oycg docx
本代码基于docx4j-3.2.0，在office word 2007上测试通过。代码如下: import java.io.File; import java.io.FileInputStream; import ja
Spring配置学习云端月影 spring配置
首先来看一个标准的Spring配置文件 applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=&q
Java新手入门的30个基本概念三 aijuans java 新手 java 入门
17.Java中的每一个类都是从Object类扩展而来的。　　18.object类中的equal和toString方法。　　equal用于测试一个对象是否同另一个对象相等。　　toString返回一个代表该对象的字符串,几乎每一个类都会重载该方法,以便返回当前状态的正确表示.(toString 方法是一个很重要的方法)　　 19.通用编程:任何类类型的所有值都可以同object类性的变量来代替。　
《2008 IBM Rational 软件开发高峰论坛会议》小记 antonyup_2006 软件测试敏捷开发项目管理 IBM 活动
我一直想写些总结,用于交流和备忘,然都没提笔,今以一篇参加活动的感受小记开个头,呵呵! 其实参加《2008 IBM Rational 软件开发高峰论坛会议》是9月4号,那天刚好调休.但接着项目颇为忙,所以今天在中秋佳节的假期里整理了下. 参加这次活动是一个朋友给的一个邀请书,才知道有这样的一个活动,虽然现在项目暂时没用到IBM的解决方案,但觉的参与这样一个活动可以拓宽下视野和相关知识.
PL/SQL的过程编程,异常,声明变量,PL/SQL块百合不是茶 PL/SQL的过程编程异常 PL/SQL块声明变量
PL/SQL; 过程; 符号; 变量; PL/SQL块; 输出; 异常; PL/SQL 是过程语言(Procedural Language)与结构化查询语言(SQL)结合而成的编程语言PL/SQL 是对 SQL 的扩展,sql的执行时每次都要写操作
Mockito(三)--完整功能介绍 bijian1013 持续集成 mockito 单元测试
mockito官网：http://code.google.com/p/mockito/，打开documentation可以看到官方最新的文档资料。一.使用mockito验证行为 //首先要import Mockito import static org.mockito.Mockito.*; //mo
精通Oracle10编程SQL(8)使用复合数据类型 bijian1013 oracle 数据库 plsql
/* *使用复合数据类型 */ --PL/SQL记录 --定义PL/SQL记录 --自定义PL/SQL记录 DECLARE TYPE emp_record_type IS RECORD( name emp.ename%TYPE, salary emp.sal%TYPE, dno emp.deptno%TYPE ); emp_
【Linux常用命令一】grep命令 bit1129 Linux常用命令
grep命令格式 grep [option] pattern [file-list] grep命令用于在指定的文件(一个或者多个,file-list)中查找包含模式串(pattern)的行,[option]用于控制grep命令的查找方式。 pattern可以是普通字符串，也可以是正则表达式，当查找的字符串包含正则表达式字符或者特
mybatis3入门学习笔记白糖_ sql ibatis qq jdbc 配置管理
MyBatis 的前身就是iBatis，是一个数据持久层(ORM)框架。 MyBatis 是支持普通 SQL 查询，存储过程和高级映射的优秀持久层框架。MyBatis对JDBC进行了一次很浅的封装。以前也学过iBatis，因为MyBatis是iBatis的升级版本，最初以为改动应该不大，实际结果是MyBatis对配置文件进行了一些大的改动，使整个框架更加方便人性化。
Linux 命令神器：lsof 入门 ronin47 lsof
lsof是系统管理/安全的尤伯工具。我大多数时候用它来从系统获得与网络连接相关的信息，但那只是这个强大而又鲜为人知的应用的第一步。将这个工具称之为lsof真实名副其实，因为它是指“列出打开文件（lists openfiles）”。而有一点要切记，在Unix中一切（包括网络套接口）都是文件。有趣的是，lsof也是有着最多
java实现两个大数相加，可能存在溢出。 bylijinnan java实现
import java.math.BigInteger; import java.util.regex.Matcher; import java.util.regex.Pattern; public class BigIntegerAddition { /** * 题目：java实现两个大数相加，可能存在溢出。 * 如123456789 + 987654321
Kettle学习资料分享，附大神用Kettle的一套流程完成对整个数据库迁移方法 Kai_Ge Kettle
Kettle学习资料分享 Kettle 3.2 使用说明书目录概述..........................................................................................................................................7 1.Kettle 资源库管
[货币与金融]钢之炼金术士 comsci 金融
自古以来,都有一些人在从事炼金术的工作.........但是很少有成功的那么随着人类在理论物理和工程物理上面取得的一些突破性进展...... 炼金术这个古老
Toast原来也可以多样化 dai_lm android toast
Style 1：默认 Toast def = Toast.makeText(this, "default", Toast.LENGTH_SHORT); def.show(); Style 2：顶部显示 Toast top = Toast.makeText(this, "top", Toast.LENGTH_SHORT); t
java数据计算的几种解决方法3 datamachine java hadoop ibatis r-langue r
4、iBatis 简单敏捷因此强大的数据计算层。和Hibernate不同，它鼓励写SQL，所以学习成本最低。同时它用最小的代价实现了计算脚本和JAVA代码的解耦，只用20%的代价就实现了hibernate 80%的功能,没实现的20%是计算脚本和数据库的解耦。复杂计算环境是它的弱项，比如：分布式计算、复杂计算、非数据
向网页中插入透明Flash的方法和技巧 dcj3sjt126com html Web Flash
将 Flash 作品插入网页的时候，我们有时候会需要将它设为透明，有时候我们需要在Flash的背面插入一些漂亮的图片，搭配出漂亮的效果……下面我们介绍一些将Flash插入网页中的一些透明的设置技巧。　　一、Swf透明、无坐标控制　　首先教大家最简单的插入Flash的代码，透明，无坐标控制：　　注意wmode="transparent"是控制Flash是否透明
ios UICollectionView的使用 dcj3sjt126com
UICollectionView的使用有两种方法，一种是继承UICollectionViewController，这个Controller会自带一个UICollectionView；另外一种是作为一个视图放在普通的UIViewController里面。个人更喜欢第二种。下面采用第二种方式简单介绍一下UICollectionView的使用。 1.UIViewController实现委托，代码如
Eos平台java公共逻辑蕃薯耀 Eos平台java公共逻辑 Eos平台 java公共逻辑
Eos平台java公共逻辑 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月1日 17:20:4
SpringMVC4零配置--Web上下文配置【MvcConfig】 hanqunfeng springmvc4
与SpringSecurity的配置类似，spring同样为我们提供了一个实现类WebMvcConfigurationSupport和一个注解@EnableWebMvc以帮助我们减少bean的声明。 applicationContext-MvcConfig.xml  <
解决ie和其他浏览器poi下载excel文件名乱码 jackyrong Excel
使用poi,做传统的excel导出，然后想在浏览器中，让用户选择另存为，保存用户下载的xls文件，这个时候，可能的是在ie下出现乱码（ie,9,10,11),但在firefox,chrome下没乱码，因此必须综合判断，编写一个工具类： /** * * @Title: pro
挥洒泪水的青春 lampcy 编程生活程序员
2015年2月28日，我辞职了，离开了相处一年的触控，转过身--挥洒掉泪水，毅然来到了兄弟连，背负着许多的不解、质疑——”你一个零基础、脑子又不聪明的人，还敢跨行业，选择Unity3D？“，”真是不自量力••••••“，”真是初生牛犊不怕虎•••••“，••••••我只是淡淡一笑，拎着行李----坐上了通向挥洒泪水的青春之地——兄弟连！这就是我青春的分割线，不后悔，只会去用泪水浇灌——已经来到
稳增长之中国股市两点意见-----严控做空，建立涨跌停版停牌重组机制 nannan408
对于股市，我们国家的监管还是有点拼的，但始终拼不过飞流直下的恐慌，为什么呢？笔者首先支持股市的监管。对于股市越管越荡的现象，笔者认为首先是做空力量超过了股市自身的升力，并且对于跌停停牌重组的快速反应还没建立好，上市公司对于股价下跌没有很好的利好支撑。我们来看美国和香港是怎么应对股灾的。美国是靠禁止重要股票做空，在
动态设置iframe高度(iframe高度自适应) Rainbow702 JavaScript iframe contentDocument 高度自适应局部刷新
如果需要对画面中的部分区域作局部刷新，大家可能都会想到使用ajax。但有些情况下，须使用在页面中嵌入一个iframe来作局部刷新。对于使用iframe的情况，发现有一个问题，就是iframe中的页面的高度可能会很高，但是外面页面并不会被iframe内部页面给撑开，如下面的结构： <div id="content"> <div id=&quo
用Rapael做图表 tntxia rap
function drawReport(paper,attr,data){ var width = attr.width; var height = attr.height; var max = 0; &nbs
HTML5 bootstrap2网页兼容（支持IE10以下） xiaoluode html5 bootstrap
<!DOCTYPE html> <html> <head lang="zh-CN"> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge">

Redis 操作帮助类

你可能感兴趣的:(Redis 操作帮助类)