SpringBoot集成Spring AOP 参考样例

其他 2018-06-09 00:07:23 阅读次数: 2

在开始之前，我们先把需要的jar包添加到工程里。新增Maven依赖如下：

[html]  view plain  copy
  1. <dependency>  
  2.     <groupId>org.springframework.boot</groupId>  
  3.     <artifactId>spring-boot-starter-aop</artifactId>  
  4. </dependency>  
接下来，我们进入正题。这里的涉及的通知类型有：前置通知、后置最终通知、后置返回通知、后置异常通知、环绕通知，下面我们就具体的来看一下怎么在SpringBoot中添加这些通知。

首先我们先创建一个Aspect切面类：
[java]  view plain  copy
  1. @Component  
  2. @Aspect  
  3. public class WebControllerAop {  
  4.   
  5. }  
指定切点：
[java]  view plain  copy
  1. //匹配com.zkn.learnspringboot.web.controller包及其子包下的所有类的所有方法  
  2. @Pointcut("execution(* com.zkn.learnspringboot.web.controller..*.*(..))")  
  3. public void executeService(){  
  4.   
  5. }  
接着我们再创建一个Controller请求处理类：

[java]  view plain  copy
  1. package com.zkn.learnspringboot.web.controller;  
  2.   
  3. import org.springframework.web.bind.annotation.RequestMapping;  
  4. import org.springframework.web.bind.annotation.RestController;  
  5.   
  6. /** 
  7.  * Created by zkn on 2016/11/19. 
  8.  */  
  9. @RestController  
  10. @RequestMapping("/aop")  
  11. public class AopTestController {  
  12.   
  13. }  

前置通知

配置前置通知：
[java]  view plain  copy
  1. /** 
  2.  * 前置通知，方法调用前被调用 
  3.  * @param joinPoint 
  4.  */  
  5. @Before("executeService()")  
  6. public void doBeforeAdvice(JoinPoint joinPoint){  
  7.     System.out.println("我是前置通知!!!");  
  8.     //获取目标方法的参数信息  
  9.     Object[] obj = joinPoint.getArgs();  
  10.     //AOP代理类的信息  
  11.     joinPoint.getThis();  
  12.     //代理的目标对象  
  13.     joinPoint.getTarget();  
  14.     //用的最多 通知的签名  
  15.     Signature signature = joinPoint.getSignature();  
  16.     //代理的是哪一个方法  
  17.     System.out.println(signature.getName());  
  18.     //AOP代理类的名字  
  19.     System.out.println(signature.getDeclaringTypeName());  
  20.     //AOP代理类的类（class）信息  
  21.     signature.getDeclaringType();  
  22.     //获取RequestAttributes  
  23.     RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();  
  24.     //从获取RequestAttributes中获取HttpServletRequest的信息  
  25.     HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);  
  26.     //如果要获取Session信息的话，可以这样写：  
  27.     //HttpSession session = (HttpSession) requestAttributes.resolveReference(RequestAttributes.REFERENCE_SESSION);  
  28.     Enumeration<String> enumeration = request.getParameterNames();  
  29.     Map<String,String> parameterMap = Maps.newHashMap();  
  30.     while (enumeration.hasMoreElements()){  
  31.         String parameter = enumeration.nextElement();  
  32.         parameterMap.put(parameter,request.getParameter(parameter));  
  33.     }  
  34.     String str = JSON.toJSONString(parameterMap);  
  35.     if(obj.length > 0) {  
  36.         System.out.println("请求的参数信息为："+str);  
  37.     }  
  38. }  
注意：这里用到了JoinPoint和RequestContextHolder。通过JoinPoint可以获得通知的签名信息，如目标方法名、目标方法参数信息等。通过RequestContextHolder来获取请求信息，Session信息。
接下来我们在Controller类里添加一个请求处理方法来测试一下前置通知：
[java]  view plain  copy
  1. @RequestMapping("/testBeforeService.do")  
  2. public String testBeforeService(String key,String value){  
  3.   
  4.     return "key="+key+"  value="+value;  
  5. }  
前置通知拦截结果如下所示：

后置返回通知

