SpringFramework-02_Spring AOP

1. Spring AOP框架介绍

1. AOP一种区别于OOP的编程思维，用来完善和解决OOP的非核心代码冗余和不方便统一维护问题
2. 代理技术（动态代理|静态代理）是实现AOP思维编程的具体技术，但是自己使用动态代理实现代码比较繁琐
3. Spring AOP框架，基于AOP编程思维，封装动态代理技术，简化动态代理技术实现的框架。SpringAOP内部帮助我们实现动态代理，只需写少量的配置，指定生效范围即可,即可完成面向切面思维编程的实现

2. Spring AOP基于注解方式实现和细节

2.1 Spring AOP底层技术组成

• 动态代理（InvocationHandler）：JDK原生的实现方式，需要被代理的目标类必须实现接口。因为这个技术要求代理对象和目标对象实现同样的接口。
• cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口。
• AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。

2.2 代码实现

1. 加入依赖

   <!-- spring-aspects会帮我们传递过来aspectjweaver -->
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aop</artifactId>
       <version>6.0.6</version>
   </dependency>
   
   <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-aspects</artifactId>
       <version>6.0.6</version>
   </dependency>
   

2. 准备接口

   public interface Calculator {
       
       int add(int i, int j);
       
       int sub(int i, int j);
       
       int mul(int i, int j);
       
       int div(int i, int j);
       
   }
   

3. 实现类

   @Component
   public class CalculatorPureImpl implements Calculator {
       
       @Override
       public int add(int i, int j) {
       
           int result = i + j;
       
           return result;
       }
       
       @Override
       public int sub(int i, int j) {
       
           int result = i - j;
       
           return result;
       }
       
       @Override
       public int mul(int i, int j) {
       
           int result = i * j;
       
           return result;
       }
       
       @Override
       public int div(int i, int j) {
       
           int result = i / j;
       
           return result;
       }
   }
   

4. 声明切面类

   import org.aspectj.lang.annotation.*;
   import org.springframework.stereotype.Component;
   
   // @Aspect表示这个类是一个切面类
   @Aspect
   // @Component注解保证这个切面类能够放入IOC容器
   @Component
   public class LogAspect {
           
       // @Before注解：声明当前方法是前置通知方法
       // value属性：指定切入点表达式，由切入点表达式控制当前通知方法要作用在哪一个目标方法上
       @Before(value = "execution(public int com.start.proxy.CalculatorPureImpl.add(int,int))")
       public void printLogBeforeCore() {
           System.out.println("[AOP前置通知] 方法开始了");
       }
       
       @AfterReturning(value = "execution(public int com.start.proxy.CalculatorPureImpl.add(int,int))")
       public void printLogAfterSuccess() {
           System.out.println("[AOP返回通知] 方法成功返回了");
       }
       
       @AfterThrowing(value = "execution(public int com.start.proxy.CalculatorPureImpl.add(int,int))")
       public void printLogAfterException() {
           System.out.println("[AOP异常通知] 方法抛异常了");
       }
       
       @After(value = "execution(public int com.start.proxy.CalculatorPureImpl.add(int,int))")
       public void printLogFinallyEnd() {
           System.out.println("[AOP后置通知] 方法最终结束了");
       }
       
   }
   

5. 开启aspectj注解支持

   • xml方式

     <?xml version="1.0" encoding="UTF-8"?>
     <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:context="http://www.springframework.org/schema/context"
            xmlns:aop="http://www.springframework.org/schema/aop"
            xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd">
     
         <!-- 进行包扫描-->
         <context:component-scan base-package="com.start" />
         <!-- 开启aspectj框架注解支持-->
         <aop:aspectj-autoproxy />
     </beans>
     

   • 配置类方式

     @Configuration
     @ComponentScan(basePackages = "com.start")
     //作用等于 <aop:aspectj-autoproxy /> 配置类上开启 Aspectj注解支持!
     @EnableAspectJAutoProxy
     public class MyConfig {
     }
     
     

2.3 获取通知细节信息

