实现一个基于动态代理的 AOP

Intro

上次看基于动态代理的 AOP 框架实现,立了一个 Flag, 自己写一个简单的 AOP 实现示例,今天过来填坑了

目前的实现是基于 Emit 来做的,后面有时间再写一个基于 Roslyn 来实现的示例

效果演示

演示代码:

切面逻辑定义:

public class TryInvokeAspect : AbstractAspect
{
public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
{
Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
try
{
next();
}
catch (Exception e)
{
Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
Console.WriteLine(e);
}
Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
}
} public class TryInvoke1Aspect : AbstractAspect
{
public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
{
Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
try
{
next();
}
catch (Exception e)
{
Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
Console.WriteLine(e);
}
Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
}
} public class TryInvoke2Aspect : AbstractAspect
{
public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
{
Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
try
{
next();
}
catch (Exception e)
{
Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
Console.WriteLine(e);
}
Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
}
}

测试服务定义

// 测试接口定义
public interface ITestService
{
[TryInvokeAspect]
void Test(); [TryInvokeAspect]
[TryInvoke1Aspect]
[TryInvoke2Aspect]
void Test1(int a, string b); [TryInvokeAspect]
string Test2(); [TryInvokeAspect]
int Test3();
}
// 测试接口实例定义
public class TestService : ITestService
{
[TryInvokeAspect]
public virtual string TestProp { get; set; } public void Test()
{
Console.WriteLine("test invoked");
} public virtual void Test1(int a, string b)
{
Console.WriteLine($"a:{a}, b:{b}");
} [TryInvoke1Aspect]
public virtual string Test2()
{
return "Hello";
} [TryInvokeAspect]
public virtual int Test3()
{
return 1;
}
}

测试代码:

//var testService = ProxyGenerator.Instance.CreateInterfaceProxy<ITestService>();
var testService = ProxyGenerator.Instance.CreateInterfaceProxy<ITestService, TestService>();
// var testService = ProxyGenerator.Instance.CreateClassProxy<TestService>();
// testService.TestProp = "12133";
testService.Test();
Console.WriteLine();
testService.Test1(1, "str"); var a = testService.Test2(); var b = testService.Test3();
Console.WriteLine($"a:{a}, b:{b}");
Console.ReadLine();

输出效果:

整体结构

ProxyGenerator

ProxyGenerator 代理生成器,用来创建代理对象

public class ProxyGenerator
{
public static readonly ProxyGenerator Instance = new ProxyGenerator(); public object CreateInterfaceProxy(Type interfaceType)
{
var type = ProxyUtil.CreateInterfaceProxy(interfaceType);
return Activator.CreateInstance(type);
} public object CreateInterfaceProxy(Type interfaceType, Type implementationType)
{
var type = ProxyUtil.CreateInterfaceProxy(interfaceType, implementationType);
return Activator.CreateInstance(type);
} public object CreateClassProxy(Type classType, params Type[] interfaceTypes)
{
var type = ProxyUtil.CreateClassProxy(classType, interfaceTypes);
return Activator.CreateInstance(type);
} public object CreateClassProxy(Type classType, Type implementationType, params Type[] interfaceTypes)
{
var type = ProxyUtil.CreateClassProxy(implementationType, interfaceTypes);
return Activator.CreateInstance(type);
}
}

为了更方便的使用泛型,定义了几个扩展方法:

public static class Extensions
{
public static TInterface CreateInterfaceProxy<TInterface>(this ProxyGenerator proxyGenerator) =>
(TInterface)proxyGenerator.CreateInterfaceProxy(typeof(TInterface)); public static TInterface CreateInterfaceProxy<TInterface, TImplement>(this ProxyGenerator proxyGenerator) where TImplement : TInterface =>
(TInterface)proxyGenerator.CreateInterfaceProxy(typeof(TInterface), typeof(TImplement)); public static TClass CreateClassProxy<TClass>(this ProxyGenerator proxyGenerator) where TClass : class =>
(TClass)proxyGenerator.CreateClassProxy(typeof(TClass)); public static TClass CreateClassProxy<TClass, TImplement>(this ProxyGenerator proxyGenerator) where TImplement : TClass =>
(TClass)proxyGenerator.CreateClassProxy(typeof(TClass), typeof(TImplement));
}

