码迷，mamicode.com
首页 > Web开发 > 详细

九、.net core(.NET 6)添加通用的Redis功能

时间：2021-06-04 19:05:09      阅读：0      评论：0      收藏：0      [点我收藏+]

标签：exception   style   方案   ice   name   turn   public   键值对   qq群   

 .net core 编写通用的Redis功能

在 Package项目里面，添加包：StackExchange.Redis:

 技术图片

 

在Common工具文件夹下，新建 Wsk.Core.Redis类库项目，并新建 RedisManage 类和对应接口 IRedisManage，如下图。然后，在该项目里面，引用共用包项目Wsk.Core.Package,用以使用Redis有关功能。

 技术图片

 

在RedisManage类里面，新增几个用于连接Redis配置的全局变量，以及一个构造函数：

 技术图片

 

在配置文件里面，新建Redis的有关配置信息：

 技术图片

配置的Json文本：

 "Redis": [
    {
      "Name": "Wesky",
      "Ip": "127.0.0.1",
      "Port": 6379,
      "Password": "wesky123",
      "Timeout": 30,
      "Db": 3
    }
  ]

 

其中，Name是别名，可以任意起。Ip是Redis的服务端地址，例如安装本地，就是127.0.0.1,端口号Port默认是6379，密码可以通过Redis安装的根目录下的配置文件进行设置，Timeout是连接的超时时间，Db是使用Redis的DB区，一般Redis的DB区默认是0到15。注意：此处的配置使用的是数组，用于将来进行Redis分布式操作的可拓展。

看下redis安装目录下的配置文件局部一览：

 技术图片

 如果打算修改该配置文件来实现修改有关的配置信息，但是没有效果，注意在windows服务里面把redis服务进行重新启动。如果还不行，就把另外一个conf配置文件也做同样的操作，然后再重启redis服务。

 

接着，在解决方案下，新建一个文件夹，叫DataEntities,该文件夹当做将来存放各种实体类或有关项目的目录。现在咱们在该新建的文件夹下，新建一个类库项目：Wsk.Core.Entity,然后新建一个实体类，叫RedisConfig，用于读取到配置文件的Redis信息进行赋值使用：

 

 技术图片

 

回到Redis类库项目，在RedisManage类里面，添加一个方法ReadRedisSetting，用于读取该配置信息，并赋值给ConfigurationOptions类：

 技术图片

 

ReadRedisSetting代码：

技术图片 
  private ConfigurationOptions ReadRedisSetting()
        {
            try
            {
                List<RedisConfig> config = AppHelper.ReadAppSettings<RedisConfig>(new string[] { "Redis" }); // 读取Redis配置信息
                if (config.Any())
                {
                    ConfigurationOptions options = new ConfigurationOptions
                    {
                        EndPoints =
                            {
                                {
                                    config.FirstOrDefault().Ip,
                                    config.FirstOrDefault().Port
                                }
                            },
                        ClientName = config.FirstOrDefault().Name,
                        Password = config.FirstOrDefault().Password,
                        ConnectTimeout = config.FirstOrDefault().Timeout,
                        DefaultDatabase = config.FirstOrDefault().Db,
                    };
                    return options;
                }
                return null;
            }
            catch(Exception ex)
            {
                _logger.LogError($"获取Redis配置信息失败：{ex.Message}");
                return null;
            }

        }
View Code

 

然后，新建一个方法ConnectionRedis，用于连接Redis：

 技术图片

方法代码：

技术图片 
 private ConnectionMultiplexer ConnectionRedis()
        {
            if (this._redisConnection != null && this._redisConnection.IsConnected)
            {
                return this._redisConnection; // 已有连接，直接使用
            }
            lock (_redisConnectionLock)
            {
                if (this._redisConnection != null)
                {
                    this._redisConnection.Dispose(); // 释放，重连
                }
                try
                {
                    this._redisConnection = ConnectionMultiplexer.Connect(_configOptions);
                }
                catch (Exception ex)
                {
                   _logger.LogError($"Redis服务启动失败：{ex.Message}");
                }
            }
            return this._redisConnection;
        }
View Code

 

在构造函数里面，进行Redis连接的实现：

 技术图片

 

现在，做个简单的测试，新建一个Set方法和一个GetValue方法，用于测试效果：

 技术图片

 

在IRedisMagane接口里面，添加以上有关的接口方法：

 技术图片

 

