(八).NET6.0添加通用的Redis功能

1.添加包:StackExchange.Redis

2.在配置文件里面,新建Redis的有关配置信息

Name是别名,可以任意起。Ip是Redis的服务端地址,例如安装本地,就是127.0.0.1,端口号Port默认是6379,密码可以通过Redis安装的根目录下的配置文件进行设置,Timeout是连接的超时时间,Db是使用Redis的DB区,一般Redis的DB区默认是0到15。注意:此处的配置使用的是数组,用于将来进行Redis分布式操作的可拓展。
注:我是本地部署的Redis,所以在本地有服务端和客户端,在初始情况下,Redis还没有密码,需要我们自己去设置,找到Redis的安装文件

进入图中的.conf文件去编辑
把#requirepass的#注释去掉 然后重新设置密码,设置完成后保存

cmd运行该文件夹,启动服务端并且指定配置文件

然后开启服务端,就可以进行本地redis开发调试了

3.Ysq.Core.Entity,然后新建一个实体类,叫RedisConfig,用于读取到配置文件的Redis信息进行赋值使用

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

点击查看代码
public interface IRedisManage
{
    /// <summary>
    /// 设置一个 键值对
    /// </summary>
    /// <param name="key"></param>
    /// <param name="value"></param>
    /// <param name="ts"></param>
    void SetValue(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();
}
点击查看代码
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<RedisConfigInfo> config = AppHelper.Instance.ReadAppSettings<RedisConfigInfo>(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 SetValue(string key, object value,TimeSpan time)
    {
        if (value!=null)
        {
            _redisConnection.GetDatabase().StringSet(key,JsonConvert.SerializeObject(value),time);
        }
    }

    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));
    }
}

5.启动项目新增对Ysq.Core.Redis项目的引用,并且注入Redis类库中的接口

6.在控制器中设置一对key/value,然后进行读取并返回

Redis客户端有内容

另外:
Redis分布式锁是一种利用Redis单线程特性以及操作原子性实现分布式系统中锁功能的机制,以下我来详细解释这张图和Redis分布式锁的原理:
分布式锁的基本概念:
●使用 SET key value EX seconds NX 命令:key: 锁的名称。
○value: 锁的值(可以用来区分客户端)。
○EX seconds: 锁的过期时间(秒),保证锁不会无限存在。
○NX: 表示“仅在键不存在时设置”(即防止重复设置锁)。
●原理:当某个客户端成功设置了锁后,其他客户端如果尝试设置同样的锁(同样的 key),会失败,直到锁过期或者被释放。

左侧客户端操作:
1.set lock true ex 60 nx:尝试创建一个名为 lock 的锁,值为 true,过期时间为 60 秒。返回 OK,说明锁成功创建。
2.尝试 set lock true ex 60 nx 再次设置锁,返回 (nil),说明锁已经存在,无法再次创建。
3.删除锁:del lock,返回 (integer) 1,表示成功删除锁。
4.再次尝试创建锁:set lock true ex 60 nx,返回 OK,锁被重新创建。
5.删除锁:del lock,返回 (integer) 1。
右侧客户端操作:
1.set lock true ex 60 nx:尝试设置锁。如果锁不存在,返回 OK,锁被设置。
2.再次设置锁:set lock true ex 60 nx,返回 (nil),说明锁已存在,当前客户端无法设置。
3.删除锁:del lock,返回 (integer) 1,锁被成功删除。
观察:
●当锁存在时,其他客户端的 SET lock ... NX 操作会失败。
●但删除锁是无条件的,任何客户端都可以执行 DEL lock 操作,这种情况下存在并发删除的风险。
Redis分布式锁的主要目的是在分布式系统中,确保同一时刻只有一个客户端对某一关键资源进行操作,避免“同时修改”导致数据不一致的问题。例如:
●限制同一资源的并发访问(如用户订单、库存操作)。
●避免定时任务的多次重复执行。
使用锁的伪代码分析:
以下伪代码演示了Redis分布式锁的使用过程:

点击查看代码
If (exists(lock)) {
    return false; // 锁存在,返回失败
} else {
    set lock true ex 5 nx; // 设置锁(超时时间为5秒)
    // 开始操作关键资源
    set key1 100; // 资源操作,比如设置值为100
    del lock; // 删除锁
    return true; // 返回成功
}

posted @   sq1201  阅读(96)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· DeepSeek “源神”启动!「GitHub 热点速览」
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· C# 集成 DeepSeek 模型实现 AI 私有化(本地部署与 API 调用教程)
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· 2 本地部署DeepSeek模型构建本地知识库+联网搜索详细步骤
点击右上角即可分享
微信分享提示