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

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

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

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

我们会有很多处理实现类,每个实现类都需要实现AfterActionBeforeActionTargetMethodExceptionAction

   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}");
}
}
  • 准备ITestServiceTestService
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" };
}

总结

  • DispatchProxy 实现动态代理主要是依赖Emit类库直接编写IL语言。
  • Activator 类在运行时动态构造对象。
  • AssemblyBuilder 类运行时动态一个获取和设置专用字段的属性、初始化专用字段的构造函数,可以动态执行方法并返回结果。

不管是Java还是Net实现AOP切面编程原理差不多。

浅析DispatchProxy动态代理AOP的更多相关文章

  1. 动态代理AOP实现方法过滤

    上一节实现了动态代理,接下来 有时候,我不需要在每一个方法都要记录日志,做权限验证 等等. 所有就有了这样的需求.AOP实现特定方法过滤,有选择性的来对方法实现AOP 拦截.就是本节标题所示. 举个例 ...

  2. 动态代理 aop切面实现事务管理

    1.定义接口和实现 public interface UserService { public String getName(int id); public Integer getAge(int id ...

  3. Spring-Boot的动态代理AOP原理

    前言 Spring AOP使用了动态代理技术,动态代理在业界比较流行的实现方式有,CGLIB,Javassist,ASM等等. Spring动态代理实现方式 Spring采用了JDK和CGLIB两种方 ...

  4. 5.动态代理AOP实现-DynamicProxy模式

    通过动态代理模式Interceptor实现在RegUser()方法本身业务前后加上一些自己的功能,如:PreProceed和PostProceed,即不修改UserProcessor类又能增加新功能 ...

  5. spring中使用动态代理(AOP)

    spring是整合了BGLIB和JDK两种动态代理 示例:使用CGLIB代理 public class MyCar { private String color = "blue"; ...

  6. Cglib动态代理浅析

    原文同步发表至个人博客[夜月归途] 原文链接:http://www.guitu18.com/se/java/2018-06-29/18.html 作者:夜月归途 出处:http://www.guitu ...

  7. JDK动态代理浅析

    原文同步发表至个人博客[夜月归途] 原文链接:http://www.guitu18.com/se/java/2018-06-29/17.html 作者:夜月归途 出处:http://www.guitu ...

  8. [编织消息框架][JAVA核心技术]cglib动态代理

    先在mavne项目里添加cglib库 maven仓库搜索cglib版本 maven地址:http://mvnrepository.com/ 点击最新的版本 3.2.5 复制到pom.xml  depe ...

  9. JDK动态代理深入理解分析并手写简易JDK动态代理(下)

    原文同步发表至个人博客[夜月归途] 原文链接:http://www.guitu18.com/se/java/2019-01-05/27.html 作者:夜月归途 出处:http://www.guitu ...

随机推荐

  1. 使用Socket实现HttpServer(三)

    使用Socket实现HttpServer(三) 这一章继续对我们的服务器进行优化,引入 NIO package com.fengsir.network.step4; import java.io.IO ...

  2. route -n 讲解

    我们经常会出现临时添加路由,或者是路由重启路由丢失等导致网络不通的情况,上网查发现很多介绍或者没有实验跟进导致理解的时候很费劲的情况,可能人家认为是比较简单的事情了,但是很多不尽然,老手也不一定能很快 ...

  3. linux磁盘概述

    硬盘简史 世界上第一块硬盘出生在1956年,至今已有61年半个多世纪的历史.它由IBM公司制造,世界上第一块硬盘:350RAMAC.盘片直径为24英寸,盘片数为50片,重量则是上百公斤,相当于两个冰箱 ...

  4. 5.Java程序运行机制

    一.编译型和解释型语言区别 计算机是不能理解高级语言的,更不能直接执行高级语言,它只能直接理解机器语言,所以任何的高级语言编写的程序都必须转换成计算机语言,也就是机器码.而这种转换的方式有两种: 编译 ...

  5. 面试官:RabbitMQ过期时间设置、死信队列、延时队列怎么设计?

    哈喽!大家好,我是小奇,一位不靠谱的程序员 小奇打算以轻松幽默的对话方式来分享一些技术,如果你觉得通过小奇的文章学到了东西,那就给小奇一个赞吧 文章持续更新 一.前言 RabbitMQ我们经常的使用, ...

  6. IP协议/地址(IPv4&IPv6)概要

    IP协议/地址(IPv4&IPv6)概要 IP协议 什么是IP协议 IP是Internet Protocol(网际互连协议)的缩写,是TCP/IP体系中的网络层协议. [1] 协议的特征 无连 ...

  7. ABP应用开发(Step by Step)-下篇

    测试 ProductAppService 类 启动模板附带测试基础架构,包括xUnit.Shouldly和NSubstitute库.它使用SQLite 内存数据库来模拟数据库,并为每个测试创建一个单独 ...

  8. [STL] map 映射

  9. Shell脚本实战:日志关键字监控+自动告警

    一个执着于技术的公众号 该程序使用场景说明:主要用于Linux服务器监控程序日志,如出现关键字异常则触发相应的动作或告警操作,通知到邮件联系人. 一.安装邮件服务 1.解压 tar -jxf mail ...

  10. Node.js躬行记(19)——KOA源码分析(上)

    本次分析的KOA版本是2.13.1,它非常轻量,诸如路由.模板等功能默认都不提供,需要自己引入相关的中间件. 源码的目录结构比较简单,主要分为3部分,__tests__,lib和docs,从名称中就可 ...