（转）Spring AOP实现方式（转）

我们可以通过三种方式来使用Spring AOP，它们分别是：@Aspect-based（Annotation），Schema-based（XML），以及底层的Spring AOP API

底层的Spring AOP API比较复杂，下面只介绍@Aspect-based(注解方式)和Schema-based（声明方式）

两种方式比较：

Spring AOP和AspectJ的比较

    Spring AOP比完全使用AspectJ更加简单，因为它不需要引入AspectJ的编译器／织
入器到你开发和构建过程中。如果你仅仅需要在Spring bean上通知执行操作，那么Spring
AOP是合适的选择。如果你需要通知domain对象或其它没有在Spring容器中管理的任意对
象，那么你需要使用AspectJ。如果你想通知除了简单的方法执行之外的连接点（如：调用
连接点、字段get或set的连接点等等），也需要使用AspectJ。

     XML风格 = 采用声明形式实现Spring AOP
    AspectJ风格 = 采用注解形式实现Spring AOP

    先前写的了两篇博文，描述了 XML风格和 AspectJ风格的使用示例，有兴趣可看看：

    XML风格：http://xtu-xiaoxin.iteye.com/admin/blogs/630787
   AspectJ风格:http://xtu-xiaoxin.iteye.com/blog/630206

    1. 首先,对注解的支持是在Java5版本以后,所以,如果你使用的是java5版本以下的JVM,
不用考虑,必须选择XML风格 (XML配置形式的),而非注解形式(AspectJ风格)的。

    2. 使用XML风格,则所有的切面、切点、通知等配置都写在一个或几个Spring配置文件里。
这样的好处是，从配置文件中，就可以很清晰的看出系统中的有哪些切面,某个切面里使用那个的
通知(advice)以及通知(advice)作用的切点。而在AspectJ风格中,在java程序中标识切面
则显得凌乱、模糊。

    在什么情况下使用注解形式的AOP?或者说使用注解来实现AOP有哪些优点呢?

    1. XML风格的AOP仅仅支持"singleton"切面实例模型,而采用AspectJ风格的AOP则
没有这个限制。

    2.XML风格的AOP中是不支持命名连接点的声明,而采用AspectJ风格的AOP则没有这个限制。不太理解的看下面实例代码：
在@AspectJ风格中我们可以编写如下的内容：

Java代码

1 @Pointcut(execution(* get*()))  
2                 public void propertyAccess() {}  
3                   
4                 @Pointcut(execution(org.xyz.Account+ *(..))  
5                 public void operationReturningAnAccount() {}  
6                   
7                 @Pointcut(propertyAccess() && operationReturningAnAccount())  
8             public void accountPropertyAccess() {}

在XML风格中，我们不能使用'&&'字符来连接命名连接点，如下：

1 Java代码  
2 <aop:pointcut id="propertyAccess"  
3                 expression="execution(* get*())"/>  
4                   
5                 <aop:pointcut id="operationReturningAnAccount"  
6             expression="execution(org.xyz.Account+ *(..))"/>  
7             <!-- 错误的配置  -->  
8           <aop:pointcut id="accountPropertyAccess"  
9             expression="propertyAccess &&　operationReturningAnAccount"/>

注意： XML风格AOP虽然不支命名连接点的声明,但是，可以使用如下形式处理，如下配置：

Java代码

1 <aop:pointcut id="propertyAccess"  
2                 expression="execution(* get*())"/>  
3    <aop:pointcut id="operationReturningAnAccount"  
4             expression="execution(org.xyz.Account+ *(..))"/>  
5     <aop:pointcut id="accountPropertyAccess"  
6             expression="execution(* get*()) and execution(org.xyz.Account+ *(..))"/>

这里对Spring中使用AOP两种不同的配置方式作了个简单的比较，希望对大家有点用处。

/、注解方式

下面主要描述spring中使用AOP的两个例子：一个采用注解的方式来实现，另一个采用声
明的方式来实现。描述这两个例子有两个目的：一是熟悉spring中的AOP使用，二就是以这些
例子作为以后对spring AOP分析作铺垫。废话少说，首先复兴下AOP种一些比较重要的概念：

    Joinpoint（连接点）：程序执行时的某个特定的点，在Spring中就是某一个方法的执行
    Pointcut（切点）：说的通俗点，spring中AOP的切点就是指一些方法的集合，而这些方法
是需要被增强、被代理的。一般都是按照一定的约定规则来表示的，如正则表达式等。切点是
由一类连接点组成。
    Advice（通知)：还是说的通俗点，就是在指定切点上要干些什么。
    Advisor（通知器)：其实就是切点和通知的结合

    好了，概念就不多说了，如果要了解详细点，可以google一把，现在先描述出两个例子中
