带你走进redis的封装及注入使用

Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。

本内容对Redis进行简单的封装。使用框架为StackExchange.Redis

定于redis的配置选项，主要用来读取配置

  public class RedisOption
    {
        public const string sectionName = "RedisConfig";
        public string ConnectionString { get; set; }
    }

定义缓存接口 IRedisOperationRepository ，在代码中使用接口，减少依赖，可以进行扩展，假如有一天我使用的这个框架停用了，

我可以使用其他框架比如ServiceStack.Redis，或者用自带的memory, 或者mongodb。主要是在替换的时候减少代码的修改量

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

namespace WebApplication2
{
    /// 
    /// Redis缓存接口
    /// 
    public interface IRedisOperationRepository
    {

        //获取 Reids 缓存值
        Task Get(string key);

        //获取值，并序列化
        Task Get(string key);

        //保存
        Task Set(string key, object value, TimeSpan cacheTime);

        //判断是否存在
        Task Exist(string key);

        //移除某一个缓存值
        Task Remove(string key);

        //全部清除
        Task Clear();

        /// 
        /// 根据key获取RedisValue
        /// 
        /// 
        /// 
        Task ListRangeAsync(string redisKey);

        /// 
        /// 在列表头部插入值。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        Task ListLeftPushAsync(string redisKey, string redisValue);

        /// 
        /// 在列表尾部插入值。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        Task ListRightPushAsync(string redisKey, string redisValue);

        /// 
        /// 在列表尾部插入数组集合。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        Task ListRightPushAsync(string redisKey, IEnumerable redisValue);

        /// 
        /// 移除并返回存储在该键列表的第一个元素  反序列化
        /// 
        /// 
        /// 
        /// 
        Task ListLeftPopAsync(string redisKey) where T : class;

        /// 
        /// 移除并返回存储在该键列表的最后一个元素   反序列化
        /// 
        /// 
        /// 
        /// 
        Task ListRightPopAsync(string redisKey) where T : class;

        /// 
        /// 移除并返回存储在该键列表的第一个元素
        /// 
        /// 
        /// 
        Task ListLeftPopAsync(string redisKey);

        /// 
        /// 移除并返回存储在该键列表的最后一个元素
        /// 
        /// 
        /// 
        Task ListRightPopAsync(string redisKey);

        /// 
        /// 列表长度
        /// 
        /// 
        /// 
        Task ListLengthAsync(string redisKey);

        /// 
        /// 返回在该列表上键所对应的元素
        /// 
        /// 
        /// 
        /// 
        Task> ListRangeAsync(string redisKey, int db = -1);

        /// 
        /// 根据索引获取指定位置数据
        /// 
        /// 
        /// 
        /// 
        /// 
        Task> ListRangeAsync(string redisKey, int start, int stop);

        /// 
        /// 删除List中的元素 并返回删除的个数
        /// 
        /// 
        /// 
        /// 
        /// 
        Task ListDelRangeAsync(string redisKey, string redisValue, long type = 0);

        /// 
        /// 清空List
        /// 
        /// 
        /// 
        Task ListClearAsync(string redisKey);


        /// 
        /// 有序集合/定时任务延迟队列用的多
        /// 
        /// key
        /// 元素
        /// 分数
        Task SortedSetAddAsync(string redisKey, string redisValue, double score);

    }
}

继承IRedisOperationRepository接口，实现类

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

namespace WebApplication2
{
    public class RedisOperationRepository : IRedisOperationRepository
    {
        private readonly ILogger _logger;
        private readonly ConnectionMultiplexer _redis;
        private readonly IDatabase _database;

        public RedisOperationRepository(ILogger logger, ConnectionMultiplexer redis)
        {
            _logger = logger;
            _redis = redis;
            _database = redis.GetDatabase();
        }

        private IServer GetServer()
        {
            var endpoint = _redis.GetEndPoints();
            return _redis.GetServer(endpoint.First());
        }

