ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > IT综合 > 【Spring】AOP之基于XML配置总结与案例

【Spring】AOP之基于XML配置总结与案例

原创 IT综合 作者：djdssdd 时间：2015-04-27 12:02:55 0 删除 编辑

  一、AOP的一些概念

         AOP（Aspect-Oriented Programming，面向切面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

       而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即切面。所谓“切面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向切面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“切面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

      使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

      实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“切面”，从而使得编译器可以在编译期间织入有关“切面”的代码。然而殊途同归，实现AOP的技术特性却是相同的，分别为：

      1、join point（连接点）：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个join point。
      2、point cut（切入点）：本质上是一个捕获连接点的结构。在AOP中，可以定义一个point cut，来捕获相关方法的调用。
      3、advice（通知）：是point cut的执行代码，是执行“切面”的具体逻辑。
      4、aspect（切面）：point cut和advice结合起来就是aspect，它类似于OOP中定义的一个类，但它代表的更多是对象间横向的关系。
      5、introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的AOP工具又将其称为mixin。

      6、AOP代理（AOP Proxy）：AOP框架创建的对象，这个对象通常可以作为目标对象的替代品，而AOP代理提供比目标对象更加强大的功能。真实的情形是，当应用调用AOP代理的方法时，AOP代理会在自己的方法中回调目标对象的方法，从而完成应用的调用。关于AOP代理的典型例子就是Spring中的事务代理Bean。通常，目标Bean的方法不是事务性的，而AOP代理包含目标Bean的全部方法，而且这 些方法经过加强变成了事务性方法。简单地说，目标对象是蓝本，AOP代理是目标对象的加强，在目标对象的基础上，增加属性和方法，提供更强大的功能。
目标对象包含一系列切入点。切入点可以触发处理连接点集合。用户可以自己定义切入点，如使用正则表达式。AOP代理包装目标对象，在切入点处加入处理。在切入点加入的处理，使得目标对象的方法功能更强。Spring 默认使用JDK动态代理实现AOP代理，主要用于代理接口。也可以使用CGLIB代理。实现类的代理，而不是接口。如果业务对象没有实现接口，默认使用 CGLIB代理。但面向接口编程是良好的习惯，尽量不要面向具体类编程。因此，业务对象通常应实现一个或多个接口。

      7、目标对象（Target Object）：包含一个连接点的对象，也被称为代理对象。
      8、 前置通知（Before advice）：在某连接点（JoinPoint）之前执行的通知，但这个通知不能阻止连接点前的执行。ApplicationContext中在里面使用元素进行声明。 
      9、后通知（After advice） ：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。ApplicationContext中在里面使用元素进行声明。
      10、返回后通知（After return advice） ：在某连接点正常完成后执行的通知，不包括抛出异常的情况。ApplicationContext中在里面使用元素进行声明。 
      11、环绕通知（Around advice） ：包围一个连接点的通知，类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为，也可以选择不执行。ApplicationContext中在里面使用元素进行声明。

      12、抛出异常后通知（After throwing advice） ： 在方法抛出异常退出时执行的通知。 ApplicationContext中在里面使用元素进行声明。

     Spring2.0目前只支持使用方法调用作为连接点（join point）。

     Spring 定义切入点语法：excution（modifiers-pattern？ret-type-pattern declaring-type-pattern ？name-pattern（param-pattern）throws-pattern？）

      除了ret-type-pattern （即返回类型模式）、name-pattern（param-pattern）（名字模式和参数模式）外，其他模式都是可选的。返回类型模式决定了方法的返回类型必须依次匹配一个连接点（即一个方法）。使用最频繁的一个返回类型模式是*，它代表了匹配任意的返回类型。如果写明了返回类型，比如String，那么只能匹配返回String类型的连接点（方法）。名字模式匹配的是方法名。你可以用*通配符表示匹配所有方法名。参数模式中，（）表示匹配了不接受任何参数的方法，而（。。）表示匹配任意数量参数的方法。模式（*）表示匹配任意类型参数的方法。模式（*，String）表示匹配：第一个为任意参数类型，第二个必须为String类型的方法。


二、基于Schema（XML）的AOP配置


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

 在Spring配置文件中，所以AOP相关定义必须放在标签下，该标签下可以有、、标签，配置顺序不可变。

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


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