的一个，其中一个是采用注解的方式来实行切面编程，具体如下：

    首先，在spring配置文件中加入如下配置（用来申明spring对@AspectJ的支持）：
    <aop:aspectj-autoproxy/>
如果你使用的是DTD，可以在Spring配置文件中加入如下配置来申明spring对@Aspect的支
持：
   <bean class="org.springframework.aop.aspectj.annotation.
                       AnnotationAwareAspectJAutoProxyCreator" />
    编写目标对象类（CommonEmployee.java），具体代码如下（省略接口类)：

Java代码

 1 package com.aop;  
 2   
 3 public class CommonEmployee implements Employee{  
 4   
 5     private String name;  
 6       
 7     public String getName() {  
 8         return name;  
 9     }  
10   
11     public void setName(String name) {  
12         this.name = name;  
13     }  
14       
15     public void signIn() {  
16        System.out.println(name+"已经签到了...........");  
17     }  
18 }

然后编写通知类AspectJLogger.java,在该通知类里，通过注入的形式来定义切面、通知以及通知所左右的切点，具体如下：

Java代码

 1 package com.aop;  
 2   
 3 import java.util.Date;  
 4   
 5 import org.aspectj.lang.ProceedingJoinPoint;  
 6 import org.aspectj.lang.annotation.After;  
 7 import org.aspectj.lang.annotation.Around;  
 8 import org.aspectj.lang.annotation.Aspect;  
 9 import org.aspectj.lang.annotation.Before;  
10   
11 /** 
12  * 使用@Aspect 注解的类， Spring 将会把它当作一个特殊的Bean（一个切面），也就是 
13  * 不对这个类本身进行动态代理 
14  */  
15 @Aspect    
16 public class AspectJLogger {  
17     /** 
18      * 必须为final String类型的,注解里要使用的变量只能是静态常量类型的 
19      */  
20     public static final String EDP = "execution(* com.aop.CommonEmployee.sign*(..))";  
21       
22     @Before(EDP)    //spring中Before通知  
23     public void logBefore() {  
24         System.out.println("logBefore:现在时间是:"+new Date());  
25     }  
26       
27     @After(EDP)    //spring中After通知  
28     public void logAfter() {  
29         System.out.println("logAfter:现在时间是:"+new Date());  
30     }  
31       
32     @Around(EDP)   //spring中Around通知  
33     public Object logAround(ProceedingJoinPoint joinPoint) {  
34         System.out.println("logAround开始:现在时间是:"+new Date()); //方法执行前的代理处理  
35         Object[] args = joinPoint.getArgs();  
36         Object obj = null;  
37         try {  
38             obj = joinPoint.proceed(args);  
39         } catch (Throwable e) {  
40             e.printStackTrace();  
41         }  
42         System.out.println("logAround结束:现在时间是:"+new Date());  //方法执行后的代理处理  
43         return obj;  
44     }  
45 }

然后，在Spring的配置文件中作如下配置：

Java代码

1 <aop:aspectj-autoproxy/>   
2 <bean id="aspect" class="com.aop.AspectJLogger" />  
3 <bean id="employee" class="com.aop.CommonEmployee">  
4   <property name="name" value="good"></property>  
5 </bean>

编写测试类Test.java,具体如下：

Java代码

 1 package com;  
 2   
 3 import org.springframework.context.ApplicationContext;  
 4 import org.springframework.context.support.ClassPathXmlApplicationContext;  
 5   
 6 import com.aop.Employee;  
 7   
 8 public class Test {  
 9     public static void main(String[] args) throws Exception{  
10         ApplicationContext act = new ClassPathXmlApplicationContext("applicationContext-aop.xml");  
11         Employee e = (Employee)act.getBean("employee");  
12         e.signIn();  
13           
14     }  
15 }