        public async Task Clear()
        {
            foreach (var endPoint in _redis.GetEndPoints())
            {
                var server = GetServer();
                foreach (var key in server.Keys())
                {
                    await _database.KeyDeleteAsync(key);
                }
            }
        }

        public async Task Exist(string key)
        {
            return await _database.KeyExistsAsync(key);
        }

        public async Task Get(string key)
        {
            return await _database.StringGetAsync(key);
        }

        public async Task Remove(string key)
        {
            await _database.KeyDeleteAsync(key);
        }

        public async Task Set(string key, object value, TimeSpan cacheTime)
        {
            if (value != null)
            {
                //序列化，将object值生成RedisValue
                await _database.StringSetAsync(key, JsonConvert.SerializeObject(value), cacheTime);
            }
        }

        public async Task Get(string key)
        {
            var value = await _database.StringGetAsync(key);
            if (value.HasValue)
            {
                //需要用的反序列化，将Redis存储的Byte[]，进行反序列化
                return JsonConvert.DeserializeObject(value);
            }
            else
            {
                return default;
            }
        }

        /// 
        /// 根据key获取RedisValue
        /// 
        /// 
        /// 
        public async Task ListRangeAsync(string redisKey)
        {
            return await _database.ListRangeAsync(redisKey);
        }

        /// 
        /// 在列表头部插入值。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        public async Task ListLeftPushAsync(string redisKey, string redisValue)
        {
            return await _database.ListLeftPushAsync(redisKey, redisValue);
        }
        /// 
        /// 在列表尾部插入值。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        public async Task ListRightPushAsync(string redisKey, string redisValue)
        {
            return await _database.ListRightPushAsync(redisKey, redisValue);
        }

        /// 
        /// 在列表尾部插入数组集合。如果键不存在，先创建再插入值
        /// 
        /// 
        /// 
        /// 
        public async Task ListRightPushAsync(string redisKey, IEnumerable redisValue)
        {
            var redislist = new List();
            foreach (var item in redisValue)
            {
                redislist.Add(item);
            }
            return await _database.ListRightPushAsync(redisKey, redislist.ToArray());
        }


        /// 
        /// 移除并返回存储在该键列表的第一个元素  反序列化
        /// 
        /// 
        /// 
        public async Task ListLeftPopAsync(string redisKey) where T : class
        {
            var cachevalue = await _database.ListLeftPopAsync(redisKey);
            if (string.IsNullOrEmpty(cachevalue)) return null;
            var res = JsonConvert.DeserializeObject(cachevalue);
            return res;
        }

        /// 
        /// 移除并返回存储在该键列表的最后一个元素   反序列化
        /// 只能是对象集合
        /// 
        /// 
        /// 
        public async Task ListRightPopAsync(string redisKey) where T : class
        {
            var cachevalue = await _database.ListRightPopAsync(redisKey);
            if (string.IsNullOrEmpty(cachevalue)) return null;
            var res = JsonConvert.DeserializeObject(cachevalue);
            return res;
        }

        /// 
        /// 移除并返回存储在该键列表的第一个元素   
        /// 
        /// 
        /// 
        public async Task ListLeftPopAsync(string redisKey)
        {
            return await _database.ListLeftPopAsync(redisKey);
        }

        /// 
        /// 移除并返回存储在该键列表的最后一个元素   
        /// 
        /// 
        /// 
        public async Task ListRightPopAsync(string redisKey)
        {
            return await _database.ListRightPopAsync(redisKey);
        }

        /// 
        /// 列表长度
        /// 
        /// 
        /// 
        public async Task ListLengthAsync(string redisKey)
        {
            return await _database.ListLengthAsync(redisKey);
        }

        /// 
        /// 返回在该列表上键所对应的元素
        /// 
        /// 
        /// 
        public async Task> ListRangeAsync(string redisKey, int db = -1)
        {
            var result = await _database.ListRangeAsync(redisKey);
            return result.Select(o => o.ToString());
        }

        /// 
        /// 根据索引获取指定位置数据
        /// 
        /// 
        /// 
        /// 
        /// 
        public async Task> ListRangeAsync(string redisKey, int start, int stop)
        {
            var result = await _database.ListRangeAsync(redisKey, start, stop);
            return result.Select(o => o.ToString());
        }

