Spring AOP面向切面编程

1 面向切面编程思维（AOP）

AOP思想主要的应用场景

AOP（面向切面编程）是一种编程范式，它通过将通用的横切关注点（如日志、事务、权限控制等）与业务逻辑分离，使得代码更加清晰、简洁、易于维护。AOP可以应用于各种场景，以下是一些常见的AOP应用场景：

1. 日志记录：在系统中记录日志是非常重要的，可以使用AOP来实现日志记录的功能，可以在方法执行前、执行后或异常抛出时记录日志。
2. 事务处理：在数据库操作中使用事务可以保证数据的一致性，可以使用AOP来实现事务处理的功能，可以在方法开始前开启事务，在方法执行完毕后提交或回滚事务。
3. 安全控制：在系统中包含某些需要安全控制的操作，如登录、修改密码、授权等，可以使用AOP来实现安全控制的功能。可以在方法执行前进行权限判断，如果用户没有权限，则抛出异常或转向到错误页面，以防止未经授权的访问。
4. 性能监控：在系统运行过程中，有时需要对某些方法的性能进行监控，以找到系统的瓶颈并进行优化。可以使用AOP来实现性能监控的功能，可以在方法执行前记录时间戳，在方法执行完毕后计算方法执行时间并输出到日志中。
5. 异常处理：系统中可能出现各种异常情况，如空指针异常、数据库连接异常等，可以使用AOP来实现异常处理的功能，在方法执行过程中，如果出现异常，则进行异常处理（如记录日志、发送邮件等）。
6. 缓存控制：在系统中有些数据可以缓存起来以提高访问速度，可以使用AOP来实现缓存控制的功能，可以在方法执行前查询缓存中是否有数据，如果有则返回，否则执行方法并将方法返回值存入缓存中。
7. 动态代理：AOP的实现方式之一是通过动态代理，可以代理某个类的所有方法，用于实现各种功能。
   综上所述，AOP可以应用于各种场景，它的作用是将通用的横切关注点与业务逻辑分离，使得代码更加清晰、简洁、易于维护。

2 Spring AOP框架介绍和关系梳理

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

3 SpringAOP基于注解方式实现和细节

3.1 Spring AOP底层技术组成

3.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 声明切面类

