getBean方法在BeanFactory中實現，實現的類有5個
在這5個類中AbstractBeanFactory完成了getBean()方法的具體實現
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws
BeansException {
return doGetBean(name, requiredType, args, false);
}
這幾個方法最終調用的是doGetBean方法
protected <T> T doGetBean(final String name, final Class<T> requiredType,
final Object[] args, boolean typeCheckOnly)
throws BeansException {
//去除&符號，因爲當配置文件中<bean>的class屬性配置的實現類是FactoryBean時，通過 getBean()方法返回的不是FactoryBean本身，
//而是FactoryBean#getObject()方法所返回的對象，相當於FactoryBean#getObject()代理了getBean()方法，如果希望獲取FactoryBean的實例，需要在beanName前加上“&”符號，即getBean("&beanName")
//在這裏要獲取的是bean的實例，所以要去掉&符號
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//-------------------------------------方法1------------------------------------------//
//從緩存中獲取單利的bean
Object sharedInstance = getSingleton(beanName);
//-------------------------------------方法1------------------------------------------//
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//從已經加載的object中獲取bean
//-------------------------------------方法2------------------------------------------//
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
//-------------------------------------方法2------------------------------------------//
}
else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//檢查要獲取的bean是不是當前線程正在創建中的bean
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
//檢查當前BeanFactory的父類BeanFactory是不是不爲空，並且要獲取的bean不包含在當前BeanFactory中
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
//還原要獲取的bean的beanName
String nameToLookup = originalBeanName(name);
//調用parentBeanFactory獲取bean
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
//typeCheckOnly默認爲false
if (!typeCheckOnly) {
//如果當前bean不在正在創建中的bean的緩存集合（alreadyCreated）中，就加進去
markBeanAsCreated(beanName);
}
try {
//合併要獲取的bean的屬性並把屬性賦值給一個RootBeanDefinition
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//檢查合併之後的RootBeanDefinition的是不是抽象的，還會檢查如果獲取bean的參數不空的情況下，bean的類型是singleton的就會報錯，因爲單利情況下bean都是一樣的，只有prototype情況下才能不一致
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//獲取當前bean依賴的bean的名稱的數組
String[] dependsOn = mbd.getDependsOn();
//如果依賴不爲空就先加載依賴到的bean
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
//將要獲取的bean的beanName和所依賴到的bean的beanName之間的關係緩存起來
registerDependentBean(dependsOnBean, beanName);
}
}
// Create bean instance.
//開始創建單利bean實例
if (mbd.isSingleton()) {
//--------------------------------------方法4------------------------------//
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
try {
//--------------------------------------方法3------------------------------//
return createBean(beanName, mbd, args);
//--------------------------------------方法3------------------------------//
}
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;
}
}
});
//--------------------------------------方法4------------------------------//
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//不是單例的情況
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
//將需要創建的bean的beanName放到ThreadLocal中
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//將需要創建的bean的beanName從ThreadLocal中移除
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//其餘類型bean
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
public Object getObject() throws BeansException {
//將需要創建的bean的beanName放到ThreadLocal中
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
//將需要創建的bean的beanName從ThreadLocal中移除
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;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
try {
return getTypeConverter().convertIfNecessary(bean, requiredType);
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean '" + name + "' to required type [" +
ClassUtils.getQualifiedName(requiredType) + "]", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
對上面的標註的方法分別進行解析：
1. getSingleton方法DefaultSingletonBeanRegistry類中，代碼如下
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
//具體實現
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//在已經註冊了的單例map集合（singletonObjects）中獲取特定beanName的bean
Object singletonObject = this.singletonObjects.get(beanName);
//檢查這個bean是不是null，並且這個bean不在正在創建中的bean的map緩存
（singletonsCurrentlyInCreation）中
if(singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//從已經緩存了的單利對象集合中獲取beanName對應的Bean
singletonObject = this.earlySingletonObjects.get(beanName);
//如果不存在，並且允許早期引用當前創建的對象
if(singletonObject == null && allowEarlyReference) {
//根據beanName獲取在可以在調用時返回單例Object實例）的工廠。
ObjectFactory<?> singletonFactory =
this.singletonFactories.get(beanName);
//如果返回的工廠不爲空就把對應的beanName放到earlySingletonObjects中，並移除singletonFactories中的值
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
//如果獲取到的對象是空，就返回null
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
單例在Spring的同一個容器內只會被創建一次，後續在獲取bean，就直接從單例緩存中獲取了。這裏也只是嘗試獲取，首先嚐試從緩存中加載，如果加載不成功則再次嘗試從singletonFactories中加載。因爲在創建單例bean 的時候會存在依賴注入的情況，而在創建依賴的時候爲了避免循環依賴，在Spring中創建bean 的原則是不等bean創建完就會將創建bean 的ObjectFactory提早曝光加入到緩存中，一旦下一個bean創建時候需要依賴上一個bean則直接使用ObjectFactory。
2. getObjectForBeanInstance方法AbstractBeanFactory中
//name：getBean方法傳入的name，beanName：處理過後的name，mbd：null
protected Object getObjectForBeanInstance(Object beanInstance, String name,
String beanName, RootBeanDefinition mbd) {
// Don't let calling code try to dereference the factory if the bean isn't a factory.
//如果要獲取的bean是FactoryBean的引用，並且緩存的對象不是FactoryBean類型。意思就是要獲取的bean實現了FactoryBean（屬於工廠），但是獲取的實例又不是FactoryBean類型的拋錯。bean是否是工廠是由它是否實現FactoryBean接口決定的
if (BeanFactoryUtils.isFactoryDereference(name)
&& !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name),
beanInstance.getClass());
}
// Now we have the bean instance, which may be a normal bean or a FactoryBean.If it's a FactoryBean, we use it to create a bean instance, unless the caller actually wants a reference to the factory.
//如果創建實例不是FactoryBean實例，或者是factoryBean的引用
if (!(beanInstance instanceof FactoryBean) ||
BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
//根據處理過的beanName獲取FactoryBean，上面方法傳進來的mbd爲null
if (mbd == null) {
object = getCachedObjectForFactoryBean(beanName);
}
//如果獲取到的FactoryBean爲空，說明這個bean沒有實現FactoryBean接口
if (object == null) {
// Return bean instance from factory.
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
//如果bean已經加載過，則獲取合併過後的RootBeanDefinition
if (mbd == null && containsBeanDefinition(beanName)) {
//-----------------------------------------合併父類和子類bean------------------------------------------------------//
mbd = getMergedLocalBeanDefinition(beanName);
//-----------------------------------------------------------------------------------------------//
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
//合併父類和子類bean 的方法
//第一步
protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws
BeansException {
// Quick check on the concurrent map first, with minimal locking.
//根據beanName檢查是否存在已經合併過的bean
RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
if (mbd != null) {
return mbd;
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
//第二步
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
BeanDefinition bd) throws BeanDefinitionStoreException {
return getMergedBeanDefinition(beanName, bd, null);
}
//第三步
//containingBd null
protected RootBeanDefinition getMergedBeanDefinition(String beanName,
BeanDefinition bd, BeanDefinition containingBd) throws
BeanDefinitionStoreException {
synchronized (this.mergedBeanDefinitions) {
RootBeanDefinition mbd = null;
// Check with full lock now in order to enforce the same merged instance.
//通過beanName檢查是否已經存在合併過的BeanDefinition
if (containingBd == null) {
mbd = this.mergedBeanDefinitions.get(beanName);
}
if (mbd == null) {
//查看是否存在父bean
if (bd.getParentName() == null) {
// Use copy of given root bean definition.
//如果不存在父bean，並且是RootBeanDefinition類型的bean，就複製一份
RootBeanDefinition並設置給mbd
if (bd instanceof RootBeanDefinition) {
mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
}
//如果不是就把bd中的值複製mbd
else {
mbd = new RootBeanDefinition(bd);
}
}else {
// Child bean definition: needs to be merged with parent.
//如果這個bean是一個子bean，就需要跟父bean進行合併
BeanDefinition pbd;
try {
//處理父bean的beanName
String parentBeanName = transformedBeanName(bd.getParentName());
//如果要過去的bean的beanName於父類的不一樣，就行合併
if (!beanName.equals(parentBeanName)) {
//此方法最終調用的還是getMergedBeanDefinition方法
pbd = getMergedBeanDefinition(parentBeanName);
} else {
if (getParentBeanFactory() instanceof
ConfigurableBeanFactory) {
pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);
}else {
throw new NoSuchBeanDefinitionException(
bd.getParentName(),"Parent name '" + bd.getParentName() + "' is
equal to bean name '" + beanName +
"': cannot be resolved without an AbstractBeanFactory parent");
}
}
}catch (NoSuchBeanDefinitionException ex) {
throw new BeanDefinitionStoreException(
bd.getResourceDescription(), beanName,
"Could not resolve parent bean definition '"
+ bd.getParentName() + "'", ex);
}
// Deep copy with overridden values.
//複製合併之後的屬性到要返回的RootBeanDefinition中
mbd = new RootBeanDefinition(pbd);
//將傳入的BeanDefinition的屬性複製一遍到新的RootBeanDefinition中
mbd.overrideFrom(bd);
}
// Set default singleton scope, if not configured before.
//設置是否單利的
if (!StringUtils.hasLength(mbd.getScope())) {
mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
}
// A bean contained in a non-singleton bean cannot be a singleton itself.
// Let's correct this on the fly here, since this might be the result of
// parent-child merging for the outer bean, in which case the original inner bean
// definition will not have inherited the merged outer bean's singleton status.
//如果外部的bean不是單利的，但是合併之後的bean是單利的那麼就將合併之後的按照外部的bean的單利情況來設定
if (containingBd != null && !containingBd.isSingleton() &&
mbd.isSingleton()) {
mbd.setScope(containingBd.getScope());
}
// Only cache the merged bean definition if we're already about to create an
// instance of the bean, or at least have already created an instance before.
//保存到緩存中
if (containingBd == null && isCacheBeanMetadata() &&
isBeanEligibleForMetadataCaching(beanName)) {
this.mergedBeanDefinitions.put(beanName, mbd);
}
}
return mbd；
}
如果從緩存中得到了bean的原始狀態，則需要對bean進行實例化。緩存中記錄的只是最原始的bean狀態，並不一定是我們最終想要的bean。
假如我們需要對工廠bean進行處理，那麼這裏得到的其實是工廠bean的初始狀態，但是我們正真需要的是工程bean中定義的factory-method方法中返回的bean，而getObjectForBeanInstance就是完成這個工作的
3. 獲取單例對象時候調用DefaultSingletonBeanRegistry類getSingleton方法的第二個參數ObjectFactory實現了ObjectFactory接口的getObject方法，調用的createBean方法，createBean方法在AbstractBeanFactory類中定義，具體實現在AbstractAutowireCapableBeanFactory類中實現
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
// 確保此時實際解析了bean類
//-----------------------------------------------方法1-----------------------------------------------//
resolveBeanClass(mbd, beanName);
//-----------------------------------------------方法1-----------------------------------------------//
// Prepare method overrides.
try {
mbd.prepareMethodOverrides();
}catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//-----------------------------------------------方法2-----------------------------------------------//
//如果bean實現了實例化前處理器接口的，則需要在實例化之前調用這個方法
//bean的生命週期的中實現了InstantiationAwareBeanPostProcessor會在這裏調用實現的postProcessBeforeInstantiation
Object bean = resolveBeforeInstantiation(beanName, mbd);
//-----------------------------------------------方法2-----------------------------------------------//
if (bean != null) {
return bean;
}
}catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//-----------------------------------------------方法3-----------------------------------------------//
Object beanInstance = doCreateBean(beanName, mbd, args);
//-----------------------------------------------方法3-----------------------------------------------//
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
方法1：resolveBeanClass在AbstractBeanFactory中定義
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
throws CannotLoadBeanClassException {
try {
//如果傳入的RootBeanDefinition已經解析過，就直接返回RootBeanDefinition對象中的beanCalss
if (mbd.hasBeanClass()) {
return mbd.getBeanClass();
}
//不管能不能獲取系統安全性都去獲取RootBeanDefinition對象中的class
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged(new PrivilegedExceptionAction<Class<?>>() {
public Class<?> run() throws Exception {
return doResolveBeanClass(mbd, typesToMatch);
}
}, getAccessControlContext());
}
else {
return doResolveBeanClass(mbd, typesToMatch);
}
}catch (PrivilegedActionException pae) {
ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}catch (ClassNotFoundException ex) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
}catch (LinkageError err) {
throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
}
方法2resolveBeforeInstantiation在AbstractAutowireCapableBeanFactory中定義
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
//beforeInstantiationResolved默認爲false
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
//檢查這個bean是不是存在beanClass，是不是不是合成的，是否實現了InstantiationAwareBeanPostProcessor（bean實例化之後但在設置顯式屬性或自動裝配之前的處理）接口
if (mbd.hasBeanClass() && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
//--------------------------方法1-------------------------//
bean = applyBeanPostProcessorsBeforeInstantiation(mbd.getBeanClass(), beanName);
//--------------------------方法1-------------------------//
if (bean != null) {
//--------------------------方法2-------------------------//
//挨個調用postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
//--------------------------方法2-------------------------//
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
//--------------------------方法1-------------------------//
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
//獲取這個bean的所有BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
//如果是InstantiationAwareBeanPostProcessor類型的，就調用實現的方法
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
//調用實現的postProcessBeforeInstantiation方法
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
//--------------------------方法2-------------------------//
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessAfterInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}
4.public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) 方法
這個方法與上面的getSingleton不同之處在於這個方法是在創建了bean對象，並初始化之後調用的，作用是從bean對象中獲取單例的bean同時放到單例緩存中
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
//在已經註冊了的單例map集合（singletonObjects）中獲取特定beanName的bean
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while the 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 + "'");
}
//singletonObjects中獲取不到bean的時候，說明是新創建的bean，這個時候需要先檢查滿足其中一個
//1.當前創建檢查中排除的beanName集合中包含這個創建中的單例beanName
//2.當前正在創建的單例beanName集合中不包含這個單例bean的beanName
beforeSingletonCreation(beanName);
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//從創建的bean中獲取bean對象
singletonObject = singletonFactory.getObject();
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//從當前正在創建的單例beanName集合中刪除當前的beanName
afterSingletonCreation(beanName);
}
//加入到單例緩存中
addSingleton(beanName, singletonObject);
}
//返回單例對象
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}