本篇文章，我們重點看下一個bean是如何被bean工廠實例化的。
在上兩篇文章中，我們對以下3個方法做了流程上的大致分析。
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
//1.會首先調用父類GenericApplicationContext中的構造方法，初始化工廠bean爲new DefaultListableBeanFactory()
//2.調用自己的構造方法，初始化了一個讀取器：AnnotatedBeanDefinitionReader reader；一個掃描器：ClassPathBeanDefinitionScanner scanner
//3.在reader的初始化構造方法中，還註冊了6個post processors
this();
//註冊bean，註冊就是把bean的定義都放在某個地方，一個併發map中，Map<String, BeanDefinition> beanDefinitionMap
//這調用了AnnotatedBeanDefinitionReader reader的註冊方法
register(annotatedClasses);
//實例化bean
refresh();
}
其中refresh()方法中涉及到bean的實例化，發生在BeanFactory中。
比如在2.4.1.1節中，for循環實例化postProcessorName，其中有一行代碼如下：
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class)就是使用bean工廠獲取bean，如果bean還沒有被實例化，這裏會進行實例化，本節就針對此過程進行詳細分析。
1. 默認的bean工廠
第一篇文章spring5源碼閱讀（一）中，在分析this（）方法時，我們知道spring默認初始化的bean工廠默認是DefaultListableBeanFactory。
先看下類圖：
繼承了AbstractBeanFactory，此類實現了bean工廠的大部分接口，包括上面例子中說的getBean方法。
2. getBean方法
AbstractBeanFactory中的getBean，共重寫了如下4種：
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
throws BeansException {
return doGetBean(name, requiredType, args, false);
}
從上述代碼中發現，每種都是基於doGetBean(name, null, args, false)實現的；所以下面我們重點分析doGetBean。
3. doGetBean方法
此方法稍微有點長，拆分一下。
3.1 getSingleton(beanName)
此段邏輯關鍵是getSingleton方法，就是先根據bean的名字從單例池中查詢到bean的單例，如果存在就直接返回了。
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//這裏已經完成了代理方法
//根據bean名字得到單例，就是從一個叫做單例池那個map中get；
// 這裏最開始get出來的肯定是null，因爲我們前面一路分析下來，並沒有發現哪裏往map中put
Object sharedInstance = getSingleton(beanName);
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 + "'");
}
}
// 如果是普通bean直接返回，工廠bean則返回sharedInstance.getObject();
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
} else {
//省略。。。
其中getSingleton方法代碼如下：
public Object getSingleton(String beanName) {
return getSingleton(beanName, true);
}
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//singletonObjects是個map，稱作單例池；將裏面key是beanName的實例取出
Object singletonObject = this.singletonObjects.get(beanName);
//isSingletonCurrentlyInCreation判斷是否正在創建，正在創建的bean都是放在singletonsCurrentlyInCreation的Set中
//只需要看看set集合中有沒有就行了
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
getSingleton的入參allowEarlyReference默認爲true，表示允許循環依賴；
this.singletonObjects表示單例池，是個map，所有實例化的單例都會緩存在這裏。屬於上下文容器的一部分。
this.earlySingletonObjects表示早期bean單例池，這個early的含義就是指bean剛實例化，但是還沒有初始化，比如沒有設置bean的屬性值；用於解決循環依賴。循環依賴的詳細說明，見下一篇文章spring5源碼閱讀（四）如何解決循環依賴
目前這個bean還沒有被實例化過，所以getSingleton返回的是null，繼續進入下一節分析。
3.2 @DependsOn()
從單例池中沒有得到單例，接下來進入else中，
//省略。。。
} 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.
//校驗是否存在bean的定義，這裏是存在的，進不到if中
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 {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
//標記此bean正在或者已經被創建了
markBeanAsCreated(beanName);
}
//省略。。。
這段沒啥好看的，繼續往下，
//省略。。。
try {
//獲取bean的定義描述信息，比如是否單例，註解等信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
//抽象bean不實例化，直接拋異常
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
//這裏是得到用了@DependsOn註解標記的類，就是依賴的類
//確保依賴的bean已經被實例化
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 + "'");
}
//註冊依賴和被依賴關係；就是放到map中
registerDependentBean(dep, beanName);
try {
//實例化依賴bean
getBean(dep);
} catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
//省略。。。
這段是在處理 @DependsOn註解，解決循環依賴。比如有A/B/C 3個類，A類上使用@DependsOn（“b”）,表示A依賴B；
@Component
@DependsOn("b")
public class A {
}
@Component
@DependsOn("c")
public class B {
}
@Component
@DependsOn("a")
public class C {
}
這樣就是A依賴B，B依賴C，C依賴A，形成了循環依賴，這段代碼就是spring判斷是否存在這種情況，存在就會拋異常；
如果不存在循環依賴，但是確實存在依賴的bean，比如在實例化A的時候，發現依賴B，那麼就會先實例化B類。
3.2 createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
上面處理完了通過@DependsOn依賴的bean，接下來就是真正實例化當前bean了。
下面這段代碼主要是判斷將要實例化的bean類型，比如單例/prototype和其他，針對不同的類型進行不同的處理方式。
這裏我們主要針對單例類型進行分析。
第二行getSingleton，上面分析了一種實現，這個方法有好幾個重載，這個方法多了個參數，用來延遲執行createBean。
//省略。。。
// Create bean instance.
if (mbd.isSingleton()) {
//創建出對象
//如果是代理模式，創建代理對象
sharedInstance = getSingleton(beanName, () -> {
//這裏實現了ObjectFactory的getObject()方法
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()) {
// 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 {
String scopeName = mbd.getScope();
final 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 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;
}
}
//省略。。。
3.2.1 getSingleton(String beanName, ObjectFactory<?> singletonFactory)
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//從單例池中取出單例，開始初始化的時候，這個肯定是null
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 + "'");
}
//確保bean之前沒有正在創建中，並記錄狀態
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//這裏開始創建bean實例
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;
}
//之前把正在創建的bean緩存起來了，現在清除緩存
afterSingletonCreation(beanName);
}
if (newSingleton) {
//將新創建的單例bean，放到單例池中
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
3.2.2 createBean()方法
看看 createBean方法，
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("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.
//在bean實例化前後，執行InstantiationAwareBeanPostProcessor 的回調方法，如果有的話
//並返回代理類
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 {
//創建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("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);
}
}
1.判斷是否有自己實現aop，有則創建代理類
2.沒有就調用繼續實例化bean的方法，如果有，比如添加了切面，也會返回代理類。
3.2.2.1 resolveBeforeInstantiation（）
先看Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
此方法作用是，在bean實例化前後，給我們一個機會，去執行實現了InstantiationAwareBeanPostProcessor 的回調方法，如果有實現代理的話，返回代理類。
正常情況下是返回null的，除非我們自己實現了InstantiationAwareBeanPostProcessor的接口方法，並在其中實現了動態代理。
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
//beforeInstantiationResolved一般是null，只要不是false就進入if
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
//isSynthetic判斷是否合成的bean，即不是應用自己定義的bean
//用於判斷beangongc是否有InstantiationAwareBeanPostProcessor後置處理器，用於創建代理的
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
return result;
}
}
}
return null;
}
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
3.2.2.2 doCreateBean（）
上面如果我們沒有自己實現InstantiationAwareBeanPostProcessor接口，那麼代碼就會繼續往下走到doCreateBean方法中。
這個方法是真正創建bean的方法，如果有動態代理，代理類也在這裏創建。
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//實例化，就是使用構造方法創建bean
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//這裏還是target bean
final 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 {
//執行MergedBeanDefinitionPostProcessor回調方法
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.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//用於解決循環依賴的設置
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
//初始化bean
Object exposedObject = bean;
try {
//填充bean的屬性
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 " +
"'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;
}
doCreateBean方法主體流程：
1.首先使用bean的構造方法創建bean；
2.執行MergedBeanDefinitionPostProcessor類型的後置處理器回調方法，利用反射技術，遍歷類中的屬性和方法，並判斷屬性和方法上的註解信息；
比如CommonAnnotationBeanPostProcessor.java，用於發現並緩存@Resource等註解修飾的屬性；
比如AutowiredAnnotationBeanPostProcessor.java，用於發現並緩存@Autowired/@Value等註解修飾的屬性；
等等。
3.提前緩存earlyBeanReference引用，就是實例化還沒初始化的bean信息，用於後邊處理循環依賴。
4.populateBean填充bean，就是初始化bean的屬性值；如果屬性是個bean，此處需要實例化依賴的bean，並緩存到一個叫earlySingletonObjects的map中；
5.initializeBean執行init或者post processors，動態代理也發生在這一步；
6.最終返回創建好的bean對象。
本篇文章就先分析到這裏，循環依賴和動態代理的細節，在後續文章中繼續分析。