SSH:Spring框架(spring之AOP)

转载 2015年11月18日 11:31:23

AOP(Aspect Oriented Programming),是面向切面编程的技术。AOP基于IoC基础,是对OOP的有益补充。


       AOP之所以能得到广泛认可,主要是因为它将应用系统拆分分了2个部分:核心业务逻辑(Core business concerns)及横向的通用逻辑,也就是所谓的切面Crosscutting enterprise concerns。例如,所有大中型应用都要涉及到的持久化管理(Persistent)、事务管理(Transaction Management)、权限管理(Privilege Management)、日志管理(Logging)和调试管理(Debugging)等。使用AOP技术,可以让开发人员只专注核心业务,而通用逻辑则使用AOP技术进行横向切入,由专人去处理这些通用逻辑,会使得任务简单明了,提高开发和调试的效率。



基本概念

       要想了解AOP,首先得了解几个重要的基本概念:

  • 切面(Aspect):一个关注点的模块化,这个关注点实现可能另外横切多个对象。比如说事务管理就是J2EE应用中一个很好的横切关注点例子。切面用Spring的Advisor或拦截器实现。
  • 连接点(Joinpoint):程序执行过程中明确的点,如方法的调用或特定的异常被抛出。
  • 通知(Advice):在特定的连接点,AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型,维护一个“围绕”连接点的拦截器链。
  • 切入点(Pointcut):指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点,例如,使用正则表达式。
  • 目标对象(Target Object):包含连接点的对象,也被称作被通知或被代理对象。
  • AOP代理(AOP Proxy):AOP框架创建的对象,包含通知。在Spring中,AOP代理可以是JDK动态代理或CGLIB代理。
  • 编织(Weaving):组装方面来创建一个被通知对象。这可以在编译时完成(例如使用AspectJ编译器),也可以在运行时完成。Spring和其他纯Java AOP框架一样,在运行时完成织入。


各种通知(Advice)类型

       为了符合各种流程处理,通知类型提供了5种,可以对目标方法进行全方位处理:

  • Before advice:在某连接点(JoinPoint)之前执行的通知,但这个通知不能阻止连接点前的执行。
    ApplicationContext中在<aop:aspect>里面使用<aop:before>元素进行声明。
  • After advice:当某连接点退出的时候执行的通知(不论是正常返回还是异常退出)。
    ApplicationContext中在<aop:aspect>里面使用<aop:after>元素进行声明。
  • After returnadvice:在某连接点正常完成后执行的通知,不包括抛出异常的情况。
    ApplicationContext中在<aop:aspect>里面使用<aop:after-returning>元素进行声明。
  • Around advice:包围一个连接点的通知,类似Web中Servlet规范中的Filter的doFilter方法。可以在方法的调用前后完成自定义的行为,也可以选择不执行。
    ApplicationContext中在<aop:aspect>里面使用<aop:around>元素进行声明。
  • Afterthrowing advice:在方法抛出异常退出时执行的通知。
    ApplicationContext中在<aop:aspect>里面使用<aop:after-throwing>元素进行声明。

(经博友提醒,将上图改成此图,是不是比上图印象更深刻一下,这两张图算一幅图)


AOP 2种代理的区别

       AOP支持2种代理,Jdk的动态代理和CGLIB实现机制。二者有什么区别呢:

  • Jdk基于接口实现:JDK动态代理对实现了接口的类进行代理。
  • CGLIB基于继承:CGLIB代理可以对类代理,主要对指定的类生成一个子类,因为是继承,所以目标类最好不要使用final声明。 
       通常情况下,鼓励使用jdk代理,因为业务一般都会抽象出一个接口,而且不用引入新的东西。如果是遗留的系统,以前没有实现接口,那么只能使用CGLIB。


       

