Spring 循环依赖
理论上应该先讲SpringBean的实例化和初始化后再来讲Spring的循环依赖问题，但鉴于笔者对循环依赖问题也是迷迷糊糊，本着打破砂锅问到底的态度，在撰写SpringBean的实例化和初始化之前，先来分析一下Spring的循环依赖，本文会有参考链接，旨在帮助笔者和与笔者一同迷惑的前辈后进们解开的Spring循环依赖之谜。
Spring IOC的四种注入方式
setter方法构造方法XML配置文件接口（已经废弃）
Spring 三级缓存
/** Cache of singleton objects: bean name to bean instance. */
// 一级缓存
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// 三级缓存
/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);
// 二级缓存
/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
/** 创建时缓存 bean在创建时会放在缓存中，创建成功后移除缓存。
private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
思考题： Spring为什么要设置三级缓存，如果只是为了解决循环依赖问题，一级缓存够用吗，二级缓存够用吗？说一说Spring设置三级缓存的意义
sigeletonObjects和earlySingletonObjects以及singletonFacotries在DefaultSingletonBeanRegistry中，可以看到，AbstractBeanFacotry继承了DefaultSingletonBeanRegistry。
DefaultSingltonBeanRegistry
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
// 笔者的话：allowEarlyReference代表允许循环引用，Spring可以禁止这个功能
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
// singeletonObject == null 代表 singleObject还未完全初始化（实例化、填充参数、初始化）
Object singletonObject = this.singletonObjects.get(beanName);
// 判断是不是正在创建
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//从二级缓存获取bean （二级缓存中bean只是完成了实例化）
singletonObject = this.earlySingletonObjects.get(beanName);
//allowEarlyReference == true 代表着允许循环依赖
if (singletonObject == null && allowEarlyReference) {
//锁住一级缓存，单例
//假如有线程ThreadA，ThreadbB，ThreadA中有A与B循环依赖，ThreadB中又有A与C循环依赖。
//并发是有先后顺序的，存在一种情况，当ThreadA和ThreadB同时进行到synchornized，就会发生锁竞争，那么假设ThreadA先获得锁，在它解决循环依赖后，一级缓存中已经有完整的A，在A释放锁后，C与其他线程竞争到锁，它自然能从一级缓存中获取A
//单例模式double check
synchronized (this.singletonObjects) {
// Consistent creation of early reference within full singleton lock
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null) {
//如果还是没有bean，就从三级缓存中获得
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//调用getObject方法获取bean，
singletonObject = singletonFactory.getObject();
//早期曝光对象中只有实例化的bean，因此getObject也只是返回实例化的bean，还没执行到属性填充这一步。
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
// 待会儿还有一个getSingleton方法可以分析，暂时放在后面
addSingletonFactory
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
if (!this.singletonObjects.containsKey(beanName)) {
//往三级缓存中添加工厂bean
this.singletonFactories.put(beanName, singletonFactory);
//对应的二级缓存删除那个没实例化的bean，笔者认为这么做是为了线程安全以及提高并发效率 this.earlySingletonObjects.remove(beanName);
//注册单例
this.registeredSingletons.add(beanName);
}
}
}
AbstractBeanFactory
getBean
// 暴露的方法
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
throws BeansException {
return doGetBean(name, requiredType, args, false);
}
doGetBean
protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {
//这个方法是获取bean真正名字 全路径名
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 这里就是调用笔者上面说的DefaultSingletonRegistry中的getSingleton方法，内部实现double check来保证并发安全问题。
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//这个方法笔者将会放到最后分析，显而易见，在这份源码中，返回时都会调用这个方法，但是在调用这个方法的时候，循环依赖的解决已经结束了
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
//这里是获取父类BeanFacotry来加载
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 原型模式下Spring没有办法解决循环依赖问题，自然就会抛出异常
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
//这个方法很重要，如果是类型检查，说明bean已经创建了
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
//到这里一切就绪，准备开始创建bean
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
//获取MergedBeanDefition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//这个应该是检查是否合法吧
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//depensOn对应有一个@Dependson的注解，有了这个注解才会有值
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// Create bean instance.
// isSingleton()是AbstractBeanDifition中的方法，判断这个mnd的Scope（作用域）是不是单例
if (mbd.isSingleton()) {
//这里也有一个getSingleton，但这里调用的不是上面分析的那个getSingleton，先往下走。
sharedInstance = getSingleton(beanName, () -> {
try {
//到了最重要的createBean方法，顾名思义，这里是执行创建Bean的逻辑
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
//原型模式
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
//自定义的Scope
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}
catch (BeansException ex) {
beanCreation.tag("exception", ex.getClass().toString());
beanCreation.tag("message", String.valueOf(ex.getMessage()));
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
finally {
//bean创建结束
beanCreation.end();
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
AbstractAutowireCapableBeanFactory
由图可知，
AbstractAutowireCapableBeanFacotry继承了AbstractBeanFactory，而在AbstractBeanFactory中，crateBean是一个抽象方法，而AbstractAutowireCapableBeanFacotry实现了这个crateBean抽象方法
createBean
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
//mbdToUse 是 mbd 对象的引用
RootBeanDefinition mbdToUse = mbd;
//解析beanName对应的类型，比如com.csh.BaseImpl
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
//深拷贝
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
// 2.验证及准备覆盖的方法（对override属性进行标记及验证）
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// resolveBeforeInstantiation方法可以返回一个代理对象，从而达到‘短路’的效果
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
//Spring正常创建Bean的逻辑
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
// A previously detected exception with proper bean creation context already,
// or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
resolveBeforeInstantiation
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
//初始化bean=null
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
// mbd不是合成的，并且BeanFacotry中有InstantiationAwareBeanPostProcessor接口
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
//调用applyBeanPostProcessorsBeforeInstantiation实现代理
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
//实例化后的后置处理器 笔者隐隐感觉此处与AOP有关
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
//代表bean实例化之前就已经被解析
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
applyBeanPostProcessorsBeforeInstantiation
@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
// InstantiationAwareBeanPostProcessor的实现类
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
//AOP动态代理？？ 笔者并不确定
Object result = bp.postProcessBeforeInstantiation(beanClass, beanName);
// 如果result不为空，则说明代理行为发生，那么返回就是一个完全构造好的bean，从而达到短路的效果
if (result != null) {
return result;
}
}
return null;
}
让我们回到createBean中继续跟踪源码
doCreateBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
//Bean的包装类为null
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
//如果是factoryBean就先移除，保证单例
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//bean实例化，并且返回包装类BeanWarpper
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//获取原生bean的引用
Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//在获取mbd的metadata（元数据），@Value、@Autowire，@Autowire就是通过这个方法实现类型的预解析
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 判断是否需要提早曝光bean（注意，此处bean只是完成了实例化，还没有完成初始化）
// 单例 and 允许循环应用 and 该bean正在创建中
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");
}
//在Bean与代理对象依赖中，这一步获取了代理，
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//记录先前原生bean的引用
Object exposedObject = bean;
try {
//属性填充，循环依赖应该是发生在这一步
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
// 如果允许循环依赖
if (earlySingletonExposure) {
// earlySingletonReference只有在当前解析的bean存在循环依赖的情况下才会不为空
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
// 如果exposedObject没有在initializeBean方法中被增强，则不影响之前的循环
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
//如果说被增强，那么该`bean`依赖的那些bean就是脏数据，需要移除
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
createBeanInstance方法
此处是没走代理的，真正的bean实例化
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// beanClass不为空 && beanClass不是公开类（不是public修饰） && 该bean不允许访问非公共构造函数和方法，则抛异常
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
}
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
//工厂方法不为空，就是用工厂方法来生成bean
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
//工厂方法是否解析过
boolean resolved = false;
//是否需要自动注入的标识符
boolean autowireNecessary = false;
if (args == null) {
//获取锁 线程安全
synchronized (mbd.constructorArgumentLock) {
//判断缓存不为null，设置标识符
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
//如果需要自动注入，就调用自动装配构造函数
return autowireConstructor(beanName, mbd, null, null);
}
else {
return instantiateBean(beanName, mbd);
}
}
// Candidate constructors for autowiring?
//应用后置处理器SmartInstantiationAwareBeanPostProcessor，拿到bean的候选构造函数
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// Preferred constructors for default construction?
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// No special handling: simply use no-arg constructor.
//简单实例化
return instantiateBean(beanName, mbd);
}
至此bean实例化的过程已经结束了，如果对
createBeanInstance中的细节有兴趣，可以访问这位大牛的链接 blog.csdn.net/v123411739/… 笔者笔力有限..实在跟不动了。那么在createBeanInstance方法执行之后，会调动addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));然后会调用一次getSinglton（这就是笔者前文提到的，DefaultSingletonBeanRegistry中的另一个getSingleton方法）中调用的，那么本着打破砂锅问到底的态度，我们自然要跟踪一下这个方法
addSingltonFacotry在DefaultSingletonRegistry中已经分析过，这里就不加以赘述，这里主要是要看getEarlyBeanReference方法
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
//很显然要进去的 getEarlyBeanReference，这是一个接口 getEarylyBeanReference接口被AbstractAutoProxyCreator重写
exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
}
}
return exposedObject;
}
public Object getEarlyBeanReference(Object bean, String beanName) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
this.earlyProxyReferences.put(cacheKey, bean);
//返回代理对象或者原生bean 这里就涉及到AOP了 会在AOP分析
return wrapIfNecessary(bean, beanName, cacheKey);
}
getSingleton方法是笔者上文提过的那个getSingleton方法，需要注意的是，循环依赖是递归执行的，假设
Bean B作为Bean A的依赖，在A调用addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))后，三级缓存中已经存在了一个Bean A的代理对象或者普通对象，那么在Bean B的调用getSingleton的时候，就会从三级缓存中将Bean A的ObjectFactory删除，而后将一个刚好实例化好的Bean Aput入二级缓存中，这样的话Bean B就能顺利地依赖注入A了。
到这一步createBean中的逻辑彻底走完了，需要注意的是外层(doGetBean)还有一个getSingleton
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
笔者认为最关键的就是addSingleton。循环依赖场景下，B会提前于A调用这个addSingleton方法，这和上文提到的addSingletonFactory方法有所不同，后者是将二级缓存放入三级缓存，而前者就是将完整的Bean放入一级缓存中。
我们现在来看看addSingleton方法
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}
到这里整个SpringBean创建过程（大概，属性填充都没有分析，初始化）以及循环依赖都已经阐述清楚了，现在思考那么几个问题。
- 在AOP循环依赖的场景下,初始化的时候是对A对象本身进行初始化，而容器中以及注入到B中的都是代理对象，这样不会有问题吗？ 不会，这是因为不管是cglib代理还是jdk动态代理生成的代理类，内部都持有一个目标类的引用，当调用代理对象的方法时，实际会去调用目标对象的方法，A完成初始化相当于代理对象自身也完成了初始化
Spring三级缓存为什么要这么设计
笔者看法：实际上一级缓存就可以解决循环依赖的问题，但是如果使用一级缓存的话，处理上会复杂得多，上了锁之后并行就会变成串行，因此Spring设计了二级缓存，二级缓存提高了并发效率，可以见笔者对getSingleton方法的分析（最上面那个），至于三级缓存，三级缓存的设计实际上是为了Spring AOP和Spring IOC解耦，如果只用二级缓存，那么上面的例子中，在注入Bean B之前Bean A就要完成代理，而引入了三级缓存后，完成AOP代理的时机是在的Bean B依赖注入Bean A的时候，通过实现getEarlyReference接口的方法获取代理或者普通对象