1. JointPoint接口

   需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。

   • 要点1：JoinPoint 接口通过 getSignature() 方法获取目标方法的签名（方法声明时的完整信息）
   • 要点2：通过目标方法签名对象获取方法名
   • 要点3：通过 JoinPoint 对象获取外界调用目标方法时传入的实参列表组成的数组

   // @Before注解标记前置通知方法
   // value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
   // 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
   // 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
   @Before(value = "execution(public int com.start.aop.api.Calculator.add(int,int))")
   public void printLogBeforeCore(JoinPoint joinPoint) {
       
       // 1.通过JoinPoint对象获取目标方法签名对象
       // 方法的签名：一个方法的全部声明信息
       Signature signature = joinPoint.getSignature();
       
       // 2.通过方法的签名对象获取目标方法的详细信息
       String methodName = signature.getName();
       System.out.println("methodName = " + methodName);
       
       int modifiers = signature.getModifiers();
       System.out.println("modifiers = " + modifiers);
       
       String declaringTypeName = signature.getDeclaringTypeName();
       System.out.println("declaringTypeName = " + declaringTypeName);
       
       // 3.通过JoinPoint对象获取外界调用目标方法时传入的实参列表
       Object[] args = joinPoint.getArgs();
       
       // 4.由于数组直接打印看不到具体数据，所以转换为List集合
       List<Object> argList = Arrays.asList(args);
       
       System.out.println("[AOP前置通知] " + methodName + "方法开始了，参数列表：" + argList);
   }
   

2. 方法返回值

   在返回通知中，通过 @AfterReturning注解的returning属性获取目标方法的返回值

   // @AfterReturning注解标记返回通知方法
   // 在返回通知中获取目标方法返回值分两步：
   // 第一步：在@AfterReturning注解中通过returning属性设置一个名称
   // 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
   @AfterReturning(
           value = "execution(public int com.start.aop.api.Calculator.add(int,int))",
           returning = "targetMethodReturnValue"
   )
   public void printLogAfterCoreSuccess(JoinPoint joinPoint, Object targetMethodReturnValue) {
       
       String methodName = joinPoint.getSignature().getName();
       
       System.out.println("[AOP返回通知] "+methodName+"方法成功结束了，返回值是：" + targetMethodReturnValue);
   }
   

3. 异常对象捕捉

   在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

   // @AfterThrowing注解标记异常通知方法
   // 在异常通知中获取目标方法抛出的异常分两步：
   // 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
   // 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
   @AfterThrowing(
           value = "execution(public int com.start.aop.api.Calculator.add(int,int))",
           throwing = "targetMethodException"
   )
   public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
       
       String methodName = joinPoint.getSignature().getName();
       
       System.out.println("[AOP异常通知] "+methodName+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
   }
   

2.4 切点表达式语法

1. 切点表达式作用
   AOP切点表达式（Pointcut Expression）是一种用于指定切点的语言，它可以通过定义匹配规则，来选择需被切入的目标对象。

2. 切点表达式语法
   

3. 语法细节

   • 第一位：execution( ) 固定开头

   • 第二位：方法访问修饰符

     public private 直接描述对应修饰符即可
     

   • 第三位：方法返回值

     int String void 直接描述返回值类型
     

     注意：

     特殊情况 不考虑 访问修饰符和返回值

     execution(* * ) 错误语法

     execution( *) 正确语法

   • 第四位：指定包的地址

      固定的包: com.start.api | service | dao
      单层的任意命名: com.start.*  = com.start.api  com.start.dao  * = 任意一层的任意命名
      任意层任意命名: com.. = com.start.api.erdaye com.a.a.a.a.a.a.a  ..任意层,任意命名 用在包上
      注意: ..不能用作包开头   public int .. 错误语法  com..
      找到任何包下: *..
     

   • 第五位：指定类名称

     固定名称: UserService
     任意类名: *
     部分任意: com..service.impl.*Impl
     任意包任意类: *..*
     

   • 第六位：指定方法名称

     语法和类名一致
     任意访问修饰符,任意类的任意方法: * *..*.*
     

   • 第七位：方法参数

     第七位: 方法的参数描述
            具体值: (String,int) != (int,String) 没有参数 ()
            模糊值: 任意参数 有 或者 没有 (..)  ..任意参数的意识
            部分具体和模糊:
              第一个参数是字符串的方法 (String..)
              最后一个参数是字符串 (..String)
              字符串开头,int结尾 (String..int)
              包含int类型(..int..)
     

