AOP 自动配置与代理机制全解析
概述
Spring Boot 通过 AopAutoConfiguration 自动配置 AOP 基础设施。它基于 @EnableAspectJAutoProxy 触发 AnnotationAwareAspectJAutoProxyCreator 的注册，该后置处理器在 Bean 初始化后阶段检测需要代理的 Bean，通过 AbstractAutoProxyCreator.wrapIfNecessary() 创建 AOP 代理。
本文将深入拆解 Spring Boot AOP 自动配置与代理机制的 10 个关键细节，涵盖自动配置条件、@EnableAspectJAutoProxy 属性、AutoProxyCreator 继承链、代理创建流程、JDK vs CGLIB 选择、Advisor 识别、通知检测与排序等核心内容。
本文基于 Spring Boot 3.2.5 + Spring Framework 6.1.6 源码分析。
AOP 核心原理可参考 AOP 核心原理 和 @AspectJ 注解驱动。
1. AopAutoConfiguration 的 @ConditionalOnClass
AopAutoConfiguration 是 Spring Boot AOP 自动配置的入口类，通过条件注解确保只在 classpath 中存在 AspectJ 相关类时才生效。
java
@AutoConfiguration
@ConditionalOnClass(EnableAspectJAutoProxy.class)
public class AopAutoConfiguration {
// 当 spring.aop.auto=true（默认）时启用
@Configuration
@EnableAspectJAutoProxy(
proxyTargetClass = false, // 默认使用 JDK 动态代理
exposeProxy = false // 默认不暴露代理到 AopContext
)
@ConditionalOnProperty(
prefix = "spring.aop",
name = "auto",
havingValue = "true", // 默认 true
matchIfMissing = true
)
static class AspectJAutoProxyingConfiguration {
// ...
}
// CGLIB 代理强制配置
@Configuration
@EnableAspectJAutoProxy(
proxyTargetClass = true,
exposeProxy = false
)
@ConditionalOnProperty(
prefix = "spring.aop",
name = "proxy-target-class",
havingValue = "true",
matchIfMissing = false
)
static class CglibAutoProxyConfiguration {
// 当 spring.aop.proxy-target-class=true 时启用
}
}触发条件链：
classpath 中存在 EnableAspectJAutoProxy.class？
↓ 是（spring-aop.jar 在 classpath 中）
spring.aop.auto=true（默认）？
↓ 是（默认配置）
AspectJAutoProxyingConfiguration 生效
↓
@EnableAspectJAutoProxy 导入 AnnotationAwareAspectJAutoProxyCreator
↓
所有 @Aspect Bean 生效，@Transactional/@Cacheable 等也生效spring.aop.* 配置属性：
properties
# application.properties
spring.aop.auto=true # 是否启用 AOP 自动配置（默认 true）
spring.aop.proxy-target-class=false # 是否强制使用 CGLIB 代理（默认 false）2. @EnableAspectJAutoProxy 的 2 个属性
@EnableAspectJAutoProxy 注解通过 @Import 注册 AnnotationAwareAspectJAutoProxyCreator。
java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class) // 注册 AutoProxyCreator
public @interface EnableAspectJAutoProxy {
// 是否使用 CGLIB 代理（替代 JDK 动态代理）
boolean proxyTargetClass() default false;
// 是否通过 AopContext.currentProxy() 暴露当前代理
boolean exposeProxy() default false;
}proxyTargetClass 属性的影响：
proxyTargetClass | 默认行为 | 效果 |
|---|---|---|
false（默认） | JDK 动态代理 | 代理接口；如果目标类没有实现接口则回退 CGLIB |
true | CGLIB 代理 | 直接继承目标类，不要求接口 |
exposeProxy 属性的影响：
java
// exposeProxy = false（默认）
@Service
public class UserServiceImpl implements UserService {
@Transactional
public void methodA() {
this.methodB(); // 自调用 → 没有经过代理 → @Transactional 不生效
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void methodB() { }
}
// exposeProxy = true
@Service
public class UserServiceImpl implements UserService {
@Transactional
public void methodA() {
UserService proxy = (UserService) AopContext.currentProxy();
proxy.methodB(); // 通过代理调用 → @Transactional 生效
}
}AspectJAutoProxyRegistrar 的实现：
java
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 1. 注册 AnnotationAwareAspectJAutoProxyCreator
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
// 2. 读取 @EnableAspectJAutoProxy 注解属性
AnnotationAttributes aajap = AnnotationAttributes.fromMap(
importingClassMetadata.getAnnotationAttributes(EnableAspectJAutoProxy.class.getName()));
if (aajap != null) {
// 设置 proxyTargetClass
if (aajap.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
// 设置 exposeProxy
if (aajap.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}3. AnnotationAwareAspectJAutoProxyCreator 继承链
AnnotationAwareAspectJAutoProxyCreator 是整个 AOP 代理创建的核心类，其继承链体现了每层新增的能力。
AnnotationAwareAspectJAutoProxyCreator
↓ 继承
AspectJAwareAdvisorAutoProxyCreator
↓ 继承
AbstractAdvisorAutoProxyCreator
↓ 继承
AbstractAutoProxyCreator
↓ 实现
SmartInstantiationAwareBeanPostProcessor（Bean 实例化后的后置处理）
BeanFactoryAware（感知 BeanFactory）每层新增的能力：
| 类 | 新增能力 | 说明 |
|---|---|---|
AbstractAutoProxyCreator | postProcessAfterInitialization() | 在 Bean 初始化后检查是否需要创建代理 |
wrapIfNecessary() | 核心方法：创建代理对象 | |
AbstractAdvisorAutoProxyCreator | 从容器中查找 Advisor Bean | findCandidateAdvisors() → BeanFactoryUtils.beansOfTypeIncludingAncestors() |
应用 Advisor 的过滤规则 | Pointcut 匹配、AspectJ 类型过滤等 | |
AspectJAwareAdvisorAutoProxyCreator | 排序增强 | 使用 AspectJPrecedenceInformation 排序通知 |
AnnotationAwareAspectJAutoProxyCreator | 检测 @Aspect 注解 | findEligibleAdvisors() → 扫描 @Aspect Bean 并提取通知方法 |
postProcessAfterInitialization() 入口：
java
public abstract class AbstractAutoProxyCreator
implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
// 1. 检查是否已创建代理（避免重复代理）
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyProxyReferences.contains(cacheKey)) {
// 已经通过提前引用创建了代理，直接返回
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}
}4. AbstractAutoProxyCreator.wrapIfNecessary() 的 4 步
wrapIfNecessary() 是 AOP 代理创建的核心方法，决定某个 Bean 是否需要被代理。
java
public abstract class AbstractAutoProxyCreator {
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
// 1. 检查是否应该跳过此 Bean
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; // 基础设施类（Advice、Pointcut、Advisor 等）→ 跳过
}
// 2. 获取该 Bean 适用的所有增强（Advisor）
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
// 存在适用的增强 → 需要创建代理
this.advisedBeans.put(cacheKey, Boolean.TRUE);
// 3. 创建代理
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;
}
}4 步流程：
wrapIfNecessary(bean, beanName, cacheKey)
↓
① 检查跳过条件
├── targetSourcedBeans 包含 → 跳过
├── advisedBeans 缓存 false → 跳过
├── isInfrastructureClass → 跳过（内置 Advisor/Advice/Pointcut 类）
└── shouldSkip → 跳过（如已经创建了代理的 Bean）
↓
② getAdvicesAndAdvisorsForBean()
├── AbstractAdvisorAutoProxyCreator.findCandidateAdvisors()
│ → 从容器中获取所有 Advisor Bean
└── findAdvisorsThatCanApply(candidateAdvisors, beanClass)
→ Pointcut 匹配 → 只保留适用当前 Bean 的 Advisor
↓
③ createProxy()
├── ProxyFactory proxyFactory = new ProxyFactory()
├── proxyFactory.setTarget(new SingletonTargetSource(bean))
├── proxyFactory.addAdvisors(interceptors)
└── proxyFactory.getProxy(classLoader)
↓
④ 返回代理对象（替换原始 Bean）5. JDK 动态代理 vs CGLIB 代理的选择
ProxyFactory 根据 proxyTargetClass 属性和目标类是否实现接口来决定代理方式。
java
public class ProxyFactory extends ProxyCreatorSupport {
// 获取代理
public Object getProxy(@Nullable ClassLoader classLoader) {
return createAopProxy().getProxy(classLoader);
}
// 创建 AOP 代理（核心选择逻辑）
protected final synchronized AopProxy createAopProxy() {
if (!this.active) {
activate();
}
return getAopProxyFactory().createAopProxy(this);
}
}
// DefaultAopProxyFactory — 决定代理策略
public class DefaultAopProxyFactory implements AopProxyFactory {
@Override
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
// 选择 JDK 动态代理的条件：
// 条件 1: config.isOptimize() — 非优化模式
// 条件 2: config.isProxyTargetClass() — 未强制 CGLIB
// 条件 3: config.getProxiedInterfaces().length > 0 — 目标类有接口
if (!config.isOptimize()
&& !config.isProxyTargetClass()
&& hasNoUserSuppliedProxyInterfaces(config)) {
return new JdkDynamicAopProxy(config);
}
// CGLIB 代理
Class<?> targetClass = config.getTargetClass();
if (targetClass.isInterface() || isProxyClass(targetClass)) {
// 目标类本身是接口 → 使用 JDK 动态代理
return new JdkDynamicAopProxy(config);
}
return new ObjenesisCglibAopProxy(config);
}
// 判断是否有用户自定义的代理接口
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
Class<?>[] interfaces = config.getProxiedInterfaces();
return interfaces.length == 0
|| (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0]));
}
}代理策略选择树：
createAopProxy(config)
↓
proxyTargetClass=false（默认）AND 无自定义接口？
↓ 是 → JdkDynamicAopProxy
↓ 否
↓
targetClass 是接口或者是代理类？
↓ 是 → JdkDynamicAopProxy
↓ 否 → ObjenesisCglibAopProxy
---
使用场景举例：
接口 + 实现类 + proxyTargetClass=false
→ JdkDynamicAopProxy（JDK 动态代理）
接口 + 实现类 + proxyTargetClass=true
→ CglibAopProxy（强制 CGLIB）
没有接口的类 + proxyTargetClass=false
→ CglibAopProxy（回退 CGLIB）
接口本身就是代理目标 + proxyTargetClass=false
→ JdkDynamicAopProxy两种代理方式对比：
| 特性 | JDK 动态代理 | CGLIB 代理 |
|---|---|---|
| 原理 | 实现 InvocationHandler 接口 | 字节码增强，生成子类 |
| 要求 | 目标类必须实现至少一个接口 | 无要求 |
| 代理对象 | 实现目标类的所有接口 | 继承目标类 |
| 方法拦截 | invoke(Object proxy, Method method, Object[] args) | 重写目标方法 |
final 方法 | 不支持（接口方法不能为 final） | 不能代理 final 方法 |
toString() / equals() / hashCode() | 自动代理 | 自动代理 |
| 构造器 | 不调用目标类构造器 | 调用目标类构造器 |
| 性能（创建） | 快 | 稍慢（字节码生成） |
| 性能（调用） | 快（反射调用） | 快（方法重写 + 拦截器链） |
6. DefaultAdvisorAutoProxyCreator 对 Advisor Bean 的自动识别
AbstractAdvisorAutoProxyCreator 负责从容器中自动发现所有匹配的 Advisor Bean。
java
public abstract class AbstractAdvisorAutoProxyCreator extends AbstractAutoProxyCreator {
// 查找候选 Advisor
protected List<Advisor> findCandidateAdvisors() {
// 委托给 AdvisorRetrievalHelper
return this.advisorRetrievalHelper.findAdvisorBeans();
}
}
// AdvisorRetrievalHelper — 实际查找逻辑
class AdvisorRetrievalHelper {
private final ConfigurableListableBeanFactory beanFactory;
public List<Advisor> findAdvisorBeans() {
// 1. 获取容器中所有 Advisor 类型 Bean 的名称
String[] advisorNames = this.beanFactory
.getBeanNamesForType(Advisor.class, true, false);
List<Advisor> advisors = new ArrayList<>();
for (String name : advisorNames) {
if (isEligibleBean(name)) {
// 2. 跳过正在创建中的 Bean（防止循环引用）
if (this.beanFactory.isCurrentlyInCreation(name)) {
// 延迟到当前 Bean 创建完成后再获取
continue;
}
// 3. 获取 Advisor Bean 实例
advisors.add(this.beanFactory.getBean(name, Advisor.class));
}
}
return advisors;
}
}查找的 Advisor 来源：
容器中所有 Advisor Bean
↓
① 从 @Aspect 类解析的通知 → AspectJPointcutAdvisor
@Aspect 类中的 @Before / @After / @Around 等通知方法
通过 @AspectJAdvisorFactory.getAdvisors() 解析为 Advisor 列表
② @EnableTransactionManagement 注册的 Advisor
BeanFactoryTransactionAttributeSourceAdvisor
处理 @Transactional 注解的事务 Advisor
③ @EnableCaching 注册的 Advisor
BeanFactoryCacheOperationSourceAdvisor
处理 @Cacheable / @CacheEvict 等缓存 Advisor
④ 用户自定义 Bean 实现 Advisor 接口
如自定义切面类实现 MethodInterceptor + Pointcut匹配过滤：
java
public abstract class AbstractAdvisorAutoProxyCreator {
protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
// 1. 获取所有候选 Advisor
List<Advisor> candidateAdvisors = findCandidateAdvisors();
// 2. 通过 Pointcut 匹配，只保留适用于 beanClass 的 Advisor
List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
// 3. 扩展点（子类可添加额外 Advisor）
extendAdvisors(eligibleAdvisors);
// 4. 排序
if (!eligibleAdvisors.isEmpty()) {
eligibleAdvisors = sortAdvisors(eligibleAdvisors);
}
return eligibleAdvisors;
}
}
// AopUtils 中的匹配检查
public static boolean canApply(Pointcut pointcut, Class<?> targetClass, boolean hasIntroductions) {
// 1. ClassFilter 匹配（类级别过滤器）
if (!pointcut.getClassFilter().matches(targetClass)) {
return false;
}
// 2. MethodMatcher 匹配（方法级别过滤器）
MethodMatcher methodMatcher = pointcut.getMethodMatcher();
if (methodMatcher == MethodMatcher.TRUE) {
return true; // 匹配所有方法
}
// 3. 遍历目标类的所有方法，检查是否有匹配的
Set<Class<?>> classes = new LinkedHashSet<>();
classes.add(targetClass);
classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
for (Class<?> clazz : classes) {
Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
for (Method method : methods) {
if (methodMatcher.matches(method, targetClass)) {
return true; // 至少有一个方法匹配
}
}
}
return false;
}7. AspectJAutoProxyingConfiguration 的内部条件
AopAutoConfiguration 内部定义了两种 @Configuration，分别对应不同的 proxyTargetClass 配置。
java
@AutoConfiguration
@ConditionalOnClass(EnableAspectJAutoProxy.class)
public class AopAutoConfiguration {
// 配置 1: 默认配置（proxyTargetClass=false）
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = false, exposeProxy = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "auto", havingValue = "true", matchIfMissing = true)
static class AspectJAutoProxyingConfiguration {
// 内部条件 1: 检查 proxyTargetClass 是否在 @EnableAspectJAutoProxy 上设置
// → 如果没有 spring.aop.proxy-target-class=true，就用默认的 false
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "false", matchIfMissing = true)
@Configuration
static class JdkDynamicProxyConfiguration {
// JDK 动态代理配置（空实现，仅确保 @EnableAspectJAutoProxy 被正确处理）
}
// 内部条件 2: 显式配置了 spring.aop.proxy-target-class=true
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true")
@Configuration
static class CglibProxyConfiguration {
// CGLIB 代理配置（同样空实现，@EnableAspectJAutoProxy 的 proxyTargetClass=true 在上层设置）
}
}
// 配置 2: 使用 CGLIB 代理（proxyTargetClass=true）
@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true, exposeProxy = false)
@ConditionalOnProperty(prefix = "spring.aop", name = "proxy-target-class", havingValue = "true", matchIfMissing = false)
static class CglibAutoProxyConfiguration {
// 当 spring.aop.proxy-target-class=true 时启用
}
}配置生效的逻辑：
① 默认情况（无 spring.aop 配置）
spring.aop.auto=true (matchIfMissing)
→ AspectJAutoProxyingConfiguration 生效
→ proxyTargetClass=false
→ @EnableAspectJAutoProxy(proxyTargetClass=false)
→ JDK 动态代理
② spring.aop.proxy-target-class=true
→ AspectJAutoProxyingConfiguration 中的 @ConditionalOnProperty("true") 不匹配
→ CglibAutoProxyConfiguration 生效
→ @EnableAspectJAutoProxy(proxyTargetClass=true)
→ CGLIB 代理
③ spring.aop.auto=false
→ 所有内部配置都不生效
→ 没有 AOP 自动配置8. @Aspect 注解检测
AnnotationAwareAspectJAutoProxyCreator 中扩展了 findCandidateAdvisors()，增加了对 @Aspect 注解类的检测。
java
public class AnnotationAwareAspectJAutoProxyCreator
extends AspectJAwareAdvisorAutoProxyCreator {
private AspectJAdvisorFactory aspectJAdvisorFactory;
@Override
protected List<Advisor> findCandidateAdvisors() {
// 1. 调用父类：从容器中获取所有 Advisor Bean
List<Advisor> advisors = super.findCandidateAdvisors();
// 2. 额外查找：从 @Aspect 注解类中构建 Advisor
if (this.aspectJAdvisorFactory != null) {
advisors.addAll(this.aspectJAdvisorBuilder
.buildAspectJAdvisors());
}
return advisors;
}
// 判断是否是基础设施类（不需要被代理）
@Override
protected boolean isInfrastructureClass(Class<?> beanClass) {
// 判断方式：
// 1. 父类检查 → Advice / Pointcut / Advisor / AopInfrastructureBean
// 2. 扩展检查 → @Aspect 注解类本身（切面自身不需要被代理）
return super.isInfrastructureClass(beanClass)
|| (this.aspectJAdvisorFactory != null
&& this.aspectJAdvisorFactory.isAspect(beanClass));
}
}@AspectJAdvisorFactory 的解析过程：
java
// ReflectiveAspectJAdvisorFactory.getAdvisors()
public class ReflectiveAspectJAdvisorFactory implements AspectJAdvisorFactory {
@Override
public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory factory) {
// 1. 获取 @Aspect 类及其元数据
Class<?> aspectClass = factory.getAspectMetadata().getAspectClass();
String aspectName = factory.getAspectMetadata().getAspectName();
// 2. 解析 @Aspect 注解
validate(aspectClass);
// 3. 使用元数据（PerClause）判断切面类型
MetadataAwareAspectInstanceFactory lazySingletonFactory = new LazySingletonAspectInstanceFactory(factory);
List<Advisor> advisors = new ArrayList<>();
// 4. 遍历 @Aspect 类的所有方法
for (Method method : getAdvisorMethods(aspectClass)) {
// 5. 为每个通知方法创建 Advisor
// 按 @Before / @After / @Around / @AfterReturning / @AfterThrowing 顺序
Advisor advisor = getAdvisor(method, lazySingletonFactory, advisors.size(), aspectName);
if (advisor != null) {
advisors.add(advisor);
}
}
// 6. 处理引入（@DeclareParents）
// ...
return advisors;
}
}@Aspect 类中方法的检测范围：
java
public class ReflectiveAspectJAdvisorFactory {
// 收集所有通知方法（按优先级排序）
private List<Method> getAdvisorMethods(Class<?> aspectClass) {
List<Method> methods = new ArrayList<>();
// 递归遍历类及其父类（排除 Object 方法）
ReflectionUtils.doWithMethods(aspectClass, method -> {
// 检查方法上是否有 AspectJ 通知注解
if (getAdviceAnnotation(method) != null) {
methods.add(method);
}
}, method -> {
// 排除 @Pointcut 标记的方法（不含通知逻辑）
return !method.isAnnotationPresent(Pointcut.class);
});
// 按优先级排序：@Around → @Before → @After → @AfterReturning → @AfterThrowing
methods.sort((m1, m2) -> {
AspectJAnnotation<?> a1 = findAspectJAnnotation(m1);
AspectJAnnotation<?> a2 = findAspectJAnnotation(m2);
return Integer.compare(a1.getAnnotationIndex(), a2.getAnnotationIndex());
});
return methods;
}
}通知注解优先级顺序：
@Around → getAnnotationIndex() = 0（最高优先级，包裹整个方法执行）
@Before → getAnnotationIndex() = 1
@After → getAnnotationIndex() = 2（finally 语义）
@AfterReturning → getAnnotationIndex() = 3（正常返回）
@AfterThrowing → getAnnotationIndex() = 4（异常返回）9. Advisor 排序优先级
当多个 Advisor 匹配同一个 Bean 时，排序决定了它们的执行顺序。
java
public abstract class AbstractAdvisorAutoProxyCreator {
// 排序 Advisor
protected List<Advisor> sortAdvisors(List<Advisor> advisors) {
// 使用排序器排序
AspectJPrecedenceComparator comparator =
new AspectJPrecedenceComparator();
List<Advisor> sorted = new ArrayList<>(advisors);
sorted.sort(comparator);
return sorted;
}
}
// AspectJPrecedenceComparator — 切面优先级比较器
class AspectJPrecedenceComparator implements Comparator<Advisor> {
@Override
public int compare(Advisor a1, Advisor a2) {
// 1. 检查是否有明确的优先级声明（@Order / Ordered）
Integer order1 = getOrder(a1);
Integer order2 = getOrder(a2);
if (order1 != null && order2 != null) {
// 都有 @Order → 值小的优先
return Integer.compare(order1, order2);
}
// 2. 检查 AspectJPrecedenceInformation
boolean p1 = a1 instanceof AspectJPrecedenceInformation;
boolean p2 = a2 instanceof AspectJPrecedenceInformation;
if (p1 && p2) {
return comparePrecedenceInformation(
(AspectJPrecedenceInformation) a1,
(AspectJPrecedenceInformation) a2);
}
// 3. 默认顺序
return p1 ? -1 : (p2 ? 1 : 0);
}
// 获取 Advisor 的 @Order 值
private Integer getOrder(Advisor advisor) {
if (advisor instanceof Ordered ordered) {
return ordered.getOrder();
}
// 从 Advisor 的源类上获取 @Order 注解
Object source = advisor.getSource();
if (source instanceof Class<?> sourceClass) {
Order order = sourceClass.getAnnotation(Order.class);
if (order != null) return order.value();
}
return null;
}
}排序规则示例：
java
@Order(1)
@Aspect
@Component
public class LoggingAspect {
@Before("execution(* com.example..*.*(..))")
public void logBefore() { }
}
@Order(2)
@Aspect
@Component
public class SecurityAspect {
@Before("execution(* com.example..*.*(..))")
public void checkSecurity() { }
}
// 执行顺序（order 值小的优先执行 @Before）：
// ① LoggingAspect.logBefore() ← order=1
// ② SecurityAspect.checkSecurity() ← order=2
// ③ 目标方法
// ④ SecurityAspect... ← 后置通知逆序
// ⑤ LoggingAspect... ← 后置通知逆序多个切面的执行顺序：
相同 JoinPoint 上的多个通知执行：
@Before（高优先级 → 低优先级）
① Aspect A @Before ← order=1
② Aspect B @Before ← order=2
③ Aspect C @Before ← order=3
↓
目标方法执行
↓
@After（低优先级 → 高优先级，逆序）
③ Aspect C @After ← order=3（优先执行）
② Aspect B @After ← order=2
① Aspect A @After ← order=110. InfrastructureAdvisorAutoProxyCreator 的注册
InfrastructureAdvisorAutoProxyCreator 是 Spring 内部用于处理基础设施 Advisor 的 AutoProxyCreator，优先级高于用户自定义的 AOP。
java
public class InfrastructureAdvisorAutoProxyCreator extends AbstractAdvisorAutoProxyCreator {
// 有 @Order 值，确保优先级高于用户自定义的 AutoProxyCreator
private int order = Ordered.LOWEST_PRECEDENCE - 1000;
@Override
protected boolean isInfrastructureClass(Class<?> beanClass) {
// 基础设施类包括：
// - Advisor / Pointcut / Advice / AopInfrastructureBean
return super.isInfrastructureClass(beanClass)
|| (beanClass != null && Advisor.class.isAssignableFrom(beanClass));
}
@Override
protected boolean shouldSkip(Class<?> beanClass, String beanName) {
// 跳过用户自定义的 AutoProxyCreator
return AbstractAutoProxyCreator.class.isAssignableFrom(beanClass);
}
}注册时机：
java
// AopAutoConfiguration 中不注册它
// 而是在 AbstractAdvisorAutoProxyCreator 内部自动注册
// 当 @EnableTransactionManagement 或 @EnableCaching 等注解被导入时
// TransactionManagementConfigurationSelector
public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
@Override
protected String[] selectImports(AdviceMode adviceMode) {
switch (adviceMode) {
case PROXY:
return new String[] {
AutoProxyRegistrar.class.getName(), // 注册 InfrastructureAdvisorAutoProxyCreator
ProxyTransactionManagementConfiguration.class.getName()
};
case ASPECTJ:
return new String[] {
TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME
};
}
}
}
// AutoProxyRegistrar 中注册
class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
// 注册 InfrastructureAdvisorAutoProxyCreator
AopConfigUtils.registerInfrastructureAutoProxyCreatorIfNecessary(registry);
}
}InfrastructureAdvisorAutoProxyCreator vs AnnotationAwareAspectJAutoProxyCreator：
| 特性 | InfrastructureAdvisorAutoProxyCreator | AnnotationAwareAspectJAutoProxyCreator |
|---|---|---|
| 注册者 | @EnableTransactionManagement / @EnableCaching | AopAutoConfiguration / @EnableAspectJAutoProxy |
| 优先级 | 高（LOWEST_PRECEDENCE - 1000） | 默认（未设置 order） |
| 处理范围 | 仅处理基础设施 Advisor | 处理所有 Advisor（含 @Aspect） |
| 检测 @Aspect | ❌ | ✅ |
| 跳过条件 | 跳过用户 AutoProxyCreator | 跳过基础设施类 |
| 用途 | 处理事务、缓存等框架内建 AOP | 处理用户自定义 AOP 和 @Aspect |
为什么需要两个 AutoProxyCreator：
java
// 两个 ProxyCreator 协作的例子：
// 一个 Bean 同时有 @Transactional 和 @Aspect 通知
@Service
@Transactional // ← InfrastructureAdvisor (事务 Advisor)
public class UserService {
public void save() { } // ← AspectJAdvisor (用户 @Aspect)
}
// InfrastructureAdvisorAutoProxyCreator 先处理（高优先级）
// → 为 @Transactional 创建代理 → 变为普通 Bean
// AnnotationAwareAspectJAutoProxyCreator 再处理
// → 检查是否需要为 @Aspect 创建代理
// → AOP 的两个代理通过不同的 AutoProxyCreator 独立工作，互不干扰总结
AOP 自动配置与代理机制的 10 个细节点总结如下：
| # | 细节点 | 核心类/机制 |
|---|---|---|
| ① | AopAutoConfiguration 的 @ConditionalOnClass | EnableAspectJAutoProxy 存在时才生效，spring.aop.auto=true 默认启用 |
| ② | @EnableAspectJAutoProxy 的 2 个属性 | proxyTargetClass（默认 false→JDK 代理）和 exposeProxy（默认 false→AopContext.currentProxy() 不可用） |
| ③ | AnnotationAwareAspectJAutoProxyCreator 继承链 | AbstractAutoProxyCreator → AbstractAdvisorAutoProxyCreator → AspectJAwareAdvisorAutoProxyCreator → AnnotationAwareAspectJAutoProxyCreator |
| ④ | AbstractAutoProxyCreator.wrapIfNecessary() 的 4 步 | getAdvicesAndAdvisorsForBean() → findAdvisorsThatCanApply() → createProxy() → ProxyFactory.getProxy() |
| ⑤ | JDK 动态代理 vs CGLIB 代理的选择 | proxyTargetClass=true → CGLIB；有接口默认 → JDK；无接口 → CGLIB |
| ⑥ | DefaultAdvisorAutoProxyCreator 对 Advisor Bean 的自动识别 | BeanFactoryUtils.beansOfTypeIncludingAncestors(Advisor.class) 查找所有 Advisor |
| ⑦ | AspectJAutoProxyingConfiguration 的内部条件 | 嵌套 @Configuration + @ConditionalOnProperty 区分 JDK/CGLIB 配置 |
| ⑧ | @Aspect 注解检测 | ReflectiveAspectJAdvisorFactory.getAdvisors() → 提取通知方法 → 按优先级 @Around → @Before → @After → @AfterReturning → @AfterThrowing |
| ⑨ | Advisor 排序优先级 | @Order / Ordered / AspectJPrecedenceInformation 确定切面执行顺序 |
| ⑩ | InfrastructureAdvisorAutoProxyCreator 的注册 | 仅处理基础设施 Advisor，用于事务/缓存等框架内建 AOP |