声明切入点 
    切入点在Spring中也是一个Bean，Bean定义方式可以有很三种方式： 
● 在标签下使用声明一个切入点Bean，该切入点可以被多个切面使用，对于需要共享使用的切入点最好使用该方式，该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式。 
● 在标签下使用声明一个切入点Bean，该切入点可以被多个切面使用，但一般该切入点只被该切面使用，当然也可以被其他切面使用，但最好不要那样使用，该切入点使用id属性指定Bean名字，在通知定义时使用pointcut-ref属性通过该id引用切入点，expression属性指定切入点表达式 
● 匿名切入点Bean，可以在声明通知时通过pointcut属性指定切入点表达式，该切入点是匿名切入点，只被该通知使用 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:config>      
  2.  <aop:aspect ref="aspectSupportBean">      
  3.      <aop:after pointcut="execution(* cn.javass..*.*(..))" method="afterAdvice"/>      
  4.  aop:aspect>    
  5. aop:config>     


声明通知：(前置通知，后置通知，环绕通知) 
1、前置通知:在切入点选择的连接点处的方法之前执行的通知，该通知不影响正常程序执行流程（除非该通知抛出异常，该异常将中断当前方法链的执行而返回）。 
Spring中在切入点选择的方法之前执行，通过标签下的标签声明： 
[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:before pointcut="切入点表达式" （或者pointcut-ref="切入点Bean引用"）     
  2.      method="前置通知实现方法名" arg-names="前置通知实现方法参数列表参数名字"/>    
● pointcut和pointcut-ref：二者选一，指定切入点； 
● method：指定前置通知实现方法名，如果是多态需要加上参数类型，多个用“，”隔开，如beforeAdvice(java.lang.String)； 
● arg-names：指定通知实现方法的参数名字，多个用“，”分隔，可选，切入点中使用“args(param)”匹配的目标方法参数将自动传递给通知实现方法同名参数。 

2、后置通知:在切入点选择的连接点处的方法之后执行的通知，包括如下类型的后置通知： 
● 后置返回通知:在切入点选择的连接点处的方法正常执行完毕时执行的通知，必须是连接点处的方法没抛出任何异常正常返回时才调用后置通知。 
在切入点选择的方法正常返回时执行，通过标签下的标签声明： 
[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:after-returning pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"      
  2.         method="后置返回通知实现方法名"      
  3.         arg-names="后置返回通知实现方法参数列表参数名字"      
  4.         returning="返回值对应的后置返回通知实现方法参数名"      
  5. />  
3、后置异常通知:在切入点选择的连接点处的方法抛出异常返回时执行的通知，必须是连接点处的方法抛出任何异常返回时才调用异常通知。 
在切入点选择的方法抛出异常时执行，通过标签下的标签声明： 
[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:after-throwing pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"      
  2.                                 method="后置异常通知实现方法名"      
  3.                                 arg-names="后置异常通知实现方法参数列表参数名字"      
  4.                                 throwing="将抛出的异常赋值给的通知实现方法参数名"/>   
4、后置最终通知:在切入点选择的连接点处的方法返回时执行的通知，不管抛没抛出异常都执行，类似于Java中的finally块。 
在切入点选择的方法返回时执行，不管是正常返回还是抛出异常都执行，通过标签下的标签声明： 
[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:after pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"      
  2.                   method="后置最终通知实现方法名"      
  3.                   arg-names="后置最终通知实现方法参数列表参数名字"/>     
5、环绕通知：环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知可以在方法调用之前和之后自定义任何行为，并且可以决定是否执行连接点处的方法、替换返回值、抛出异常等等。 
环绕着在切入点选择的连接点处的方法所执行的通知，环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值，可通过标签下的标签声明： 

[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:around pointcut="切入点表达式"  pointcut-ref="切入点Bean引用"      
  2.                      method="后置最终通知实现方法名"      
  3.                      arg-names="后置最终通知实现方法参数列表参数名字"/>    

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

引入 
    Spring允许为目标对象引入新的接口，通过在< aop:aspect>标签内使用< aop:declare-parents>标签进行引入，定义方式如下： 
[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:declare-parents      
  2.           types-matching="AspectJ语法类型表达式"      
  3.           implement-interface=引入的接口"                   
  4.           default-impl="引入接口的默认实现"      
  5.           delegate-ref="引入接口的默认实现Bean引用"/>    

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

[html] view plaincopy在CODE上查看代码片派生到我的代码片
  1. <aop:advisor pointcut="切入点表达式" pointcut-ref="切入点Bean引用"      
  2.                      advice-ref="通知API实现引用"/>    
  3.     
  4. <bean id="beforeAdvice" class="cn.javass.spring.chapter6.aop.BeforeAdviceImpl"/>    
  5. <aop:advisor pointcut="execution(* cn.javass..*.sayAdvisorBefore(..))"      
  6.                      advice-ref="beforeAdvice"/>     


三、使用范例

一定要注意导入这些包！

aspectjweaver.jar

aopalliance-1.0.jar


1、人的接口类


[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.mucfc;  
  2. /**   
  3. *功能  人的接口类 
  4. *作者 林炳文（ling20081005@126.com 博客：http://blog.csdn.net/evankaka）   
  5. *时间 2015.4.24  
  6. */  
  7. public interface Person {  
  8.     public void eatBreakfast();  
  9.     public void eatLunch();  
  10.     public void eatSupper();  
  11.       
  12.   
  13. }  
2、Baby实现类



[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.mucfc;  
  2. /**   
  3. *功能  人的实现类 
  4. *作者 林炳文（ling20081005@126.com 博客：http://blog.csdn.net/evankaka）   
  5. *时间 2015.4.24  
  6. */  
  7. public class BabyPerson implements Person{  
  8.   
  9.     @Override  
  10.     public void eatBreakfast() {  
  11.         System.out.println("小Baby正在吃早餐");  
  12.     }  
  13.   
  14.     @Override  
  15.     public void eatLunch() {  
  16.         System.out.println("小Baby正在吃午餐");  
  17.     }  
  18.   
  19.     @Override  
  20.     public void eatSupper() {  
  21.         System.out.println("小Baby正在吃晚餐");  
  22.     }  
  23.   
  24. }  

3、然后把要增强的方法都写在一个文件中去



[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.mucfc;  
  2.   
  3. import org.aspectj.lang.ProceedingJoinPoint;  
  4.   
  5. public class AdivceMethod {  
  6. public void beforeEat(){  
  7.     System.out.println("-------------------吃饭之前先洗小手！--------------------");  
  8. }  
  9. public void afterEat(){  
  10.     System.out.println("-------------------午饭吃完要睡午觉！--------------------");  
  11. }  
  12. public Object aroundEat(ProceedingJoinPoint pjp) throws Throwable{  
  13.       System.out.println("-------------------吃晚饭前先玩一玩！-------------------");    
  14.       Object retVal = pjp.proceed();    
  15.       System.out.println("-------------------晚饭吃完后要得睡觉了！-------------------");   
  16.       return retVal;  
  17. }  
  18. }  

4、下面就是重点了，直接使用aop:config



[html] view plaincopy在CODE上查看代码片派生到我的代码片
  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.              
  11.       <bean id="babyPerson" class="com.mucfc.BabyPerson"/><!-- 被增强的bean -->  
  12.       <bean id="adviceAspect" class="com.mucfc.AdivceMethod"/><!-- 增强方法的bean -->  
  13.   
  14.      <aop:config  proxy-target-class="true">    
  15.      <aop:pointcut id="pointcut" expression="execution(* com.mucfc.BabyPerson.*(..))"/>  <!-- 定义切点 -->  
  16.      <aop:aspect ref="adviceAspect">  <!-- 定义切面 -->  
  17.         <aop:before method="beforeEat" pointcut-ref="pointcut" />  <!-- 定义前置增强方法 -->  
  18.         <aop:after method="afterEat" pointcut="execution(* com.mucfc.BabyPerson.eatLunch(..))"/><!--定义后置增加，使用匿名切点  -->  
  19.         <aop:around method="aroundEat" pointcut="execution(* com.mucfc.BabyPerson.eatSupper(..))"/><!--定义后置增加，使用匿名切点  -->  
  20.      aop:aspect>    
  21.     aop:config>  
  22.       
  23.      
  24.   
  25. beans>  

5、测试



[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. package com.mucfc;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Test {  
  7.   
  8.     public static void main(String[] args) {  
  9.         ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");  
  10.        Person babyPerson=(BabyPerson)context.getBean("babyPerson");  
  11.         babyPerson.eatBreakfast();  
  12.         babyPerson.eatLunch();  
  13.         babyPerson.eatSupper();  
  14.           
  15.     }  
  16.   
  17. }  
结果：


基于XML的配置方法实现很方便，比上一讲的基于API的方法简单多了，而且代码看起来更容易解决，做到这里。不得不佩服Spring的强大！
http://dwz.cn/HPerv
http://t.cn/RAHABSu
http://985.so/jrS2
http://dwz.cn/HPerL
http://t.cn/RAHABKj
http://985.so/jrS3
http://dwz.cn/HPet2
http://t.cn/RAHABQV
http://985.so/jrSB
http://dwz.cn/HPesg
http://t.cn/RAHABO8
http://985.so/jrS5
http://dwz.cn/HPesr
http://t.cn/RAHABW1
http://985.so/jrS6
http://dwz.cn/HPesw
http://t.cn/RAHABlO
http://985.so/jrS7
http://dwz.cn/HPesH
http://t.cn/RAHABjj
http://985.so/jrS9
http://dwz.cn/HPesU
http://t.cn/RAHABTP
http://985.so/jrS8
http://dwz.cn/HPet0
http://t.cn/RAHABHp
http://985.so/jrSA
http://dwz.cn/HPetb
http://t.cn/RAHAB8Z
http://985.so/jrSC
http://dwz.cn/HPetj
http://t.cn/RAHABEC
http://985.so/jrSD
http://dwz.cn/HPett
http://t.cn/RAHABmn
http://985.so/jrSE
http://dwz.cn/HPetB
http://t.cn/RAHAB17
http://985.so/jrSF
http://dwz.cn/HPetP
http://t.cn/RAHABBB
http://985.so/jrSG
http://dwz.cn/HPeu5
http://t.cn/RAHABg7
http://985.so/jrSH
http://dwz.cn/HPeud
http://t.cn/RAHABe8
http://985.so/jrSJ
http://dwz.cn/HPeup
http://t.cn/RAHABkW
http://985.so/jrSK
http://dwz.cn/HPeuB
http://t.cn/RAHABs0
http://985.so/jrSN
http://dwz.cn/HPeuE
http://t.cn/RAHArhx
http://985.so/jrSM
http://dwz.cn/HPeuO
http://t.cn/RAHArzA
http://985.so/jrSP
http://dwz.cn/HPeuU
http://t.cn/RAHArwI
http://985.so/jrSQ
http://dwz.cn/HPeve
http://t.cn/RAHAr2G
http://985.so/jrSR
http://dwz.cn/HPevq
http://t.cn/RAHArL1
http://985.so/jrSS
http://dwz.cn/HPevB
http://t.cn/RAHAr4A
http://985.so/jrST
http://dwz.cn/HPevI
http://t.cn/RAHArbF
http://985.so/jrSU
http://dwz.cn/HPevX
http://t.cn/RAHAr5A
http://985.so/jrSV
http://dwz.cn/HPew6
http://t.cn/RAHArtt
http://985.so/jrSW
http://dwz.cn/HPewy
http://t.cn/RAHArCg
http://985.so/jrTb
http://dwz.cn/HPewm
http://t.cn/RAHArfp
http://985.so/jrSX
http://dwz.cn/HPeww
http://t.cn/RAHArMV
http://985.so/jrSY
http://dwz.cn/HPewE
http://t.cn/RAHArJn
http://985.so/jrSZ
http://dwz.cn/HPewK
http://t.cn/RAHArXo
http://985.so/jrTa
http://dwz.cn/HPewQ
http://t.cn/RAHArlN
http://985.so/jrTe
http://dwz.cn/HPex8
http://t.cn/RAHArNH
http://blog.itpub.net/30224485/viewspace-1605495/

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/30224485/viewspace-1605532/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： Oracle入门指导：入门学习心得
下一篇： 没有了~
请登录后发表评论 登录
全部评论
djdssdd

注册时间：2015-04-27

  • 博文量
    2
  • 访问量
    4851

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593