spring--AOP1--6

AOP 之 6.1 AOP基础

6.1.1  AOP是什么

考虑这样一个问题：需要对系统中的某些业务做日志记录，比如支付系统中的支付业务需要记录支付相关日志，对于支付系统可能相当复杂，比如可能有自己的支付系统，也可能引入第三方支付平台，面对这样的支付系统该如何解决呢？

  • 传统解决方案：

1）日志部分提前公共类LogUtils，定义“longPayBegin”方法用于记录支付开始日志，“logPayEnd”用于记录支付结果：

2）支付部分，定义IPayService接口并定义支付方法“pay”，并定义了两个实现：“PointPayService”表示积分支付，“RMBPayService”表示人民币支付；并且在每个支付实现中支付逻辑和记录日志：

3）支付实现很明显有重复代码，这个重复很明显可以使用模板设计模式消除重复：

4）到此我们设计了一个可以复用的接口；但大家觉得这样记录日志会很好吗，有没有更好的解决方案？

如果对积分支付方式添加统计功能，比如在支付时记录下用户总积分数、当前消费的积分数，那我们该如何做呢？直接修改源代码添加日志记录，这完全违背了面向对象最重要的原则之一：开闭原则（对扩展开放，对修改关闭）？

  • 更好的解决方案：在我们的支付组件中由于使用了日志组件，即日志模块横切于支付组件，在传统程序设计中很难将日志组件分离出来，即不耦合我们的支付组件；因此面向方面编程AOP就诞生了，它能分离我们的组件，使组件完全不耦合:

1）采用面向方面编程后，我们的支付组件看起来如下所示，代码中不再有日志组件的任何东西；

2）所以日志相关的提取到一个切面中，AOP实现者会在合适的时候将日志功能织入到我们的支付组件中去，从而完全解耦支付组件和日志组件。

看到这大家可能不是很理解，没关系，先往下看。

面向方面编程(AOP)：也可称为面向切面编程，是一种编程范式，提供从另一个角度来考虑程序结构从而完善面向对象编程(OOP)。

 

在进行OOP开发时，都是基于对组件（比如类）进行开发，然后对组件进行组合，OOP最大问题就是无法解耦组件进行开发，比如我们上边举例，而AOP就是为了克服这个问题而出现的，它来进行这种耦合的分离。

AOP为开发者提供一种进行横切关注点（比如日志关注点横切了支付关注点）分离并织入的机制，把横切关注点分离，然后通过某种技术织入到系统中，从而无耦合的完成了我们的功能。

6.1.2  能干什么

AOP主要用于横切关注点分离和织入，因此需要理解横切关注点和织入：

  • 关注点：可以认为是所关注的任何东西，比如上边的支付组件；
  • 关注点分离：将问题细化从而单独部分，即可以理解为不可再分割的组件，如上边的日志组件和支付组件；
  • 横切关注点：一个组件无法完成需要的功能，需要其他组件协作完成，如日志组件横切于支付组件；
  • 织入：横切关注点分离后，需要通过某种技术将横切关注点融合到系统中从而完成需要的功能，因此需要织入，织入可能在编译期、加载期、运行期等进行。

横切关注点可能包含很多，比如非业务的：日志、事务处理、缓存、性能统计、权限控制等等这些非业务的基础功能；还可能是业务的：如某个业务组件横切于多个模块。如图6-1

图6-1 关注点与横切关注点

传统支付形式，流水方式：

面向切面方式，先将横切关注点分离，再将横切关注点织入到支付系统中：

AOP能干什么：

  • 用于横切关注点的分离和织入横切关注点到系统；比如上边提到的日志等等；
  • 完善OOP；
  • 降低组件和模块之间的耦合性；
  • 使系统容易扩展；
  • 而且由于关注点分离从而可以获得组件的更好复用。

6.1.3  AOP的基本概念

在进行AOP开发前，先熟悉几个概念：

  • 连接点（Jointpoint）：表示需要在程序中插入横切关注点的扩展点，连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等，Spring只支持方法执行连接点，在AOP中表示为“在哪里干”；
  • 切入点（Pointcut）：选择一组相关连接点的模式，即可以认为连接点的集合，Spring支持perl5正则表达式和AspectJ切入点模式，Spring默认使用AspectJ语法，在AOP中表示为“在哪里干的集合”；
  • 通知（Advice）：在连接点上执行的行为，通知提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段；包括前置通知（before advice）、后置通知(after advice)、环绕通知（around advice），在Spring中通过代理模式实现AOP，并通过拦截器模式以环绕连接点的拦截器链织入通知；在AOP中表示为“干什么”；
  • 方面/切面（Aspect）：横切关注点的模块化，比如上边提到的日志组件。可以认为是通知、引入和切入点的组合；在Spring中可以使用Schema和@AspectJ方式进行组织实现；在AOP中表示为“在哪干和干什么集合”；
  • 引入（inter-type declaration）：也称为内部类型声明，为已有的类添加额外新的字段或方法，Spring允许引入新的接口（必须对应一个实现）到所有被代理对象（目标对象）, 在AOP中表示为“干什么（引入什么）”；
  • 目标对象（Target Object）：需要被织入横切关注点的对象，即该对象是切入点选择的对象，需要被通知的对象，从而也可称为“被通知对象”；由于Spring AOP 通过代理模式实现，从而这个对象永远是被代理对象，在AOP中表示为“对谁干”；
  • AOP代理（AOP Proxy）：AOP框架使用代理模式创建的对象，从而实现在连接点处插入通知（即应用切面），就是通过代理来对目标对象应用切面。在Spring中，AOP代理可以用JDK动态代理或CGLIB代理实现，而通过拦截器模型应用切面。
  • 织入（Weaving）：织入是一个过程，是将切面应用到目标对象从而创建出AOP代理对象的过程，织入可以在编译期、类装载期、运行期进行。

在AOP中，通过切入点选择目标对象的连接点，然后在目标对象的相应连接点处织入通知，而切入点和通知就是切面（横切关注点），而在目标对象连接点处应用切面的实现方式是通过AOP代理对象，如图6-2所示。

图6-2 概念关系

接下来再让我们具体看看Spring有哪些通知类型：

  • 前置通知（Before Advice）:在切入点选择的连接点处的方法之前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。
  • 后置通知（After Advice）:在切入点选择的连接点处的方法之后执行的通知，包括如下类型的后置通知：
    • 后置返回通知（After returning Advice）:在切入点选择的连接点处的方法正常执行完毕时执行的通知，必须是连接点处的方法没抛出任何异常正常返回时才调用后置通知。
    • 后置异常通知（After throwing Advice）: 在切入点选择的连接点处的方法抛出异常返回时执行的通知，必须是连接点处的方法抛出任何异常返回时才调用异常通知。
    • 后置最终通知（After finally Advice）: 在切入点选择的连接点处的方法返回时执行的通知，不管抛没抛出异常都执行，类似于Java中的finally块。
  • 环绕通知（Around Advices）：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。

