---

一、AOP 代码示例

1. 准备注解和目标类

/*** @author zhuRuiBo* @date 2025/2/21 11:22*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {String value() default "";
}@Slf4j
@RestController
@RequestMapping("/aop")
public class AopDemoController {/*** 切点*/@Log("s1LogAnno")@GetMapping("s1")public String s1() {log.info("s1 ---");return "ok";}
}

2. 定义 Aspect

定义两个 Aspect, 一个 Around Aspect, 一个是分离(Before, After, AfterReturn, AfterThrowing)的 Aspect

/*** around Aspect* @author zhuRuiBo* @date 2025/2/21 11:25*/
@Slf4j
@Component
@Aspect
public class LogAroundAspect {@Pointcut("@annotation(com.zrb.aop.demo.Log)")public void pointcut(){}@Around("pointcut()")public Object around(ProceedingJoinPoint joinPoint) throws Throwable {log.info("around - before: {}", joinPoint.getSignature().getName());Object result = joinPoint.proceed();log.info("around - after: {}", joinPoint.getSignature().getName());return result;}
}

@Slf4j
@Component
@Aspect
public class LogSeparateAspect {@Pointcut("@annotation(com.zrb.aop.demo.Log)")public void pointcut(){}@Before("pointcut()")public void before(){log.info("LogSeparateAspect before");}@After("pointcut()")public void after() {log.info("LogSeparateAspect after");}@AfterReturning("pointcut()")public void afterReturning() {log.info("LogSeparateAspect afterReturning");}@AfterThrowing("pointcut()")public void afterThrowing() {log.info("LogSeparateAspect afterThrowing");}
}

3. 结论

2025-02-26 14:12:39.843  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.LogAroundAspect         : around - before: s1
2025-02-26 14:12:39.843  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.LogSeparateAspect       : LogSeparateAspect before
2025-02-26 14:12:39.850  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.AopDemoController       : s1 ---
2025-02-26 14:12:39.850  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.LogSeparateAspect       : LogSeparateAspect afterReturning
2025-02-26 14:12:39.850  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.LogSeparateAspect       : LogSeparateAspect after
2025-02-26 14:12:39.850  INFO 67047 --- [io-10010-exec-1] com.zrb.aop.demo.LogAroundAspect         : around - after: s1

二、源码

此处源码参考 springboot-2.7.3 版本
本篇源码只解析 Aop 的核心, 直接跳过 spring 的生命周期流程

1. AOP 实现核心类

1. AbstractAutoProxyCreator: 创建代理的核心类, 代理对象就在 wrapIfNecessary 方法中创建
2. @EnableAspectJAutoProxy 开启 Aspect 自动配置，或许在老版本中我们还需要手动添加这个注解, 但是在 2.7.3 版本中，已经不需要手动引入这个注解了
3. AopAutoConfiguration : Aop 自动配置类
4. Advisor 与 Advice：Advisor 中包含了一个 Advice, 而每一个 Aop 注解(@Around,@Before, @After 等等)都会被包装成为一个 Advice, 最终也是通过 Advice 去执行目标方法

2. 代理类的创建流程

2.1 核心类 AbstractAutoProxyCreator

/*** 实现了 SmartInstantiationAwareBeanPostProcessor, 所以在 Bean 的生命周期中会执行该类的* postProcessBeforeInstantiation 和 postProcessAfterInstantiation* 这里直接说结论: 代理一般是在 postProcessAfterInstantiation 中创建的* 	postProcessBeforeInstantiation 中也可能会创建，但是一般不会在这个方法中创建* 扩展：SmartInstantiationAwareBeanPostProcessor 本身还有一个 getEarlyBeanReference 的方法, 这个方法被三级缓存所引用* 目的是为了方便随时从三级缓存中创建代理，因此代理对象也可能在三级缓存中直接创建*/
public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupportimplements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware

2.2 AbstractAutoProxyCreator#postProcessBeforeInstantiation

