AOP（面向切面编程）

---

前言

AOP是什么？AOP框架是什么？

---

一、问题

问题分析
附加功能代码重复，分散在各个业务功能方法中！冗余，且不方便统一维护！
解决思路
解耦。 将重复的代码统一提取，并且动态插入到每个业务方法。
代理模式
通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。

二、AOP思维

1、AOP和OOP的区别

2、相关术语名词

三、Spring AOP框架

1、概念

基于AOP编程思维，封装动态代理技术，简化动态代理技术实现的框架！SpringAOP内部帮助我们实现动态代理，我们只需写少量的配置，指定生效范围即可完成面向切面思维编程的实现！

2、底层技术组成

JDK动态代理：JDK原生的实现方式，需要被代理的目标类必须实现接口
cglib：通过继承被代理的目标类实现代理，所以不需要目标类实现接口！
AspectJ：早期的AOP实现的框架，SpringAOP借用了AspectJ中的AOP注解。

3、实现步骤

（1）导入依赖pom.xml

<!-- 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);      
}
package com.atguigu.proxy;
//实现类
@Component
public class CalculatorPureImpl implements Calculator {    
    @Override
    public int add(int i, int j) {    
        int result = i + j;    
        return result;
    }
}

（3）声明切面类

@Aspect  // @Aspect表示这个类是一个切面类
@Component  // @Component注解保证这个切面类能够放入IOC容器
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后置通知] 方法最终结束了");
    } 
}

（4）开启aspectj注解支持

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

4、获取通知细节

（1）JoinPoint接口
需要获取方法签名、传入的实参等信息时，可以在通知方法声明JoinPoint类型的形参。
（2）方法返回值
通过@AfterReturning注解的returning属性获取目标方法的返回值！
（3）异常对象捕捉
在异常通知中，通过@AfterThrowing注解的throwing属性获取目标方法抛出的异常对象

// @AfterThrowing注解标记异常通知方法
@AfterThrowing(
        value = "execution(public int com.atguigu.aop.api.Calculator.add(int,int))",
// 在返回通知中获取目标方法返回值分两步：
// 第一步：在@AfterReturning注解中通过returning属性设置一个名称
// 第二步：使用returning属性设置的名称在通知方法中声明一个对应的形参
        returning = "targetMethodReturnValue",
// 在异常通知中获取目标方法抛出的异常分两步：
// 第一步：在@AfterThrowing注解中声明一个throwing属性设定形参名称
// 第二步：使用throwing属性指定的名称在通知方法声明形参，Spring会将目标方法抛出的异常对象从这里传给我们 
        throwing = "targetMethodException"
)
public void printLogAfterCoreException(JoinPoint joinPoint, Throwable targetMethodException) {
   // 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+"方法抛异常了，异常类型是：" + targetMethodException.getClass().getName());
}

5、重用切点表达式(@Pointcut)

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

//同类引用
@Before(value = "declarPointCut()")
//不同类引用
@Before(value = "com.atguigu.spring.aop.aspect.LogAspect.declarPointCut()")
public void printLogBeforeCoreOperation(JoinPoint joinPoint) {}

6、环绕通知

环绕通知对应整个 try…catch…finally 结构
// 使用@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;
}

---