AOP的配置方式有2种方式:xml配置和AspectJ注解方式。今天我们就来实践一下xml配置方式。


      我采用的jdk代理,所以首先将接口和实现类代码附上

  1. package com.tgb.aop;  
  2.   
  3. public interface UserManager {  
  4.   
  5.     public String findUserById(int userId);  
  6. }  
  7.   
  8.   
  9. package com.tgb.aop;  
  10.   
  11. public class UserManagerImpl implements UserManager {  
  12.   
  13.     public String findUserById(int userId) {  
  14.         System.out.println("---------UserManagerImpl.findUserById()--------");  
  15.         if (userId <= 0) {  
  16.             throw new IllegalArgumentException("该用户不存在!");   
  17.         }  
  18.         return "张三";  
  19.     }  
  20. }  

       单独写一个Advice通知类进行测试。这个通知类可以换成安全性检测、日志管理等等。

  1. package com.tgb.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5.   
  6. /** 
  7.  * Advice通知类 
  8.  * 测试after,before,around,throwing,returning Advice. 
  9.  * @author Admin 
  10.  * 
  11.  */  
  12. public class XMLAdvice {  
  13.   
  14.     /** 
  15.      * 在核心业务执行前执行,不能阻止核心业务的调用。 
  16.      * @param joinPoint 
  17.      */  
  18.     private void doBefore(JoinPoint joinPoint) {  
  19.         System.out.println("-----doBefore().invoke-----");  
  20.         System.out.println(" 此处意在执行核心业务逻辑前,做一些安全性的判断等等");  
  21.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  22.         System.out.println("-----End of doBefore()------");  
  23.     }  
  24.       
  25.     /** 
  26.      * 手动控制调用核心业务逻辑,以及调用前和调用后的处理, 
  27.      *  
  28.      * 注意:当核心业务抛异常后,立即退出,转向After Advice 
  29.      * 执行完毕After Advice,再转到Throwing Advice 
  30.      * @param pjp 
  31.      * @return 
  32.      * @throws Throwable 
  33.      */  
  34.     private Object doAround(ProceedingJoinPoint pjp) throws Throwable {  
  35. //ProceedingJoinPoint :t获得当前正在执行的方法
  36.         System.out.println("-----doAround().invoke-----");  
  37.         System.out.println(" 此处可以做类似于Before Advice的事情");  
  38.           
  39.         //调用核心逻辑  
  40.         Object retVal = pjp.proceed();  
  41.           
  42.         System.out.println(" 此处可以做类似于After Advice的事情");  
  43.         System.out.println("-----End of doAround()------");  
  44.         return retVal;  
  45.     }  
  46.   
  47.     /** 
  48.      * 核心业务逻辑退出后(包括正常执行结束和异常退出),执行此Advice 
  49.      * @param joinPoint 
  50.      */  
  51.     private void doAfter(JoinPoint joinPoint) {  
  52.         System.out.println("-----doAfter().invoke-----");  
  53.         System.out.println(" 此处意在执行核心业务逻辑之后,做一些日志记录操作等等");  
  54.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  55.         System.out.println("-----End of doAfter()------");  
  56.     }  
  57.       
  58.     /** 
  59.      * 核心业务逻辑调用正常退出后,不管是否有返回值,正常退出后,均执行此Advice 
  60.      * @param joinPoint 
  61.      */  
  62.     private void doReturn(JoinPoint joinPoint) {  
  63.         System.out.println("-----doReturn().invoke-----");  
  64.         System.out.println(" 此处可以对返回值做进一步处理");  
  65.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  66.         System.out.println("-----End of doReturn()------");  
  67.     }  
  68.       
  69.     /** 
  70.      * 核心业务逻辑调用异常退出后,执行此Advice,处理错误信息 
  71.      * @param joinPoint 
  72.      * @param ex 
  73.      */  
  74.     private void doThrowing(JoinPoint joinPoint,Throwable ex) {  
  75.         System.out.println("-----doThrowing().invoke-----");  
  76.         System.out.println(" 错误信息:"+ex.getMessage());  
  77.         System.out.println(" 此处意在执行核心业务逻辑出错时,捕获异常,并可做一些日志记录操作等等");  
  78.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  79.         System.out.println("-----End of doThrowing()------");  
  80.     }  
  81. }  

       只有Advice还不行,还需要在application-config.xml中进行配置:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.          xmlns:aop="http://www.springframework.org/schema/aop"  
  6.          xmlns:tx="http://www.springframework.org/schema/tx"  
  7. <!--下列的数据中必须为偶数个-->

  8.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  9.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  
  10.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
  11.                
  12.       
  13.     <bean id="userManager" class="com.tgb.aop.UserManagerImpl"/>  
  14.       
  15.     <!--<bean id="aspcejHandler" class="com.tgb.aop.AspceJAdvice"/>-->  
  16.     <bean id="xmlHandler" class="com.tgb.aop.XMLAdvice" />  
  17.     <aop:config>  
  18.         <aop:aspect id="aspect" ref="xmlHandler">  
  19.             <aop:pointcut id="pointUserMgr" expression="execution(* com.tgb.aop.*.find*(..))"/>  
  20.               
  21.             <aop:before method="doBefore"  pointcut-ref="pointUserMgr"/>  
  22.             <aop:after method="doAfter"  pointcut-ref="pointUserMgr"/>  
  23.             <aop:around method="doAround"  pointcut-ref="pointUserMgr"/>  
  24.             <aop:after-returning method="doReturn"  pointcut-ref="pointUserMgr"/>  
  25.             <aop:after-throwing method="doThrowing" throwing="ex" pointcut-ref="pointUserMgr"/>  
  26.               
  27.         </aop:aspect>  
  28.     </aop:config>  
  29. </beans>  

       编一个客户端类进行测试一下:

  1. package com.tgb.aop;  
  2.   
  3. import org.springframework.beans.factory.BeanFactory;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class Client {  
  7.   
  8.     public static void main(String[] args) {  
  9.         BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext.xml");  
  10.         UserManager userManager = (UserManager)factory.getBean("userManager");  
  11.           
  12.         //可以查找张三  
  13.         userManager.findUserById(1);  
  14.           
  15.         System.out.println("=====我==是==分==割==线=====");  
  16.   
  17.         try {  
  18.             // 查不到数据,会抛异常,异常会被AfterThrowingAdvice捕获  
  19.             userManager.findUserById(0);  
  20.         } catch (IllegalArgumentException e) {  
  21.         }  
  22.     }  
  23. }  

       结果如图:


       值得注意的是Around与Before和After的执行顺序。3者的执行顺序取决于在xml中的配置顺序。图中标记了3块,分别对应Before,Around,After。其中②中包含有③。这是因为aop:after配置到了aop:around的前面,如果2者调换一下位置,这三块就会分开独立显示。如果配置顺序是aop:after  -> aop:around ->aop:before,那么①和③都会包含在②中。这种情况的产生是由于Around的特殊性,它可以做类似于Before和After的操作。当安全性的判断不通过时,可以阻止核心业务逻辑的调用,这是Before做不到的。

  


       使用xml可以对aop进行集中配置。很方便而简单。可以对所有的aop进行配置,当然也可以分开到单独的xml中进行配置。当需求变动时,不用修改代码,只要重新配置aop,就可以完成修改操作。