@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {Object cacheKey = getCacheKey(beanClass, beanName);if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {if (this.advisedBeans.containsKey(cacheKey)) {return null;}// 注意这个 shouldSkip 及其重要，实现类 AspectJAwareAdvisorAutoProxyCreator 里面会创建 Advisor// 然后 Advisor 构造器中会创建 Adviceif (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE);return null;}}// 一般来讲这个地方获取到的是 null, 因此一般不会在这个地方就创建代理类TargetSource targetSource = getCustomTargetSource(beanClass, beanName);if (targetSource != null) {if (StringUtils.hasLength(beanName)) {this.targetSourcedBeans.add(beanName);}Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);// 创建代理类Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);this.proxyTypes.put(cacheKey, proxy.getClass());return proxy;}return null;
}

2.3 AspectJAwareAdvisorAutoProxyCreator#shouldSkip

@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {// TODO: Consider optimization by caching the list of the aspect names// 获取 ioc 中手动注入的 Advisor, 在 AnnotationAwareAspectJAutoProxyCreator 中会创建 Aspect 中的 Advisor// 至于为什么会是 AnnotationAwareAspectJAutoProxyCreator 可以参考第二章List<Advisor> candidateAdvisors = findCandidateAdvisors();for (Advisor advisor : candidateAdvisors) {if (advisor instanceof AspectJPointcutAdvisor &&((AspectJPointcutAdvisor) advisor).getAspectName().equals(beanName)) {return true;}}return super.shouldSkip(beanClass, beanName);
}/*** AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors*/
@Override
protected List<Advisor> findCandidateAdvisors() {// Add all the Spring advisors found according to superclass rules.// super.findCandidateAdvisors() 是获取 spring 中显示加入的 AdvisorList<Advisor> advisors = super.findCandidateAdvisors();// Build Advisors for all AspectJ aspects in the bean factory.if (this.aspectJAdvisorsBuilder != null) {// buildAspectJAdvisors() 将 Aspect 类，构建成 Advisoradvisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());}return advisors;
}

2.4 aspectJAdvisorsBuilder#buildAspectJAdvisors

将 Aspect 构建成 Advisor

public List<Advisor> buildAspectJAdvisors() {List<String> aspectNames = this.aspectBeanNames;if (aspectNames == null) {synchronized (this) {aspectNames = this.aspectBeanNames;// 只会初始化一次if (aspectNames == null) {List<Advisor> advisors = new ArrayList<>();aspectNames = new ArrayList<>();// 获取所有的 beanNamesString[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);for (String beanName : beanNames) {// 判断是否符合条件的 beanName, 当前一直返回 trueif (!isEligibleBean(beanName)) {continue;}// We must be careful not to instantiate beans eagerly as in this case they// would be cached by the Spring container but would not have been weaved.Class<?> beanType = this.beanFactory.getType(beanName, false);if (beanType == null) {continue;}// 判断当前 bean 是否是一个 Aspect// 很简单，通过判断该类上是否注有 @Aspect 注解if (this.advisorFactory.isAspect(beanType)) {aspectNames.add(beanName);AspectMetadata amd = new AspectMetadata(beanType, beanName);if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {MetadataAwareAspectInstanceFactory factory =new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);// 通过 advisorFactory 创建 advisorList<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);if (this.beanFactory.isSingleton(beanName)) {this.advisorsCache.put(beanName, classAdvisors);}else {this.aspectFactoryCache.put(beanName, factory);}advisors.addAll(classAdvisors);}...}}this.aspectBeanNames = aspectNames;return advisors;}}}...return advisors;
}

2.5 advisorFactory#getAdvisors

/*** advisorFactory#getAdvisors*/
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();validate(aspectClass);...MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);List<Advisor> advisors = new ArrayList<>();// getAdvisorMethods 是获取了除了 @Pointcut 之外的所有的方法for (Method method : getAdvisorMethods(aspectClass)) {...// getAdvisor 中，如果没有任何的注解将会返回 null// 默认 Advisor 实现类为 InstantiationModelAwarePointcutAdvisorImpl, 构造器中会创建 AdviseAdvisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, 0, aspectName);if (advisor != null) {advisors.add(advisor);}}...return advisors;
}/*** getAdvisor()*/
@Override
@Nullable
public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,int declarationOrderInAspect, String aspectName) {validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());AspectJExpressionPointcut expressionPointcut = getPointcut(candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());if (expressionPointcut == null) {return null;}// 默认的 Advisor 实现类为 InstantiationModelAwarePointcutAdvisorImplreturn new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
}

2.6 AbstractAutoProxyCreator#postProcessAfterInitialization

