我們都知道Spring中的BeanFactory是一個IOC容器输硝，負責創(chuàng)建Bean和緩存一些單例的Bean對象谭梗，以供項目運行過程中使用。
創(chuàng)建Bean的大概的過程：
- 實例化Bean對象吴汪，為Bean對象在內(nèi)存中分配空間钞楼，各屬性賦值為默認值
- 初始化Bean對象喇闸，為Bean對象填充屬性
- 將Bean放入緩存
首先，容器為了緩存這些單例的Bean需要一個數(shù)據(jù)結(jié)構(gòu)來存儲询件，比如Map {k:name; v:bean}燃乍。
而我們創(chuàng)建一個Bean就可以往Map中存入一個Bean。這時候我們僅需要一個Map就可以滿足創(chuàng)建+緩存的需求宛琅。
但是創(chuàng)建Bean過程中可能會遇到循環(huán)依賴問題刻蟹，比如A對象依賴了一個B對象，而B對象內(nèi)部又依賴了一個A嘿辟，如下：
public class A {
B b;
}
public class B {
A a;
}
假設(shè)A和B我都定義為單例的對象舆瘪，并且需要在項目啟動過程中自動注入，如下：
@Component
public class A {
@Autowired
B b;
}
@Component
public class B {
@Autowired
A a;
}
一級緩存
- 實例化A對象红伦。
- 填充A的屬性階段時需要去填充B對象英古，而此時B對象還沒有創(chuàng)建，所以這里為了完成A的填充就必須要先去創(chuàng)建B對象昙读；
- 實例化B對象召调。
- 執(zhí)行到B對象的填充屬性階段，又會需要去獲取A對象蛮浑，而此時Map中沒有A唠叛，因為A還沒有創(chuàng)建完成，導致又需要去創(chuàng)建A對象沮稚。
- 這樣艺沼，就會循環(huán)往復，一直創(chuàng)建下去壮虫，只到堆棧溢出澳厢。
為什么不能在實例化A之后就放入Map环础？
因為此時A尚未創(chuàng)建完整，所有屬性都是默認值剩拢，并不是一個完整的對象线得，在執(zhí)行業(yè)務時可能會拋出未知的異常。所以必須要在A創(chuàng)建完成之后才能放入Map徐伐。
二級緩存
此時我們引入二級緩存用另外一個Map2 {k:name; v:earlybean} 來存儲尚未已經(jīng)開始創(chuàng)建但是尚未完整創(chuàng)建的對象贯钩。
- 實例化A對象之后，將A對象放入Map2中办素。
- 在填充A的屬性階段需要去填充B對象角雷，而此時B對象還沒有創(chuàng)建，所以這里為了完成A的填充就必須要先去創(chuàng)建B對象性穿。
- 創(chuàng)建B對象的過程中勺三，實例化B對象之后，將B對象放入Map2中需曾。
- 執(zhí)行到B對象填充屬性階段吗坚，又會需要去獲取A對象，而此時Map中沒有A呆万，因為A還沒有創(chuàng)建完成商源，但是我們繼續(xù)從Map2中拿到尚未創(chuàng)建完畢的A的引用賦值給a字段。這樣B對象其實就已經(jīng)創(chuàng)建完整了谋减，盡管B.a對象是一個還未創(chuàng)建完成的對象牡彻。
- 此時將B放入Map并且從Map2中刪除。
- 這時候B創(chuàng)建完成出爹，A繼續(xù)執(zhí)行b的屬性填充可以拿到B對象庄吼，這樣A也完成了創(chuàng)建。
- 此時將A對象放入Map并從Map2中刪除以政。
二級緩存已然解決了循環(huán)依賴問題霸褒，為什么還需要三級緩存？
從上面的流程中我們可以看到使用兩級緩存可以完美解決循環(huán)依賴的問題盈蛮，但是Spring中還有另外一個問題需要解決废菱，這就是初始化過程中的AOP實現(xiàn)。
AOP是Spring的重要功能抖誉，實現(xiàn)方式就是使用代理模式動態(tài)增強類的功能殊轴。
動態(tài)單例目前有兩種技術(shù)可以實現(xiàn)，一種是JDK自帶的基于接口的動態(tài)Proxy技術(shù)袒炉，一種是CGlib基于字節(jié)碼動態(tài)生成的Proxy技術(shù)旁理，這兩種技術(shù)都是需要原始對象創(chuàng)建完畢，之后基于原始對象生成代理對象的我磁。
那么我們發(fā)現(xiàn)孽文，在二級緩存的設(shè)計下驻襟，我們需要在放入緩存Map之前將代理對象生成好。
將流程改為：
- 實例化Bean對象芋哭，為Bean對象在內(nèi)存中分配空間沉衣，各屬性賦值為默認值
- 如果有動態(tài)單例，生成Bean對象的代理Proxy對象
- 初始化Proxy對象减牺，為Bean對象填充屬性
- 將Proxy放入緩存
這樣雖然也可以解決豌习，AOP的問題，但是我們知道Spring中AOP的實現(xiàn)是通過后置處理器BeanPostProcessor機制來實現(xiàn)的拔疚，而后置處理器是在填充屬性結(jié)束后才執(zhí)行的肥隆。流程如下：
- 實例化對象
- 對象填充屬性
- BeanPostProcessor doBefore
- init-method
- BeanPostProcessor doAfter -- AOP是在這個階段實現(xiàn)的
所以要實現(xiàn)上面的方案，勢必需要將BeanPostProcessor階段提前或者侵入到填充屬性的流程中稚失，那么從程序設(shè)計上來說栋艳，這樣做肯定是不美的。
三級緩存
Spring引入了第三級緩存來解決這個問題墩虹， Map3 {k:name v:ObjectFactory} 嘱巾，這個緩存的value就不是Bean對象了，而是一個接口對象由一段lamda表達式實現(xiàn)诫钓。在這段lamda表達式中去完成一些BeanPostProcessor的執(zhí)行。
- 實例化A對象之后篙螟，將A的ObjectFactory對象放入Map3中菌湃。
- 在填充A的屬性階段需要去填充B對象，而此時B對象還沒有創(chuàng)建遍略，所以這里為了完成A的填充就必須要先去創(chuàng)建B對象惧所。
- 創(chuàng)建B對象的過程中，實例化B的ObjectFactory對象之后绪杏，將B對象放入Map2中下愈。
- 執(zhí)行到B對象填充屬性階段，又會需要去獲取A對象蕾久，而此時Map1中沒有A势似，因為A還沒有創(chuàng)建完成，但是我們繼續(xù)從Map2中也拿不到僧著，到Map3中獲取了A的ObjectFactory對象履因，通過ObjectFactory對象獲取A的早期對象，并將這個早期對象放入Map2中盹愚，同時刪除Map3中的A栅迄，將尚未創(chuàng)建完畢的A的引用賦值給a字段。這樣B對象其實就已經(jīng)創(chuàng)建完整了皆怕，盡管B.a對象是一個還未創(chuàng)建完成的對象毅舆。
- 此時將B放入Map并且從Map3中刪除西篓。
- 這時候B創(chuàng)建完成，A繼續(xù)執(zhí)行b的屬性填充可以拿到B對象憋活，這樣A也完成了創(chuàng)建污淋。
- 此時將A對象放入Map并從Map2中刪除。
取自別人家的圖
源碼步驟解析
- SpringBoot項目啟動執(zhí)行到
SpringApplication#run中的refreshContext(context);余掖，最終調(diào)用Spring容器的AbstractApplicationContext#refresh方法寸爆，開始初始化BeanFactory。 - 在
AbstractApplicationContext#refresh步驟中盐欺，執(zhí)行到AbstractApplicationContext#finishBeanFactoryInitialization方法赁豆，開始完成 Bean 工廠初始化。 - 執(zhí)行到
AbstracBeanFactory.preInstantiateSingletons()冗美，開始根據(jù)BeanFactory中的BeanDefinition信息初始化Bean對象魔种。 - 在
AbstracBeanFactory.preInstantiateSingletons()方法中，發(fā)現(xiàn)A對象的BeanDefinition粉洼，執(zhí)行AbstracBeanFactory.getBean方法节预，獲取A對象。 - 在
AbstracBeanFactory.getBean方法中属韧，執(zhí)行AbstracBeanFactory.doGetBean方法安拟，獲取A對象。 - 在
AbstracBeanFactory.doGetBean方法中執(zhí)行DefaultSingletonBeanRegistry#getSingleton方法宵喂，嘗試從緩存中獲取A對象的單例對象緩存糠赦。- 到一級緩存singletonObjects中找，未找到锅棕；
- 到二級緩存earlySingletonObjects中找拙泽，未找到；
- 到三級緩存singletonFactories中找裸燎，未找到顾瞻；
- 再次執(zhí)行
DefaultSingletonBeanRegistry#getSingleton的重載方法，傳入lamda表達式形式的ObjectFactory對象德绿，內(nèi)部調(diào)用AbstractAutowireCapableBeanFactory#createBean方法荷荤，嘗試創(chuàng)建A對象。 - 在
AbstractAutowireCapableBeanFactory#createBean方法中脆炎，調(diào)用AbstractAutowireCapableBeanFactory#doCreateBean方法梅猿，實際執(zhí)行創(chuàng)建A對象。 - 實例化A對象秒裕，給字段賦值默認值后袱蚓，調(diào)用
DefaultSingletonBeanRegistry#addSingletonFactory方法，傳入A對象的lamda表達式形式的ObjectFactory對象几蜻，將ObjectFactory對象放入三級緩存singletonFactories中喇潘，并從2級緩存earlySingletonObjects中移除（雖然這里沒有）体斩，設(shè)置A對象已經(jīng)開始注冊。- 此處傳入的lamda表達式颖低，內(nèi)部調(diào)用了
AbstractAutowireCapableBeanFactory#getEarlyBeanReference絮吵，此方法用來執(zhí)行實現(xiàn)了SmartInstantiationAwareBeanPostProcessor的后置處理器，比如實現(xiàn)AOP的AbstractAutoProxyCreator
- 此處傳入的lamda表達式颖低，內(nèi)部調(diào)用了
- 然后開始執(zhí)行A對象的
AbstractAutowireCapableBeanFactory#populateBean忱屑，進行屬性填充蹬敲。 - 在進行屬性填充時，發(fā)現(xiàn)依賴了B對象莺戒，執(zhí)行
AbstracBeanFactory.getBean方法伴嗡，嘗試獲取B對象。參考上面步驟4~9从铲。 - 執(zhí)行到B對象的屬性填充時瘪校，發(fā)現(xiàn)依賴了A對象，執(zhí)行
AbstracBeanFactory.getBean方法名段，嘗試獲取A對象阱扬。 - 在
AbstracBeanFactory.doGetBean方法中執(zhí)行DefaultSingletonBeanRegistry#getSingleton方法，嘗試從緩存中獲取A對象的單例對象緩存伸辟。- 到一級緩存singletonObjects中找麻惶，未找到；
- 到二級緩存earlySingletonObjects中找自娩，未找到用踩；
- 到三級緩存singletonFactories中找，找到了忙迁，并調(diào)用ObjectFactory的getObject方法獲取A對象的引用，ObjectFactory內(nèi)部調(diào)用了
AbstractAutowireCapableBeanFactory#getEarlyBeanReference碎乃，獲取到A的早期對象姊扔，將A的早期對象放入二級緩存earlySingletonObjects中，并將三級緩存singletonFactories中A對象移除梅誓；
- 這樣拿到A的對象之后恰梢，B的屬性填充完畢，B初始化完成梗掰，方法return到
DefaultSingletonBeanRegistry#getSingleton的重載方法時嵌言，調(diào)用DefaultSingletonBeanRegistry#addSingleton方法，將B對象放入一級緩存及穗，并將B從二三級緩存中移除（雖然已經(jīng)沒有了）摧茴。 - 這樣在return回A的流程，第11步埂陆，將A依賴的B屬性填充完整苛白，此時A也填充完畢娃豹，初始化完成，方法繼續(xù)return到A流程的
DefaultSingletonBeanRegistry#getSingleton的重載方法時购裙，調(diào)用DefaultSingletonBeanRegistry#addSingleton方法懂版，將A對象放入一級緩存，并將A從二三級緩存中移除（此時只有二級緩存中有）躏率。 - 這樣A和B就初始化完成了躯畴。
- 如果A或者B存在AOP，需要返回代理對象薇芝，這操作是在第9步的
AbstractAutowireCapableBeanFactory#getEarlyBeanReference中完成的蓬抄，B嘗試獲取A的時候，觸發(fā)了這個方法恩掷，如果A需要被代理倡鲸，則是在這個方法中執(zhí)行的，這個方法最終返回了一個代理對象黄娘，并將這個對象以A的名義放入了二級緩存峭状。 - 打完收工。
源碼
AbstractApplicationContext#refresh#finishBeanFactoryInitialization 入口類方法 刷新上下文逼争，初始化BeanFactory优床，完成工廠初始化。
DefaultListableBeanFactory#preInstantiateSingletons 準備實例化單例對象
@Override
public void preInstantiateSingletons() throws BeansException {
if (logger.isTraceEnabled()) {
logger.trace("Pre-instantiating singletons in " + this);
}
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
if (isFactoryBean(beanName)) {
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
getBean(beanName);
}
}
}
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize")
.tag("beanName", beanName);
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
smartInitialize.end();
}
}
}
AbstractBeanFactory#getBean(java.lang.String) 獲取bean對象
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
AbstractBeanFactory#doGetBean 實際執(zhí)行獲取bean對象
/**
* Return an instance, which may be shared or independent, of the specified bean.
* @param name the name of the bean to retrieve
* @param requiredType the required type of the bean to retrieve
* @param args arguments to use when creating a bean instance using explicit arguments
* (only applied when creating a new instance as opposed to retrieving an existing one)
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object beanInstance;
// Eagerly check singleton cache for manually registered singletons.
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 + "'");
}
}
beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
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);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
.tag("beanName", name);
try {
if (requiredType != null) {
beanCreation.tag("beanType", requiredType::toString);
}
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
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.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
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;
}
});
beanInstance = 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);
}
beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
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);
}
});
beanInstance = 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 {
beanCreation.end();
}
}
return adaptBeanInstance(name, beanInstance, requiredType);
}
AbstractAutowireCapableBeanFactory.java createBean誓焦、doCreateBean胆敞、getEarlyBeanReference
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
try {
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.
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 {
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);
}
}
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
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 {
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.
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);
}
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) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
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;
}
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;
}
DefaultSingletonBeanRegistry.java 三級緩存
public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
/** 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);
...
/**
* Return the (raw) singleton object registered under the given name.
* <p>Checks already instantiated singletons and also allows for an early
* reference to a currently created singleton (resolving a circular reference).
* @param beanName the name of the bean to look for
* @param allowEarlyReference whether early references should be created or not
* @return the registered singleton object, or {@code null} if none found
*/
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// Quick check for existing instance without full singleton lock
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
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) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
}
}
return singletonObject;
}
}
