自行打造实现控制反转容器（IOC）与面向方面编程（AOP）的轻量级Framework（3）

MyFramework之AOP部分
原创： 牛超  TOKYO
 
旨于搭建轻量架构，为目标对象设置装备与拦截器，并利用代理模式封装对象，其中如何拦截对象的方法行为并将装备置于其中尤为关键，具体实现即拦截器类，代码如下所示：
package myFramework;
 
import java.lang.reflect.* ;
/**
 * ProxyObjectHandler : Proxy Object Handler
 * create proxy objects according to target object and it's advices
 *
 * @author Niu Chao
 * @since 2008-8-19
 * @version 0.1
 */
public class ProxyObjectHandler extends ProxyTargetHandler
{
        private IAdvice[] advices ;
        private Reflection reflect ;
       
        //construct the proxy according to proxy target and advices
        //根据目标 ?象与装备 ?建对 象
        public ProxyObjectHandler(Object objproxy , IAdvice[] aAdvs)
        {
                 super(objproxy) ;
                 reflect = Reflection.getInstance() ;
                 setAdvices(aAdvs) ;
                 sortAdvices() ;
        }
        public Object getProxyObject()
        {
                 return Proxy.newProxyInstance(
                 this.getObjTarget().getClass().getClassLoader(), this.getObjTarget()
                 .getClass().getInterfaces(), this);
        }
        //get the number of advice by sort .
        //将装备 按指定方式编 号
        private int adviceSortNumber(IAdvice adv)
        {
                 Class cls = adv.getClass() ;
                 try
                 {
                           //IBeforeAdvice
                           if ( reflect.isAssignable("myFramework.IBeforeAdvice",cls))
                           {
                                    return 0 ;
                           }//IAroundAdvice
                           else if (reflect.isAssignable("myFramework.IAroundAdvice",cls))
                           {
                                    return 1 ;
                           }//IThrowsAdvice
                           else if (reflect.isAssignable("myFramework.IThrowsAdvice",cls))
                           {
                                    return 2 ;
                           }
                           else //Class.forName("myFramework.IAfterAdvice").isAssignableFrom(adv.getClass())
                           {
                                    return 3 ;
                           }
                 }
                 catch(Exception ex)        
                 {
                           ex.printStackTrace() ;
                           System.exit(-1) ;
                           return -1 ;
                 }
        }
       
        //sort the advices
        //以编 号为 ?先级 排序装备
private void sortAdvices()
        {
                 IAdvice advref ;
                 if (advices.length < 1)
                           return ;
                 for ( int i = 0 ; i < advices.length - 1 ; i ++ )
                 {
                           for ( int j = i + 1 ; j < advices.length ; j ++)
                           {
                                    if (adviceSortNumber(advices[i]) > adviceSortNumber(advices[j]))
                                    {
                                             advref = advices[i] ;
                                             advices[i] = advices[j] ;
                                             advices[j] = advref ;
                                    }
                           }
                 }
        }
       
        //getter
        public IAdvice[] getAdvices()
        {
                 return advices ;
        }
        //setter
        public void setAdvices(IAdvice[] advs)
        {
                 advices = advs ;
        }
       
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
        {
                 // TODO: Add your code here
                 int i = 0 , j = 0 , iSortnum;
                 IAdvice advref ;
                 Reflection reflect = Reflection.getInstance() ;
                
                 //arguments of advice
                 Object[] advArgs ;
                 Object result = null;
                
                 //process advices with before function
                 //处理带 有前置切入点的装备                   
for (i = 0 ; i < advices.length ; i ++)
                 {
                           iSortnum = adviceSortNumber(advices[i]) ;
                           if ( iSortnum < 2)
                           {
                                    //record the start index of aroundadvices
                                    //记 ?AROUND装备 索引号以备 后用
                                    if (iSortnum < 1)
                                    {
                                             j = i ;
                                    }
                                    advArgs = new Object[]{this.getObjTarget() , method , args};
                                    //invoke the function called "before" of device
                                    //调用装备 的前置切入处 理方法
                                    reflect.invokeMethod(advices[i], "before", advArgs) ;
                           }
                           else
                           {
                                    break ;
                           }
                 }
                
            //process the proxy with ThrowAdvice set up.
                 //处理异 常处 理装备                
try
                 {
                           //process the proxy function                           
                           //调用目标 ?象的方法
                           result = method.invoke(this.getObjTarget(), args);
                 }
                catch(InvocationTargetException ex)
                {
                        boolean bflagthrow = true ;
                        //catch exception and active thowadvices
                        for ( ; i < advices.length ; i ++)
                        {
                                iSortnum = adviceSortNumber(advices[i]) ;
                                if (iSortnum == 2) //ThrowAdvice
                                {
                                        advArgs = new Object[]{this.getObjTarget() , method , args ,ex.getTargetException()};
                                        reflect.invokeMethod(advices[i], "afterThrowing", advArgs) ;
                                        bflagthrow = false ;
                                }
                                else
                                {
                                        break ;
                                }      
                        }
                        if (bflagthrow)
                        {
                                throw ex.getTargetException();
                        }                      
               }                 
//process advices with afterReturn function
                 //调用各装备 的后置处 理
                 for (i = j + 1; i < advices.length ; i ++)
                 {
                           iSortnum = adviceSortNumber(advices[i]) ;
                           if (iSortnum != 2)
                           {
                                    advArgs = new Object[]{this.getObjTarget() , method , args ,result};
                                    reflect.invokeMethod(advices[i], "afterReturn", advArgs) ;
                           }
                 }
                
                 return result ;                               
        }       
 
}
拦截器通过切入点可以灵活的实现加载装备的所有功能，而装备的定义正是面向方面的体现，各个装备专注于自己的方面比如日志、权限验证等，提高了可重用性。至于装备接口的定义，这里只举一个例子，与Spring不同，IAroundAdvice即对象包围处理装备。
package myFramework;
import java.lang.reflect.Method;
 
/**
 * IAroundAdvice : Around Advice Interface
 * handle a method and process before/after(around) it.
 * @author Niu Chao
 * @since 2008-8-19
 * @version 0.1
 */
public interface IAroundAdvice  extends IAdvice
{
       public void before(Object target, Method m, Object[] args) ;
       public void afterReturn(Object target, Method m, Object[] args,
                               Object objReturn);
}
正如定义的那样，该装备的实例对象必须实现两个函数before与afterReturn。恰似结合了BEFORE与AFTER两种装备那样。这些装备与目标实例的结合不是直接耦合作用的，而利用IoC和代理模式实现了松散耦合，并且分工明确，系统开发也会变得更为自自由由。