浅析DispatchProxy动态代理AOP

技术分享 2年前 (2022-06-17) 0 999+

浅析DispatchProxy动态代理AOP(代码源码)

最近学习了一段时间Java,了解到Java实现动态代理AOP主要分为两种方式JDK、CGLIB，我之前使用NET实现AOP切面编程，会用Filter拦截器、Attribute特性、中间件、继承父类重写父类方法。

经过查找资料接触到了（牛逼不分先后）

DispatchProxy抽象类源码地址
Dora开源地址
castleproject开源地址
CZGL.AOP开源地址

DispatchProxy类介绍

DispatchProxy源码，主要使用了Emit类库直接编写IL语言，动态生成类，和方法，然后会调用Invoke方法（性能很高，几乎和我们写的C#编译成IL没有区别），我们继承了DispatchProxy抽象类，重写Invoke方法，具体实现就可以自定义了。

DispatchProxy源码

DispatchProxy主要是Activator（文档地址）以及AssemblyBuilder（文档地址）实现,

Activator 类在运行时可以动态构造对象
AssemblyBuilder 类在运行时可以动态获取和设置专用字段的属性、初始化专用字段的构造函数，动态执行方法并返回结果。

    // 动态代理生成类     internal static class DispatchProxyGenerator     {         // 动态代理容器（保存已经生成过的代理）         private static readonly Dictionary<Type, Dictionary<Type, Type>> s_baseTypeAndInterfaceToGeneratedProxyType = new Dictionary<Type, Dictionary<Type, Type>>();         private static readonly ProxyAssembly s_proxyAssembly = new ProxyAssembly();         private static readonly MethodInfo s_dispatchProxyInvokeMethod = typeof(DispatchProxy).GetTypeInfo().GetDeclaredMethod("Invoke");          // 返回派生自'baseType'的代理的新实例，并实现'interfaceType'          internal static object CreateProxyInstance(Type baseType, Type interfaceType)         {             Debug.Assert(baseType != null);             Debug.Assert(interfaceType != null);             // 获取代理类型             Type proxiedType = GetProxyType(baseType, interfaceType);             // 创建实例             return Activator.CreateInstance(proxiedType, (Action<object[]>)DispatchProxyGenerator.Invoke);         }          // 首先从代理容器中获取，如果没有进行创建         private static Type GetProxyType(Type baseType, Type interfaceType)         {             // 锁住容器             lock (s_baseTypeAndInterfaceToGeneratedProxyType)             {                 Dictionary<Type, Type> interfaceToProxy = null;                 // 判断baseType实现类类型容器中是否存在，不存在先初始化一个                 if (!s_baseTypeAndInterfaceToGeneratedProxyType.TryGetValue(baseType, out interfaceToProxy))                 {                     interfaceToProxy = new Dictionary<Type, Type>();                     s_baseTypeAndInterfaceToGeneratedProxyType[baseType] = interfaceToProxy;                 }                 Type generatedProxy = null;                 // 判断是否存在interfaceType接口类型代理类，不存在就创建一个                 if (!interfaceToProxy.TryGetValue(interfaceType, out generatedProxy))                 {                     generatedProxy = GenerateProxyType(baseType, interfaceType);                     interfaceToProxy[interfaceType] = generatedProxy;                 }                  return generatedProxy;             }         }          // 生成一个派生自'baseType'的新代理类型，并实现'interfaceType'          private static Type GenerateProxyType(Type baseType, Type interfaceType)         {             TypeInfo baseTypeInfo = baseType.GetTypeInfo();              // 接口类型必须是接口，而不是类              if (!interfaceType.GetTypeInfo().IsInterface)             {                 throw new ArgumentException(SR.Format(SR.InterfaceType_Must_Be_Interface, interfaceType.FullName), "T");             }              // 基类型不能密封，因为代理需要将其子类化。              if (baseTypeInfo.IsSealed)             {                 throw new ArgumentException(SR.Format(SR.BaseType_Cannot_Be_Sealed, baseTypeInfo.FullName), "TProxy");             }              // 基类型不能是抽象类型             if (baseTypeInfo.IsAbstract)             {                 throw new ArgumentException(SR.Format(SR.BaseType_Cannot_Be_Abstract, baseType.FullName), "TProxy");             }              // 基类型必须有一个公共默认属性（不然没啥意义）             if (!baseTypeInfo.DeclaredConstructors.Any(c => c.IsPublic && c.GetParameters().Length == 0))             {                 throw new ArgumentException(SR.Format(SR.BaseType_Must_Have_Default_Ctor, baseType.FullName), "TProxy");             }              // 创建baseType类              ProxyBuilder pb = s_proxyAssembly.CreateProxy("generatedProxy", baseType);              // 获取接口中需要实现的信息，动态添加实现             foreach (Type t in interfaceType.GetTypeInfo().ImplementedInterfaces)                 pb.AddInterfaceImpl(t);              // 添加实现             pb.AddInterfaceImpl(interfaceType);              // 实现完接口，创建该类型             Type generatedProxyType = pb.CreateType();             return generatedProxyType;         }          // 调用(抽象的)DispatchProxy.Invoke()方法。          private static void Invoke(object[] args)         {             PackedArgs packed = new PackedArgs(args);             MethodBase method = s_proxyAssembly.ResolveMethodToken(packed.DeclaringType, packed.MethodToken);             // 方法是否泛型方法定义             if (method.IsGenericMethodDefinition)                 // 创建泛型方法定义                 method = ((MethodInfo)method).MakeGenericMethod(packed.GenericTypes);              // 调用(抽象的)DispatchProxy.Invoke()方法             try             {                 Debug.Assert(s_dispatchProxyInvokeMethod != null);                 // 执行packed.DispatchProxy该类方法，获取方法的返回结果                 object returnValue = s_dispatchProxyInvokeMethod.Invoke(packed.DispatchProxy,                                                                        new object[] { method, packed.Args });                 // 执行返回结果                 packed.ReturnValue = returnValue;             }             catch (TargetInvocationException tie)             {                 ExceptionDispatchInfo.Capture(tie.InnerException).Throw();             }         }

