Spring AOP代理创建机制与循环依赖处理

1. Spring AOP代理创建机制全景透视

在Spring框架的核心设计中，代理创建时机直接关系到整个容器的行为正确性。让我们从一个实际案例切入：当你在Service层方法上添加@Transactional注解后，Spring是如何确保事务生效的？这个看似简单的功能背后，隐藏着复杂的代理创建逻辑。

Spring处理代理的时机选择绝非偶然，而是经过严密设计的。在容器启动过程中，Bean的实例化与初始化会经历多个关键阶段：

1. 实例化阶段（Instantiation）：通过构造函数或工厂方法创建原始对象
2. 属性填充（Population）：注入依赖项
3. 初始化前（Before Initialization）：执行BeanPostProcessor前置处理
4. 初始化（Initialization）：调用init-method或@PostConstruct方法
5. 初始化后（After Initialization）：执行BeanPostProcessor后置处理

代理创建可能发生在两个关键节点：

• 初始化阶段（通过BeanPostProcessor前置处理）
• 三级缓存解决循环依赖时的早期曝光

这种双路径设计带来了几个显著优势：

• 性能优化：避免不必要的代理创建
• 循环依赖支持：通过早期引用打破依赖环
• 灵活性：支持多种代理策略动态选择

关键理解：Spring并非总是等到完全初始化后才创建代理，这种灵活的时机选择正是其设计精妙之处。

2. 初始化阶段代理创建深度解析

2.1 AbstractAutoProxyCreator的工作机制

Spring中代理创建的主力是AbstractAutoProxyCreator及其子类（如AnnotationAwareAspectJAutoProxyCreator）。这个处理器会在Bean生命周期的两个时点介入：

java复制public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
    // 在实例化前尝试创建代理（特殊场景使用）
    // ...
}

public Object postProcessAfterInitialization(Object bean, String beanName) {
    // 主要的代理创建入口
    if (shouldSkip(beanClass, beanName)) {
        return bean;
    }
    return wrapIfNecessary(bean, beanName, cacheKey, beanClass);
}

实际开发中常见的误区是认为所有代理都在初始化后创建。但通过源码跟踪可以发现，当处理循环依赖时，情况会变得复杂。

2.2 典型代理创建流程

让我们看一个标准非循环依赖场景的代理创建过程：

1. 容器调用getBean("serviceA")开始创建
2. 实例化ServiceA原始对象
3. 填充ServiceA的依赖属性
4. 执行初始化方法
5. AbstractAutoProxyCreator介入：
   • 检查是否需要代理（根据@Aspect、@Transactional等）
   • 创建ProxyFactory配置代理参数
   • 选择JDK动态代理或CGLIB
6. 返回代理对象

这个流程清晰明了，但当出现循环依赖时，情况就会发生变化。

3. 三级缓存与早期代理曝光

3.1 三级缓存结构解析

Spring解决循环依赖的核心在于三级缓存设计：

关键点在于二级缓存存储的可能是"早期代理对象"。当Bean A依赖Bean B，而Bean B又依赖Bean A时：

1. 创建A实例后立即放入三级缓存
2. 开始填充A的属性时发现需要B
3. 创建B实例后同样放入三级缓存
4. B填充属性时从三级缓存获取A的ObjectFactory
5. 此时会触发A的早期代理创建（如果需要）
6. 将A的代理对象放入二级缓存
7. B完成初始化
8. A继续完成初始化

3.2 源码中的关键逻辑

在DefaultSingletonBeanRegistry中可以看到关键实现：

java复制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;
}

当从三级缓存(ObjectFactory)获取对象时，会触发SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法，这正是早期代理创建的点。

4. 两种代理创建路径的对比分析

4.1 时机对比表

4.2 典型问题场景分析

场景一：事务不生效
当在初始化方法(@PostConstruct)中调用代理方法时，如果代理是在初始化后创建，则此时调用的是原始对象方法，导致事务等AOP功能失效。

解决方案：

java复制@Service
public class OrderService {
    @Autowired
    private OrderService self; // 注入代理后的实例
    
