详实明了的IOC容器的介绍，启动流程以及Bean的实例化和依赖注入

@Override
  public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
  this.readerContext = readerContext;
  logger.debug("Loading bean definitions");
  //读取XML文件
  Element root = doc.getDocumentElement();
  //载入并注册BeanDefinition
  doRegisterBeanDefinitions(root);
  }

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
  if (delegate.isDefaultNamespace(root)) {
    //获取子节点
    NodeList nl = root.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
    Node node = nl.item(i);
    if (node instanceof Element) {
      Element ele = (Element) node;
      if (delegate.isDefaultNamespace(ele)) {
      //解析节点
      parseDefaultElement(ele, delegate);
      }
      else {
      delegate.parseCustomElement(ele);
      }
    }
    }
  }
  else {
    delegate.parseCustomElement(root);
  }
  }

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
  //省略部分非核心代码
  //如果节点是bean节点，说明是一个Bean
  else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
    processBeanDefinition(ele, delegate);
  }
  }

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
  BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
  if (bdHolder != null) {
    bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
    try {
    // Register the final decorated instance.(注册BeanDefinition)
    BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
    }
    catch (BeanDefinitionStoreException ex) {
    getReaderContext().error("Failed to register bean definition with name '" +
      bdHolder.getBeanName() + "'", ele, ex);
    }
    // Send registration event.
    getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
  }
  }

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(256);

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    throws BeanDefinitionStoreException {
    if (hasBeanCreationStarted()) {
    // Cannot modify startup-time collection elements anymore (for stable iteration)
    //加锁，保证线程安全
    synchronized (this.beanDefinitionMap) {
    // 将beanDefinition值设置到beanDefinitionMap中
      this.beanDefinitionMap.put(beanName, beanDefinition);
      List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
      updatedDefinitions.addAll(this.beanDefinitionNames);
      updatedDefinitions.add(beanName);
      this.beanDefinitionNames = updatedDefinitions;
      if (this.manualSingletonNames.contains(beanName)) {
      Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
      updatedSingletons.remove(beanName);
      this.manualSingletonNames = updatedSingletons;
      }
    }
    }
    else {
    // Still in startup registration phase，将beanDefinition值设置到beanDefinitionMap中
    this.beanDefinitionMap.put(beanName, beanDefinition);
    this.beanDefinitionNames.add(beanName);
    this.manualSingletonNames.remove(beanName);
    }
    this.frozenBeanDefinitionNames = null;
    }

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
  // Instantiate the bean（实例化Bean）
  BeanWrapper instanceWrapper = null;
  if (mbd.isSingleton()) {
    //如果是单例Bean,首先清理FactoryBean缓存
    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  }
  if (instanceWrapper == null) {
    //使用特定的策略实例化Bean,如果工厂方法、构造器等，将BeanDefinition转换为BeanWrapper
    instanceWrapper = createBeanInstance(beanName, mbd, args);
  }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
  Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
  // Allow post-processors to modify the merged bean definition. 允许MergedBeanDefinitionPostProcessor修改BeanDefinition
   synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                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.
  //需要提前暴露Bean的条件：单例&&允许循环依赖&&当前Bean正在创建中，检测到了循环依赖
   boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        //对于需要提前暴露的Bean,以其ObjectFactory的形式放入singletonFactories中,以解决循环依赖的问题
        //ObjectFactory所创建的Bean由getEarlyBeanReference()方法指定
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
  // Initialize the bean instance. Bean的初始化
  Object exposedObject = bean;
    try {
        //对Bean进行属性的填充。此外,如果依赖了其他Bean,则会在这里注入依赖
        populateBean(beanName, mbd, instanceWrapper);
        //执行Bean的初始化方法,如配置的init-method等
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
  //循环依赖检查
    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();
                }
            }
        }
    }
    try {
        //注册Bean的销毁方法,如destroy-method
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    return exposedObject;
}
}

@Override
  public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
  //省略部分代码
  // Don't override the class with CGLIB if no overrides.
  if (bd.getMethodOverrides().isEmpty()) {
    //通过构造器实例化Bean  
    return BeanUtils.instantiateClass(constructorToUse);
  }
  else {
    // Must generate CGLIB subclass.(通过CGLIB的方式生成Bean)
    return instantiateWithMethodInjection(bd, beanName, owner);
  }
  }

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
    //类型转换接口
    TypeConverter converter = getCustomTypeConverter();
  if (converter == null) {
    converter = bw;
  }
  BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
  String propertyName = pv.getName();
                  //对于ref来说就是beanName,对于value 来说就是value
    Object originalValue = pv.getValue();
    Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
    boolean convertible = bw.isWritableProperty(propertyName) &&
      !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
    if (convertible) {
      convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
    }
  try {
    //设置依赖属性
    bw.setPropertyValues(new MutablePropertyValues(deepCopy));
  }
  catch (BeansException ex) {
    throw new BeanCreationException(
      mbd.getResourceDescription(), beanName, "Error setting property values", ex);
  }
  }
  private Object convertForProperty(Object value, String propertyName, BeanWrapper bw, TypeConverter converter) {
  if (converter instanceof BeanWrapperImpl) {
    return ((BeanWrapperImpl) converter).convertForProperty(value, propertyName);
  }
  else {
    PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
    MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
    return converter.convertIfNecessary(value, pd.getPropertyType(), methodParam);
  }
  }