测试得出结果为：logBefore:现在时间是:Thu Apr 01 16:34:27 CST 2010
               logAround开始:现在时间是:Thu Apr 01 16:34:27 CST 2010
      good已经签到了...........
      logAfter:现在时间是:Thu Apr 01 16:34:27 CST 2010
      logAround结束:现在时间是:Thu Apr 01 16:34:27 CST 2010
一些注意的知识：
               1.环绕方法通知，环绕方法通知要注意必须给出调用之后的返回值，否
        则被代理的方法会停止调用并返回null，除非你真的打算这么做。

                 2.只有环绕通知才可以使用JoinPoint的子类ProceedingJoinPoint，个
                    连接点类型可以调用代理的方法，并获取、改变返回值。

2、声明方式

CommonEmployee.java和注解AOP中的类一样，没有变化，也就是说目标对象是不变的,
具体想要了解该类详细代码,请看上篇blog。

通知类发生了一点小改变，具体通知类Logger.java如下：

Java代码

 1 package com.aop;  
 2   
 3 import java.util.Date;  
 4 import org.aspectj.lang.ProceedingJoinPoint;  
 5   
 6 public class Logger{  
 7   
 8     //spring中Before通知  
 9     public void logBefore() {  
10         System.out.println("logBefore:现在时间是:"+new Date());  
11     }  
12       
13     //spring中After通知  
14     public void logAfter() {  
15         System.out.println("logAfter:现在时间是:"+new Date());  
16     }  
17       
18     //spring中Around通知  
19     public Object logAround(ProceedingJoinPoint joinPoint) {  
20         System.out.println("logAround开始:现在时间是:"+new Date()); //方法执行前的代理处理  
21         Object[] args = joinPoint.getArgs();  
22         Object obj = null;  
23         try {  
24             obj = joinPoint.proceed(args);  
25         } catch (Throwable e) {  
26             e.printStackTrace();  
27         }  
28         System.out.println("logAround结束:现在时间是:"+new Date());  //方法执行后的代理处理  
29         return obj;  
30     }  
31       
32 }

可以看见，上面的通知类没有引入注解了。所以，要想在spring中使用没有注解的通知类，
则必须在spring配置文件中作如下配置：

Java代码

 1 <bean id="employee" class="com.aop.CommonEmployee">  
 2       <property name="name" value="good"></property>  
 3     </bean>  
 4     <bean id="advice" class="com.aop.Logger" />  
 5    <aop:config >  
 6      <aop:aspect ref="advice">  
 7         <aop:pointcut id="pointcut" expression="execution(* com.aop.CommonEmployee.sign*(..))"/>  
 8         <aop:before method="logBefore" pointcut-ref="pointcut"/>  
 9         <aop:after method="logAfter" pointcut-ref="pointcut"/>  
10         <aop:around method="logAround" pointcut-ref="pointcut"/>  
11       </aop:aspect>  
12    </aop:config>

最后，测试类Test.java代码已在上篇博文中贴出，详细请看：
http://xtu-xiaoxin.iteye.com/blog/630206

最后得出测试结果如下：
logBefore:现在时间是:Fri Apr 02 14:44:37 CST 2010
logAround开始:现在时间是:Fri Apr 02 14:44:37 CST 2010
good已经签到了...........
logAfter:现在时间是:Fri Apr 02 14:44:37 CST 2010
logAround结束:现在时间是:Fri Apr 02 14:44:37 CST 2010

参考：

http://xtu-xiaoxin.iteye.com/blog/637909

http://xtu-xiaoxin.iteye.com/blog/630206

http://xtu-xiaoxin.iteye.com/blog/630787

http://www.psjay.com/summary-of-spring-3-aop.html

http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/aop.html#aop-schema

http://zywang.iteye.com/blog/974226

posted on 2016-09-21 16:40 药药发呆阅读(137) 评论(0) 收藏举报

刷新页面返回顶部

导航

（转）Spring AOP实现方式（转）