Autofac实现拦截器和切面编程

Autofac.Annotation框架是我用.netcore写的一个注解式DI框架，基于Autofac参考 Spring注解方式所有容器的注册和装配,切面,拦截器等都是依赖标签来完成。

开源地址：https://github.com/yuzd/Autofac.Annotation

本期讲的是最新重构的功能，这个功能也是赋予了这个框架的无限可能，也是我觉得设计的比较好的地方， 今天来说说我是怎么设计的

切面和拦截器介绍

拦截器是什么？

可以帮助我们方便在执行目标方法的

• 前(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; }
    }

image

这一组注解是暴露给外部使用，来搜集哪些类的哪些方法需要增强

接下来需要去针对性去实现每一种增强器要做的事情

定义一个增强器接口IAdvice

    internal interface IAdvice
    {
        /// <summary>
        ///  拦截器方法
        /// </summary>
        /// <param name="aspectContext">执行上下文</param>
        /// <param name="next">下一个增强器</param>
        /// <returns></returns>
        Task OnInvocation(AspectContext aspectContext, AspectDelegate next);
    }

image

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. 组装增强器们成为一个调用链

image

每一个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管道（一个委托）

image

更多关于这种设计模式更多信息请参考我另外一篇文章: 中间件(middlewware)模式

按照我们的需求构建的完整执行示意图如下：

单个拦截器或者切面

image

多个拦截器或者切面

image

生成代理类代理目标方法去执行上面构造的拦截器链

这一步就简单了，如果检测到目标有打拦截器注解，则会给这个类动态创建一个proxy类，

生成代理类用的是castle.core的dynamic组件

默认的是Class+virtual的方式对目标方法进行拦截

image

注意:考虑到性能，在项目启动的时候把构建好进行缓存，然后再拦截器里面使用

好了，拦截器和切面介绍到此，更多教程请参考项目wiki(教程很详细哦，别忘记给个star)

https://github.com/yuzd/Autofac.Annotation/wiki

关注公众号一起学习