从新手到高手：Spring AOP的进阶指南

一、AOP简介

1.1 AOP入门案例

1.2 AOP 优点

二、核心概念

2.1 切面(Aspect)

2.2 切点(PointCut)

2.3 通知(Advice)

2.4 织入(Weaving)

三、AOP 原理

3.1 CGLIB 与 JDK动态代理对比

3.2 切面优先级

四、总结

一、AOP简介

AOP(Aspect-Oriented Programming) 面向切面编程，是一种编程范式，通过预编译和运行期间动态代理实现程序功能统一维护的一种技术。下面通过一个简单的案例来了解下AOP如何使用。

1.1 AOP入门案例

假如有这么一个需求，需要你来统计方法的执行时长，这也是性能检测的常用手段。如果不使用 AOP 的话，你大概率会这样做。

public void methodA() {long startTime = System.currentTimeMillis();// 业务代码 long endTime = System.currentTimeMillis();// 计算代码执行时长 endTime - startTime   
}

这样做当然没有错，但是如果有很多方法需要你去统计呢，每个方法内都需要有相同的代码，看起来很麻烦。AOP 出现后在很大程度上缓解了这种臃肿的代码，只需要一个注解就可以搞定。

首先需要添加依赖：

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

// 统计方法执行时长的注解
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface ExecutionTimeStatistic {}@Slf4j
@Aspect
@Component
public class ExecutionTimeAspect {@Pointcut("@annotation(com.***.ExecutionTimeStatistic)")public void pointCut() {}@Around("pointCut()")public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {Object obj = null;try {ExecutionTimeStatistic executionTime = getExecutionTime(joinPoint);if (Objects.isNull(executionTime)) {return joinPoint.proceed();}// 获取方法名String methodName = joinPoint.getSignature().getName();// 获取类名String className = joinPoint.getSignature().getDeclaringTypeName();StopWatch stopWatch = new StopWatch("methodName");stopWatch.start();obj = joinPoint.proceed();stopWatch.stop();log.info("执行方法耗时统计, 执行方法为:{}#{}, 耗时:{}", className, methodName, stopWatch.getTotalTimeMillis() + "ms");} catch (Throwable throwable) {log.warn("统计方法执行耗时异常", throwable);throw throwable;}return obj;}private static ExecutionTimeStatistic getExecutionTime(JoinPoint joinPoint) {Signature signature = joinPoint.getSignature();MethodSignature methodSignature = (MethodSignature) signature;Method method = methodSignature.getMethod();if (method != null) {return method.getAnnotation(ExecutionTimeStatistic.class);}return null;}}

如果需要统计某一个方法的执行时长，只需要在方法上加上 @ExecutionTimeStatistic 注解即可，是不是很简单呢？

通过这个案例就凸显出 AOP 的几个优点。

1.2 AOP 优点

为什么需要 AOP，它有什么优点呢？

减少代码重复：在传统 OOP 中，横切关注点(如日志记录、性能统计、安全控制等)通常会在多个类中重复出现。AOP 出现后可以将这些关注点模块化为切面，避免重复代码，提高代码可维护性。
提高模块化：AOP 将模块化的代码抽取出来，业务逻辑更加干净简介。
易于维护和扩展：修改一个横切关注点只需要再一个地方修改即可，简单便捷。如果有新功能的话，新扩展横切面就好，无需修改原有业务代码。
提高代码可读性：通过将横切关注点分离出来，主业务逻辑变得更加清晰，提高了代码的可读性。

总之，AOP通过提供一种新的方式来组织代码，使得程序结构更加清晰、易于维护，并且能够更好地适应变化。

二、核心概念

下面介绍下 AOP 的核心概念，通过对这些概念的理解有助于设计出更好的切面程序。

2.1 切面(Aspect)

切面是 AOP 中的关键概念，它代表了一个横切关注点的模块化实现。一个切面通常包含了多个通知(advice)，这些通知会在特定的连接点(join point)上执行。切面可以用来封装那些分散在整个应用程序中的公共行为，如日志记录、事务管理、权限检查等。如下图：

切面的定义如下：

// 切面定义
@Aspect
@Component
public class ExecutionTimeAspect {}

2.2 切点(PointCut)

切入点（Pointcut）定义了通知应该在哪些连接点上执行。它是通过一个表达式来定义的，该表达式指定了哪些连接点满足条件。切入点可以使用Spring AOP的表达式语言来定义。

切点定义如下：

@Pointcut("@annotation(com.***.ExecutionTimeStatistic)")
public void pointCut() {}

2.3 通知(Advice)

通知是在切面中的一个动作，它定义了在特定的连接点上要执行的行为，Spring AOP 支持多种类型的通知。

通知类型	描述
@Before	用于定义前置通知，相当于BeforeAdvice，在连接点之前执行的通知
@AfterReturning	用于定义后置通知，在连接点成功执行之后通知
@Around	用于定义环绕通知，在连接点之前和之后执行的通知，可以控制连接点是否执行
@AfterThrowing	用于定义异常通知来处理程序中未处理的异常，在连接点抛出异常之后执行的通知。程序正常执行时不会通知
@After	用于定义最终通知，无论连接点是否最终执行都会通知

总结来说，Spring AOP中注解的执行顺序是 @Before-> @Around（开始部分） -> 目标方法执行 -> @Around（结束部分） -> @AfterReturning（如果成功）或 @AfterThrowing（如果异常） -> @After。

2.4 织入(Weaving)

织入指的是将切面(Aspect)和通知(Advice)插入到应用程序的目标对象的方法执行的流程中。简单来说，就是将切面中的横切关注点与应用程序的主要业务逻辑进行整合。

织入可以再不同的时机发生，主要有三种类型：

编译时织入：在编译阶段，AOP 代理会直接修改源代码或字节码，将切面的代码织入到目标类方法中。这种方式的优点是在编译期就完成了织入，避免了运行时的额外开销，但是需要专门的工具来支持。
加载时织入：在类加载到 JVM 时织入，使用 Agent 技术可以再类加载时修改字节码。
运行时织入：在应用程序运行时动态的创建代理对象，并将切面织入到代理对象中，Spring 就是采用的这种方式，缺点是在运行期会有一定的开销。

下面来看下 Spring AOP 的实现原理。

三、AOP 原理

上面讲了织入的方式，Spring AOP 默认的织入方式是运行时织入的，那它是如何实现的呢？

AOP 的原理是基于动态代理技术实现的，Spring AOP 默认使用动态代理来实现切面（Aspect）中的通知（Advice）在目标对象的方法调用前后插入的功能。

动态代理是运行时动态创建代理对象的一种技术，Spring 支持两种动态代理技术。

JDK 动态代理：当目标对象实现了至少一个接口时，Spring 使用 JDK 动态代理技术来创建代理对象。JDK 动态代理是通过 java.lang.reflect.Proxy 类和 InvocationHandler 接口实现的。

CGLIB 动态代理：当目标对象没有实现任何接口时，Spring 使用 CGLIB(Code Generation Library)来创建代理，CGLIB 是一个代码生成库，它可以动态生成类的子类。

Spring AOP 会根据目标对象是否实现了接口来决定使用哪种类型的代理：如果目标对象实现了接口，则使用 JDK 动态代理；如果目标对象没有实现接口，则使用 CGLIB 代理。

不过在编程中可以指定使用哪种代理方式，在 SpringBoot 启动类上添加 @EnableAspectJAutoProxy 注解并设置 proxyTargetClass 属性来控制代理类型：

@EnableAspectJAutoProxy(proxyTargetClass = true) // 强制使用 CGLIB 代理

3.1 CGLIB 与 JDK动态代理对比

CGLIB 和 JDK 动态代理是两种常见的动态代理技术，它们各有特点和适用场景。

适用场景：JDK动态代理适用于实现了接口的的对象，不需要依赖第三方库，比较简单。CGLIB 适用于任何类，包括没有实现接口的类和final类，需要依赖 CGLIB 库。
性能对比
1. 初始化时 JDK 动态代理不需要生成额外的字节码，因此性能较好。
2. 方法运行时，每次方法调用时，JDK 动态代理都需要通过 InvocationHandler 接口来处理，这可能会引入一定的性能开销。CGLIB 代理通过生成子类的方式实现了方法拦截，因此在方法调用时性能较高。
3. 内存开销：由于 JDK 动态代理不需要生成额外的字节码，因此内存消耗相对较低。CGLIB 代理生成子类时会增加内存消耗，特别是在大规模应用中，可能会导致内存增加。

总结，对于少量方法调用时，JDK 动态代理在性能上可能优于 CGLIB 代理。对于大量方法调用时，CGLIB 代理在性能上通常优于 JDK 动态代理。