【SSM】Spring AOP 统一问题处理(重点:Spring AOP 实现原理)

本文涉及的产品
日志服务 SLS,月写入数据量 50GB 1个月
简介: 本文重点介绍AOP 的定义、Spring AOP与AOP的关系、AOP 组成、Spring AOP 实现 和 Spring AOP 实现原理(对象代理)

  【大家好,我是爱干饭的猿,本文重点介绍AOP 的定义、Spring AOP与AOP的关系、AOP 组成、Spring AOP 实现 和 Spring AOP 实现原理(对象代理)

后续会继续分享MyBatis及其他重要知识点总结,如果喜欢这篇文章,点个赞👍,关注一下吧】

上一篇文章:《【SSM】Spring MVC 程序开发(重点:SpringMVC 工作流程)》


🤞目录🤞

🎯1.什么是 Spring AOP?

🎯2.为什要用 AOP?

🎯3.Spring AOP 的使用与原理

3.1 AOP 组成

1 切面(Aspect)

2 连接点(Join Point)

3 切点(Pointcut)

4 通知(Advice)

3.2 Spring AOP 实现

1 添加 AOP 框架支持

2 定义切面和切点

3. 定义相关通知

3.3 Spring AOP 实现原理(对象代理)

1. 织入(Weaving):代理的生成时机

2. 动态代理


🎯1.什么是 Spring AOP?

AOP(Aspect Oriented Programming):面向切面编程,它是一种思想,它是对某一类事情的集中处理

而 AOP 是一种思想,而 Spring AOP 是一个框架,提供了一种对 AOP 思想的实现,它们的关系和 IoC 与 DI 类似。

🎯2.为什要用 AOP?

想象一个场景,我们在做后台系统时,除了登录和注册等几个功能不需要做用户登录验证之外,其他几乎所有页面调用的前端控制器( Controller)都需要先验证用户登录的状态。

我们之前的处理方式是每个 Controller 都要写一遍用户登录验证,然而当你的功能越来越多,那么你要 写的登录验证也越来越多,而这些方法又是相同的,这么多的方法就会代码修改和维护的成本。

这个时候,我们就可以考虑 AOP 来统一处理。

