zoukankan      html  css  js  c++  java

  • spring3.0 AOP 具体解释

    一、什么是 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 编程事实上是非常easy的事情。纵观 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>  
  • 相关阅读:
    html页面禁止自动填充浏览器记住的密码
    未能加载文件或程序集“System.Data.SQLite.DLL”或它的某一个依赖项
    DotNetMQ的一个小demo
    js 排列 组合 的一个简单例子
    js 生成笛卡尔积
    290.单词模式。给定一种 pattern(模式) 和一个字符串 str ，判断 str 是否遵循相同的模式。（c++方法）
    递归与迭代的联系以及优缺点（以c++为例）
    leetcode344 反转字符串 c++实现
    面试题：编写一个函数来查找字符串数组中的最长公共前缀。 如果不存在公共前缀，返回空字符串 ""。（c++实现）
    LeetCode题库13. 罗马数字转整数（c++实现）
  • 原文地址：https://www.cnblogs.com/zhchoutai/p/8343566.html
Copyright © 2011-2022 走看看