现在转到启动项目上，启动项目新增对Wsk.Core.Redis项目的引用，并且在WskService类下面，新增对刚刚新增的Redis管理类的依赖注入的注册：

 技术图片

 

现在，在控制器里面，添加有关构造函数的依赖注入，然后做个实践，验证下是否成功。

先改写控制器内容，先设置一对key/value，然后进行读取并返回：

 技术图片

 

启动项目，输入Hello Redis！ ，然后查看返回对应的内容：

 

 技术图片

 

我们打开Redis管理客户端看看，是不是可以看见有这个值：

 技术图片

 

因为我们配置的是Db = 3,所以在Db3这个地方，可以看见我们的Key,点击Tesk，即可在右边窗口看见对应的内容。说明Redis操作成功。

最后，咱们对Redis管理类进行一些其他功能的添加，以及接口方法的添加，用于完善它的功能链，包括移除、读取实体数据、清空、异步操作等。以下截图为对应的接口方法展示：

 技术图片

 接口部分源码：

技术图片 
 public interface IRedisManage
    {
        /// <summary>
        /// 设置一个 键值对
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="ts"></param>
        void Set(string key, object value, TimeSpan ts);
        /// <summary>
        ///  //获取 Reids 缓存值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        string GetValue(string key);
        /// <summary>
        /// 获取序列化值
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        TEntity Get<TEntity>(string key);
        /// <summary>
        /// 判断Key是否存在
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        bool Get(string key);
        /// <summary>
        /// 移除某个Key和值
        /// </summary>
        /// <param name="key"></param>
        void Remove(string key);
        /// <summary>
        /// 清空Redis
        /// </summary>
        void Clear();
        /// <summary>
        /// 异步获取 Reids 缓存值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<string> GetValueAsync(string key);
        /// <summary>
        /// 异步获取序列化值
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="key"></param>
        /// <returns></returns>
        Task<TEntity> GetAsync<TEntity>(string key);
        Task SetAsync(string key, object value, TimeSpan cacheTime);
        Task<bool> GetAsync(string key);
        /// <summary>
        /// 异步移除指定的key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task RemoveAsync(string key);
        /// <summary>
        /// 异步移除模糊查询到的key
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        Task RemoveByKey(string key);
        /// <summary>
        /// 异步全部清空
        /// </summary>
        /// <returns></returns>
        Task ClearAsync();
    }
View Code

接口实现部分的整体源码：