各种通知类型在UML序列图中的位置如图6-3所示：

图6-3 通知类型

6.1.4  AOP代理

AOP代理就是AOP框架通过代理模式创建的对象，Spring使用JDK动态代理或CGLIB代理来实现，Spring缺省使用JDK动态代理来实现，从而任何接口都可别代理，如果被代理的对象实现不是接口将默认使用CGLIB代理，不过CGLIB代理当然也可应用到接口。

AOP代理的目的就是将切面织入到目标对象。

概念都将完了，接下来让我们看一下AOP的 HelloWorld!吧。

AOP 之 6.2 AOP的HelloWorld

6.2.1  准备环境

首先准备开发需要的jar包，请到spring-framework-3.0.5.RELEASE-dependencies.zip和spring-framework-3.0.5.RELEASE-with-docs中查找如下jar包：

org.springframework.aop-3.0.5.RELEASE.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.net.sf.cglib-2.2.0.jar

将这些jar包添加到“Build Path”下。

6.2.2  定义目标类

1）定义目标接口：

java代码：

package cn.javass.spring.chapter6.service;
public interface IHelloWorldService {
    public void sayHello();
}

2）定义目标接口实现：

java代码：

package cn.javass.spring.chapter6.service.impl;
import cn.javass.spring.chapter6.service.IHelloWorldService;
public class HelloWorldService implements IHelloWorldService {
    @Override
    public void sayHello() {
        System.out.println("============Hello World!");
    }
}

注：在日常开发中最后将业务逻辑定义在一个专门的service包下，而实现定义在service包下的impl包中，服务接口以IXXXService形式，而服务实现就是XXXService，这就是规约设计，见名知义。当然可以使用公司内部更好的形式，只要大家都好理解就可以了。

6.2.2  定义切面支持类

有了目标类，该定义切面了，切面就是通知和切入点的组合，而切面是通过配置方式定义的，因此这定义切面前，我们需要定义切面支持类，切面支持类提供了通知实现：

java代码：

package cn.javass.spring.chapter6.aop;
public class HelloWorldAspect {
       //前置通知
    public void beforeAdvice() {
        System.out.println("===========before advice");
    }
    //后置最终通知
    public void afterFinallyAdvice() {
        System.out.println("===========after finally advice");
    }
}

此处HelloWorldAspect类不是真正的切面实现，只是定义了通知实现的类，在此我们可以把它看作就是缺少了切入点的切面。

注：对于AOP相关类最后专门放到一个包下，如“aop”包，因为AOP是动态织入的，所以如果某个目标类被AOP拦截了并应用了通知，可能很难发现这个通知实现在哪个包里，因此推荐使用规约命名，方便以后维护人员查找相应的AOP实现。

6.2.3  在XML中进行配置

有了通知实现，那就让我们来配置切面吧：

1）首先配置AOP需要aop命名空间，配置头如下：

java代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
</beans>

2）配置目标类：

java代码：

<bean id="helloWorldService"
class="cn.javass.spring.chapter6.service.impl.HelloWorldService"/>

3）配置切面：

java代码：

<bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>
    <aop:aspect ref="aspect">
        <aop:before pointcut-ref="pointcut" method="beforeAdvice"/>
        <aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterFinallyAdvice"/>
    </aop:aspect>
</aop:config>

切入点使用<aop:config>标签下的<aop:pointcut>配置，expression属性用于定义切入点模式，默认是AspectJ语法，“execution(* cn.javass..*.*(..))”表示匹配cn.javass包及子包下的任何方法执行。

切面使用<aop:config>标签下的<aop:aspect>标签配置，其中“ref”用来引用切面支持类的方法。

前置通知使用<aop:aspect>标签下的<aop:before>标签来定义，pointcut-ref属性用于引用切入点Bean，而method用来引用切面通知实现类中的方法，该方法就是通知实现，即在目标类方法执行之前调用的方法。

最终通知使用<aop:aspect>标签下的<aop:after >标签来定义，切入点除了使用pointcut-ref属性来引用已经存在的切入点，也可以使用pointcut属性来定义，如pointcut="execution(* cn.javass..*.*(..))"，method属性同样是指定通知实现，即在目标类方法执行之后调用的方法。

6.2.4    运行测试

测试类非常简单，调用被代理Bean跟调用普通Bean完全一样，Spring AOP将为目标对象创建AOP代理，具体测试代码如下：

java代码：

package cn.javass.spring.chapter6;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.javass.spring.chapter6.service.IHelloWorldService;
import cn.javass.spring.chapter6.service.IPayService;
public class AopTest {
    @Test
    public void testHelloworld() {
        ApplicationContext ctx =  new ClassPathXmlApplicationContext("chapter6/helloworld.xml");
        IHelloWorldService helloworldService =
        ctx.getBean("helloWorldService", IHelloWorldService.class);
        helloworldService.sayHello();
    }
}

该测试将输出如下如下内容：

java代码：

===========before advice
============Hello World!
===========after finally advice

从输出我们可以看出：前置通知在切入点选择的连接点（方法）之前允许，而后置通知将在连接点（方法）之后执行，具体生成AOP代理及执行过程如图6-4所示。

图6-4 Spring AOP框架生成AOP代理过程

6.3  基于Schema的AOP

基于Schema的AOP从Spring2.0之后通过“aop”命名空间来定义切面、切入点及声明通知。

在Spring配置文件中，所以AOP相关定义必须放在<aop:config>标签下，该标签下可以有<aop:pointcut>、<aop:advisor>、<aop:aspect>标签，配置顺序不可变。

  • <aop:pointcut>：用来定义切入点，该切入点可以重用；
  • <aop:advisor>：用来定义只有一个通知和一个切入点的切面；
  • <aop:aspect>：用来定义切面，该切面可以包含多个切入点和通知，而且标签内部的通知和切入点定义是无序的；和advisor的区别就在此，advisor只包含一个通知和一个切入点。

6.3.1  声明切面

切面就是包含切入点和通知的对象，在Spring容器中将被定义为一个Bean，Schema方式的切面需要一个切面支持Bean，该支持Bean的字段和方法提供了切面的状态和行为信息，并通过配置方式来指定切入点和通知实现。

切面使用<aop:aspect>标签指定，ref属性用来引用切面支持Bean。

切面支持Bean“aspectSupportBean”跟普通Bean完全一样使用，切面使用“ref”属性引用它。

6.3.2  声明切入点

切入点在Spring中也是一个Bean，Bean定义方式可以有很三种方式：

1）在<aop:config>标签下使用<aop:pointcut>声明一个切入点Bean，该切入点可以被多个切面使用，对于需要共享使用的切入点最好使用该方式，该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式：

java代码：

