【JavaEE进阶】 Spring AOP详解

2024-03-07 1342阅读

温馨提示：这篇文章已超过383天没有更新，请注意相关的内容是否还可用！

文章目录

🎋前言
🎍Spring AOP核心概念
- 🚩切点(Pointcut)
- 🚩连接点(Join Point)
- 🚩通知(Advice)
- 🚩切面(Aspect)
- 🍀通知类型
- - 🚩注意事项
  - 🌲@PointCut
  - 🎄切面优先级@Order
  - 🍃切点表达式
  - - 🚩execution表达式
    - 🚩@annotation
    - - 🎈自定义注解 @MyAspect
      - 🎈切面类
      - 🎈添加自定义注解
      - ⭕总结
        🎋前言
        
        在《【JavaEE进阶】 Spring AOP快速上手》中我们快速上手了AOP，接下来博主来详细介绍一下AOP
        
        学习内容主要分为以下三部分：
        
        Spring AOP中涉及的核心概念
        
        Spring AOP通知类型
        
        多个AOP程序的执行顺序
        
        🎍Spring AOP核心概念
        
        🚩切点(Pointcut)
        
        切点(Pointcut),也称之为"切⼊点"
        
        Pointcut的作⽤就是提供⼀组规则(使⽤AspectJ pointcut expression language 来描述),告诉程序对哪些⽅法来进行功能增强.
        
        上面的表达式 execution(* com.example.demo.controller.*.*(..)) 就是切点表达式（后面会进行介绍）
        
        🚩连接点(Join Point)
        
        满⾜切点表达式规则的⽅法,就是连接点.也就是可以被AOP控制的⽅法
        
        在《【JavaEE进阶】 Spring AOP快速上手》中，所有com.example.demo.controller路劲下的方法，都是连接点
        
        
        上述BookController中的⽅法都是连接点
        
        切点和连接点的关系
        
        连接点是满⾜切点表达式的元素.切点可以看做是保存了众多连接点的⼀个集合.
        比如:
        
        切点表达式:全体教师
        连接点就是:张三,李四等各个⽼师
        🚩通知(Advice)
        
        通知就是具体要做的⼯作,指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)
        
        比如《【JavaEE进阶】 Spring AOP快速上手》程序中记录业务⽅法的耗时时间,就是通知.
        
        在AOP面向切面编程当中,我们把这部分重复的代码逻辑抽取出来单独定义,这部分代码就是通知的内容.
        
        🚩切面(Aspect)
        
        切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)
        
        通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法,在什么时候执⾏什么样的操作
        
        切⾯既包含了通知逻辑的定义,也包括了连接点的定义.
        
        切面所在的类,我们⼀般称为切面类(被@Aspect注解标识的类)
        
        🍀通知类型
        
        上⾯我们讲了什么是通知,接下来我们来看一看通知的类型. 在《【JavaEE进阶】 Spring AOP快速上手》使用的@Around 就是其中⼀种通知类型,表示环绕通知.
        
        Spring中AOP的通知类型有以下⼏种:
        
        @Around:环绕通知,此注解标注的通知⽅法在⽬标⽅法前,后都被执⾏
        @Before:前置通知,此注解标注的通知⽅法在⽬标⽅法前被执⾏
        @After:后置通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,⽆论是否有异常都会执⾏
        @AfterReturning:返回后通知,此注解标注的通知⽅法在⽬标⽅法后被执⾏,有异常不会执⾏
        @AfterThrowing:异常后通知,此注解标注的通知⽅法发⽣异常后执⾏
        接下来我们通过代码来来加深对这几个通知的理解
        
        含各个通知类型代码如下：
        
        @Slf4j @Aspect @Component public class AspectDemo { //前置通知 @Before("execution(* com.example.demo.controller.*.*(..))") public void doBefore() { log.info("执⾏ Before ⽅法"); } //后置通知 @After("execution(* com.example.demo.controller.*.*(..))") public void doAfter() { log.info("执⾏ After ⽅法"); } //返回后通知 @AfterReturning("execution(* com.example.demo.controller.*.*(..))") public void doAfterReturning() { log.info("执⾏ AfterReturning ⽅法"); } //抛出异常后通知 @AfterThrowing("execution(* com.example.demo.controller.*.*(..))") public void doAfterThrowing() { log.info("执⾏ doAfterThrowing ⽅法"); } //添加环绕通知 @Around("execution(* com.example.demo.controller.*.*(..))") public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { log.info("Around ⽅法开始执⾏"); Object result = joinPoint.proceed(); log.info("Around ⽅法结束执⾏"); return result; } }
        
        我们再来写一下测试代码，代码如下：
        
        @RestController public class AspectDemoController { @RequestMapping("/test1") public String test1() { return "测试一，无异常版本"; } @RequestMapping("/test2") public String test2() { int n = 10 / 0; return "测试二，有异常版本"; } }
        
        我们先来运行程序，访问无异常的测试一
        
        
        程序正常运行的情况下, @AfterThrowing 标识的通知方法不会执⾏
        
        从上图也可以看出来, @Around 标识的通知方法包含两部分,⼀个"前置逻辑",⼀个"后置逻辑".
        
        其中"前置逻辑"会先于 @Before 标识的通知⽅法执行,"后置逻辑"会晚于 @After 标识的通知⽅法执
        
        
        我们再来看一下有异常时的情况
        
        
        观察日志：
        
        程序发⽣异常的情况下：
        
        @AfterReturning 标识的通知⽅法不会执行， @AfterThrowing 标识的通知方法执行了
        @Around 环绕通知中原始方法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执行了(因为原始方法调用出异常了)
        
        🚩注意事项
        
        @Around 环绕通知需要调用 ProceedingJoinPoint.proceed() 来让原始方法执行,其他通知不需要考虑目标⽅法执行.
        
        @Around 环绕通知方法的返回值,必须指定为Object,来接收原始方法的返回值,否则原始方法执行完毕,是获取不到返回值的.
        
        ⼀个切⾯类可以有多个切点.
        
        🌲@PointCut
        
        上面代码存在⼀个问题,就是存在⼤量重复的切点表达式 execution(* com.example.demo.controller.*.*(..))
        
        对待此问题，Spring提供了 @PointCut 注解,把公共的切点表达式提取出来,需要⽤到时引⽤该切⼊点表达式即可.
        
        代码修改如下：
        
        当切点定义使用private修饰时,仅能在当前切⾯类中使用,当其他切⾯类也要使用当前切点定义时,就需要把private改为public.引用方式为：全限定类名.方法名()
        
        @Slf4j @Aspect @Component public class AspectDemo2 { //前置通知 @Before("com.example.demo.aspect.AspectDemo.pt()") public void doBefore() { log.info("执⾏ AspectDemo2 -> Before ⽅法"); } }
        
        🎄切面优先级@Order
        
        当我们在⼀个项目中,定义了多个切⾯类时,并且这些切⾯类的多个切⼊点都匹配到了同⼀个目标⽅法.
        
        当目标⽅法运⾏的时候,这些切⾯类中的通知方法都会执行,那么这⼏个通知⽅法的执行顺序是什么样的呢?
        
        我们先准备如下案例
        
        实现代码如下，其他切面类代码只做输出名字的修改
        
        @Slf4j @Aspect @Component public class AspectDemo1 { //定义切点(公共的切点表达式) @Pointcut("execution(* com.example.demo.controller.*.*(..))") private void pt(){} //前置通知 @Before("pt()") public void doBefore() { log.info("AspectDemo1,执⾏ Before ⽅法"); } //后置通知 @After("pt()") public void doAfter() { log.info("AspectDemo1,执⾏ After ⽅法"); } //返回后通知 @AfterReturning("pt()") public void doAfterReturning() { log.info("AspectDemo1,执⾏ AfterReturning ⽅法"); } //添加环绕通知 @Around("pt()") public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { log.info("AspectDemo1,Around ⽅法开始执⾏"); Object result = joinPoint.proceed(); log.info("AspectDemo1,Around ⽅法结束执⾏"); return result; } }
        
        运行程序访问后，我们观察日志
        
        
        通过上述程序的运⾏结果,可以看出:
        
        存在多个切⾯类时,默认按照切⾯类的类名字⺟排序：
        
        @Before 通知：字⺟排名靠前的先执行
        @After 通知：字⺟排名靠前的后执行
        @Around 通知：字母排名靠前的先执行开始执行的方法，最后执行结束执行的方法
        @AfterReturning 通知：字⺟排名靠前的后执行
        但这种⽅式不⽅便管理,我们的类名更多还是具备⼀定含义的.
        
        Spring给我们提供了⼀个新的注解,来控制这些切⾯通知的执⾏顺序:@Order
        执行程序，观察日志
        
        通过上述程序的结果：
        
        @Before 通知：数字越小的先执行
        @After 通知：数字越小的后执行
        @Around 通知：数字越小的先执行开始执行的方法，最后执行结束执行的方法
        @AfterReturning 通知：数字越小的后执行
        @Order 控制切⾯的优先级,先执⾏优先级较⾼的切⾯,再执行优先级较低的切面,最终执行目标⽅法.
        
        🍃切点表达式
        
        上面的代码中,我们⼀直在使⽤切点表达式来描述切点.下⾯我们来介绍⼀下切点表达式的语法.
        
        切点表达式常见有两种表达⽅式
        
        execution(RR)：根据方法的签名来匹配
        
        @annotation(RR)：根据注解匹配
        
        🚩execution表达式
        
        execution()是最常用的切点表达式,用来匹配⽅法,语法为:
        
        execution( )
        
        其中访问修饰符和异常可以省略
        
        
        
        切点表达式⽀持通配符表达:
        
        关于 * ，匹配任意字符，只匹配⼀个元素(返回类型,包,类名,⽅法或者⽅法参数)
        
        包名使⽤ * 表⽰任意包(⼀层包使⽤⼀个*)
        类名使⽤ * 表⽰任意类
        返回值使⽤ * 表⽰任意返回值类型
        ⽅法名使⽤ * 表⽰任意⽅法
        参数使⽤ * 表⽰⼀个任意类型的参数
        关于. . 匹配多个连续的任意符号,可以通配任意层级的包,或任意类型,任意个数的参数
        
        使⽤. .配置包名，标识此包以及此包下的所有⼦包
        可以使⽤ . .配置参数，任意个任意类型的参数
        //TestController下的public修饰,返回类型为String⽅法名为t1,⽆参⽅法 execution(public String com.example.demo.controller.TestController.t1()) //省略访问修饰符 execution(String com.example.demo.controller.TestController.t1()) //匹配所有返回类型 execution(* com.example.demo.controller.TestController.t1()) //匹配TestController下的所有⽆参⽅法 execution(* com.example.demo.controller.TestController.*()) //匹配TestController下的所有⽅法 execution(* com.example.demo.controller.TestController.*(..)) //匹配controller包下所有的类的所有⽅法 execution(* com.example.demo.controller.*.*(..)) //匹配所有包下⾯的TestController execution(* com..TestController.*(..)) //匹配com.example.demo包下,⼦孙包下的所有类的所有⽅法 execution(* com.example.demo..*(..))
        
        🚩@annotation
        
        execution表达式更适用有规则的,如果我们要匹配多个无规则的方法呢
        
        这个时候我们使用execution这种切点表达式来描述就不是很⽅便了.
        
        我们可以借助自定义注解的方式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点
        
        实现步骤：
        
        编写自定义注解
        使用 @annotation 表达式来描述切点
        在连接点的⽅法上添加自定义注解
        🎈自定义注解 @MyAspect
        
        创建⼀个注解类(和创建Class⽂件⼀样的流程,选择Annotation就可以了)
        
        @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface MyAspect { }
        
        @Target 标识了 Annotation 所修饰的对象范围,即该注解可以用在什么地⽅.常用取值:
        ElementType.TYPE:⽤于描述类、接⼝(包括注解类型)或enum声明
        ElementType.METHOD:描述⽅法
        ElementType.PARAMETER:描述参数
        ElementType.TYPE_USE:可以标注任意类型
        @Retention 指Annotation被保留的时间⻓短,标明注解的⽣命周期
        @Retention 的取值有三种:
        RetentionPolicy.SOURCE：表⽰注解仅存在于源代码中,编译成字节码后会被丢弃.这意味着在运⾏时⽆法获取到该注解的信息,只能在编译时使⽤.⽐如 @SuppressWarnings ,以及lombok提供的注解 @Data ,@Slf4j
        RetentionPolicy.CLASS：编译时注解.表⽰注解存在于源代码和字节码中,但在运⾏时会被丢弃.这意味着在编译时和字节码中可以通过反射获取到该注解的信息,但在实际运⾏时⽆法获取.通常⽤于⼀些框架和⼯具的注解.
        RetentionPolicy.RUNTIME：运⾏时注解.表⽰注解存在于源代码,字节码和运行时中.这意味着在编译时,字节码中和实际运行时都可以通过反射获取到该注解的信息.通常用于⼀些需要在运⾏时处理的注解,如Spring的@Controller @ResponseBody
        🎈切面类
        
        使用 @annotation 切点表达式定义切点,只对@MyAspect ⽣效
        
        @Slf4j @Component @Aspect public class MyAspectDemo { //前置通知 @Before("@annotation(com.example.demo.aspect.MyAspect)") public void before(){ log.info("MyAspect -> before ..."); } //后置通知 @After("@annotation(com.example.demo.aspect.MyAspect)") public void after(){ log.info("MyAspect -> after ..."); } }
        
        🎈添加自定义注解
        
        在TestController中的t1()和UserController中的u1()这两个方法上添加自定义注解 @MyAspect ,其他方法不添加
        
        
        
        进行测试后，只有添加@MyAspect注解的切面通知被执行了，其他都没有被执行
        
        ⭕总结
        
        关于《【JavaEE进阶】 Spring AOP详解》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

VPS购买请点击我

免责声明：我们致力于保护作者版权，注重分享，被刊用文章因无法核实真实出处，未能及时与作者取得联系，或有版权异议的，请联系管理员，我们会立即处理! 部分文章是来自自研大数据AI进行生成,内容摘自(百度百科,百度知道,头条百科,中国民法典,刑法,牛津词典,新华词典,汉语词典,国家院校,科普平台)等数据,内容仅供学习参考,不准确地方联系删除处理! 图片声明：本站部分配图来自人工智能系统AI生成,觅知网授权图片,PxHere摄影无版权图库和百度，360，搜狗等多加搜索引擎自动关键词搜索配图，如有侵权的图片，请第一时间联系我们，邮箱：ciyunidc@ciyunshuju.com。本站只作为美观性配图使用,无任何非法侵犯第三方意图,一切解释权归图片著作权方,本站不承担任何责任。如有恶意碰瓷者,必当奉陪到底严惩不贷!

相关阅读

目录[+]