`
tjukk
  • 浏览: 45081 次
  • 性别: Icon_minigender_1
  • 来自: 天津
社区版块
存档分类
最新评论

Spring AOP

 
阅读更多

转自:http://blog.csdn.net/a906998248/article/details/7514969

 

一、什么是 AOP。

AOP(Aspect Orient Programming),也就是面向切面编程。可以这样理解,面向对象编程(OOP)是从静态角度考虑程序结构,面向切面编程(AOP)是从动态角度考虑程序运行过程

 

二、AOP 的作用。

常常通过 AOP 来处理一些具有横切性质的系统性服务,如事物管理、安全检查、缓存、对象池管理等,AOP 已经成为一种非常常用的解决方案。

 

三、AOP 的实现原理。

<img src="AOP代理.jpg" />

如图:AOP 实际上是由目标类的代理类实现的AOP 代理其实是由 AOP 框架动态生成的一个对象,该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法,但 AOP 代理中的方法与目标对象的方法存在差异,AOP 方法在特定切入点添加了增强处理,并回调了目标对象的方法

 

四、Spring 中对 AOP 的支持

Spring 中 AOP 代理由 Spring 的 IoC 容器负责生成、管理,其依赖关系也由 IoC 容器负责管理。因此,AOP 代理可以直接使用容器中的其他 Bean 实例作为目标,这种关系可由 IoC 容器的依赖注入提供。Spring 默认使用 Java 动态代理来创建 AOP 代理, 这样就可以为任何接口实例创建代理了。当需要代理的类不是代理接口的时候, Spring 自动会切换为使用 CGLIB 代理,也可强制使用 CGLIB。 

AOP 编程其实是很简单的事情。纵观 AOP 编程, 其中需要程序员参与的只有三个部分:

 

  • 定义普通业务组件。
  • 定义切入点,一个切入点可能横切多个业务组件。
  • 定义增强处理,增强处理就是在 AOP 框架为普通业务组件织入的处理动作。

 

所以进行 AOP 编程的关键就是定义切入点和定义增强处理。一旦定义了合适的切入点和增强处理,AOP 框架将会自动生成 AOP 代理,即:代理对象的方法 = 增强处理 + 被代理对象的方法

 

五、Spring 中 AOP 的实现。

Spring 有如下两种选择来定义切入点和增强处理。

 

  • 基于 Annotation 的“零配置”方式:使用@Aspect、@Pointcut等 Annotation 来标注切入点和增强处理。
  • 基于 XML 配置文件的管理方式:使用 Spring 配置文件来定义切入点和增强点。

 

1、基于 Annotation 的“零配置”方式。

(1)、首先启用 Spring 对 @AspectJ 切面配置的支持。

 

[java] view plaincopy
 
  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-3.0.xsd  
  7.            http://www.springframework.org/schema/aop  
  8.        http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">  
  9.         <!-- 启动对@AspectJ注解的支持 -->  
  10.         <aop:aspectj-autoproxy/>  
  11. </beans>  


如果不打算使用 Spring 的 XML Schema 配置方式,则应该在 Spring 配置文件中增加如下片段来启用@AspectJ 支持。

 

 

[java] view plaincopy
 
  1. <!-- 启用@AspectJ 支持 -->  
  2. <bean class="org.springframeword.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator" />  

 

 

(2)、定义切面 Bean。

当启动了@AspectJ 支持后,只要在 Spring 容器中配置一个带@Aspect 注释的 Bean, Spring 将会自动识别该 Bean 并作为切面处理。

 

[java] view plaincopy
 
  1. // 使用@Aspect 定义一个切面类  
  2. @Aspect  
  3. public class LogAspect {  
  4.         // 定义该类的其他内容  
  5.         ...  
  6. }  

 

 

(3)、定义 Before 增强处理。

 

 

[java] view plaincopy
 
  1. // 定义一个切面  
  2. @Aspect  
  3. public class BeforeAdviceTest {  
  4.     // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点  
  5.     @Before("execution(* com.wicresoft.app.service.impl.*.*(..))")  
  6.     public void authorith(){  
  7.         System.out.println("模拟进行权限检查。");  
  8.     }  
  9. }  

 

 

上面使用@Before Annotation 时,直接指定了切入点表达式,指定匹配 com.wicresoft.app.service.impl包下所有类的所有方法执行作为切入点。
关于这个表达式的规则如下图。

 

(4)、定义 AfterReturning 增强处理。

 

[java] view plaincopy
 
  1. // 定义一个切面  
  2. @Aspect  
  3. public class AfterReturningAdviceTest {  
  4.     // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点  
  5.     @AfterReturning(returning="rvt", pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))")  
  6.     public void log(Object rvt) {  
  7.         System.out.println("模拟目标方法返回值:" + rvt);  
  8.         System.out.println("模拟记录日志功能...");  
  9.     }  
  10. }  

 

 

(5)、定义 AfterThrowing 增强处理。

 

 

[java] view plaincopy
 
  1. // 定义一个切面  
  2. @Aspect  
  3. public class AfterThrowingAdviceTest {  
  4.     // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点  
  5.     @AfterThrowing(throwing="ex", pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))")  
  6.     public void doRecoverActions(Throwable ex) {  
  7.         System.out.println("目标方法中抛出的异常:" + ex);  
  8.         System.out.println("模拟抛出异常后的增强处理...");  
  9.     }  
  10. }  

 

 

(6)、定义 After 增强处理。

 

After 增强处理与AfterReturning 增强处理有点相似,但也有区别:

 

  • AfterReturning 增强处理处理只有在目标方法成功完成后才会被织入。
  • After 增强处理不管目标方法如何结束(保存成功完成和遇到异常中止两种情况),它都会被织入。

 

 

[java] view plaincopy
 
  1. // 定义一个切面  
  2. @Aspect  
  3. public class AfterAdviceTest {  
  4.     // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点  
  5.     @After("execution(* com.wicresoft.app.service.impl.*.*(..))")  
  6.     public void release() {  
  7.         System.out.println("模拟方法结束后的释放资源...");  
  8.     }  
  9. }  

 

 

(7)、Around 增强处理

 

Around 增强处理近似等于 Before 增强处理和  AfterReturning 增强处理的总和。它可改变执行目标方法的参数值,也可改变目标方法之后的返回值。

 

[java] view plaincopy
 
  1. // 定义一个切面  
  2. @Aspect  
  3. public class AroundAdviceTest {  
  4.     // 匹配 com.wicresoft.app.service.impl 包下所有类的所有方法作为切入点  
  5.     @Around("execution(* com.wicresoft.app.service.impl.*.*(..))")  
  6.     public Object processTx(ProceedingJoinPoint jp) throws java.lang.Throwable {  
  7.         System.out.println("执行目标方法之前,模拟开始事物...");  
  8.         // 执行目标方法,并保存目标方法执行后的返回值  
  9.         Object rvt = jp.proceed(new String[]{"被改变的参数"});  
  10.         System.out.println("执行目标方法之前,模拟结束事物...");  
  11.         return rvt + "新增的内容";  
  12.     }  
  13. }  

 

 

(8)、访问目标方法的参数。

 

访问目标方法最简单的做法是定义增强处理方法时将第一个参数定义为 JoinPoint 类型,当该增强处理方法被调用时,该 JoinPoint 参数就代表了织入增强处理的连接点。JoinPoint 里包含了如下几个常用方法。

 

  • Object[] getArgs(): 返回执行目标方法时的参数。
  • Signature getSignature(): 返回被增强的方法的相关信息。
  • Object getTarget(): 返回被织入增强处理的目标对象。
  • Object getThis(): 返回 AOP 框架为目标对象生成的代理对象。

 

提示当时使用 Around 处理时,我们需要将第一个参数定义为 ProceedingJoinPoint 类型,该类型是 JoinPoint 类型的子类

 

(9)、定义切入点。

所谓切入点,其实质就是为一个切入点表达式起一个名称,从而允许在多个增强处理中重用该名称。

Spring 切入点定义包含两个部分:

 

  • 一个切入点表达式。
  • 一个包含名字和任意参数的方法签名。

 

 

[java] view plaincopy
 
  1. // 使用@Pointcut Annotation 时指定切入点表达式  
  2. @pointcut("execution * transfer(..)")  
  3. // 使用一个返回值为void,方法体为空的方法来命名切入点  
  4. private void anyOldTransfer(){}  
  5.   
  6. // 使用上面定义的切入点  
  7. @AfterReturning(pointcut="anyOldTransfer()", returning="reVal")  
  8. public void writeLog(String msg, Object reVal){  
  9.     ...  
  10. }  

 

 

2、基于 XML 配置文件的管理方式。

 

 

  • 不配置切入点

 

 

[java] view plaincopy
 
  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-3.0.xsd  
  7.            http://www.springframework.org/schema/aop  
  8.        http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">  
  9.         <aop:config>  
  10.             <!-- 将 fourAdviceBean 转换成切面 Bean, 切面 Bean 的新名称为:fourAdviceAspect,指定该切面的优先级为2 -->  
  11.             <aop:aspect id="fourAdviceAspect" ref="fourAdviceBean" order="2">  
  12.                 <!-- 定义个After增强处理,直接指定切入点表达式,以切面 Bean 中的 Release() 方法作为增强处理方法 -->  
  13.                 <aop:after pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="release" />  
  14.                   
  15.                 <!-- 定义个Before增强处理,直接指定切入点表达式,以切面 Bean 中的 authority() 方法作为增强处理方法 -->  
  16.                 <aop:before pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="authority" />  
  17.                   
  18.                 <!-- 定义个AfterReturning增强处理,直接指定切入点表达式,以切面 Bean 中的 log() 方法作为增强处理方法 -->  
  19.                 <aop:after-returning pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="log" />  
  20.                   
  21.                 <!-- 定义个Around增强处理,直接指定切入点表达式,以切面 Bean 中的 processTx() 方法作为增强处理方法 -->  
  22.                 <aop:around pointcut="execution(* com.wicresoft.app.service.impl.*.*(..))" method="processTx" />  
  23.                   
  24.             </aop:aspect>  
  25.         </aop:config>  
  26.           
  27.         <!-- 省略各个Bean 的配置 -->  
  28.         <!-- ... -->  
  29.           
  30. </beans>  

 

 

  • 配置切入点

 

 

[java] view plaincopy
 
  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-3.0.xsd  
  7.            http://www.springframework.org/schema/aop  
  8.        http://www.springframework.org/schema/beans/spring-aop-3.0.xsd">  
  9.         <aop:config>  
  10.             <!-- 定义一个切入点,myPointcut,直接知道它对应的切入点表达式 -->  
  11.             <aop:pointcut id="myPointcut" expression="execution(* com.wicresoft.app.service.impl.*.*(..))" method="release" />  
  12.             <aop:aspect id="afterThrowingAdviceAspect" ref="afterThrowingAdviceBean" order="1">  
  13.                 <!-- 使用上面定于切入点定义增强处理 -->  
  14.                 <!-- 定义一个AfterThrowing 增强处理,指定切入点以切面 Bean 中的 doRecovertyActions() 方法作为增强处理方法 -->  
  15.                 <aop:after-throwing pointcut-ref="myPointcut" method="doRecovertyActions" throwing="ex" />  
  16.             </aop:aspect>  
  17.         </aop:config>  
  18.           
  19.         <!-- 省略各个Bean 的配置 -->  
  20.         <!-- ... -->  
  21.           
  22. </beans>  

 

参考:

《轻量级 Java EE 企业应用实战(第三版)》 李刚

分享到:
评论

相关推荐

    spring aop jar 包

    Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的重要组成部分,它提供了一种在不修改源代码的情况下,对程序进行功能增强的技术。这个"spring aop jar 包"包含了实现这一功能所需的类和接口,...

    Spring AOP 16道面试题及答案.docx

    Spring AOP,全称为Aspect Oriented Programming,是面向切面编程的一种编程范式,它是对传统的面向对象编程(OOP)的一种补充。在OOP中,核心是对象,而在AOP中,核心则是切面。切面是关注点的模块化,即程序中的...

    简单spring aop 例子

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点问题,如日志、事务管理、安全性等。本示例将简要介绍如何在Spring应用中实现AOP,通过实际的...

    spring aop 自定义注解保存操作日志到mysql数据库 源码

    3、对spring aop认识模糊的,不清楚如何实现Java 自定义注解的 4、想看spring aop 注解实现记录系统日志并入库等 二、能学到什么 1、收获可用源码 2、能够清楚的知道如何用spring aop实现自定义注解以及注解的逻辑...

    死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理(csdn)————程序.pdf

    Spring AOP 是一种面向切面编程的技术,它允许我们在不修改源代码的情况下,对应用程序的特定部分(如方法调用)进行增强。在 Spring 中,AOP 的实现主要依赖于代理模式,有两种代理方式:JDK 动态代理和 CGLIB 动态...

    Spring AOP完整例子

    Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许开发者在不修改源代码的情况下,通过插入切面来增强或改变程序的行为。在本教程中,我们将深入探讨Spring AOP的不同使用方法,包括定义切点、通知类型...

    Spring Aop四个依赖的Jar包

    Spring AOP,全称Aspect-Oriented Programming(面向切面编程),是Spring框架的一个重要模块,它通过提供声明式的方式来实现面向切面编程,从而简化了应用程序的开发和维护。在Spring AOP中,我们无需深入到每个...

    spring aop依赖jar包

    现在,我们回到主题——"springaop依赖的jar包"。在Spring 2.5.6版本中,使用Spring AOP通常需要以下核心jar包: - `spring-aop.jar`:这是Spring AOP的核心库,包含了AOP相关的类和接口。 - `spring-beans.jar`:...

    spring AOP 引入jar包,spring IOC 引入Jar包

    Spring AOP 和 Spring IOC 是 Spring 框架的两个核心组件,它们对于任何基于 Java 的企业级应用开发都至关重要。Spring AOP(面向切面编程)允许开发者在不修改源代码的情况下,通过“切面”来插入新的行为或增强已...

    反射实现 AOP 动态代理模式(Spring AOP 的实现原理)

    面向切面编程(AOP)是一种编程范式,旨在将横切关注点(如日志、安全等)与业务逻辑分离,从而提高模块化。...利用Java反射机制和Spring AOP框架,开发者可以方便地实现AOP,从而提升代码的模块化和可维护性。

    Spring AOP实现机制

    **Spring AOP 实现机制详解** Spring AOP(面向切面编程)是Spring框架的核心特性之一,它允许程序员在不修改源代码的情况下,通过“切面”来插入额外的业务逻辑,如日志、事务管理等。AOP的引入极大地提高了代码的...

    springAOP配置动态代理实现

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它允许程序员在不修改源代码的情况下,通过在运行时插入额外的行为(如日志记录、性能监控等)来增强对象的功能。动态代理则是Spring AOP实现的核心技术之一...

    Spring AOP面向方面编程原理:AOP概念

    ### Spring AOP面向方面编程原理:AOP概念详解 #### 一、引言 随着软件系统的日益复杂,传统的面向对象编程(OOP)逐渐暴露出难以应对某些横切关注点(cross-cutting concerns)的问题。为了解决这一挑战,面向方面编程...

    小马哥讲 Spring AOP 编程思想 - API 线索图.pdf

    在讨论Spring AOP(面向切面编程)时,首先需要理解几个核心概念。Spring AOP 是Spring框架提供的一个功能模块,它允许开发者将横切关注点(cross-cutting concerns)从业务逻辑中解耦出来,通过在方法调用前后进行...

    spring aop切面拦截指定类和方法实现流程日志跟踪

    ### Spring AOP 实现流程日志跟踪 #### 一、背景与目的 在现代软件开发过程中,为了确保系统的稳定性和可维护性,通常会引入非功能性的需求来增强应用程序的功能,比如日志记录、安全控制等。这些需求往往不是业务...

    spring aop 五个依赖jar

    Spring AOP(面向切面编程)是Spring框架的重要组成部分,它提供了一种模块化和声明式的方式来处理系统中的交叉关注点,如日志、事务管理等。在Java应用中,AOP通过代理模式实现了切面编程,使得我们可以将业务逻辑...

    Spring AOP 入门作者:廖雪峰

    ### Spring AOP 入门详解 #### 一、Spring AOP 概述 Spring AOP(Aspect Oriented Programming,面向切面编程)是Spring框架的一个关键特性,它为开发者提供了在运行时动态添加代码(即横切关注点或切面)到已有...

    Spring源码最难问题:当Spring AOP遇上循环依赖.docx

    Spring源码最难问题:当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题,当Spring AOP遇上循环依赖时,该如何解决? Spring通过三级缓存机制解决循环依赖的问题。 在Spring中,bean的实例化...

    spring AOP依赖三个jar包

    Spring AOP,即Spring的面向切面编程模块,是Spring框架的重要组成部分,它允许开发者在不修改源代码的情况下,对程序进行横切关注点的处理,如日志、事务管理等。实现这一功能,主要依赖于三个核心的jar包:aop...

    spring aop的demo

    在`springAop1`这个压缩包中,可能包含了一个简单的应用示例,展示了如何定义一个切面类,以及如何在该类中定义通知方法。例如,我们可能会看到一个名为`LoggingAspect`的类,其中包含了`@Before`注解的方法,用于在...

Global site tag (gtag.js) - Google Analytics