<aop:config>
 <aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>
 <aop:aspect ref="aspectSupportBean">
    <aop:before pointcut-ref="pointcut" method="before"/>
 </aop:aspect>
</aop:config>

2）在<aop:aspect>标签下使用<aop:pointcut>声明一个切入点Bean，该切入点可以被多个切面使用，但一般该切入点只被该切面使用，当然也可以被其他切面使用，但最好不要那样使用，该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式：

java代码：

<aop:config>
 <aop:aspect ref="aspectSupportBean">
    <aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>
    <aop:before pointcut-ref="pointcut" method="before"/>
 </aop:aspect>
</aop:config>

3）匿名切入点Bean，可以在声明通知时通过pointcut属性指定切入点表达式，该切入点是匿名切入点，只被该通知使用：

java代码：

<aop:config>
 <aop:aspect ref="aspectSupportBean">
     <aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterFinallyAdvice"/>
 </aop:aspect>
</aop:config>

6.3.3  声明通知

基于Schema方式支持前边介绍的5中通知类型：

一、前置通知：在切入点选择的方法之前执行，通过<aop:aspect>标签下的<aop:before>标签声明：

java代码：

<aop:before pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
method="前置通知实现方法名"
arg-names="前置通知实现方法参数列表参数名字"/>

pointcut和pointcut-ref：二者选一，指定切入点；

method：指定前置通知实现方法名，如果是多态需要加上参数类型，多个用“，”隔开，如beforeAdvice(java.lang.String)；

arg-names：指定通知实现方法的参数名字，多个用“，”分隔，可选，类似于【3.1.2 构造器注入】中的参数名注入限制：在class文件中没生成变量调试信息是获取不到方法参数名字的，因此只有在类没生成变量调试信息时才需要使用arg-names属性来指定参数名，如arg-names="param"表示通知实现方法的参数列表的第一个参数名字为“param”。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

public void sayBefore(String param);

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public void sayBefore(String param) {
    System.out.println("============say " + param);
}

第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：

java代码：

public void beforeAdvice(String param) {
    System.out.println("===========before advice param:" + param);
}

最后在chapter6/advice.xml配置文件中进行如下配置：

java代码：

<bean id="helloWorldService" class="cn.javass.spring.chapter6.service.impl.HelloWorldService"/>
<bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>
<aop:config>
    <aop:aspect ref="aspect">
        <aop:before pointcut="execution(* cn.javass..*.sayBefore(..)) and args(param)"
                           method="beforeAdvice(java.lang.String)"
                           arg-names="param"/>
    </aop:aspect>
</aop:config>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test
public void testSchemaBeforeAdvice(){
     System.out.println("======================================");
     ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
     IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
     helloworldService.sayBefore("before");
    System.out.println("======================================");
}

将输入：

==========================================
===========before advice param:before
============say before
=========================================

分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayBefore(..)) ”匹配目标方法sayBefore，且使用“args(param)”匹配目标方法只有一个参数且传入的参数类型为通知实现方法中同名的参数类型；

2）目标方法定义：使用method=" beforeAdvice(java.lang.String) "指定前置通知实现方法，且该通知有一个参数类型为java.lang.String参数；

3）目标方法参数命名：其中使用arg-names=" param "指定通知实现方法参数名为“param”，切入点中使用“args(param)”匹配的目标方法参数将自动传递给通知实现方法同名参数。

 

二、后置返回通知：在切入点选择的方法正常返回时执行，通过<aop:aspect>标签下的<aop:after-returning>标签声明：

java代码：

<aop:after-returning pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
    method="后置返回通知实现方法名"
    arg-names="后置返回通知实现方法参数列表参数名字"
    returning="返回值对应的后置返回通知实现方法参数名"
/>

pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

returning：定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法执行正常返回后，将把目标方法返回值传给通知方法；returning限定了只有目标方法返回值匹配与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

public boolean sayAfterReturning();

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public boolean sayAfterReturning() {
    System.out.println("============after returning");
    return true;
}

第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：

java代码：

public void afterReturningAdvice(Object retVal) {
    System.out.println("===========after returning advice retVal:" + retVal);
}

最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：

java代码：

<aop:after-returning pointcut="execution(* cn.javass..*.sayAfterReturning(..))"
                                method="afterReturningAdvice"
                               arg-names="retVal"
                               returning="retVal"/>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test
public void testSchemaAfterReturningAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterReturning();
    System.out.println("======================================");
}

将输入：

======================================
============after returning
===========after returning advice retVal:true
======================================

分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterReturning(..)) ”匹配目标方法sayAfterReturning，该方法返回true；

2）目标方法定义：使用method="afterReturningAdvice"指定后置返回通知实现方法；

3）目标方法参数命名：其中使用arg-names="retVal"指定通知实现方法参数名为“retVal”；

4）返回值命名：returning="retVal"用于将目标返回值赋值给通知实现方法参数名为“retVal”的参数上。

三、后置异常通知：在切入点选择的方法抛出异常时执行，通过<aop:aspect>标签下的<aop:after-throwing>标签声明：

java代码：

<aop:after-throwing pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
                                method="后置异常通知实现方法名"
                                arg-names="后置异常通知实现方法参数列表参数名字"
                                throwing="将抛出的异常赋值给的通知实现方法参数名"/>

pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

throwing：定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法；throwing限定了只有目标方法抛出的异常匹配与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行，对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

public void sayAfterThrowing();

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public void sayAfterThrowing() {
    System.out.println("============before throwing");
    throw new RuntimeException();
}

第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：

java代码：

public void afterThrowingAdvice(Exception exception) {
  System.out.println("===========after throwing advice exception:" + exception);
}

最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：

java代码：

<aop:after-throwing pointcut="execution(* cn.javass..*.sayAfterThrowing(..))"
                                method="afterThrowingAdvice"
                                arg-names="exception"
                                throwing="exception"/>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test(expected = RuntimeException.class)
public void testSchemaAfterThrowingAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterThrowing();
    System.out.println("======================================");
}

将输入：

======================================

============before throwing

===========after throwing advice exception:java.lang.RuntimeException

======================================

分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterThrowing(..))”匹配目标方法sayAfterThrowing，该方法将抛出RuntimeException异常；

2）目标方法定义：使用method="afterThrowingAdvice"指定后置异常通知实现方法；

3）目标方法参数命名：其中使用arg-names="exception"指定通知实现方法参数名为“exception”；

4）异常命名：returning="exception"用于将目标方法抛出的异常赋值给通知实现方法参数名为“exception”的参数上。

四、后置最终通知：在切入点选择的方法返回时执行，不管是正常返回还是抛出异常都执行，通过<aop:aspect>标签下的<aop:after >标签声明：

java代码：

<aop:after pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
                  method="后置最终通知实现方法名"
                  arg-names="后置最终通知实现方法参数列表参数名字"/>

pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

