程序博客网 > 小海家淘宝

SSM框架 之 Spring-AOP（面向切面编程）

来源：互联网 发布：小海家淘宝 编辑：程序博客网 时间：2024/05/17 01:50
转载自http://blog.csdn.net/onlylove_longshao/article/details/53560785

1AOP概述

AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。
两种编程思想。是对面向对象编程的一种补充。
面向切面编程：是指在程序运行期间将某段代码，动态的切入到某个类的指定方法的指定位置的这种编程思想叫做面向切面编程。
AOP编程操作的主要对象是切面(aspect)，而切面模块化横切关注点。
在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应用在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的类里——这样的类我们通常称之为“切面”。
AOP的好处：
每个事物逻辑位于一个位置，代码不分散，便于维护和升级
业务模块更简洁，只包含核心业务代码

2AOP术语

2.1横切关注点:从每个方法中抽取出来的同一类非核心业务。
2.2切面(Aspect):封装横切关注点信息的类，每个关注点体现为一个通知方法。
2.3通知(Advice):切面必须要完成的各个具体工作
2.4目标(Target):被通知的对象
2.5代理(Proxy):向目标对象应用通知之后创建的代理对象
2.6连接点(Joinpoint)
横切关注点在程序代码中的具体体现，对应程序执行的某个特定位置。例如：类某个方法调用前、调用后、方法捕获到异常后等。
在应用程序中可以使用横纵两个坐标来定位一个具体的连接点：
2.7切入点(pointcut)：

定位连接点的方式。每个类的方法中都包含多个连接点，所以连接点是类中客观存在的事物。如果把连接点看作数据库中的记录，那么切入点就是查询条件——AOP可以通过切入点定位到特定的连接点。切点通过org.springframework.aop.Pointcut 接口进行描述，它使用类和方法作为连接点的查询条件。

为了方便理解以上专业术语，给出下图：



3AspectJ


3.1简介

AspectJ：Java社区里最完整最流行的AOP框架。
在Spring2.0以上版本中，可以使用基于AspectJ注解或基于XML配置的AOP。

3.2在Spring中启用AspectJ注解支持

①导入JAR包

commons-logging-1.1.3.jar

spring-beans-4.0.0.RELEASE.jar

spring-context-4.0.0.RELEASE.jar

spring-core-4.0.0.RELEASE.jar

spring-expression-4.0.0.RELEASE.jar

 
AOP依赖的包

spring-aop-4.0.0.RELEASE.jar

spring-aspects-4.0.0.RELEASE.jar

②引入aop名称空间

③配置
<aop:aspectj-autoproxy>
当Spring IOC容器侦测到bean配置文件中的<aop:aspectj-autoproxy>元素时，会自动为与AspectJ切面匹配的bean创建代理

3.3用AspectJ注解声明切面

①要在Spring中声明AspectJ切面，只需要在IOC容器中将切面声明为bean实例。②当在Spring IOC容器中初始化AspectJ切面之后，Spring IOC容器就会为那些与 AspectJ切面相匹配的bean创建代理。
③在AspectJ注解中，切面只是一个带有@Aspect注解的Java类，它往往要包含很多通知。
④通知是标注有某种注解的简单的Java方法。
⑤AspectJ支持5种类型的通知注解：

[1]@Before：前置通知，在方法执行之前执行

[2]@After：后置通知，在方法执行之后执行

[3]@AfterRunning：返回通知，在方法返回结果之后执行

[4]@AfterThrowing：异常通知，在方法抛出异常之后执行

[5]@Around：环绕通知，围绕着方法执行



3.4AOP版的可以日志记录的计算器

