在上篇文章中学习了Spring AOP，并学习了前置通知和后置通知。地址为：http://www.cnblogs.com/dreamfree/p/4095858.html

在本文中，将继续上篇的学习，继续了解返回通知、异常通知和环绕通知。具体的含义详见代码注释

 package com.yl.spring.aop;

 import java.util.Arrays;

 import org.aspectj.lang.JoinPoint;

 import org.aspectj.lang.ProceedingJoinPoint;

 import org.aspectj.lang.annotation.After;

 import org.aspectj.lang.annotation.AfterReturning;

 import org.aspectj.lang.annotation.AfterThrowing;

 import org.aspectj.lang.annotation.Around;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.springframework.stereotype.Component;

 @Component

 @Aspect

 public class LoggingAspect {

     /**

      * 在com.yl.spring.aop.ArithmeticCalculator接口的每一个实现类的每一个方法开始之前执行一段代码

      */

     @Before("execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))")

     public void beforeMethod(JoinPoint joinPoint) {

         String methodName = joinPoint.getSignature().getName();

         Object[] args = joinPoint.getArgs();

         System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));

     }

     /**

      * 在com.yl.spring.aop.ArithmeticCalculator接口的每一个实现类的每一个方法执行之后执行一段代码

      * 无论该方法是否出现异常

      */

     @After("execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))")

     public void afterMethod(JoinPoint joinPoint) {

         String methodName = joinPoint.getSignature().getName();

         Object[] args = joinPoint.getArgs();

         System.out.println("The method " + methodName + " ends with " + Arrays.asList(args));

     }

     /**

      * 方法正常结束后执行的代码

      * 返回通知是可以访问到方法的返回值的

      */

     @AfterReturning(value="execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))", returning="result")

     public void afterReturning(JoinPoint joinPoint, Object result) {

         String methodName = joinPoint.getSignature().getName();

         System.out.println("The method " + methodName + " return with " + result);

     }

     /**

      * 在方法出现异常时会执行的代码

      * 可以访问到异常对象，可以指定在出现特定异常时在执行通知代码

      */

     @AfterThrowing(value="execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))", throwing="ex")

     public void afterThrowing(JoinPoint joinPoint, Exception ex) {

         String methodName = joinPoint.getSignature().getName();

         System.out.println("The method " + methodName + " occurs exception: " + ex);

     }

     /**

      * 环绕通知需要携带ProceedingJoinPoint类型的参数

      * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法。

      * 而且环绕通知必须有返回值，返回值即为目标方法的返回值

      */

     @Around("execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))")

     public Object aroundMethod(ProceedingJoinPoint pjd) {

         Object result = null;

         String methodName = pjd.getSignature().getName();

         //执行目标方法

         try {

             //前置通知

             System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));

             result = pjd.proceed();

             //返回通知

             System.out.println("The method " + methodName + " ends with " + Arrays.asList(pjd.getArgs()));

         } catch (Throwable e) {

             //异常通知

             System.out.println("The method " + methodName + " occurs expection : " + e);

             throw new RuntimeException(e);

         }

         //后置通知

         System.out.println("The method " + methodName + " ends");

         return result;

     }

 }

切面的优先级　　

　　为项目增加一个新的切面类，负责验证功能，则需要指定切面执行的顺序。即切面的优先级。具体方法是给切面类增加@Order注解，并指定具体的数字，值越小优先级越高

 package com.yl.spring.aop;

 import java.util.Arrays;

 import org.aspectj.lang.JoinPoint;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.springframework.core.annotation.Order;

 import org.springframework.stereotype.Component;

 /**

  * 可以使用@Order注解指定切面的优先级，值越小优先级越高

  * @author yul

  *

  */

 @Order(2)

 @Component

 @Aspect

 public class ValidationAspect {

     @Before("execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))")

     public void vlidateArgs(JoinPoint joinPoint) {

         System.out.println("validate: " + Arrays.asList(joinPoint.getArgs()));

     }

 }

切点表达式的重用：

