`

AOP实现(二)——Spring 2.0中的AOP实现

阅读更多
    在Spring 2.0中,除了传统的通过实现AOP AIP的方式来实现Advice之外,还提供了两种更加简便的方式来实现Advice1)基于XML Schema的设置;2)基于Annotation的支持,采用这两种方式,Advice将不用实现特定的接口。现在让我们来看看如何使用这两种方式来分别实现Before AdviceAfter AdviceAround AdviceThrowing Advice
   
一、Before Advice:基于XML Schema
当基于XML Schema实现Before Advice时,你的Advice类不用实现org.springframework.aop.MethodBeforeAdvice接口,例如:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4.   
  5. public class LogBeforeAdvice {  
  6.     public void before(JoinPoint joinPoint) {  
  7.         System.out.println("Logging before " + joinPoint.getSignature().getName());  
  8.     }  
  9. }  


          before
方法是在目标对象上的方法被执行前要执行的方法,before方法中的JoinPoint参数是可选项,你可以根据需要决定是否需要JoinPoint参数,通过JoinPoint对象,你可以获得目标对象(getTarget())、目标方法上的参数(getArgs())等信息。
    
然后在XML中为目标对象指定LogBeforeAdvice代理:
xml 代码
 
  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="http://www.springframework.org/schema/beans  
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  7.     http://www.springframework.org/schema/aop  
  8.     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  9.     <bean id="messageSender" class="com.savage.aop.HttpMessageSender"></bean>  
  10.       
  11.     <bean id="logBeforeAdvice" class="com.savage.aop.LogBeforeAdvice"></bean>  
  12.       
  13.     <aop:config>  
  14.         <aop:aspect id="logBefore" ref="logBeforeAdvice">  
  15.             <aop:before pointcut="execution(* com.savage.aop.MessageSender.*(..))"
  16.                         method="before"/>  
  17.         </aop:aspect>  
  18.     </aop:config>  
  19. </beans>  


    
如上所示,在Spring 2.0中要使用基于XML Sechma声明AOP的方式,需要在XML中加入aop的名称空间。当基于XML Sechma实现AOP时,所有的AOP都是在<aop:config></aop:config>标签中声明的,<aop:aspect></aop:aspect>用于定义Advice实例。<aop:before></aop:before>表示当前实例用于实现Before Advicepointcut属性用于指定pointcut表示式,上面的例子表示此Advice将应用于com.savage.aop.MessageSender接口中的任何方法;method属性表示Advice上要调用的方法。
    
现在调用任何MessageSender接口上的方法之前都会执行LogBeforeAdvicebefore方法,例如:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  5.   
  6. public class AdviceDemo {  
  7.     public static void main(String[] args) {  
  8.         ApplicationContext context =
  9.                            new ClassPathXmlApplicationContext("beans-config.xml");  
  10.         MessageSender sender = (MessageSender)context.getBean("messageSender");  
  11.         sender.sendMessage("message");  
  12.     }  
  13. }  

    
二、Before Advice:基于Annotation
        
使用Annotation来实现Advice,在XML文件上的定义要比基于XML Sechema的方法要简便的多,但在实现Before Advice类时,则需要使用到@Aspect@Before标识,并需要引入org.aspectj.lang.annotation包中的类。还以LogBeforeAdvice为例,LogBeforeAdvice类需要改为:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.Aspect;  
  5. import org.aspectj.lang.annotation.Before;  
  6.   
  7. @Aspect  
  8. public class LogBeforeAdvice {  
  9.     @Before("execution(* com.savage.aop.MessageSender.*(..))")  
  10.     public void before(JoinPoint joinPoint) {  
  11.         System.out.println("Logging before " + joinPoint.getSignature().getName());  
  12.     }  
  13. }  


    
如上所示,通过@Aspect将一个类声明为Aspect类,通过@Before将方法声明Before Advice,方法中的JoinPoint同样是可选的。然后在XML文件中做如下定义:
xml 代码
 
  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="http://www.springframework.org/schema/beans  
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  7.     http://www.springframework.org/schema/aop  
  8.     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  9.     <bean id="messageSender" class="com.savage.aop.HttpMessageSender"></bean>  
  10.       
  11.     <bean id="logBeforeAdvice" class="com.savage.aop.LogBeforeAdvice"></bean>  
  12.       
  13.     <aop:aspectj-autoproxy/>  
  14. </beans>  


    
所有基于Annotation实现的Advice,在XML文件中都只要使用<aop:aspectj-autoproxy></aop:aspectj-autoproxy>进行设置就可以了,非常简单。

    
三、After Advice:基于XML Sechma
        
Before Advice一样,基于XML Sechma实现After Returning Advice时,不再需要org.springframework.aop.AfterReturningAdvice接口:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4.   
  5. public class LogAfterReturningAdvice {  
  6.     public void afterReturning(JoinPoint joinPoint) {  
  7.         System.out.println("Logging after " + joinPoint.getSignature().getName());  
  8.     }  
  9. }  


然后在XML中做如下设置:
xml 代码
 
  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="http://www.springframework.org/schema/beans  
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  7.     http://www.springframework.org/schema/aop  
  8.     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  9.     <bean id="messageSender" class="com.savage.aop.HttpMessageSender"></bean>  
  10.       
  11.     <bean id="logAfterReturningAdvice" 
  12.           class="com.savage.aop.LogAfterReturningAdvice"></bean>  
  13.       
  14.     <aop:config>  
  15.         <aop:aspect id="logAfterReturning" ref="logAfterReturningAdvice">  
  16.             <aop:after-returning   
  17.                 pointcut="execution(* com.savage.aop.MessageSender.*(..))"   
  18.                 method="logAfterReturning"/>  
  19.         </aop:aspect>  
  20.     </aop:config>  
  21. </beans>  


    四、After Advice:基于Annotation
       
Before Advice相似,使用@AfterReturning来表示After Returning Advice
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.Aspect;  
  5. import org.aspectj.lang.annotation.AfterReturning;  
  6.   
  7. @Aspect  
  8. public class AfterReturningAdvice {  
  9.     @AfterReturning(pointcut="execution(* com.savage.aop.MessageSender.*(..))",
  10.                     returning="retVal")  
  11.     public void afterReturning(JoinPoint joinPoint, Object retVal) {  
  12.         System.out.println("Logging after " + joinPoint.getSignature().getName());  
  13.     }  
  14. }  


    
这里和Before Advice有点不同的是,在定义Poincut表示式时,多了一个returning属性,用于指定目标方法执行完后的返回值。
    
XML文件中的设置与LogBeforeAdvice的相似(将logBeforeAdvice的定义改为logAfterReturning的定义),不再列举。

    
五、Around Advice:基于XML Sechma
         
Spring 2.0中,Around Advice不用实现org.aoplliance.intercept.MethodInterceptor接口,但Advice的方法必须返回对象,并且必须定义一个ProceedingJoinPoint参数,例如:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.ProceedingJoinPoint;  
  4.   
  5. public class LogAroundAdvice {  
  6.     public void invoke(ProceedingJoinPoint joinPoint) {  
  7.         System.out.println("Logging before " + joinPoint.getSignature().getName());  
  8.         Object retVal = joinPoint.proceed();  
  9.         System.out.println("Logging after " + joinPoint.getSignature().getName());  
  10.         return retVal;  
  11.     }  
  12. }  


XML中的设置如下:
xml 代码
 
  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="http://www.springframework.org/schema/beans  
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  7.     http://www.springframework.org/schema/aop  
  8.     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  9.     <bean id="messageSender" class="com.savage.aop.HttpMessageSender"></bean>  
  10.       
  11.     <bean id="logAroundAdvice" class="com.savage.aop.LogAroundAdvice"></bean>  
  12.       
  13.     <aop:config>  
  14.         <aop:aspect id="logAround" ref="logAroundAdvice">  
  15.             <aop:around   
  16.                 pointcut="execution(* com.savage.aop.MessageSender.*(..))"   
  17.                 method="invoke"/>  
  18.         </aop:aspect>  
  19.     </aop:config>  
  20. </beans>  


    
六、Around Advice:基于Annotation
         
Before Advice相似,使用@Around来表示Around Advice
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.ProceedingJoinPoint;  
  4. import org.aspectj.lang.annotation.Aspect;  
  5. import org.aspectj.lang.annotation.Around;  
  6.   
  7. @Aspect  
  8. public class AfterReturningAdvice {  
  9.     @Around("execution(* com.savage.aop.MessageSender.*(..))")  
  10.     public void invoke(ProceedingJoinPoint joinPoint) {  
  11.         System.out.println("Logging before " + joinPoint.getSignature().getName());  
  12.         Object retVal = joinPoint.proceed();  
  13.         System.out.println("Logging after " + joinPoint.getSignature().getName());  
  14.         return retVal;  
  15.     }  
  16. }  


    
XML文件中的设置与LogBeforeAdvice的相似(将logBeforeAdvice的定义改为logAroundAdvice的定义),不再列举。

    
七、Throw Advice:基于XML Sechma
        
Spring 2.0中,Throw Advice不用实现org.springframework.aop.ThrowsAdvice接口,但Advice的方法必须定义Throwable(或其子类)参数,例如:
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4.   
  5. public class LogThrowingAdvice {  
  6.     public void afterThrowing (JoinPoint joinPoint, Throwable throwable) {  
  7.         System.out.println("Logging when throwing " + joinPoint.getSignature().getName());  
  8.     }  
  9. }  


XML的设置如下:
xml 代码
 
  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="http://www.springframework.org/schema/beans  
  6.     http://www.springframework.org/schema/beans/spring-beans-2.0.xsd  
  7.     http://www.springframework.org/schema/aop  
  8.     http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">  
  9.     <bean id="messageSender" class="com.savage.aop.HttpMessageSender"></bean>  
  10.       
  11.     <bean id="logThrowingAdvice" class="com.savage.aop.LogThrowingAdvice"></bean>  
  12.       
  13.     <aop:config>  
  14.         <aop:aspect id="logThrowing" ref="logThrowingAdvice">  
  15.             <aop:after-throwing   
  16.                 pointcut="execution(* com.savage.aop.MessageSender.*(..))"  
  17.                 throwing="throwable"  
  18.                 method="afterThrowing"/>  
  19.         </aop:aspect>  
  20.     </aop:config>  
  21. </beans>  


    
<aop:after-throwing></aop:after-throwing>中必须定义throwing属性,指定方法中的throwable参数。Spring将根据异常类型决定是否调用afterThrowing方法。

    
八、Throw Advice:基于Annotation
java 代码
 
  1. package com.savage.aop;  
  2.   
  3. import org.aspectj.lang.JoinPoint;  
  4. import org.aspectj.lang.annotation.Aspect;  
  5. import org.aspectj.lang.annotation.AfterThrowing;  
  6.   
  7. @Aspect  
  8. public class AfterThrowingAdvice {  
  9.     @AfterThrowing(pointcut="execution(* com.savage.aop.MessageSender.*(..))",
  10.                    throwing="throwable")  
  11.     public void afterThrowing(JoinPoint joinPoint, Throwable throwable) {  
  12.         System.out.println("Logging when throwing "
  13.                            + joinPoint.getSignature().getName());  
  14.     }  
  15. }  


       XML
文件中的设置与LogBeforeAdvice的相似(将logBeforeAdvice的定义改为logThrowingAdvice的定义),不再列举。

    九、Pointcut
    在Spring 2.0中,
分享到:
评论
1 楼 luup333 2008-10-30  
寫的很好,我剛學spring,對我很有幫助。

相关推荐

    spring2.0中文开发参考手册.chm.zip

    Spring支持基于代理的AOP和基于元数据的AOP,提供了灵活的切面实现方式。 4. **IoC容器与Bean**:在Spring中,每个Java对象被称为一个Bean,由IoC容器管理其生命周期。Bean可以通过XML、注解或Java配置进行定义,...

    spring2.0-中文参考手册.pdf

    根据提供的信息来看,这份文档似乎包含了Spring 2.0框架的一些基本概念和技术要点,但由于文本内容较为混乱且不可读,我们将基于文档标题“spring2.0-中文参考手册.pdf”及描述来构建相关的知识点。 ### Spring 2.0...

    spring 2.0使用AOP实例(基于Annotation的配置方式)

    这篇博客文章将探讨如何在Spring 2.0中使用AOP实例,特别是通过注解来实现。 首先,我们需要了解AOP的基本概念。AOP的核心是切面(Aspect),它封装了横切关注点,即那些跨越多个对象的行为或责任。在Spring中,切...

    spring2.0hibernate3.1

    提供的两个CHM文件——hibernate3.1.CHM和Spring2.0.chm,是官方的英文帮助文档,对于深入理解Spring 2.0和Hibernate 3.1的细节、API以及最佳实践具有极大价值。通过阅读这些文档,开发者可以掌握这两个框架的核心...

    spring 2.0 jar

    在描述中提到的"spring 2.0 jar"是一个完整的Spring框架的二进制库文件,它包含了所有Spring 2.0版本的类和资源。这个jar文件可能是从学校的网站上下载的,通常用于搭建开发环境或教学目的。由于作者表示自己没有试...

    Spring_2.0_Samples

    在Spring 2.0中,DI可以通过XML配置、注解或基于Java的配置实现。例如,`@Autowired`注解可以自动将符合条件的bean注入到目标字段或方法中,极大地简化了代码。 其次,Spring的IoC(Inversion of Control,控制反转...

    spring2.0和spring2.5 及以上版本的jar包区别 spring jar 包详解

    在Spring2.0时代,为了方便开发者快速构建应用程序,提供了一个包含几乎所有核心功能的单一jar包——`spring.jar`。这个单一的jar包几乎包含了除了`spring-mock.jar`之外的所有内容,因为`spring-mock.jar`主要是在...

    spring security 2.0 的简单配置使用(补)——用aop控制method级权限

    在本文中,我们将深入探讨如何在Spring Security 2.0版本中配置并使用AOP(面向切面编程)来实现方法级别的权限控制。首先,我们需要理解Spring Security的基础概念。 1. **Spring Security基本架构** Spring ...

    SpringReference2.0RC2.chm

    7. **Spring AOP代理**:Spring通过两种代理模式实现AOP——JDK动态代理和CGLIB代理。前者适用于接口实现类,后者适用于没有实现接口的类。代理模式使得可以在不修改原有代码的情况下,向方法添加增强功能。 8. **...

    SSHAPI,绝对chm格式,包括Hibernate,spring2.0,struts-2

    SSHAPI 是一个集合了三个主流Java企业级开发框架——Spring、Hibernate和Struts2的API文档,以CHM(Compiled Help Manual)格式呈现。CHM是一种由微软开发的帮助文件格式,它将HTML文档集合在一起,形成一个可搜索的...

    Java人力资源管理系统,基于 spring mvc,Spring2,Hibernate3 框架开发

    《Java人力资源管理系统详解——基于Spring MVC、Spring 2.0与Hibernate 3.0框架》 在现代企业管理中,人力资源管理扮演着至关重要的角色。利用先进的技术手段进行人力资源的信息化管理,可以极大地提高企业的运营...

    Spring 参考手册及开发指南中文版

    以下是对这两个文档——"Spring2.0参考手册(中文).pdf"和"Spring开发指南中文.pdf"中关键知识点的详细解读。 1. **依赖注入(Dependency Injection, DI)**:这是Spring的核心特性之一,允许开发者将对象间的依赖...

    Spring 中文教程

    本教程将基于提供的两本PDF文档——"Spring 2.0 中文用户指南"和"SpringGuide",来深入探讨Spring的核心概念和技术。 一、Spring框架概述 Spring是一个开源的应用程序框架,它旨在简化Java企业级应用的开发。它通过...

    spring 学习第二天

    在 Spring 2.0 版本中,引入了基于 XML 的 AOP 配置支持。这种方式通过在 XML 文件中定义切面、切入点和通知来实现 AOP 功能。 - **`&lt;aop:config&gt;`**:用于配置 AOP,包括定义切面、切入点和通知等。 - **`&lt;aop:...

    spring技术文档

    - **2.3.2 支持@AspectJ切面**:Spring 2.0支持@AspectJ切面语法,使得AOP的实现更加自然。 **2.4 中间层** - **2.4.1 更简单的声明式事务配置**:在XML中配置声明式事务变得更加直观,简化了事务管理的复杂度。 -...

    精通 Spring_2.x_6-9 精通 Spring_2.x_6-9

    Spring框架中的AOP实现主要依赖于Spring的核心特性之一——IoC(Inversion of Control,控制反转)。Spring AOP构建在IoC容器之上,使得开发者可以利用Spring框架本身提供的强大功能来实现AOP。Spring 2.0版本对AOP...

    spring2.5+struts2.0+hibernate3.0分页

    本项目基于经典的Java企业级开发框架——Spring 2.5、Struts 2.0和Hibernate 3.0实现了一个分页功能。下面我们将详细探讨这三个框架以及它们如何协同工作来实现分页。 首先,Spring 2.5是IoC(Inversion of Control...

    Hibernate3.2和Spring3.0学习jar包

    【标题】"Hibernate3.2和Spring3.0学习jar包"揭示了这个压缩包包含的是两个关键的Java开发框架——Hibernate3.2与Spring3.0的核心库。这两个框架在企业级Java应用中占据着重要的地位,尤其在处理持久化层和依赖注入...

    利用Spring实现工作流

    例如,Activiti是一个基于BPMN 2.0标准的开源工作流引擎,它可以与Spring无缝集成,实现流程定义、启动、查询和控制等功能。 在创建一个简单的工作流引擎时,我们首先需要定义流程模型。这通常通过XML文件或图形化...

    spring-aspects.jar

    首先,`spring-aspects.jar`是Spring框架的AOP模块,它包含了Spring对AspectJ库的支持,使得开发者可以在Spring环境中无缝地实现AOP。AspectJ是一种全面的AOP解决方案,能够处理编译时和运行时的切面,而Spring AOP...

Global site tag (gtag.js) - Google Analytics