使用dynamic和MEF实现轻量级的AOP组件

Posted 2021-02-28 anyihen

转摘 https://www.cnblogs.com/niceWk/archive/2010/07/22/1783068.html

水到渠成

在上一篇的《偷梁换柱》中，介绍了WeavableObject的基本实现，本篇将继续进一步探讨它的更多细节。

首先我们来看一下方法拦截点（AOP术语称为joinpoint 加入点）的位置，通常的AOP对方法的拦截有3种，一种是Before method call, 它设置在进入原方法体之前，一种是After method call，它设置在方法返回之前，还有一种就是Around，它的行为很霸道，就是不执行原方法。后来基于不同的语言特性，有些平台开始出现Before return、 After return、Before throw exception等等，通过仔细的衡量，笔者决定在一个方法中设置如下拦截点，即能保证满足大部分功能需要，又能保证结构上的简单：

 

public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
{
    result = null;
 
    var mi = typeof(T).GetMethods()
        .FirstOrDefault(m => m.Name == binder.Name

                                    && binder.ReturnType.IsAssignableFrom(m.ReturnType)

                                    && IsMatchParameters(m.GetParameters(), args));
 
    if (mi != null)
    {
        WeavingContext context = new WeavingContext(source, binder, args);
 
        try
        {
           // Before method call 拦截点
 
           //Around method call 拦截点

 

           //调用原方法    
           context.ReturnValue = mi.Invoke(source, args);
        }
        catch (Exception ex)
        { 

           //异常处理拦截点

            ProcessException(context, ex);
        }
        finally
        {
            // After method call 拦截点
            result = context.ReturnValue;
        }
 
        return true;
    }
    else
    {
        return false;
    }
}

对象属性get/set的拦截类似，大家自己可以看代码，这里从略。

解决了拦截点的定义，下一步就是如何织入拦截器方法（AOP术语叫做Advice)。初看貌似可以使用事件，也就是说在不同的拦截点触发相应的事件以此触发预先注册的拦截类的事件处理器，但使用事件有一个问题无法解决，那就是如果有多个事件处理器，我们很难保证事件处理器的执行次序。为此，特意设计了一个对象链类AspectChain（从LinkedList<T>派生），为什么不是List<T>? 主要的原因是我们需要从两头沿着节点来调用链中的对象，基本的调用原则是：
Before method call : 从链头到链尾；

Around method call: 从链头到链尾；

Exception method call：从链头到链尾；

After method call: 从链尾到链头。

AspectChain采用责任链设计模式，其中有两个方法值得注意，第一个方法是HasAroundMethod，如果链中只要任何一个对象携带有对AroundMethodCall的方法，该方法返回true，否则返回false。因为Around注入的方法和被注入的原方法二者是相互排斥的，它们之中只能有一个被执行，如果有Around方法的话，那么Around方法就要替代原方法。第二个方法是ExceptionMethodCall，我们这样来处理异常，也就是如果链中有一个对象的异常处理方法返回true，就表示异常事件不再继续传递，异常处理完毕，否则一直传递到最后一个节点，如果所有的节点都返回false，那么异常将被抛出到外部对象去处理。

现在我们对如何设计Aspect的结构的思路逐渐明朗化了，那就是每个Aspect都必须携带可以被拦截点回调的方法，实际的回调是发生在AspectChain链中的。

下面就是我们设计的IAspect接口：

   public interface IAspect
    {
        void OnBeforeMethodCall(WeavingContext context);
        bool HasArroundMethod(WeavingContext context);
        void OnAroundMethodCall(WeavingContext context);
        void OnAfterMethodCall(WeavingContext context);
        bool OnExceptionMethodCall(WeavingContext context, Exception ex);
        void OnPropertyChanging(WeavingContext context);
        void OnPropertyChanged(WeavingContext context);
        void OnBeforeGetValue(WeavingContext context);
        void OnAfterGetValue(WeavingContext context);
        List<string> Targets { get; }
        bool IsMatch(string target);
        int Sequence { get; set; }
        bool Enabled { get; set; }
    }

