用Redis做小型Asp.net网站的性能优化

最新推荐文章于 2024-08-09 13:29:49 发布

驽马农夫

最新推荐文章于 2024-08-09 13:29:49 发布

阅读量4.6k

点赞数

分类专栏：工程实践文章标签： asp.net redis 优化性能

本文链接：https://blog.csdn.net/shaozhenged/article/details/77650383

版权

工程实践专栏收录该内容

12 篇文章 1 订阅

订阅专栏

主题	概要
Redis	Redis作缓存，优化网站性能

编辑	时间
新建	20170828

序号	参考资料
1	https://github.com/StackExchange/StackExchange.Redis
2	https://yq.aliyun.com/ziliao/89080
3	https://www.quartz-scheduler.net/

解决问题

当网站中有发布公告、发布新闻的场景时，可能会有发布人员的选择模块。
这里写图片描述
而就是这个模块，弹出整个公司的组织结构和人员，会很耗时，大概要几十秒钟。现在的方案是请求一次，就去库里面查信息，并组建成树型结构。每个人就算获取的是同样的数据，都要操作一遍，如果并发人数多，会加重服务器压力，影响体验。

解决方案

考虑引进缓存，现在的方案是部署一个Redis库，Redis库只做缓存，不做持久化。Redis库每晚凌晨进行一次全量更新，同步mysql里面的人员和部门数据。白天每隔2个小时进行增量更新；如果人数有变化，则更新人员，如果部门有变化，则进行全量更新；如果都没变化，则不做更新。同时提供了一个手动更新的页面，如果确切知道了信息有改变，就通过手动进行更新。

应用程序直接从Redis里面取数据，并存到内存中。数据格式为部门数组，每个部门下面挂接部门人员和子部门，子部门下面又挂机人员和子部门的层次结构，是典型的部分-整体设计模式。

整个逻辑如下图：
这里写图片描述
其中Mysql的表结构不提，就是些关系型表，Redis主要用到了hashSet和sortedSet。

部门数量和人员数量：
这里写图片描述

组织结构：
这里写图片描述

需要注意的是组织结构就用了String型的key-value存储，value值就是序列化了部门的层次结构。这个层次结构是构建部门和人员的基石。通过部门ID，从Redis里面获取人员，再查找子部门ID，不断递归。

通过部门ID获取人员，需要给人员建立索引，每个部门下的人员ID组成一个set，key为部门ID。
这里写图片描述

Web应用从Redis构建结构树的时候，先从组织结构中获取部门ID，通过部门ID获取该部门下所有人员的ID，再通过人员ID获取具体的人员信息。

Redis C#客户端

Redis的安装和配置见后，这里使用Redis官方推荐的StackExchange.Redis（https://github.com/StackExchange/StackExchange.Redis）。建立一个类库项目，从NuGet中安装StackExchange.Redis包。

这里写图片描述

这里参考https://yq.aliyun.com/ziliao/89080对StackExchange.Redis做了简单的封装。

public class RedisConnectionHelp
    {       
        public static readonly string redisConnStr= System.Web.Configuration.WebConfigurationManager.AppSettings["RedisConnString"];
        private static readonly object locker = new object();

        //--系统自定义key前缀
        public static readonly string SysCustomKeyPrex = "hx:test:";

        private static ConnectionMultiplexer instance;

        /// <summary>
        /// 单例获取
        /// </summary>
        public static ConnectionMultiplexer Instance
        {
            get
            {
                if(instance==null)
                {
                    lock(locker)
                    {
                        if(instance==null || !instance.IsConnected)
                        {
                            instance = GetManager();
                        }
                    }
                }
                return instance;
            }
        }


        public static ConnectionMultiplexer GetManager(string connectionString = null)
        {
            var connStr = connectionString ?? redisConnStr;
            var connect = ConnectionMultiplexer.Connect(connStr);
            return connect;
        }
    }