　　在LoggingAspect类中，切点的表达式可以先定义，在使用。

 package com.yl.spring.aop;

 import java.util.Arrays;

 import org.aspectj.lang.JoinPoint;

 import org.aspectj.lang.ProceedingJoinPoint;

 import org.aspectj.lang.annotation.After;

 import org.aspectj.lang.annotation.AfterReturning;

 import org.aspectj.lang.annotation.AfterThrowing;

 import org.aspectj.lang.annotation.Around;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.aspectj.lang.annotation.Pointcut;

 import org.springframework.core.annotation.Order;

 import org.springframework.stereotype.Component;

 @Order(1)

 @Component

 @Aspect

 public class LoggingAspect {

     /**

      * 定义一个方法，用于声明切入点表达式。一般的，该方法中再不需要添加其他的代码

      * 使用@Pointcut 来声明切入点表达式

      * 后面的其他通知直接使用方法名直接引用方法名即可

      */

     @Pointcut("execution(public int com.yl.spring.aop.ArithmeticCalculator.*(..))")

     public void declareJoinPointExpression() {

     }

     /**

      * 在com.yl.spring.aop.ArithmeticCalculator接口的每一个实现类的每一个方法开始之前执行一段代码

      */

     @Before("declareJoinPointExpression()")

     public void beforeMethod(JoinPoint joinPoint) {

         String methodName = joinPoint.getSignature().getName();

         Object[] args = joinPoint.getArgs();

         System.out.println("The method " + methodName + " begins with " + Arrays.asList(args));

     }

     /**

      * 在com.yl.spring.aop.ArithmeticCalculator接口的每一个实现类的每一个方法执行之后执行一段代码

      * 无论该方法是否出现异常

      */

     @After("declareJoinPointExpression()")

     public void afterMethod(JoinPoint joinPoint) {

         String methodName = joinPoint.getSignature().getName();

         Object[] args = joinPoint.getArgs();

         System.out.println("The method " + methodName + " ends with " + Arrays.asList(args));

     }

     /**

      * 方法正常结束后执行的代码

      * 返回通知是可以访问到方法的返回值的

      */

     @AfterReturning(value="declareJoinPointExpression()", returning="result")

     public void afterReturning(JoinPoint joinPoint, Object result) {

         String methodName = joinPoint.getSignature().getName();

         System.out.println("The method " + methodName + " return with " + result);

     }

     /**

      * 在方法出现异常时会执行的代码

      * 可以访问到异常对象，可以指定在出现特定异常时在执行通知代码

      */

     @AfterThrowing(value="declareJoinPointExpression()", throwing="ex")

     public void afterThrowing(JoinPoint joinPoint, Exception ex) {

         String methodName = joinPoint.getSignature().getName();

         System.out.println("The method " + methodName + " occurs exception: " + ex);

     }

     /**

      * 环绕通知需要携带ProceedingJoinPoint类型的参数

      * 环绕通知类似于动态代理的全过程：ProceedingJoinPoint类型的参数可以决定是否执行目标方法。

      * 而且环绕通知必须有返回值，返回值即为目标方法的返回值

      */

     @Around("declareJoinPointExpression()")

     public Object aroundMethod(ProceedingJoinPoint pjd) {

         Object result = null;

         String methodName = pjd.getSignature().getName();

         //执行目标方法

         try {

             //前置通知

             System.out.println("The method " + methodName + " begins with " + Arrays.asList(pjd.getArgs()));

             result = pjd.proceed();

             //返回通知

             System.out.println("The method " + methodName + " ends with " + Arrays.asList(pjd.getArgs()));

         } catch (Throwable e) {

             //异常通知

             System.out.println("The method " + methodName + " occurs expection : " + e);

             throw new RuntimeException(e);

         }

         //后置通知

         System.out.println("The method " + methodName + " ends");

         return result;

     }

 }

当处于不同的类，甚至不同的包时，可以使用包名.类名.方法名

具体代码如下：

 package com.yl.spring.aop;

 import java.util.Arrays;

 import org.aspectj.lang.JoinPoint;

 import org.aspectj.lang.annotation.Aspect;

 import org.aspectj.lang.annotation.Before;

 import org.springframework.core.annotation.Order;

 import org.springframework.stereotype.Component;

 /**

  * 可以使用@Order注解指定切面的优先级，值越小优先级越高

  * @author yul

  *

  */

 @Order(2)

 @Component

 @Aspect

 public class ValidationAspect {

     @Before("com.yl.spring.aop.LoggingAspect.declareJoinPointExpression()")

     public void vlidateArgs(JoinPoint joinPoint) {

         System.out.println("validate: " + Arrays.asList(joinPoint.getArgs()));

     }

 }

最新文章

  1. 前端小菜鸟的Mobile之旅---开篇
  2. Lua IO库详解
  3. 关于RACK的一点简单介绍
  4. mount/umount系统调用
  5. 黄聪：PHP 免费获取手机号码归属地（转）
  6. Jersey(1.19.1) - Client API, Overview of the API
  7. 一步一步学android控件（之十五） —— DegitalClock & AnalogClock
  8. The 5th tip of DB Query Analyzer
  9. shell基础(转)
  10. 构建安全的Xml Web Service系列之初探使用Soap头
  11. STL算法设计理念 - 函数适配器
  12. a标签伪类选择器以及伪元素:hover的案例
  13. mysql如何直接查出从1开始递增的数
  14. NPM 报错--fs: re-evaluating native module sources is not supported. If you are using the graceful-fs module
  15. docker下搭建fastfds
  16. Floyed
  17. 一张图看懂JavaScript中数组的迭代方法：forEach、map、filter、reduce、every、some
  18. Android常用逆向工具+单机游戏破解
  19. js或jsp 获取项目路径常用方法
  20. 00006 - Linux中使用export命令设置环境变量

热门文章

  1. 云主机上搭建squid3代理服务器
  2. （转）PHP中的 抽象类（abstract class）和 接口（interface）
  3. linux驱动系列之arm汇编
  4. Begin Andriod -- 安装android开发环境
  5. 使用Yeoman搭建 AngularJS 应用 (6) —— 让我们搭建一个网页应用
  6. java第三课：分支结构、循环结构
  7. JPA2 关于 PagingAndSortingRepository
  8. pthread_create()之前的属性设置
  9. HDU1796+容斥原理
  10. c缺陷与陷阱笔记-第三章 语义陷阱