    @PostConstruct
    public void init() {
        self.initialize(); // 通过代理调用
    }
    
    @Transactional
    public void initialize() {
        // 初始化逻辑
    }
}

场景二：循环依赖中的代理不一致
当Bean A和Bean B相互依赖且都需要代理时，可能会出现代理创建时序问题。Spring通过三级缓存机制确保最终使用的是同一个代理实例。

5. 源码级调试实践指南

5.1 关键断点设置

要深入理解代理创建过程，建议在以下关键位置设置断点：

1. AbstractAutowireCapableBeanFactory#doCreateBean

   • 实例化后：instanceWrapper = createBeanInstance(beanName, mbd, args)
   • 三级缓存添加：addSingletonFactory(beanName, () -> getEarlyBeanReference(...))

2. AbstractAutoProxyCreator#postProcessAfterInitialization

   • 主代理创建入口：return wrapIfNecessary(bean, beanName, cacheKey, beanClass)

3. DefaultSingletonBeanRegistry#getSingleton

   • 三级缓存查询：singletonObject = singletonFactory.getObject()

5.2 调试技巧

1. 创建简单测试用例：

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

@Component
public class ServiceB {
    @Autowired private ServiceA a;
    @Async public void methodB() {}
}

2. 观察日志输出：
   开启DEBUG日志级别，关注：

• BeanCurrentlyInCreation日志
• Creating instance of bean...
• Returning cached instance of singleton bean...

3. 使用条件断点：
   在getEarlyBeanReference方法上设置条件断点：beanName.equals("serviceA")

6. 性能优化与最佳实践

6.1 代理创建性能考量

代理创建是相对昂贵的操作，优化建议：

1. 合理使用@Scope

   • 对于无状态的Service，保持默认singleton
   • 避免不必要的prototype scope增加代理开销

2. 谨慎使用@Aspect

   • 精确指定切点表达式，避免过度匹配
   • 例如：@Pointcut("execution(public * com.example..*(..))")

3. 代理类型选择

   • 优先使用CGLIB（spring.aop.proxy-target-class=true）
   • 对于接口明确的场景可使用JDK动态代理

6.2 循环依赖处理建议

虽然Spring提供了循环依赖支持，但设计上应尽量避免：

1. 重构方案：

   • 提取公共逻辑到第三方Bean
   • 使用事件驱动模型解耦
   • 考虑使用Setter注入替代构造器注入

2. 必须使用时的注意事项：

   • 避免在构造器中调用代理方法
   • 使用@Lazy延迟注入打破循环
   • 确保相互依赖的方法没有事务传播冲突

7. 高级应用场景分析

7.1 自定义代理创建逻辑

通过继承AbstractAutoProxyCreator可以实现自定义代理策略：

java复制public class CustomAutoProxyCreator extends AbstractAutoProxyCreator {
    @Override
    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
        if (beanClass.getName().contains("Special")) {
            return new Object[] { new CustomInterceptor() };
        }
        return DO_NOT_PROXY;
    }
}

// 注册为Bean后生效
@Bean
public static CustomAutoProxyCreator customAutoProxyCreator() {
    return new CustomAutoProxyCreator();
}

7.2 混合代理场景处理

当同一个Bean需要多种代理时（如@Transactional和@Async），处理顺序很重要：

1. 通过@Order控制切面顺序
2. 代理会形成调用链：
   TransactionalProxy -> AsyncProxy -> Target
3. 注意方法可见性：
   内部方法调用不会经过代理，应避免自调用

实际开发中遇到的一个典型问题是异步事务方法：

java复制@Transactional
public void process() {
    asyncTask(); // 异步不生效
    this.asyncTask(); // 同样不生效
}

@Async
public void asyncTask() {
    // 需要从代理对象调用才会异步执行
}

正确做法是通过代理实例调用：

java复制@Service
public class MyService {
    @Autowired
    private MyService selfProxy; // 注入代理
    
    @Transactional
    public void process() {
        selfProxy.asyncTask(); // 正确触发异步
    }
}