public boolean sayAfterFinally();

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public boolean sayAfterFinally() {
        System.out.println("============before finally");
        throw new RuntimeException();
}

第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：

java代码：

public void afterFinallyAdvice() {
        System.out.println("===========after finally advice");
}

最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：

java代码：

<aop:after pointcut="execution(* cn.javass..*.sayAfterFinally(..))"
         method="afterFinallyAdvice"/>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test(expected = RuntimeException.class)
public void testSchemaAfterFinallyAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAfterFinally();
    System.out.println("======================================");
}

将输入：

======================================

============before finally

===========after finally advice

======================================

分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAfterFinally(..))”匹配目标方法sayAfterFinally，该方法将抛出RuntimeException异常；

2）目标方法定义：使用method=" afterFinallyAdvice "指定后置最终通知实现方法。

五、环绕通知：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值，可通过<aop:aspect>标签下的<aop:around >标签声明：

java代码：

<aop:around pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"
                     method="后置最终通知实现方法名"
                     arg-names="后置最终通知实现方法参数列表参数名字"/>

pointcut和pointcut-ref：同前置通知同义；

method：同前置通知同义；

arg-names：同前置通知同义；

环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型，在通知实现方法内部使用ProceedingJoinPoint的proceed()方法使目标方法执行，proceed 方法可以传入可选的Object[]数组，该数组的值将被作为目标方法执行时的参数。

 

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

  1. public void sayAround(String param);

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public void sayAround(String param) {
   System.out.println("============around param:" + param);
}

第三在cn.javass.spring.chapter6.aop. HelloWorldAspect定义通知实现：

java代码：

public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("===========around before advice");
    Object retVal = pjp.proceed(new Object[] {"replace"});
    System.out.println("===========around after advice");
    return retVal;
}

最后在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：

java代码：

<aop:around pointcut="execution(* cn.javass..*.sayAround(..))"
           method="aroundAdvice"/>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test
public void testSchemaAroundAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IHelloWorldService helloworldService =
    ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayAround("haha");
    System.out.println("======================================");
}

将输入：

======================================

===========around before advice

============around param:replace

===========around after advice

======================================

分析一下吧：

1）切入点匹配：在配置中使用“execution(* cn.javass..*.sayAround(..))”匹配目标方法sayAround；

2）目标方法定义：使用method="aroundAdvice"指定环绕通知实现方法，在该实现中，第一个方法参数为pjp，类型为ProceedingJoinPoint，其中“Object retVal = pjp.proceed(new Object[] {"replace"});”，用于执行目标方法，且目标方法参数被“new Object[] {"replace"}”替换，最后返回“retVal ”返回值。

3）测试：我们使用“helloworldService.sayAround("haha");”传入参数为“haha”，但最终输出为“replace”，说明参数被替换了。

6.3.4  引入

Spring引入允许为目标对象引入新的接口，通过在< aop:aspect>标签内使用< aop:declare-parents>标签进行引入，定义方式如下：

java代码：

<aop:declare-parents
          types-matching="AspectJ语法类型表达式"
          implement-interface=引入的接口"
          default-impl="引入接口的默认实现"
          delegate-ref="引入接口的默认实现Bean引用"/>

types-matching：匹配需要引入接口的目标对象的AspectJ语法类型表达式；

implement-interface：定义需要引入的接口；

default-impl和delegate-ref：定义引入接口的默认实现，二者选一，default-impl是接口的默认实现类全限定名，而delegate-ref是默认的实现的委托Bean名；

接下来让我们练习一下吧：

首先定义引入的接口及默认实现：

java代码：

package cn.javass.spring.chapter6.service;
public interface IIntroductionService {
    public void induct();
}

java代码：

package cn.javass.spring.chapter6.service.impl;
import cn.javass.spring.chapter6.service.IIntroductionService;
public class IntroductiondService implements IIntroductionService {
    @Override
    public void induct() {
        System.out.println("=========introduction");
    }
}

其次在chapter6/advice.xml配置文件中接着前置通知配置的例子添加如下配置：

java代码：

<aop:declare-parents
    types-matching="cn.javass..*.IHelloWorldService+"
    implement-interface="cn.javass.spring.chapter6.service.IIntroductionService"
    default-impl="cn.javass.spring.chapter6.service.impl.IntroductiondService"/>

最后测试一下吧，测试代码cn.javass.spring.chapter6.AopTest：

java代码：

@Test
public void testSchemaIntroduction() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
    IIntroductionService introductionService =
    ctx.getBean("helloWorldService", IIntroductionService.class);
    introductionService.induct();
    System.out.println("======================================");
}

将输出：

======================================

=========introduction

======================================

分析一下吧：

1）目标对象类型匹配：使用types-matching="cn.javass..*.IHelloWorldService+"匹配IHelloWorldService接口的子类型，如HelloWorldService实现；

2）引入接口定义：通过implement-interface属性表示引入的接口，如“cn.javass.spring.chapter6.service.IIntroductionService”。

3）引入接口的实现：通过default-impl属性指定，如“cn.javass.spring.chapter6.service.impl.IntroductiondService”，也可以使用“delegate-ref”来指定实现的Bean。

4）获取引入接口：如使用“ctx.getBean("helloWorldService", IIntroductionService.class);”可直接获取到引入的接口。

6.3.5 Advisor

Advisor表示只有一个通知和一个切入点的切面，由于Spring AOP都是基于AOP联盟的拦截器模型的环绕通知的，所以引入Advisor来支持各种通知类型（如前置通知等5种），Advisor概念来自于Spring1.2对AOP的支持，在AspectJ中没有相应的概念对应。

Advisor可以使用<aop:config>标签下的<aop:advisor>标签定义：

java代码：

<aop:advisor pointcut="切入点表达式" pointcut-ref="切入点Bean引用"
                     advice-ref="通知API实现引用"/>

pointcut和pointcut-ref：二者选一，指定切入点表达式；

advice-ref：引用通知API实现Bean，如前置通知接口为MethodBeforeAdvice；

接下来让我们看一下示例吧：

首先在cn.javass.spring.chapter6.service.IhelloWorldService定义一个测试方法：

java代码：

public void sayAdvisorBefore(String param);

其次在cn.javass.spring.chapter6.service.impl. HelloWorldService定义实现

java代码：

@Override
public void sayAdvisorBefore(String param) {
    System.out.println("============say " + param);
}

第三定义前置通知API实现：

java代码：

package cn.javass.spring.chapter6.aop;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdviceImpl implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println("===========before advice");
    }
}

在chapter6/advice.xml配置文件中先添加通知实现Bean定义：

java代码：

<bean id="beforeAdvice" class="cn.javass.spring.chapter6.aop.BeforeAdviceImpl"/>

然后在<aop:config>标签下，添加Advisor定义，添加时注意顺序：

java代码：