并不像是每个Aspect对象都要实现所有接口中的方法，所以我们就很有必要为这些对象设计一个共同的抽象基类AspectBase，这样做的好处能够从DynamicAspect的设计中看出来。

接口还包含的几个属性和一个IsMatch的方法。在上一篇要处理的问题列表中的问题6， 我们解决了前一半，那么Aspect如何匹配目标对象的问题，我们需要一种方法来辨别目标对象，笔者采用正则表达式将目标对象的类型名称和正则表达式的模板进行匹配，一个Aspect可以匹配多个目标对象，也就是我们可以在Aspect对象中指定多个模板，模板保存在Targets属性中，这样我们只要遍历这个链表就可以获取匹配的信息。IsMatch的实现在AspectBase中实现，注意IsMatch在基类被定义为虚拟的，也就是说它可以被派生类重载，允许派生类实现它们自己的匹配规则。Sequence属性用来告知对象被插入到AspectChain的次序，Enabled则作为一个开关，如果该值被设置为false, 那么这个Aspect将不再参与编织。默认值是true。下面是IsMatch接口方法在AspectBase中的实现：

       public virtual bool IsMatch(string target)
        {
            if (Targets.Count == 0)
                return true;
 
            return Targets.Any(t => Regex.IsMatch(target, t));
        }

如果没有模板存在在Target表中，则认为匹配所有的目标对象类型。为了方便正则表达式模板的编写，特意设计一个助手类TargetPattern，但这个类并不一定需要，它的一个主要目的就是减少一些硬编码。比如你可以用TargetPattern.All 来代替 @“w+?"。我们解决了目标对象的匹配问题，采用同样的方法，我们可以在重载的IAspect实现方法中让具体的Aspect类来决定如何匹配目标方法。大家可以下载包里面的例子看到，在例子中使用的是硬编码，但是具体Aspect类的实现不是DynamicAspect的任务（除了一些广泛通用的Aspect之外，DynamicAspect的未来任务就是内建对通用Aspect的实现）。每个Aspect的开发者都可以自己实现对方法的匹配算法，问题是每个具体的Aspect是如何知道调用方的信息呢？答案就在作为方法参数传递的WeavingContext对象，那么就让我们看一下这个对象都有什么成员来提供必要的信息：

    public class WeavingContext
    {        
        private DynamicMetaObjectBinder binder;
 
        public WeavingContext(object target, DynamicMetaObjectBinder binder, object[] argumentValues=null, object returnValue=null)
        {
            this.Target = target;
            this.binder = binder;
            this.ArgumentValues = argumentValues;
            this.ReturnValue = returnValue;
        }
 
        public object[] ArgumentValues { get; set; }
 
        public object ReturnValue { get; set; }
 
        public object Target { get; private set; }
 
 
        public InvokeMemberBinder InvokeMemberBinder
        {
            get  { return binder as InvokeMemberBinder; }
        }
 
        public InvokeBinder InvokeBinder
        {
            get { return binder as InvokeBinder; }
        }
 
        public GetIndexBinder GetIndexBinder
        {
            get { return binder as GetIndexBinder; }
        }
 

       public SetIndexBinder SetIndexBinder
        {
            get { return binder as SetIndexBinder; }
        }

        public GetMemberBinder GetMemberBinder
        {
            get { return binder as GetMemberBinder; }
        }
        public SetMemberBinder SetMemberBinder
        {
            get { return binder as SetMemberBinder; }
        }

WeavingContext类包含四个重要的信息，即使用构造器参数传入对象的四个对象：

Target是目标对象实例，该对象可作为Aspect计算匹配的信息来源；Binder对象，Binder对象含有调用方绑定到动态方法上的元数据信息，如被调用的方法名称，参数个数等，不同的动态方法有不同的Binder类型，为了避免在代码中写很多if elseif 这样的语句，我们将不同类型的Binder做成属性，以方便在Aspect的方法中调用。ArgumentValues顾名思义就是参数值集合，同样ReturnValue则用于保存方法的返回值（如果有的话）。

我想我们已经解决了要解决的7个问题中的6个，剩下问题7将在下一篇当我们揭示实现DynamicAspect的另一半MEF (Managed Extensibility Framework)时予以阐述。

（未完待续）