除了统一的用户登录判断之外,AOP 还可以实现:

    • 统一日志记录
    • 统一方法执行时间统计
    • 统一的返回格式设置
    • 统一的异常处理
    • 事务的开启和提交等

    也就是说使用 AOP 可以扩充多个对象的某个能力,所以 AOP 可以说是 OOP(Object Oriented Programming,面向对象编程)的补充和完善。

    🎯3.Spring AOP 的使用与原理

    3.1 AOP 组成

    1 切面(Aspect)

    切面(Aspect)由切点(Pointcut)和通知(Advice)组成,它既包含了横切逻辑的定义,也包括了连 接点的定义。

    切面是包含了:通知、切点和切面的类,相当于 AOP 实现的某个功能的集合。

    2 连接点(Join Point)

    应用执行过程中能够插入切面的一个点,这个点可以是方法调用时,抛出异常时,甚至修改字段时。切面代码可以利用这些点插入到应用的正常流程之中,并添加新的行为。

    连接点相当于需要被增强的某个 AOP 功能的所有方法。

    3 切点(Pointcut)

    Pointcut 是匹配 Join Point 的谓词。 Pointcut 的作用就是提供一组规则(使用 AspectJ pointcut expression language 来描述)来匹配 Join Point,给满足规则的 Join Point 添加 Advice。

    切点相当于保存了众多连接点的一个集合(如果把切点看成一个表,而连接点就是表中一条一条的 数据)。

    4 通知(Advice)

    切面也是有目标的 ——它必须完成的工作。在 AOP 术语中,切面的工作被称之为通知

    通知:定义了切面是什么,何时使用,其描述了切面要完成的工作,还解决何时执行这个工作的问题。 Spring 切面类中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行调用:

      • 前置通知使用 @Before:通知方法会在目标方法调用之前执行。
      • 后置通知使用 @After:通知方法会在目标方法返回或者抛出异常后调用。
      • 返回之后通知使用 @AfterReturning:通知方法会在目标方法返回后调用。
      • 抛异常后通知使用 @AfterThrowing:通知方法会在目标方法抛出异常后调用。
      • 环绕通知使用 @Around:通知包裹了被通知的方法,在被通知的方法通知之前和调用之后执行自 定义的行为。(环绕可以实现前四个通知,较常用

      AOP 整个组成部分的概念如下图所示,以多个页面都要访问用户登录权限为例:

      image.gif编辑

      3.2 Spring AOP 实现

      Spring AOP 来实现一下 AOP 的功能,完成的目标是拦截所有 UserController 里面的方法,每次调用 UserController 中任意一个方法时,都执行相应的通知事件

      1 添加 AOP 框架支持

      在 pom.xml 中添加如下配置:(starter 后增加 aop即可)

      <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
          </dependency>

      image.gif

      2 定义切面和切点

      切点指的是具体要处理的某一类问题,比如用户登录权限验证就是一个具体的问题,记录所有方法的执行日志就是一个具体的问题,切点定义的是某一类问题

      Spring AOP 切点的定义如下,在切点中我们要定义拦截的规则,具体实现如下:

      其中 pointcut 方法为空方法,它不需要有方法体,此方法名就是起到一个“标识”的作用,标识下面的通知方法具体指的是哪个切点(因为切点可能有很多个)。

      方式一:通过 AspectJ方式定义

      切点表达式说明:

      @Component // 1. 首先,把类注册到 Spring 中
      @Aspect    // 2. 需要声明这个类是一个 切面类
      public class MyAspect {
          // 3. 定义一个切点 通过 AspectJ
          @Pointcut("execution(* com.haomin.aop.aop.UserService.*(..))")
          public void pointcut(){ }
      }

      image.gif

      AspectJ 支持三种通配符:

        • * :匹配任意字符,只匹配一个元素(包,类,或方法,方法参数)。
        • * .. :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使用。
        • + :表示按照类型匹配指定类的所有类,必须跟在类名后面,如 com.cad.Car+ ,表示继承该类的所 有子类包括本身。

        切点表达式由切点函数组成,其中 execution() 是最常用的切点函数,用来匹配方法,

        语法为: execution(<修饰符><返回类型><包.类.方法(参数)><异常>)

        修饰符和异常可以省略。

        image.gif编辑

        方式二:自定义切点

        1. 先定义一个注解

        @Target(ElementType.METHOD)
        @Retention(RetentionPolicy.RUNTIME)
        public @interface SomePointcut {
        }

        image.gif

        2. 然后将一个注解定义成 切点

        @Component // 1. 首先,把类注册到 Spring 中
        @Aspect    // 2. 需要声明这个类是一个 切面类
        public class MyAspect {
            // 3. 将一个注解定义成 切点
            @Pointcut("@annotation(com.haomin.aop.aop.SomePointcut)")
            public void somePointcut() { }
        }

        image.gif

        3. 使用时,哪个方法需要 AOP,就可以把这个注解修饰在方法上

        @Service
        public class UserService {
            @SomePointcut //使用时,哪个方法需要 AOP,就可以把这个注解修饰在方法上
            public void register(String username, String password) {
                System.out.printf("UserService.register(username = %s, password = %s)\n", username, password);
            }
        }

        image.gif

        3. 定义相关通知

        通知定义的是被拦截的方法具体要执行的业务,比如用户登录权限验证方法就是具体要执行的业务。 Spring AOP 中,可以在方法上使用以下注解,会设置方法为通知方法,在满足条件后会通知本方法进行。

        /**
         * @author haomin
         * @date 2022/10/17 18:14
         **/
        @Component // 1. 首先,把类注册到 Spring 中
        @Aspect    // 2. 需要声明这个类是一个 切面类
        public class MyAspect {
            // 3. 定义一个切点
            // 3.1 通过 AspectJ 定义切点
            @Pointcut("execution(* com.haomin.aop.aop.UserService.*(..))")
            public void OnePointcut(){ }
            // 3.2 将一个注解定义成切点
            @Pointcut("@annotation(com.haomin.aop.aop.SomePointcut)")
            public void somePointcut() { }
            // 4. 定义一个切点通知
            // 结束前通知
            @Before("OnePointcut()")
            public void beforeMethodInvoked() {
                System.out.println("执行:MyAspect.beforeMethodInvoked()");
            }
            // 结束后通知
            @After("OnePointcut()")
            public void afterMethodInvoked() {
                System.out.println("执行:MyAspect.afterMethodInvoked()");
            }
            // 返回值后通知 :无异常的情况
            @AfterReturning("OnePointcut()")
            public void afterReturning() {
                System.out.println("执行:MyAspect.afterReturning()");
            }
            // 异常后通知
            @AfterThrowing("OnePointcut()")
            public void afterThrowing() {
                System.out.println("执行:MyAspect.afterThrowing()");
            }
            @Around("OnePointcut()")
            public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
                try {
                    // 执行拦截方法
                    System.out.println("beforeMethodInvoked"); // 相当于前置通知
                    Object obj = joinPoint.proceed();          // 真正调用方法的位置
                    System.out.println("afterReturning");      // 相当于返回之后通知
                    return obj;
                } catch (Throwable throwable) {
                    System.out.println("afterThrowing");       // 相当于抛异常后置通知
                    throw throwable;
                } finally {
                    System.out.println("afterMethodInvoked");  // 相当于后置通知
                }
            }
        }

        image.gif

        3.3 Spring AOP 实现原理(对象代理)

        Spring AOP 是构建在动态代理基础上,因此 Spring 对 AOP 的支持局限于方法级别的拦截。

        Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。默认情况下,实现了接口的类,使用 AOP 会基于 JDK 生成代理类,没有实现接口的类,会基于 CGLIB 生成代理类。

        image.gif编辑

        1. 织入(Weaving):代理的生成时机

        织入是把切面应用到目标对象并创建新的代理对象的过程,切面在指定的连接点被织入到目标对象中。 在目标对象的生命周期里有多个点可以进行织入:

          • 编译期:切面在目标类编译时被织入。这种方式需要特殊的编译器。AspectJ的织入编译器就是以 这种方式织入切面的。
          • 类加载器:切面在目标类加载到JVM时被织入。这种方式需要特殊的类加载器(ClassLoader),它 可以在目标类被引入应用之前增强该目标类的字节码。AspectJ5的加载时织入(load-time weaving. LTW)就支持以这种方式织入切面。
          • 运行期:切面在应用运行的某一时刻被织入。一般情况下,在织入切面时,AOP容器会为目标对象 动态创建一个代理对象。SpringAOP就是以这种方式织入切面的。

          image.gif编辑

          2. 动态代理

          此种实现在设计模式上称为动态代理模式,在实现的技术手段上,都是在 class 代码运行期,动态的织入字节码。

          我们学习 Spring 框架中的AOP,主要基于两种方式:JDK 及 CGLIB 的方式。这两种方式的代理目标都是被代理类中的方法,在运行期,动态的织入字节码生成代理类

          CGLIB是Java中的动态代理框架,主要作用就是根据目标类和方法,动态生成代理类。 Java中的动态代理框架,几乎都是依赖字节码框架(如 ASM,Javassist 等)实现的。 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码文件信息,修改部分信 息,或动态生成一个 class。

          JDK 动态代理实现

          JDK 实现时,先通过实现 InvocationHandler 接口创建方法调用处理器,再通过 Proxy 来创建代理类。

          import org.springframework.stereotype.Service;
          import java.lang.reflect.InvocationHandler;
          import java.lang.reflect.Method;
          import java.lang.reflect.Proxy;
          /**
           * @author haomin
           * @date 2022/10/17 18:57
           **/
          public class ServiceJDKInvocationHandler implements InvocationHandler {
              //目标对象即就是被代理对象
              private Object target;
              public ServiceJDKInvocationHandler(Object target) {
                  this.target = target;
              }
              //proxy代理对象
              @Override
              public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  //1.安全检查
                  System.out.println("安全检查");
                  // 2.记录日志
                  System.out.println("记录日志");
                  // 3.时间统计开始
                  System.out.println("记录开始时间");
                  // 通过反射调用被代理类的方法
                  Object retVal = method.invoke(target, args);
                  // 4.时间统计结束
                  System.out.println("记录结束时间");
                  return retVal;
              }
              public static void main(String[] args) {
                  UserInter target = new UserService();
                  // CGLIB 动态代理实现
                  //方法调用处理器
                  InvocationHandler handler = new ServiceJDKInvocationHandler(target);
                  //创建一个代理类:通过被代理类、被代理实现的接口、方法调用处理器来创建
                  UserInter proxy = (UserInter) Proxy.newProxyInstance(
                          target.getClass().getClassLoader(),
                          new Class[]{UserInter.class},
                          handler);
                  proxy.register("张三", "123");
              }
          }
          // 接口
          interface UserInter {
              void register(String username, String password);
          }
          // 接口实现类
          @Service
          class UserService implements UserInter{
              @Override
              public void register(String username, String password) {
                  System.out.printf("UserService.register(username = %s, password = %s)\n", username, password);
              }
          }

          image.gif

          CGLIB 动态代理实现

          CGLIB 动态代理实现时通过继承被代理类。

          /**
           * @author haomin
           * @date 2022/10/17 19:10
           **/
          import org.springframework.cglib.proxy.Enhancer;
          import org.springframework.cglib.proxy.MethodInterceptor;
          import org.springframework.cglib.proxy.MethodProxy;
          import org.springframework.stereotype.Service;
          import java.lang.reflect.Method;
          public class ServiceCGLIBInterceptor implements MethodInterceptor {
              //被代理对象
              private Object target;
              public ServiceCGLIBInterceptor(Object target) {
                  this.target = target;
              }
              @Override
              public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                  //1.安全检查
                  System.out.println("安全检查");
                  //2.记录日志
                  System.out.println("记录日志");
                  // 3.时间统计开始
                  System.out.println("记录开始时间");
                  // 通过cglib的代理方法调用
                  Object retVal = methodProxy.invoke(target, args);
                  // 4.时间统计结束
                  System.out.println("记录结束时间");
                  return retVal;
              }
              public static void main(String[] args) {
                  UserService2 target = new UserService2();
                  UserService2 proxy = (UserService2) Enhancer.create(
                          target.getClass(),
                          new ServiceCGLIBInterceptor(target)
                  );
                  proxy.register("张三", "123");
              }
          }
          // 一个类对象
          @Service
          class UserService2{
              public void register(String username, String password) {
                  System.out.printf("UserService.register(username = %s, password = %s)\n", username, password);
              }
          }

          image.gif

          JDK 和 CGLIB 的区别

          1. JDK 实现,要求被代理类必须实现接口,之后是通过 InvocationHandler 及 Proxy,在运行时动态的在内存中生成了代理类对象,该代理对象是通过实现同样的接口实现(类似静态代理接口实现的 方式),只是该代理类是在运行期时,动态的织入统一的业务逻辑字节码来完成。

          2. CGLIB 实现,被代理类可以不实现接口,是通过继承被代理类,在运行时动态的生成代理类对象。


          分享到此,感谢大家观看!!!

          如果你喜欢这篇文章,请点赞关注吧,或者如果你对文章有什么困惑,可以私信我。

          🏓🏓🏓

          相关实践学习
          日志服务之使用Nginx模式采集日志
          本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
          相关文章
          |
          2月前
          |
          安全 Java 数据库
          一天十道Java面试题----第四天(线程池复用的原理------>spring事务的实现方式原理以及隔离级别)
          这篇文章是关于Java面试题的笔记,涵盖了线程池复用原理、Spring框架基础、AOP和IOC概念、Bean生命周期和作用域、单例Bean的线程安全性、Spring中使用的设计模式、以及Spring事务的实现方式和隔离级别等知识点。
          |
          2月前
          |
          Java
          Spring5入门到实战------9、AOP基本概念、底层原理、JDK动态代理实现
          这篇文章是Spring5框架的实战教程,深入讲解了AOP的基本概念、如何利用动态代理实现AOP,特别是通过JDK动态代理机制在不修改源代码的情况下为业务逻辑添加新功能,降低代码耦合度,并通过具体代码示例演示了JDK动态代理的实现过程。
          Spring5入门到实战------9、AOP基本概念、底层原理、JDK动态代理实现
          |
          15天前
          |
          设计模式 Java 测试技术
          spring复习04,静态代理动态代理,AOP
          这篇文章讲解了Java代理模式的相关知识,包括静态代理和动态代理(JDK动态代理和CGLIB),以及AOP(面向切面编程)的概念和在Spring框架中的应用。文章还提供了详细的示例代码,演示了如何使用Spring AOP进行方法增强和代理对象的创建。
          spring复习04,静态代理动态代理,AOP
          |
          6天前
          |
          Java Spring 容器
          Spring IOC、AOP与事务管理底层原理及源码解析
          【10月更文挑战第1天】Spring框架以其强大的控制反转(IOC)和面向切面编程(AOP)功能,成为Java企业级开发中的首选框架。本文将深入探讨Spring IOC和AOP的底层原理,并通过源码解析来揭示其实现机制。同时,我们还将探讨Spring事务管理的核心原理,并给出相应的源码示例。
          42 9
          |
          2天前
          |
          设计模式 Java Spring
          Spring Boot监听器的底层实现原理
          Spring Boot监听器的底层实现原理主要基于观察者模式(也称为发布-订阅模式),这是设计模式中用于实现对象之间一对多依赖的一种常见方式。在Spring Boot中,监听器的实现依赖于Spring框架提供的事件监听机制。
          9 1
          |
          16天前
          |
          XML Java 开发者
          经典面试---spring IOC容器的核心实现原理
          作为一名拥有十年研发经验的工程师,对Spring框架尤其是其IOC(Inversion of Control,控制反转)容器的核心实现原理有着深入的理解。
          57 3
          |
          1天前
          |
          负载均衡 Java 网络架构
          Spring Cloud原理详解
          介绍了Spring Cloud的原理和核心组件,包括服务注册与发现、配置管理、负载均衡、断路器、智能路由、分布式消息传递、分布式追踪和服务熔断等,旨在帮助开发人员快速构建和管理微服务架构中的分布式系统。
          6 0
          |
          29天前
          |
          Java 数据库连接 数据库
          Spring基础3——AOP,事务管理
          AOP简介、入门案例、工作流程、切入点表达式、环绕通知、通知获取参数或返回值或异常、事务管理
          Spring基础3——AOP,事务管理
          |
          2月前
          |
          Java 数据库连接 Spring
          后端框架入门超详细 三部曲 Spring 、SpringMVC、Mybatis、SSM框架整合案例 【爆肝整理五万字】
          文章是关于Spring、SpringMVC、Mybatis三个后端框架的超详细入门教程,包括基础知识讲解、代码案例及SSM框架整合的实战应用,旨在帮助读者全面理解并掌握这些框架的使用。
          后端框架入门超详细 三部曲 Spring 、SpringMVC、Mybatis、SSM框架整合案例 【爆肝整理五万字】
          |
          2月前
          |
          XML Java 数据格式
          Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解
          这篇文章是Spring5框架的AOP切面编程教程,通过XML配置方式,详细讲解了如何创建被增强类和增强类,如何在Spring配置文件中定义切入点和切面,以及如何将增强逻辑应用到具体方法上。文章通过具体的代码示例和测试结果,展示了使用XML配置实现AOP的过程,并强调了虽然注解开发更为便捷,但掌握XML配置也是非常重要的。
          Spring5入门到实战------11、使用XML方式实现AOP切面编程。具体代码+讲解