皮卡球ca
皮卡球ca

DB|Redis快速入手，NET起跑

DB|Redis快速入手，NET起跑_第1张图片
image

Redis可以完美实现高速缓存的功能，同时也具备了数据库的所有技能（Redis称之为数据持久化）。前者可以秒掉memcached，后者原则上可以替代传统数据库，但鉴于Mysql，SQL Server，Oracle等关系型数据库所占领的领地非常广泛，处理的问题相当复杂，Redis要完全取而代之，尚需时日。事实上，任何一种技术都无法独步天下，我们只是择其善者而用之。

可以肯定的是，Redis在数据缓存和存储方面确实有着不可比拟的优势，在传统数据库难顾首位的应用场景里，Redis大放异彩。

1）热点数据（缓存）
热点数据（经常会被查询，但极少变更的数据），大量密集的访问对速度和定位都由着较高的要求，QPS和极强的稳定性成为reidis的必杀技。

2）计数器
传统DB在处理并发访问时，可能存在脏读的情况，Redis采用单线程，可以避免并发问题，同时保证100%毫秒级性能。

3）队列

4）位操作

5）分布式锁与单线程机制

关于队列和计数等操作，已在文末提供的工具类中加以封装，可以直接取用。

1.下载

官方网站 https://redis.io/
官方网站（中） http://www.redis.cn/
入门文档 http://www.runoob.com/redis/redis-tutorial.html
DB|Redis快速入手，NET起跑_第2张图片
image

建议去github下载 https://github.com/MicrosoftArchive/redis/releases

安装过程非常简单，下载解压缩后，命令行定位到相应目录执行命令就可以了，github很贴心地打了包，也可以直接执行他们的安装程序。

安装成功的界面如下：

DB|Redis快速入手，NET起跑_第3张图片
image

2.配置

由于我此前已经安装过，所以显示端口被占用了。


DB|Redis快速入手，NET起跑_第4张图片
image

关于数据库的默认端口，记住这个就可以了。


image.png

密码设置 config set requirepass test123

用过MySQL的同学是不是感到很亲切，熟悉的套路熟悉的感觉，没错，和MySQL一样，Redis也有较为成熟的管理工具，我选择了redisdesktop，下载地址 https://redisdesktop.com/，界面非常友好。

DB|Redis快速入手，NET起跑_第5张图片
redisdesktop连接界面
DB|Redis快速入手，NET起跑_第6张图片
redisdesktop管理界面

更多设置可以参考 http://www.runoob.com/redis/redis-install.html

3.测试

DB|Redis快速入手，NET起跑_第7张图片
key-value设置及读取

4.工具及API

Redis非常良心的一点是提供了丰富而强大的api支持，作为C#从业人员，本次分享C#的两个工具类，需要的话可以直接取用。工具类依赖于StackExchange.Redis包，请使用nuget自行安装。

RedisConnectionHelp .cs

using StackExchange.Redis;
using System;
using System.Collections.Concurrent;
using System.Configuration;


namespace RedisHelper
{
    /// 
    /// ConnectionMultiplexer对象管理帮助类
    /// 
    public static class RedisConnectionHelp
    {
        //系统自定义Key前缀
        public static readonly string SysCustomKey = ConfigurationManager.AppSettings["RedisKey"] ?? "";

        //"127.0.0.1:6379,allowadmin=true
        private static readonly string RedisConnectionString = ConfigurationManager.AppSettings["RedisExchangeHosts"];

        private static readonly object Locker = new object();
        private static ConnectionMultiplexer _instance;
        private static readonly ConcurrentDictionary ConnectionCache = new ConcurrentDictionary();

        /// 
        /// 单例获取
        /// 
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if (_instance == null)
                {
                    lock (Locker)
                    {
                        if (_instance == null || !_instance.IsConnected)
                        {
                            _instance = GetManager();
                        }
                    }
                }
                return _instance;
            }
        }

        /// 
        /// 缓存获取
        /// 
        /// 
        /// 
        public static ConnectionMultiplexer GetConnectionMultiplexer(string connectionString)
        {
            if (!ConnectionCache.ContainsKey(connectionString))
            {
                ConnectionCache[connectionString] = GetManager(connectionString);
            }
            return ConnectionCache[connectionString];
        }

        private static ConnectionMultiplexer GetManager(string connectionString = null)
        {
            connectionString = connectionString ?? RedisConnectionString;
            var connect = ConnectionMultiplexer.Connect(connectionString);

            //注册如下事件
            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)
        {
            Console.WriteLine("Configuration changed: " + e.EndPoint);
        }

        /// 
        /// 发生错误时
        /// 
        /// 
        /// 
        private static void MuxerErrorMessage(object sender, RedisErrorEventArgs e)
        {
            Console.WriteLine("ErrorMessage: " + e.Message);
        }

        /// 
        /// 重新建立连接之前的错误
        /// 
        /// 
        /// 
        private static void MuxerConnectionRestored(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine("ConnectionRestored: " + e.EndPoint);
        }

        /// 
        /// 连接失败 ， 如果重新连接成功你将不会收到这个通知
        /// 
        /// 
        /// 
        private static void MuxerConnectionFailed(object sender, ConnectionFailedEventArgs e)
        {
            Console.WriteLine("重新连接：Endpoint failed: " + e.EndPoint + ", " + e.FailureType + (e.Exception == null ? "" : (", " + e.Exception.Message)));
        }

        /// 
        /// 更改集群
        /// 
        /// 
        /// 
        private static void MuxerHashSlotMoved(object sender, HashSlotMovedEventArgs e)
        {
            Console.WriteLine("HashSlotMoved:NewEndPoint" + e.NewEndPoint + ", OldEndPoint" + e.OldEndPoint);
        }

        /// 
        /// redis类库错误
        /// 
        /// 
        /// 
        private static void MuxerInternalError(object sender, InternalErrorEventArgs e)
        {
            Console.WriteLine("InternalError:Message" + e.Exception.Message);
        }

        #endregion 事件
    }
}