        /// 
        /// 删除List中的元素 并返回删除的个数
        /// 
        /// key
        /// 元素
        /// 大于零 : 从表头开始向表尾搜索，小于零 : 从表尾开始向表头搜索，等于零：移除表中所有与 VALUE 相等的值
        /// 
        public async Task ListDelRangeAsync(string redisKey, string redisValue, long type = 0)
        {
            return await _database.ListRemoveAsync(redisKey, redisValue, type);
        }

        /// 
        /// 清空List
        /// 
        /// 
        public async Task ListClearAsync(string redisKey)
        {
            await _database.ListTrimAsync(redisKey, 1, 0);
        }


        /// 
        /// 有序集合/定时任务延迟队列用的多
        /// 
        /// key
        /// 元素
        /// 分数
        public async Task SortedSetAddAsync(string redisKey, string redisValue, double score)
        {
            await _database.SortedSetAddAsync(redisKey, redisValue, score);
        }

    }
}

为IServiceCollection 定义一个扩展类，主要是用于注入单例的服务，这边提供了两个扩展方法，其他配置可以有需要可以在RedisOption里面加。

 /// 
    /// Redis缓存 启用服务
    /// 
    public static class RedisCacheSetupExtensions
    {
        public static void AddRedisCacheSetup(this IServiceCollection services,RedisOption redisOption)
        {
            if (services == null) throw new ArgumentNullException(nameof(services));

            services.AddTransient();

            // 配置启动Redis服务，虽然可能影响项目启动速度，但是不能在运行的时候报错，所以是合理的
            services.AddSingleton(sp =>
            {
                //获取连接字符串
                string redisConfiguration = redisOption.ConnectionString;

                var configuration = ConfigurationOptions.Parse(redisConfiguration, true);

                configuration.ResolveDns = true;

                return ConnectionMultiplexer.Connect(configuration);
            });
        }


        public static void AddRedisCacheSetup(this IServiceCollection services, ConfigurationOptions configurationOptions)
        {
            if (services == null) throw new ArgumentNullException(nameof(services));

            services.AddTransient();

            // 配置启动Redis服务，虽然可能影响项目启动速度，但是不能在运行的时候报错，所以是合理的
            services.AddSingleton(sp =>
            {
                return ConnectionMultiplexer.Connect(configurationOptions);
            });
        }


    }

进行服务配置

    public void ConfigureServices(IServiceCollection services)
        {
            RedisOption redisOption= confiiguration.GetSection(RedisOption.sectionName).Get();
            //Redis缓存
            services.AddRedisCacheSetup(redisOption);
            services.AddControllersWithViews();    
        }

appsettings.json 里面的连接配置，有密码的要带上密码，我这边不用密码，使用第二个，第一个被我注释了。

  "RedisConfig": {

    // "ConnectionString": "127.0.0.1:6379,password=,connectTimeout=3000,connectRetry=1,syncTimeout=10000,DefaultDatabase=10" //redis数据库连接字符串
    "ConnectionString": "127.0.0.1:6379,connectTimeout=3000,connectRetry=1,syncTimeout=10000,DefaultDatabase=10"

  }

对缓存redis 进行注入使用。

public class HomeController : Controller
{
    private readonly IRedisOperationRepository redisOperationRepository;

    public HomeController(IRedisOperationRepository redisOperationRepository)
    {
        this.redisOperationRepository = redisOperationRepository;
    }

    // GET: HomeController
    public ActionResult Index()
    {
        redisOperationRepository.Set("name", "keyy" ,TimeSpan.FromSeconds(100));
        return View();
    }
  }

经过以上的配置，就可以进行运用了。

使用场景一般有商品秒杀，菜单加载，其他配置选项，用于数据变动不大的每日公告等缓存。

代码路径在https://gitee.com/Henry173265046/redisdemo

带你走进redis的封装及注入使用

Java相关栏目本月热门文章