Castle实践9－在Castle IOC容器中使用AspectSharp(全面剖析AspectSharp Facility)

        在“Castle实践8”介绍了A#的使用方法，那么A#如何和Castle IOC容器结合起来使用呢？在Castle的官方falicicies库中，提供了AspectSharp Facility来让我们可以很简单在IOC中使用A#。我把使用方法放在最后，题目说了是要全面剖析这个facility的原理，借助这次分析让我们对Castle IOC中的Falicity编写有更深的了解。

        编写一个facility之前，最重要的就是要明确这个falicity的目的。通过“实践8”知道，要使用一个aop过的对象，需要调用engine.WrapClass或者engine.WrapInterface来对目的对象包装，那么得出这个facility的目的就是：当用户向IOC容器请求组件的时候，根据aop的配置自动包装组件再交给客户使用。

        明白了需求，那么就开始分析吧：

protected   override   void  Init()
{
     if  (FacilityConfig  ==   null )  return ;

     //  第一步
    RegisterAspectEngine();
     //  第二步
    RegisterInterceptor();

     //  第三步
    Kernel.ProxyFactory  =   new  AopProxyFactory();

     //  第四步
    _engine  =  (AspectEngine) Kernel[  typeof (AspectEngine) ];

     //  第五步：向IOC里面加入任何组件的时候，OnComponentRegistered会回调
    Kernel.ComponentRegistered  +=   new  ComponentDataDelegate(OnComponentRegistered);
}

第一步：

private   void  RegisterAspectEngine()
{
     //  获取当前facility的配置，相当于获取了a#的配置
    String contents  =  FacilityConfig.Value;

     //  创建a#的builder
    AspectEngineBuilder builder  =   new  AspectLanguageEngineBuilder(contents);

    ComponentModel model  =  
         new  ComponentModel( " aspectsharp.engine " , 
             typeof (AspectEngine),  typeof (AspectEngine));
    
     //  a#的builder作为扩张属性
    model.ExtendedProperties.Add( " builder " , builder);
     //  engine激活的时候执行AspectEngineActivator
    model.CustomComponentActivator  =   typeof (AspectEngineActivator);

     //  把a# engine作为组件加入ioc中
    Kernel.AddCustomComponent( model );
}

第二步：

private   void  RegisterInterceptor()
{
     //  讲AopInterceptor加入IOC中
    Kernel.AddComponent(  " aspectsharp.interceptor " ,  typeof (AopInterceptor) );
}

第三步：注册ioc的proxy工厂

///   <summary>
///  Specialization of  <see cref="Castle.Windsor.Proxy.DefaultProxyFactory"/>
///  that checks for aspects in the model and potential mixins.
///   </summary>
public   class  AopProxyFactory : DefaultProxyFactory
{
protected   override   void  CustomizeContext(GeneratorContext context, IKernel kernel, 
    ComponentModel model,  object [] arguments)
{
     //  获取a#的配置
    AspectDefinition aspect  =  (AspectDefinition) model.ExtendedProperties[ " aop.aspect " ];

     if  (aspect  ==   null )  return ;

     //  得到所有mixin
    MixinDefinitionCollection mixins  =  aspect.Mixins;

     foreach (MixinDefinition definition  in  mixins)
    {
        Type mixinType  =  definition.TypeReference.ResolvedType;
        
         try
        {
             //  创建一个minix对象并交给dynamicproxy，dynamicproxy产生proxy的时候会用到
            context.AddMixinInstance( Activator.CreateInstance( mixinType ) );
        }
         catch (Exception e)
        {
             throw   new  ApplicationException( " Could not instantiate mixin  "   +  mixinType.FullName, e);
        }
    }
}

protected   override   void  CustomizeProxy( object  proxy, GeneratorContext context, IKernel kernel, ComponentModel model)
{
     //  获取在上面的CustomizeContext函数中创建的mixin对象
     object [] mixins  =  context.MixinsAsArray();

     //  所有实现了IProxyAware的mixin对象，都会把实际的代理set到里面交给客户处理
     // 在“Castle实践8”中的SecurityMixin就是实现了IProxyAware的，在SecurityMixin类
     // 上下文中可以任意使用proxy，这下明白了吧。
     for ( int  i = 0 ; i  <  mixins.Length; i ++ )
    {
         object  mixin  =  mixins[i];
        
         if  (mixin  is  IProxyAware)
        {
            (mixin  as  IProxyAware).SetProxy(proxy);
        }
    }
}

第四步：激活a# engine，导致AspectEngineActivator执行

protected   override   object  InternalCreate()
{
     //  获取a#的builder
    AspectEngineBuilder builder  =  (AspectEngineBuilder) 
         base .Model.ExtendedProperties[ " builder " ];

    System.Diagnostics.Debug.Assert( builder  !=   null  );

     //  创建engine
     return  builder.Build();
}

第五步：向IOC里面加入任何组件的时候，OnComponentRegistered会回调

private   void  OnComponentRegistered(String key, IHandler handler)
{
     //  检查a#配置中是否包含组件的“切面”
     // 就是当前加入的这个组件是否需要aop（怎么说呢？？表达不太清晰，大家应该明白吧。请原谅~~）
    AspectDefinition[] aspects  =  
        _engine.AspectMatcher.Match( handler.ComponentModel.Implementation, 
        _engine.Configuration.Aspects );

     if  (aspects.Length  !=   0 )
    {
         //  如果组件需要aop，则合并配置中对此组件的切面定义
         // 并将定义加入到组件的扩张属性中
        handler.ComponentModel.ExtendedProperties[ " aop.aspect " ]  =  Union(aspects);

         //  向组件加入拦截器
         // 当向ioc请求组件对象的时候，拦截器的作用就是根据上面的定义来产生一个组件的proxy
        handler.ComponentModel.Interceptors.Add( 
             new  InterceptorReference(  typeof (AopInterceptor) ) );
    }
}

private  AspectDefinition Union(AspectDefinition[] aspects)
{
     //  这里作用是合并对组件的“切面”配置内容
     // 但作者todo了，未完成？

     if  (aspects.Length  ==   1 )
    {
         return  aspects[ 0 ];
    }

     //  TODO: Merge aspects

     return  aspects[ 0 ];
}

