Spring
容器幫程序管理Bean
,而實際上最終是由BeanFactory
管理的,本文就具體分析getBean方法。
重載方法
Spring 提供以下方法獲取bean實例,當然大同小異:
getBean
以 傳入 classType爲例,當調用 getBean:204, AbstractBeanFactory
,進入 AbstractBeanFactory
的 getBean
方法:
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
// 第三個參數爲 參數,第四個爲是否檢查
return doGetBean(name, requiredType, null, false);
}
看具體 doGetBean
方法
doGetBean
該方法目的是獲取一個bean實例具體實現。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 獲取bean名稱
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
// 嘗試檢查,該名稱bean是否已經創建過
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
// 不爲空,那麼就說明有循環依賴(circular reference),並且說明可能是不完整的。
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類型,從而判斷是否返回。
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 再一次判斷,是否在循環引用,如果是,那麼就立即失敗
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 首先回去父類裏面找
// 判斷該bean定義,是否真存在與該BeanFactory
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) {
// 將其加入到 alreadyCreated中,說明正在創建。bean從 mergedBeanDefinitions 中暫時去除,以免再次創建。
markBeanAsCreated(beanName);
}
try {
// 從當前類中獲取BeanDefinition。
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 判斷當前bean 類,是否爲抽象類,是就報錯。
checkMergedBeanDefinition(mbd, beanName, args);
// 獲取depensOn,即需要有該類。
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 + "'");
}
// 註冊並放入dependentBeanMap 中
registerDependentBean(dep, beanName);
try {
// 優先獲取 dependon的bean
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 單例模式
if (mbd.isSingleton()) {
// 單例模式下獲取,傳入beanName
sharedInstance = getSingleton(beanName, () -> {
try {
// 創建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()) {
// 原型模式,即每次都創建
Object prototypeInstance = null;
try {
// 直接創建新bean
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 包裝
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 其他模式
String scopeName = mbd.getScope();
// 獲取bean名稱
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
// 調用scope.get,而還是由createBean去創建bean
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 BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 在一次檢查是否匹配,不匹配則報錯。
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;
}
- 獲取bean名稱
transformedBeanName
,會分析是否 以&
從而爲獲取beanfactory
實例。 - 在
getSingleton
中看是否已經創建過時,會分析是否由於循環引用而導致 先創建或者正在創建,具體存儲在DefaultSingletonBeanRegistry
的singletonsCurrentlyInCreation
。最後會返回具體是否由於循環依賴相關信息。 - 再一次判斷是否在創建中,在就立即報錯。
- 如果有 父
BeanFactory
,會首先去父BeanFactory
中尋找。 - 如果
typeCheckOnly
= true 其加入到alreadyCreated
中,說明正在創建。bean從mergedBeanDefinitions
中暫時去除,以免再次創建 - 在獲取
BeanDefinition
過程中,首先會從getMergedLocalBeanDefinition
去獲取,而它主要從mergedBeanDefinitions
獲取。而在第五步中,可能被remove了,所以會再嘗試 從beanDefinitionMap
,再獲取不到就會報錯。最後,又會把獲取到的BeanDefinition
重新放到mergedBeanDefinitions
中。 - 初始化bean時,會校驗
DependOn
類,如果有兩個類,相互DependOn
,則會報錯。如果有且檢查通過,則會將其放入HashSet
的dependentBeanMap
中:而value爲LinkedHashSet
類型。並先會去獲取其依賴想dep
。即要先把依賴項獲取。 - 接下來,通過判斷Spring bean的 scope類型去創建,Spring Bean Scope有以下幾種類型:
- singleton 在Spring的IoC容器中只存在一個對象實例,所有該對象的引用都共享這個實例。默認爲此類型
- prototype 每次http請求將會有各自的bean實例,類似於prototype。
當然,在Spring MVC中,則可能有其他多種類型 - request 每次http請求將會有各自的bean實例,類似於prototype。
- session 在一個http session中,一個bean定義對應一個bean實例。
- global session 在一個全局的http session中,一個bean定義對應一個bean實例。典型情況下,僅在使用portlet context的時候有效。
當然,也可以自己實現org.springframework.beans.factory.config.Scope
,自定義的作用域。
- 單例和原型模式區別,在於單例會首先進入
getSingleton
方法,並且將createBean
方法傳入,而在getSingleton
則會進行相應的檢查。 - 單例模式可以理解爲 一種自定義Scope,最終都是同樣調用方法及步驟。
getSingleton
獲取單例的bean:
- 通過調用
singletonFactory
中具體接口方法創建並初始化bean實例 - 創建前後一些資源佔有和釋放工作。具體可以結合後面兩節看。
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;
}
}
在創建完最後,會將已有單例實例放入相應變量中,便於程序從 BeanFactory
中獲取:
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);
}
}
beforePrototypeCreation
具體方法聲明爲 : public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory)
。
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) {
// 判斷當前BeanFactory是否處於destory狀態。
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 {
// 執行 回調函數,即 createBean
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;
}
}
- 首先會對當前單例加鎖,默認Spring的單例配置有
systemEnvironment
Mapenviroment
StandardEnvironmentsystemProperties
Properties
- 在創建之前,執行
beforeSingletonCreation
會再一次檢查,會判斷是否在inCreationCheckExclusions
創建,並且會放入singletonsCurrentlyInCreation
中。 - 當執行玩createBean回調後,會在final塊 執行
afterSingletonCreation
將2中鎖佔用狀態清除。
createBean
看具體的 創建bean的代碼,以下代碼包含三部分邏輯:
- 創建bean實例
- 實例化bean
- 執行所有 post-processor 例子
@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;
// 獲取bean類
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
// 填充進 beanClass中
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 校驗 override 方法
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 給一個機會 給 InstantiationAwareBeanPostProcessor,即是否自定義bean 生成過程。
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 {
// 執行 doCreateBean 創建。
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);
}
}
- 校驗 beanClass 並填充。
- 校驗 override 方法,即如果判斷
overloaded
中 具體override
數量。 - 執行
resolveBeforeInstantiation
,即當beanFactory
中有InstantiationAwareBeanPostProcessor
時,可以通過InstantiationAwareBeanPostProcessor
返回bean實例
@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// 判斷該beandefinition 不是 jvm生成,並且有 InstantiationAwareBeanPostProcessor.
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 執行所有的 postProcessBeforeInstantiation
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
// 執行所有的 postProcessAfterInitialization
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
- 如果3中沒有創建成功,則會通過
doCreateBean
創建。
doCreateBean
具體的創建邏輯,都在 doCreateBean
中了。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 初始化beanWrapper
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 先從 factoryBeanInstanceCache 移除該beanName。
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 創建 實例
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 執行所有的 `MergedBeanDefinitionPostProcessor`,允許其修改`beanDefinition`
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;
}
}
// 提前緩存單例對象,來解決循環依賴問題,即當前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");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 實例化bean實例。
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
// 完成實例化bean後其他邏輯,例如 填入 相關係統參數 aware,執行所有 postProcessAfterInitialization 方法
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 " +
"'getBeanNamesOfType' 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;
}
- 檢查完
BeanWrapper
後,則會進入createBeanInstance
創建具體bean
實例 - 執行所有的
MergedBeanDefinitionPostProcessor
,允許其修改beanDefinition
- 提前緩存單例對象,來解決循環依賴問題,即當前bean沒有初始化,只是實例化了。
- 執行
populateBean
以完成bean實例化, 其中@Autowired
等注入 參數解析就在這裏。 - 完成實例化bean後其他邏輯,例如 填入 相關係統參數 aware,執行 配置的
init
方法,執行所有postProcessAfterInitialization
方法,如果bean爲InitializingBean
類型,則會執行其afterPropertiesSet
方法 - 判斷是否爲 DisposableBean(停止是回調用),是則需要建立回調。
createBeanInstance
具體選擇性 調用構造方法 創建BeanInstance
過程
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 獲取bean 類
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 校驗類可訪問性
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);
}
// 如果有特定工廠方法,則通過其創建
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// 加鎖,判斷是否在構造方法初有 需要autowired的
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
if (autowireNecessary) {
// 構造方法初有需要注入的 屬性
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 直接創建。
return instantiateBean(beanName, mbd);
}
}
// 判斷構造方法是否需要 通過 SmartInstantiationAwareBeanPostProcessor 獲取。
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 看是否有配置 構造方法
ctors = mbd.getPreferredConstructors();
if (ctors != null) {
return autowireConstructor(beanName, mbd, ctors, null);
}
// 使用默認無參構造方法.
return instantiateBean(beanName, mbd);
}
- 獲取
beanClass
以及校驗其合法性 - 判斷是否有 專屬提供者方法
InstanceSupplier
,有就直接通過其構建 - 判斷是否有工廠方法,若有則從工廠方法中獲取。
- 判斷構造方法,是否需要 注入
@Autowired
,需要則先注入而後再構建。 - 以默認構造方法兜底處理去生成。
afterPrototypeCreation
這個比較簡單,和 方法 beforeSingletonCreation
相呼應,分別爲釋放和佔有資源。
protected void afterSingletonCreation(String beanName) {
if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
}
}
本文有以下幾個問題,大家可以先好好思考:
@Autowired
具體實例過程FactoryBean
類型如何初始化,最後一個方法getObjectForBeanInstance
作用?- Spring 中循環依賴具體解決
覺得博主寫的有用,不妨關注博主公衆號: 六點A君。
哈哈哈,一起研究Spring: