瞭解過springboot的載入流程的都知道springboot初始化bean都在refresh方法中。這個方法程式碼如下:

// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.新建beanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
 
prepareBeanFactory(beanFactory);
try {
   // Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
   // 載入實現beanFactoryPostProcessor的bean，bean定義的時候執行
invokeBeanFactoryPostProcessors(beanFactory);
 
// Register bean processors that intercept bean creation.
   // 載入實現了beanPostProcessor，在bean例項化前、後執行
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
 
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
   //例項化非懶載入的bean、bean封裝、屬性注入、註解注入(主要使用BeanPostProcessor或子類實現)等
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();

這裡我們主要看下finishBeanfactoryInitialization方法。此方法實現了bean的例項和屬性注入等。進入此方法的最後一行。

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

註釋寫的很清楚，例項化剩餘非懶載入的bean。此方法的實現是核心類DefaultLisListableBeanFactory實現。這個方法中有個判斷：bean是否是beanFactory的實現類。如果是則獲取bean的時候會從beanFactory實現類的getObject中獲取，我們重點看看getBean這個方法。getBean是spring中最重要、最牛逼的方法之一, 具體的邏輯是通過doGetBean方法處理的。我們看下doGetBean方法，方法很長。我們分成幾個部分去看。

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 + "'");
}
   }
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

2、從父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 {
      // No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}

3、直接建立RootBeanDefinition

//mark 給此bean 馬克一下。防止重複建立
if (!typeCheckOnly) {
   markBeanAsCreated(beanName);
}

try {
   final 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);
getBean(dep);
}
   }

4、是singleton還是prototype型別的，根據不同型別去例項化bean,程式碼只貼了單例的型別：

// 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;
}
   });
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

5、檢查bean的型別是否匹配

// 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.isDebugEnabled()) {
         logger.debug("Failed to convert bean '" + name + "' to required type '" +
               ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
      throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}

整個doGetBean方法改成這5個部分，重點看下第4個部分中的createBean和getObjectForBeanInstance方法。

1、createBean方法，裡面主要是2個部分,bean直接是通過BeanPostProcessor的postProcessBeforeIntantiation方法獲取的。註釋也是描述的很清楚:Give BeanPostProcessors a chance to return a proxy instead of the bean instance(英語渣渣不敢瞎翻譯誤導大家，理解就好)，程式碼如下：

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);
}

第一個部分自己實現，那麼createBean方法第2個部分毋庸置疑肯定是spring去例項化bean，程式碼如下：

try {
   Object beanInstance = doCreateBean(beanName, mbdToUse, args);
   if (logger.isDebugEnabled()) {
      logger.debug("Finished creating instance of bean '" + beanName + "'");
}
   return beanInstance;
}

又是do開頭的方法，說明這個也是一個建立方法，spring中一般do開頭的都是用於建立某個物件。跟著程式碼走，看下doCreateBean方法，在檢視此方法之前，可能需要了解下BeanWarpper這個封裝類。bean的封裝、屬性注入等都是用BeanWarpper去完成的。看下程式碼：

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
   instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
   instanceWrapper = createBeanInstance(beanName, mbd, args);
}

進入createBeanInstance方法中，就是呼叫構造器去例項化bean，返回beanWrapper。通過構造器獲取例項程式碼如下：

// Need to determine the constructor...
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
      mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
   return autowireConstructor(beanName, mbd, ctors, args);
}

// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);

這裡例項化我一開始以為就是簡單的反射，後面我點進去時候發現裡面一直提策略例項化，我目前瞭解的是可以解決Override的問題等。如果有興趣的可以自行檢視。到這裡為止。我們終於例項化bean了。下面看下第二步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);
}
}

populateBean方法名稱就暴露他是幹啥的：填充bean。我放一段比較重要的部分：

if (hasInstAwareBpps || needsDepCheck) {
   if (pvs == null) {
      pvs = mbd.getPropertyValues();
}
   PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
   if (hasInstAwareBpps) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvs == null) {
               return;
}
         }
      }
   }
   if (needsDepCheck) {
      checkDependencies(beanName, mbd, filteredPds, pvs);
}
}

這段程式碼貌似沒有什麼注入、填充什麼的，我們看下InstantiationAwareBeanPostProcessor這個介面，發現這個介面有個很熟悉的實現類是：AutowiredAnnotationBeanPostProcessor。這個類的方法中我們看到終於看到了jnject方法。但是在inject之前需要呼叫下findAutowiringMatedata方法獲取一下元資料:

// Fall back to class name as cache key, for backwards compatibility with custom callers.
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
   synchronized (this.injectionMetadataCache) {
      metadata = this.injectionMetadataCache.get(cacheKey);
      if (InjectionMetadata.needsRefresh(metadata, clazz)) {
         if (metadata != null) {
            metadata.clear(pvs);
}
         metadata = buildAutowiringMetadata(clazz);
         this.injectionMetadataCache.put(cacheKey, metadata);
}
   }
}
return metadata;

那麼問題又來了，這個injectionMetadataCache集合值是從那裡來的呢？AutowiredAnnotationBeanPostProcessor實現了MergeBeandefinitionPostProcessor,那麼就好了，肯定是在bean例項的時候呼叫了postProcessMergedBeanDefintion這個方法。果然在doCreateBean方法中有這麼一段：

// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
   if (!mbd.postProcessed) {
      try {
         //通過 BeanPostProcessor將需要註解的元資料 放到Map中
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
      catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
      mbd.postProcessed = true;
}
}

哎，spring縝密啊。元資料有了，下面我們看下element.inject()方法是如何操作的：

if (this.isField) {
   Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));
}
else {
   if (checkPropertySkipping(pvs)) {
      return;
}
   try {
      Method method = (Method) this.member;
ReflectionUtils.makeAccessible(method);
method.invoke(target, getResourceToInject(target, requestingBeanName));
}
   catch (InvocationTargetException ex) {
      throw ex.getTargetException();
}
}

方法簡單明瞭，直接使用反射將值set到屬性中，至此 bean的例項、屬性注入基本完成，下面我們回頭來看doGetBean的另一個方法getObjectForBeanInstance。

2、getObjectForBeanInstance方法。對於是FactoryBean型別的 bean通過getObject獲取到bean的代理例項，跟著方法一直走下去會到getObejct()方法中。

if (System.getSecurityManager() != null) {
   AccessControlContext acc = getAccessControlContext();
   try {
      object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
   catch (PrivilegedActionException pae) {
      throw pae.getException();
}
}
else {
   //從FactoryBean實現bean中getObejct獲取到bean
object = factory.getObject();
}

到此 finishBeanfactoryInitialization方法執行結束！