public class RedisHelper
    {
        private int DbNum { get; }

        private readonly ConnectionMultiplexer conn;

        /// <summary>
        /// 自定义Key命名前缀
        /// </summary>
        public string CustomKeyPrex { get; set; }

        public RedisHelper()
        {
            DbNum = 0;
            conn = RedisConnectionHelp.Instance;
        }

        #region 通用辅助类

        private string addKeyPrex(string oldStr)
        {
            var keyPrex = CustomKeyPrex ?? RedisConnectionHelp.SysCustomKeyPrex;
            return keyPrex + oldStr;
        }

        private T action<T>(Func<IDatabase, T> func)
        {
            var database = conn.GetDatabase(DbNum);
            return func(database);
        }


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

        public T convertObj<T>(RedisValue value)
        {
            if (!value.HasValue)
            {
                return default(T);
            }
            return JsonConvert.DeserializeObject<T>(value);
        }

        private IList<T> convetList<T>(RedisValue[] values)
        {
            IList<T> result = new List<T>();
            foreach (var item in values)
            {
                var model = convertObj<T>(item);
                result.Add(model);
            }
            return result;
        }

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

        #endregion


        #region String

        /// <summary>
        /// 保存单个key值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="expiry">过期时间</param>
        /// <returns></returns>
        public bool stringSet(string key, string value, TimeSpan? expiry = default(TimeSpan?))
        {
            key = addKeyPrex(key);
            return action(db => db.StringSet(key, value, expiry));
        }

        /// <summary>
        /// 获取单个key的值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public string stringGet(string key)
        {
            key = addKeyPrex(key);
            return action(db => db.StringGet(key));
        }


        /// <summary>
        /// 保存一个对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="obj"></param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool stringSet<T>(string key, T obj, TimeSpan? expiry = default(TimeSpan?))
        {
            key = addKeyPrex(key);
            string json = convertJson<T>(obj);
            return action(db => db.StringSet(key, json, expiry));
        }


        /// <summary>
        /// 获取一个key的对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T stringGet<T>(string key)
        {
            key = addKeyPrex(key);

            return action(db => convertObj<T>(db.StringGet(key)));
        }
        #endregion


        #region List
        /// <summary>
        /// 移除指定ListId的内部List的值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void listRemove<T>(string key, T value)
        {
            key = addKeyPrex(key);
            action(db => db.ListRemove(key, convertJson(value)));
        }


        /// <summary>
        /// 获取指定key的List
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public IList<T> listRange<T>(string key)
        {
            key = addKeyPrex(key);
            return action(redis =>
            {
                var values = redis.ListRange(key);
                return convetList<T>(values);
            });
        }

        /// <summary>
        /// 入队
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void listRightPush<T>(string key, T value)
        {
            key = addKeyPrex(key);
            action(db => db.ListRightPush(key, convertJson<T>(value)));
        }


        /// <summary>
        /// 出队
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T listRightPop<T>(string key) where T : class
        {
            key = addKeyPrex(key);
            return action(db =>
            {
                var value = db.ListRightPop(key);
                return convertObj<T>(value);
            });
        }


        /// <summary>
        /// 入栈
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public void listLeftPush<T>(string key, T value)
        {
            key = addKeyPrex(key);
            action(db => db.ListLeftPush(key, convertJson(value)));
        }

        /// <summary>
        /// 出栈
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public T listLeftPop<T>(string key) where T : class
        {
            key = addKeyPrex(key);
            return action(db =>
            {
                var value = db.ListLeftPop(key);
                return convertObj<T>(value);
            });
        }

        /// <summary>
        /// 获取集合中的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long listLength(string key)
        {
            key = addKeyPrex(key);
            return action(redis => redis.ListLength(key));
        }


        #endregion

        #region HASH

        /// <summary>
        /// 判断某个数据是否已经被缓存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool hashExists(string key, string dataKey)
        {
            key = addKeyPrex(key);
            return action(db => db.HashExists(key, dataKey));
        }

        /// <summary>
        /// 存储数据到hash表
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool hashSet<T>(string key, string dataKey, T t)
        {
            key = addKeyPrex(key);
            return action(db =>
            {
                string json = convertJson(t);
                return db.HashSet(key, dataKey, json);
            });
        }

        /// <summary>
        /// 移除hash中的某值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public bool hashDelete(string key, string dataKey)
        {
            key = addKeyPrex(key);
            return action(db => db.HashDelete(key, dataKey));
        }

        /// <summary>
        /// 移除hash中的多个值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKeys"></param>
        /// <returns></returns>
        public long hashDelete(string key, List<RedisValue> dataKeys)
        {
            key = addKeyPrex(key);
            //List<RedisValue> dataKeys1 = new List<RedisValue>() {"1","2"};
            return action(db => db.HashDelete(key, dataKeys.ToArray()));
        }

        /// <summary>
        /// 从hash表获取数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <returns></returns>
        public T hashGet<T>(string key, string dataKey)
        {
            key = addKeyPrex(key);
            return action(db =>
            {
                string value = db.HashGet(key, dataKey);
                return convertObj<T>(value);
            });
        }

        /// <summary>
        /// 为数字增长val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>增长后的值</returns>
        public double hashIncrement(string key, string dataKey, double val = 1)
        {
            key = addKeyPrex(key);
            return action(db => db.HashIncrement(key, dataKey, val));
        }

        /// <summary>
        /// 为数字减少val
        /// </summary>
        /// <param name="key"></param>
        /// <param name="dataKey"></param>
        /// <param name="val">可以为负</param>
        /// <returns>减少后的值</returns>
        public double hashDecrement(string key, string dataKey, double val = 1)
        {
            key = addKeyPrex(key);
            return action(db => db.HashDecrement(key, dataKey, val));
        }

        /// <summary>
        /// 获取hashkey所有Redis key
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        public IList<T> hashKeys<T>(string key)
        {
            key = addKeyPrex(key);
            return action(db =>
            {
                RedisValue[] values = db.HashKeys(key);
                return convetList<T>(values);
            });
        }
        #endregion


        #region 有序set 
        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="score"></param>
        public bool sortedSetAdd<T>(string key, T value, double score)
        {
            key = addKeyPrex(key);
            return action(redis => redis.SortedSetAdd(key, convertJson<T>(value), score));
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        public bool sortedSetRemove<T>(string key, T value)
        {
            key = addKeyPrex(key);
            return action(redis => redis.SortedSetRemove(key, convertJson(value)));
        }

        /// <summary>
        /// 获取全部
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public IList<T> sortedSetRangeByRank<T>(string key)
        {
            key = addKeyPrex(key);
            return action(redis =>
            {
                var values = redis.SortedSetRangeByRank(key);
                return convetList<T>(values);
            });
        }

        /// <summary>
        /// 获取集合中的数量
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public long sortedSetLength(string key)
        {
            key = addKeyPrex(key);
            return action(redis => redis.SortedSetLength(key));
        }

        #endregion


        #region key管理

        /// <summary>
        /// 删除单个key
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns>是否删除成功</returns>
        public bool keyDelete(string key)
        {
            key = addKeyPrex(key);
            return action(db => db.KeyDelete(key));
        }

        /// <summary>
        /// 删除多个key
        /// </summary>
        /// <param name="keys">rediskey</param>
        /// <returns>成功删除的个数</returns>
        public long keyDelete(List<string> keys)
        {
            List<string> newKeys = keys.Select(addKeyPrex).ToList();
            return action(db => db.KeyDelete(convertRedisKeys(newKeys)));
        }

        /// <summary>
        /// 判断key是否存储
        /// </summary>
        /// <param name="key">redis key</param>
        /// <returns></returns>
        public bool keyExists(string key)
        {
            key = addKeyPrex(key);
            return action(db => db.KeyExists(key));
        }

        /// <summary>
        /// 重新命名key
        /// </summary>
        /// <param name="key">就的redis key</param>
        /// <param name="newKey">新的redis key</param>
        /// <returns></returns>
        public bool keyRename(string key, string newKey)
        {
            key = addKeyPrex(key);
            return action(db => db.KeyRename(key, newKey));
        }

        /// <summary>
        /// 设置Key的时间
        /// </summary>
        /// <param name="key">redis key</param>
        /// <param name="expiry"></param>
        /// <returns></returns>
        public bool keyExpire(string key, TimeSpan? expiry = default(TimeSpan?))
        {
            key = addKeyPrex(key);
            return action(db => db.KeyExpire(key, expiry));
        }

        #endregion key

        #region 其他

        public ITransaction createTransaction()
        {
            return getDatabase().CreateTransaction();
        }

        public IDatabase getDatabase()
        {
            return conn.GetDatabase(DbNum);
        }

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

        #endregion

        #region Batch批量处理
        public IBatch createBatch()
        {
           return getDatabase().CreateBatch();          
        }


        public Task<bool> batchHashSetAsync<T>(IBatch batch, string key, string dataKey, T t)
        {
            key = addKeyPrex(key);
            var json = convertJson(t);
            return  batch.HashSetAsync(key, dataKey, json);
        }


        public Task<bool> batchSortedSetAdd<T>(IBatch batch, string key, T value, double score)
        {
            key = addKeyPrex(key);
            var json = convertJson(value);
            return batch.SortedSetAddAsync(key, json, score);
        }


        public void batchExecute(IBatch batch)
        {
            batch.Execute();
        }

        public Task<RedisValue> batchHashGetAsync(IBatch batch, string key, string dataKey)
        {
            key = addKeyPrex(key);
            return batch.HashGetAsync(key, dataKey);            
        }


        public Task<RedisValue[]> batchSortedSetRangeByRankAsync(IBatch batch,string key)
        {
            key = addKeyPrex(key);
            return batch.SortedSetRangeByRankAsync(key);                   
        }


        #endregion

    }

这里只是摘取了需要的部分，并封装了批量读取的功能。

部分-整体模式

类似公司的组织结构是典型的部分-整体模式。

抽像类，定义一个增加组件的方法：
这里写图片描述

具体类中实现该方法：
这里写图片描述

从Redis中获取数据，并递归构造成一个单例模式的树型结构：

  private void buildOrg(DepartmentInfo[] dept,ConstructOrgComponent orgRoot)
        {
            foreach(var d in dept)
            {
                redis.CustomKeyPrex = InitPrexConstant.DepEmployeeInID;

                //--取得该部门下的人员ID
                var idList=redis.sortedSetRangeByRank<string>(d.ID);                

                List<Task<RedisValue>> taskBaseInfos = new List<Task<RedisValue>>();
                List<Task<RedisValue>> taskSimpInfos = new List<Task<RedisValue>>();

                var batch = redis.createBatch();
                foreach (var id in idList)
                {                   
                    redis.CustomKeyPrex = InitPrexConstant.EmployeeBase;
                    //var eBase = redis.hashGet<EmployeeBaseInfo>(id, "EmployeeBase");  
                    var eBase = redis.batchHashGetAsync(batch,id, "EmployeeBase");
                    taskBaseInfos.Add(eBase);

                    redis.CustomKeyPrex = InitPrexConstant.EmployeeSimple;
                    //var eSimple = redis.hashGet<EmployeeSimpleInfo>(id, "EmployeeSimple");
                    var eSimple = redis.batchHashGetAsync(batch,id, "EmployeeSimple");
                    taskSimpInfos.Add(eSimple);

                }
                redis.batchExecute(batch);

                List<EmployeeBaseInfo> baseInfos = new List<EmployeeBaseInfo>();
                List<EmployeeSimpleInfo> simpInfos = new List<EmployeeSimpleInfo>();
                for (var i=0;i<taskBaseInfos.Count;i++)
                {
                    var baseTemp = JsonConvert.DeserializeObject<EmployeeBaseInfo>(taskBaseInfos[i].Result.ToString());
                    baseInfos.Add(baseTemp);

                    var simpTemp = JsonConvert.DeserializeObject<EmployeeSimpleInfo>(taskSimpInfos[i].Result.ToString());
                    simpInfos.Add(simpTemp);
                }

                ConstructOrgComposite orgTemp = new ConstructOrgComposite(d,baseInfos,simpInfos);
                orgRoot.addOrgComponent(orgTemp);

                buildOrg(d.Children,orgTemp);
            }
        }

由于展示的不是所有的代码，只是把这个过程表述下。传入的参数dept部门数组是树形结构，含有子部门。orgRoot是迭代构造的组织机构。
调用的时候，先虚拟一个根，通过遍历部门层次，不断递归。

private void build()
        {
            try
            {
                redis.CustomKeyPrex = InitPrexConstant.OrgPre;
                var orgStr = redis.stringGet("");
                OrganizationInfo orgInfo = redis.convertObj<OrganizationInfo>(orgStr);
                DepartmentInfo rootDept = new DepartmentInfo();  //--虚拟根部门 
                rootDept.Children = orgInfo.Children[0].Departments;
                orgComposite = new ConstructOrgComposite(rootDept, new List<EmployeeBaseInfo>(), new List<EmployeeSimpleInfo>());
                buildOrg(rootDept.Children, orgComposite);
            }
            catch (Exception ex)
            {
                HX.Common.Platform.Log(LogLevel.Error, ex.Message);
            }
        }

注意从redis获取人员的时候，按部门进行批读取，而不是每次读取一个人员。
这里写图片描述

最后三句代码：
这里写图片描述

根据部门、人员信息构造当前组织，并添加到父组织中。接着，当前组织又作为父组织不断递归。

策略模式与Quartz

策略模式是为了消除if块引进的，这个模式比较简单。
定义一个策略基类：
这里写图片描述
一个具体的增量策略类InitStrategyAddUpdate和全量策略类，继承自策略基类并实现doInit方法。

一个初始化类作为上下文，维护一个对具体策略的引用。

public class RedisInit
    {
        private InitStrategyBase initStrategy;     

        public RedisInit(InitStrategyBase initStrategy)
        {
            this.initStrategy = initStrategy;            
        }

        public void doInit()
        {
            initStrategy.doInit();           
        }

    }

一个初始化类作为上下文，维护一个对具体策略的引用，典型的多态。

为了管理策略的调度，引用Quartz程序集（https://www.quartz-scheduler.net/），具体的使用和触发器规则可以参见官网。
这里分别为两种更新方式定义两个job。

增量job：

 class AddUpdateJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            RedisInit redisInit = new RedisInit(new InitStrategyAddUpdate() { OnInitSuccess = ConstructOrgBuild.Instance.resetInsance });
            redisInit.doInit();           
        }
    }