RedisHelper .cs


using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Newtonsoft.Json;
using StackExchange.Redis;


namespace RedisUtil
{
    /// 
    /// Redis操作
    /// 
    public class RedisHelper
    {
        private int DbNum { get; set; }
        private readonly ConnectionMultiplexer _conn;
        public string CustomKey;

        #region 构造函数

        public RedisHelper(int dbNum = 0)
                : this(dbNum, null)
        {
        }

        public RedisHelper(int dbNum, string readWriteHosts)
        {
            DbNum = dbNum;
            _conn =
                string.IsNullOrWhiteSpace(readWriteHosts) ?
                RedisConnectionHelp.Instance :
                RedisConnectionHelp.GetConnectionMultiplexer(readWriteHosts);
        }

        #endregion 构造函数

        #region String

        #region 同步方法

        /// 
        /// 保存单个key value
        /// 
        /// Redis Key
        /// 保存的值
        /// 过期时间
        /// 
        public bool StringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            return Do(db => db.StringSet(key, value, expiry));
        }

        /// 
        /// 保存多个key value
        /// 
        /// 键值对
        /// 
        public bool StringSet(List> keyValues)
        {
            List> newkeyValues =
                keyValues.Select(p => new KeyValuePair(AddSysCustomKey(p.Key), p.Value)).ToList();
            return Do(db => db.StringSet(newkeyValues.ToArray()));
        }

        /// 
        /// 保存一个对象
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public bool StringSet(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            string json = ConvertJson(obj);
            return Do(db => db.StringSet(key, json, expiry));
        }

