【腾讯云】11.11 云上盛惠,云产品限时抢购,1核2G云服务器首年88元

搜搜吧

查看: 14|回复: 0

[资讯] 你真的确定Spring AOP的执行顺序吗

[复制链接]
  • TA的每日心情
    奋斗
    昨天 13:35
  • 签到天数: 695 天

    [LV.9]以坛为家II

    博士生

    1万

    主题

    2万

    帖子

    5万

    积分

    Rank: 8Rank: 8

    UID
    15343
    威望
    -561
    贡献
    8107
    在线时间
    368 小时
    注册时间
    2015-10-12
    发表于 7 天前 | 显示全部楼层 |阅读模式

    cb4100b6c2d0d70127d57db62e59d6a1.jpg-wh_651x-s_2477738415.jpg

    前言

    公司这两个月启动了全新的项目,项目排期满满当当,不过该学习还是要学习。这不,给公司搭项目的时候,。

    本文内容重点:

    • 问题描述
    • Spring AOP执行顺序
    • 探究顺序错误的真相
    • 代码验证
    • 结论

    问题描述

    公司新项目需要搭建一个新的前后分离HTTP服务,我选择了目前比较熟悉的SpringBoot Web来快速搭建一个可用的系统。

    鲁迅说过,不要随便升级已经稳定使用的版本。我偏不信这个邪,仗着自己用了这么久Spring,怎么能不冲呢。不说了,直接引入了最新的SprinBoot 2.3.4.RELEASE版本,开始给项目搭架子。

    起初,大多数的组件引入都一切顺利,本以为就要大功告成了,没想到在搭建日志切面时栽了跟头。

    作为一个接口服务,为了方便查询接口调用情况和定位问题,一般都会将请求日志打印出来,而Spring的AOP作为切面支持,完美的切合了日志记录的需求。

    之前的项目中,运行正确的切面日志记录效果如下图:

    d4b24115365329aafd9c467c7a90e371.png-wh_600x-s_351789899.png

    可以看到图内的一次方法调用,会输出请求url,出入参,以及请求IP等等,之前为了好看,还加入了分割线。

    我把这个实现类放入新项目中,执行出来却是这样的:

    122a6c3120ffeba422138b24452d0e54.png

    我揉了揉眼睛,仔细看了看复制过来的老代码,精简版如下:

    • /**
    • * 在切点之前织入
    • * @param joinPoint
    • * @throws Throwable
    • */
    • @Before("webLog()")
    • public void doBefore(JoinPoint joinPoint) throws Throwable {
    •     // 开始打印请求日志
    •     ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    •     HttpServletRequest request = attributes.getRequest();
    •     // 初始化traceId
    •     initTraceId(request);
    •     // 打印请求相关参数
    •     LOGGER.info("========================================== Start ==========================================");
    •     // 打印请求 url
    •     LOGGER.info("URL            : {}", request.getRequestURL().toString());
    •     // 打印 Http method
    •     LOGGER.info("HTTP Method    : {}", request.getMethod());
    •     // 打印调用 controller 的全路径以及执行方法
    •     LOGGER.info("Class Method   : {}.{}", joinPoint.getSignature().getDeclaringTypeName(), joinPoint.getSignature().getName());
    •     // 打印请求的 IP
    •     LOGGER.info("IP             : {}", IPAddressUtil.getIpAdrress(request));
    •     // 打印请求入参
    •     LOGGER.info("Request Args   : {}", joinPoint.getArgs());
    • }
    • /**
    • * 在切点之后织入
    • * @throws Throwable
    • */
    • @After("webLog()")
    • public void doAfter() throws Throwable {
    •     LOGGER.info("=========================================== End ===========================================");
    • }
    • /**
    • * 环绕
    • * @param proceedingJoinPoint
    • * @return
    • * @throws Throwable
    • */
    • @Around("webLog()")
    • public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    •     long startTime = System.currentTimeMillis();
    •     Object result = proceedingJoinPoint.proceed();
    •     // 打印出参
    •     LOGGER.info("Response Args  : {}", result);
    •     // 执行耗时
    •     LOGGER.info("Time-Consuming : {} ms", System.currentTimeMillis() - startTime);
    •     return result;
    • }

    代码感觉完全没有问题,难道新版本的SpringBoot出Bug了。

    显然,成熟的框架不会在这种大方向上犯错误,那会不会是新版本的SpringBoot把@After和@Around的顺序反过来了?

    其实事情也没有那么简单。

    Spring AOP执行顺序

    我们先来回顾下Spring AOP执行顺序。

    我们在网上查找关于SpringAop执行顺序的的资料,大多数时候,你会查到如下的答案:

    正常情况

    49289e90b9d4f52b0cea15f20aafb3f0.png

    异常情况

    959ea6ca6f2f96dd4ece18b27b38d466.png-wh_600x-s_3365119023.png

    多个切面的情况

    746e781899853db2f10a0a8232a25c46.png-wh_600x-s_21952906.png

    所以@Around理应在@After之前,但是在SprinBoot 2.3.4.RELEASE版本中,@Around切切实实执行在了@After之后。

    当我尝试切换回2.2.5.RELEASE版本后,执行顺序又回到了@Around-->@After

    探究顺序错误的真相

    既然知道了是SpringBoot版本升级导致的问题(或者说顺序变化),那么就要来看看究竟是哪个库对AOP执行的顺序进行了变动,毕竟,SpringBoot只是“形”,真正的内核在Spring。

    我们打开pom.xml文件,使用插件查看spring-aop的版本,发现SpringBoot 2.3.4.RELEASE 版本使用的AOP是spring-aop-5.2.9.RELEASE。

    而2.2.5.RELEASE对应的是spring-aop-5.2.4.RELEASE

    于是我去官网搜索文档,不得不说Spring由于过于庞大,官网的文档已经到了冗杂的地步,不过最终还是找到了:

    https://docs.spring.io/spring-framework/docs/5.2.9.RELEASE/spring-framework-reference/core.html#aop-ataspectj-advice-ordering

    a7728d835064bcc3efeb717345ddfc5a.png-wh_600x-s_1579768753.png

    As of Spring Framework 5.2.7, advice methods defined in the same @Aspect class that need to run at the same join point are assigned precedence based on their advice type in the following order, from highest to lowest precedence: @Around, @Before, @After, @AfterReturning, @AfterThrowing.

    我粗浅的翻译一下重点:

    从Spring5.2.7开始,在相同@Aspect类中,通知方法将根据其类型按照从高到低的优先级进行执行:@Around,@Before ,@After,@AfterReturning,@AfterThrowing。

    这样看其实对比不明显,我们再回到老版本,也就是2.2.5.RELEASE对应的spring-aop-5.2.4.RELEASE,当时的文档是这么写的:

    What happens when multiple pieces of advice all want to run at the same join point? Spring AOP follows the same precedence rules as AspectJ to determine the order of advice execution. The highest precedence advice runs first "on the way in" (so, given two pieces of before advice, the one with highest precedence runs first). "On the way out" from a join point, the highest precedence advice runs last (so, given two pieces of after advice, the one with the highest precedence will run second).

    简单翻译:在相同@Aspect类中Spring AOP遵循与AspectJ相同的优先级规则来确定advice执行的顺序。

    再挖深一点,那么AspectJ的优先级规则是什么样的?

    我找了AspectJ的文档:

    https://www.eclipse.org/aspectj/doc/next/progguide/semantics-advice.html

    07b61cbde78260c740da6d45e3fa29a6.png-wh_600x-s_2271337489.png

    At a particular join point, advice is ordered by precedence.

    A piece of around advice controls whether advice of lower precedence will run by calling proceed. The call to proceed will run the advice with next precedence, or the computation under the join point if there is no further advice.

    A piece of before advice can prevent advice of lower precedence from running by throwing an exception. If it returns normally, however, then the advice of the next precedence, or the computation under the join pint if there is no further advice, will run.

    Running after returning advice will run the advice of next precedence, or the computation under the join point if there is no further advice. Then, if that computation returned normally, the body of the advice will run.

    Running after throwing advice will run the advice of next precedence, or the computation under the join point if there is no further advice. Then, if that computation threw an exception of an appropriate type, the body of the advice will run.

    Running after advice will run the advice of next precedence, or the computation under the join point if there is no further advice. Then the body of the advice will run.

    大伙又要说了,哎呀太长不看!简短地说,Aspectj的规则就是上面我们能够在网上查阅到的顺序图展示的那样,依旧是老的顺序。

    代码验证

    我把业务逻辑从代码中删除,只验证下这几个advice的执行顺序:

    • /**
    • * 日志切面
    • */
    • @Aspect
    • @Component
    • public class WebLogAspect {
    •     private final static Logger LOGGER = LoggerFactory.getLogger(WebLogAspect.class);
    •     /** 以 controller 包下定义的所有请求为切入点 */
    •     @Pointcut("execution(public * com.xx.xxx.xxx.controller..*.*(..))")
    •     public void webLog() {}
    •     /**
    •      * 在切点之前织入
    •      * @param joinPoint
    •      * @throws Throwable
    •      */
    •     @Before("webLog()")
    •     public void doBefore(JoinPoint joinPoint) throws Throwable {
    •         LOGGER.info("-------------doBefore-------------");
    •     }
    •     @AfterReturning("webLog()")
    •     public void afterReturning() {
    •         LOGGER.info("-------------afterReturning-------------");
    •     }
    •     @AfterThrowing("webLog()")
    •     public void afterThrowing() {
    •         LOGGER.info("-------------afterThrowing-------------");
    •     }
    •     /**
    •      * 在切点之后织入
    •      * @throws Throwable
    •      */
    •     @After("webLog()")
    •     public void doAfter() throws Throwable {
    •         LOGGER.info("-------------doAfter-------------");
    •     }
    •     /**
    •      * 环绕
    •      * @param proceedingJoinPoint
    •      * @return
    •      * @throws Throwable
    •      */
    •     @Around("webLog()")
    •     public Object doAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    •         long startTime = System.currentTimeMillis();
    •         LOGGER.info("-------------doAround before proceed-------------");
    •         Object result = proceedingJoinPoint.proceed();
    •         LOGGER.info("-------------doAround after proceed-------------");
    •         return result;
    •     }

    我们将版本改为2.2.5.RELEASE,结果如图:


    我们将版本改为2.3.4.RELEASE,结果如图:


    结论

    经过上面的资料文档查阅,我能给出的结论是:

    从Spring5.2.7开始,Spring AOP不再严格按照AspectJ定义的规则来执行advice,而是根据其类型按照从高到低的优先级进行执行:@Around,@Before ,@After,@AfterReturning,@AfterThrowing。

    这次的研究思考十分仓促,如果结论有误请大家踊跃指正,也欢迎大家自己尝试,毕竟口说无凭,实验室检验真理的唯一标准!


    搜搜吧社区温馨提示:
    搜搜吧(www.sosoba.org)十分重视网络版权及其他知识产权的保护,针对网络侵权采取如下版权政策:
    1、本站有理由相信网友侵犯任何人的版权或作品,(图文,文字,下载,视频,非法传播),本站有权不事先通知即删除涉嫌侵权的作品和内容
    2、本站将采取必要的网络技术手段,确认为侵权作品或内容的用户有权进行警告、屏蔽、删除的行为,尽可能的防止侵权行为的发生
    3、搜搜吧影视资源均收集自互联网,没有提供影片资源存储,也未参与录制上传,若本站收录的资源涉及您的版权或知识产权或其他利益,我们会立即删除
    4、搜搜吧,删帖,投诉,举报,侵权,若本站侵犯您的权益,附上身份及权利证明,请直接发送邮件到 kefu-sosoba@qq.com 我们将在一个工作日内删除
    Powered by www.sosoba.org Copyright © 2013-2020 搜搜吧社区 小黑屋|手机版|地图|联系站长|腾讯云代金券|帮助中心|公共DNS|seo优化服务|搜搜吧
    广告服务/项目合作/会员购买:QQ 侵权举报邮箱: kefu-sosoba@qq.com  搜搜吧建站时间:创建于2013年07月23日
    免责声明:本站所有的内容均来自互联网以及第三方作者自由发布,版权归原作者版权所有,搜搜吧不承担任何的法律责任,若有侵权请来信告知,我们立即删除!

    GMT+8, 2020-10-23 01:05 , Processed in 0.110249 second(s), 11 queries , MemCache On.

    快速回复 返回顶部 返回列表