Spring IOC学习（6）——DefaultListableBeanFactory

目录

 

简介

项目启动后容器如何初始化所有单例对象

BeanFactory和ApplicationContext的关系

---

简介

DefaultListableBeanFactory已经是一个成熟的容器了，是Spring的默认BeanFactory；
实现了BeanDefinitionRegistry接口，可通过读取配置文件等方式，预先注册所有bean定义；
bean定义：描述bean的作用范围、ROLE等级、是否懒加载、depends-on等信息；这个概念在AbstractBeanFactory才出现，在FactoryBeanRegistrySupport之前都没有

/**
 * 注册bean定义
 */
 @Override
 public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
   throws BeanDefinitionStoreException {

  Assert.hasText(beanName, "Bean name must not be empty");
  Assert.notNull(beanDefinition, "BeanDefinition must not be null");

  if (beanDefinition instanceof AbstractBeanDefinition) {
   try {
    ((AbstractBeanDefinition) beanDefinition).validate();
   }
   catch (BeanDefinitionValidationException ex) {
    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
      "Validation of bean definition failed", ex);
   }
  }

  BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
  if (existingDefinition != null) {
   //已存在同名的bean定义
   if (!isAllowBeanDefinitionOverriding()) {
    //不允许覆盖则抛异常
    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
      "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
      "': There is already [" + existingDefinition + "] bound.");
   }
   else if (existingDefinition.getRole() < beanDefinition.getRole()) {
    // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    // 等级更高的bean定义将被覆盖
    if (logger.isWarnEnabled()) {
     logger.warn("Overriding user-defined bean definition for bean '" + beanName +
       "' with a framework-generated bean definition: replacing [" +
       existingDefinition + "] with [" + beanDefinition + "]");
    }
   }
   else if (!beanDefinition.equals(existingDefinition)) {
    //覆盖前打个日志
    if (logger.isInfoEnabled()) {
     logger.info("Overriding bean definition for bean '" + beanName +
       "' with a different definition: replacing [" + existingDefinition +
       "] with [" + beanDefinition + "]");
    }
   }
   else {
    if (logger.isDebugEnabled()) {
     logger.debug("Overriding bean definition for bean '" + beanName +
       "' with an equivalent definition: replacing [" + existingDefinition +
       "] with [" + beanDefinition + "]");
    }
   }
   //注册
   this.beanDefinitionMap.put(beanName, beanDefinition);
  }

  else {
   if (hasBeanCreationStarted()) {
    //容器已经进入创建bean的阶段，要做同步操作
    // Cannot modify startup-time collection elements anymore (for stable iteration)
    synchronized (this.beanDefinitionMap) {
     this.beanDefinitionMap.put(beanName, beanDefinition);
     List updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
     updatedDefinitions.addAll(this.beanDefinitionNames);
     updatedDefinitions.add(beanName);
     this.beanDefinitionNames = updatedDefinitions;
     if (this.manualSingletonNames.contains(beanName)) {
      Set updatedSingletons = new LinkedHashSet(this.manualSingletonNames);
      updatedSingletons.remove(beanName);
      this.manualSingletonNames = updatedSingletons;
     }
    }
   }
   else {
    //不需考虑同步操作
    // Still in startup registration phase
    this.beanDefinitionMap.put(beanName, beanDefinition);
    this.beanDefinitionNames.add(beanName);
    this.manualSingletonNames.remove(beanName);
   }
   this.frozenBeanDefinitionNames = null;
  }

  if (existingDefinition != null || containsSingleton(beanName)) {
   //清除数据，如已存在的单例对象、子定义等
   resetBeanDefinition(beanName);
  }
 }

/**
 * 移除已注册的bean定义
 */
 @Override
 public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
  Assert.hasText(beanName, "'beanName' must not be empty");

  //移除
  BeanDefinition bd = this.beanDefinitionMap.remove(beanName);
  if (bd == null) {
   if (logger.isTraceEnabled()) {
    logger.trace("No bean named '" + beanName + "' found in " + this);
   }
   throw new NoSuchBeanDefinitionException(beanName);
  }

  if (hasBeanCreationStarted()) {
   //容器已经进入创建bean的阶段，要做同步操作；
   // Cannot modify startup-time collection elements anymore (for stable iteration)
   synchronized (this.beanDefinitionMap) {
    List updatedDefinitions = new ArrayList(this.beanDefinitionNames);
    updatedDefinitions.remove(beanName);
    this.beanDefinitionNames = updatedDefinitions;
   }
  }
  else {
   // Still in startup registration phase
   this.beanDefinitionNames.remove(beanName);
  }
  this.frozenBeanDefinitionNames = null;

  //清除数据，如已存在的单例对象、子定义等
  resetBeanDefinition(beanName);
 }

