Spring初始化容器—實例化bean對象

        經過AbstractApplicationContext.refresh()方法調用finishBeanFactoryInitialization()方法進行bean的建立。

/**
 * 完成bean的建立
 * Finish the initialization of this context's bean factory,
 * initializing all remaining singleton beans.
 */
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
   // Initialize conversion service for this context.
   if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
         beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
      beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
   }

   // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
   String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
   for (String weaverAwareName : weaverAwareNames) {
      getBean(weaverAwareName);
   }

   // Stop using the temporary ClassLoader for type matching.
   beanFactory.setTempClassLoader(null);

   // Allow for caching all bean definition metadata, not expecting further changes.
   beanFactory.freezeConfiguration();

   //主要完成bean對象的實例化
   // Instantiate all remaining (non-lazy-init) singletons.
   beanFactory.preInstantiateSingletons();
}

        DefaultListableBeanFactory：主要完成bean的實例化、以及存儲XmlBeanDefinitionReader解析resource註冊到beanFactory中的BeanDefinition；數據結構以下：

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
      implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

  //.........................
  
  //存儲由XmlBeanDefinitionReader解析資源文件中的BeanDefinition
   /** Map of bean definition objects, keyed by bean name */
   private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

   /** Map of singleton and non-singleton bean names keyed by dependency type */
   private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);

   /** Map of singleton-only bean names keyed by dependency type */
   private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<Class<?>, String[]>(64);

   /** List of bean definition names, in registration order */
   private final List<String> beanDefinitionNames = new ArrayList<String>();

   /** Whether bean definition metadata may be cached for all beans */
   private boolean configurationFrozen = false;

   /** Cached array of bean definition names in case of frozen configuration */
   private String[] frozenBeanDefinitionNames;
   
   //.....................
}

        初始化單列bean對象，其中bean對象包括普通的bean對象和實現FactoryBean接口的bean對象；經過beanFactory獲取FactoryBean對應的bean對象實際是經過FactoryBean.getObject()方法獲取的。

@Override
public void preInstantiateSingletons() throws BeansException {
   if (this.logger.isDebugEnabled()) {
      this.logger.debug("Pre-instantiating singletons in " + this);
   }
   List<String> beanNames;
   synchronized (this.beanDefinitionMap) {
      // 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.
      beanNames = new ArrayList<String>(this.beanDefinitionNames);
   }
   for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         //判斷bean類型
         if (isFactoryBean(beanName)) {
            //獲取FactoryBean自己須要前綴「&」
            final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
               isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
                  @Override
                  public Boolean run() {
                     return ((SmartFactoryBean<?>) factory).isEagerInit();
                  }
               }, getAccessControlContext());
            }
            else {
               isEagerInit = (factory instanceof SmartFactoryBean &&
                     ((SmartFactoryBean<?>) factory).isEagerInit());
            }
            if (isEagerInit) {
               getBean(beanName);
            }
         }
         else {//普通bean的建立
            getBean(beanName);
         }
      }
   }
}




/**
 * 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 bean類型
 * @param args arguments to use if creating a prototype using explicit arguments to a
 * static factory method. It is invalid to use a non-null args value in any other case. 
 * args是prototype所需的參數
 * @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(
      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
      throws BeansException {

   final String beanName = transformedBeanName(name);
   Object bean;

   // Eagerly check singleton cache for manually registered singletons.
   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 = 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 (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) {
         markBeanAsCreated(beanName);//標記bean已建立
      }

      try {
         //獲取BeanDefinition
         final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         //檢查BeanDefinition是不是Abstract，或者是不是Prototype等處理
         checkMergedBeanDefinition(mbd, beanName, args);

         //獲取bean的依賴
         // Guarantee initialization of beans that the current bean depends on.
         String[] dependsOn = mbd.getDependsOn();
         if (dependsOn != null) {
            for (String dependsOnBean : dependsOn) {
               //判斷循環依賴
               if (isDependent(beanName, dependsOnBean)) {
                  throw new BeanCreationException("Circular depends-on relationship between '" +
                        beanName + "' and '" + dependsOnBean + "'");
               }
               registerDependentBean(dependsOnBean, beanName);
               getBean(dependsOnBean);
            }
         }

         //一、建立SingleBean
         // Create bean instance.
         if (mbd.isSingleton()) {
             //建立單實例bean
            sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
               @Override
               public Object getObject() throws BeansException {
                  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);
         }
         //二、建立PrototypeBean
         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對象，bean爲FactoryBean類型則，經過FactoryBean.getObject()獲取，反之直接返回
            //prototypeInstance
            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 '" + scopeName + "'");
            }
            try {
               Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                  @Override
                  public Object getObject() throws BeansException {
                     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;
      }
   }

   //classType檢查，若bean來下與ClassType不一樣，則進行強制轉換
   // 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;
}


一、建立單實例bean，主要是依賴其父類SingletonBeanRegistry實現；SingletonBeanRegistry數據結構：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

   /**
    * Internal marker for a null singleton object:
    * used as marker value for concurrent Maps (which don't support null values).
    */
   protected static final Object NULL_OBJECT = new Object();

    
   //緩存singleton對象
   private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(64);

   //緩存beanFactory
   /** Cache of singleton factories: bean name --> ObjectFactory */
   private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);

   //緩存earlySingletonObjects，緩存建立的bean以前是否已被緩存過
   /** Cache of early singleton objects: bean name --> bean instance */
   private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

   //緩存全部註冊過的beanName
   /** Set of registered singletons, containing the bean names in registration order */
   private final Set<String> registeredSingletons = new LinkedHashSet<String>(64);

   //當前正被建立的beanName
   /** Names of beans that are currently in creation */
   private final Set<String> singletonsCurrentlyInCreation =
         Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

   //建立被排除的beanname
   /** Names of beans currently excluded from in creation checks */
   private final Set<String> inCreationCheckExclusions =
         Collections.newSetFromMap(new ConcurrentHashMap<String, Boolean>(16));

   /** List of suppressed Exceptions, available for associating related causes */
   private Set<Exception> suppressedExceptions;

   /** Flag that indicates whether we're currently within destroySingletons */
   private boolean singletonsCurrentlyInDestruction = false;

   /** Disposable bean instances: bean name --> disposable instance */
   private final Map<String, Object> disposableBeans = new LinkedHashMap<String, Object>();

   /** Map between containing bean names: bean name --> Set of bean names that the bean contains */
   private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<String, Set<String>>(16);

   //緩存當前bean被全部其餘bean依賴的集合
   /** Map between dependent bean names: bean name --> Set of dependent bean names */
   private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

   //與dependentBeanMap緩存方式相反，緩存當前bean所依賴的全部其餘bean的集合
   /** Map between depending bean names: bean name --> Set of bean names for the bean's dependencies */
   private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<String, Set<String>>(64);

     //..........................method..............
/**
 * Return the (raw) singleton object registered under the given name,
 * creating and registering a new one if none registered yet.
 * @param beanName the name of the bean
 * @param singletonFactory the ObjectFactory to lazily create the singleton
 * with, if necessary
 * @return the registered singleton object
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "'beanName' 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 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 + "'");
         }
         beforeSingletonCreation(beanName);
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<Exception>();
         }
         try {
            //建立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;
            }
            afterSingletonCreation(beanName);
         }
         //將以建立的bean加入緩存singletonObjects中
         addSingleton(beanName, singletonObject);
      }
      return (singletonObject != NULL_OBJECT ? singletonObject : null);
   }
}

}