         这时候回头来看看，我们的目的是自动包装，上面的代码中没有调用A# engine的WrapClass和WrapInterface的，其实两个wrap做的是调用DefaultProxyFactory来产生代理的，这里给AopProxyFactory代替了。而真正请求一个组件的时候，产生代理的工作都是在AopInterceptor中处理的。

///   <summary>
///  Summary description for AopInterceptor.
///   </summary>
[Transient]
public   class  AopInterceptor : IMethodInterceptor, IOnBehalfAware
{
     private  IKernel _kernel;
     private  AspectEngine _engine;
     private  IInvocationDispatcher _dispatcher;

     public  AopInterceptor(AspectEngine engine, IKernel kernel)
    {
        _engine  =  engine;
        _kernel  =  kernel;
    }

     public   void  SetInterceptedComponentModel(ComponentModel target)
    {
         //  获取组件的aop配置
        AspectDefinition aspectDef  =  (AspectDefinition) 
            target.ExtendedProperties[ " aop.aspect " ];

        System.Diagnostics.Debug.Assert( aspectDef  !=   null  );

         //  InvocationDispatcher用于proxy的方法分派，ContainerInvocationDispatcher重写了
         // ObtainInterceptorInstance方法，唯一的作用是：尝试从IOC中获取拦截器对象
        _dispatcher  =   new  ContainerInvocationDispatcher(aspectDef, _kernel);
        _dispatcher.Init(_engine);
    }

     public   object  Intercept(IMethodInvocation invocation,  params   object [] args)
    {
         //  a#内幕：_dispatcher.Intercept会处理客户的函数调用
         // Intercept方法会从ObtainInterceptorInstance获取拦截器实例
         // （ContainerInvocationDispatcher中重写的方法起作用了）
         //  如果没有拦截器则直接Proceed，有拦截器则在拦截器进行处理
         // 这是a#拦截的一个简单过程，详细你可以参考：a#中的DefaultInvocationDispatcher源码
         return  _dispatcher.Intercept( (IInvocation) invocation, args);
    }
}

而在ContainerInvocationDispatcher重写的ObtainInterceptorInstance是这样的：

///   <summary>
///  获取拦截器对象
///   </summary>
protected   override  IMethodInterceptor ObtainInterceptorInstance(Type adviceType)
{
     if  (_kernel.HasComponent( adviceType ))
    {
         //  方式一：从IOC中获取
         // 如果我们把拦截器注册进IOC里面，这里就直接获取
         try
        {
             return  (IMethodInterceptor) _kernel[adviceType];
        }
         catch (InvalidCastException ex)
        {
             //  In this case, the specified interceptor
             //  does not implement the IMethodInterceptor from
             //  AopAlliance

            String message  =  String.Format( " The interceptor {0} does  "   +  
                 " not implement AopAlliance.Interceptor.IMethodInterceptor " , adviceType.FullName); 

             throw   new  ApplicationException(message, ex);
        }
    }

     //  方式二：从A#的DefaultInvocationDispatcher中获取
     // A#中对拦截器对象实例是有缓存处理的（一个HashTable：_type2AdviceInstance）
     return   base .ObtainInterceptorInstance(adviceType);
}

        分析结束啦～ ，最后放上使用方法，很简单的：

1）配置：

< configuration >
     < facilities >
         < facility  id ="aspectsharp" >
<![CDATA[
import AopDemo.Interceptors
import AopDemo.Mixins

aspect log for [AopDemo]
    pointcut method(*)
        advice(LoggerInterceptor)
    end
end

aspect Security for [AopDemo]
    include SecurityMixin
    pointcut method(*)
        advice(SecurityCheckInterceptor)
    end
end
]]>
         </ facility >
     </ facilities >
</ configuration >

2）初始化容器：

container  =   new  WindsorContainer( @" ../../aspectsharp.ioc.xml " );
container.AddFacility( " aspectsharp " ,  new  AspectSharpFacility()) ;
container.AddComponent( " persondao " ,  typeof (PersonDao));

3）使用组件：

PersonDao dao  =  container[ " persondao " ]  as  PersonDao;
dao.Create( " AAA " );
...

完整demo下载地址：
http://www.wjshome.com/Income/Others/Castle.AspectSharp%20Facility.Demo.rar

bye~