/**
  * Reset all bean definition caches for the given bean,
  * including the caches of beans that are derived from it.
  * @param beanName the name of the bean to reset
  */
 protected void resetBeanDefinition(String beanName) {
  // Remove the merged bean definition for the given bean, if already created.
  //清除MergedBeanDefinition(?)
  clearMergedBeanDefinition(beanName);

  // Remove corresponding bean from singleton cache, if any. Shouldn't usually
  // be necessary, rather just meant for overriding a context's default beans
  // (e.g. the default StaticMessageSource in a StaticApplicationContext).
  //清除单例
  destroySingleton(beanName);

  // Reset all bean definitions that have the given bean as parent (recursively).
  // 还要清除所有的子定义
  for (String bdName : this.beanDefinitionNames) {
   if (!beanName.equals(bdName)) {
    BeanDefinition bd = this.beanDefinitionMap.get(bdName);
    if (beanName.equals(bd.getParentName())) {
     resetBeanDefinition(bdName);
    }
   }
  }
 }

项目启动后容器如何初始化所有单例对象

//AbstractApplicationContext.refresh
 @Override
 public void refresh() throws BeansException, IllegalStateException {
  synchronized (this.startupShutdownMonitor) {
   // Prepare this context for refreshing.
   prepareRefresh();

   // Tell the subclass to refresh the internal bean factory.
   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.
    invokeBeanFactoryPostProcessors(beanFactory);

    // Register bean processors that intercept bean creation.
    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.
    //准备初始化所有非懒加载的单例对象（默认是非懒加载）
    finishBeanFactoryInitialization(beanFactory);

    // Last step: publish corresponding event.
    finishRefresh();
   }

   catch (BeansException ex) {
    if (logger.isWarnEnabled()) {
     logger.warn("Exception encountered during context initialization - " +
       "cancelling refresh attempt: " + ex);
    }

    // Destroy already created singletons to avoid dangling resources.
    destroyBeans();

    // Reset 'active' flag.
    cancelRefresh(ex);

    // Propagate exception to caller.
    throw ex;
   }

   finally {
    // Reset common introspection caches in Spring's core, since we
    // might not ever need metadata for singleton beans anymore...
    resetCommonCaches();
   }
  }
 }


//AbstractApplicationContext.finishBeanFactoryInitialization
 /**
  * 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));
  }

  // Register a default embedded value resolver if no bean post-processor
  // (such as a PropertyPlaceholderConfigurer bean) registered any before:
  // at this point, primarily for resolution in annotation attribute values.
  if (!beanFactory.hasEmbeddedValueResolver()) {
   beanFactory.addEmbeddedValueResolver(new StringValueResolver() {
    @Override
    public String resolveStringValue(String strVal) {
     return getEnvironment().resolvePlaceholders(strVal);
    }
   });
  }

  // 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();

  // Instantiate all remaining (non-lazy-init) singletons.
  //准备初始化所有非懒加载的单例对象（默认是非懒加载）
  beanFactory.preInstantiateSingletons();
 }


//DefaultListableBeanFactory.preInstantiateSingletons
 @Override
 public void preInstantiateSingletons() throws BeansException {
  if (logger.isDebugEnabled()) {
   logger.debug("Pre-instantiating singletons in " + this);
  }

  // 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.
  List beanNames = new ArrayList(this.beanDefinitionNames);

  // Trigger initialization of all non-lazy singleton beans...
  for (String beanName : beanNames) {
   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    //要进行实例化必须满足三个条件：非抽象类；单例；非懒加载
    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() {
       @Override
       public Boolean run() {
        return ((SmartFactoryBean) factory).isEagerInit();
       }
      }, getAccessControlContext());
     }
     else {
      isEagerInit = (factory instanceof SmartFactoryBean &&
        ((SmartFactoryBean) factory).isEagerInit());
     }
     if (isEagerInit) {
      //如果需要，则也初始化该FactoryBean的产品bean
      getBean(beanName);
     }
    }
    else {
     //对于一般的bean，直接初始化即可
     getBean(beanName);
    }
   }
  }

  // Trigger post-initialization callback for all applicable beans...
  for (String beanName : beanNames) {
   //遍历容器里的bean,如果发现有SmartInitializingSingleton,则执行它的回调方法（一般定义所有单例bean初始化完成后的一些处理）
   Object singletonInstance = getSingleton(beanName);
   if (singletonInstance instanceof SmartInitializingSingleton) {
    final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
    if (System.getSecurityManager() != null) {
     AccessController.doPrivileged(new PrivilegedAction