// AbstractAutoProxyCreator#postProcessAfterInitialization
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {if (bean != null) {Object cacheKey = getCacheKey(bean.getClass(), beanName);if (this.earlyProxyReferences.remove(cacheKey) != bean) {// 核心方法 wrapIfNecessary// 另外三级缓存中存放的 lambda 也会调用这个方法 return wrapIfNecessary(bean, beanName, cacheKey);}}return bean;
}

2.7 AbstractAutoProxyCreator#wrapIfNecessary

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {return bean;}if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {return bean;}if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {this.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;}// Create proxy if we have advice. // 创建代理对象，如果我们有 Advice 的话// 获取所有的 Advisor, 如果存在 Advisor 就要创建代理对象Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);if (specificInterceptors != DO_NOT_PROXY) {this.advisedBeans.put(cacheKey, Boolean.TRUE);// 创建代理对象Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));this.proxyTypes.put(cacheKey, proxy.getClass());// 返回代理对象return proxy;}this.advisedBeans.put(cacheKey, Boolean.FALSE);return bean;
}

2.8 添加 ExposeInvocationInterceptor

@Override
@Nullable
protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);if (advisors.isEmpty()) {return DO_NOT_PROXY;}return advisors.toArray();
}/*** AbstractAdvisorAutoProxyCreator#findEligibleAdvisors*/
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {// 获取所有的 AdvisorList<Advisor> candidateAdvisors = findCandidateAdvisors();List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);// 添加一个头部的 Advisor: extendAdvisors(eligibleAdvisors);if (!eligibleAdvisors.isEmpty()) {eligibleAdvisors = sortAdvisors(eligibleAdvisors);}return eligibleAdvisors;
}/* * AspectJAwareAdvisorAutoProxyCreator#extendAdvisors*/
@Override
protected void extendAdvisors(List<Advisor> candidateAdvisors) {AspectJProxyUtils.makeAdvisorChainAspectJCapableIfNecessary(candidateAdvisors);
}/*** AspectJProxyUtils#makeAdvisorChainAspectJCapableIfNecessary*/
public static boolean makeAdvisorChainAspectJCapableIfNecessary(List<Advisor> advisors) {// Don't add advisors to an empty list; may indicate that proxying is just not requiredif (!advisors.isEmpty()) {// 在 Advisor 上添加一个 ExposeInvocationInterceptor.ADVISORif (foundAspectJAdvice && !advisors.contains(ExposeInvocationInterceptor.ADVISOR)) {advisors.add(0, ExposeInvocationInterceptor.ADVISOR);return true;}}return false;
}

2.9 创建代理对象 createProxy()

protected Object createProxy(Class<?> beanClass, @Nullable String beanName,@Nullable Object[] specificInterceptors, TargetSource targetSource) {if (this.beanFactory instanceof ConfigurableListableBeanFactory) {AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);}// 将需要创建的配置信息保存到 proxyFactory，proxyFactory 创建代理的时候定制化ProxyFactory proxyFactory = new ProxyFactory();proxyFactory.copyFrom(this);...// 获取 AdvisorsAdvisor[] advisors = buildAdvisors(beanName, specificInterceptors);proxyFactory.addAdvisors(advisors);proxyFactory.setTargetSource(targetSource);// 钩子, 可以定制化 proxyFactorycustomizeProxyFactory(proxyFactory);...// 通过 proxyFactory 获取代理对象return proxyFactory.getProxy(classLoader);
}

2.10 ProxyFactory#getProxy

/*** ProxyFactory#getProxy*/
public Object getProxy(@Nullable ClassLoader classLoader) {return createAopProxy().getProxy(classLoader);
}/*** createAopProxy*/
protected final synchronized AopProxy createAopProxy() {if (!this.active) {activate();}return getAopProxyFactory().createAopProxy(this);
}/*** createAopProxy()* 总结：* 1. 如果没有开启“类”类型的代理, 直接使用 JDK 的代理* 2. 如果目标类是一个接口, 一个已经被代理过的类, 或者是一个 lambda 表达式, 都是用 JDK 的代理, 否则是用 CGLIB*/@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {...// 这个判断, 简单来说就是开启了类类型的代理, 如果没有开启, 直接使用 JDK 的代理if (!NativeDetector.inNativeImage() &&(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {// 如果目标类是一个接口, 一个已经被代理过的类, 或者是一个 lambda 表达式, 都是用 JDK 的代理, 否则是用 CGLIBif (targetClass.isInterface() || Proxy.isProxyClass(targetClass) || ClassUtils.isLambdaClass(targetClass)) {return new JdkDynamicAopProxy(config);}return new ObjenesisCglibAopProxy(config);}else {return new JdkDynamicAopProxy(config);}
}

2.11 CGLIB 代理类

下面的代码, 需要知道 CGLIB 如何使用