AbstractAspect

AbstractAspect 切面抽象类,继承了 Attribute,可以继承它来实现自己的切面逻辑

public abstract class AbstractAspect : Attribute
{
public abstract void Invoke(MethodInvocationContext methodInvocationContext, Action next);
}

MethodInvocationContext

MethodInvocationContext 方法执行上下文,包含了执行方法时的原始方法信息以及代理方法信息,方法参数,方法返回值

public class MethodInvocationContext
{
public MethodInfo ProxyMethod { get; } public MethodInfo MethodBase { get; } public object ProxyTarget { get; } public object Target { get; } public object[] Parameters { get; } public object ReturnValue { get; set; } public MethodInvocationContext(MethodInfo method, MethodInfo methodBase, object proxyTarget, object target, object[] parameters)
{
ProxyMethod = method;
MethodBase = methodBase;
ProxyTarget = proxyTarget;
Target = target;
Parameters = parameters;
}
}

代理方法逻辑

生成代理的方法在上一节已经介绍,主要就是通过 Emit 生成代理类,要写一些 Emit 代码, Emit 不在今天的讨论范围内,这里不多介绍,生成代理方法的时候,会检查方法上的 Attribute ,如果是切面逻辑就注册切面逻辑,最后像 asp.net core 中间件一样组装在一起拼成一个委托。

核心代码如下:

// var invocation = new MethodInvocationContext(method, methodBase, this, parameters);
var localAspectInvocation = il.DeclareLocal(typeof(MethodInvocationContext));
il.Emit(OpCodes.Ldloc, localCurrentMethod);
il.Emit(OpCodes.Ldloc, localMethodBase);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldloc, localTarget);
il.Emit(OpCodes.Ldloc, localParameters);
// 创建一个 MethodInvocationContext 实例
il.New(typeof(MethodInvocationContext).GetConstructors()[0]);
il.Emit(OpCodes.Stloc, localAspectInvocation); // AspectDelegate.InvokeAspectDelegate(invocation);
il.Emit(OpCodes.Ldloc, localAspectInvocation);
var invokeAspectDelegateMethod =
typeof(AspectDelegate).GetMethod(nameof(AspectDelegate.InvokeAspectDelegate));
// 执行方法以及注册的切面逻辑
il.Call(invokeAspectDelegateMethod);
il.Emit(OpCodes.Nop); if (method.ReturnType != typeof(void))
{
// 获取方法返回值
il.Emit(OpCodes.Ldloc, localAspectInvocation);
var getMethod = typeof(MethodInvocationContext).GetProperty("ReturnValue").GetGetMethod();
il.EmitCall(OpCodes.Callvirt, getMethod, Type.EmptyTypes); if (method.ReturnType.IsValueType)
{
// 如果是值类型,做一下类型转换
il.EmitCastToType(typeof(object), method.ReturnType);
} il.Emit(OpCodes.Stloc, localReturnValue);
il.Emit(OpCodes.Ldloc, localReturnValue);
} il.Emit(OpCodes.Ret);

注册并执行切面逻辑代码实现:

// 缓存方法体执行的委托,包含切面逻辑的执行和方法的调用
private static readonly ConcurrentDictionary<string, Action<MethodInvocationContext>> _aspectDelegates = new ConcurrentDictionary<string, Action<MethodInvocationContext>>(); public static void InvokeAspectDelegate(MethodInvocationContext context)
{
var action = _aspectDelegates.GetOrAdd($"{context.ProxyMethod.DeclaringType}.{context.ProxyMethod}", m =>
{
// 获取切面逻辑,这里根据切面类型做了一个去重
var aspects = new List<AbstractAspect>(8);
if (context.MethodBase != null)
{
// 获取类方法上的切面逻辑
foreach (var aspect in context.MethodBase.GetCustomAttributes<AbstractAspect>())
{
if (!aspects.Exists(x => x.GetType() == aspect.GetType()))
{
aspects.Add(aspect);
}
}
}
// 获取接口方法上的切面
var methodParameterTypes = context.ProxyMethod.GetParameters().Select(p => p.GetType()).ToArray();
foreach (var implementedInterface in context.ProxyTarget.GetType().GetImplementedInterfaces())
{
var method = implementedInterface.GetMethod(context.ProxyMethod.Name, methodParameterTypes);
if (null != method)
{
foreach (var aspect in method.GetCustomAttributes<AbstractAspect>())
{
if (!aspects.Exists(x => x.GetType() == aspect.GetType()))
{
aspects.Add(aspect);
}
}
}
} // 构建切面逻辑执行管道,类似于 asp.net core 里的请求管道, 以原始方法调用作为中间件的最后一步
var builder = PipelineBuilder.Create<MethodInvocationContext>(x => x.Invoke());
foreach (var aspect in aspects)
{
// 注册切面逻辑
builder.Use(aspect.Invoke);
}
// 构建方法执行委托
return builder.Build();
});
// 执行委托
action.Invoke(context); // 检查返回值,防止切面逻辑管道的中断执行导致值类型返回值没有赋值
if (context.ProxyMethod.ReturnType != typeof(void))
{
if (context.ReturnValue == null && context.ProxyMethod.ReturnType.IsValueType)
{
// 为值类型返回值设置默认值作为返回值
context.ReturnValue = Activator.CreateInstance(context.ProxyMethod.ReturnType);
}
}
}

More

以上基本可以实现一个 AOP 功能,但是从扩展性以及功能上来说都还比较欠缺,基于 Attribute 的方式固然可以实现功能,但是太不灵活,如果我要在一个无法修改的接口上的某一个方法做一个切面逻辑,显然只使用 Attribute 是做不到的,还是 Fluent-API 的方式比较灵活。

想做一层 AOP 的抽象,切面逻辑通过 Fluent-API 的方式来注册,大概的 API 可能是这样的:

var settings = FluentAspects.For<ITestService>();
setting.PropertySetter(x=>x.TestProp)
.InterceptWith<TryInterceptor>()
.InterceptWith<TryInterceptor1>();
setting.Method(x=> x.Test2())
.InterceptWith<TryInterceptor>()
.InterceptWith<TryInterceptor1>();

然后基于 AspectCoreCastle.Core 来实现具体的 AOP 功能,暂时先想一下,争取尽快的发布一个基本可用的版本,然后之前基于 EF Core 的自动审计也可以基于 AOP 来实现了,这样就不需要显示继承 AuditDbContext 了~

文章所有源码可以在 Github 上获取到,Github 地址: https://github.com/WeihanLi/SamplesInPractice/tree/master/AopSample

Reference