LogAspect中的代码
[java] view plain copy
print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 1、告诉ioc这个组件的存在 
  3.  * 2、告诉ioc这是一个切面使用@Aspect 
  4.  * @author syl 
  5.  * 
  6.  */  
  7. @Aspect  
  8. @Component  
  9. public class LogAspect {  
  10.       
  11.     /** 
  12.      * try{ 
  13.      *      @Before前置通知 
  14.      *      method.invoke(); 
  15.      *      @AfterRunning返回通知 
  16.      * }catch(e){ 
  17.      *      @AfterThrowing：异常通知， 
  18.      * } 
  19.      * @After 
  20.      * 
  21.      * 告诉Spring这些放在都在那个方法的哪个位置执行 
  22.      * 1）、告诉位置 
  23.      [1]@Before：前置通知，在方法执行之前执行 
  24.      [2]@After：后置通知，在方法执行最终结束之后执行。 
  25.         如果没异常 
  26.      [3]@AfterRunning：返回通知，在方法返回结果之后执行 
  27.      [4]@AfterThrowing：异常通知，在方法抛出异常之后执行 
  28.  
  29.  
  30.     1、编写切入点表达式，来告诉spring是切入哪个方法的这个位置 
  31.      */  
  32.     @Before(value=“execution(public * *.add(int, int))”)  
  33.     public void logStart(){  
  34.     System.out.println(”AOP日志，方法开始”);  
  35.     }  
  36.       
  37.     @After(value=“execution(public * *.add(int, int))”)  
  38.     public void logEnd(){  
  39.     System.out.println(”AOP日志，方法最终结束”);  
  40.     }  
  41.       
  42.     @AfterThrowing(value=“execution(public * *.add(int, int))”)  
  43.     public void logException(){  
  44.     System.out.println(”AOP日志，方法出现异常”);  
  45.     }  
  46.       
  47.     @AfterReturning(value=“execution(public * *.add(int, int))”)  
  48.     public void logReturn(){  
  49.     System.out.println(”AOP日志，方法正常执行”);  
  50.     }  
/** * 1、告诉ioc这个组件的存在 * 2、告诉ioc这是一个切面使用@Aspect * @author syl * */@Aspect@Componentpublic class LogAspect {    /**     * try{     *      @Before前置通知     *      method.invoke();     *      @AfterRunning返回通知     * }catch(e){     *      @AfterThrowing：异常通知，     * }     * @After     *     * 告诉Spring这些放在都在那个方法的哪个位置执行     * 1）、告诉位置     [1]@Before：前置通知，在方法执行之前执行     [2]@After：后置通知，在方法执行最终结束之后执行。        如果没异常     [3]@AfterRunning：返回通知，在方法返回结果之后执行     [4]@AfterThrowing：异常通知，在方法抛出异常之后执行    1、编写切入点表达式，来告诉spring是切入哪个方法的这个位置     */    @Before(value="execution(public * *.add(int, int))")    public void logStart(){    System.out.println("AOP日志，方法开始");    }    @After(value="execution(public * *.add(int, int))")    public void logEnd(){    System.out.println("AOP日志，方法最终结束");    }    @AfterThrowing(value="execution(public * *.add(int, int))")    public void logException(){    System.out.println("AOP日志，方法出现异常");    }   @Around(value = "execution(public * *.query(..))")    public Object huanrao(ProceedingJoinPoint joinPoint) throws Throwable {        System.out.println("环绕通知");        joinPoint.proceed();    }    @AfterReturning(value="execution(public * *.add(int, int))")    public void logReturn(){    System.out.println("AOP日志，方法正常执行");    }    applicationContext中的内容
[html] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <!--1、自动扫描所有的组件  -->  
  2. <context:component-scan base-package="com.atguigu"></context:component-scan>  
  3. <!--2、开启基于注解的aop功能  -->  
  4. <aop:aspectj-autoproxy></aop:aspectj-autoproxy>  
  5. <!--  
  6.  0）、被代理对象也得先加入到ioc中  
  7.  1）、编写日志切面，并加入到ioc中，@Component @Aspect  
  8.  2）、给切面编写通知方法。  
  9.  3）、加上何时何地切入的注解。切入点表达式  
  10.  4）、开启基于注解的aop功能即可  
  11.  -->  
<!--1、自动扫描所有的组件  --><context:component-scan base-package="com.atguigu"></context:component-scan><!--2、开启基于注解的aop功能  --><aop:aspectj-autoproxy></aop:aspectj-autoproxy><!-- 0）、被代理对象也得先加入到ioc中 1）、编写日志切面，并加入到ioc中，@Component @Aspect 2）、给切面编写通知方法。 3）、加上何时何地切入的注解。切入点表达式 4）、开启基于注解的aop功能即可 -->

4、AOP细节

1切入点表达式

1.1作用
通过表达式的方式定位一个或多个具体的连接点。

1.2语法细节
①切入点表达式的语法格式:execution([权限修饰符] [返回值类型] [简单类名/全类名] [方法名]([参数列表]))
②举例说明

表达式 execution(* com.atguigu.spring.ArithmeticCalculator.*(..))
含义 ArithmeticCalculator接口中声明的所有方法；第一个“*”代表任意修饰符及任意返回值；第二个“*”代表任意方法；
“..”匹配任意数量、任意类型的参数；若目标类、接口与该切面类在同一个包中可以省略包名。


表达式 execution(public * ArithmeticCalculator.*(..))
含义 ArithmeticCalculator接口的所有公有方法


表达式 execution(public double ArithmeticCalculator.*(..))
含义 ArithmeticCalculator接口中返回double类型数值的方法


表达式 execution(public double ArithmeticCalculator.*(double, ..))
含义 第一个参数为double类型的方法；“..” 匹配任意数量、任意类型的参数。


表达式 execution(public double ArithmeticCalculator.*(double, double))
含义 参数类型为double，double类型的方法


③在AspectJ中，切入点表达式可以通过 “&&”、“||”、“!”等操作符结合起来。
表达式 execution (* *.add(int,..)) || execution(* *.sub(int,..))
含义 任意类中第一个参数为int类型的add方法或sub方法

1.3AOP细节-切入点表达式应用到实际的切面类中
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. //1、不能用本身的类型去找，只能用接口类型  
  2. //2、IOC容器中保存的不是这个对象的本身，而是代理对象  
  3. //3、为什么接口类型又是可以的.因为jdk在创建动态代理的时候，  
  4. //需要被代理对象的接口  
  5. /*Calculator bean = ioc.getBean(Calculator.class); 
  6. bean.add(1, 2); 
  7. System.out.println(bean.getClass());*/  
  8. MathCalculator bean = ioc.getBean(MathCalculator.class);  
  9. bean.add(1, 2);  
  10. System.out.println(bean.getClass());  
//1、不能用本身的类型去找，只能用接口类型//2、IOC容器中保存的不是这个对象的本身，而是代理对象//3、为什么接口类型又是可以的.因为jdk在创建动态代理的时候，//需要被代理对象的接口/*Calculator bean = ioc.getBean(Calculator.class);bean.add(1, 2);System.out.println(bean.getClass());*/MathCalculator bean = ioc.getBean(MathCalculator.class);bean.add(1, 2);System.out.println(bean.getClass());

2当前连接点细节
2.1概述
切入点表达式通常都会是从宏观上定位一组方法，和具体某个通知的注解结合起来就能够确定对应的连接点。那么就一个具体的连接点而言，我们可能会关心这个连接点的一些具体信息，
例如：当前连接点所在方法的方法名、当前传入的参数值等等。这些信息都封装在JoinPoint接口的实例对象中。

3通知

3.1概述
在具体的连接点上要执行的操作。
一个切面可以包括一个或者多个通知。
通知所使用的注解的值往往是切入点表达式。

3.2前置通知
前置通知：在方法执行之前执行的通知
使用@Before注解

3.3后置通知
后置通知：后置通知是在连接点完成之后执行的，即连接点返回结果或者抛出异常的时候
使用@After注解

3.4返回通知
返回通知：无论连接点是正常返回还是抛出异常，后置通知都会执行。如果只想在连接点返回的时候记录日志，应使用返回通知代替后置通知。
使用@AfterReturning注解
在返回通知中访问连接点的返回值
在返回通知中，只要将returning属性添加到@AfterReturning注解中，就可以访问连接点的返回值。该属性的值即为用来传入返回值的参数名称
必须在通知方法的签名中添加一个同名参数。在运行时Spring AOP会通过这个参数传递返回值
原始的切点表达式需要出现在pointcut属性中 
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @AfterReturning(value = “com.atguigu.aspect.LogAspect.mypoint()”, returning = “res”)  
  2. public void validReturn(JoinPoint joinPoint, Object res) {  
  3.     Signature signature = joinPoint.getSignature();  
  4.     String name = signature.getName();  
  5.     System.out.println(”AOP参数验证，【” + name + “】方法正常返回,返回值为：” + res);  
  6. }  
@AfterReturning(value = "com.atguigu.aspect.LogAspect.mypoint()", returning = "res")public void validReturn(JoinPoint joinPoint, Object res) {    Signature signature = joinPoint.getSignature();    String name = signature.getName();    System.out.println("AOP参数验证，【" + name + "】方法正常返回,返回值为：" + res);}

3.5异常通知
异常通知：只在连接点抛出异常时才执行异常通知
将throwing属性添加到@AfterThrowing注解中，也可以访问连接点抛出的异常。Throwable是所有错误和异常类的顶级父类，所以在异常通知方法可以捕获到任何错误和异常。
如果只对某种特殊的异常类型感兴趣，可以将参数声明为其他异常的参数类型。然后通知就只在抛出这个类型及其子类的异常时才被执行
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @AfterThrowing(value = “execution(public * *.*(int, int))”, throwing = “e”)  
  2. public void logException(JoinPoint joinPoint, Throwable e) {  
  3.     // 获取方法名  
  4.     String name = joinPoint.getSignature().getName();  
  5.     System.out.println(”AOP日志，【” + name + “】方法出现异常：异常对象：” + abc);  
  6. }  
@AfterThrowing(value = "execution(public * *.*(int, int))", throwing = "e")public void logException(JoinPoint joinPoint, Throwable e) {    // 获取方法名    String name = joinPoint.getSignature().getName();    System.out.println("AOP日志，【" + name + "】方法出现异常：异常对象：" + abc);}

3.6环绕通知
环绕通知是所有通知类型中功能最为强大的，能够全面地控制连接点，甚至可以控制是否执行连接点。
对于环绕通知来说，连接点的参数类型必须是ProceedingJoinPoint。它是 JoinPoint的子接口，允许控制何时执行，是否执行连接点。
在环绕通知中需要明确调用ProceedingJoinPoint的proceed()方法来执行被代理的方法。如果忘记这样做就会导致通知被执行了，但目标方法没有被执行。
注意：环绕通知的方法需要返回目标方法执行之后的结果，即调用 joinPoint.proceed();的返回值，否则会出现空指针异常。
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. /** 
  2.  * 最强大通知。 一般不常用 
  3.  *  
  4.  * @param proceedingJoinPoint 
  5.  * @return 
  6.  */  
  7. @Around(value = “com.atguigu.aspect.LogAspect.mypoint()”)  
  8. public Object vaildAround(ProceedingJoinPoint proceedingJoinPoint) {  
  9.     // proceedingJoinPoint封装了连接点的详细信息  
  10.     // proceed，执行目标方法 method.invoke  
  11.     Object proceed = null;  
  12.     Object[] args = proceedingJoinPoint.getArgs();  
  13.     try {  
  14.         // //传入目标执行时需要的参数列表  
  15.         // 前置通知  
  16.         System.out.println(”proceed…之前”);  
  17.   
  18.   
  19.         // method.invoke  
  20.         // 目标方法执行完成后会有返回值，这个返回值一定return出去  
  21.         proceed = proceedingJoinPoint.proceed(args);  
  22.         // 返回通知  
  23.         System.out.println(”proceed…之后”);  
  24.     } catch (Throwable e) {  
  25.         // e.printStackTrace();  
  26.         // 异常通知  
  27.         System.out.println(”proceed…异常”);  
  28.         // 1、注意：  
  29.         // 一定将这个异常继续抛出去，以方便外界都能收到这个异常  
  30.         throw new RuntimeException(e);  
  31.     } finally {  
  32.         // 后置通知  
  33.         System.out.println(”proceed…结束”);  
  34.     }  
  35.   
  36.   
  37.     return proceed;  
  38. }  
/** * 最强大通知。 一般不常用 *  * @param proceedingJoinPoint * @return */@Around(value = "com.atguigu.aspect.LogAspect.mypoint()")public Object vaildAround(ProceedingJoinPoint proceedingJoinPoint) {    // proceedingJoinPoint封装了连接点的详细信息    // proceed，执行目标方法 method.invoke    Object proceed = null;    Object[] args = proceedingJoinPoint.getArgs();    try {        // //传入目标执行时需要的参数列表        // 前置通知        System.out.println("proceed...之前");        // method.invoke        // 目标方法执行完成后会有返回值，这个返回值一定return出去        proceed = proceedingJoinPoint.proceed(args);        // 返回通知        System.out.println("proceed...之后");    } catch (Throwable e) {        // e.printStackTrace();        // 异常通知        System.out.println("proceed...异常");        // 1、注意：        // 一定将这个异常继续抛出去，以方便外界都能收到这个异常        throw new RuntimeException(e);    } finally {        // 后置通知        System.out.println("proceed...结束");    }    return proceed;}


3.7重用切入点定义
在编写AspectJ切面时，可以直接在通知注解中书写切入点表达式。但同一个切点表达式可能会在多个通知中重复出现。
在AspectJ切面中，可以通过@Pointcut注解将一个切入点声明成简单的方法。切入点的方法体通常是空的，因为将切入点定义与应用程序逻辑混在一起是不合理的。
切入点方法的访问控制符同时也控制着这个切入点的可见性。如果切入点要在多个切面中共用，最好将它们集中在一个公共的类中。在这种情况下，它们必须被声明为public。
在引入这个切入点时，必须将类名也包括在内。如果类没有与这个切面放在同一个包中，还必须包含包名。
其他通知可以通过方法名称引入该切入点 
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Pointcut(value = “execution(public * *.*(int, int))”)  
  2. public void mypoint() {  
  3. }  
  4.   
  5.   
  6. @Before(value = “mypoint()”)  
  7. public void logStart(JoinPoint joinPoint) {  
  8.     Object[] args = joinPoint.getArgs();  
  9.     String name = joinPoint.getSignature().getName();  
  10.     System.out.println(”AOP日志：【” + name + “】方法开始运行,参数是:”  
  11.             + Arrays.asList(args));  
  12. }  
  13.   
  14.   
  15. @After(“mypoint()”)  
  16. public void logEnd(JoinPoint joinPoint) {  
  17.     String name = joinPoint.getSignature().getName();  
  18.     System.out.println(”AOP日志：【” + name + “】方法运行结束!”);  
  19. }  
  20.   
  21.   
  22. @AfterThrowing(value = “mypoint()”, throwing = “e”)  
  23. public void logException(JoinPoint joinPoint, Exception e) {  
  24.     String name = joinPoint.getSignature().getName();  
  25.     System.out.println(”AOP日志：【” + name + “】方法运行出现异常:” + e);  
  26. }  
  27.   
  28.   
  29. @AfterReturning(value = “mypoint()”, returning = “res”)  
  30. public void logReturn(JoinPoint joinPoint, Object res) {  
  31.     String name = joinPoint.getSignature().getName();  
  32.     System.out.println(”AOP日志：【” + name + “】方法正常结束,返回值为:” + res);  
  33. }  
@Pointcut(value = "execution(public * *.*(int, int))")public void mypoint() {}@Before(value = "mypoint()")public void logStart(JoinPoint joinPoint) {    Object[] args = joinPoint.getArgs();    String name = joinPoint.getSignature().getName();    System.out.println("AOP日志：【" + name + "】方法开始运行,参数是:"            + Arrays.asList(args));}@After("mypoint()")public void logEnd(JoinPoint joinPoint) {    String name = joinPoint.getSignature().getName();    System.out.println("AOP日志：【" + name + "】方法运行结束!");}   @Around("execution(* com.chen.service.LoginService.*(..))")    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {       System.out.println("环绕通知");       //获得通知对象        Object obj=joinPoint.proceed();        return obj;    }@AfterThrowing(value = "mypoint()", throwing = "e")public void logException(JoinPoint joinPoint, Exception e) {    String name = joinPoint.getSignature().getName();    System.out.println("AOP日志：【" + name + "】方法运行出现异常:" + e);}@AfterReturning(value = "mypoint()", returning = "res")public void logReturn(JoinPoint joinPoint, Object res) {    String name = joinPoint.getSignature().getName();    System.out.println("AOP日志：【" + name + "】方法正常结束,返回值为:" + res);}
 
3.8指定切面的优先级
在同一个连接点上应用不止一个切面时，除非明确指定，否则它们的优先级是不确定的。
切面的优先级可以通过实现Ordered接口或利用@Order注解指定。
实现Ordered接口，getOrder()方法的返回值越小，优先级越高。
若使用@Order注解，序号出现在注解中 
[java] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. @Aspect  
  2. @Component  
  3. @Order(2)  
  4. public class LogAspect {  
  5. }  
  6.   
  7. @Component  
  8. @Aspect  
  9. @Order(1)  
  10. public class ValidatorAspect {  
  11. }  
@Aspect@Component@Order(2)public class LogAspect {}@Component@Aspect@Order(1)public class ValidatorAspect {}

先切入的最后出去。


5、 以XML方式配置切面

1概述
除了使用AspectJ注解声明切面，Spring也支持在bean配置文件中声明切面。这种声明是通过aop名称空间中的XML元素完成的。
正常情况下，基于注解的声明要优先于基于XML的声明。通过AspectJ注解，切面可以与AspectJ兼容，而基于XML的配置则是Spring专有的。由于AspectJ得到
越来越多的 AOP框架支持，所以以注解风格编写的切面将会有更多重用的机会。

2配置细节
在bean配置文件中，所有的Spring AOP配置都必须定义在<aop:config>元素内部。对于每个切面而言，都要创建一个<aop:aspect>元素来为具体的切面实现
引用后端bean实例。切面bean必须有一个标识符，供<aop:aspect>元素引用。
[plain] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <bean id=”logAspect” class=”com.atguigu.aspect.LogAspect”></bean>  
  2. <bean id=”validatorAspect” class=”com.atguigu.aspect.ValidatorAspect”></bean>  
  3. <bean id=”mathCalulator” class=”com.atguigu.calulator.MathCalulator”></bean>  
  4.   
  5.   
  6. <aop:config>  
  7.     <aop:aspect ref=”logAspect”></aop:aspect>  
  8.     <aop:aspect ref=”validatorAspect”></aop:aspect>  
  9. </aop:config>  
<bean id="logAspect" class="com.atguigu.aspect.LogAspect"></bean><bean id="validatorAspect" class="com.atguigu.aspect.ValidatorAspect"></bean><bean id="mathCalulator" class="com.atguigu.calulator.MathCalulator"></bean><aop:config>    <aop:aspect ref="logAspect"></aop:aspect>    <aop:aspect ref="validatorAspect"></aop:aspect></aop:config>
 
3声明切入点
切入点使用<aop:pointcut>元素声明。
切入点必须定义在<aop:aspect>元素下，或者直接定义在<aop:config>元素下。
定义在<aop:aspect>元素下：只对当前切面有效
定义在<aop:config>元素下：对所有切面都有效
基于XML的AOP配置不允许在切入点表达式中用名称引用其他切入点。
[plain] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <aop:pointcut expression=”execution(* *.*(..))” id=”mypoint”/>  
<aop:pointcut expression="execution(* *.*(..))" id="mypoint"/>
 
4声明通知
在aop名称空间中，每种通知类型都对应一个特定的XML元素。
通知元素需要使用<pointcut-ref>来引用切入点，或用<pointcut>直接嵌入切入点表达式。
method属性指定切面类中通知方法的名称
[plain] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1. <aop:before method=”logStart” pointcut=”execution(* *.*(..))”/  
<aop:before method="logStart" pointcut="execution(* *.*(..))"/
 
5完整代码如下 
[plain] view plain copy
 print?在CODE上查看代码片派生到我的代码片
  1.  <!–基于注解的AOP  
  2. 1、将被代理的对象和切面类都要加入ioc容器中   
  3. 2、配置切面类的每个通知方法，都在何时何地执行  
  4. 3、开启基于注解的aop功能  
  5. –>  
  6. <!–基于XML的AOP  –>  
  7. <!–1、将这些组件加入到ioc中  –>  
  8. <bean id=”mathCalculator” class=”com.atguigu.inf.MathCalculator”></bean>  
  9. <bean id=”aalidatorAspect” class=”com.atguigu.aspect.AalidatorAspect”></bean>  
  10. <bean id=”logAspect” class=”com.atguigu.aspect.LogAspect”></bean>  
  11.   
  12.   
  13. <!–2、配置切面类的详细信息,依赖于aop名称空间  –>  
  14. <aop:config>  
  15. <aop:pointcut expression=”execution(* *.*(..))” id=”mypoint”/>  
  16. <aop:pointcut expression=”execution(* *.add(..))” id=”mypoint1”/>  
  17. <!– 配置第二个切面，默认根据切面配置的优先顺序执行–>  
  18. <aop:aspect ref=”aalidatorAspect” order=”1”>  
  19.     <aop:before method=”validStart” pointcut-ref=”mypoint”/>  
  20.     <aop:after-returning method=”validReturn” pointcut-ref=”mypoint” returning=”res”/>  
  21. </aop:aspect>  
  22. <!–使用aop:aspect配置一个切面  –>  
  23. <aop:aspect ref=”logAspect” order=”0”>  
  24.     <!– 配置前置通知是哪个方法 –>  
  25.     <aop:before method=”logStart” pointcut=”execution(* *.*(..))”/>  
  26.     <aop:after method=”logEnd” pointcut-ref=”mypoint”/>  
  27.     <!–returning指定返回值  –>  
  28.     <aop:after-returning method=”logReturn” pointcut-ref=”mypoint” returning=”res”/>  
  29.     <!–throwing指定异常参数的名 –>  
  30.     <aop:after-throwing method=”logException” pointcut-ref=”mypoint” throwing=”abc”/>  
  31. </aop:aspect>  
  32. </aop:config>   
 <!--基于注解的AOP1、将被代理的对象和切面类都要加入ioc容器中 2、配置切面类的每个通知方法，都在何时何地执行3、开启基于注解的aop功能--><!--基于XML的AOP  --><!--1、将这些组件加入到ioc中  --><bean id="mathCalculator" class="com.atguigu.inf.MathCalculator"></bean><bean id="aalidatorAspect" class="com.atguigu.aspect.AalidatorAspect"></bean><bean id="logAspect" class="com.atguigu.aspect.LogAspect"></bean><!--2、配置切面类的详细信息,依赖于aop名称空间  --><aop:config><aop:pointcut expression="execution(* *.*(..))" id="mypoint"/><aop:pointcut expression="execution(* *.add(..))" id="mypoint1"/><!-- 配置第二个切面，默认根据切面配置的优先顺序执行--><aop:aspect ref="aalidatorAspect" order="1">    <aop:before method="validStart" pointcut-ref="mypoint"/>    <aop:after-returning method="validReturn" pointcut-ref="mypoint" returning="res"/></aop:aspect><!--使用aop:aspect配置一个切面  --><aop:aspect ref="logAspect" order="0">    <!-- 配置前置通知是哪个方法 -->    <aop:before method="logStart" pointcut="execution(* *.*(..))"/>    <aop:after method="logEnd" pointcut-ref="mypoint"/>    <!--returning指定返回值  -->    <aop:after-returning method="logReturn" pointcut-ref="mypoint" returning="res"/>    <!--throwing指定异常参数的名 -->    <aop:after-throwing method="logException" pointcut-ref="mypoint" throwing="abc"/></aop:aspect></aop:config> 











       document.getElementById("bdshell_js").src = "http://bdimg.share.baidu.com/static/js/shell_v2.js?cdnversion=" + Math.ceil(new Date()/3600000)
    <div id="digg" articleid="53560785">        <dl id="btnDigg" class="digg digg_disable" onclick="btndigga();">             <dt>顶</dt>            <dd>1</dd>        </dl>        <dl id="btnBury" class="digg digg_disable" onclick="btnburya();">              <dt>踩</dt>            <dd>0</dd>                       </dl>    </div> <div class="tracking-ad" data-mod="popu_222"><a href="javascript:void(0);">&nbsp;</a>   </div><div class="tracking-ad" data-mod="popu_223"> <a href="javascript:void(0);">&nbsp;</a></div><script type="text/javascript">            function btndigga() {                $(".tracking-ad[data-mod='popu_222'] a").click();            }            function btnburya() {                $(".tracking-ad[data-mod='popu_223'] a").click();            }        </script>
     
                                        
<div style="clear:both; height:10px;"></div>    <div class="similar_article" style="">            <h4>我的同类文章</h4>            <div class="similar_c" style="margin:20px 0px 0px 0px">                <div class="similar_c_t">                            <label class="similar_cur">                                <span style="cursor:pointer" onclick="GetCategoryArticles('6466257','OnlyLove_longshao','foot','53560785');">SSM（Spring--SpringMVC--Mybats）<em>（3）</em></span>                            </label>                </div>                <div class="similar_wrap tracking-ad" data-mod="popu_141" style="max-height: 195px; background-color: rgb(246, 244, 236);">                    <a href="http://blog.csdn.net" style="display:none">http://blog.csdn.net</a>                    <ul class="similar_list fl"><li><em>•</em><a href="http://blog.csdn.net/OnlyLove_longshao/article/details/53677748" id="foot_aritcle_53677748undefined5516243083961583" target="_blank" title="SpringMVC一次请求过程源码分析">SpringMVC一次请求过程源码分析</a><span>2016-12-15</span><label><i>阅读</i><b>509</b></label></li> <li><em>•</em><a href="http://blog.csdn.net/OnlyLove_longshao/article/details/53142939" id="foot_aritcle_53142939undefined5477943287098417" target="_blank" title="SSM框架 之 Spring-IOC">SSM框架 之 Spring-IOC</a><span>2016-11-12</span><label><i>阅读</i><b>287</b></label></li> </ul>                    <ul class="similar_list fr"><li><em>•</em><a href="http://blog.csdn.net/OnlyLove_longshao/article/details/53560447" id="foot_aritcle_53560447undefined1954295464489053" target="_blank" title="深入探索IOC容器的实质">深入探索IOC容器的实质</a><span>2016-12-10</span><label><i>阅读</i><b>348</b></label></li> </ul>                </div>            </div>        </div>    <script type="text/javascript">    $(function () {        GetCategoryArticles('6466257', 'OnlyLove_longshao','foot','53560785');    });</script>
0 0
小海家淘宝 小海家淘宝
原创粉丝点击
热门IT博客
java服务器监控java服务器监控
更新tensorflow版本更新tensorflow版本
小米3支持4g网络吗
查找端口占用
贵阳大数据电商产业园
linux 阻塞 毫秒
知乎发现不一样的王麟
没人请吃饭知乎
modern php pdf微盘
网购最多的商品 数据
json 格式检验
java是什么意思啊
淘宝拍摄方案
linux tar 解压
比较两个数组的差异
nginx 设置访问权限
sql match
md5算法唯一吗
戴尔色彩软件
手机制作软件视频教程
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 瑞德全站仪价格 瑞德摩尔 佛瑞德 薇诺娜瑞德 斯瑞德 凯瑞德股票 中汇瑞德 中汇瑞德电子有限公司 曼瑞德新风系统怎么样 曼瑞德温控器 凯瑞德股吧 施瑞德 瑞德菲男装 索瑞德ups 银月守卫塞尔瑞德 伟瑞德 迈瑞德 瑞德减肥茶 埃瑞德风口 瑞思 价格 瑞思 外教 瑞思 英语 瑞思 贝乐 女神瑞思52分钟在线播放 瑞思英语怎么样 瑞思英语员工真实工资 瑞思英语歌曲 瑞思英语学费 瑞思英语培训中心 瑞思 少儿英语 瑞思少儿英语好吗 瑞思英语 教材 瑞思少儿英语怎么样 瑞思英语培训怎么样 瑞思英语费用 瑞思英语收费 瑞思英语地址 瑞思英语好不好 瑞思英语好吗 瑞思英语培训机构 瑞思英语总部

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里