Spring AOP本质(6)

/** 
* 类过滤器 
*/ 
public  interface ClassFilter { 
     //类过滤器单例 
     public  static  final ClassFilter TRUE = TrueClassFilter.INSTANCE; 
     //类匹配方法 
     public  boolean matches(Class class1); 
}

/** 
* 方法过滤器 
*/ 
public  interface MethodMatcher { 
     //方法过滤器单例 
     public  static  final MethodMatcher TRUE = TrueMethodMatcher.INSTANCE; 
     //静态方法匹配方法 
     public  boolean matches(Method method, Class class1); 
     //判断静态还是动态匹配，返回true动态匹配，false静态匹配 
     public  boolean isRuntime(); 
     //对象（动态）匹配方法 
     public  boolean matches(Method method, Class class1, Object aobj[]); 
}

/** 
* 通知者接口 
*/ 
public  interface Advisor { 
     //切面是否为per instance 
     public  boolean isPerInstance(); 
     //获取切面上的通知 
     public Advice getAdvice(); 
}

/** 
* 通知者子接口，Spring中标准的切面都应该实现此接口 
*/ 
public PointcutAdvisor  extends Advisor { 
     //获取通知者的切点 
     public Pointcut getPointcut(); 
}

/** 
* 业务组件：BeanOne 
*/ 
public  class BeanOne { 
     public  void foo() { 
        System.out.println( "BeanOne的foo()被调用!"); 
    }     
     public  void bar() { 
        System.out.println( "BeanOne的bar()被调用!"); 
    } 
}

/** 
* 业务组件：BeanTwo 
*/ 
public  class BeanTwo { 
     public  void foo() { 
        System.out.println( "BeanTwo的foo()被调用!"); 
    }     
     public  void bar() { 
        System.out.println( "BeanTwo的bar()被调用!"); 
    } 
}

import org.aopalliance.intercept.MethodInterceptor; 
import org.aopalliance.intercept.MethodInvocation; 

/** 
* 自定义通知：Advice 
*/ 
public  class SimpleAdvice  implements MethodInterceptor { 
     public Object invoke(MethodInvocation invocation)  throws Throwable { 
        System.out.println( ">> 业务方法调用前动作，被代理调用目标方法是： " + invocation.getMethod().getName()); 
        Object retVal = invocation.proceed(); 
        System.out.println( ">> 业务方法调用结束后动作！"); 
         return retVal; 
    } 
}

import java.lang.reflect.Method; 
import org.springframework.aop.ClassFilter; 
import org.springframework.aop.support.StaticMethodMatcherPointcut; 

/** 
* 自定义静态切入点：Pointcut 
*/ 
public  class SimpleStaticPointcut  extends StaticMethodMatcherPointcut { 

     public  boolean matches(Method method, Class cls) { 
         //类方法名为foo时候匹配 
        System.out.println( "切入点方法匹配,正在匹配"+cls.getName()+ "的"+method.getName()+ "方法!"); 
         return ( "foo".equals(method.getName())); 
    } 

     public ClassFilter getClassFilter() { 
         return  new ClassFilter() { 
             public  boolean matches(Class cls) { 
                System.out.println( "切入点类匹配,正在匹配"+cls.getName()+ "类!"); 
                 //BeanOne类匹配 
                 return (cls == BeanOne. class); 
            } 
        }; 
    } 
}

import org.aopalliance.aop.Advice; 
import org.springframework.aop.Advisor; 
import org.springframework.aop.Pointcut; 
import org.springframework.aop.framework.ProxyFactory; 
import org.springframework.aop.support.DefaultPointcutAdvisor; 

/** 
* 客户端测试 
*/ 
public  class StaticPointcutExample { 

     public  static  void main(String[] args) { 
         //创建目标对象 
        BeanOne one =  new BeanOne(); 
        BeanTwo two =  new BeanTwo(); 

         //定义代理对象 
        BeanOne proxyOne; 
        BeanTwo proxyTwo; 

         //创建一个切入点 
        Pointcut pc =  new SimpleStaticPointcut(); 
         //创建一个通知 
        Advice advice =  new SimpleAdvice(); 
         //创建一个通知者(即通知和切入点的结合) 
        Advisor advisor =  new DefaultPointcutAdvisor(pc, advice); 

         //创建一个代理工厂 
        ProxyFactory pf =  new ProxyFactory(); 
         //将方面加入工厂 
        pf.addAdvisor(advisor); 
         //将目标加入工厂 
        pf.setTarget(one); 
         //获取代理对象产品 
        proxyOne = (BeanOne) pf.getProxy();   //这个时候会进行匹配检查 

         //创建一个代理工厂 
        pf =  new ProxyFactory(); 
        pf.addAdvisor(advisor); 
        pf.setTarget(two); 
        proxyTwo = (BeanTwo) pf.getProxy(); 

         /* 
       org.springframework.aop.framework.ProxyFactory中 
       设置的代理目标一次仅能一个,这点不要犯迷糊,我查过源码了. 
      */ 

         //从代理产品上调用目标方法 
        proxyOne.foo(); 
        proxyTwo.foo(); 

        proxyOne.bar(); 
        proxyTwo.bar(); 

    } 
}

- Using JDK 1.4 collections 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne类! 
切入点方法匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne的foo方法! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne类! 
切入点方法匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne的bar方法! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne类! 
切入点方法匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne的hashCode方法! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne类! 
切入点方法匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne的toString方法! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanTwo类! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanTwo类! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanTwo类! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanTwo类! 
切入点类匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne类! 
切入点方法匹配,正在匹配com.apress.prospring.ch6.staticpc.BeanOne的foo方法! 
>> 业务方法调用前动作，被代理调用目标方法是： foo 
BeanOne的foo()被调用! 
>> 业务方法调用结束后动作！ 
BeanTwo的foo()被调用! 
BeanOne的bar()被调用! 
BeanTwo的bar()被调用! 

Process finished with exit code 0