《Pro Spring》学习笔记之StaticMethodMatcherPointCut静态切入点实例

在使用任何PointCut之前，我们必须先生成一个通知(Advisor)，更准确地说是一个PointcutAdvisor

DefaultPointcutAdvisor是用来结合一个PointCut和一个Advice的简单PointcutAdvisor

所谓静态切入点，就是说spring会针对目标上的每一个方法调用一次MethodMatcher的mathces方法，其返回值被缓冲器来以便日后使用，这样，对每一个方法的适用性测试只会进行一次，相对动态的效率比较高，推荐使用

 

我们有两个类BeanOne和BeanTwo作为Target

 

package ch6.SimpleAOP.StaticPointCutAdvisor;

public class BeanOne ...{
   public void foo()...{
       System.out.println("foo-one");
   }
   public void bar()...{
       System.out.println("bar-one");
   }
}

package ch6.SimpleAOP.StaticPointCutAdvisor;

public class BeanTwo ...{
   public void foo()...{
       System.out.println("foo-two");
   }
   public void bar()...{
       System.out.println("bar-two");
   }
}

 我们想只在BeanOne的foo方法上使用AOP，需如下定义Pointcut

 

package ch6.SimpleAOP.StaticPointCutAdvisor;

import java.lang.reflect.Method;

import org.springframework.aop.ClassFilter;
import org.springframework.aop.support.StaticMethodMatcherPointcut;

public class SimpleStaticPointcut extends StaticMethodMatcherPointcut ...{

    public boolean matches(Method method, Class cls) ...{
        
        return ("foo".equals(method.getName()));
    }


    public ClassFilter getClassFilter() ...{
        
        return new ClassFilter()...{
            public boolean matches(Class cls)...{
                return (cls==BeanOne.class);
            }
        };
    }

}

 

创建环绕通知

 

package ch6.SimpleAOP.StaticPointCutAdvisor;

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

public class SimpleAdvise implements MethodInterceptor ...{

    public Object invoke(MethodInvocation invocation) throws Throwable ...{
        System.out.println("before");
        Object retVal=invocation.proceed();
        System.out.println("after");
        return retVal;
    }

}

测试代码：

 

package ch6.SimpleAOP.StaticPointCutAdvisor;

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 Test ...{

    /** *//**
     * @param args
     */
    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 SimpleAdvise();
         Advisor advisor=new DefaultPointcutAdvisor(pc,advice);
         
         
         //创建BeanOne代理
         ProxyFactory pf1=new ProxyFactory();
         pf1.addAdvisor(advisor);
         pf1.setTarget(one);
         proxyOne=(BeanOne)pf1.getProxy();
         
         //创建BeanTwo代理
         ProxyFactory pf2=new ProxyFactory();
         pf2.addAdvisor(advisor);
         pf2.setTarget(two);
         proxyTwo=(BeanTwo)pf2.getProxy();
         
         
         proxyOne.foo();
         proxyOne.bar();
         
         proxyTwo.foo();
         proxyTwo.bar();
         
    }

}

 

运行结果：

before
foo-one
after
bar-one
foo-two
bar-two