实现一个简单的基于动态代理的 AOP的更多相关文章

  1. 动态代理到基于动态代理的AOP

    动态代理,是java支持的一种程序设计方法. 动态代理实现中有两个重要的接口和类,分别是InvocationHandler(interface),Proxy(class). 要实现动态代理,必须要定义 ...

  2. .NET 下基于动态代理的 AOP 框架实现揭秘

    .NET 下基于动态代理的 AOP 框架实现揭秘 Intro 之前基于 Roslyn 实现了一个简单的条件解析引擎,想了解的可以看这篇文章 https://www.cnblogs.com/weihan ...

  3. 设计模式 - 动态代理原理及模仿JDK Proxy 写一个属于自己的动态代理

    本篇文章代码内容较多,讲的可能会有些粗糙,大家可以选择性阅读. 本篇文章的目的是简单的分析动态代理的原理及模仿JDK Proxy手写一个动态代理以及对几种代理做一个总结. 对于代理模式的介绍和讲解,网 ...

  4. 并发编程概述 委托(delegate) 事件(event) .net core 2.0 event bus 一个简单的基于内存事件总线实现 .net core 基于NPOI 的excel导出类,支持自定义导出哪些字段 基于Ace Admin 的菜单栏实现 第五节:SignalR大杂烩(与MVC融合、全局的几个配置、跨域的应用、C/S程序充当Client和Server)

    并发编程概述   前言 说实话,在我软件开发的头两年几乎不考虑并发编程,请求与响应把业务逻辑尽快完成一个星期的任务能两天完成绝不拖三天(剩下时间各种浪),根本不会考虑性能问题(能接受范围内).但随着工 ...

  5. mybatis源码学习:基于动态代理实现查询全过程

    前文传送门: mybatis源码学习:从SqlSessionFactory到代理对象的生成 mybatis源码学习:一级缓存和二级缓存分析 下面这条语句,将会调用代理对象的方法,并执行查询过程,我们一 ...

  6. struts1:(Struts重构)构建一个简单的基于MVC模式的JavaWeb

    在构建一个简单的基于MVC模式的JavaWeb 中,我们使用了JSP+Servlet+JavaBean构建了一个基于MVC模式的简单登录系统,但在其小结中已经指出,这种模式下的Controller 和 ...

  7. 一个简单的基于 DirectShow 的播放器 2(对话框类)

    上篇文章分析了一个封装DirectShow各种接口的封装类(CDXGraph):一个简单的基于 DirectShow 的播放器  1(封装类) 本文继续上篇文章,分析一下调用这个封装类(CDXGrap ...

  8. 一个简单的基于 DirectShow 的播放器 1(封装类)

    DirectShow最主要的功能就是播放视频,在这里介绍一个简单的基于DirectShow的播放器的例子,是用MFC做的,今后有机会可以基于该播放器开发更复杂的播放器软件. 注:该例子取自于<D ...

  9. 构建一个简单的基于MVC模式的JavaWeb

    零晨三点半了,刚刚几个兄弟一起出去吼歌,才回来,这应该是我大学第二次去K歌,第一次是大一吧,之后每次兄弟喊我,我都不想去,因为我还是很害怕去KTV,或许是因为那里是我伤心的地方,也或许是因为我在那里失 ...

随机推荐

  1. Eclipse快捷键(转)

    Ctrl+1 快速修复(最经典的快捷键,就不用多说了)Ctrl+D: 删除当前行 Ctrl+Alt+↓ 复制当前行到下一行(复制增加)Ctrl+Alt+↑ 复制当前行到上一行(复制增加)Alt+↓ 当 ...

  2. hibernate实现有两种配置,xml配置与注释配置。

    (1):xml配置:hibernate.cfg.xml (放到src目录下)和实体配置类:xxx.hbm.xml(与实体为同一目录中) <?xml version='1.0' encoding= ...

  3. Codeforce - Runtime Error

    Bahosain was trying to solve this simple problem, but he got a Runtime Error on one of the test case ...

  4. 解密TDE加密数据库

    1 找到加密的数据库,new query 2 执行sql 语句:ALTER DATABASE  database_name SET ENCRYPTION OFF; DROP DATABASE ENCR ...

  5. Android_declare-styleable_自己定义控件的属性

    1.简单实例 (1).在res/values文件下定义一个attrs.xml文件 <? xml version="1.0" encoding="utf-8" ...

  6. openstack添加数据库

    输入:neutron-db-manage revision -m "表的名称"        neutron-db-manage upgrade head 如果遇到版本名找不到的情 ...

  7. 《项目架构那点儿事》——快速构建Junit用例

    [前 言]按照惯例,在实际项目中我往往会对自己编写的程序进行测试,当测试通过后才能将其用于实战中,当然,编写单元测试是不可避免的,可以直接清晰的检验出 我们程序的可靠性.可只执行性,从中发现问题从而得 ...

  8. 那些年我们写js烦的不疼不痒的错误

    1.Js 字符变量不加双/单引号. 列如:var strJsonInfo = '@Html.Raw(ViewBag.JsonInfo)'; 2.js 对象初始化器,最后一个属性值加逗号. 例如:var ...

  9. SaltStack配置管理和YAML

    配置管理和YAML 配置管理 所谓的配置管理,也称为状态管理,就是可以通过编写文件,文件的内容为安装什么功能.开启什么服务,执行什么任务等信息,然后通过salt的配置管理,指定minion来执行这些操 ...

  10. spark生成大宽表的parquet性能优化

    1.  背景介绍 将一份数据量很大的用户属性文件解析成结构化的数据供查询框架查询剖析,其中用户属性包含用户标识,平台类型,性别,年龄,学历,兴趣爱好,购物倾向等等,大概共有七百个左右的标签属性.为了查 ...