Spring详解------------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!吧。

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代码：

查看复制到剪贴板打印

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

 

       2）定义目标接口实现：

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter6.service.impl;  
2. import cn.javass.spring.chapter6.service.IHelloWorldService;  
3. public class HelloWorldService implements IHelloWorldService {  
4.     @Override  
5.     public void sayHello() {  
6.         System.out.println("============Hello World!");  
7.     }  
8. }  
9.    

 

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

6.2.2  定义切面支持类

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

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter6.aop;  
2. public class HelloWorldAspect {  
3.        //前置通知  
4.     public void beforeAdvice() {  
5.         System.out.println("===========before advice");  
6. }  
7. //后置最终通知  
8.     public void afterFinallyAdvice() {  
9.         System.out.println("===========after finally advice");  
10.     }  
11. }  

 

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

 

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

6.2.3  在XML中进行配置

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

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

 

java代码：

查看复制到剪贴板打印

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <beans  xmlns="http://www.springframework.org/schema/beans"  
3.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
4.         xmlns:aop="http://www.springframework.org/schema/aop"  
5.         xsi:schemaLocation="  
6.            http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
8.            http://www.springframework.org/schema/aop  
9.            http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">  
10. </beans>  
11.    

 

 

       2）配置目标类：

 

java代码：

查看复制到剪贴板打印

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

 

       3）配置切面：

 

java代码：

查看复制到剪贴板打印

1. <bean id="aspect" class="cn.javass.spring.chapter6.aop.HelloWorldAspect"/>  
2. <aop:config>  
3. <aop:pointcut id="pointcut" expression="execution(* cn.javass..*.*(..))"/>  
4.     <aop:aspect ref="aspect">  
5.         <aop:before pointcut-ref="pointcut" method="beforeAdvice"/>  
6.         <aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterFinallyAdvice"/>  
7.     </aop:aspect>  
8. </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代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter6;  
2. import org.junit.Test;  
3. import org.springframework.context.ApplicationContext;  
4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
5. import cn.javass.spring.chapter6.service.IHelloWorldService;  
6. import cn.javass.spring.chapter6.service.IPayService;  
7. public class AopTest {  
8.     @Test  
9.     public void testHelloworld() {  
10.         ApplicationContext ctx =  new ClassPathXmlApplicationContext("chapter6/helloworld.xml");  
11.         IHelloWorldService helloworldService =  
12.         ctx.getBean("helloWorldService", IHelloWorldService.class);  
13.         helloworldService.sayHello();  
14.     }  
15. }  
16.    

 

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

 

java代码：

查看复制到剪贴板打印

1. ===========before advice  
2. ============Hello World!  
3. ===========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代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

6.3.3  声明通知

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

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

 

java代码：

查看复制到剪贴板打印

1. <aop:before pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"  
2. method="前置通知实现方法名"  
3. 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代码：

查看复制到剪贴板打印

1. public void sayBefore(String param);  

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

将输入：

	========================================== ===========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代码：

查看复制到剪贴板打印

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

 

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

         method：同前置通知同义；

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

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

 

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

 

java代码：

查看复制到剪贴板打印

1. public boolean sayAfterReturning();  
2.    

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

1. @Test  
2. public void testSchemaAfterReturningAdvice() {  
3.     System.out.println("======================================");  
4.     ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");  
5.     IHelloWorldService helloworldService = ctx.getBean("helloWorldService", IHelloWorldService.class);  
6.     helloworldService.sayAfterReturning();      
7.     System.out.println("======================================");  
8. }  

 

将输入：

	====================================== ============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代码：

查看复制到剪贴板打印

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

 

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

         method：同前置通知同义；

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

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

 

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

 

java代码：

查看复制到剪贴板打印

1. public void sayAfterThrowing();  
2.    

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

 

java代码：

查看复制到剪贴板打印

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

将输入：

	====================================== ============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代码：

查看复制到剪贴板打印

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

 

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

         method：同前置通知同义；

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

 

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

 

java代码：

查看复制到剪贴板打印

1. public boolean sayAfterFinally();  

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

将输入：

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

 

 

 

 

 

 

 

 

 

分析一下吧：

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

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

 

 

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

 

java代码：

查看复制到剪贴板打印

1. <aop:around pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"  
2.                      method="后置最终通知实现方法名"  
3.                      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代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

1. @Test  
2. public void testSchemaAroundAdvice() {  
3.     System.out.println("======================================");  
4.     ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");  
5.     IHelloWorldService helloworldService =  
6.     ctx.getBean("helloWorldService", IHelloWorldService.class);  
7.     helloworldService.sayAround("haha");  
8.     System.out.println("======================================");  
9. }  

 

将输入：

	====================================== ===========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代码：

查看复制到剪贴板打印

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

 

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

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

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

 

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

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

 

java代码：

查看复制到剪贴板打印

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

 

 

java代码：

查看复制到剪贴板打印

1. package cn.javass.spring.chapter6.service.impl;  
2. import cn.javass.spring.chapter6.service.IIntroductionService;  
3. public class IntroductiondService implements IIntroductionService {  
4.     @Override  
5.     public void induct() {  
6.         System.out.println("=========introduction");  
7.     }  
8. }  

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

1. @Test  
2. public void testSchemaIntroduction() {  
3.     System.out.println("======================================");  
4.     ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");  
5.     IIntroductionService introductionService =  
6.     ctx.getBean("helloWorldService", IIntroductionService.class);  
7.     introductionService.induct();  
8.     System.out.println("======================================");  
9. }  
10.    

 

 

将输入：

	====================================== =========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代码：

查看复制到剪贴板打印

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

 

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

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

 

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

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

 

java代码：

查看复制到剪贴板打印

1. public void sayAdvisorBefore(String param);  

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

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

 

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

 

java代码：

查看复制到剪贴板打印

1. @Test  
2. public void testSchemaAdvisor() {  
3.    System.out.println("======================================");  
4.    ApplicationContext ctx = new ClassPathXmlApplicationContext("chapter6/advice.xml");  
5.    IHelloWorldService helloworldService =  
6.    ctx.getBean("helloWorldService", IHelloWorldService.class);  
7.    helloworldService.sayAdvisorBefore("haha");  
8.    System.out.println("======================================");  
9. }   

 

将输入：

	====================================== ===========before advice ============say haha ======================================

 

 

在此我们只介绍了前置通知API，其他类型的在后边章节介绍。

    不推荐使用Advisor，除了在进行事务控制的情况下，其他情况一般不推荐使用该方式，该方式属于侵入式设计，必须实现通知API。

Spring详解------------AOP

标签：

原文地址：http://blog.csdn.net/u011225629/article/details/47143093