AspectJ注解方式去配置spring aop:

依旧采用的jdk代理,接口和实现类代码请参考上篇博文。主要是将Aspect类分享一下:

  1. package com.tgb.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.ProceedingJoinPoint;  
  5. import org.aspectj.lang.annotation.After;  
  6. import org.aspectj.lang.annotation.AfterReturning;  
  7. import org.aspectj.lang.annotation.AfterThrowing;  
  8. import org.aspectj.lang.annotation.Around;  
  9. import org.aspectj.lang.annotation.Aspect;  
  10. import org.aspectj.lang.annotation.Before;  
  11. import org.aspectj.lang.annotation.DeclareParents;  
  12. import org.aspectj.lang.annotation.Pointcut;  
  13.   
  14. /** 
  15.  * 测试after,before,around,throwing,returning Advice. 
  16.  * @author Admin 
  17.  * 
  18.  */  
  19. @Aspect  
  20. public class AspceJAdvice {  
  21.   
  22.     /** 
  23.      * Pointcut 
  24.      * 定义Pointcut,Pointcut的名称为aspectjMethod(),此方法没有返回值和参数 
  25.      * 该方法就是一个标识,不进行调用 
  26.      */  
  27.     @Pointcut("execution(* find*(..))")  
  28.     private void aspectjMethod(){};  
  29.       
  30.     /**  
  31.      * Before 
  32.      * 在核心业务执行前执行,不能阻止核心业务的调用。 
  33.      * @param joinPoint  
  34.      */    
  35.     @Before("aspectjMethod()")    
  36.     public void beforeAdvice(JoinPoint joinPoint) {    
  37.         System.out.println("-----beforeAdvice().invoke-----");  
  38.         System.out.println(" 此处意在执行核心业务逻辑前,做一些安全性的判断等等");  
  39.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  40.         System.out.println("-----End of beforeAdvice()------");  
  41.     }  
  42.       
  43.     /**  
  44.      * After  
  45.      * 核心业务逻辑退出后(包括正常执行结束和异常退出),执行此Advice 
  46.      * @param joinPoint 
  47.      */  
  48.     @After(value = "aspectjMethod()")    
  49.     public void afterAdvice(JoinPoint joinPoint) {    
  50.         System.out.println("-----afterAdvice().invoke-----");  
  51.         System.out.println(" 此处意在执行核心业务逻辑之后,做一些日志记录操作等等");  
  52.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  53.         System.out.println("-----End of afterAdvice()------");  
  54.     }    
  55.   
  56.     /**  
  57.      * Around  
  58.      * 手动控制调用核心业务逻辑,以及调用前和调用后的处理, 
  59.      *  
  60.      * 注意:当核心业务抛异常后,立即退出,转向AfterAdvice 
  61.      * 执行完AfterAdvice,再转到ThrowingAdvice 
  62.      * @param pjp 
  63.      * @return 
  64.      * @throws Throwable 
  65.      */   
  66.     @Around(value = "aspectjMethod()")    
  67.     public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {    
  68.         System.out.println("-----aroundAdvice().invoke-----");  
  69.         System.out.println(" 此处可以做类似于Before Advice的事情");  
  70.           
  71.         //调用核心逻辑  
  72.         Object retVal = pjp.proceed();  
  73.         System.out.println(" 此处可以做类似于After Advice的事情");  
  74.         System.out.println("-----End of aroundAdvice()------");  
  75.         return retVal;  
  76.     }    
  77.       
  78.     /**  
  79.      * AfterReturning  
  80.      * 核心业务逻辑调用正常退出后,不管是否有返回值,正常退出后,均执行此Advice 
  81.      * @param joinPoint 
  82.      */   
  83.     @AfterReturning(value = "aspectjMethod()", returning = "retVal")    
  84.     public void afterReturningAdvice(JoinPoint joinPoint, String retVal) {    
  85.         System.out.println("-----afterReturningAdvice().invoke-----");  
  86.         System.out.println("Return Value: " + retVal);   
  87.         System.out.println(" 此处可以对返回值做进一步处理");  
  88.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  89.         System.out.println("-----End of afterReturningAdvice()------");  
  90.     }  
  91.       
  92.     /** 
  93.      * 核心业务逻辑调用异常退出后,执行此Advice,处理错误信息 
  94.      *  
  95.      * 注意:执行顺序在Around Advice之后 
  96.      * @param joinPoint 
  97.      * @param ex 
  98.      */  
  99.     @AfterThrowing(value = "aspectjMethod()", throwing = "ex")    
  100.     public void afterThrowingAdvice(JoinPoint joinPoint, Exception ex) {    
  101.         System.out.println("-----afterThrowingAdvice().invoke-----");  
  102.         System.out.println(" 错误信息:"+ex.getMessage());  
  103.         System.out.println(" 此处意在执行核心业务逻辑出错时,捕获异常,并可做一些日志记录操作等等");  
  104.         System.out.println(" 可通过joinPoint来获取所需要的内容");  
  105.         System.out.println("-----End of afterThrowingAdvice()------");    
  106.     }    
  107. }  


       application-config.xml中,只需要配置业务逻辑bean和Aspect bean,并启用Aspect注解即可:

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2.   
  3. <beans xmlns="http://www.springframework.org/schema/beans"  
  4.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  5.          xmlns:aop="http://www.springframework.org/schema/aop"  
  6.          xmlns:tx="http://www.springframework.org/schema/tx"  
  7.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  8.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  
  9.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
  10.              
  11.     <!-- 启用AspectJ对Annotation的支持 -->         
  12.     <aop:aspectj-autoproxy/>             
  13.       
  14.     <bean id="userManager" class="com.tgb.aop.UserManagerImpl"/>  
  15.     <bean id="aspcejHandler" class="com.tgb.aop.AspceJAdvice"/>  
  16.       
  17. </beans>  

       结果如图:



       通过测试的发现AroundAdvice、BeforeAdvice、AfterAdvice、ReturningAdvice的执行顺序是根据注解的顺序而定的。但是有时候修改了顺序,结果却没有变化,可能是缓存的缘故。前几天我也遇到了这样的问题,不过今天再测试了一下,发现执行顺序又跟注解的顺序一致了。


       xml 和 Annotation 注解都可以作为配置项,对Spring AoP进行配置管理,那么它们各自都有什么优缺点呢?

  首先说说 xml 。目前 web 应用中几乎都使用 xml 作为配置项,例如我们常用的框架 Struts、Spring、Hibernate 等等都采用 xml 作为配置。xml 之所以这么流行,是因为它的很多优点是其它技术的配置所无法替代的:

    • xml 作为可扩展标记语言最大的优势在于开发者能够为软件量身定制适用的标记,使代码更加通俗易懂。
    • 利用 xml 配置能使软件更具扩展性。例如 Spring 将 class 间的依赖配置在 xml 中,最大限度地提升应用的可扩展性。
    • 具有成熟的验证机制确保程序正确性。利用 Schema 或 DTD 可以对 xml 的正确性进行验证,避免了非法的配置导致应用程序出错。
    • 修改配置而无需变动现有程序。
  虽然有如此多的好处,但毕竟没有什么万能的东西,xml 也有自身的缺点。
    • 需要解析工具或类库的支持。
    • 解析 xml 势必会影响应用程序性能,占用系统资源。
    • 配置文件过多导致管理变得困难。
    • 编译期无法对其配置项的正确性进行验证,或要查错只能在运行期。
    • IDE 无法验证配置项的正确性无能为力。
    • 查错变得困难。往往配置的一个手误导致莫名其妙的错误。
    • 开发人员不得不同时维护代码和配置文件,开发效率变得低下。
    • 配置项与代码间存在潜规则。改变了任何一方都有可能影响另外一方。
  让我们来看看 Annotation 的优点。
    • 保存在 class 文件中,降低维护成本。
    • 无需工具支持,无需解析。
    • 编译期即可验证正确性,查错变得容易。
    • 提升开发效率。
  同样 Annotation 也不是万能的,它也有很多缺点。
    • 若要对配置项进行修改,不得不修改 Java 文件,重新编译打包应用。
    • 配置项编码在 Java 文件中,可扩展性差。
  总结:没有一个事物是万能的,同样 xml 和 Java Annotation 都有各自的优缺点。通过以上对比,细心的读者可能已经发现它们的优缺点恰恰是互补的。xml 的强项是 Annotation 所不具备的,而 Annotation 的优势也是 xml 所欠缺的。这也正是时下流行的 xml + Annotation 配置的原因所在。平衡才是王道呀!

