AOP（Aspect-Oriented Programming，面向切面编程）_aop拦截对象字段上的注解-优快云博客

本文链接：https://blog.youkuaiyun.com/YiHanXii/article/details/144829907

AOP（Aspect-Oriented Programming，面向切面编程）

AOP 是一种编程范式，它通过横切关注点（cross-cutting concerns）的概念，增强了传统的面向对象编程（OOP）的能力。AOP 的主要目的是将横切关注点从业务逻辑中抽离出来，达到模块化和代码解耦的效果。

在 Spring 框架中，AOP 是核心功能之一，广泛应用于日志记录、事务管理、权限校验等场景。

核心概念

1. 横切关注点（Cross-Cutting Concerns）

横切关注点是指那些与具体业务逻辑无关，但又需要在多个模块或组件中反复使用的功能。

示例：日志记录、性能监控、权限校验、事务管理。

这些功能与业务逻辑无关，却需要在业务逻辑代码中多次出现，因此会导致代码的重复和耦合。

2. 切面（Aspect）

切面是横切关注点的具体实现，封装了横切逻辑。

切面包含了 “横切逻辑” 和 “在什么地方应用横切逻辑” 的定义。
在 Spring 中，切面是一个带有 @Aspect 注解的类。

3. 通知（Advice）

通知是切面中定义的具体动作，即要在目标方法执行的某个阶段执行的逻辑。通知可以分为以下几种类型：

前置通知（Before Advice）：在目标方法执行之前执行。
后置通知（After Advice）：在目标方法执行之后执行，无论是否抛出异常。
返回通知（AfterReturning Advice）：在目标方法成功返回后执行。
异常通知（AfterThrowing Advice）：在目标方法抛出异常后执行。
环绕通知（Around Advice）：包裹目标方法的执行，可以在目标方法执行前后加入逻辑。

4. 切入点（Pointcut）

切入点定义了哪些方法、类或包需要被切面逻辑拦截。它决定了横切逻辑的作用范围。

切入点通常通过表达式（Pointcut Expressions）来指定。

5. 连接点（Join Point）

连接点是程序执行过程中的某个特定点。例如，方法调用、异常抛出等。AOP 可以在这些点上插入切面逻辑。

6. 目标对象（Target Object）

目标对象是被 AOP 代理的对象。切面逻辑会应用到目标对象的方法上。

7. AOP 代理（AOP Proxy）

AOP 代理是 Spring AOP 用来实现切面的底层机制。

Spring AOP 使用 JDK 动态代理 或 CGLIB 来创建代理对象。
代理对象是目标对象的包装，拦截目标方法的调用并执行切面逻辑。

AOP 的工作原理

Spring AOP 的核心实现依赖于动态代理技术：

JDK 动态代理：
- 使用 Java 内置的 Proxy 类。
- 只能代理实现了接口的类。
CGLIB 动态代理：
- 使用字节码生成技术，生成目标类的子类作为代理。
- 可以代理没有实现接口的类。

Spring 会根据目标类是否实现接口自动选择代理方式：

如果目标类实现了接口，默认使用 JDK 动态代理。
如果目标类没有实现接口，则使用 CGLIB 动态代理。

AOP 的实现方式

在 Spring 中，AOP 的实现主要有两种方式：

1. 基于注解的 AOP

使用注解是 Spring AOP 的主流实现方式。

依赖配置：
添加 AOP 依赖。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

定义切面类：
使用 @Aspect 注解定义切面类，并用通知和切入点来描述切面逻辑。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("执行方法前：记录日志");
    }

    @After("execution(* com.example.service.*.*(..))")
    public void logAfter() {
        System.out.println("执行方法后：记录日志");
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "result")
    public void logAfterReturning(Object result) {
        System.out.println("方法返回结果：" + result);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
    public void logAfterThrowing(Exception ex) {
        System.out.println("方法抛出异常：" + ex.getMessage());
    }

    @Around("execution(* com.example.service.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法执行前");
        Object result = joinPoint.proceed(); // 执行目标方法
        System.out.println("方法执行后");
        return result;
    }
}

切入点表达式示例：
- 拦截指定包中的所有方法：
```
execution(* com.example.service.*.*(..))
```
- 拦截返回值为 void 的方法：
```
execution(void com.example..*(..))
```
- 拦截特定注解标记的方法：
```
@annotation(com.example.annotation.MyAnnotation)
```

2. 基于 XML 的 AOP

虽然注解方式更常用，但 Spring 也支持基于 XML 的配置方式。

<aop:aspectj-autoproxy/>
<aop:config>
    <aop:aspect ref="loggingAspect">
        <aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/>
        <aop:before method="logBefore" pointcut-ref="serviceMethods"/>
    </aop:aspect>
</aop:config>