Spring AOP代理创建时机解析与循环依赖处理-代码聚汇网

Spring AOP代理创建时机解析与循环依赖处理

Spring AOP代理创建时机循环依赖

|难度：普通|阅读约 19 分钟

1. 为什么需要研究Spring AOP代理创建时机？

在Spring框架的实际开发中，我们经常会遇到一些看似简单却令人困惑的现象：为什么有些Bean的方法调用没有触发切面逻辑？为什么循环依赖场景下AOP行为会出现不一致？这些问题的根源往往与Spring创建代理对象的时机选择密切相关。

Spring框架在处理AOP代理时，主要存在两种创建时机选择：

初始化阶段完成后的后置处理（通过BeanPostProcessor）
提前暴露对象时的早期代理（通过三级缓存机制）

我曾在实际项目中遇到过这样一个典型场景：一个标记了@Transactional的服务类A，依赖另一个同样有事务注解的服务类B，而B又反过来依赖A。这种循环依赖情况下，事务注解时灵时不灵，最终发现就是因为对代理创建时机理解不透彻导致的。

需要模型API调用？免费领10W Token，多模型网关一键接入 Claude、DeepSeek 等主流模型。

2. 初始化阶段创建代理的标准流程

2.1 标准AOP代理创建路径

在常规无循环依赖的场景下，Spring创建AOP代理的标准流程是这样的：

实例化原始Bean对象（通过构造函数或工厂方法）
填充属性（依赖注入）
执行初始化回调（@PostConstruct等）
经过AbstractAutoProxyCreator的postProcessAfterInitialization方法
如果需要代理，则在此创建并返回代理对象

java复制// 典型的后置处理器实现片段
public Object postProcessAfterInitialization(Object bean, String beanName) {
    if (bean != null) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        if (!this.earlyProxyReferences.contains(cacheKey)) {
            return wrapIfNecessary(bean, beanName, cacheKey);
        }
    }
    return bean;
}

2.2 这种方式的优势与局限

这种标准流程的优势在于：

生命周期完整：Bean已经完全初始化，所有属性都已注入
逻辑清晰：代理包装发生在所有初始化工作完成之后
易于理解：符合大多数开发者对AOP的直观认知

但它的局限性也很明显：

无法处理循环依赖：当Bean之间存在循环引用时，会导致依赖注入不完整
可能造成重复代理：在特定情况下可能导致同一个Bean被多次代理

提示：在Spring Boot应用中，可以通过设置spring.aop.auto=false来禁用自动代理，但这会完全关闭Spring AOP功能。

3. 三级缓存机制与早期代理

3.1 三级缓存的结构与作用

Spring解决循环依赖的核心机制是三级缓存：

singletonObjects：完全初始化好的单例Bean
earlySingletonObjects：提前暴露的原始对象（尚未完成属性填充和初始化）
singletonFactories：对象工厂，用于生成早期引用

java复制// DefaultSingletonBeanRegistry中的关键代码
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

3.2 早期代理的创建时机

当Spring检测到循环依赖时，会通过SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法提前创建代理：

实例化Bean对象后，立即将原始对象包装到ObjectFactory中存入三级缓存
当其他Bean需要注入这个Bean时，会通过工厂提前获取代理对象
后续初始化完成后，会检查是否已经创建过代理，避免重复创建

java复制// AbstractAutoProxyCreator中的实现
public Object getEarlyBeanReference(Object bean, String beanName) {
    Object cacheKey = getCacheKey(bean.getClass(), beanName);
    this.earlyProxyReferences.put(cacheKey, bean);
    return wrapIfNecessary(bean, beanName, cacheKey);
}

4. 两种时机的对比与选择策略

4.1 关键差异对比表

特性	初始化阶段代理	三级缓存早期代理
触发条件	无循环依赖	存在循环依赖
代理创建阶段	Bean初始化完成后	Bean实例化后立即创建
生命周期完整性	完整	不完整（属性未全部注入）
性能影响	较小	需要额外缓存操作
适用场景	大多数常规情况	循环依赖场景

4.2 Spring的选择策略

Spring内部采用以下决策逻辑：

首先尝试通过三级缓存获取Bean（解决循环依赖）
如果没有循环依赖，走标准初始化流程
在initializeBean阶段最终确定代理对象

java复制// AbstractAutowireCapableBeanFactory中的代码片段
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    // 执行Aware接口方法
    invokeAwareMethods(beanName, bean);
    
    // 执行BeanPostProcessor前置处理
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    
    // 执行初始化方法
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    // ...
    
    // 执行BeanPostProcessor后置处理（包括AOP代理创建）
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    
    return wrappedBean;
}

5. 源码级调试与验证方法

5.1 关键断点设置

要验证代理创建时机，可以在以下关键位置设置断点：

AbstractAutoProxyCreator.postProcessAfterInitialization
AbstractAutoProxyCreator.getEarlyBeanReference
DefaultSingletonBeanRegistry.getSingleton
AbstractAutowireCapableBeanFactory.doCreateBean

5.2 验证实验设计

可以通过以下实验验证不同场景下的代理行为：

无循环依赖场景：

java复制@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
    
    @Transactional
    public void methodA() {}
}

@Service
public class ServiceB {
    public void methodB() {}
}

循环依赖场景：

java复制@Service
public class ServiceX {
    @Autowired
    private ServiceY serviceY;
    
    @Transactional
    public void methodX() {}
}

@Service
public class ServiceY {
    @Autowired
    private ServiceX serviceX;
    
    @Transactional
    public void methodY() {}
}

5.3 调试观察要点

在调试过程中需要特别关注：

代理对象的实际创建时间点
earlyProxyReferences集合的变化
最终注入到其他Bean中的对象类型
事务等切面功能是否正常生效

6. 常见问题与解决方案

6.1 代理不生效的典型场景

自调用问题：

java复制@Service
public class ProblemService {
    @Transactional
    public void methodA() {
        this.methodB(); // 自调用不会经过代理
    }
    
    @Transactional
    public void methodB() {}
}

解决方案：

避免自调用
通过AopContext获取当前代理（需要开启exposeProxy）

初始化顺序问题：

java复制@Configuration
public class Config {
    @Bean
    public BeanA beanA() {
        return new BeanA(beanB()); // 直接方法调用绕过代理
    }
    
    @Bean
    @Transactional
    public BeanB beanB() {
        return new BeanB();
    }
}