AOP详解

一、基础概念

Aspect(切面)：指横切性关注点的抽象即为切面，它与类相似，只是两者的关注点不一样，类是对物体特征的抽象，而切面是横切性关注点的抽象(包括切入点的描述和通知的描述)。

Joinpoint(连接点)：所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法， 因为spring只支持方法型的连接点，实际上joinpoint还可以是field或者构造器。

Pointcut(切入点)：所谓切入点是指我们要对那些joinpoint进行拦截的定义。通常需要与excution表达式进行匹配。

Advice(通知)：所谓通知是指拦截到jointpoint之后所要做的事情就是通知。通知分为前置通知、后置通知、异常通知、最终通知、环绕通知。

Target(目标对象)：代理的目标对象

Weave(织入): 指将aspects应用到target对象并导致proxy对象创建的过程称为织入

Introducton(引入)：在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Field

注：红色字体为重要概念

二、应用举例

基于xml配置方式进行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:context="http://www.springframework.org/schema/context"   
5.        xmlns:aop="http://www.springframework.org/schema/aop"        
6.        xsi:schemaLocation="http://www.springframework.org/schema/beans  
7.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
8.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
9.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">  
10.         <aop:aspectj-autoproxy/><!-- 启动对@AspectJ注解的支持 -->  
11. </beans> 
    

Java代码

1. import org.aspectj.lang.ProceedingJoinPoint;  
2. import org.aspectj.lang.annotation.After;  
3. import org.aspectj.lang.annotation.AfterReturning;  
4. import org.aspectj.lang.annotation.AfterThrowing;  
5. import org.aspectj.lang.annotation.Around;  
6. import org.aspectj.lang.annotation.Aspect;  
7. import org.aspectj.lang.annotation.Before;  
8. import org.aspectj.lang.annotation.Pointcut;  
9. import org.springframework.stereotype.Component;  
10.   
11. @Aspect @Component  
12. public class MyInterceptor {  
13.   
14. /** 
15.      *@Pointcut ：表示规定切入点  
16.      *execution() 语法规范 
17.      * 第一个“*”表示任意返回结果类型 
18.      * “cn.itcast.service.impl.PersonServiceBean”：表示对此类进行拦截， 
19.      * 如果是cn.itcast.service..*.*：表示对包cn.itcast.service以及子包里所有的类的所有方法进行拦截， 
20.      * (..)表示参数  
21.      */   
22.   
23.       
24.     @Pointcut("execution(* com.mingbai.springaop.PersonServiceBean.*(..))")  
25.     private void anyMethod(){}//声明一个切入点  
26.       
27. /*  @Before("anyMethod()") 
28.     public void doAccessCheck(){ 
29.         System.out.println("前置通知"); 
30.     }*/  
31.       
32.     //此时的前置通知，只能拦截到参数个数和类型匹配的方法  
33.     //args(name)中的name必须和方法doAccessCheck的参数一至  
34.     @Before("anyMethod() && args(name)")  
35.     public void doAccessCheck(String name){  
36.         System.out.println(name+"前置通知");  
37.     }  
38.       
39. /*  @AfterReturning("anyMethod()") 
40.     public void doAfterReturn(){ 
41.         System.out.println("后置通知"); 
42.     }*/  
43.     //得到方法的返回值  
44.     @AfterReturning(pointcut="anyMethod()",returning="result")  
45.     public void doAfterReturn(String result){  
46.         System.out.println("后置通知  "+result);  
47.     }  
48.       
49.   
50.     @After("anyMethod()")  
51.     public void doAfter(){  
52.         System.out.println("最终通知");  
53.     }  
54.       
55. /*  @AfterThrowing("anyMethod()") 
56.     public void doAfterThrow(){ 
57.         System.out.println("异常通知"); 
58.     }*/  
59.     @AfterThrowing(pointcut="anyMethod()",throwing="e")  
60.     public void doAfterThrow(Exception e){  
61.         System.out.println("异常通知------"+e.getMessage());  
62.     }  
63.       
64.     @Around("anyMethod()")  
65.     public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{  
66.         System.out.println("环绕通知  开始");  
67.         Object obj = pjp.proceed();  
68.         System.out.println("环绕通知  结束");  
69.         return obj;  
70.     }  
71. }  

（二）基于XML配置的方式

切面只是一个普通的javabean

