当前位置：首页 > news >正文

SpringFramework-AOP

news 2026/7/10 17:43:30

非核心业务功能对对核心业务功能有干扰，且附加功能代码重复，分散在各个业务功能方法中，冗余，且不方便统一维护

解耦。我们需要把附加功能从业务功能代码中抽取出来。将重复的代码统一提取，并且[动态插入]到每个业务方法

代理模式

通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

无代理场景：

有代理场景：

静态代理：主动创建代理类，为每一个目标方法都创建代理方法，静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。

public class CalculatorStaticProxy implements Calculator { // 将被代理的目标对象声明为成员变量 private Calculator target; public CalculatorStaticProxy(Calculator target) { this.target = target; } @Override public int add(int i, int j) { // 附加功能由代理类中的代理方法来实现 System.out.println("参数是：" + i + "," + j); // 通过目标对象来实现核心业务逻辑 int addResult = target.add(i, j); System.out.println("方法内部 result = " + result); return addResult; }

动态代理：

JDK动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口，他会根据目标类的接口动态生成一个代理对象！代理对象和目标对象有相同的接口！（拜把子）

cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！（认干爹） JDK动态代理技术实现（了解）

public class ProxyFactory { private Object target; public ProxyFactory(Object target) { this.target = target; } public Object getProxy(){ /** * newProxyInstance()：创建一个代理实例 * 其中有三个参数： * 1、classLoader：加载动态生成的代理类的类加载器 * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组 * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法 */ ClassLoader classLoader = target.getClass().getClassLoader(); Class<?>[] interfaces = target.getClass().getInterfaces(); InvocationHandler invocationHandler = new InvocationHandler() { /** * invoke 调用代理的方法都会执行此此方法! 非核心业务 + 目标调用就行了 * proxy : 代理对象 * method: 目标的方法 * args: 执行方法的参数 * */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { /** * proxy：代理对象 * method：代理对象需要实现的方法，即其中需要重写的方法 * args：method所对应方法的参数 */ Object result = null; try { System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args)); //调用目标方法进行核心业务 result = method.invoke(target, args); System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result); } catch (Exception e) { e.printStackTrace(); System.out.println("[动态代理][日志] "+method.getName()+"，异常："+e.getMessage()); } finally { System.out.println("[动态代理][日志] "+method.getName()+"，方法执行完毕"); } return result; } }; /** * jdk生成代理对象 * 参数1: 类加载器 * 参数2: 目标类的接口们 * 参数3: 具体要进行的代理动作 [非核心动作 - 调用目标方法] */ return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler); } }

代理方式可以解决附加功能代码干扰核心代码和不方便统一维护的问题！

他主要是将附加功能代码提取到代理中执行，不干扰目标核心代码！

面向切面编程思维（AOP）

面向切面编程思想AOP

AOP：Aspect Oriented Programming面向切面编程

AOP可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP允许开发者定义纵向的关系，但并不适合定义横向的关系，例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切（cross cutting），在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

AOP技术，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。

AOP术语名词介绍

横切关注点：

从每个方法中抽取出来的同一类非核心业务，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。

通知(增强)：

每一个横切关注点上要做的事情都需要写一个方法来实现[横切关注点代码]

前置通知：在被代理的目标方法前执行
返回通知：在被代理的目标方法成功结束后执行（寿终正寝）
异常通知：在被代理的目标方法异常结束后执行（死于非命）
后置通知：在被代理的目标方法最终结束后执行（盖棺定论）
环绕通知：使用try...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的所有位置

连接点 joinpoint：

在 Spring 中，可以被动态代理拦截目标类的目标方法

切入点 pointcut：

被选中的连接点，符合条件的每个具体的方法都是一个具体的连接点。

切面 aspect：

切入点[具体的方法]和通知[非核心功能]的结合

目标 target

被代理的目标对象。

代理 proxy

向目标对象应用通知[非核心功能]之后创建的代理对象。

织入 weave

指把通知[非核心功能]应用到目标上，生成代理对象的过程。可以在编译期织入，也可以在运行期织入，Spring采用后者。

Spring AOP框架介绍和关系梳理

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

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

获取通知细节信息

JointPoint接口

全部增强方法中,获取目标方法的信息(方法名,参数,访问修饰符,所属的类的信息...)
(JoinPoint jointPoint) import org.aspectj.lang.JoinPoint;
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); 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); }

方法返回值[@AfterReturning]

第一步：在@AfterReturning注解中通过returning属性设置一个名称
第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参

// @AfterReturning注解标记返回通知方法 // 在返回通知中获取目标方法返回值分两步： // 第一步：在@AfterReturning注解中通过returning属性设置一个名称 // 第二步：使用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 ]

第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们

// @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()); }

切点表达式语法

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

切点表达式语法

固定语法 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 5. 方法名，语法和类名一致 6. 形参数列表 没有参数: () 有具体参数: (String) (String,int) 模糊参数: (..) 有没有参数都可以，有多个也可以 不分模糊: (String..) String 后面有没有无所谓 (..int) 最后一个参数是int (String..int)

重用（提取）切点表达式

同一类内部引用

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

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

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

不同类中引用

添加类的全限定符+方法名

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

切点统一管理

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

@Component public class AtguiguPointCut { @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(){} }

环绕通知

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

joinPoint 目标方法 (获取目标方法信息,多了一个执行方法)

// 使用@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; }