AOP编程中注解参数详解

客官°小女子只卖身不卖艺 2022-06-18 08:45 202阅读 0赞

## AOP编程中注解参数详解 ##

@Pointcut("execution(*transfer(..))")
    private void anyOldTransfer() {}
    切入点指定者的支持
    Spring AOP 支持在切入点表达式中使用如下的AspectJ切入点指定者：
    1：execution：匹配方法执行的连接点，这是你将会用到的Spring的最主要的切入点指定者。
    2：within：限定匹配特定类型的连接点（在使用SpringAOP的时候，在匹配的类型中定义的方法的执行）。
    3：this：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中bean reference（Spring AOP 代理）是指定类型的实例。
    4： target：限定匹配特定的连接点（使用SpringAOP的时候方法的执行），其中目标对象（被代理的appolication object）是指定类型的实例。
    5： args：限定匹配特定的连接点（使用Spring AOP的时候方法的执行），其中参数是指定类型的实例。
    6： @target：限定匹配特定的连接点（使用SpringAOP的时候方法的执行），其中执行的对象的类已经有指定类型的注解。
    7： @args：限定匹配特定的连接点（使用SpringAOP的时候方法的执行），其中实际传入参数的运行时类型有指定类型的注解。
    8： @within：限定匹配特定的连接点，其中连接点所在类型已指定注解（在使用Spring AOP的时候，所执行的方法所在类型已指定注解）。
    9： @annotation：限定匹配特定的连接点（使用SpringAOP的时候方法的执行），其中连接点的主题有某种给定的注解
    合并切入点表达式
    切入点表达式可以使用‘&&', '||' 和'!'来合并.还可以通过名字来指向切入点表达式。
    切入点表达式的基本语法
    Spring AOP 用户可能会经常使用 execution pointcut designator。执行表达式的格式如下：
    execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
    除了返回类型模式（上面代码片断中的ret-type-pattern），名字模式和参数模式以外，所有的部分都是可选的。返回类型模式决定了方法的返回类型必须依次匹配一个连接点。
    类型匹配模式
    1：*：匹配任何数量字符；比如模式 (*,String) 匹配了一个接受两个参数的方法，第一个可以是任意类型，第二个则必须是String类型
    2：..：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数，可以使零到多个。
    3： +：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。
    类型匹配模式示例
    1：java.lang.String 匹配String类型；
    2：java.*.String 匹配java包下的任何“一级子包”下的String类型；
    如匹配java.lang.String，但不匹配java.lang.ss.String
    3：java..* 匹配java包及任何子包下的任何类型;
    如匹配java.lang.String、java.lang.annotation.Annotation
    4：java.lang.*ing 匹配任何java.lang包下的以ing结尾的类型；
    5：java.lang.Number+ 匹配java.lang包下的任何Number的子类型；
    如匹配java.lang.Integer，也匹配java.math.BigInteger
    切入点表达式的基本示例，使用execution
    1：public * *(..)
    任何公共方法的执行
    2：* cn.javass..IPointcutService.*()
    cn.javass包及所有子包下IPointcutService接口中的任何无参方法
    3：* cn.javass..*.*(..)
    cn.javass包及所有子包下任何类的任何方法
    4：* cn.javass..IPointcutService.*(*)
    cn.javass包及所有子包下IPointcutService接口的任何只有一个参数方法
    5：* (!cn.javass..IPointcutService+).*(..)
    非“cn.javass包及所有子包下IPointcutService接口及子类型”的任何方法
    6：* cn.javass..IPointcutService+.*()
    cn.javass包及所有子包下IPointcutService接口及子类型的的任何无参方法
    7：* cn.javass..IPointcut*.test*(java.util.Date)
    cn.javass包及所有子包下IPointcut前缀类型的的以test开头的只有一个参数类型为java.util.Date的方法，注意该匹配是根据方法签名的参数类型进行匹配的，而不是根据执行时传入的参数类型决定的如定义方法：public void test(Object obj);即使执行时传入java.util.Date，也不会匹配的。
    8：* cn.javass..IPointcut*.test*(..) throwsIllegalArgumentException, ArrayIndexOutOfBoundsException
    cn.javass包及所有子包下IPointcut前缀类型的的任何方法，且抛出IllegalArgumentException和ArrayIndexOutOfBoundsException异常
    9：* (cn.javass..IPointcutService+ &&java.io.Serializable+).*(..)
    任何实现了cn.javass包及所有子包下IPointcutService接口和java.io.Serializable接口的类型的任何方法
    10：@java.lang.Deprecated * *(..)
    任何持有@java.lang.Deprecated注解的方法
    11：@java.lang.Deprecated @cn.javass..Secure * *(..)
    任何持有@java.lang.Deprecated和@cn.javass..Secure注解的方法
    12：@(java.lang.Deprecated || cn.javass..Secure) * *(..)
    任何持有@java.lang.Deprecated或@cn.javass..Secure注解的方法
    13：(@cn.javass..Secure *) *(..)
    任何返回值类型持有@cn.javass..Secure的方法
    14：* (@cn.javass..Secure *).*(..)
    任何定义方法的类型持有@cn.javass..Secure的方法
    15：* *(@cn.javass..Secure (*) , @cn.javass..Secure (*))
    任何签名带有两个参数的方法，且这个两个参数都被@ Secure标记了，如public void test(@Secure String str1, @Secure String str1);
    16：* *((@ cn.javass..Secure *))或* *(@ cn.javass..Secure *)
    任何带有一个参数的方法，且该参数类型持有@ cn.javass..Secure；如public void test(Model model);且Model类上持有@Secure注解
    17：* *(@cn.javass..Secure (@cn.javass..Secure *) ,@cn.javass..Secure (@cn.javass..Secure *))
    任何带有两个参数的方法，且这两个参数都被@ cn.javass..Secure标记了；且这两个参数的类型上都持有@ cn.javass..Secure；
    18：* *(java.util.Map<cn.javass..Model,cn.javass..Model>, ..)
    任何带有一个java.util.Map参数的方法，且该参数类型是以<cn.javass..Model, cn.javass..Model>为泛型参数；注意只匹配第一个参数为java.util.Map,不包括子类型；如public voidtest(HashMap<Model, Model> map, String str);将不匹配，必须使用“* *(java.util.HashMap<cn.javass..Model,cn.javass..Model>, ..)”进行匹配；而public void test(Map map, int i);也将不匹配，因为泛型参数不匹配
    19：* *(java.util.Collection<@cn.javass..Secure*>)
    任何带有一个参数（类型为java.util.Collection）的方法，且该参数类型是有一个泛型参数，该泛型参数类型上持有@cn.javass..Secure注解；如public voidtest(Collection<Model> collection);Model类型上持有@cn.javass..Secure
    切入点表达式的基本示例，使用within匹配指定类型内的方法
    1：within(cn.javass..*)
    cn.javass包及子包下的任何方法执行
    2：within(cn.javass..IPointcutService+)
    cn.javass包或所有子包下IPointcutService类型及子类型的任何方法
    3：within(@cn.javass..Secure *)
    持有cn.javass..Secure注解的任何类型的任何方法必须是在目标对象上声明这个注解，在接口上声明的对它不起作用
    
    切入点表达式的基本示例，使用this
    使用“this(类型全限定名)”匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口方法也可以匹配；注意this中使用的表达式必须是类型全限定名，不支持通配符
    1：this(cn.javass.spring.chapter6.service.IPointcutService)
    当前AOP对象实现了 IPointcutService接口的任何方法
    2：this(cn.javass.spring.chapter6.service.IIntroductionService)
    当前AOP对象实现了 IIntroductionService接口的任何方法也可能是引入接口
    切入点表达式的基本示例，使用target
    使用“target(类型全限定名)”匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；注意target中使用的表达式必须是类型全限定名，不支持通配符
    1：target(cn.javass.spring.chapter6.service.IPointcutService)
    当前目标对象（非AOP对象）实现了IPointcutService接口的任何方法
    2：target(cn.javass.spring.chapter6.service.IIntroductionService)
    当前目标对象（非AOP对象） 实现了IIntroductionService接口的任何方法不可能是引入接口
    切入点表达式的基本示例，使用args
    使用“args(参数类型列表)”匹配当前执行的方法传入的参数为指定类型的执行方法；注意是匹配传入的参数类型，不是匹配方法签名的参数类型；参数类型列表中的参数必须是类型全限定名，通配符不支持；args属于动态切入点，这种切入点开销非常大，非特殊情况最好不要使用
    1：args (java.io.Serializable,..)
    任何一个以接受“传入参数类型为 java.io.Serializable” 开头，且其后可跟任意个任意类型的参数的方法执行，args指定的参数类型是在运行时动态匹配的
    切入点表达式的基本示例，使用@within
    使用“@within(注解类型)”匹配所以持有指定注解类型内的方法；注解类型也必须是全限定类型名
    1：@within cn.javass.spring.chapter6.Secure)
    任何目标对象对应的类型持有Secure注解的类方法；必须是在目标对象上声明这个注解，在接口上声明的对它不起作用
    切入点表达式的基本示例，使用@target
    使用“@target(注解类型)”匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；注解类型也必须是全限定类型名
    1：@target (cn.javass.spring.chapter6.Secure)
    任何目标对象持有Secure注解的类方法；必须是在目标对象上声明这个注解，在接口上声明的对它不起作用
    切入点表达式的基本示例，使用@args
    使用“@args(注解列表)”匹配当前执行的方法传入的参数持有指定注解的执行；注解类型也必须是全限定类型名
    1：@args (cn.javass.spring.chapter6.Secure)
    任何一个只接受一个参数的方法，且方法运行时传入的参数持有注解cn.javass.spring.chapter6.Secure；动态切入点，类似于arg指示符；
    切入点表达式的基本示例，使用@annotation
    使用“@annotation(注解类型)”匹配当前执行方法持有指定注解的方法；注解类型也必须是全限定类型名
    1：@annotation(cn.javass.spring.chapter6.Secure )
    当前执行方法上持有注解 cn.javass.spring.chapter6.Secure将被匹配
    切入点表达式的基本示例，使用bean
    使用“bean(Bean id或名字通配符)”匹配特定名称的Bean对象的执行方法；Spring AOP扩展的，在AspectJ中无相应概念
    1：bean(*Service)
    匹配所有以Service命名（id或name）结尾的Bean
    切入点表达式的基本示例，使用reference pointcut
    引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持，如下所示：
    
    java代码：
    查看复制到剪贴板打印
    @Pointcut(value="bean(*Service)") //命名切入点1
    private void pointcut1(){}
    @Pointcut(value="@args(cn.javass.spring.chapter6.Secure)") //命名切入点2
    private void pointcut2(){}
    
    @Before(value = "pointcut1() && pointcut2()") //引用命名切入点
    public void referencePointcutTest1(JoinPoint jp) {
    dump("pointcut1() && pointcut2()", jp);
    }
    声明通知
    通知是跟一个切入点表达式关联起来的，并且在切入点匹配的方法执行之前或者之后或者之前和之后运行。 切入点表达式可能是指向已命名的切入点的简单引用或者是一个已经声明过的切入点表达式。
    前置通知（Before advice） ，使用 @Before注解声明
    
    java代码：
    查看复制到剪贴板打印
    @Aspect
    public class BeforeExample {
    @Before("execution(* com.xyz.myapp.dao.*.*(..))")
    public void doAccessCheck() {
    // ...
    }
    }
    返回后通知（After returning advice） ，使用 @AfterReturning注解声明
    后通知（After (finally) advice） ，使用@After注解声明
    抛出后通知（After throwing advice） ，使用 @AfterThrowing注解声明
    可以将抛出的异常绑定到通知的一个参数上 ，如下：
    
    java代码：
    查看复制到剪贴板打印
    @AfterThrowing(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    throwing="ex")
    public void doRecoveryActions(Exception ex) {
    // ...
    }
    环绕通知（Around Advice） ，使用 @Around注解声明
    
    java代码：
    查看复制到剪贴板打印
    @Around("com.xyz.myapp.SystemArchitecture.businessService()")
    public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
    // start stopwatch
    Object retVal = pjp.proceed();
    // stop stopwatch
    return retVal;
    }
    给Advice传递参数
    通常情况下，Advice都需要获取一定的参数，比如：Before需要截获传入的参数，而After需要获取方法的返回值等等。下面介绍两种方式
    方式一：使用JoinPoint来给Advice的方法传递参数
    Spring AOP提供使用org.aspectj.lang.JoinPoint类型获取连接点数据，任何通知方法的第一个参数都可以是JoinPoint(环绕通知是ProceedingJoinPoint，JoinPoint子类)，当然第一个参数位置也可以是JoinPoint.StaticPart类型，这个只返回连接点的静态部分。
    1：JoinPoint：提供访问当前被通知方法的目标对象、代理对象、方法参数等数据
    
    java代码：
    查看复制到剪贴板打印
    public interface JoinPoint {
    String toString(); //连接点所在位置的相关信息
    String toShortString(); //连接点所在位置的简短相关信息
    String toLongString(); //连接点所在位置的全部相关信息
    Object getThis(); //返回AOP代理对象
    Object getTarget(); //返回目标对象
    Object[] getArgs(); //返回被通知方法参数列表
    Signature getSignature(); //返回当前连接点签名
    SourceLocation getSourceLocation();//返回连接点方法所在类文件中的位置
    String getKind(); //连接点类型
    StaticPart getStaticPart(); //返回连接点静态部分
    }
    2：ProceedingJoinPoint：用于环绕通知，使用proceed()方法来执行目标方法
    
    java代码：
    查看复制到剪贴板打印
    public interface ProceedingJoinPoint extends JoinPoint {
    public Object proceed() throws Throwable;
    public Object proceed(Object[] args) throws Throwable;
    }
    3：JoinPoint.StaticPart：提供访问连接点的静态部分，如被通知方法签名、连接点类型等
    
    java代码：
    查看复制到剪贴板打印
    public interface StaticPart {
    Signature getSignature(); //返回当前连接点签名
    String getKind(); //连接点类型
    int getId(); //唯一标识
    String toString(); //连接点所在位置的相关信息
    String toShortString(); //连接点所在位置的简短相关信息
    String toLongString(); //连接点所在位置的全部相关信息
    }
    4：示例：使用如下方式在通知方法上声明，必须是在第一个参数，然后使用jp.getArgs()就能获取到被通知方法参数：
    
    java代码：
    查看复制到剪贴板打印
    @Before(value="execution(* sayBefore(*))")
    public void before(JoinPoint jp) {}
    @Before(value="execution(* sayBefore(*))")
    public void before(JoinPoint.StaticPart jp) {}
    方式二：使用args来给Advice的方法传递参数，示例如：
    
    java代码：
    查看复制到剪贴板打印
    @Before(value="execution(* test(*)) && args(param)", argNames="param")
    public void before1(String param) {
    System.out.println("===param:" + param);
    }
    切入点表达式execution(* test(*)) && args(param) ：
    （1）首先execution(* test(*))匹配任何方法名为test，且有一个任何类型的参数；
    （2）args(param)将首先查找通知方法上同名的参数，并在方法执行时（运行时）匹配传入的参数是使用该同名参数类型，即java.lang.String；如果匹配将把该被通知参数传递给通知方法上同名参数。
    参数匹配的策略
    1：可以通过“argNames”属性指定参数名 ，示例如：
    
    java代码：
    查看复制到剪贴板打印
    @Before(value=" args(param)", argNames="param") //明确指定了
    public void before1(String param) {
    System.out.println("===param:" + param);
    }
    2：如果第一个参数类型是JoinPoint、ProceedingJoinPoint或JoinPoint.StaticPart类型，应该从“argNames”属性省略掉该参数名（可选，写上也对），这些类型对象会自动传入的，但必须作为第一个参数。示例如：
    
    java代码：
    查看复制到剪贴板打印
    @Before(value=" args(param)", argNames="param") //明确指定了
    public void before1(JoinPoint jp, String param) {
    System.out.println("===param:" + param);
    }
    3：如果“ class文件中含有变量调试信息”，Spring将可以使用这些方法签名中的参数名来确定参数名，示例如下：
    
    java代码：
    查看复制到剪贴板打印
    @Before(value=" args(param)") //不需要argNames了
    public void before1(JoinPoint jp, String param) {
    System.out.println("===param:" + param);
    }
    4：如果没有“ class文件中含有变量调试信息”，将尝试自己的参数匹配算法，如果发现参数绑定有二义性将抛出AmbiguousBindingException异常；对于只有一个绑定变量的切入点表达式，而通知方法只接受一个参数，说明绑定参数是明确的，从而能配对成功，示例如下：
    @Before(value=" args(param)")
    public void before1(JoinPoint jp, String param) {
    System.out.println("===param:" + param);
    }
    5：以上策略失败将抛出IllegalArgumentException。
    处理参数
    
    java代码：
    查看复制到剪贴板打印
    @Around("execution(List<Account> find*(..)) &&" +
    "com.xyz.SystemArchitecture.inDataAccessLayer() && " +"args(accountHolderNamePattern)")
    public Object preProcessQueryPattern(ProceedingJoinPoint pjp, StringaccountHolderNamePattern)
    throws Throwable {
    String newPattern = preProcess(accountHolderNamePattern);
    return pjp.proceed(new Object[] {newPattern});
    }
    获取方法运行后的返回值
    
    java代码：
    查看复制到剪贴板打印
    @AfterReturning(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    returning="retVal")
    public void doAccessCheck(Object retVal) {
    // ...
    }
    Advice执行的顺序
    如果有多个通知想要在同一连接点运行会发生什么？Spring AOP 的执行通知的顺序跟AspectJ的一样。 在“进入”连接点的情况下，最高优先级的通知会先执行（所以上面给出的两个前置通知（before advice）中，优先级高的那个会先执行）。 在“退出”连接点的情况下，最高优先级的通知会最后执行。只需要记住通知是按照定义的顺序来执行的就可以了。
    当定义在 不同的 切面里的两个通知都需要在一个相同的连接点中运行，那么除非你指定，否则执行的顺序是未知的。 你可以通过指定优先级来控制执行顺序。在Spring中可以在切面类中实现org.springframework.core.Ordered 接口做到这一点。 在两个切面中，Ordered.getValue()方法返回值较低的那个有更高的优先级。
    
    
    java代码：
    查看复制到剪贴板打印
    声明一个切面 ：<aop:aspect>
    <aop:config>
    <aop:aspect id="myAspect" ref="adviceBean">
    ...
    </aop:aspect>
    </aop:config>
    <bean id="adviceBean" class="...">
    ...
    </bean>
    声明一个切入点 ：<aop:pointcut>
    <aop:config>
    <aop:pointcut id="businessService"
    expression="execution(* com.xyz.myapp.service.*.*(..))"/>
    </aop:config>
    
    在切面里面声明一个切入点和声明一个顶级的切入点非常类似：
    
    java代码：
    查看复制到剪贴板打印
    <aop:config>
    <aop:aspect id="myAspect" ref="aBean">
    <aop:pointcut id="businessService"
    expression="execution(* com.xyz.myapp.service.*.*(..))"/>
    ...
    </aop:aspect>
    </aop:config>
    当需要连接子表达式的时候，'&'在XML中用起来非常不方便，所以关键字'and', 'or' 和 'not'可以分别用来代替'&', '||' 和 '!'。
    
    java代码：
    查看复制到剪贴板打印
    声明通知Advice，Before Advice
    <aop:aspect id="beforeExample" ref="aBean">
    <aop:before
    pointcut="execution(* com.xyz.myapp.dao.*.*(..))"
    method="doAccessCheck"/>
    ...
    </aop:aspect>
    返回后通知（After returning advice）
    <aop:aspect id="afterReturningExample" ref="aBean">
    <aop:after-returning
    pointcut-ref="dataAccessOperation"
    method="doAccessCheck"/>
    ...
    </aop:aspect>
    
    java代码：
    查看复制到剪贴板打印
    抛出异常后通知（After throwing advice）
    <aop:aspect id="afterThrowingExample" ref="aBean">
    <aop:after-throwing
    pointcut-ref="dataAccessOperation"
    thowing="dataAccessEx"
    method="doRecoveryActions"/>
    ...
    </aop:aspect>
    后通知（After (finally) advice）
    <aop:aspect id="afterFinallyExample" ref="aBean">
    <aop:after
    pointcut-ref="dataAccessOperation"
    method="doReleaseLock"/>
    ...
    </aop:aspect>
    
    Around通知
    
    java代码：
    查看复制到剪贴板打印
    <aop:aspect id="aroundExample" ref="aBean">
    <aop:around
    pointcut-ref="businessService"
    method="doBasicProfiling"/>
    ...
    </aop:aspect>
    通知的参数，可以通过 arg-names 属性来实现
    
    java代码：
    查看复制到剪贴板打印
    <aop:before
    pointcut="com.xyz.lib.Pointcuts.anyPublicMethod()"
    method="audit"
    arg-names="auditable"/>
    Advisor
    “advisors”这个概念来自Spring1.2对AOP的支持，在AspectJ中是没有等价的概念。 advisor就像一个小的自包含的切面，这个切面只有一个通知。
    
    java代码：
    查看复制到剪贴板打印
    <aop:config>
    <aop:pointcut id="businessService"
    expression="execution(* com.xyz.myapp.service.*.*(..))"/>
    <aop:advisor
    pointcut-ref="businessService"
    advice-ref="tx-advice"/>
    </aop:config>
    Spring AOP还是完全用AspectJ？
    优先选用Spring的AOP，因为它不是一个人在战斗，Spring除了AOP，还有IOC，还有事务等其他功能。
    如果你需要通知domain对象或其它没有在Spring容器中管理的任意对象，那么你需要使用AspectJ。
    Spring AOP中使用@AspectJ还是XML？
    优先使用@AspectJ。
    XML风格有两个缺点。第一是它不能完全将需求实现的地方封装到一个位置。DRY原则中说系统中的每一项知识都必须具有单一、无歧义、权威的表示。当使用XML风格时，如何实现一个需求的知识被分割到支撑类的声明中以及XML配置文件中。当使用@AspectJ风格时就只有一个单独的模块 -切面- 信息被封装了起来。 第二是XML风格同@AspectJ风格所能表达的内容相比有更多的限制：仅仅支持"singleton"切面实例模型，并且不能在XML中组合命名连接点的声明。
    
    Spring AOP使用JDK动态代理或者CGLIB来为目标对象创建代理。如果被代理的目标对象实现了至少一个接口，则会使用JDK动态代理。所有该目标类型实现的接口都将被代理。若该目标对象没有实现任何接口，则创建一个CGLIB代理。
    如果你希望强制使用CGLIB代理，（例如：希望代理目标对象的所有方法，而不只是实现自接口的方法）那也可以。但是需要考虑以下问题:
    1：无法通知（advise）Final 方法，因为他们不能被覆写。
    2：将CGLIB 2二进制发行包放在classpath下面，JDK本身就提供了动态代理
    3：强制使用CGLIB代理需要将<aop:config> 的 proxy-target-class 属性设为true:
    <aop:config proxy-target-class="true"></aop:config>
    4：当需要使用CGLIB代理和@AspectJ自动代理支持，请按照如下的方式设置 <aop:aspectj-autoproxy> 的proxy-target-class 属性：
    <aop:aspectj-autoproxy proxy-target-class="true"/>
    切入点的API
    org.springframework.aop.Pointcut 是最核心的接口，用来将 通知应用于特定的类和方法，完整的接口定义如下：
    
    java代码：
    查看复制到剪贴板打印
    public interface Pointcut {
    ClassFilter getClassFilter();
    MethodMatcher getMethodMatcher();
    }
    1：将Pointcut接口分割成有利于重用类和方法匹配的两部分，以及进行更细粒度的操作组合（例如与另一个方法匹配实现进行“或操作”）。
    2：ClassFilter接口用来将切入点限定在一个给定的类集合中。如果matches()方法总是返回true，所有目标类都将被匹配：
    public interface ClassFilter {
    boolean matches(Class clazz);
    }
    3：MethodMatcher接口通常更重要，完整的接口定义如下：
    
    java代码：
    查看复制到剪贴板打印
    public interface MethodMatcher {
    boolean matches(Method m, Class targetClass);
    boolean isRuntime();
    boolean matches(Method m, Class targetClass, Object[] args);
    }
    matches(Method, Class)方法用来测试这个切入点是否匹配目标类的指定方法。这将在AOP代理被创建的时候执行，这样可以避免在每次方法调用的时候都执行。如果matches(Method, Class )对于一个给定的方法返回true，并且isRuntime() 也返回true，那么matches(Method, Class , Object[])将在每个方法调用的时候被调用。这使得切入点在通知将被执行前可以查看传入到方法的参数。
    
    大多数MethodMatcher是静态的，这意味着isRuntime()方法返回 false。在这种情况下，matches(Method, Class ,Object[])永远不会被调用。
    
    静态切入点
    静态切入点基于方法和目标类进行切入点判断而不考虑方法的参数。在多数情况下，静态切入点是高效的、最好的选择。Spring只在第一次调用方法时执行静态切入点：以后每次调用这个方法时就不需要再执行。
    1：正则表达式切入点
    正则表达式是最常用的描述静态切入点的方式，多数AOP框架都支持这种方式。org.springframework.aop.support.Perl5RegexpMethodPointcut是一个最基本的正则表达式切入点，它使用Perl 5正则表达式语法。示例如下：
    
    java代码：
    查看复制到剪贴板打印
    <bean id="settersAndAbsquatulatePointcut"
    class="org.springframework.aop.support.Perl5RegexpMethodPointcut">
    <property name="patterns">
    <list>
    <value>.*set.*</value>
    <value>.*absquatulate</value>
    </list>
    </property>
    </bean>
    拦截around通知
    Spring里使用方法拦截的around通知兼容AOP联盟接口。实现around通知的MethodInterceptor应当实现下面的接口：
    
    java代码：
    查看复制到剪贴板打印
    public interface MethodInterceptor extends Interceptor {
    Object invoke(MethodInvocation invocation) throws Throwable;
    }
    提示：在invok方法里面不要忘记调用：invocation.proceed();
    前置通知
    
    java代码：
    查看复制到剪贴板打印
    public interface MethodBeforeAdvice extends BeforeAdvice {
    void before(Method m, Object[] args, Object target) throws Throwable;
    }
    后置通知
    
    java代码：
    查看复制到剪贴板打印
    public interface AfterReturningAdvice extends Advice {
    void afterReturning(Object returnValue, Method m, Object[] args, Object target)throws Throwable;
    }
    异常通知
    如果连接点抛出异常，异常通知（throws advice）将在连接点返回后被调用。 Spring提供类型检查的异常通知，这意味着org.springframework.aop.ThrowsAdvice接口不包含任何方法：它只是一个标记接口用来标识所给对象实现了一个或者多个针对特定类型的异常通知方法。这些方法应当满足下面的格式
    afterThrowing([Method], [args], [target], subclassOfThrowable)
    只有最后一个参数是必须的。因此异常通知方法对方法及参数的需求，方法的签名将从一到四个参数之间变化。 下面是一些throws通知的例子。
    当一个RemoteException（包括它的子类）被抛出时，下面的通知会被调用：
    
    java代码：
    查看复制到剪贴板打印
    public class RemoteThrowsAdvice implements ThrowsAdvice {
    public void afterThrowing(RemoteException ex) throws Throwable {
    // Do something with remote exception
    }
    }
    引入通知
    
    java代码：
    查看复制到剪贴板打印
    public interface IntroductionInterceptor extends MethodInterceptor {
    boolean implementsInterface(Class intf);
    }
    使用ProxyFactoryBean创建AOP代理
    使用ProxyFactoryBean或者其它IoC相关类带来的最重要的好处之一就是创建AOP代理，这意味着通知和切入点也可以由IoC来管理。这是一个强大的功能并使得某些特定的解决方案成为可能
    下面描述ProxyFactoryBean的属性：
    1：proxyTargetClass：这个属性为true时，目标类本身被代理而不是目标类的接口。如果这个属性值被设为true，CGLIB代理将被创建
    2：optimize：用来控制通过CGLIB创建的代理是否使用激进的优化策略。除非完全了解AOP代理如何处理优化，否则不推荐用户使用这个设置。目前这个属性仅用于CGLIB代理；对于JDK动态代理（缺省代理）无效。
    3：frozen：用来控制代理工厂被配置之后，是否还允许修改通知。缺省值为false（即在代理被配置之后，不允许修改代理的配置）。
    4：exposeProxy：决定当前代理是否被保存在一个ThreadLocal中以便被目标对象访问。（目标对象本身可以通过MethodInvocation来访问，因此不需要ThreadLocal。）如果个目标对象需要获取代理而且exposeProxy属性被设为true，目标对象可以使用AopContext.currentProxy()方法。
    5：aopProxyFactory：使用AopProxyFactory的实现。这提供了一种方法来自定义是否使用动态代理，CGLIB或其它代理策略。 缺省实现将根据情况选择动态代理或者CGLIB。一般情况下应该没有使用这个属性的需要；它是被设计来在Spring 1.1中添加新的代理类型的。
    6：proxyInterfaces：需要代理的接口名的字符串数组。如果没有提供，将为目标类使用一个CGLIB代理
    7：interceptorNames：Advisor的字符串数组，可以包括拦截器或其它通知的名字。顺序是很重要的，排在前面的将被优先服务。就是说列表里的第一个拦截器将能够第一个拦截调用。
    这里的名字是当前工厂中bean的名字，包括父工厂中bean的名字。这里你不能使用bean的引用因为这会导致ProxyFactoryBean忽略通知的单例设置。
    你可以把一个拦截器的名字加上一个星号作为后缀（*）。这将导致这个应用程序里所有名字以星号之前部分开头的advisor都被应用。