Spring AOP 详解
作者:mmseoamin日期:2023-12-18

Spring AOP 详解

  • 一、什么是 Spring AOP
  • 二、为何要用 AOP
  • 三、Spring AOP
    • 3.1 AOP 组成
      • 3.1.1 切面 (Aspect)
      • 3.1.2 连接点 (Join Point)
      • 3.1.3 切点 (Pointcut)
      • 3.1.4 通知 / 增强方法 (Advice)
      • 3.1.5 小结
      • 3.2 Spring AOP 使用
        • 3.2.1 添加 AOP 框架支持
        • 3.2.2 定义切面和切点
        • 3.2.3 定义相关通知
        • 3.2.4 验证
        • 3.3 Spring AOP 实现原理
        • 四、总结

          一、什么是 Spring AOP

          在介绍 Spring AOP 之前,⾸先要了解⼀下什么是 AOP?

          AOP (Aspect Oriented Programming):⾯向切⾯编程,它是⼀种思想,它是对某⼀类事情的集中处理。 比如⽤户登录权限的效验,没学 AOP 之前,我们所有需要判断⽤户登录的⻚⾯ (中的⽅法),都要各⾃实现或调⽤⽤户验证的⽅法,然⽽有了 AOP 之后,我们只需要在某⼀处配置⼀下,所有需要判断⽤户登录页面 (中的⽅法) 就全部可以实现⽤户登录验证了,不再需要每个⽅法中都写相同的⽤户登录验证了。

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

          Spring AOP 详解,在这里插入图片描述,第1张

          二、为何要用 AOP

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

          我们之前的处理⽅式是每个 Controller 都要写⼀遍用户登录验证,然⽽当你的功能越来越多,那么你要写的登录验证也越来越多,⽽这些⽅法⼜是相同的,这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢?答案是有的,对于这种功能统一,且使用的地方较多的功能,就可以考虑 AOP 来统一处理了。

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

          • 统⼀⽇志记录
          • 统⼀⽅法执⾏时间统计
          • 统⼀的返回格式设置
          • 统⼀的异常处理
          • 事务的开启和提交等

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

            三、Spring AOP

            Spring AOP 学习主要分为以下 3 个部分:

            1. 学习 AOP 是如何组成的?也就是学习 AOP 组成的相关概念。
            2. 学习 Spring AOP 使用。
            3. 学习 Spring AOP 实现原理。

            下⾯我们分别来看。

            3.1 AOP 组成

            3.1.1 切面 (Aspect)

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

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

            3.1.2 连接点 (Join Point)

            应⽤执⾏过程中能够插⼊切⾯的⼀个点,这个点可以是⽅法调⽤时,抛出异常时,甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中,并添加新的⾏为。

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

            3.1.3 切点 (Pointcut)

            Pointcut 是匹配 Join Point 的谓词。

            Pointcut 的作⽤就是提供⼀组规则(使⽤ AspectJ pointcut expression language 来描述)来匹配 Join Point,给满⾜规则的 Join Point 添加 Advice。

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

            3.1.4 通知 / 增强方法 (Advice)

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

            通知:定义了切⾯是什么,何时使⽤,其描述了切⾯要完成的⼯作,还解决何时执⾏这个⼯作的问题。

            Spring 切⾯类中,可以在⽅法上使⽤以下注解,会设置⽅法为通知⽅法,在满⾜条件后会通知本⽅法进⾏调⽤:

            • 前置通知使⽤ @Before:通知⽅法会在⽬标⽅法调⽤之前执⾏。
            • 后置通知使⽤ @After:通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤。
            • 返回之后通知使⽤ @AfterReturning:通知⽅法会在⽬标⽅法返回后调⽤。
            • 抛异常后通知使⽤ @AfterThrowing:通知⽅法会在⽬标⽅法抛出异常后调⽤。
            • 环绕通知使⽤ @Around:通知包裹了被通知的⽅法,在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为。

              切点相当于要增强的方法。

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

              Spring AOP 详解,在这里插入图片描述,第2张

              3.1.5 小结

              Spring AOP 详解,在这里插入图片描述,第3张

              3.2 Spring AOP 使用

              接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能,完成的⽬标是拦截所有 UserController ⾥⾯的⽅法,每次调⽤ UserController 中任意⼀个⽅法时,都执⾏相应的通知事件。

              Spring AOP 的实现步骤如下:

              1. 添加 Spring AOP 框架⽀持
              2. 定义切⾯和切点
              3. 定义通知

              3.2.1 添加 AOP 框架支持

              在 pom.xml 中添加如下配置:

              		
              			org.springframework.boot
              			spring-boot-starter-aop
              		
              

              3.2.2 定义切面和切点

              切点指的是具体要处理的某⼀类问题,⽐如⽤户登录权限验证就是⼀个具体的问题,记录所有⽅法的执行日志就是⼀个具体的问题,切点定义的是某⼀类问题。

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

              package com.example.demo.aop;
              import org.aspectj.lang.annotation.*;
              import org.springframework.stereotype.Component;
              /**
               * 登录的 AOP 实现代码
               */
              @Component
              @Aspect // 标识当前类为一个切面
              public class LoginAOP {
                  // 定义切点(拦截的规则)
                  @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
                  public void pointcut() {
                  }
              }
              

              其中 pointcut ⽅法为空⽅法,它不需要有⽅法体,此⽅法名就是起到⼀个“标识”的作⽤,标识下⾯的

              通知⽅法具体指的是哪个切点(因为切点可能有很多个)。

              切点表达式说明

              AspectJ ⽀持三种通配符:

              * :匹配任意字符,只匹配⼀个元素(包,类,或⽅法,⽅法参数)

              .. :匹配任意字符,可以匹配多个元素 ,在表示类时,必须和 * 联合使⽤。

              + :表示按照类型匹配指定类的所有类,必须跟在类名后⾯,如 com.cad.Car+ ,表示继承该类的所有子类包括本身

              切点表达式由切点函数组成,其中 execution() 是最常⽤的切点函数,⽤来匹配⽅法,语法为:

              execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)

              Spring AOP 详解,在这里插入图片描述,第4张

              修饰符和异常可以省略,具体含义如下:

              Spring AOP 详解,在这里插入图片描述,第5张

              Spring AOP 详解,在这里插入图片描述,第6张

              Spring AOP 详解,在这里插入图片描述,第7张

              表达式示例:

              execution(* com.cad.demo.User.*(..)) :匹配 User 类⾥的所有⽅法。

              execution(* com.cad.demo.User+.*(..)) :匹配该类的⼦类包括该类的所有⽅法。

              execution(* com.cad.*.*(..)) :匹配 com.cad 包下的所有类的所有⽅法。

              execution(* com.cad..*.*(..)) :匹配 com.cad 包下、⼦孙包下所有类的所有⽅法。

              execution(* addUser(String, int)) :匹配 addUser ⽅法,且第⼀个参数类型是 String,第⼆个参数类型是 int。

              3.2.3 定义相关通知

              通知定义的是被拦截的⽅法具体要执⾏的业务,⽐如⽤户登录权限验证⽅法就是具体要执⾏的业务。

              Spring AOP 中,可以在⽅法上使⽤以下注解,会设置⽅法为通知⽅法,在满⾜条件后会通知本⽅法进⾏调⽤:

              • 前置通知使⽤@Before:通知⽅法会在目标方法调⽤之前执行。
              • 后置通知使⽤@After:通知⽅法会在目标方法返回或者抛出异常后调用。
              • 返回之后通知使⽤@AfterReturning:通知方法会在目标方法返回后调用。
              • 抛异常后通知使⽤@AfterThrowing:通知方法会在目标方法抛出异常后调用。
              • 环绕通知使⽤@Around:通知包裹了被通知的方法,在被通知的⽅法通知之前和调用之后执行⾃定义的行为。

                具体实现如下:

                package com.example.demo.aop;
                import org.aspectj.lang.ProceedingJoinPoint;
                import org.aspectj.lang.annotation.*;
                import org.springframework.stereotype.Component;
                /**
                 * 登录的 AOP 实现代码
                 */
                @Component
                @Aspect // 标识当前类为一个切面
                public class LoginAOP {
                    // 定义切点(拦截的规则)
                    @Pointcut("execution(* com.example.demo.controller.UserController.*(..))")
                    public void pointcut() {
                    }
                    // 前置通知
                    @Before("pointcut()")
                    public void doBefore() {
                        System.out.println("执行了前置通知");
                    }
                    // 后置通知
                    @After("pointcut()")
                    public void doAfter() {
                        // 后置通知实现的具体业务代码
                        System.out.println("执行了后置通知");
                    }
                    // 环绕通知
                    @Around("pointcut()")
                    public Object doAround(ProceedingJoinPoint joinPoint) {
                        Object result = null;
                        // 前置业务代码
                        System.out.println("环绕通知的前置执行方法");
                        try {
                            // 执行目标方法
                            result = joinPoint.proceed();
                        } catch (Throwable e) {
                            e.printStackTrace();
                        }
                        // 后置业务执行代码
                        System.out.println("环绕通知的后置执行方法");
                        return result;
                    }
                }
                

                经过以上的代码我们就能实现 Spring AOP 了。

                3.2.4 验证

                提前对 UserController 类中的 getall 方法进行一系列封装:

                package com.example.demo.controller;
                import com.example.demo.model.UserInfo;
                import com.example.demo.service.UserService;
                import org.springframework.beans.factory.annotation.Autowired;
                import org.springframework.web.bind.annotation.RequestMapping;
                import org.springframework.web.bind.annotation.RestController;
                import java.util.List;
                @RestController
                @RequestMapping("/user")
                public class UserController {
                    @Autowired
                    private UserService userService;
                    @RequestMapping("/getall")
                    public List getUsers() {
                        System.out.println("执行了 UserController.getUsers 方法");
                        return userService.getAll();
                    }
                }
                
                package com.example.demo.service;
                import com.example.demo.mapper.UserMapper;
                import com.example.demo.model.UserInfo;
                import org.springframework.beans.factory.annotation.Autowired;
                import org.springframework.stereotype.Service;
                import java.util.List;
                @Service
                public class UserService {
                    @Autowired
                    private UserMapper userMapper;
                    public List getAll(){
                        return userMapper.getAll();
                    }
                }
                
                package com.example.demo.mapper;
                import com.example.demo.model.UserInfo;
                import org.apache.ibatis.annotations.Mapper;
                import java.util.List;
                @Mapper // mybaits 接口,此注解一定不能忽略
                public interface UserMapper {
                    // 查询所有的信息
                    public List getAll();
                }
                
                
                
                
                    
                
                

                通过 http://localhost:8080/user/getall 访问,控制台:

                Spring AOP 详解,在这里插入图片描述,第8张

                (环绕通知在最外层~)

                3.3 Spring AOP 实现原理

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

                Spring AOP 支持 JDK Proxy 和 CGLIB 方式实现动态代理。

                • 默认情况下,实现了接口的类,使用 AOP 会基于 JDK ⽣成代理类;
                • 没有实现接⼝的类,会基于 CGLIB ⽣成代理类。

                  Spring AOP 详解,在这里插入图片描述,第9张

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

                  织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程,切⾯在指定的连接点被织⼊到⽬标对象中。

                  在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊:

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

                    动态代理

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

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

                    • CGLIB是Java中的动态代理框架,主要作⽤就是根据⽬标类和⽅法,动态⽣成代理类。
                    • Java中的动态代理框架,⼏乎都是依赖字节码框架(如 ASM,Javassist 等)实现的。
                    • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息,修改部

                      分信息,或动态⽣成⼀个 class。

                      JDK 动态代理实现

                      JDK 实现时,先通过实现 InvocationHandler 接⼝创建⽅法调⽤处理器,再通过 Proxy 来创建代理类。

                      以下为代码实现:

                      import org.example.demo.service.AliPayService;
                      import org.example.demo.service.PayService;
                      import java.lang.reflect.InvocationHandler;
                      import java.lang.reflect.Method;
                      import java.lang.reflect.Proxy;
                      //动态代理:使⽤JDK提供的api(InvocationHandler、Proxy实现),此种⽅式实现,要求被
                      代理类必须实现接⼝
                      public class PayServiceJDKInvocationHandler implements InvocationHandler {
                          //⽬标对象即就是被代理对象
                          private Object target;
                          public PayServiceJDKInvocationHandler( 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) {
                              PayService target= new AliPayService();
                              //⽅法调⽤处理器
                              InvocationHandler handler =
                                      new PayServiceJDKInvocationHandler(target);
                              //创建⼀个代理类:通过被代理类、被代理实现的接⼝、⽅法调⽤处理器来创建
                              PayService proxy = (PayService) Proxy.newProxyInstance(
                                      target.getClass().getClassLoader(),
                                      new Class[]{PayService.class},
                                      handler
                              );
                              proxy.pay();
                          }
                      }
                      

                      CGLIB 动态代理实现

                      CGLIB 实现时,先通过实现 MethodInterceptor 接⼝创建⽅法调⽤处理器,再通过 Enhancer 来创建代理类。

                      import org.springframework.cglib.proxy.Enhancer;
                      import org.springframework.cglib.proxy.MethodInterceptor;
                      import org.springframework.cglib.proxy.MethodProxy;
                      import org.example.demo.service.AliPayService;
                      import org.example.demo.service.PayService;
                      import java.lang.reflect.Method;
                      public class PayServiceCGLIBInterceptor implements MethodInterceptor {
                          //被代理对象
                          private Object target;
                          public PayServiceCGLIBInterceptor(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) {
                              PayService target= new AliPayService();
                              PayService proxy= (PayService) Enhancer.create(target.getClass(),new PayServiceCGLIBInterceptor(target));
                              proxy.pay();
                          }
                      }
                      

                      JDK 和 CGLIB 实现的区别

                      1. JDK 实现,要求被代理类必须实现接⼝,之后是通过 InvocationHandler 及 Proxy,在运⾏时动态的在内存中⽣成了代理类对象,该代理对象是通过实现同样的接⼝实现(类似静态代理接⼝实现的⽅式),只是该代理类是在运⾏期时,动态的织⼊统⼀的业务逻辑字节码来完成。
                      2. CGLIB 实现,被代理类可以不实现接⼝,是通过继承被代理类,在运⾏时动态的⽣成代理类对象 (三方框架,一般性能有优势)。

                      四、总结

                      AOP 是对某⽅⾯能⼒的统⼀实现,它是⼀种实现思想,Spring AOP 是对 AOP 的具体实现,Spring AOP 可通过 AspectJ (注解) 的方式来实现 AOP 的功能,Spring AOP 的实现步骤是:

                      1. 添加 AOP 框架⽀持。
                      2. 定义切⾯和切点。
                      3. 定义通知。

                      Spring AOP 是通过动态代理的⽅式,在运⾏期将 AOP 代码织⼊到程序中的,它的实现⽅式有两种:JDK Proxy 和 CGLIB。