AOP-Redis缓存

我没有单独使用过Redis，细节我可能解释不到位。该文章是采用依赖注入实现AOP-Redis缓存功能的

之前有写实现Memory缓存的。异曲同工之妙。

使用Redis离不开安装get包：StackExchange.Redis.

操作流程：

1. 创建一个RedisAOP的.cs文件。继承IInterceptor的接口，允许程序进行拦截。该接口应该依赖于Autofac，所以依赖注入最好使用AUtofac。
2. 实现接口的方法Intercept。拦截的功能的操作主要在此处执行。
3. 老张的项目是有一个baseAop的，因为RedisAOP和MemoryAOP都是属于缓存，有公共的方法。例如截取Key值等。初学我就不搞太麻烦了。一个一个手写比较容易记住。
4. 定义一个接口一个实现。IRedisCaching，RedisCaching。该实现主要是向Redis存储值和取值。所以定义两个方法，Get获取缓存，Set存入缓存。
5. RedisCaching里依赖注入ConnectionMultiplexer、这个代表Redis的连接字符串对象(应该可以这么理解，也可能我说的不太准确)。通过该对象的GetDatabase()获取redis内的数据库链接对象。然后使用StringGet，或者StringSet来存储或读取缓存。
6. 将接口注入到第一步的RedisAOP中，让我们可以进行操作Redis。
7. 很重要的一部分。将IRedisCaching和RedisCaching注入程序，以至于我们可以依赖注入在RedisAOP中使用。其次！！！很重要的一部分不能忘记ConnectionMultiplexer也要注入进去！！！我一开始因为不常用redis。脑子抽抽忘记了。

• RedisAOP代码

public class RedisAOP : IInterceptor
    {
        protected readonly IRedisCaching redis; 

        public RedisAOP(IRedisCaching _redis)
        {
            this.redis = _redis;
        }
        public void Intercept(IInvocation invocation)
        {
            var method = invocation.MethodInvocationTarget ?? invocation.Method;
            //获取自定义缓存键
            var cacheKey = CustomCacheKey(invocation);
            //根据key获取相应的缓存值
            var cacheValue = redis.GetValue(cacheKey).Result;
            if (cacheValue != null)
            {
                //动态返回类型
                Type returnType;
                //获取传入方法的返回类型。如果是多个就取默认第一个
                if (typeof(Task).IsAssignableFrom(method.ReturnType))
                {
                    returnType = method.ReturnType.GenericTypeArguments.FirstOrDefault();
                }
                else
                {
                    returnType = method.ReturnType;
                }
                //将数据解析成方法返回类型
                dynamic _result = JsonSerializer.Deserialize(cacheValue, returnType);
                invocation.ReturnValue = (typeof(Task).IsAssignableFrom(method.ReturnType)) ? Task.FromResult(_result) : _result;
                return;
            }
            //去执行当前的方法
            invocation.Proceed();
            //存入缓存
            if (!string.IsNullOrWhiteSpace(cacheKey))
            {
                redis.Set(cacheKey, invocation.ReturnValue,TimeSpan.FromHours(24));
            }
        }

        /// <summary>
        /// object 转 string
        /// </summary>
        /// <param name="arg"></param>
        /// <returns></returns>
        protected static string GetArgumentValue(object arg)
        {
            if (arg is DateTime || arg is DateTime?)
            {
                return ((DateTime)arg).ToString("yyyyMMddHHmmss");
            }

            if (arg is string || arg is ValueType || arg is Nullable)
            {
                return arg.ToString();
            }

            if (arg != null)
            {
                if (arg.GetType().IsClass)
                {
                    return MD5Helper.MD5Encrypt16(JsonSerializer.Serialize(arg));
                }
            }

            return string.Empty;
        }

        /// <summary>
        /// 自定义缓存的key
        /// </summary>
        /// <param name="invocation"></param>
        /// <returns></returns>
        protected string CustomCacheKey(IInvocation invocation)
        {
            var typeName = invocation.TargetType.Name;
            var methodName = invocation.Method.Name;
            var methodArguments = invocation.Arguments.Select(GetArgumentValue).Take(3).ToList();//获取参数列表，最多三个

            string key = $"{typeName}:{methodName}:";
            foreach (var param in methodArguments)
            {
                key = $"{key}{param}:";
            }
            return key.TrimEnd(':');
        }
    }

• IRedisCaching/RedisCaching代码

public class RedisCaching : IRedisCaching
    {
        private readonly ConnectionMultiplexer redis;
        private readonly IDatabase database;
        public RedisCaching(ConnectionMultiplexer _redis)
        {
            this.redis = _redis;
            database = _redis.GetDatabase();
        }
        /// <summary>
        /// 获取值
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        public async Task<string> GetValue(string key)
        {
            return await database.StringGetAsync(key);
        }
        /// <summary>
        /// 存储值
        /// </summary>
        /// <param name="key"></param>
        /// <param name="value"></param>
        /// <param name="cacheTime">过期时间</param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task Set(string key, object value, TimeSpan cacheTime)
        {
            if (value != null)
            {
                if (value is string cacheValue)
                {
                    // 字符串无需序列化
                   await database.StringSetAsync(key, cacheValue, cacheTime);
                }
                else
                {
                    //序列化，将object值生成RedisValue
                    await database.StringSetAsync(key, JsonSerializer.Serialize(value), cacheTime);
                }
            }
        }
    }

• 注入相关的接口，和Redis

//接口
builder.Services.AddSingleton<IRedisCaching,RedisCaching>();
//Redis
builder.Services.AddSingleton<ConnectionMultiplexer>(sp =>
{
    //获取连接字符串
    string redisConfiguration = "127.0.0.1:6678,password=123456";
    var configuration = ConfigurationOptions.Parse(redisConfiguration, true);
    configuration.ResolveDns = true;
    return ConnectionMultiplexer.Connect(configuration);
});

• 使用Autofac将AOP文件注册到服务的程序集中

var assemblysServicesPath = Path.Combine(basePath, "DogService");

            builder.RegisterType<LogAOP>();//可以直接替换其他拦截器！一定要把拦截器进行注册
            builder.RegisterType<RedisAOP>();

            //注入仓储
            var assemblysRepository = Assembly.LoadFrom(assemblysRepositoryPath);
            builder.RegisterAssemblyTypes(assemblysRepository)
                      .AsImplementedInterfaces()//方法表示将组件以其实现的接口类型进行注册，这样在进行依赖注入时，可以根据接口类型获取相应的实现类
                      .PropertiesAutowired()//方法用于自动装配属性依赖
                      .InstancePerDependency()//方法表示每次请求时都创建一个新的实例。
                      .EnableInterfaceInterceptors()//方法启用接口拦截，使得后续可以对注册的接口进行拦截。
                      .InterceptedBy(typeof(LogAOP),typeof(RedisAOP));//表

完活