<aop:advisor pointcut="execution(* cn.javass..*.sayAdvisorBefore(..))"
                     advice-ref="beforeAdvice"/>

测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test
public void testSchemaAdvisor() {
   System.out.println("======================================");
   ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");
   IHelloWorldService helloworldService =
   ctx.getBean("helloWorldService", IHelloWorldService.class);
   helloworldService.sayAdvisorBefore("haha");
   System.out.println("======================================");
}

将输出：

 
 

======================================

===========before advice

============say haha

======================================

Spring除了支持Schema方式配置AOP，还支持注解方式：使用@AspectJ风格的切面声明。

AOP 之 6.4 基于@AspectJ的AOP

6.4.1  启用对@AspectJ的支持

Spring默认不支持@AspectJ风格的切面声明，为了支持需要使用如下配置：

java代码：

<aop:aspectj-autoproxy/>

这样Spring就能发现@AspectJ风格的切面并且将切面应用到目标对象。

6.4.2  声明切面

@AspectJ风格的声明切面非常简单，使用@Aspect注解进行声明：

java代码：

@Aspect()
Public class Aspect{
……
}

然后将该切面在配置文件中声明为Bean后，Spring就能自动识别并进行AOP方面的配置：

java代码：

<bean id="aspect" class="……Aspect"/>

该切面就是一个POJO，可以在该切面中进行切入点及通知定义，接着往下看吧。

6.4.3  声明切入点

@AspectJ风格的命名切入点使用org.aspectj.lang.annotation包下的@Pointcut+方法（方法必须是返回void类型）实现。

java代码：

@Pointcut(value="切入点表达式", argNames = "参数名列表")
public void pointcutName(……) {}

value：指定切入点表达式；

argNames：指定命名切入点方法参数列表参数名字，可以有多个用“，”分隔，这些参数将传递给通知方法同名的参数，同时比如切入点表达式“args(param)”将匹配参数类型为命名切入点方法同名参数指定的参数类型。

pointcutName：切入点名字，可以使用该名字进行引用该切入点表达式。

java代码：

@Pointcut(value="execution(* cn.javass..*.sayAdvisorBefore(..)) && args(param)", argNames = "param")
public void beforePointcut(String param) {}

定义了一个切入点，名字为“beforePointcut”，该切入点将匹配目标方法的第一个参数类型为通知方法实现中参数名为“param”的参数类型。

6.4.4  声明通知

@AspectJ风格的声明通知也支持5种通知类型：

一、前置通知：使用org.aspectj.lang.annotation 包下的@Before注解声明；

java代码：

@Before(value = "切入点表达式或命名切入点", argNames = "参数列表参数名")

value：指定切入点表达式或命名切入点；

argNames：与Schema方式配置中的同义。

 

接下来示例一下吧：

1、定义接口和实现，在此我们就使用Schema风格时的定义；

2、定义切面：

java代码：

package cn.javass.spring.chapter6.aop;
import org.aspectj.lang.annotation.Aspect;
@Aspect
public class HelloWorldAspect2 {  

}

3、定义切入点：

java代码：

@Pointcut(value="execution(* cn.javass..*.sayAdvisorBefore(..)) && args(param)", argNames = "param")
public void beforePointcut(String param) {}

4、定义通知

java代码：

@Before(value = "beforePointcut(param)", argNames = "param")
public void beforeAdvice(String param) {
    System.out.println("===========before advice param:" + param);
}

5、在chapter6/advice2.xml配置文件中进行如下配置：

java代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="
           http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  

  <aop:aspectj-autoproxy/>
  <bean id="helloWorldService"
            class="cn.javass.spring.chapter6.service.impl.HelloWorldService"/>  

  <bean id="aspect"
             class="cn.javass.spring.chapter6.aop.HelloWorldAspect2"/>  

</beans>

6、测试代码cn.javass.spring.chapter6.AopTest:

java代码：

@Test
public void testAnnotationBeforeAdvice() {
    System.out.println("======================================");
    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice2.xml");
    IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);
    helloworldService.sayBefore("before");
    System.out.println("======================================");
}

将输出：

 
 

==========================================

===========before advice param:before

============say before

==========================================

切面、切入点、通知全部使用注解完成：

1）使用@Aspect将POJO声明为切面；

2）使用@Pointcut进行命名切入点声明，同时指定目标方法第一个参数类型必须是java.lang.String，对于其他匹配的方法但参数类型不一致的将也是不匹配的，通过argNames = "param"指定了将把该匹配的目标方法参数传递给通知同名的参数上；

3）使用@Before进行前置通知声明，其中value用于定义切入点表达式或引用命名切入点；

4）配置文件需要使用<aop:aspectj-autoproxy/>来开启注解风格的@AspectJ支持；

5）需要将切面注册为Bean，如“aspect”Bean；

6）测试代码完全一样。

二、后置返回通知：使用org.aspectj.lang.annotation 包下的@AfterReturning注解声明；

java代码：

@AfterReturning(
value="切入点表达式或命名切入点",
pointcut="切入点表达式或命名切入点",
argNames="参数列表参数名",
returning="返回值对应参数名")

value：指定切入点表达式或命名切入点；

pointcut：同样是指定切入点表达式或命名切入点，如果指定了将覆盖value属性指定的，pointcut具有高优先级；

argNames：与Schema方式配置中的同义；

returning：与Schema方式配置中的同义。

java代码：

@AfterReturning(
    value="execution(* cn.javass..*.sayBefore(..))",
    pointcut="execution(* cn.javass..*.sayAfterReturning(..))",
    argNames="retVal", returning="retVal")
public void afterReturningAdvice(Object retVal) {
    System.out.println("===========after returning advice retVal:" + retVal);
}

其中测试代码与Schema方式几乎一样，在此就不演示了，如果需要请参考AopTest.java中的testAnnotationAfterReturningAdvice测试方法。

 

三、后置异常通知：使用org.aspectj.lang.annotation 包下的@AfterThrowing注解声明；

java代码：

@AfterThrowing (
value="切入点表达式或命名切入点",
pointcut="切入点表达式或命名切入点",
argNames="参数列表参数名",
throwing="异常对应参数名")

value：指定切入点表达式或命名切入点；

pointcut：同样是指定切入点表达式或命名切入点，如果指定了将覆盖value属性指定的，pointcut具有高优先级；

argNames：与Schema方式配置中的同义；

throwing：与Schema方式配置中的同义。

java代码：

@AfterThrowing(
    value="execution(* cn.javass..*.sayAfterThrowing(..))",
    argNames="exception", throwing="exception")
public void afterThrowingAdvice(Exception exception) {
    System.out.println("===========after throwing advice exception:" + exception);
}

其中测试代码与Schema方式几乎一样，在此就不演示了，如果需要请参考AopTest.java中的testAnnotationAfterThrowingAdvice测试方法。

四、后置最终通知：使用org.aspectj.lang.annotation 包下的@After注解声明；