Java代码

1. import org.aspectj.lang.ProceedingJoinPoint;  
2.   
3. public class MyInterceptor1 {  
4.       
5.   
6.     public void doAccessCheck(){  
7.         System.out.println("前置通知-------");  
8.     }  
9.       
10.     public void doAfterReturn(){  
11.         System.out.println("后置通知");  
12.     }  
13.       
14.   
15.     public void doAfter(){  
16.         System.out.println("最终通知");  
17.     }  
18.     public void doAfterThrow(){  
19.         System.out.println("异常通知");  
20.     }  
21.       
22.     public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable{  
23.         System.out.println("环绕通知  开始");  
24.         Object obj = pjp.proceed();  
25.         System.out.println("环绕通知  结束");  
26.         return obj;  
27.     }  
28. }  配置文件 ：
    
    
    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:context="http://www.springframework.org/schema/context"   
    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  
    8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
    9.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
    10.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
    11.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">     
    12.        
    13.    
    14.  <bean id="per" class="com.mingbai.springaop.PersonServiceBean"/>  
    15.      <bean id="myInterceptor" class="com.mingbai.springaop.MyInterceptor1"/>  
    16.      <!--    
    17.      <aop:config>  
    18.         <aop:aspect id="asp" ref="myInterceptor">  
    19.             <aop:pointcut id="mycut" expression="execution(* com.mingbai.springaop.*.*(..))"/>  
    20.             <aop:before pointcut-ref="mycut" method="doAccessCheck"/>  
    21.             <aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>  
    22.             <aop:after pointcut-ref="mycut" method="doAfter"/>  
    23.             <aop:after-throwing pointcut-ref="mycut" method="doAfterThrow"/>  
    24.             <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>  
    25.         </aop:aspect>  
    26.      </aop:config>
        
    27.      -->   
    28.      <!-- 只是拦截返回类型为java.lang.String的方法     
    29.      <aop:config>  
    30.         <aop:aspect id="asp" ref="myInterceptor">  
    31.             <aop:pointcut id="mycut" expression="execution(java.lang.String com.mingbai.springaop.*.*(..))"/>  
    32.             <aop:before pointcut-ref="mycut" method="doAccessCheck"/>  
    33.             <aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>  
    34.             <aop:after pointcut-ref="mycut" method="doAfter"/>  
    35.             <aop:after-throwing pointcut-ref="mycut" method="doAfterThrow"/>  
    36.             <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>  
    37.         </aop:aspect>  
    38.      </aop:config>  
    39.    -->   
    40.    <!-- 返回非void的方法 -->  
    41.    <aop:config>  
    42.         <aop:aspect id="asp" ref="myInterceptor">  
    43.             <aop:pointcut id="mycut" expression="execution(!void com.mingbai.springaop.*.*(..))"/>  
    44.             <aop:before pointcut-ref="mycut" method="doAccessCheck"/>  
    45.             <aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>  
    46.             <aop:after pointcut-ref="mycut" method="doAfter"/>  
    47.             <aop:after-throwing pointcut-ref="mycut" method="doAfterThrow"/>  
    48.             <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>  
    49.         </aop:aspect>  
    50.      </aop:config>  
    51.    <!-- 匹配第一个参数为java.lang.String,其它的无所谓   
    52.      <aop:config>  
    53.         <aop:aspect id="asp" ref="myInterceptor">  
    54.             <aop:pointcut id="mycut" expression="execution(* com.mingbai.springaop.*.*(..))"/>  
    55.             <aop:before pointcut-ref="mycut" method="doAccessCheck"/>  
    56.             <aop:after-returning pointcut-ref="mycut" method="doAfterReturn"/>  
    57.             <aop:after pointcut-ref="mycut" method="doAfter"/>  
    58.             <aop:after-throwing pointcut-ref="mycut" method="doAfterThrow"/>  
    59.             <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>  
    60.         </aop:aspect>  
    61.      </aop:config>  
    62.    -->  
    63.      
    64. </beans> 

总结

spring 3.x 的aop容器大致运行流程为：

1.定义切面(包括切入点pointcut和通知advice)。

2.当spring容器在调用Bean时，如果满足excution中的格式（切入点），那么就将通知（advice）插入到该切入点中。

通知：前置，后置、环绕通知等等

详情可观看慕课网spring入门——aop