Autofac实现拦截器和切面编程
Posted dotNET跨平台
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Autofac实现拦截器和切面编程相关的知识，希望对你有一定的参考价值。
Autofac.Annotation框架是我用.netcore写的一个注解式DI框架，基于Autofac参考 Spring注解方式所有容器的注册和装配,切面,拦截器等都是依赖标签来完成。
开源地址：https://github.com/yuzd/Autofac.Annotation
上期说了Autofac实现有条件的DI
本期讲的是最新重构的功能，这个功能也是赋予了这个框架的无限可能，也是我觉得设计的比较好的地方， 今天来说说我是怎么设计的。本篇文章我写的时候想了很久如何脱离代码去讲的很清楚，但是发现很难，因为设计的巧妙之处还是在于代码，得细品。至少我觉得比Spring的拦截器链用的代码少而精巧,而且更容器理解（手动狗头）
切面和拦截器介绍
拦截器是什么？
可以帮助我们方便在执行目标方法的
前(Before)
后(After)
返回值时(AfterReturn)
抛错误时(AfterThrowing)
环绕(Around)
简单示例：
//自己实现一个拦截器
public class TestHelloBefore:AspectBefore
public override Task Before(AspectContext aspectContext)
Console.WriteLine("TestHelloBefore");
return Task.CompletedTask;
[Component]
public class TestHello
[TestHelloBefore]//打上拦截器
public virtual void Say()
Console.WriteLine("Say");
先执行 TestHelloBefor的Before方法再执行你的Say方法
更多使用示例请查看 Aspect拦截器
切面是什么？
定义一个切面(根据筛选器去实现满足条件的多个类的多个方法的“拦截器”
简单示例：
[Component]
public class ProductController
public virtual string GetProduct(string productId)
return "GetProduct:" + productId;
public virtual string UpdateProduct(string productId)
return "UpdateProduct:" + productId;
[Component]
public class UserController
public virtual string GetUser(string userId)
return "GetUser:" + userId;
public virtual string DeleteUser(string userId)
return "DeleteUser:" + userId;
// *Controller 代表匹配 只要是Controller结尾的类都能匹配
// Get* 代表上面匹配成功的类下 所以是Get打头的方法都能匹配
[Pointcut(Class = "*Controller",Method = "Get*")]
public class LoggerPointCut
[Around]
public async Task Around(AspectContext context,AspectDelegate next)
Console.WriteLine("PointcutTest1.Around-start");
await next(context);
Console.WriteLine("PointcutTest1.Around-end");
[Before]
public void Before()
Console.WriteLine("PointcutTest1.Before");
[After]
public void After()
Console.WriteLine("PointcutTest1.After");
[AfterReturn(Returing = "value1")]
public void AfterReturn(object value1)
Console.WriteLine("PointcutTest1.AfterReturn");
[AfterThrows(Throwing = "ex1")]
public void Throwing(Exception ex1)
Console.WriteLine("PointcutTest1.Throwing");
更多示例请查看 Pointcut切面编程
如何实现的
分为3步
1.搜集拦截算子(比如Before/After等这个我们叫算子)
2.构造拦截器链(按照上面图的方式把算子链接起来)
3.生成代理类代理目标方法去执行上面构造的拦截器链
1.搜集拦截算子
因为拦截器的使用是约定了要继承 AspectInvokeAttribute
/// <summary>
/// AOP拦截器 默认包含继承关系
/// </summary>
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
public class AspectInvokeAttribute : Attribute
/// <summary>
/// 排序 值越低，优先级越高
/// </summary>
public int OrderIndex get; set;
/// <summary>
/// 分组名称
/// </summary>
public string GroupName get; set;
这一组注解是暴露给外部使用，来搜集哪些类的哪些方法需要增强
接下来需要去针对性去实现每一种增强器要做的事情
定义一个增强器接口IAdvice
internal interface IAdvice
/// <summary>
/// 拦截器方法
/// </summary>
/// <param name="aspectContext">执行上下文</param>
/// <param name="next">下一个增强器</param>
/// <returns></returns>
Task OnInvocation(AspectContext aspectContext, AspectDelegate next);
Before增强器
/// <summary>
/// 前置增强器
/// </summary>
internal class AspectBeforeInterceptor : IAdvice
private readonly AspectBefore _beforeAttribute;
public AspectBeforeInterceptor(AspectBefore beforeAttribute)
_beforeAttribute = beforeAttribute;
public async Task OnInvocation(AspectContext aspectContext, AspectDelegate next)
//先执行Before逻辑
await this._beforeAttribute.Before(aspectContext);
//在走下一个增强器
await next.Invoke(aspectContext);
After增强器
/// <summary>
/// 后置增强器
/// </summary>
internal class AspectAfterInterceptor : IAdvice
private readonly AspectAfter _afterAttribute;
private readonly bool _isAfterAround;
public AspectAfterInterceptor(AspectAfter afterAttribute, bool isAfterAround = false)
_afterAttribute = afterAttribute;
_isAfterAround = isAfterAround;
public async Task OnInvocation(AspectContext aspectContext, AspectDelegate next)
try
if (!_isAfterAround) await next.Invoke(aspectContext);
finally
//不管成功还是失败都会执行的
await this._afterAttribute.After(aspectContext, aspectContext.Exception ?? aspectContext.ReturnValue);
环绕增强器
/// <summary>
/// 环绕返回拦截处理器
/// </summary>
internal class AspectAroundInterceptor : IAdvice
private readonly AspectArround _aroundAttribute;
private readonly AspectAfterInterceptor _aspectAfter;
private readonly AspectAfterThrowsInterceptor _aspectThrows;
public AspectAroundInterceptor(AspectArround aroundAttribute, AspectAfter aspectAfter, AspectAfterThrows chainAspectAfterThrows)
_aroundAttribute = aroundAttribute;
if (aspectAfter != null)
_aspectAfter = new AspectAfterInterceptor(aspectAfter, true);
if (chainAspectAfterThrows != null)
_aspectThrows = new AspectAfterThrowsInterceptor(chainAspectAfterThrows, true);
public async Task OnInvocation(AspectContext aspectContext, AspectDelegate next)
Exception exception = null;
try
if (_aroundAttribute != null)
await _aroundAttribute.OnInvocation(aspectContext, next);
return;
catch (Exception ex)
exception = ex;
finally
if (exception == null && _aspectAfter != null) await _aspectAfter.OnInvocation(aspectContext, next);
try
if (exception != null && _aspectAfter != null)
await _aspectAfter.OnInvocation(aspectContext, next);
if (exception != null && _aspectThrows != null)
await _aspectThrows.OnInvocation(aspectContext, next);
finally
if (exception != null) throw exception;
返回值增强器
/// <summary>
/// 后置返值增强器
/// </summary>
internal class AspectAfterReturnInterceptor : IAdvice
private readonly AspectAfterReturn _afterAttribute;
public AspectAfterReturnInterceptor(AspectAfterReturn afterAttribute)
_afterAttribute = afterAttribute;
public async Task OnInvocation(AspectContext aspectContext, AspectDelegate next)
await next.Invoke(aspectContext);
//执行异常了不执行after 去执行Throw
if (aspectContext.Exception != null)
return;
if (_afterAttribute != null)
await this._afterAttribute.AfterReturn(aspectContext, aspectContext.ReturnValue);
异常返回增强器
/// <summary>
/// 异常返回增强器
/// </summary>
internal class AspectAfterThrowsInterceptor : IAdvice
private readonly AspectAfterThrows _aspectThrowing;
private readonly bool _isFromAround;
public AspectAfterThrowsInterceptor(AspectAfterThrows throwAttribute, bool isFromAround = false)
_aspectThrowing = throwAttribute;
_isFromAround = isFromAround;
public async Task OnInvocation(AspectContext aspectContext, AspectDelegate next)
try
if (!_isFromAround) await next.Invoke(aspectContext);
finally
//只有目标方法出现异常才会走 增强的方法出异常不要走
if (aspectContext.Exception != null)
Exception ex = aspectContext.Exception;
if (aspectContext.Exception is TargetInvocationException targetInvocationException)
ex = targetInvocationException.InnerException;
if (ex == null)
ex = aspectContext.Exception;
var currentExType = ex.GetType();
if (_aspectThrowing.ExceptionType == null || _aspectThrowing.ExceptionType == currentExType)
await _aspectThrowing.AfterThrows(aspectContext, aspectContext.Exception);
2. 组装增强器们成为一个调用链
每一个node的有三个信息，如下
/// <summary>
/// 拦截node组装
/// </summary>
internal class AspectMiddlewareComponentNode
/// <summary>
/// 下一个
/// </summary>
public AspectDelegate Next;
/// <summary>
/// 执行器
/// </summary>
public AspectDelegate Process;
/// <summary>
/// 组件
/// </summary>
public Func<AspectDelegate, AspectDelegate> Component;
采用LinkedList来构建我们的拉链式调用， 我们把上面的每个增强器作为一个个middeware，添加进来。
internal class AspectMiddlewareBuilder
private readonly LinkedList<AspectMiddlewareComponentNode> Components = new LinkedList<AspectMiddlewareComponentNode>();
/// <summary>
/// 新增拦截器链
/// </summary>
/// <param name="component"></param>
public void Use(Func<AspectDelegate, AspectDelegate> component)
var node = new AspectMiddlewareComponentNode
Component = component
;
Components.AddLast(node);
/// <summary>
/// 构建拦截器链
/// </summary>
/// <returns></returns>
public AspectDelegate Build()
var node = Components.Last;
while (node != null)
node.Value.Next = GetNextFunc(node);
node.Value.Process = node.Value.Component(node.Value.Next);
node = node.Previous;
return Components.First.Value.Process;
/// <summary>
/// 获取下一个
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private AspectDelegate GetNextFunc(LinkedListNode<AspectMiddlewareComponentNode> node)
return node.Next == null ? ctx => Task.CompletedTask : node.Next.Value.Process;
然后build方法会构建成一个一层嵌套一层的pipeline管道（一个委托）
更多关于这种设计模式更多信息请参考我另外一篇文章:中间件(middlewware)模式
构建的顺序: After, Around,Before,最后才是实际的方法
这里尤其要注意需要将AfterReturn 和 AfterThrowing在Around增强器里面调用，这里要细品！
按照我们的需求构建的完整执行示意图如下：
单个拦截器或者切面
多个拦截器或者切面
3.生成代理类代理目标方法去执行上面构造的拦截器链
这一步就简单了，如果检测到目标有打拦截器注解，则会给这个类动态创建一个proxy类，
生成代理类用的是castle.core的dynamic组件
默认的是Class+virtual的方式对目标方法进行拦截
注意:考虑到性能，在项目启动的时候把构建好进行缓存，然后再拦截器里面使用
https://github.com/yuzd/Autofac.Annotation/wiki
我是正东,学的越多不知道也越多。热爱可低漫长岁月,这一刻我很爽!
以上是关于Autofac实现拦截器和切面编程的主要内容，如果未能解决你的问题，请参考以下文章