java代码：

@After (
value="切入点表达式或命名切入点",
argNames="参数列表参数名")

value：指定切入点表达式或命名切入点；

argNames：与Schema方式配置中的同义；

java代码：

@After(value="execution(* cn.javass..*.sayAfterFinally(..))")
public void afterFinallyAdvice() {
    System.out.println("===========after finally advice");
}

其中测试代码与Schema方式几乎一样，在此就不演示了，如果需要请参考AopTest.java中的testAnnotationAfterFinallyAdvice测试方法。

五、环绕通知：使用org.aspectj.lang.annotation 包下的@Around注解声明；

java代码：

@Around (
value="切入点表达式或命名切入点",
argNames="参数列表参数名")

value：指定切入点表达式或命名切入点；

argNames：与Schema方式配置中的同义；

java代码：

@Around(value="execution(* cn.javass..*.sayAround(..))")
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("===========around before advice");
    Object retVal = pjp.proceed(new Object[] {"replace"});
    System.out.println("===========around after advice");
    return retVal;
}

其中测试代码与Schema方式几乎一样，在此就不演示了，如果需要请参考AopTest.java中的annotationAroundAdviceTest测试方法。

6.4.5  引入

@AspectJ风格的引入声明在切面中使用org.aspectj.lang.annotation包下的@DeclareParents声明：

java代码：

@DeclareParents(
value=" AspectJ语法类型表达式",
defaultImpl=引入接口的默认实现类)
private Interface interface;

value：匹配需要引入接口的目标对象的AspectJ语法类型表达式；与Schema方式中的types-matching属性同义；

private Interface interface：指定需要引入的接口；

defaultImpl：指定引入接口的默认实现类，没有与Schema方式中的delegate-ref属性同义的定义方式；

java代码：

@DeclareParents(
    value="cn.javass..*.IHelloWorldService+", defaultImpl=cn.javass.spring.chapter6.service.impl.IntroductiondService.class)
private IIntroductionService introductionService;

其中测试代码与Schema方式几乎一样，在此就不演示了，如果需要请参考AopTest.java中的testAnnotationIntroduction测试方法。

AOP 之 6.5 AspectJ切入点语法详解

6.5.1  Spring AOP支持的AspectJ切入点指示符

切入点指示符用来指示切入点表达式目的，，在Spring AOP中目前只有执行方法这一个连接点，Spring AOP支持的AspectJ切入点指示符如下：

execution：用于匹配方法执行的连接点；

         within：用于匹配指定类型内的方法执行；

         this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；

         target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；

         args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；

         @within：用于匹配所以持有指定注解类型内的方法；

         @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；

         @args：用于匹配当前执行的方法传入的参数持有指定注解的执行；

         @annotation：用于匹配当前执行方法持有指定注解的方法；

         bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法；

         reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持。

AspectJ切入点支持的切入点指示符还有： call、get、set、preinitialization、staticinitialization、initialization、handler、adviceexecution、withincode、cflow、cflowbelow、if、@this、@withincode；但Spring AOP目前不支持这些指示符，使用这些指示符将抛出IllegalArgumentException异常。这些指示符Spring AOP可能会在以后进行扩展。

6.5.1  命名及匿名切入点

命名切入点可以被其他切入点引用，而匿名切入点是不可以的。

只有@AspectJ支持命名切入点，而Schema风格不支持命名切入点。

如下所示，@AspectJ使用如下方式引用命名切入点：

6.5.2        ；类型匹配语法

首先让我们来了解下AspectJ类型匹配的通配符：

* ：匹配任何数量字符；

.. ：（两个点）匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。

+ ：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

 

java.lang.String    匹配String类型；

java.*.String         匹配java包下的任何“一级子包”下的String类型；

如匹配java.lang.String，但不匹配java.lang.ss.String

java..*                  匹配java包及任何子包下的任何类型;

如匹配java.lang.String、java.lang.annotation.Annotation

java.lang.*ing      匹配任何java.lang包下的以ing结尾的类型；

java.lang.Number+  匹配java.lang包下的任何Number的自类型；

如匹配java.lang.Integer，也匹配java.math.BigInteger

 

接下来再看一下具体的匹配表达式类型吧：

匹配类型：使用如下方式匹配

 
 

注解？ 类的全限定名字

  • 注解：可选，类型上持有的注解，如@Deprecated；
  • 类的全限定名：必填，可以是任何类全限定名。

匹配方法执行：使用如下方式匹配：

 
 

注解？ 修饰符? 返回值类型 类型声明?方法名(参数列表) 异常列表？

  •  
  • 注解：可选，方法上持有的注解，如@Deprecated；
  • 修饰符：可选，如public、protected；
  • 返回值类型：必填，可以是任何类型模式；“*”表示所有类型；
  • 类型声明：可选，可以是任何类型模式；
  • 方法名：必填，可以使用“*”进行模式匹配；
  • 参数列表：“()”表示方法没有任何参数；“(..)”表示匹配接受任意个参数的方法，“(..,java.lang.String)”表示匹配接受java.lang.String类型的参数结束，且其前边可以接受有任意个参数的方法；“(java.lang.String,..)” 表示匹配接受java.lang.String类型的参数开始，且其后边可以接受任意个参数的方法；“(*,java.lang.String)” 表示匹配接受java.lang.String类型的参数结束，且其前边接受有一个任意类型参数的方法；
  • 异常列表：可选，以“throws 异常全限定名列表”声明，异常全限定名列表如有多个以“，”分割，如throws java.lang.IllegalArgumentException, java.lang.ArrayIndexOutOfBoundsException。

匹配Bean名称：可以使用Bean的id或name进行匹配，并且可使用通配符“*”；

6.5.3  组合切入点表达式

AspectJ使用 且（&&）、或（||）、非（！）来组合切入点表达式。

在Schema风格下，由于在XML中使用“&&”需要使用转义字符“&amp;&amp;”来代替之，所以很不方便，因此Spring ASP 提供了and、or、not来代替&&、||、！。

6.5.4  切入点使用示例

       一、execution：使用“execution(方法表达式)”匹配方法执行；

 


模式
描述

public * *(..)
任何公共方法的执行

* cn.javass..IPointcutService.*()
cn.javass包及所有子包下IPointcutService接口中的任何无参方法

* cn.javass..*.*(..)
cn.javass包及所有子包下任何类的任何方法

* cn.javass..IPointcutService.*(*)
cn.javass包及所有子包下IPointcutService接口的任何只有一个参数方法

* (!cn.javass..IPointcutService+).*(..)
非“cn.javass包及所有子包下IPointcutService接口及子类型”的任何方法

* cn.javass..IPointcutService+.*()
cn.javass包及所有子包下IPointcutService接口及子类型的的任何无参方法

