.net8 AOP 实现简单的Json Redis 缓存/业务分离

张建平

 场景: 在不动 业务逻辑的情况下, 实现读写缓存
　  这里使用的AOP的方式 在 方法上加注解, 这目前有个弊端不能传数组, 涉及到排序问题

1.   /// <summary>
2.   /// Json Redis缓存
3.   /// </summary>
4.   public class RedisInterceptorAttribute : AbstractInterceptorAttribute
5.   {
6.       readonly string _cacheKey;
7.       bool _isDb = false; //是否走缓存
8.       int _expireSeconds = -1;
9.    
11.       public RedisInterceptorAttribute(string cacheKey, int expireSeconds = -1,bool isDb=false)
12.       {
13.           _cacheKey = cacheKey;
14.           _isDb = isDb;
15.           _expireSeconds = expireSeconds;
16.       }
18.       public override async Task Invoke(AspectContext context, AspectDelegate next)
19.       {
20.          
21.           Type returnType = context.ServiceMethod.ReturnType;
22.           Type genericArgument = returnType.GetGenericArguments()[0];
23.           // 生成缓存的key
24.           string cacheKeyWithParams = GenerateCacheKey(context);
26.           if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>))
27.           {
28.               //通过类型获取缓存方法,并且调用 GetAsync 方法
29.               MethodInfo method = this.GetType().GetMethod("GetAsync", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
30.               MethodInfo genericMethod = method.MakeGenericMethod(genericArgument);
32.               var cacheTask = (Task)genericMethod.Invoke(this, new object[] { cacheKeyWithParams });
33.               await cacheTask.ConfigureAwait(true);
35.               var resultProperty = cacheTask.GetType().GetProperty("Result");
36.               var cacheResult = resultProperty.GetValue(cacheTask);
39.               if (cacheResult != null)
40.               {
41.                   context.ReturnValue = ConvertToReturnType(cacheResult, returnType);
42.                   // 设置缓存的逻辑
43.                   await Task.CompletedTask;
45.               }
46.               else
47.               {
48.                   await context.Invoke(next);
49.                   // 设置缓存
50.                    if (returnType.IsGenericType && returnType.GetGenericTypeDefinition() == typeof(Task<>))
51.                   {
52.                       MethodInfo setMethod = this.GetType().GetMethod("SetAsync", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
53.                       MethodInfo genericSetMethod = setMethod.MakeGenericMethod(genericArgument);
55.                       var resultProperty1 = context.ReturnValue.GetType().GetProperty("Result");
56.                       var result = resultProperty1.GetValue(context.ReturnValue);
57.                       await (Task)genericSetMethod.Invoke(this, new object[] { cacheKeyWithParams, result });
58.                   }
59.               }
60.           }
61.           else
62.           {
63.               await next(context);
64.           }
65.       }
66.       private string GenerateCacheKey(AspectContext context)
67.       {
68.           var keyBuilder = new System.Text.StringBuilder(_cacheKey);
70.           foreach (var parameter in context.Parameters)
71.           {
72.               keyBuilder.Append(":").Append(FormatParameter(parameter));
73.           }
75.           return keyBuilder.ToString();
76.       }
78.       /// <summary>
79.       /// 格式化参数(类似url过滤一下数据,: 会影响阅读)
80.       /// </summary>
81.       /// <param name="parameter"></param>
82.       /// <returns></returns>
83.       private string FormatParameter(object parameter)
84.       {
85.          
86.           return JsonConvert.SerializeObject(parameter).Replace(":", "=").Replace("{", "").Replace("}", "").Replace(""", "").Replace(",", "&");
87.       }
88.       /// <summary>
89.       /// 将返回值转换为原有类型
90.       /// </summary>
91.       /// <param name="result"></param>
92.       /// <param name="returnType"></param>
93.       /// <returns></returns>
94.       private object ConvertToReturnType(object result, Type returnType)
95.       {
96.           Type taskResultType = returnType.GetGenericArguments()[0];
97.           return typeof(Task).GetMethod(nameof(Task.FromResult))
98.                              .MakeGenericMethod(taskResultType)
99.                              .Invoke(null, new[] { result });
100.       }
102.       async Task<T> GetAsync<T>(string key)
103.       {
104.           var result = await RedisHelper.GetAsync<T>(key);
105.           return result;
106.       }
108.       async Task SetAsync<T>(string cacheKey, T data)
109.       {
110.           if (data != null)
111.           {
112.               await RedisHelper.SetAsync(cacheKey, data, _expireSeconds);
113.           }
114.       }
116.   }

复制代码

这样就简单实现了
只需要在方法上加注解, 一定要加virtual

1.      //一定要加virtual
2.      [RedisInterceptor("school")]
3.      public virtual async Task<List<string>> SelectAsync(Guid[] schoolId)
4.      {
5.          ///业务
6.          return new();
7.      }

复制代码

QQ群: 929412850 (Byte.Core 框架交流群)
未经作者同意,禁止转发
   

来源:https://www.cnblogs.com/wxhwpmdyz/p/18397527
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！