        /// 
        /// 获取单个key的值
        /// 
        /// Redis Key
        /// 
        public string StringGet(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.StringGet(key));
        }

        /// 
        /// 获取多个Key
        /// 
        /// Redis Key集合
        /// 
        public RedisValue[] StringGet(List listKey)
        {
            List newKeys = listKey.Select(AddSysCustomKey).ToList();
            return Do(db => db.StringGet(ConvertRedisKeys(newKeys)));
        }

        /// 
        /// 获取一个key的对象
        /// 
        /// 
        /// 
        /// 
        public T StringGet(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db => ConvertObj(db.StringGet(key)));
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public double StringIncrement(string key, double val = 1)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.StringIncrement(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public double StringDecrement(string key, double val = 1)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.StringDecrement(key, val));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 保存单个key value
        /// 
        /// Redis Key
        /// 保存的值
        /// 过期时间
        /// 
        public async Task StringSetAsync(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.StringSetAsync(key, value, expiry));
        }

        /// 
        /// 保存多个key value
        /// 
        /// 键值对
        /// 
        public async Task StringSetAsync(List> keyValues)
        {
            List> newkeyValues =
                keyValues.Select(p => new KeyValuePair(AddSysCustomKey(p.Key), p.Value)).ToList();
            return await Do(db => db.StringSetAsync(newkeyValues.ToArray()));
        }

        /// 
        /// 保存一个对象
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public async Task StringSetAsync(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            string json = ConvertJson(obj);
            return await Do(db => db.StringSetAsync(key, json, expiry));
        }

        /// 
        /// 获取单个key的值
        /// 
        /// Redis Key
        /// 
        public async Task StringGetAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.StringGetAsync(key));
        }

        /// 
        /// 获取多个Key
        /// 
        /// Redis Key集合
        /// 
        public async Task StringGetAsync(List listKey)
        {
            List newKeys = listKey.Select(AddSysCustomKey).ToList();
            return await Do(db => db.StringGetAsync(ConvertRedisKeys(newKeys)));
        }

        /// 
        /// 获取一个key的对象
        /// 
        /// 
        /// 
        /// 
        public async Task StringGetAsync(string key)
        {
            key = AddSysCustomKey(key);
            string result = await Do(db => db.StringGetAsync(key));
            return ConvertObj(result);
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public async Task StringIncrementAsync(string key, double val = 1)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.StringIncrementAsync(key, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public async Task StringDecrementAsync(string key, double val = 1)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.StringDecrementAsync(key, val));
        }

        #endregion 异步方法

        #endregion String

        #region Hash

        #region 同步方法

        /// 
        /// 判断某个数据是否已经被缓存
        /// 
        /// 
        /// 
        /// 
        public bool HashExists(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.HashExists(key, dataKey));
        }

        /// 
        /// 存储数据到hash表
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public bool HashSet(string key, string dataKey, T t)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                string json = ConvertJson(t);
                return db.HashSet(key, dataKey, json);
            });
        }

        /// 
        /// 移除hash中的某值
        /// 
        /// 
        /// 
        /// 
        public bool HashDelete(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.HashDelete(key, dataKey));
        }

        /// 
        /// 移除hash中的多个值
        /// 
        /// 
        /// 
        /// 
        public long HashDelete(string key, List dataKeys)
        {
            key = AddSysCustomKey(key);
            //List dataKeys1 = new List() {"1","2"};
            return Do(db => db.HashDelete(key, dataKeys.ToArray()));
        }

        /// 
        /// 从hash表获取数据
        /// 
        /// 
        /// 
        /// 
        /// 
        public T HashGet(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                string value = db.HashGet(key, dataKey);
                return ConvertObj(value);
            });
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public double HashIncrement(string key, string dataKey, double val = 1)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.HashIncrement(key, dataKey, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public double HashDecrement(string key, string dataKey, double val = 1)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.HashDecrement(key, dataKey, val));
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        /// 
        public List HashKeys(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                RedisValue[] values = db.HashKeys(key);
                return ConvetList(values);
            });
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 判断某个数据是否已经被缓存
        /// 
        /// 
        /// 
        /// 
        public async Task HashExistsAsync(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.HashExistsAsync(key, dataKey));
        }

        /// 
        /// 存储数据到hash表
        /// 
        /// 
        /// 
        /// 
        /// 
        /// 
        public async Task HashSetAsync(string key, string dataKey, T t)
        {
            key = AddSysCustomKey(key);
            return await Do(db =>
            {
                string json = ConvertJson(t);
                return db.HashSetAsync(key, dataKey, json);
            });
        }

        /// 
        /// 移除hash中的某值
        /// 
        /// 
        /// 
        /// 
        public async Task HashDeleteAsync(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.HashDeleteAsync(key, dataKey));
        }

        /// 
        /// 移除hash中的多个值
        /// 
        /// 
        /// 
        /// 
        public async Task HashDeleteAsync(string key, List dataKeys)
        {
            key = AddSysCustomKey(key);
            //List dataKeys1 = new List() {"1","2"};
            return await Do(db => db.HashDeleteAsync(key, dataKeys.ToArray()));
        }

        /// 
        /// 从hash表获取数据
        /// 
        /// 
        /// 
        /// 
        /// 
        public async Task HashGeAsync(string key, string dataKey)
        {
            key = AddSysCustomKey(key);
            string value = await Do(db => db.HashGetAsync(key, dataKey));
            return ConvertObj(value);
        }

        /// 
        /// 为数字增长val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 增长后的值
        public async Task HashIncrementAsync(string key, string dataKey, double val = 1)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.HashIncrementAsync(key, dataKey, val));
        }

        /// 
        /// 为数字减少val
        /// 
        /// 
        /// 
        /// 可以为负
        /// 减少后的值
        public async Task HashDecrementAsync(string key, string dataKey, double val = 1)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.HashDecrementAsync(key, dataKey, val));
        }

        /// 
        /// 获取hashkey所有Redis key
        /// 
        /// 
        /// 
        /// 
        public async Task> HashKeysAsync(string key)
        {
            key = AddSysCustomKey(key);
            RedisValue[] values = await Do(db => db.HashKeysAsync(key));
            return ConvetList(values);
        }

        #endregion 异步方法

        #endregion Hash

        #region List

        #region 同步方法

        /// 
        /// 移除指定ListId的内部List的值
        /// 
        /// 
        /// 
        public void ListRemove(string key, T value)
        {
            key = AddSysCustomKey(key);
            Do(db => db.ListRemove(key, ConvertJson(value)));
        }

        /// 
        /// 获取指定key的List
        /// 
        /// 
        /// 
        public List ListRange(string key)
        {
            key = AddSysCustomKey(key);
            return Do(redis =>
            {
                var values = redis.ListRange(key);
                return ConvetList(values);
            });
        }

        /// 
        /// 入队
        /// 
        /// 
        /// 
        public void ListRightPush(string key, T value)
        {
            key = AddSysCustomKey(key);
            Do(db => db.ListRightPush(key, ConvertJson(value)));
        }

        /// 
        /// 出队
        /// 
        /// 
        /// 
        /// 
        public T ListRightPop(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
             {
                 var value = db.ListRightPop(key);
                 return ConvertObj(value);
             });
        }

        /// 
        /// 入栈
        /// 
        /// 
        /// 
        /// 
        public void ListLeftPush(string key, T value)
        {
            key = AddSysCustomKey(key);
            Do(db => db.ListLeftPush(key, ConvertJson(value)));
        }

        /// 
        /// 出栈
        /// 
        /// 
        /// 
        /// 
        public T ListLeftPop(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db =>
            {
                var value = db.ListLeftPop(key);
                return ConvertObj(value);
            });
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public long ListLength(string key)
        {
            key = AddSysCustomKey(key);
            return Do(redis => redis.ListLength(key));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 移除指定ListId的内部List的值
        /// 
        /// 
        /// 
        public async Task ListRemoveAsync(string key, T value)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.ListRemoveAsync(key, ConvertJson(value)));
        }

        /// 
        /// 获取指定key的List
        /// 
        /// 
        /// 
        public async Task> ListRangeAsync(string key)
        {
            key = AddSysCustomKey(key);
            var values = await Do(redis => redis.ListRangeAsync(key));
            return ConvetList(values);
        }

        /// 
        /// 入队
        /// 
        /// 
        /// 
        public async Task ListRightPushAsync(string key, T value)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.ListRightPushAsync(key, ConvertJson(value)));
        }

        /// 
        /// 出队
        /// 
        /// 
        /// 
        /// 
        public async Task ListRightPopAsync(string key)
        {
            key = AddSysCustomKey(key);
            var value = await Do(db => db.ListRightPopAsync(key));
            return ConvertObj(value);
        }

        /// 
        /// 入栈
        /// 
        /// 
        /// 
        /// 
        public async Task ListLeftPushAsync(string key, T value)
        {
            key = AddSysCustomKey(key);
            return await Do(db => db.ListLeftPushAsync(key, ConvertJson(value)));
        }

        /// 
        /// 出栈
        /// 
        /// 
        /// 
        /// 
        public async Task ListLeftPopAsync(string key)
        {
            key = AddSysCustomKey(key);
            var value = await Do(db => db.ListLeftPopAsync(key));
            return ConvertObj(value);
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public async Task ListLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await Do(redis => redis.ListLengthAsync(key));
        }

        #endregion 异步方法

        #endregion List

        #region SortedSet 有序集合

        #region 同步方法

        /// 
        /// 添加
        /// 
        /// 
        /// 
        /// 
        public bool SortedSetAdd(string key, T value, double score)
        {
            key = AddSysCustomKey(key);
            return Do(redis => redis.SortedSetAdd(key, ConvertJson(value), score));
        }

        /// 
        /// 删除
        /// 
        /// 
        /// 
        public bool SortedSetRemove(string key, T value)
        {
            key = AddSysCustomKey(key);
            return Do(redis => redis.SortedSetRemove(key, ConvertJson(value)));
        }

        /// 
        /// 获取全部
        /// 
        /// 
        /// 
        public List SortedSetRangeByRank(string key)
        {
            key = AddSysCustomKey(key);
            return Do(redis =>
            {
                var values = redis.SortedSetRangeByRank(key);
                return ConvetList(values);
            });
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public long SortedSetLength(string key)
        {
            key = AddSysCustomKey(key);
            return Do(redis => redis.SortedSetLength(key));
        }

        #endregion 同步方法

        #region 异步方法

        /// 
        /// 添加
        /// 
        /// 
        /// 
        /// 
        public async Task SortedSetAddAsync(string key, T value, double score)
        {
            key = AddSysCustomKey(key);
            return await Do(redis => redis.SortedSetAddAsync(key, ConvertJson(value), score));
        }

        /// 
        /// 删除
        /// 
        /// 
        /// 
        public async Task SortedSetRemoveAsync(string key, T value)
        {
            key = AddSysCustomKey(key);
            return await Do(redis => redis.SortedSetRemoveAsync(key, ConvertJson(value)));
        }

        /// 
        /// 获取全部
        /// 
        /// 
        /// 
        public async Task> SortedSetRangeByRankAsync(string key)
        {
            key = AddSysCustomKey(key);
            var values = await Do(redis => redis.SortedSetRangeByRankAsync(key));
            return ConvetList(values);
        }

        /// 
        /// 获取集合中的数量
        /// 
        /// 
        /// 
        public async Task SortedSetLengthAsync(string key)
        {
            key = AddSysCustomKey(key);
            return await Do(redis => redis.SortedSetLengthAsync(key));
        }

        #endregion 异步方法

        #endregion SortedSet 有序集合

        #region key

        /// 
        /// 删除单个key
        /// 
        /// redis key
        /// 是否删除成功
        public bool KeyDelete(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.KeyDelete(key));
        }

        /// 
        /// 删除多个key
        /// 
        /// rediskey
        /// 成功删除的个数
        public long KeyDelete(List keys)
        {
            List newKeys = keys.Select(AddSysCustomKey).ToList();
            return Do(db => db.KeyDelete(ConvertRedisKeys(newKeys)));
        }

        /// 
        /// 判断key是否存储
        /// 
        /// redis key
        /// 
        public bool KeyExists(string key)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.KeyExists(key));
        }

        /// 
        /// 重新命名key
        /// 
        /// 就的redis key
        /// 新的redis key
        /// 
        public bool KeyRename(string key, string newKey)
        {
            key = AddSysCustomKey(key);
            return Do(db => db.KeyRename(key, newKey));
        }

        /// 
        /// 设置Key的时间
        /// 
        /// redis key
        /// 
        /// 
        public bool KeyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
        {
            key = AddSysCustomKey(key);
            return Do(db => db.KeyExpire(key, expiry));
        }

        #endregion key

        #region 发布订阅

        /// 
        /// Redis发布订阅  订阅
        /// 
        /// 
        /// 
        public void Subscribe(string subChannel, Action handler = null)
        {
            ISubscriber sub = _conn.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 = _conn.GetSubscriber();
            return sub.Publish(channel, ConvertJson(msg));
        }

        /// 
        /// Redis发布订阅  取消订阅
        /// 
        /// 
        public void Unsubscribe(string channel)
        {
            ISubscriber sub = _conn.GetSubscriber();
            sub.Unsubscribe(channel);
        }

        /// 
        /// Redis发布订阅  取消全部订阅
        /// 
        public void UnsubscribeAll()
        {
            ISubscriber sub = _conn.GetSubscriber();
            sub.UnsubscribeAll();
        }

        #endregion 发布订阅

        #region 其他

        public ITransaction CreateTransaction()
        {
            return GetDatabase().CreateTransaction();
        }

        public IDatabase GetDatabase()
        {
            return _conn.GetDatabase(DbNum);
        }

        public IServer GetServer(string hostAndPort)
        {
            return _conn.GetServer(hostAndPort);
        }

        /// 
        /// 设置前缀
        /// 
        /// 
        public void SetSysCustomKey(string customKey)
        {
            CustomKey = customKey;
        }

        #endregion 其他

        #region 辅助方法

        private string AddSysCustomKey(string oldKey)
        {
            var prefixKey = CustomKey ?? RedisConnectionHelp.SysCustomKey;
            return prefixKey + oldKey;
        }

        private T Do(Func func)
        {
            var database = _conn.GetDatabase(DbNum);
            return func(database);
        }

        private string ConvertJson(T value)
        {
            string result = value is string ? value.ToString() : JsonConvert.SerializeObject(value);
            return result;
        }

        private T ConvertObj(RedisValue value)
        {
            return JsonConvert.DeserializeObject(value);
        }

        private List ConvetList(RedisValue[] values)
        {
            List result = new List();
            foreach (var item in values)
            {
                var model = ConvertObj(item);
                result.Add(model);
            }
            return result;
        }

        private RedisKey[] ConvertRedisKeys(List redisKeys)
        {
            return redisKeys.Select(redisKey => (RedisKey)redisKey).ToArray();
        }

        #endregion 辅助方法
    }
}