全量job：

// <summary>
    /// 全量更新任务，每天凌晨2点
    /// </summary>
    public class AllUpdateJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            RedisInit redisInit = new RedisInit(new InitStrategyAllUpdate() { OnInitSuccess = ConstructOrgBuild.Instance.resetInsance });
            redisInit.doInit();           
        }
    }

每个Job绑定不同的策略。

定义一个封装类，Schedule这两个Job。

  public class UpdateRedisJobWorker
    {
        private static IScheduler scheduler= StdSchedulerFactory.GetDefaultScheduler();
        public static void startUpdateJob()
        {
            scheduler.Start();

            IJobDetail allUpdateJob = JobBuilder.Create<AllUpdateJob>()
                    .WithIdentity("allUpdate", "Redis")
                    .Build();
            var nightStrategy= System.Web.Configuration.WebConfigurationManager.AppSettings["RedisUpdateStrategyNight"];

            ITrigger allUpdateTrigger = TriggerBuilder.Create()
               .WithIdentity("allUpdateTrigger", "RedisTrigger")
               .ForJob(allUpdateJob)
               .WithSchedule(CronScheduleBuilder.DailyAtHourAndMinute(int.Parse(nightStrategy), 00)) // 每天2:00执行一次                                                                             
               .Build();

            scheduler.ScheduleJob(allUpdateJob, allUpdateTrigger);


            IJobDetail addUpdateJob = JobBuilder.Create<AddUpdateJob>()
                    .WithIdentity("addUpdate", "Redis")
                    .Build();

            var dayStrategy = System.Web.Configuration.WebConfigurationManager.AppSettings["RedisUpdateStrategyDay"];
            ITrigger addUpdateTrigger = TriggerBuilder.Create()
               .WithIdentity("addUpdateTrigger", "RedisTrigger")
               .ForJob(addUpdateJob)
               .WithCronSchedule(dayStrategy) // 每天8~18点，每隔两小时执行一次                                                                             
               .Build();

            scheduler.ScheduleJob(addUpdateJob, addUpdateTrigger);

        }

        public static void shutdownUpdateJob()
        {
            scheduler.Shutdown();
        }
    }