SpringBoot 之集成 Spring AOP

其他 2018-07-11 15:13:39 阅读次数: 0

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

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

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

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

前置通知

配置前置通知：
  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类里添加一个请求处理方法来测试一下前置通知：
  1. @RequestMapping( "/testBeforeService.do")
  2. public String testBeforeService(String key,String value){
  4. return "key="+key+ " value="+value;
  5. }
前置通知拦截结果如下所示：

后置返回通知

配置后置返回通知的代码如下：
  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){
  13. System.out.println( "第一个后置返回通知的返回值："+keys);
  14. }
  16. @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")
  17. public void doAfterReturningAdvice2(String keys){
  19. System.out.println( "第二个后置返回通知的返回值："+keys);
  20. }
Controller里添加响应的请求处理信息来测试后置返回通知：
  1. @RequestMapping( "/testAfterReturning.do")
  2. public String testAfterReturning(String key){
  4. return "key=: "+key;
  5. }
  6. @RequestMapping( "/testAfterReturning01.do")
  7. public Integer testAfterReturning01(Integer key){
  9. return key;
  10. }
当发送请求为：http://localhost:8001/aop/testAfterReturning.do?key=testsss&value=855sss时，处理结果如图所示：
当发送请求为：http://localhost:8001/aop/testAfterReturning01.do?key=55553&value=855sss时，处理结果如图所示：

后置异常通知

后置异常通知的配置方式如下：
  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里配置响应的请求处理类：
  1. @RequestMapping( "/testAfterThrowing.do")
  2. public String testAfterThrowing(String key){
  4. throw new NullPointerException();
  5. }
后置异常通知方法的处理结果如下所示：

后置最终通知

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

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


环绕通知

环绕通知的配置方式如下：
  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对应的请求处理类如下：
  1. @RequestMapping( "/testAroundService.do")
  2. public String testAroundService(String key){
  4. return "环绕通知："+key;
  5. }
当发送请求为：http://localhost:8001/aop/testAroundService.do?key=55553

当发送请求为:http://localhost:8001/aop/testAfter02.do?key=55553&value=855sss时，不符合环绕通知的切入规则，所以环绕通知不会 执行。
完整的AOP配置代码如下：
  1. package com.zkn.learnspringboot.aop;
  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;
  13. import javax.servlet.http.HttpServletRequest;
  14. import javax.servlet.http.HttpSession;
  15. import java.util.Enumeration;
  16. import java.util.Map;
  18. /**
  19. * Created by zkn on 2016/11/18.
  20. */
  21. @Component
  22. @Aspect
  23. public class WebControllerAop {
  25. //匹配com.zkn.learnspringboot.web.controller包及其子包下的所有类的所有方法
  26. @Pointcut( "execution(* com.zkn.learnspringboot.web.controller..*.*(..))")
  27. public void executeService(){
  29. }
  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. }
  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){
  82. System.out.println( "第一个后置返回通知的返回值："+keys);
  83. }
  85. @AfterReturning(value = "execution(* com.zkn.learnspringboot.web.controller..*.*(..))",returning = "keys",argNames = "keys")
  86. public void doAfterReturningAdvice2(String keys){
  88. System.out.println( "第二个后置返回通知的返回值："+keys);
  89. }
  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. }
  108. /**
  109. * 后置最终通知（目标方法只要执行完了就会执行后置通知方法）
  110. * @param joinPoint
  111. */
  112. @After( "executeService()")
  113. public void doAfterAdvice(JoinPoint joinPoint){
  115. System.out.println( "后置通知执行了!!!!");
  116. }
  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类代码如下:
  1. package com.zkn.learnspringboot.web.controller;
  3. import org.springframework.web.bind.annotation.RequestMapping;
  4. import org.springframework.web.bind.annotation.RestController;
  6. /**
  7. * Created by zkn on 2016/11/19.
  8. */
  9. @RestController
  10. @RequestMapping( "/aop")
  11. public class AopTestController {
  13. @RequestMapping( "/testBeforeService.do")
  14. public String testBeforeService(String key,String value){
  16. return "key="+key+ " value="+value;
  17. }
  18. @RequestMapping( "/testAfterReturning.do")
  19. public String testAfterReturning(String key){
  21. return "key=: "+key;
  22. }
  23. @RequestMapping( "/testAfterReturning01.do")
  24. public Integer testAfterReturning01(Integer key){
  26. return key;
  27. }
  28. @RequestMapping( "/testAfterThrowing.do")
  29. public String testAfterThrowing(String key){
  31. throw new NullPointerException();
  32. }
  33. @RequestMapping( "/testAfter.do")
  34. public String testAfter(String key){
  36. throw new NullPointerException();
  37. }
  38. @RequestMapping( "/testAfter02.do")
  39. public String testAfter02(String key){
  41. return key;
  42. }
  43. @RequestMapping( "/testAroundService.do")
  44. public String testAroundService(String key){
  46. return "环绕通知："+key;
  47. }
  48. }

代码地址： https://github.com/zhangconan/LearnSpringBoot/tree/master/src/main/java/com/zkn/learnspringboot/aop 

转自：https://blog.csdn.net/zknxx/article/details/53240959

猜你喜欢

转载自blog.csdn.net/u011314442/article/details/80996945
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
循环神经网络（rnn）讲解
Tigao教程四：单独的关节运动
金蝶K3WISE15.0-注册套打教程
如何在Mac上配置Kubernetes
Android应用结束自身进程的方法
SpringMVC学习 十三 拦截器栈
中国驻洛杉矶总领馆举行新春招待会
HttpClient get post 发送
11 - three.js 笔记 - 绘制三维字体模型
Mysql递归获取某个父节点下面的所有子节点和子节点上的所有父节点
每日归档
更多
2024-05-01(4)
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)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022