DispatchProxy拓展封装

根据前面的介绍，对DispatchProxy有了一定的了解，我们可以进行一些封装方便以后使用。

DynamicProxy动态代理类

我们创建DynamicProxy类，包装方法执行之前&执行之后的处理，主体方法报错的处理，形成一个动态代理类。

    public class DynamicProxy : DispatchProxy, IScopedDependency     {         private static ILogger<DynamicProxy>? _logger { get; set; }          /// <summary>         /// 目标类         /// </summary>         public object Target { get; set; }          /// <summary>         /// 动作之后执行         /// </summary>         private Action<object?[]?> _afterAction { get; set; }          /// <summary>         /// 动作之前执行         /// </summary>         private Action<object?[]?, object> _beforeAction { get; set; }          /// <summary>         /// 目标方法异常(默认抛出异常信息)         /// </summary>         private Action<MethodInfo?, object?[]?, Exception> _methodExceptionAction { get; set; } = (methodInfo, args, ex) => throw ex;          /// <summary>         /// 执行方法         /// </summary>         /// <param name="targetMethod">目标方法</param>         /// <param name="args">方法参数</param>         /// <returns></returns>         protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)         {             // 异常信息             Exception exception = null;             // 方法执行前处理             AfterAction(args);             // 方法执行结果             object resultValue = null;             if (targetMethod != null)             {                 try                 {                     //调用实际目标对象的方法                     resultValue = targetMethod.Invoke(Target, args);                 }                 catch (Exception ex)                 {                     _logger.LogError($"Invoke=>调用实际目标对象的方法出现错误：{ex.Message}，{ex.StackTrace}");                     _methodExceptionAction(targetMethod, args, ex);                 }             }             // 方法执行后处理             BeforeAction(args, resultValue);              // 判断主体方法执行是否异常             if (exception != null)             {                 throw exception;             }              return resultValue;         }          /// <summary>         /// 创建代理实例         /// </summary>         /// <param name="target">代理的接口类型</param>         /// <param name="afterAction">方法执行前执行的事件</param>         /// <param name="beforeAction">方法执行后执行的事件</param>         /// <returns></returns>         public T Create<T>(T target,             Action<object?[]?> afterAction,             Action<object?[]?, object> beforeAction,             Action<MethodInfo?, object?[]?, Exception> targetMethodExceptionAction,             ILogger<DynamicProxy> logger)         {             // DispatchProxy.Create创建T对象             object proxy = Create<T, DynamicProxy>();             _logger = logger;             DynamicProxy proxyDecorator = (DynamicProxy)proxy;             proxyDecorator.Target = target;             proxyDecorator._afterAction = afterAction;             proxyDecorator._beforeAction = beforeAction;             proxyDecorator._methodExceptionAction = targetMethodExceptionAction;             return (T)proxy;         }          private void AfterAction(object?[]? args)         {             if (_afterAction == null)             {                 return;             }              try             {                 _afterAction.Invoke(args);             }             catch (Exception ex)             {                 _logger.LogError($"AfterAction=>执行之前异常：{ex.Message}，{ex.StackTrace}");             }         }          private void BeforeAction(object?[]? args, object? result)         {             if (_beforeAction == null)             {                 return;             }              try             {                 _beforeAction.Invoke(args, result);             }             catch (Exception ex)             {                 _logger.LogError($"BeforeAction=>执行之后异常：{ex.Message}，{ex.StackTrace}");             }         }     }

创建IProxyHandle

我们会有很多处理实现类，每个实现类都需要实现AfterAction、BeforeAction、TargetMethodExceptionAction

   public interface IProxyHandle     {         /// <summary>         /// 执行之前         /// </summary>         /// <param name="args">目标方法参数</param>         void AfterAction(object?[]? args);          /// <summary>         /// 执行之后         /// </summary>         /// <param name="args">目标方法参数</param>         /// <param name="result">目标方法执行结果</param>         void BeforeAction(object?[]? args, object resultValue);          /// <summary>         /// 方法执行错误处理         /// </summary>         /// <param name="targetMethod">目标方法</param>         /// <param name="args">目标方法参数</param>         /// <param name="ex">目标方法执行结果</param>         void MethodExceptionAction(MethodInfo? targetMethod, object?[]? args, Exception ex);     }

创建ProxyHandleAttribute特性

这里我尝试过几种方式，通过接口或者使用特性，最终特性比较方便团队使用（接口也不错）。

    /// <summary>     /// 代理Aop特性     /// </summary>     [AttributeUsage(AttributeTargets.Class)]     public class ProxyHandleAttribute : Attribute     {         public Type Type { get; set; }         public ProxyHandleAttribute(Type type)         {             this.Type = type;         }     }

ProxyFactory代理工厂

根据实现类获取Aop切面类型，再获取AOP工厂（IEnumerable<IProxyHandle>）中对应实现。

    /// <summary>     /// 代理工厂     /// </summary>     public class ProxyFactory : IScopedDependency     {         private readonly IServiceProvider _serviceProvider;         private readonly IEnumerable<IProxyHandle> _proxyHandleList;         private readonly DynamicProxy _dynamicProxy;         private readonly ILogger<DynamicProxy> _logger;         public ProxyFactory(IEnumerable<IProxyHandle> proxyHandleList,             IServiceProvider serviceProvider,             DynamicProxy dynamicProxy,             ILogger<DynamicProxy> logger)         {             this._serviceProvider = serviceProvider;             this._proxyHandleList = proxyHandleList;             this._dynamicProxy = dynamicProxy;             this._logger = logger;         }          /// <summary>         /// 创建代理实例         /// </summary>         /// <returns></returns>         public T Create<T>() where T : class         {              var target = _serviceProvider.GetService<T>();             if (target == null)             {                 throw new BusinessException($"执行ProxyFactory=》Create方法：{typeof(T).FullName}未注入");             }             var type = target.GetType();             var proxyHandleAttribute = type.GetCustomAttribute<ProxyHandleAttribute>();             if (proxyHandleAttribute == null)             {                 throw new BusinessException($"执行ProxyFactory=》Create方法：{type.FullName}需要添加ProxyHandleAttribute特性");             }             var proxyHandle = _proxyHandleList.FirstOrDefault(x => x.GetType() == proxyHandleAttribute.Type);             if (proxyHandleAttribute == null)             {                 throw new BusinessException($"执行ProxyFactory=》Create方法：没有找到对应IProxyHandle接口实现");             }             //创建代理类             var proxy = _dynamicProxy.Create(target,                 proxyHandle.AfterAction,                 proxyHandle.BeforeAction,                 proxyHandle.MethodExceptionAction,                 _logger);             return proxy;         }     }

DynamicProxy使用示例

IProxyHandle实现类(ProxyHandleTest)

public class ProxyHandleTest : IProxyHandle     {         public void AfterAction(object[] args)         {             Console.WriteLine($"ProxyHandleTest=》AfterAction方法执行，args：{JsonSerializer.Serialize(args)}");         }          public void BeforeAction(object[] args, object resultValue)         {             Console.WriteLine($"ProxyHandleTest=》BeforeAction方法执行，args：{JsonSerializer.Serialize(args)}，result：{resultValue}");         }          public void MethodExceptionAction(MethodInfo targetMethod, object[] args, Exception ex)         {             Console.WriteLine($"ProxyHandleTest=》MethodExceptionAction方法执行，targetMethod,：{targetMethod.Name}，args：{JsonSerializer.Serialize(args)}，ex：{ex.Message}");         }     }

准备ITestService、TestService

public interface ITestService     {         /// <summary>         /// 获取用户Id信息         /// </summary>         /// <returns></returns>         int GetUserId();          void SetUserId(int userId);     }      [ProxyHandle(typeof(ProxyHandleTest))]     public class TestService : ITestService, IScopedDependency     {         public int GetUserId()         {             Console.WriteLine($"执行TestService=>GetUserId()");             return 10;         }          public void SetUserId(int userId)         {             Console.WriteLine($"执行TestService=>SetUserId({userId})");             throw new Exception("执行TestService=>SetUserId测试异常");         }     }

最后只需要注入ProxyFactory

    public class TestController : AbpController     {         private readonly ProxyFactory _proxyFactory;         public TestController(ProxyFactory proxyFactory)         {             _proxyFactory = proxyFactory;         }          // GET: api/<TestController>         [HttpGet]         public IEnumerable<string> Get()         {             // 从工厂获取代理类             var testService = _proxyFactory.Create<ITestService>();             testService.GetUserId();             return new string[] { "value1", "value2" };         }