* cn.javass..IPointcut*.test*(java.util.Date)
cn.javass包及所有子包下IPointcut前缀类型的的以test开头的只有一个参数类型为java.util.Date的方法，注意该匹配是根据方法签名的参数类型进行匹配的，而不是根据执行时传入的参数类型决定的

如定义方法：public void test(Object obj);即使执行时传入java.util.Date，也不会匹配的；

* cn.javass..IPointcut*.test*(..)  throws

IllegalArgumentException, ArrayIndexOutOfBoundsException
cn.javass包及所有子包下IPointcut前缀类型的的任何方法，且抛出IllegalArgumentException和ArrayIndexOutOfBoundsException异常

* (cn.javass..IPointcutService+

&& java.io.Serializable+).*(..)
任何实现了cn.javass包及所有子包下IPointcutService接口和java.io.Serializable接口的类型的任何方法

@java.lang.Deprecated * *(..)
任何持有@java.lang.Deprecated注解的方法

@java.lang.Deprecated @cn.javass..Secure  * *(..)
任何持有@java.lang.Deprecated和@cn.javass..Secure注解的方法

@(java.lang.Deprecated || cn.javass..Secure) * *(..)
任何持有@java.lang.Deprecated或@ cn.javass..Secure注解的方法

(@cn.javass..Secure  *)  *(..)
任何返回值类型持有@cn.javass..Secure的方法

*  (@cn.javass..Secure *).*(..)
任何定义方法的类型持有@cn.javass..Secure的方法

* *(@cn.javass..Secure (*) , @cn.javass..Secure (*))
任何签名带有两个参数的方法，且这个两个参数都被@ Secure标记了，

如public void test(@Secure String str1,

@Secure String str1);

* *((@ cn.javass..Secure *))或

* *(@ cn.javass..Secure *)
任何带有一个参数的方法，且该参数类型持有@ cn.javass..Secure；

如public void test(Model model);且Model类上持有@Secure注解

* *(

@cn.javass..Secure (@cn.javass..Secure *) ,

@ cn.javass..Secure (@cn.javass..Secure *))
任何带有两个参数的方法，且这两个参数都被@ cn.javass..Secure标记了；且这两个参数的类型上都持有@ cn.javass..Secure；

* *(

java.util.Map<cn.javass..Model, cn.javass..Model>

, ..)
任何带有一个java.util.Map参数的方法，且该参数类型是以< cn.javass..Model, cn.javass..Model >为泛型参数；注意只匹配第一个参数为java.util.Map,不包括子类型；

如public void test(HashMap<Model, Model> map, String str);将不匹配，必须使用“* *(

java.util.HashMap<cn.javass..Model,cn.javass..Model>

, ..)”进行匹配；

而public void test(Map map, int i);也将不匹配，因为泛型参数不匹配

* *(java.util.Collection<@cn.javass..Secure *>)
任何带有一个参数（类型为java.util.Collection）的方法，且该参数类型是有一个泛型参数，该泛型参数类型上持有@cn.javass..Secure注解；

如public void test(Collection<Model> collection);Model类型上持有@cn.javass..Secure

* *(java.util.Set<? extends HashMap>)
任何带有一个参数的方法，且传入的参数类型是有一个泛型参数，该泛型参数类型继承与HashMap；

Spring AOP目前测试不能正常工作

* *(java.util.List<? super HashMap>)
任何带有一个参数的方法，且传入的参数类型是有一个泛型参数，该泛型参数类型是HashMap的基类型；如public voi test(Map map)；

Spring AOP目前测试不能正常工作

* *(*<@cn.javass..Secure *>)
任何带有一个参数的方法，且该参数类型是有一个泛型参数，该泛型参数类型上持有@cn.javass..Secure注解；

Spring AOP目前测试不能正常工作

 

二、within：使用“within(类型表达式)”匹配指定类型内的方法执行；


模式
描述

within(cn.javass..*)
cn.javass包及子包下的任何方法执行

within(cn.javass..IPointcutService+)
cn.javass包或所有子包下IPointcutService类型及子类型的任何方法

within(@cn.javass..Secure *)
持有cn.javass..Secure注解的任何类型的任何方法

必须是在目标对象上声明这个注解，在接口上声明的对它不起作用

 

三、this：使用“this(类型全限定名)”匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口方法也可以匹配；注意this中使用的表达式必须是类型全限定名，不支持通配符；

 


模式
描述

this(cn.javass.spring.chapter6.service.IPointcutService)
当前AOP对象实现了 IPointcutService接口的任何方法

this(cn.javass.spring.chapter6.service.IIntroductionService)
当前AOP对象实现了 IIntroductionService接口的任何方法

也可能是引入接口

 

四、target：使用“target(类型全限定名)”匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；注意target中使用的表达式必须是类型全限定名，不支持通配符；


模式
描述

target(cn.javass.spring.chapter6.service.IPointcutService)
当前目标对象（非AOP对象）实现了 IPointcutService接口的任何方法

target(cn.javass.spring.chapter6.service.IIntroductionService)
当前目标对象（非AOP对象） 实现了IIntroductionService 接口的任何方法

不可能是引入接口

 

五、args：使用“args(参数类型列表)”匹配当前执行的方法传入的参数为指定类型的执行方法；注意是匹配传入的参数类型，不是匹配方法签名的参数类型；参数类型列表中的参数必须是类型全限定名，通配符不支持；args属于动态切入点，这种切入点开销非常大，非特殊情况最好不要使用；


模式
描述

args (java.io.Serializable,..)
任何一个以接受“传入参数类型为 java.io.Serializable” 开头，且其后可跟任意个任意类型的参数的方法执行，args指定的参数类型是在运行时动态匹配的

 

六、@within：使用“@within(注解类型)”匹配所以持有指定注解类型内的方法；注解类型也必须是全限定类型名；


模式
描述

@within cn.javass.spring.chapter6.Secure)
任何目标对象对应的类型持有Secure注解的类方法；

必须是在目标对象上声明这个注解，在接口上声明的对它不起作用

 

七、@target：使用“@target(注解类型)”匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；注解类型也必须是全限定类型名； 


模式
描述

@target (cn.javass.spring.chapter6.Secure)
任何目标对象持有Secure注解的类方法；

必须是在目标对象上声明这个注解，在接口上声明的对它不起作用

 

八、@args：使用“@args(注解列表)”匹配当前执行的方法传入的参数持有指定注解的执行；注解类型也必须是全限定类型名；


模式
描述

@args (cn.javass.spring.chapter6.Secure)
任何一个只接受一个参数的方法，且方法运行时传入的参数持有注解 cn.javass.spring.chapter6.Secure；动态切入点，类似于arg指示符；

 

九、@annotation：使用“@annotation(注解类型)”匹配当前执行方法持有指定注解的方法；注解类型也必须是全限定类型名；


模式
描述

