• spring之AOP(面向切面编程)之详结

    AOP面向切面编程，一种编程范式，指导开发者如何组织程序结构

    作用：

    在不惊动原始设计的基础上为其进行功能增强

    核心概念

    • 代理：SpringAOP的核心本质是采用代理模式实现的
    • 连接点：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
      • 在springAOP中，理解为方法的执行
    • 切入点：匹配连接点的式子
      • 在springAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
    • 通知：在切入点出执行的操作，也就是共性功能，在AOP中，功能最终以方法的形式呈现
    • 通知类：定义通知的类
    • 切面：描述通知与切入点的对应关系

    如果不理解的话可以看这一段话帮助理解：连接点（所有英雄）、切入点（增强的英雄）、通知类（buff库）、通知（各种buff）、切面（可以理解为设计师，从buff库里面拿出具体的buff加强给英雄）

    现给一个入门案例：

    注解配置类：

    1. @Configuration
    2. @ComponentScan("com.example")
    3. @EnableAspectJAutoProxy  //切面相关注解
    4. public class SpringConfig {
    5. }

    切面：

    1. @Component  //交给spring来管理
    2. @Aspect //声明这个类是切面
    3. public class MyAdvice {
    4.     //定义一个私有的切入点
    5.     @Pointcut("execution(void com.example.dao.BookDao.update())")
    6.     private void pt(){}
    7.  
    8.     //通知在方法前执行
    9.     @Before("pt()")
    10.     public void method(){
    11.         System.out.println(System.currentTimeMillis());
    12.     }
    13. }

    连接点及实现类：

    1. public interface BookDao {
    2.     public void save();
    3.     public void update();
    4. }
    1. @Repository
    2. public class BookDaoImpl implements BookDao {
    3.     @Override
    4.     public void save() {
    5.         System.out.println("book dao save...");
    6.     }
    7.  
    8.     @Override
    9.     public void update() {
    10.         System.out.println("book dao update...");
    11.     }
    12. }

    测试：

    1. public class Aop {
    2.  
    3.     public static void main(String[] args) {
    4.         ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);
    5.         BookDao bookDao = ctx.getBean(BookDao.class);
    6.         bookDao.update();
    7.     }
    8. }
    9. //输出
    10. 1712407510166
    11. book dao update...

    工作流程

    1. Spring容器启动
    2. 读取所有切面配置中的切入点
    3. 初始化bean，判定bean对应的类中的方法是否匹配到任意切入点
      1. 匹配失败，创建对象 
        1. public static void main(String[] args) {
        2.         ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);
        3.         BookDao bookDao = ctx.getBean(BookDao.class);
        4.         //bookDao.update();
        5.         System.out.println(bookDao);
        6.         System.out.println(bookDao.getClass());
        7.     }
        8.  
        9. //输出
        10. com.example.dao.impl.BookDaoImpl@b3ca52e
        11. class com.example.dao.impl.BookDaoImpl

      2. 匹配成功，创建原始对象(目标对象)的代理对象。目标对象：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的。代理：目标对象无法直接完成工作，需要对其进行功能回调，通过原始对象的代理对象实现 
        1. public static void main(String[] args) {
        2.         ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);
        3.         BookDao bookDao = ctx.getBean(BookDao.class);
        4.         //bookDao.update();
        5.         System.out.println(bookDao);
        6.         System.out.println(bookDao.getClass());
        7.     }
        8.  
        9. //输出
        10. com.example.dao.impl.BookDaoImpl@7530ad9c
        11. class com.sun.proxy.$Proxy19
    4. 获取bean的执行方法
      1. 获取bean，调用方法并执行，完成操作
      2. 获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

    切入点表达式

    • 切入点：要进行增强的方法
    • 切入点表达式：要进行增强的方法的描述方式

    1. 描述方式

    1. 方式1：执行com.example.dao包下的BookDao接口中的无参数update方法：execution(void com.example.dao.BookDao.update())
    2. 方式2：执行com.example.dao.impl包下的BookDaoImpl类中的无参数update方法：execution(void com.example.dao.impl.BookDaoImpl.update())

    2. 切入点表达式的标准格式

    格式：动作关键字(访问修饰符  返回值  包名.类/接口名.方法名（参数）异常名)

    execution(public void com.example.dao.impl.BookDaoImpl.update(int))
    • 动作关键字：描述切入点的动作行为，例如execution表示执行到指定切入点
    • 访问修饰符：public、private等，可以省略
    • 返回值
    • 包名
    • 类/接口名
    • 方法名
    • 参数
    • 异常名：方法定义中抛出指定异常，可以省略

    通配符描述切入点：

    • * ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配出现 
      1. //匹配com.example包下任意包中的BookDao类或接口中所有update开头的带有一个参数的方法
      2. execution(public * com.example.*.BookDao.update*(*))
    • .. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写 
      1. //匹配com包下任意包中的BookDao类或接口中所有名称为update的方法
      2. execution(public Book com..BookDao.update(..))
    • + ：专用于匹配子类型 
      execution(* *..*Dao+.*(..))

    通知类型

    • AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
    • AOP通知共分为5种类型：
      • 前置通知：@Before 
        1. @Component  //交给spring来管理
        2. @Aspect //声明这个类是切面
        3. public class MyAdvice {
        4.     //定义一个私有的切入点
        5.     @Pointcut("execution(void com.example.dao.BookDao.update())")
        6.     private void pt(){}
        7.  
        8.     //通知在方法前执行
        9.     @Before("pt()")
        10.     public void method(){
        11.         System.out.println(System.currentTimeMillis());
        12.     }
        13. }
        14. //输出
        15. 1712407510166
        16. book dao update...
      • 后置通知：@After。如果方法异常也会执行 
        1. @Component  //交给spring来管理
        2. @Aspect //声明这个类是切面
        3. public class MyAdvice {
        4.     //定义一个私有的切入点
        5.     @Pointcut("execution(void com.example.dao.BookDao.update())")
        6.     private void pt(){}
        7.  
        8.     @After("pt()")
        9.     public void method(){
        10.         System.out.println(System.currentTimeMillis());
        11.     }
        12. }
        13.  
        14. //输出
        15. book dao update...
        16. 1712407576367
      • 环绕通知：@Around 
        1. @Component  //交给spring来管理
        2. @Aspect //声明这个类是切面
        3. public class MyAdvice {
        4.     //定义一个私有的切入点
        5.     @Pointcut("execution(void com.example.dao.BookDao.update())")
        6.     private void pt(){}
        7.  
        8.     
        9.     @Around("pt()")
        10.     public void method(ProceedingJoinPoint pjp) throws Throwable {
        11.         System.out.println("around before advice...");
        12.         //表示对原始操作的调用
        13.         pjp.proceed();
        14.         //如果方法有返回值的话用以下
        15.         //Object proceed = pjp.proceed();
        16.         System.out.println("around after advice...");
        17.     }
        18. }
        19.  
        20. //输出
        21. around before advice...
        22. book dao update...
        23. around after advice...
        • 注意事项：
          • 环绕通知必须依赖形参ProceedingJoinPoint才能实现对原始方法的调用，进而实现原始方法调用前后同时添加通知
          • 通知中如果未使用ProceedingJoinPoint对原始方法进行调用将跳过原始方法的执行
          • 对原始方法的调用可以不接收返回值，通知方法设置成void即可，如果接收返回值，必须设定为Object类型
          • 原始方法的返回值如果是void类型，通知方法的返回值类型可以设置成void，也可以设置成Object类型
          • 由于无法预知原始方法运行后是否会抛出异常，因此环绕通知方法必须抛出Throwable对象
      • 返回后通知：@AfterRunning。方法执行完后执行，如果方法异常不会执行
      • 抛出异常后通知：@AfterThrowing。方法异常会执行，无异常则不执行

    通知获取数据

    • 获取切入点方法的参数
      • JoinPoint：适用于前置、后置、返回后、抛出异常后通知，必须是第一个参数。现以前置为例： 
        1. //接口实现类的方法
        2. @Override
        3. public String findName(int id) {
        4.     System.out.println("id:"+id);
        5.     return "test";
        6. }
        7.  
        8. //前置通知
        9. //定义一个私有的切入点
        10.     @Pointcut("execution(* com.example.dao.BookDao.findName(..))")
        11.     private void pt(){}
        12.  
        13.     @Before("pt()")
        14.     public void before(JoinPoint joinPoint){
        15.         //获取方法的参数
        16.         Object[] args = joinPoint.getArgs();
        17.         System.out.println(Arrays.toString(args));
        18.         System.out.println("before advice...");
        19.     }
        20.  
        21. //测试
        22.  public static void main(String[] args) {
        23.         ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);
        24.         BookDao bookDao = ctx.getBean(BookDao.class);
        25.         String name = bookDao.findName(100);
        26.         System.out.println(name);
        27.     }
        28.  
        29. //输出
        30. [100]
        31. before advice...
        32. id:100
        33. test
      • ​​​​​​​ProceedingJoinPoint：适用于环绕通知 
        1.  @Around("pt()")
        2.     public Object around(ProceedingJoinPoint pjp) throws Throwable {
        3.         //获取方法的参数
        4.         Object[] args = pjp.getArgs();
        5.         System.out.println(Arrays.toString(args));
        6.         //可以对原始操作的参数进行修改
        7.         args[0]=666;
        8.         Object proceed = pjp.proceed(args);//args可加可不加，默认是方法的参数，修改后传递的是修改的数据
        9.         return proceed;
        10. }
        11. //测试
        12.  public static void main(String[] args) {
        13.         ApplicationContext ctx= new AnnotationConfigApplicationContext(SpringConfig.class);
        14.         BookDao bookDao = ctx.getBean(BookDao.class);
        15.         String name = bookDao.findName(100);
        16.         System.out.println(name);
        17.     }
        18.  
        19. //输出
        20. [100]
        21. id:666
        22. test
    • 获取切入点方法返回值
      • ​​​​​​​返回后通知 
        1. @AfterReturning(value = "pt()",returning = "ret")
        2.     public void afterReturning(Object ret){
        3.         System.out.println("方法的返回值是："+ret);
        4.         System.out.println("afterReturning advice...");
        5.     }
      • 环绕通知。 
        1.  @Around("pt()")
        2.     public Object around(ProceedingJoinPoint pjp) throws Throwable {
        3.         //获取方法的参数
        4.         Object[] args = pjp.getArgs();
        5.         System.out.println(Arrays.toString(args));
        6.         //可以对原始操作的参数进行修改
        7.         args[0]=666;
        8.         Object proceed = pjp.proceed(args);//args可加可不加，默认是方法的参数，修改后传递的是修改的数据
        9.         return proceed;//proceed就是方法的返回值
        10. }
    • 获取切入点方法运行异常信息
      • ​​​​​​​抛出异常后通知 
        1. @AfterThrowing(value = "pt()",throwing = "t")
        2.     public void afterThrowing(Throwable t){
        3.         System.out.println("afterThrowing advice...");
        4.     }
      • 环绕通知。 
        1. @Around("pt()")
        2.     public Object around(ProceedingJoinPoint pjp) throws Throwable {
        3.         Object ret=null;
        4.         try {
        5.             ret= pjp.proceed();
        6.         } catch (Throwable e) {
        7.             e.printStackTrace();
        8.         }
        9.         return ret;
        10.     }

  • 相关阅读:
    Vector的扩容机制原理及源码分析
    【檀越剑指大厂--泛型】泛型总结
    【华为机试真题 JAVA】找出符合要求的字符串子串-100
    小鱼ROS
    Node.js基础---npm与包
    docx-preview 实现前端word预览
    性能测试TPS/QPS/RT理解
    centos上安装clickhouse和启动使用
    vue3切换路由模式——Hash 、histoary
    音视频从入门到精通——MediaMuxer API 简介
  • 原文地址：https://blog.csdn.net/qq_62636650/article/details/137434000