SSH：Spring框架（spring之AOP）

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. 
   
9.          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
10.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd  
11.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">  
12.                
13.       
14.     <bean id="userManager" class="com.tgb.aop.UserManagerImpl"/>  
15.       
16.     <!--<bean id="aspcejHandler" class="com.tgb.aop.AspceJAdvice"/>-->  
17.     <bean id="xmlHandler" class="com.tgb.aop.XMLAdvice" />  
18.     <aop:config>  
19.         <aop:aspect id="aspect" ref="xmlHandler">  
20.             <aop:pointcut id="pointUserMgr" expression="execution(* com.tgb.aop.*.find*(..))"/>  
21.               
22.             <aop:before method="doBefore"  pointcut-ref="pointUserMgr"/>  
23.             <aop:after method="doAfter"  pointcut-ref="pointUserMgr"/>  
24.             <aop:around method="doAround"  pointcut-ref="pointUserMgr"/>  
25.             <aop:after-returning method="doReturn"  pointcut-ref="pointUserMgr"/>  
26.             <aop:after-throwing method="doThrowing" throwing="ex" pointcut-ref="pointUserMgr"/>  
27.               
28.         </aop:aspect>  
29.     </aop:config>  
30. </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 配置的原因所在。平衡才是王道呀！