@annotation(cn.javass.spring.chapter6.Secure )
当前执行方法上持有注解 cn.javass.spring.chapter6.Secure将被匹配

 

十、bean：使用“bean(Bean id或名字通配符)”匹配特定名称的Bean对象的执行方法；Spring ASP扩展的，在AspectJ中无相应概念；


模式
描述

bean(*Service)
匹配所有以Service命名（id或name）结尾的Bean

 

十一、reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持，如下所示：

 

       比如我们定义如下切面：

java代码：

Java代码  

  1. package cn.javass.spring.chapter6.aop;
  2. import org.aspectj.lang.annotation.Aspect;
  3. import org.aspectj.lang.annotation.Pointcut;
  4. @Aspect
  5. public class ReferencePointcutAspect {
  6. @Pointcut(value="execution(* *())")
  7. public void pointcut() {}
  8. }

可以通过如下方式引用：

java代码：

Java代码  

  1. @Before(value = "cn.javass.spring.chapter6.aop.ReferencePointcutAspect.pointcut()")
  2. public void referencePointcutTest2(JoinPoint jp) {}

除了可以在@AspectJ风格的切面内引用外，也可以在Schema风格的切面定义内引用，引用方式与@AspectJ完全一样。

 

到此我们切入点表达式语法示例就介绍完了，我们这些示例几乎包含了日常开发中的所有情况，但当然还有更复杂的语法等等，如果以上介绍的不能满足您的需要，请参考AspectJ文档。

由于测试代码相当长，所以为了节约篇幅本示例代码在cn.javass.spring.chapter6. PointcutTest文件中，需要时请参考该文件。

spring--AOP1--6

时间： 2024-10-10 06:11:04

spring--AOP1--6的相关文章

spring Aop1

工 作忙,时间紧,不过事情再多,学习是必须的.记得以前的部门老大说过:“开发人员不可能一天到晚只有工作,肯定是需要自我学习.第一:为了更充实自己,保 持进步状态.第二:为了提升技术,提高开发能力.第三:保持程序员对技术和学习的热情,工作的激情.程序员还是需要把基础打扎实,修炼自己的内功.” 所以赶紧把学习的东西总结一下,加深印象.之前有说了下AOP的原理 (http://www.cnblogs.com/yanbincn/archive/2012/06/01/2530377.html) .基于代理

Spring中的AOP（五）——在Advice方法中获取目标方法的参数

摘要: 本文介绍使用Spring AOP编程中,在增强处理方法中获取目标方法的参数,定义切点表达式时使用args来快速获取目标方法的参数. 获取目标方法的信息 访问目标方法最简单的做法是定义增强处理方法时,将第一个参数定义为JoinPoint类型,当该增强处理方法被调用时,该JoinPoint参数就代表了织入增强处理的连接点.JoinPoint里包含了如下几个常用的方法: Object[] getArgs:返回目标方法的参数 Signature getSignature:返回目标方法的签名 Ob

Spring框架笔记（二十三）——基于配置文件的方式来配置 AOP

配置实现IOC功能时,我们采用了配置文件xml和注解两类方式实现.实现AOP功能时我们也可以使用两种方式.前面我们介绍了AOP基于注解的实现方式,本文我将采用基于配置文件的方式完成从原始对象bean.切面bean.切点及通知配置的方法. 用基于 XML 的配置声明切面 除了使用 AspectJ 注解声明切面, Spring 也支持在 Bean 配置文件中声明切面. 这种声明是通过 aop schema 中的 XML 元素完成的. 正常情况下, 基于注解的声明要优先于基于 XML 的声明. 通过

Spring boot中使用aop详解

版权声明:本文为博主武伟峰原创文章,转载请注明地址http://blog.csdn.net/tianyaleixiaowu. aop是spring的两大功能模块之一,功能非常强大,为解耦提供了非常优秀的解决方案. 现在就以springboot中aop的使用来了解一下aop. 一:使用aop来完成全局请求日志处理 创建一个springboot的web项目,勾选aop,pom如下: [html] view plain copy print? <?xml version="1.0" e

Spring多个AOP执行先后顺序

Spring声明式事务是基于AOP实现的,那么,如果我们在同一个方法自定义多个AOP,我们如何指定他们的执行顺序呢?首先:配置AOP执行顺序的三种方式: 1.通过实现org.springframework.core.Ordered接口 [email protected]?? [email protected]?? [email protected]?? 4.public?class?MessageQueueAopAspect1?implements?Ordered{@Override?? 5.?

Spring源码窥探之：注解方式的AOP原理

AOP入口代码分析 通过注解的方式来实现AOP1. @EnableAspectJAutoProxy通过@Import注解向容器中注入了AspectJAutoProxyRegistrar这个类,而它在容器中的名字是org.springframework.aop.config.internalAutoProxyCreator.2. AspectJAutoProxyRegistrar实现了ImportBeanDefinitionRegistrar接口,所以可以向容器中注册Bean的定义信息.3. 通过

spring学习5：基于注解实现spring的aop

目录 spring学习5:基于注解实现spring的aop 一.基于注解+xml实现 1.1 在配置文件中开启spring对注解aop的支持 1.2 把通知类用注解配置到容器中,并用注解声明为切面 1.3 定义切入点表达式 1.4 定义通知 二.基于纯注解实现 三.多个aop的执行顺序 1.xml配置 2.注解配置 3.注意 spring学习5:基于注解实现spring的aop 上一节学习了spring aop的基本概念和如何基于xml配置来实现aop功能.这一节来学习下如何用注解实现aop 一

Spring事务管理（详解+实例）

写这篇博客之前我首先读了<Spring in action>,之后在网上看了一些关于Spring事务管理的文章,感觉都没有讲全,这里就将书上的和网上关于事务的知识总结一下,参考的文章如下: Spring事务机制详解 Spring事务配置的五种方式 Spring中的事务管理实例详解 1 初步理解 理解事务之前,先讲一个你日常生活中最常干的事:取钱. 比如你去ATM机取1000块钱,大体有两个步骤:首先输入密码金额,银行卡扣掉1000元钱:然后ATM出1000元钱.这两个步骤必须是要么都执行要么都

SSM整合（spring,spirngmvc,mybatis）

整合思路   准备环境:导入jar包(spring mybatis  dbcp连接池  mysql驱动包 log4j) 工程结构: --------------------------- 1.  整合dao mybatis和spring进行整合   applicationContext-dao.xml 配置: 1.数据源 2.SqlSessionFactory 3.mapper扫描器 创建po以及mapper(通过逆向工程,这里不再演示) 针对综合查询mapper,一般情况会有关联查询,建议自定

Spring Boot 热部署

需要在pom.xml文件中加如下代码: 1 <dependencies> 2 <dependency> 3 <groupId>org.springframework.boot</groupId> 4 <artifactId>spring-boot-devtools</artifactId> 5 <optional>true</optional> 6 </dependency> 7 </depe