2.5 （提取）切点表达式

1. 同一类内部引用

   提取

   // 切入点表达式重用
   @Pointcut("execution(public int com.start.aop.api.Calculator.add(int,int)))")
   public void declarPointCut() {}
   

   注意：提取切点注解使用@Pointcut(切点表达式) ， 需要添加到一个无参数无返回值方法上

   引用

   @Before(value = "declarPointCut()")
   public void printLogBeforeCoreOperation(JoinPoint joinPoint) {
   

2. 不同类中引用

   不同类在引用切点，只需要添加类的全限定符+方法名

   @Before(value = "com.start.spring.aop.aspect.LogAspect.declarPointCut()")
   public Object roundAdvice(ProceedingJoinPoint joinPoint) {
   

3. 切点统一管理

   建议：将切点表达式统一存储到一个类中进行集中管理和维护

   @Component
   public class AllPointCut {
       
       @Pointcut(value = "execution(public int *..Calculator.sub(int,int))")
       public void atguiguGlobalPointCut(){}
       
       @Pointcut(value = "execution(public int *..Calculator.add(int,int))")
       public void atguiguSecondPointCut(){}
       
       @Pointcut(value = "execution(* *..*Service.*(..))")
       public void transactionPointCut(){}
   }
   

2.6 环绕通知

环绕通知对应整个 try…catch…finally 结构，包括前面四种通知的所有功能

// 使用@Around注解标明环绕通知方法
@Around(value = "com.start.aop.aspect.AtguiguPointCut.transactionPointCut()")
public Object manageTransaction(
    
        // 通过在通知方法形参位置声明ProceedingJoinPoint类型的形参，
        // Spring会将这个类型的对象传给我们
        ProceedingJoinPoint joinPoint) {
    
    // 通过ProceedingJoinPoint对象获取外界调用目标方法时传入的实参数组
    Object[] args = joinPoint.getArgs();
    
    // 通过ProceedingJoinPoint对象获取目标方法的签名对象
    Signature signature = joinPoint.getSignature();
    
    // 通过签名对象获取目标方法的方法名
    String methodName = signature.getName();
    
    // 声明变量用来存储目标方法的返回值
    Object targetMethodReturnValue = null;
    
    try {
    
        // 在目标方法执行前：开启事务（模拟）
        log.debug("[AOP 环绕通知] 开启事务，方法名：" + methodName + "，参数列表：" + Arrays.asList(args));
    
        // 过ProceedingJoinPoint对象调用目标方法
        // 目标方法的返回值一定要返回给外界调用者
        targetMethodReturnValue = joinPoint.proceed(args);
    
        // 在目标方法成功返回后：提交事务（模拟）
        log.debug("[AOP 环绕通知] 提交事务，方法名：" + methodName + "，方法返回值：" + targetMethodReturnValue);
    
    }catch (Throwable e){
    
        // 在目标方法抛异常后：回滚事务（模拟）
        log.debug("[AOP 环绕通知] 回滚事务，方法名：" + methodName + "，异常：" + e.getClass().getName());
    
    }finally {
    
        // 在目标方法最终结束后：释放数据库连接
        log.debug("[AOP 环绕通知] 释放数据库连接，方法名：" + methodName);
    
    }
    
    return targetMethodReturnValue;
}

2.6 切面优先级设置

相同目标方法上同时存在多个切面时，切面的优先级控制切面的内外嵌套顺序。

• 优先级高的切面：外面
• 优先级低的切面：里面

使用 @Order 注解可以控制切面的优先级：

• @Order(较小的数)：优先级高
• @Order(较大的数)：优先级低

3. Spring AOP对获取Bean的影响

对实现了接口的类应用切面

对没实现接口的类应用切面new

如果使用AOP技术，目标类有接口，必须使用接口类型接收IoC容器中代理组件