配置后置返回通知的代码如下：
[java]  view plain  copy
  1. /** 
  2.  * 后置返回通知 
  3.  * 这里需要注意的是: 
  4.  *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息 
  5.  *      如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数 
  6.  * returning 限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值 
  7.  * @param joinPoint 
  8.  * @param keys 
  9.  */  
  10. @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys")  
  11. public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){  
  12.   
  13.     System.out.println("第一个后置返回通知的返回值："+keys);  
  14. }  
  15.   
  16. @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")  
  17. public void doAfterReturningAdvice2(String keys){  
  18.   
  19.     System.out.println("第二个后置返回通知的返回值："+keys);  
  20. }  
Controller里添加响应的请求处理信息来测试后置返回通知：
[java]  view plain  copy
  1. @RequestMapping("/testAfterReturning.do")  
  2. public String testAfterReturning(String key){  
  3.   
  4.     return "key=: "+key;  
  5. }  
  6. @RequestMapping("/testAfterReturning01.do")  
  7. public Integer testAfterReturning01(Integer key){  
  8.   
  9.     return key;  
  10. }  
当发送请求为：http://localhost:8001/aop/testAfterReturning.do?key=testsss&value=855sss时，处理结果如图所示：
当发送请求为：http://localhost:8001/aop/testAfterReturning01.do?key=55553&value=855sss时，处理结果如图所示：

后置异常通知

后置异常通知的配置方式如下：
[java]  view plain  copy
  1. /** 
  2.  * 后置异常通知 
  3.  *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法； 
  4.  *  throwing 限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行， 
  5.  *      对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。 
  6.  * @param joinPoint 
  7.  * @param exception 
  8.  */  
  9. @AfterThrowing(value = "executeService()",throwing = "exception")  
  10. public void doAfterThrowingAdvice(JoinPoint joinPoint,Throwable exception){  
  11.     //目标方法名：  
  12.     System.out.println(joinPoint.getSignature().getName());  
  13.     if(exception instanceof NullPointerException){  
  14.         System.out.println("发生了空指针异常!!!!!");  
  15.     }  
  16. }  
Controller里配置响应的请求处理类：
[java]  view plain  copy
  1. @RequestMapping("/testAfterThrowing.do")  
  2. public String testAfterThrowing(String key){  
  3.   
  4.     throw new NullPointerException();  
  5. }  
后置异常通知方法的处理结果如下所示：

后置最终通知

后置最终通知的配置方式如下：
[java]  view plain  copy
  1. /** 
  2.  * 后置最终通知（目标方法只要执行完了就会执行后置通知方法） 
  3.  * @param joinPoint 
  4.  */  
  5. @After("executeService()")  
  6. public void doAfterAdvice(JoinPoint joinPoint){  
  7.   
  8.     System.out.println("后置通知执行了!!!!");  
  9. }  
Controller类配置相应的请求处理类：
[java]  view plain  copy
  1. @RequestMapping("/testAfter.do")  
  2. public String testAfter(String key){  
  3.   
  4.     throw new NullPointerException();  
  5. }  
  6. @RequestMapping("/testAfter02.do")  
  7. public String testAfter02(String key){  
  8.   
  9.     return key;  
  10. }  
当发送请求为：http://localhost:8001/aop/testAfter.do?key=55553&value=855sss

当发送请求为：http://localhost:8001/aop/testAfter02.do?key=55553&value=855sss


环绕通知

环绕通知的配置方式如下：
[java]  view plain  copy
  1. /** 
  2.  * 环绕通知： 
  3.  *   环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。 
  4.  *   环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型 
  5.  */  
  6. @Around("execution(* com.zkn.learnspringboot.web.controller..*.testAround*(..))")  
  7. public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){  
  8.     System.out.println("环绕通知的目标方法名："+proceedingJoinPoint.getSignature().getName());  
  9.     try {  
  10.         Object obj = proceedingJoinPoint.proceed();  
  11.         return obj;  
  12.     } catch (Throwable throwable) {  
  13.         throwable.printStackTrace();  
  14.     }  
  15.     return null;  
  16. }  
Controller对应的请求处理类如下：
[java]  view plain  copy
  1. @RequestMapping("/testAroundService.do")  
  2. public String testAroundService(String key){  
  3.   
  4.     return "环绕通知："+key;  
  5. }  
当发送请求为：http://localhost:8001/aop/testAroundService.do?key=55553