package com.atguigu.advice;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.atguigu.proxy.CalculatorPureImpl.add(int,int))")public void printLogBeforeCore() {System.out.println("[AOP前置通知] 方法开始了");}@AfterReturning(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")public void printLogAfterSuccess() {System.out.println("[AOP返回通知] 方法成功返回了");}@AfterThrowing(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")public void printLogAfterException() {System.out.println("[AOP异常通知] 方法抛异常了");}@After(value = "execution(public int com.atguigu.proxy.CalculatorPureImpl.add(int,int))")public void printLogFinallyEnd() {System.out.println("[AOP后置通知] 方法最终结束了");}}

3 配置类方式

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

3.3 获取通知细节信息

/*** 1.   定义方法 - 增强代码* 2.   使用注解指定对应的位置* 3.   配置切点表达式选中方法* 4.   切面和ioc的配置* 5.   开启aspectj注解的支持** TODO:增强方法中获取目标方法信息*  1. 全部增强方法中，获取目标方法的信息（方法名，参数，访问修饰符，所属类的信息）*      (JoinPoint joinPoint)*      joinPoint包含目标方法的信息  import org.aspectj.lang.JoinPoint;*  2. 返回的结果 - 只在@AfterReturning中有效*      (Object 形参名) 形参名接收返回结果*      @AfterReturning(value = "execution(* com..impl.*.*(..))",returning = "形参名即可")*  3. 获取异常信息 - @AfterThrowing*      (Throwable 形参名) 形参名接收异常信息*      @AfterThrowing(value = "execution(* com..impl.*.*(..))",throwing = "形参名即可")*/

JointPoint接口

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

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

// @Before注解标记前置通知方法
// value属性：切入点表达式，告诉Spring当前通知方法要套用到哪个目标方法上
// 在前置通知方法形参位置声明一个JoinPoint类型的参数，Spring就会将这个对象传入
// 根据JoinPoint对象就可以获取目标方法名称、实际参数列表
@Before(value = "execution(public int com.atguigu.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);//获取方法所属类的信息String simpleName = joinPoint.getTarget().getClass().getSimpleName();//获取访问修饰符int modifiers = signature.getModifiers();System.out.println("modifiers = " + modifiers);//获取方法名String name = joinPoint.getSignature().getName();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);
}

方法返回值

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

// @AfterReturning注解标记返回通知方法
// 在返回通知中获取目标方法返回值分两步：
// 第一步：在@AfterReturning注解中通过retur ning属性设置一个名称
// 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
@AfterReturning(value = "execution(public int com.atguigu.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);
}

异常对象捕捉

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

// @AfterThrowing注解标记异常通知方法
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们
@AfterThrowing(value = "execution(public int com.atguigu.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());
}

3.4 切点表达式

/*** TODO:切点表达式*  固定语法 execution(1 2 3.4.5(6))*  1. 访问修饰符*      public / private*  2. 方法的返回参数类型*      String int void*     如果不考虑访问修饰符和返回值 那么这两位整合成一起写 **     如果要是不考虑 必须两个都不考虑 不能出现 * String*  3. 包的位置*      具体包：com.atguigu.service.impl*      单层模糊：com.atguigu.service.*  *单层模糊*      多层模糊：com..impl  ..是任意层的模糊*      细节：..不能开头*      例如 找所有impl包：com..impl  不能写..impl  写成:*..impl*   4. 类的名称*      具体：CalculatorPureImpl*      模糊：**      部分模糊：*Impl 即以Impl结尾的类名*   5. 方法名 语法和类名一致*   6. (6)型参数列表*      没有参数:()*      有具体参数：(String) (String,int)有顺序要求*      模糊参数：(..)有没有参数都可以 有多个也可以*      部分模糊：(String..) String后面有没有无所谓*              (..int)     最后一个参数是int*              (String..int) 第一个是String 最后一个是int*   TODO:实战*      1.查询某包某类下，访问修饰符是公有，返回值是int的全部方法*          public int 包名.类名.*(..)*      2.查询某包下类中第一个参数是String的方法*          * 包名.*.*(String..)*      3.查询全部包下，无参数的方法！*          * *..*.*()*      4.查询com包下，以int参数类型结尾的方法*          * com..*.*(..int)*      5.查询指定包下，Service开头类的私有返回值int的无参数方法*          private int 包名.Service*.*()*/

3.5 重用（提取）切点表达式

/*** TODO:切点表达式的提取和复用*      1. 当前类中提取*         定义一个空方法*         注解 @Pointcut()*         增强注解中引用切点表达式的方法即可    直接调用方法名*      2. 创建一个存储切点的类*          单独维护切点表达式*          其它类的切点方法 类的全限定符号 方法名()*/@Pointcut("execution(* com.atguigu.service.impl.*.*(..))")
public void pc(){}//别的类中的切点表达式引用：包+类名+函数名 比如"com.atguigu.pointcut.MyPointCut.pc()"
@Before("pc()")
public void start(){System.out.println("方法开始了");
}@After("pc()")
public void after(){System.out.println("方法结束了");
}@AfterThrowing("pc()")
public void error(){System.out.println("方法报错了");
}

3.6 环绕通知

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

   /*** 环绕通知 需要在通知中 定义目标方法的执行* @param joinPoint 目标方法（获取目标方法信息 多了一个执行方法）* @return  目标方法的返回值*/
// 使用@Around注解标明环绕通知方法
@Around(value = "com.atguigu.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;
}

3.7 切面优先级设置

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

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

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

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

5 Spring AOP 对获取Bean的影响理解