Spring-framework源码分析（八）getBean单例循环依赖解决思路

@Component
public class A {
	@Autowired
	private B b;
}

@Component
public class B {
	@Autowired
	private A a;
}

@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // 从一级缓存获取，key=beanName value=bean
  Object singletonObject = this.singletonObjects.get(beanName);
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    synchronized (this.singletonObjects) {
      // 从二级缓存获取，key=beanName value=bean
      singletonObject = this.earlySingletonObjects.get(beanName);
      // 是否允许循环引用, allowEarlyReference 默认为true
      if (singletonObject == null && allowEarlyReference) {
        /**
         * 三级缓存获取，key=beanName value=objectFactory，objectFactory中存储getObject()方法用于获取提前曝光的实例
         * 为什么不直接将实例缓存到二级缓存，而要多此一举将实例先封装到objectFactory中？
         *
         * 因为主要关键点在getObject()方法并非直接返回实例，而是对实例又使用
         * SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法对bean进行处理
         * 
         * 也就是说，当spring中存在该后置处理器，所有的单例bean在实例化后都会被进行提前曝光到三级缓存中，
         * 但是并不是所有的bean都存在循环依赖，也就是三级缓存到二级缓存的步骤不一定都会被执行，有可能曝光后直接创建完成，没被提前引用过，
         * 就直接被加入到一级缓存中。因此可以确保只有提前曝光且被引用的bean才会进行该后置处理
         */
        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
        if (singletonFactory != null) {
         /**
          * 通过getObject()方法获取bean，通过此方法获取到的实例不单单是提前曝光出来的实例，
          * 它还经过了SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法处理过。
          * 这也正是三级缓存存在的意义，可以通过重写该后置处理器对提前曝光的实例，在被提前引用时进行一些操作
          */
          singletonObject = singletonFactory.getObject();
          /**
          * 放入到二级缓存中
          */
          this.earlySingletonObjects.put(beanName, singletonObject);
          /**
          * 从三级缓存中删除
          */
          this.singletonFactories.remove(beanName);
        }
      }
    }
  }
  return singletonObject;
}

// 提前暴露一个早期的单例工厂，以便解决循环引用

// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
  if (logger.isTraceEnabled()) {
    logger.trace("Eagerly caching bean '" + beanName +
        "' to allow for resolving potential circular references");
  }
  addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

// 初始化阶段

// Initialize the bean instance.
Object exposedObject = bean;
try {
  // 属性填充
  populateBean(beanName, mbd, instanceWrapper);
  // 初始化
  exposedObject = initializeBean(beanName, exposedObject, mbd);
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  Object exposedObject = bean;
  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
      exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
    }
  }
  return exposedObject;
}

@Override
public Object getEarlyBeanReference(Object bean, String beanName) {
  Object cacheKey = getCacheKey(bean.getClass(), beanName);
  this.earlyProxyReferences.put(cacheKey, bean);
  return wrapIfNecessary(bean, beanName, cacheKey);
}

// AbstractAutoProxyCreator.java
public Object getEarlyBeanReference(Object bean, String beanName) {
  // 缓存当前bean，表示该bean被提前代理了
  Object cacheKey = getCacheKey(bean.getClass(), beanName);
  this.earlyProxyReferences.put(cacheKey, bean);
  // 对bean进行提前Spring AOP代理
  return wrapIfNecessary(bean, beanName, cacheKey);
}