当发送请求为:http://localhost:8001/aop/testAfter02.do?key=55553&value=855sss时，不符合环绕通知的切入规则，所以环绕通知不会 执行。
完整的AOP配置代码如下：
[java]  view plain  copy
  1. package com.zkn.learnspringboot.aop;  
  2.   
  3. import com.alibaba.fastjson.JSON;  
  4. import com.google.common.collect.Maps;  
  5. import org.aspectj.lang.JoinPoint;  
  6. import org.aspectj.lang.ProceedingJoinPoint;  
  7. import org.aspectj.lang.Signature;  
  8. import org.aspectj.lang.annotation.*;  
  9. import org.springframework.stereotype.Component;  
  10. import org.springframework.web.context.request.RequestAttributes;  
  11. import org.springframework.web.context.request.RequestContextHolder;  
  12.   
  13. import javax.servlet.http.HttpServletRequest;  
  14. import javax.servlet.http.HttpSession;  
  15. import java.util.Enumeration;  
  16. import java.util.Map;  
  17.   
  18. /** 
  19.  * Created by zkn on 2016/11/18. 
  20.  */  
  21. @Component  
  22. @Aspect  
  23. public class WebControllerAop {  
  24.   
  25.     //匹配com.zkn.learnspringboot.web.controller包及其子包下的所有类的所有方法  
  26.     @Pointcut("execution(* com.zkn.learnspringboot.web.controller..*.*(..))")  
  27.     public void executeService(){  
  28.   
  29.     }  
  30.   
  31.     /** 
  32.      * 前置通知，方法调用前被调用 
  33.      * @param joinPoint 
  34.      */  
  35.     @Before("executeService()")  
  36.     public void doBeforeAdvice(JoinPoint joinPoint){  
  37.         System.out.println("我是前置通知!!!");  
  38.         //获取目标方法的参数信息  
  39.         Object[] obj = joinPoint.getArgs();  
  40.         //AOP代理类的信息  
  41.         joinPoint.getThis();  
  42.         //代理的目标对象  
  43.         joinPoint.getTarget();  
  44.         //用的最多 通知的签名  
  45.         Signature signature = joinPoint.getSignature();  
  46.         //代理的是哪一个方法  
  47.         System.out.println(signature.getName());  
  48.         //AOP代理类的名字  
  49.         System.out.println(signature.getDeclaringTypeName());  
  50.         //AOP代理类的类（class）信息  
  51.         signature.getDeclaringType();  
  52.         //获取RequestAttributes  
  53.         RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();  
  54.         //从获取RequestAttributes中获取HttpServletRequest的信息  
  55.         HttpServletRequest request = (HttpServletRequest) requestAttributes.resolveReference(RequestAttributes.REFERENCE_REQUEST);  
  56.         //如果要获取Session信息的话，可以这样写：  
  57.         //HttpSession session = (HttpSession) requestAttributes.resolveReference(RequestAttributes.REFERENCE_SESSION);  
  58.         Enumeration<String> enumeration = request.getParameterNames();  
  59.         Map<String,String> parameterMap = Maps.newHashMap();  
  60.         while (enumeration.hasMoreElements()){  
  61.             String parameter = enumeration.nextElement();  
  62.             parameterMap.put(parameter,request.getParameter(parameter));  
  63.         }  
  64.         String str = JSON.toJSONString(parameterMap);  
  65.         if(obj.length > 0) {  
  66.             System.out.println("请求的参数信息为："+str);  
  67.         }  
  68.     }  
  69.   
  70.     /** 
  71.      * 后置返回通知 
  72.      * 这里需要注意的是: 
  73.      *      如果参数中的第一个参数为JoinPoint，则第二个参数为返回值的信息 
  74.      *      如果参数中的第一个参数不为JoinPoint，则第一个参数为returning中对应的参数 
  75.      * returning 限定了只有目标方法返回值与通知方法相应参数类型时才能执行后置返回通知，否则不执行，对于returning对应的通知方法参数为Object类型将匹配任何目标返回值 
  76.      * @param joinPoint 
  77.      * @param keys 
  78.      */  
  79.     @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys")  
  80.     public void doAfterReturningAdvice1(JoinPoint joinPoint,Object keys){  
  81.   
  82.         System.out.println("第一个后置返回通知的返回值："+keys);  
  83.     }  
  84.   
  85.     @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")  
  86.     public void doAfterReturningAdvice2(String keys){  
  87.   
  88.         System.out.println("第二个后置返回通知的返回值："+keys);  
  89.     }  
  90.   
  91.     /** 
  92.      * 后置异常通知 
  93.      *  定义一个名字，该名字用于匹配通知实现方法的一个参数名，当目标方法抛出异常返回后，将把目标方法抛出的异常传给通知方法； 
  94.      *  throwing 限定了只有目标方法抛出的异常与通知方法相应参数异常类型时才能执行后置异常通知，否则不执行， 
  95.      *      对于throwing对应的通知方法参数为Throwable类型将匹配任何异常。 
  96.      * @param joinPoint 
  97.      * @param exception 
  98.      */  
  99.     @AfterThrowing(value = "executeService()",throwing = "exception")  
  100.     public void doAfterThrowingAdvice(JoinPoint joinPoint,Throwable exception){  
  101.         //目标方法名：  
  102.         System.out.println(joinPoint.getSignature().getName());  
  103.         if(exception instanceof NullPointerException){  
  104.             System.out.println("发生了空指针异常!!!!!");  
  105.         }  
  106.     }  
  107.   
  108.     /** 
  109.      * 后置最终通知（目标方法只要执行完了就会执行后置通知方法） 
  110.      * @param joinPoint 
  111.      */  
  112.     @After("executeService()")  
  113.     public void doAfterAdvice(JoinPoint joinPoint){  
  114.   
  115.         System.out.println("后置通知执行了!!!!");  
  116.     }  
  117.   
  118.     /** 
  119.      * 环绕通知： 
  120.      *   环绕通知非常强大，可以决定目标方法是否执行，什么时候执行，执行时是否需要替换方法参数，执行完毕是否需要替换返回值。 
  121.      *   环绕通知第一个参数必须是org.aspectj.lang.ProceedingJoinPoint类型 
  122.      */  
  123.     @Around("execution(* com.zkn.learnspringboot.web.controller..*.testAround*(..))")  
  124.     public Object doAroundAdvice(ProceedingJoinPoint proceedingJoinPoint){  
  125.         System.out.println("环绕通知的目标方法名："+proceedingJoinPoint.getSignature().getName());  
  126.         try {//obj之前可以写目标方法执行前的逻辑  
  127.             Object obj = proceedingJoinPoint.proceed();//调用执行目标方法  
  128.             return obj;  
  129.         } catch (Throwable throwable) {  
  130.             throwable.printStackTrace();  
  131.         }  
  132.         return null;  
  133.     }  
  134. }  
