init

2025-11-04 21:09:16 +08:00
parent 8260e293c7
commit bb90a020dc
592 changed files with 61749 additions and 27 deletions
--- a/DouyinApi.Extensions/AOP/CacheAOPbase.cs
+++ b/DouyinApi.Extensions/AOP/CacheAOPbase.cs
@@ -0,0 +1,184 @@
+using DouyinApi.Common.Helper;
+using Castle.DynamicProxy;
+using Newtonsoft.Json;
+using SqlSugar;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace DouyinApi.AOP
+{
+    public abstract class CacheAOPbase : IInterceptor
+    {
+        /// <summary>
+        /// AOP的拦截方法
+        /// </summary>
+        /// <param name="invocation"></param>
+        public abstract void Intercept(IInvocation invocation);
+
+        /// <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(':');
+        }
+
+        /// <summary>
+        /// object 转 string
+        /// </summary>
+        /// <param name="arg"></param>
+        /// <returns></returns>
+        protected static string GetArgumentValue(object arg)
+        {
+            if (arg is DateTime)
+                return ((DateTime)arg).ToString("yyyyMMddHHmmss");
+
+            if (!arg.IsNotEmptyOrNull())
+                return arg.ObjToString();
+
+            if (arg != null)
+            {
+                if (arg is Expression)
+                {
+                    var obj = arg as Expression;
+                    var result = Resolve(obj);
+                    return MD5Helper.MD5Encrypt16(result);
+                }
+                else if (arg.GetType().IsClass)
+                {
+                    return MD5Helper.MD5Encrypt16(JsonConvert.SerializeObject(arg));
+                }
+
+                return $"value:{arg.ObjToString()}";
+            }
+            return string.Empty;
+        }
+
+        private static string Resolve(Expression expression)
+        {
+            ExpressionContext expContext = new ExpressionContext();
+            expContext.Resolve(expression, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+
+            pars.ForEach(s =>
+            {
+                value = value.Replace(s.ParameterName, s.Value.ObjToString());
+            });
+
+            return value;
+        }
+
+        private static string GetOperator(ExpressionType expressiontype)
+        {
+            switch (expressiontype)
+            {
+                case ExpressionType.And:
+                    return "and";
+                case ExpressionType.AndAlso:
+                    return "and";
+                case ExpressionType.Or:
+                    return "or";
+                case ExpressionType.OrElse:
+                    return "or";
+                case ExpressionType.Equal:
+                    return "=";
+                case ExpressionType.NotEqual:
+                    return "<>";
+                case ExpressionType.LessThan:
+                    return "<";
+                case ExpressionType.LessThanOrEqual:
+                    return "<=";
+                case ExpressionType.GreaterThan:
+                    return ">";
+                case ExpressionType.GreaterThanOrEqual:
+                    return ">=";
+                default:
+                    throw new Exception($"不支持{expressiontype}此种运算符查找！");
+            }
+        }
+
+        private static string ResolveFunc(Expression left, Expression right, ExpressionType expressiontype)
+        {
+            var Name = (left as MemberExpression).Member.Name;
+            var Value = (right as ConstantExpression).Value;
+            var Operator = GetOperator(expressiontype);
+            return Name + Operator + Value ?? "null";
+        }
+
+        private static string ResolveLinqToObject(Expression expression, object value, ExpressionType? expressiontype = null)
+        {
+            var MethodCall = expression as MethodCallExpression;
+            var MethodName = MethodCall.Method.Name;
+            switch (MethodName)
+            {
+                case "Contains":
+                    if (MethodCall.Object != null)
+                        return Like(MethodCall);
+                    return In(MethodCall, value);
+                case "Count":
+                    return Len(MethodCall, value, expressiontype.Value);
+                case "LongCount":
+                    return Len(MethodCall, value, expressiontype.Value);
+                default:
+                    throw new Exception($"不支持{MethodName}方法的查找！");
+            }
+        }
+
+        private static string In(MethodCallExpression expression, object isTrue)
+        {
+            var Argument1 = (expression.Arguments[0] as MemberExpression).Expression as ConstantExpression;
+            var Argument2 = expression.Arguments[1] as MemberExpression;
+            var Field_Array = Argument1.Value.GetType().GetFields().First();
+            object[] Array = Field_Array.GetValue(Argument1.Value) as object[];
+            List<string> SetInPara = new List<string>();
+            for (int i = 0; i < Array.Length; i++)
+            {
+                string Name_para = "InParameter" + i;
+                string Value = Array[i].ToString();
+                SetInPara.Add(Value);
+            }
+            string Name = Argument2.Member.Name;
+            string Operator = Convert.ToBoolean(isTrue) ? "in" : " not in";
+            string CompName = string.Join(",", SetInPara);
+            string Result = $"{Name} {Operator} ({CompName})";
+            return Result;
+        }
+        private static string Like(MethodCallExpression expression)
+        {
+
+            var Temp = expression.Arguments[0];
+            LambdaExpression lambda = Expression.Lambda(Temp);
+            Delegate fn = lambda.Compile();
+            var tempValue = Expression.Constant(fn.DynamicInvoke(null), Temp.Type);
+            string Value = $"%{tempValue}%";
+            string Name = (expression.Object as MemberExpression).Member.Name;
+            string Result = $"{Name} like {Value}";
+            return Result;
+        }
+
+
+        private static string Len(MethodCallExpression expression, object value, ExpressionType expressiontype)
+        {
+            object Name = (expression.Arguments[0] as MemberExpression).Member.Name;
+            string Operator = GetOperator(expressiontype);
+            string Result = $"len({Name}){Operator}{value.ToString()}";
+            return Result;
+        }
+
+    }
+}