相关文章推荐

Spring框架IOC与AOP简单应用浅解-适合初入SSH框架学习

该文简述Spring核心框架结构中的IOC模块与AOP模块的简单应用,针对于SSH框架整合后续的简单应用实例,适合初学者入门阅读,欢迎诸路大神莅临指导...

Spring框架核心Jar和AOP所需的Jar文件

  • 2017年01月10日 16:42
  • 4.65MB
  • 下载

SSH和Spring框架简介

  • 2011年10月15日 21:00
  • 11KB
  • 下载

spring框架学习(六)AOP

AOP(Aspect-OrientedProgramming)面向方面编程,与OOP完全不同,使用AOP编程系统被分为方面或关注点,而不是OOP中的对象。    AOP的引入  在OOP面向对象的使用...

spring框架的ioc和aop通俗解释

IoC(Inversion of Control)中文名叫控制反转,就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部 容器负责的。这样控制权就由应用转移到了外部容器,控制权的转移...

AOP编程简介及其在Spring框架中的使用

AOP编程简介及其在Spring框架中的使用额,最近一直没来逛自己的博客发现游客蛮多的:),从前段时间开始就一直在学ssh框架(已经搞定strut2和hibernate),javaweb的框架还是蛮多...

关于spring框架中的IOC/DI和AOP,以及声明式事务管理的理解

IOC/DI:中文意思控制反转/依赖注入,针对以前编程,类中的属性都是写死的,直接在程序中给成员变量初始化。这样的编程,耦合度太高,代码的灵活性和扩展性太差。spring的处理方式是,在配置文件中,将...

Spring框架IOC和AOP的理解

spring开源框架 一.什么是Spring? 简单来说:spring是一个轻量级控制反转(IOC)和面向切面(AOP)容器的框架 spring的基本框架主要包含六大模块:DAO、ORM...

【spring框架】AOP的XML实现(必须掌握)

spring的AOP可以用Annotation来实现,同样的,也可以通过XML的配置来实现,下面来介绍使用XML配置的过程。 1.声明一个切面 有了schema的支持,切面就和常规的Java对象一样...

spring框架学习(八)—静态代理、JDK与CGLIB动态代理、AOP+IoC

目录 一、为什么需要代理模式二、静态代理三、动态代理,使用JDK内置的Proxy实现四、动态代理,使用cglib实现五、使用Spring实现AOP六、使用IOC配置的方式实现AOP七、使用XML配置...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SSH:Spring框架(spring之AOP)
举报原因:
原因补充:

(最多只允许输入30个字)