@Override
public Object getProxy(@Nullable ClassLoader classLoader) {try {... // Configure CGLIB Enhancer...// 创建 EnhancerEnhancer enhancer = createEnhancer();...// 获取 callbackCallback[] callbacks = getCallbacks(rootClass);...// 将 callback 设置到 enhancer 上return createProxyClassAndInstance(enhancer, callbacks);}...
}

2.12 获取拦截器 getCallbacks

private Callback[] getCallbacks(Class<?> rootClass) throws Exception {...// Choose an "aop" interceptor (used for AOP calls).// Aop 的默认 CallbackCallback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);...return callbacks;
}

3. Aop自动配置

查看 Springboot 的自动配置类中与 Aop 相关的, 可以看到 springboot 引入了一个 AopAutoConfiguration

3.1 AopAutoConfiguration 源码

	/*** spring.aop.proxy-target-class 指的是是否自动代理“类”类型的* 可以看到无论如何都会引入 @EnableAspectJAutoProxy*/@AutoConfiguration@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)public class AopAutoConfiguration {@Configuration(proxyBeanMethods = false)@ConditionalOnClass(Advice.class)static class AspectJAutoProxyingConfiguration {@Configuration(proxyBeanMethods = false)@EnableAspectJAutoProxy(proxyTargetClass = false)@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false")static class JdkDynamicAutoProxyConfiguration {}@Configuration(proxyBeanMethods = false)@EnableAspectJAutoProxy(proxyTargetClass = true)@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true",matchIfMissing = true)static class CglibAutoProxyConfiguration {}}...}

3.2 @EnableAspectJAutoProxy

/*** 引入了一个 AspectJAutoProxyRegistrar 类*/
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {boolean proxyTargetClass() default false;boolean exposeProxy() default false;}

3.3 AspectJAutoProxyRegistrar

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {/*** 注册 Aop 需要的类*/@Overridepublic void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {// 注册 AbstractAutoProxyCreator 的具体子类AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);AnnotationAttributes enableAspectJAutoProxy =AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);if (enableAspectJAutoProxy != null) {if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);}if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);}}}}

3.4 注册

@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {return registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, null);
}/*** 由此可见 @EnableAspectJAutoProxy 注册的 AbstractAutoProxyCreator 为 AnnotationAwareAspectJAutoProxyCreator*/
@Nullable
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, @Nullable Object source) {return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

4. AOP 执行流程

这里只研究 CGLIB 的代理

4.1 拦截器 DynamicAdvisedInterceptor

从源码 1 可知，代理类的拦截器是 DynamicAdvisedInterceptor，当执行目标方法的时候会执行到该类的 interceptor 方法中

@Override
@Nullablepublic Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {Object oldProxy = null;boolean setProxyContext = false;Object target = null;TargetSource targetSource = this.advised.getTargetSource();try {if (this.advised.exposeProxy) {// Make invocation available if necessary.oldProxy = AopContext.setCurrentProxy(proxy);setProxyContext = true;}// 这行代码也很重要, advised 就是之前的 ProxyFactory, 这里面将每个 Advisor 里面的 Advise 取出来组成一个链// 第一个 Advise 是 ExposeInvocationInterceptor#ADVISORList<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);Object retVal;// Check whether we only have one InvokerInterceptor: that is,// no real advice, but just reflective invocation of the target.if (chain.isEmpty() && CglibMethodInvocation.isMethodProxyCompatible(method)) {...}else {// We need to create a method invocation...// 创建一个 CglibMethodInvocation, 执行目标方法// CglibMethodInvocation 是贯穿整个 aop 上下文的一个对象retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();}retVal = processReturnType(proxy, target, method, retVal);return retVal;}finally {if (target != null && !targetSource.isStatic()) {targetSource.releaseTarget(target);}if (setProxyContext) {// Restore old proxy.AopContext.setCurrentProxy(oldProxy);}}}

4.2 方法执行 proceed

是一个链式的执行方式，与 SpringSecurity 的过滤器链一样

@Override
@Nullable
public Object proceed() throws Throwable {// We start with an index of -1 and increment early.if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {// 开始执行目标方法return invokeJoinpoint();}// 找到当前的 AdviceObject interceptorOrInterceptionAdvice =this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {// Evaluate dynamic method matcher here: static part will already have// been evaluated and found to match.InterceptorAndDynamicMethodMatcher dm =(InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {// dm.interceptor 其实就是各个 Advise// 比如说 @Around 就是 AspectJAroundAdvice, @Before 就是 MethodBeforeAdviceInterceptor// 这里把自身传递下去, interceptor执行 proceed() 就会回到当前方法, 当所有的 Advice 执行完成之后, 就会执行目标方法, 然后将返回值依次返回给 Advisereturn dm.interceptor.invoke(this);}else {// Dynamic matching failed.// Skip this interceptor and invoke the next in the chain.return proceed();}}else {// It's an interceptor, so we just invoke it: The pointcut will have// been evaluated statically before this object was constructed.return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);}
}

总结

ExposeInvocationInterceptor

它的主要作用是将当前的 MethodInvocation 对象暴露给后续的拦截器或切面，以便在 AOP 链中的任何地方都可以访问当前的调用上下文。在自定义拦截器中，可以通过 ExposeInvocationInterceptor.currentInvocation() 获取当前的 MethodInvocation