• Spring学习笔记12 面向切面编程AOP

    Spring学习笔记11 GoF代理模式_biubiubiu0706的博客-CSDN博客

    AOP(Aspect Oriented Programming):面向切面编程,面向方面编程.

    AOP是对OOP的补充延申.底层使用动态代理实现.

    Spring的AOP使用的动态代理是:JDK动态代理_CGLIB动态代理技术.Spring在这两种动态代理中灵活切换.如果是代理接口,会默认使用JDK动态代理,如果要代理某个类,这个类没有实现接口,就会切换使用CGLIB.当然,也可以强制通过一些配置让Spring只使用CGLIB

    日志,事务管理,安全这些交叉业务(非业务代码)都属于AOP

    AOP是一种思想,JDK代理,CGLIB代理都是AOP思想的实现,Spring AOP底层用的就是JDK代理和CGLIB代理

    面向切面编程的七大术语:

    连接点  Joinpoint:在程序的整个执行流程中,可以织入切面的位置.方法的执行前,异常抛出之后等位置.----->我的理解连接点就是用户需要被扩展的方法,其实我们将自定义注解放到目标方法上做标识,那么该注解其实就是一个连接点 连接点描述的是位置

    切入点 Pointcut:程序执行流程中,真正织入切面的方法.(一个切入点对应多个连接点).---->我的理解:用户实际扩展的方法,确定了连接点,那么该方法就是一个切入点

    通知 Advice: 扩展方法的具体实现

            1.前置通知:在目标方法执行之前执行  @Before

            2.后置通知:在目标方法执行之后,返回时执行  @AfterReturning

            3.环绕通知:在目标方法执行前后,都要执行的通知 也可以控制方法是否执行  @Around

            4.异常通知:在目标方法执行之后,抛出异常时执行  @AfterThrowing

            5.最终通知:无论程序是否执行成功,都要最后执行的通知   @After

    切面 Aspect:切入点+通知就是切面

    织入 Weaving:把通知应用到目标对象的过程

    代理对象 Proxy:一个目标对象被织入通知后产生的新对象

    目标对象 Target:被织入通知的对象

    切入点表达式:

    概念:当程序满足切入点表达式,才能进入切面,执行通知方法

    1.bean("Bean的id") 根据Bean名称 进行拦截 只能匹配一个

    2.within("com.example") 包名+类名 可以使用通配符*? 能匹配多个

    3.execution(返回值类型  包名.类名.方法名(参数列表))

    4.annotation(包名.注解名)

    使用SpringAOP

    Spring对AOP的实现包括已下3种方式:

    第一种方式:Spring框架结合AspectJ框架实现的AOP,基于注解方式

    第二种方式:Spring框架结合AspectJ框架实现的AOP,基于XML方式

    第三种方式:Spring框架自己实现的AOP,基于XML配置方式

    实际开发中,都是Spring+AspectJ来实现AOP,重点第一种和第二种方式.

    准备环境

    新建模块spring-aspectj-xml

    导入依赖

    
    
    
        org.springframework
        spring-context
        6.0.10
    
    
    
        org.springframework
        spring-aspects
        6.0.10
    
    
    
        junit
        junit
        4.13.2
        test

    Spring配置文件中添加context命名空间和aop命名空间

    先搭个架子

    配置文件    注意下  这个注释可能没写对

    默认情况下，会使用Spring的JDK动态代理来代理目标对象。这意味着如果你的目标对象实现了至少一个接口，Spring将会使用JDK动态代理。这种代理方式仅代理实现了接口的方法。

    如果目标对象没有实现任何接口，Spring将会使用CGLIB（Code Generation Library）来创建一个子类代理。CGLIB允许代理类继承目标对象，因此可以代理非接口类型的目标对象。


    是强制使用CGLIB代理意思

    测试,当调用业务层login方法时候

    业务层新增一个方法

    如果我在切入点表达式中修改下

    可见切入点表达式很重要

    新加一个业务类

    修改切入点表达式

    测试

    下面引入所有通知

    将UserService注释掉  避免看着混乱

    1. package com.example.aspect;
    2.  
    3. import org.aspectj.lang.ProceedingJoinPoint;
    4. import org.aspectj.lang.annotation.*;
    5. import org.springframework.stereotype.Component;
    6.  
    7. /**
    8.  * @author hrui
    9.  * @date 2023/9/26 0:33
    10.  */
    11. @Component
    12. @Aspect//标注是一个切面
    13. public class LogAspect {//切面
    14.  
    15.     //切面=切入点+通知
    16.     //通知就是增强,就是具体要编写的增强代码
    17.  
    18.     //前置通知   方法执行之前
    19.     @Before("execution(* com.example.service..*(..))")//里面要写切入点表达式 UserService里的所有方法
    20.     public void 增强(){
    21.         System.out.println("我是一个通知,我是一段增强代码");
    22.     }
    23.  
    24.     //后置通知   方法执行之后返回时执行
    25.     @AfterReturning("execution(* com.example.service..*(..))")
    26.     public void afterAdvice(){
    27.         System.out.println("方法执行之后通知");
    28.     }
    29.  
    30.     //环绕通知 目标方法执行之前和执行之后   并且在前置通知之前  在后置通知之后
    31.     @Around("execution(* com.example.service..*(..))")
    32.     public Object aroundAdvice(ProceedingJoinPoint joinPoint){//注意多参情况ProceedingJoinPoint要放第一位
    33.         Object result = null;
    34.         try {
    35.             System.out.println("执行方法前");
    36.             //调用目标方法
    37.             result=joinPoint.proceed();
    38.             System.out.println("执行方法后");
    39.         } catch (Throwable throwable) {
    40.             throwable.printStackTrace();
    41.         }finally {
    42.  
    43.         }
    44.         return result;
    45.     }
    46.  
    47.     //异常通知 发生异常之后
    48.     @AfterThrowing(value = "execution(* com.example.service..*(..))",throwing = "e")//当目标方法执行时,抛出异常时,可以用AfterThrowing记录
    49.     public void afterThrowingAdvice(){
    50.         System.out.println("报错了我就执行了");
    51.     }
    52.  
    53.     //最终通知asd
    54.     @After("execution(* com.example.service..*(..))")
    55.     public void after(){
    56.         System.out.println("最后我肯定会执行");
    57.     }
    58.  
    59. }

    当系统有多个切面时候

    加个切面

    可以用@Order排序   数字小在前面

    测试

    通用切入点

    切面上的代码,每个切入点都要写切入点表达式,代码冗余

    1. package com.example.aspect;
    2.  
    3. import org.aspectj.lang.ProceedingJoinPoint;
    4. import org.aspectj.lang.annotation.*;
    5. import org.springframework.core.annotation.Order;
    6. import org.springframework.stereotype.Component;
    7.  
    8. /**
    9.  * @author hrui
    10.  * @date 2023/9/26 0:33
    11.  */
    12. @Component
    13. @Aspect//标注是一个切面
    14. @Order(2)
    15. public class LogAspect {//切面
    16.  
    17.     //切面=切入点+通知
    18.     //通知就是增强,就是具体要编写的增强代码
    19.  
    20.  
    21.     @Pointcut("execution(* com.example.service..*(..))")
    22.     public void 通用切点(){
    23.         //这个方法只是一个标记,方法名随意,方法体也不需要写任何代码
    24.     }
    25.  
    26.  
    27.     //前置通知   方法执行之前
    28.     @Before("通用切点()")//里面要写切入点表达式 UserService里的所有方法
    29.     public void 增强(){
    30.         System.out.println("我是一个通知,我是一段增强代码");
    31.     }
    32.  
    33.     //后置通知   方法执行之后返回时执行
    34.     @AfterReturning("通用切点()")
    35.     public void afterAdvice(){
    36.         System.out.println("方法执行之后通知");
    37.     }
    38.  
    39.     //环绕通知 目标方法执行之前和执行之后   并且在前置通知之前  在后置通知之后
    40.     @Around("通用切点()")
    41.     public Object aroundAdvice(ProceedingJoinPoint joinPoint){//注意多参情况ProceedingJoinPoint要放第一位
    42.         Object result = null;
    43.         try {
    44.             System.out.println("执行方法前");
    45.             //调用目标方法
    46.             result=joinPoint.proceed();
    47.             System.out.println("执行方法后");
    48.         } catch (Throwable throwable) {
    49.             throwable.printStackTrace();
    50.         }finally {
    51.  
    52.         }
    53.         return result;
    54.     }
    55.  
    56.     //异常通知 发生异常之后
    57.     @AfterThrowing(value = "通用切点()",throwing = "e")//当目标方法执行时,抛出异常时,可以用AfterThrowing记录
    58.     public void afterThrowingAdvice(){
    59.         System.out.println("报错了我就执行了");
    60.     }
    61.  
    62.     //最终通知asd
    63.     @After("通用切点()")
    64.     public void after(){
    65.         System.out.println("最后我肯定会执行");
    66.     }
    67.  
    68. }

    测试

    范式

    1. package com.jt.aop;
    2.  
    3.  
    4. import org.aspectj.lang.JoinPoint;
    5. import org.aspectj.lang.ProceedingJoinPoint;
    6. import org.aspectj.lang.annotation.*;
    7. import org.springframework.stereotype.Component;
    8.  
    9. import java.util.Arrays;
    10.  
    11. /**
    12.  *  AOP(面向切面编程) 主要利用**动态代理**的模式 **降低程序的耦合度,扩展业务功能方法.**
    13.  * 1.AOP需要被Spring容器管理 @Component
    14.  * 2.标识该类是AOP切面   @Aspect
    15.  * 关于AOP名词介绍
    16.  * 1).连接点: 用户可以被扩展的方法    其实我们将自定义注解放到目标方法上做标识,那么该注解其实就是个连接点
    17.  * 2).切入点: 用户实际扩展的方法      确定了连接点,那么该方法也就是个切入点
    18.  * 3).通知:  扩展方法的具体实现       5个通知
    19.  * 4).切面: 将通知应用到切入点的过程
    20.  *
    21.  *   通知类型(必会)
    22.  * 1. before:  在目标方法执行之前执行
    23.  * 2. afterReturning: 在目标方法执行之后返回时执行
    24.  * 3. afterThrowing:  在目标方法执行之后,抛出异常时执行
    25.  * 4. after:	无论程序是否执行成功,都要最后执行的通知
    26.  * 5. around: 在目标方法执行前后 都要执行的通知(完美体现了动态代理模式)
    27.  * 	功能最为强大 只有环绕通知可以控制目标方法的执行
    28.  *
    29.  * 关于通知方法总结:
    30.  * 	1.环绕通知是处理业务的首选.  可以修改程序的执行轨迹
    31.  * 	2.另外的四大通知一般用来做程序的监控.(监控系统) 只做记录
    32.  * @author TB
    33.  * @date 2020/2/12 0:24
    34.  */
    35. @Component
    36. //虽然标识了该类为AOP切面 但是Spring容器默认不能识别切面注解,需要手动配置
    37. //需要在配置类SpringConfig里加上注解@EnableAspectJAutoProxy
    38. @Aspect
    39. public class SpringAOP {
    40.     /**
    41.      * 切入点表达式
    42.      * 概念:当程序满足切入点表达式,才能进入切面,执行通知方法.
    43.      *
    44.      * 1.bean("bean的ID")  根据beanId进行拦截  只能匹配一个
    45.      * 2.within("包名.类名") 可以使用通配符*?      能匹配多个.
    46.      * 	粒度: 上述的切入点表达式 粒度是类级别的.  粗粒度.
    47.      * 3.execution(返回值类型   包名.类名.方法名(参数列表...))
    48.      * 	粒度: 控制的是方法参数级别. 所以粒度较细.   最常用的.
    49.      * 4.@annotation(包名.注解名)     只拦截注解.
    50.      * 	粒度: 注解是一种标记 根据规则标识某个方法/属性/类    细粒度
    51.      */
    53.     /**
    54.      * 切入点表达式练习
    55.      * within:
    56.      *  1.within(com.jt.*.DeptServiceImpl)   一级包下的类
    57.      *  2.within(com.jt..*.DeptServiceImpl)  ..代表多级包下的类
    58.      *  3.within(com.jt..*)  包下的所有的类
    59.      *
    60.      * execution(返回值类型 包名.类名.方法名(参数列表))
    61.      *  1.execution(* com.jt..*.DeptServiceImpl.add*())
    62.      *  注释: 返回值类型任意的, com.jt下的所有包中的DeptServiceImpl的类
    63.      *        的add开头的方法 ,并且没有参数.
    64.      *
    65.      *  2.execution(* com.jt..*.*(..))
    66.      *  注释: 返回值类型任意,com.jt包下的所有包的所有类的所有方法 任意参数.
    67.      *
    68.      *  3.execution(int com.jt..*.*(int))
    69.      *  4.execution(Integer com.jt..*.*(Integer))
    70.      *  强调: 在Spring表达式中没有自动拆装箱功能! 注意参数类型
    71.      *
    72.      * @annotation(包名.注解名)
    73.      *     @Before("@annotation(com.jt.anno.Cache)")
    74.      *    只拦截特定注解的内容.
    75.      */
    77.  
    78.     //1.定义before通知
    79.     //@Before("bean(deptServiceImpl)")//扫描的是一个类 因此该类里所有方法都被扩展到了
    80.     //@Before("within(com.jt.service.DeptServiceImpl)")//和上面效果一样
    81.     //@Before("execution(* com.jt.service.DeptServiceImpl.add*())")//*表示返回值类型任意 add*表示以add开头的方法名 最后()表示参数是空的
    82.     //@Before("@annotation(com.jt.anno.Cache)")//意思有该注解 就作为切入点   因此用注解标识最常用(自定义个注解)
    83.  
    84.     /**
    85.      * spring为了AOP动态获取目标对象及方法中的数据,则通过Joinpoint
    86.      * JoinPoint是所有通知的公共参数,无论哪种通知里都可以使用
    87.      * 在Before里可以获取
    88.      * 对象做数据传递获取如:
    89.      * 1.获取目标对象的类型
    90.      * 2.获取目标方法的名称
    91.      * 3.获取目标方法的参数
    92.      * @param joinPoint
    93.      */
    94.     @Before("pointcut()")
    95.     public void before(JoinPoint joinPoint){//前置方法一般作用获取参数，方法名,等等
    96.         System.out.println("目标对象的Class类对象: "+joinPoint.getTarget().getClass());
    97.         System.out.println("获取目标方法的方法签名: "+joinPoint.getSignature());
    98.         System.out.println("获取目标对象的类名: "+ joinPoint.getSignature().getDeclaringTypeName());
    99.         System.out.println("获取目标对象方法名: "+ joinPoint.getSignature().getName());
    100.         System.out.println("获取目标方法参数: "+ Arrays.toString(joinPoint.getArgs()));
    101.         System.out.println("我是before通知");
    102.     }
    103.  
    104.  
    105.     //1.定义一个切入点
    106.     @Pointcut("@annotation(com.jt.anno.Cache)")
    107.     public void pointcut(){
    108.  
    109.     }
    110.  
    111.     //如果每个通知前都加个切入点表达式  那么也太冗余了 因此我们可以定义个切入点 其他通知都围绕切入点
    112.     //@BafterReturning("@annotation(com.jt.anno.Cache)")
    113.     /**
    114.      * JoinPoint参数是所有通知方法公有的
    115.      *AfterReturning是目标方法返回执行之后返回时执行
    116.      * 可以记录方法的返回值
    117.      * AfterReturning注解里 value和pointcut是相同的效果:也就是说
    118.      * @AfterReturning(value="pointcut()",returning="result")和@AfterReturning(pointcut="pointcut()",returning="result")
    119.      * 效果一样
    120.      * returning:将方法的返回值,通过形参result(这个随便取名)来进行传递(Spring会将返回值赋值给你定义的这个变量)
    121.      */
    122.     @AfterReturning(value="pointcut()",returning="result")
    123.     public void afterReturning(JoinPoint joinPoint,Object result){//这里注意 如果有需要用到JointPoint参数 那么必须放在第一个位置  不用可以去掉
    124.         System.out.println("目标返回值结果是: "+result);
    125.         System.out.println("我是AfterReturning的通知");
    126.     }
    127.  
    128.     @AfterThrowing(pointcut = "pointcut()",throwing="e")//当目标方法执行时,抛出异常时,可以用AfterThrowing记录
    129.     public void afterThrowing(Exception e){
    130.         System.out.println("获取目标异常信息: "+e.getMessage());
    131.         System.out.println("获取目标异常类型: "+e.getClass());
    132.         System.out.println("我是AfterThrowing的通知,出现异常了");
    133.     }
    134.  
    135.     @After("pointcut()")
    136.     public void after(){
    137.         System.out.println("我是After的通知");
    138.     }
    139.  
    140.  
    141.     /**
    142.      * 关于环绕通知的说明
    143.      * 作用: 可以控制目标方法是否执行.
    144.      * 参数: ProceedingJoinPoint 通过proceed方法控制目标方法执行.
    145.      * 注意事项:
    146.      *  ProceedingJoinPoint 只能适用环绕通知
    147.      * @return
    148.      */
    149.     @Around("pointcut()")
    150.     public Object around(ProceedingJoinPoint joinPoint){//注意多参情况ProceedingJoinPoint要放第一位
    151.         Object result = null;
    152.         try {
    153.             System.out.println("环绕通知开始");
    154.             //1.执行下一个通知  2.执行目标方法 3.接收返回值
    155.             Long start = System.currentTimeMillis();
    156.             result = joinPoint.proceed();
    157.             Long end = System.currentTimeMillis();
    158.             System.out.println("耗时:"+(end-start));
    159.         } catch (Throwable throwable) {
    160.             throwable.printStackTrace();
    161.         }
    162.         System.out.println("环绕通知结束");
    163.         return result;
    164.     }
    165. }

    关于全注解式开发,不用Spring配置文件

    测试也需要改下

    Spring AOP基于XML方式的实现

    新建模块spring-aspectj-xml2

    依赖

    
    
    
        org.springframework
        spring-context
        6.0.10
    
    
    
        org.springframework
        spring-aspects
        6.0.10
    
    
    
        junit
        junit
        4.13.2
        test

     目标类

    切面类

  • 相关阅读:
    @ConditionalOnProperty配置属性作为条件
    验证工程师如何才能脱颖而出？
    iOS17.2正式版什么时候发布？ 13大新功能细节抢先看
    线程中的LockSapport于线程中断(一)
    linux常见下载安装工具
    数据分析面试手册《指标篇》
    谷歌、AMD、英特尔加入挑战，英伟达AI解决方案还能继续“遥遥领先”吗？
    算法面经广联达、中兴、电信篇
    文盘 Rust -- tokio 绑定 cpu 实践
    GAN实战笔记——第七章半监督生成对抗网络（SGAN）
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/133282000