你可能感兴趣的:(DB|Redis快速入手，NET起跑)

  • .Net启动程序报错：It was not possible to find any compatible framework version SCscHero .NET/C#.netmicrosoft
    阅文时长|0.68分钟字数统计|1092字符主要内容|1、引言&背景2、解决方案3、声明与参考资料『.Net启动程序报错：Itwasnotpossibletofindanycompatibleframeworkversion』编写人|SCscHero
  • PyAutoGUI 使用教程 —— 喜欢你就 Copy 一下 冰雪危境 Pythonpython
    前言PyAutoGUI是一个纯Python的GUI自动化工具，它可以让程序自动控制鼠标和键盘等一系列操作来达到自动化操作目的。使用PyAutoGUI脚本，在执行期间，应避免手动移动鼠标或进行键盘输入，以免干扰脚本的执行。全局暂停设置：通过设置全局变量pyautogui.PAUSE=“秒”，来每个延迟每个动作执行的暂停时间，以防止错误或干扰。自动防故障：将鼠标快速移到屏幕左上角，脚本会立即停止执行。
  • springboot整合Logback m0_74825634 面试学习路线阿里巴巴springbootlogback后端
    Logback介绍描述Logback是由log4j创始人设计的另外一种开源日志组件，性能比log4j要好。相对是一个可靠、通用、快速而又灵活的Java日志框架。Logback主要分三个模块1、logback-core：其他两个模块的基础模块2、logback-classic：它是log4j的一个改良版本，同时它完整实现了slf4j。API，可以很方便地更换成其它日志系统，如log4j或JDK14L
  • ShardingSphere实例讲解 沉墨的夜 java数据库分库分表shardingsphere
    ShardingSphere（原名Sharding-JDBC）是一个开源的分布式数据库中间件，它为Java应用提供了透明的数据库分片、读写分离、分布式事务等功能。在使用ShardingSphere时，应用不需要了解数据库分片的实现细节，它会自动将SQL请求路由到正确的数据库和表。以下是一个简单的ShardingSphere-JDBC实例讲解，展示如何在Java项目中配置和使用Sharding-JD
  • 推荐开源项目：Chat-Template - 快速构建聊天机器人原型的利器 侯深业Dorian
    推荐开源项目：Chat-Template-快速构建聊天机器人原型的利器chat-templateChat-TemplateisaReactcomponentthatenablesquickprototypingofbotconversations.项目地址:https://gitcode.com/gh_mirrors/ch/chat-template1、项目介绍Chat-Template是一款基于
  • .NET 5.0 WebAPI部署发布404记录 聿琴丶 c#asp.net
    前面步骤不用过多介绍，这里是使用dbfrist进行数据库迁移，在部署到本地IIS之后，IIS中点击网站进行浏览，会显示404这里你可以忽略，不用纠结这个界面，因为这里与framework的Api不同，我们使用的是SwaggerUI所以你需要查看的是http://localhost:8082/swagger/index.html（这里我配置的端口是8082，不冲突就行，随意配置）然后你会发现也是错误
  • .NET MAUI 手搓 UDP/TCP 通信 云端狂人 .netudptcp/ip
    在.NETMAUI中，UDP和TCP是网络通信协议，与MAUI框架本身的关系在于.NETMAUI可以利用.NET的网络功能来实现跨平台的网络通信。.NET提供的System.Net.Sockets命名空间来处理。该命名空间提供了创建和管理套接字（Sockets）来进行网络通信的相关类和方法。在.NETMAUI中，这些类同样适用于跨平台应用开发。具体来说：.NETMAUI是一个跨平台框架，用于构建A
  • 跨越界限，触手可及：.NET MAUI引领跨平台移动应用开发新纪元 墨夶 C#学习资料1.net
    在这个移动为先的时代，开发者们面临着一个巨大的挑战：如何以最小的成本和最高的效率构建出适用于多个操作系统的应用程序。传统的做法往往意味着重复劳动和高昂的维护成本。然而，随着.NETMulti-platformAppUI(.NETMAUI)的出现，这一切都发生了改变。作为微软推出的一款革命性框架，.NETMAUI不仅简化了跨平台应用的创建过程，还赋予了开发者前所未有的灵活性与创造力。今天，我们将一起
  • Oracle 机器宕机之后启动数据库 天农学子 数据库oracle
    Oracle机器宕机之后启动数据库启动监听，登录数据库，启动数据库检查监听[oracle@oracle-db~]$lsnrctlstatusLSNRCTLforLinux:Version11.2.0.4.0-Productionon24-JAN-202509:42:34Copyright(c)1991,2013,Oracle.Allrightsreserved.Connectingto(DESCR
  • CRM 微服务 山猪打不过家猪 C#微服务架构云原生
    文章目录项目地址一、项目地址教程作者：教程地址：代码仓库地址：所用到的框架和插件：dbtairflow一、用户与认证服务主要功能：用户注册、登录、注销。认证（OAuth、JWT等）。权限和角色管理（RBAC/ABAC）。单点登录（SSO）。技术亮点：集成第三方身份认证（如Google、AzureAD）。使用APIGateway统一进行身份认证。客户管理服务主要功能：存储和管理客户信息（姓名、联系方
  • Acerola：基于.NET Core的六边形架构服务模板安装与使用指南 樊会灿
    Acerola：基于.NETCore的六边形架构服务模板安装与使用指南hexagonal-architecture-acerolaAnHexagonalArchitectureservicetemplatewithDDD,CQRS,TDDandSOLIDusing.NETCore2.0.Allsmallfeaturesaretestableandcouldbemocked.Adapterscoul
  • .NET MAUI进行UDP通信（二） 聿琴丶 MAUI.netudp网络协议
    上篇文章有写过一个简单的demo，本次对项目进行进一步的扩展，添加tabbar功能。1.修改AppShell.xaml文件，如下所示：-->-->1).将MainPage注释掉2).添加tabbar功能3).第一个ShellConten的路由设置为Mine文件，注意到ContentTemplate="{DataTemplateminePage:Mine}"，当前不是local,是因为我们引用了命名
  • 【计算机视觉】图像滤波 油泼辣子多加 计算机视觉计算机视觉人工智能python神经网络
    1.图像滤波定义图像滤波是一种非常重要的图像处理技术，图像平滑、边缘检测、边缘增强、去除噪声都属于图像滤波，图像滤波是一种基于邻域的算法。通过图像滤波，可以实现图像平滑、边缘检测；图像平滑也叫图像模糊，用以去除图像中的噪声、伪影等，它是图像处理和计算机视觉的常见步骤。函数模糊类型特点使用场景cv.blur均值模糊简单快速，所有像素权重相等基础平滑和降噪cv.GaussianBlur高斯模糊中心权重
  • Android BitmapShader简洁实现马赛克，Kotlin（二） zhangphil kotlinAndroidandroidkotlin
    AndroidBitmapShader简洁实现马赛克，Kotlin（二）这一篇AndroidBitmapShader简洁实现马赛克，Kotlin（一）-CSDN博客遗留一个问题，xml定义的MyView为wrap_content的宽高，如果改成其他模式如match_parent，因为background的Bitmap和draw时候的Bitmap不一致（background被拉伸了），导致手指划过屏
  • linux lamp 山客泛舟游Y linuxphpapache
    linuxlamp1.lamp简介有了前面学习的知识的铺垫，今天可以来学习下第一个常用的web架构了。所谓lamp，其实就是由Linux+Apache+Mysql/MariaDB+Php/Perl/Python的一组动态网站或者服务器的开源软件，除Linux外其它各部件本身都是各自独立的程序，但是因为经常被放在一起使用，拥有了越来越高的兼容度，共同组成了一个强大的Web应用程序平台。LAMP指的是
  • miniconda中成功安装gdal库 跳动的弦 遥感学习python
    通过网上浏览相关帖子，未找到在miniconda中安装gdal库的相关内容，本人在本次安装成功之前已经历过两次失败，故在这里记录本次成功安装的细节，希望对有相似需求的朋友有所帮助。介于本人在这一方面也是初学者，有不正确的地方还请各位好友不吝指教。安装之前先下载安装RedistributingVisualC++Files，配置好VisualC++环境LatestsupportedVisualC++R
  • git clone出现fatal: unable to access Failed to connect to github.com port 443: Timed out解决方案 爱编程的喵喵 Python基础课程gitgithubtimeoutport443解决方案
      大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的知识进行总结与归纳，不仅形成深入且独到的理解，而且能够帮助新手快速入门。  本文主要介绍了gitclone出现fatal:un
  • python绘图实例 charlie_wang007 pythonpython
    pythonPlt实例背景：业务的健身数据，有一个字段是其他附加信息，格式是json，需要查出该字段，解出json，拿到目标数据，按要求聚合，如燃脂是0.25的有几个目的：要验证运营页面的概览数据是否正确策略：从表中查出数据，格式化，用plt绘制，与被测页面的图形数据对比代码如下：#coding:utf8importMySQLdbimportjsonimportpandasaspdimportnu
  • 设计模式-行为型模式-迭代器模式 繁星璀璨G #行为型模式设计模式迭代器模式c++
    工程源码：C++设计模式-行为型模式-迭代器模式https://download.csdn.net/download/qq_40788199/85774530码云：C++设计模式-行为型模式-迭代器模式https://gitee.com/gongguixing/c-design-mode.git1、模式的定义与特点迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，
  • Gradio 快速构建机器学习web可视化界面心得 算法小菜鸟成长心得 python
    1.操作完成提示try:#对输入的字符串代码进行编译运行exec(get_test_code_example)gr.Info("Modeltestingcompletedsuccessfully.")except:raisegr.Error("Modeltestingfailed.")用到了gr.Info()和gr.Errot(）
  • es6.7.1分词器ik插件安装-和head插件连接es特殊配置 运维实战课程 jenkins运维
    es6.7.1分词器ik插件安装-和head插件连接es特殊配置如果对运维课程感兴趣，可以在b站上、A站或csdn上搜索我的账号：运维实战课程，可以关注我，学习更多免费的运维实战技术视频1.查看es6.7.1和es-head安装位置和es插件路径[root@verify-10-100-4-4data]#dockerps|grepes4f0fe4db0ca9elasticsearch-head:6.
  • k8s（kubernetes）常见故障处理总结——详细文档 运维实战课程 docker和k8s学习文档kubernetesdocker容器
    k8s（kubernetes）常见故障处理总结——详细文档本文涵盖了k8s运维过程中大部分常见的故障,提供相应的排查思路，笔记详细，仅供参考本人会经常更新运维相关技术文档，如有兴趣，可以关注我博客，欢迎互动分享k8s其他相关详细资料下载地址：kubeadm初始化高可用k8s1.20.4集群网盘地址:https://url28.ctfile.com/f/37115828-599516373-25f4
  • 探索 `.NET MAUI` 工作坊：跨平台移动应用开发的新纪元 倪澄莹George
    探索.NETMAUI工作坊：跨平台移动应用开发的新纪元dotnet-maui-workshopAfulldayworkshop(.NETMAUIWorkshopinaBox)onhowtobuildappswith.NETMAUIforiOS,Android,macOS,andWindows项目地址:https://gitcode.com/gh_mirrors/do/dotnet-maui-wor
  • 补充:关于802.1X身份验证中CA证书的配置 deflag interfaceauthenticationwindowspasswordsserveraccess
    前几天写了H3C和CISCO两种交换机的802.1X实现方法,但是有人联系我说CA没有配置好,验证不过去.由于时间关系,我这里不写出自己的配置文档.手上有一篇可供参考的配置文档,希望对大家有所帮助.电子版文档在我的究竟中资源里面去下载吧.地址:http://download.csdn.net/user/deflag使用EAP-TLS（智能卡与证书）实现802.1X－－－－验证服务器和交换机相关配置
  • flask+layui学生信息管理系统 元宇宙中的程序员 flasklayuipython
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结前言提示：这里可以添加本文要记录的大概内容：例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。一、数据库建模1、创建数据模型classStudentORM(db.Model):stu_id=d
  • 【玩转全栈】----靓号管理系统实现 Edward-tan oracle数据库django
    先赞后看，养成习惯。。。目录数据库设置基本功能路由器靓号显示靓号添加靓号编辑视图函数额外功能搜索功能分页一般逻辑动态页码上下页首尾页数据库设置新建一个数据库（或者就用之前部门、用户管理的也行），用Django连接到数据库：DATABASES={"default":{"ENGINE":"django.db.backends.mysql","NAME":"mydata_1","USER":"root"
  • 大系统的标准规范介绍 代码改变世界ctw optee精选armv8trustzoneTEEarmv9optee标准规范
    快速链接:.《optee精选全集》付费专栏-[目录]付费专栏-付费课程【购买须知】目录1、思考2、未来系统软件架构图3、当前主流系统软件架构图4、GP/PSCI/SMCCC规范概览5、生态：系统软件架构1、思考当前的主流软件框架是怎样的？有什么标准规范吗？不同的SOC系统启动时有什么标准规范吗？在运行状态跨系统进行电源管理时有什么标准规范吗2、未来系统软件架构图在未来的软件生态架构中，一个SOC上
  • optee gprof 代码改变世界ctw optee精选gprofftrace调试opteeTEEtrustzone
    快速链接:.《optee精选全集》付费专栏-[目录]付费专栏-付费课程【购买须知】目录思考什么是opteeGprof？开启opteegprofgprof解析生成的文件思考什么是opteeGprof？如何开启opteegprof？opteegprof和linuxgprof有什么不同？什么是opteeGprof？Gprof是一种性能分析工具，用于收集程序的运行时性能数据，主要用于分析函数的调用关系和运
  • YOLOv10涨点改进：特征融合创新 | 多层次特征融合（SDI），小目标涨点明显，| UNet v2，比UNet显存占用更少、参数更少 AI小怪兽 YOLOv10魔术师YOLO目标检测算法人工智能目标跟踪
    本文独家改进：多层次特征融合（SDI），能够显著提升不同尺度和小目标的识别率如何引入到YOLOv10：1)替代原始的Concat；改进结构图如下：《YOLOv10魔术师专栏》将从以下各个方向进行创新：【原创自研模块】【多组合点优化】【注意力机制】【卷积魔改】【block&多尺度融合结合】【损失&IOU优化】【上下采样优化】【小目标性能提升】【前沿论文分享】【训练实战篇】订阅者通过添加WX:AI_C
  • YOLO11涨点优化：特征融合创新 | 多层次特征融合（SDI），小目标涨点明显| UNet v2，比UNet显存占用更少、参数更少 AI小怪兽 YOLO11魔术师深度学习目标检测计算机视觉目标跟踪神经网络python
    本文独家改进：多层次特征融合（SDI），能够显著提升不同尺度和小目标的识别率如何引入到YOLO11：1)替代原始的Concat；改进结构图如下：《YOLOv11魔术师专栏》将从以下各个方向进行创新：【原创自研模块】【多组合点优化】【注意力机制】【卷积魔改】【block&多尺度融合结合】【损失&IOU优化】【上下采样优化】【小目标性能提升】【前沿论文分享】【训练实战篇】订阅者通过添加WX:AI_CV
  • HQL之投影查询 归来朝歌 HQLHibernate查询语句投影查询
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 针对上面的场景，如果需要将一个对象查出来： HQL语句写“from 对象”即可 Session session = HibernateUtil.openSession();
  • Spring整合redis bylijinnan redis
    pom.xml <dependencies> <!-- Spring Data - Redis Library --> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redi
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2 0624chenhong Hibernate
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 org.hibernate.NonUniqueResultException: query did not return a unique result: 2         在项目中出现了org.hiber
  • android动画效果 不懂事的小屁孩 android动画
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。
  • js delete 删除机理以及它的内存泄露问题的解决方案 换个号韩国红果果 JavaScript
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 举例： var person={name:{firstname:'bob'}} var p=person.name delete person.name p.firstname -->'bob' // 依然可以访问p.firstname，存在内存泄露
  • Oracle将零干预分析加入网络即服务计划 蓝儿唯美 oracle
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
  • spring学习——springmvc（二） a-john springMVC
    Spring MVC提供了非常方便的文件上传功能。 1，配置Spring支持文件上传： DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
  • POJ-2828-Buy Tickets aijuans ACM_POJ
    POJ-2828-Buy Tickets http://poj.org/problem?id=2828 线段树，逆序插入 #include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
  • Java Ant build.xml详解 asia007 build.xml
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
  • android按钮监听器的四种技术 百合不是茶 androidxml配置监听器实现接口
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;    1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似   创建监听器的实例 myLis lis = new myLis();   使用add方法给按钮添加监听器  
  • 软件架构师不等同于资深程序员 bijian1013 程序员架构师架构设计
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。         如今很多的公司
  • TeamForge Wiki Syntax & CollabNet User Information Center sunjing TeamForgeHow doAttachementAnchorWiki Syntax
    the CollabNet user information center http://help.collab.net/   How do I create a new Wiki page? A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
  • 【Redis四】Redis数据类型 bit1129 redis
    概述 Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
  • SSH2整合-附源码 白糖_ eclipsespringtomcatHibernateGoogle
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。     补充1：项目中部分jar包不是最新版的，可能导
  • [转]开源项目代码的学习方法 braveCS 学习方法
    转自： http://blog.sina.com.cn/s/blog_693458530100lk5m.html http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html   1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
  • 编程之美-子数组的最大和（二维） bylijinnan 编程之美
    package beautyOfCoding; import java.util.Arrays; import java.util.Random; public class MaxSubArraySum2 { /** * 编程之美 子数组之和的最大值（二维） */ private static final int ROW = 5; private stat
  • 读书笔记-3 chengxuyuancsdn jquery笔记resultMap配置ibatis一对多配置
    1、resultMap配置 2、ibatis一对多配置 3、jquery笔记 1、resultMap配置 当<select resultMap="topic_data"> <resultMap id="topic_data">必须一一对应。 (1)<resultMap class="tblTopic&q
  • [物理与天文]物理学新进展 comsci
          如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境       怎么办呢?  
  • Oracle 11g新特性:Automatic Diagnostic Repository daizj oracleADR
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 这两份log文
  • 简单排序:选择排序 dieslrae 选择排序
    public void selectSort(int[] array){ int select; for(int i=0;i<array.length;i++){ select = i; for(int k=i+1;k<array.leng
  • C语言学习六指针的经典程序，互换两个数字 dcj3sjt126com c
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 # include <stdio.h> void swap_1(int, int); void swap_2(int *, int *); void swap_3(int *, int *); int main(void) { int a = 3; int b =
  • php 5.4中php-fpm 的重启、终止操作命令 dcj3sjt126com PHP
    php 5.4中php-fpm 的重启、终止操作命令: 查看php运行目录命令：which php/usr/bin/php 查看php-fpm进程数：ps aux | grep -c php-fpm 查看运行内存/usr/bin/php  -i|grep mem 重启php-fpm/etc/init.d/php-fpm restart 在phpinfo()输出内容可以看到php
  • 线程同步工具类 shuizhaosi888 同步工具类
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch）   闭锁（CountDownLatch） public class RunMain { public long timeTasks(int nThreads, final Runnable task) throws InterruptedException { fin
  • bleeding edge是什么意思 haojinghua DI
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。   In computer science, bleeding edge is a term that
  • c中实现utf8和gbk的互转 jimmee ciconvutf8&gbk编码
    #include <iconv.h> #include <stdlib.h> #include <stdio.h> #include <unistd.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> int code_c
  • 大型分布式网站架构设计与实践 lilin530 应用服务器搜索引擎
    1.大型网站软件系统的特点？ a.高并发，大流量。 b.高可用。 c.海量数据。 d.用户分布广泛，网络情况复杂。 e.安全环境恶劣。 f.需求快速变更，发布频繁。 g.渐进式发展。 2.大型网站架构演化发展历程？ a.初始阶段的网站架构。 应用程序，数据库，文件等所有的资源都在一台服务器上。 b.应用服务器和数据服务器分离。 c.使用缓存改善网站性能。 d.使用应用
  • 在代码中获取Android theme中的attr属性值 OliveExcel androidtheme
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西.   在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: int defaultColor = 0xFF000000; int[] attrsArray = { andorid.r.
  • 基于Zookeeper的分布式共享锁 roadrunners zookeeper分布式共享锁
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。   共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。   官
  • 两个容易被忽略的MySQL知识 tomcat_oracle mysql
    1、varchar(5)可以存储多少个汉字，多少个字母数字？ 　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。 　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
  • zoj 3827 Information Entropy(水题) 阿尔萨斯 format
    题目链接：zoj 3827 Information Entropy 题目大意：三种底，计算和。 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 #include <cstdio> #include <cstring> #include <cmath&
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他