完整的Controller类代码如下:
[java]  view plain  copy
  1. package com.zkn.learnspringboot.web.controller;  
  2.   
  3. import org.springframework.web.bind.annotation.RequestMapping;  
  4. import org.springframework.web.bind.annotation.RestController;  
  5.   
  6. /** 
  7.  * Created by zkn on 2016/11/19. 
  8.  */  
  9. @RestController  
  10. @RequestMapping("/aop")  
  11. public class AopTestController {  
  12.   
  13.     @RequestMapping("/testBeforeService.do")  
  14.     public String testBeforeService(String key,String value){  
  15.   
  16.         return "key="+key+"  value="+value;  
  17.     }  
  18.     @RequestMapping("/testAfterReturning.do")  
  19.     public String testAfterReturning(String key){  
  20.   
  21.         return "key=: "+key;  
  22.     }  
  23.     @RequestMapping("/testAfterReturning01.do")  
  24.     public Integer testAfterReturning01(Integer key){  
  25.   
  26.         return key;  
  27.     }  
  28.     @RequestMapping("/testAfterThrowing.do")  
  29.     public String testAfterThrowing(String key){  
  30.   
  31.         throw new NullPointerException();  
  32.     }  
  33.     @RequestMapping("/testAfter.do")  
  34.     public String testAfter(String key){  
  35.   
  36.         throw new NullPointerException();  
  37.     }  
  38.     @RequestMapping("/testAfter02.do")  
  39.     public String testAfter02(String key){  
  40.   
  41.         return key;  
  42.     }  
  43.     @RequestMapping("/testAroundService.do")  
  44.     public String testAroundService(String key){  
  45.   
  46.         return "环绕通知："+key;  
  47.     }  
  48. }  

猜你喜欢

转载自blog.csdn.net/qq_23167527/article/details/78623474
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022