技术图片 
  public class RedisManage : IRedisManage
    {
        public volatile ConnectionMultiplexer _redisConnection;
        private readonly object _redisConnectionLock = new object();
        private readonly ConfigurationOptions _configOptions;
        private readonly ILogger<RedisManage> _logger;
        public RedisManage(ILogger<RedisManage> logger)
        {
            _logger = logger;
            ConfigurationOptions options = ReadRedisSetting();
            if (options == null)
            {
               _logger.LogError("Redis数据库配置有误");
            }

           this._configOptions = options;
            this._redisConnection = ConnectionRedis();
        }

        private ConfigurationOptions ReadRedisSetting()
        {
            try
            {
                List<RedisConfig> config = AppHelper.ReadAppSettings<RedisConfig>(new string[] { "Redis" }); // 读取Redis配置信息
                if (config.Any())
                {
                    ConfigurationOptions options = new ConfigurationOptions
                    {
                        EndPoints =
                            {
                                {
                                    config.FirstOrDefault().Ip,
                                    config.FirstOrDefault().Port
                                }
                            },
                        ClientName = config.FirstOrDefault().Name,
                        Password = config.FirstOrDefault().Password,
                        ConnectTimeout = config.FirstOrDefault().Timeout,
                        DefaultDatabase = config.FirstOrDefault().Db,
                    };
                    return options;
                }
                return null;
            }
            catch(Exception ex)
            {
                _logger.LogError($"获取Redis配置信息失败：{ex.Message}");
                return null;
            }

        }

        private ConnectionMultiplexer ConnectionRedis()
        {
            if (this._redisConnection != null && this._redisConnection.IsConnected)
            {
                return this._redisConnection; // 已有连接，直接使用
            }
            lock (_redisConnectionLock)
            {
                if (this._redisConnection != null)
                {
                    this._redisConnection.Dispose(); // 释放，重连
                }
                try
                {
                    this._redisConnection = ConnectionMultiplexer.Connect(_configOptions);
                }
                catch (Exception ex)
                {
                   _logger.LogError($"Redis服务启动失败：{ex.Message}");
                }
            }
            return this._redisConnection;
        }

        public string GetValue(string key)
        {
            return _redisConnection.GetDatabase().StringGet(key);
        }

        public void Set(string key, object value, TimeSpan ts)
        {
            if (value != null)
            {
                _redisConnection.GetDatabase().StringSet(key, JsonConvert.SerializeObject(value), ts);
            }
        }

        public void Clear()
        {
            foreach (var endPoint in this.ConnectionRedis().GetEndPoints())
            {
                var server = this.ConnectionRedis().GetServer(endPoint);
                foreach (var key in server.Keys())
                {
                    _redisConnection.GetDatabase().KeyDelete(key);
                }
            }
        }

        public bool Get(string key)
        {
            return _redisConnection.GetDatabase().KeyExists(key);
        }

     
        public TEntity Get<TEntity>(string key)
        {
            var value = _redisConnection.GetDatabase().StringGet(key);
            if (value.HasValue)
            {
                //需要用的反序列化，将Redis存储的Byte[]，进行反序列化
                return JsonConvert.DeserializeObject<TEntity>(value);
            }
            else
            {
                return default(TEntity);
            }
        }

        public void Remove(string key)
        {
            _redisConnection.GetDatabase().KeyDelete(key);
        }

        public bool SetValue(string key, byte[] value)
        {
            return _redisConnection.GetDatabase().StringSet(key, value, TimeSpan.FromSeconds(120));
        }



        public async Task ClearAsync()
        {
            foreach (var endPoint in this.ConnectionRedis().GetEndPoints())
            {
                var server = this.ConnectionRedis().GetServer(endPoint);
                foreach (var key in server.Keys())
                {
                    await _redisConnection.GetDatabase().KeyDeleteAsync(key);
                }
            }
        }

        public async Task<bool> GetAsync(string key)
        {
            return await _redisConnection.GetDatabase().KeyExistsAsync(key);
        }

        public async Task<string> GetValueAsync(string key)
        {
            return await _redisConnection.GetDatabase().StringGetAsync(key);
        }

        public async Task<TEntity> GetAsync<TEntity>(string key)
        {
            var value = await _redisConnection.GetDatabase().StringGetAsync(key);
            if (value.HasValue)
            {
                return JsonConvert.DeserializeObject<TEntity>(value);
            }
            else
            {
                return default;
            }
        }

        public async Task RemoveAsync(string key)
        {
            await _redisConnection.GetDatabase().KeyDeleteAsync(key);
        }

        public async Task RemoveByKey(string key)
        {
            var redisResult = await _redisConnection.GetDatabase().ScriptEvaluateAsync(LuaScript.Prepare(
                //模糊查询：
                " local res = redis.call(‘KEYS‘, @keypattern) " +
                " return res "), new { @keypattern = key });

            if (!redisResult.IsNull)
            {
                var keys = (string[])redisResult;
                foreach (var k in keys)
                    _redisConnection.GetDatabase().KeyDelete(k);

            }
        }

        public async Task SetAsync(string key, object value, TimeSpan cacheTime)
        {
            if (value != null)
            {
                await _redisConnection.GetDatabase().StringSetAsync(key, JsonConvert.SerializeObject(value), cacheTime);
            }
        }

        public async Task<bool> SetValueAsync(string key, byte[] value)
        {
            return await _redisConnection.GetDatabase().StringSetAsync(key, value, TimeSpan.FromSeconds(120));
        }

    }
View Code

 

由于时间关系，就不一一列举各自的功能了，各位大佬们可以自行尝试。

最后，说个小窍门：Key值如果使用冒号，在客户端上面查看就会自动变成分层结构。举个例子，改写控制器，原本设置的Test这个Key,改写为Test:Wesky:

 技术图片

 

然后，启动程序，让他执行一下，用于生成一条记录，例如此处我写入：Hello Key’s Rules:

 技术图片

 

由此可见，Key值分层显示了。在一些场合下，可以使用冒号来分隔开不同层级的Key，以便于在客户端查看。

至此，结束，欢迎打赏、评论和点赞。

版权所有，转载请注明出处：https://www.cnblogs.com/weskynet/p/14847526.html

备注：如果有需要Redis、以及Redis安装包的，以及安装教程，可以加以下的QQ群进行获取和咨询。

九、.net core(.NET 6)添加通用的Redis功能

标签：exception   style   方案   ice   name   turn   public   键值对   qq群   

原文地址：https://www.cnblogs.com/weskynet/p/14847526.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！