介绍

1. 本文仅做学习记录，若有不正确的地方，请多多指教
2. Spring版本：5.2.x（代码可能略有不同）

配置文件的加载

测试代码

//替代xmlBeanFactory
//bean工厂
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
//资源管理器
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
//资源 - 配置文件
ClassPathResource resource = new ClassPathResource("DefaultApplicationContext.xml");
//解析bean
reader.loadBeanDefinitions(resource);

准备工作

1. DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

//跟踪代码会发现一共会实例化2个父类
//1. AbstractAutowireCapableBeanFactory
//2. AbstractBeanFactory
//期间，AbstractAutowireCapableBeanFactory的构造器如下
public AbstractAutowireCapableBeanFactory() {
   super();
   //将Class类型加入集合ignoredDependencyInterfaces中 即add操作
   ignoreDependencyInterface(BeanNameAware.class);
   ignoreDependencyInterface(BeanFactoryAware.class);
   ignoreDependencyInterface(BeanClassLoaderAware.class);
}

2. XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

//在XmlBeanFactoryReader构造器中调用了super(registry)父类构造器方法
//以下是父类AbstractBeanFactoryReader构造方法
//ps:DefaultListableBeanFactory实现了BeanFactoryRegistry接口，所以它也是BeanDefinitionRegistry类型
protected AbstractBeanDefinitionReader(BeanDefinitionRegistry registry) {
   Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
   //将DefaultListableBeanFactory赋值给当前类属性
   this.registry = registry;

   // Determine ResourceLoader to use.
   //因为当前beanFactory并没有实现ResourceLoader接口 不能解析xml if进入失败
   if (this.registry instanceof ResourceLoader) {
      this.resourceLoader = (ResourceLoader) this.registry;
   }
   else {
       //PathMatchingResourcePatternResolver是作为资源路径的解析器 支持解析通配符和classpath:等
       //在实例化时，会new DefaultResourceLoader();给成员变量resourceLoader赋值
       //ps：PathMatchingResourcePatternResolver和DefaultResourceLoader都是ResourceLoader的子类
       //DefaultResourceLoader的getResources方法可以获取资源（这里可以当做配置文件）
       //而PathMatchingResourcePatternResolver加入了Ant解析资源路径 所以它的getResources功能相对更强大一些
      this.resourceLoader = new PathMatchingResourcePatternResolver();
   }

   // Inherit Environment if possible
   // DefaultListableBeanFactory也不是Environment子类 所以走else
   if (this.registry instanceof EnvironmentCapable) {
      this.environment = ((EnvironmentCapable) this.registry).getEnvironment();
   }
   else {
       //StandardEnvironment：包含了环境配置数据 如spring.profiles.active
       //但是StandardEnvironment无参构造器并无任何操作 所以这里一切都是默认值 仅做了实例化操作
      this.environment = new StandardEnvironment();
   }
}

3. ClassPathResource resource = new ClassPathResource("DefaultApplicationContext.xml");

//在ClassPathResource单参构造器中调用了以下构造器 其中classLoader默认为null
public ClassPathResource(String path, @Nullable ClassLoader classLoader) {
   Assert.notNull(path, "Path must not be null");
   //对资源路径做一些转换 如window的""转为"/"
   String pathToUse = StringUtils.cleanPath(path);
   //如果以“/”开头 则去除
   if (pathToUse.startsWith("/")) {
      pathToUse = pathToUse.substring(1);
   }
   //记录资源路径
   this.path = pathToUse;
   this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
}

一切准备工作结束，就可以开始解析xml文件了。

XML文件解析（无关代码或步骤将略过）

1. 入口：reader.loadBeanDefinitions(resource)
2. 参数：
- reader：XmlBeanDefinitionReader
- resource：ClassPathResource

public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   //EncodedResource是记录资源编码字符的对象
   //这里实例化EncodedResource 在构造器中仅将resource赋值给了成员变量作以记录 编码字符均默认为null
   return loadBeanDefinitions(new EncodedResource(resource));
}


public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {

   //值得一提的是 resourcesCurrentlyBeingLoaded是ThreadLocal 保存的类型是Set<EncodingResource>类型 默认容量为4
   //这里获取了当前线程所加载过的资源文件
   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

   //如果add失败 则说明当前文件已加载过
   if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException(
            //检测到xx（某资源文件）循环加载
            "Detected cyclic loading of " + encodedResource + " - check your import definitions!");
   }

   //获取当前文件的输入流
   try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
      //inputSource XML实体的单个输入源
      InputSource inputSource = new InputSource(inputStream);
      if (encodedResource.getEncoding() != null) {
         inputSource.setEncoding(encodedResource.getEncoding());
      }
      //加载xml核心逻辑开始 （查看下一代码片段
      return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException(
            "IOException parsing XML document from " + encodedResource.getResource(), ex);
   }
   finally {
      //最后移除当前已加载的文件（再次加载也无影响 不存在循环加载
      currentResources.remove(encodedResource);
      if (currentResources.isEmpty()) {
        //如果当前线程完成了所有资源的加载 则移除LocalThread当前线程数据
         this.resourcesCurrentlyBeingLoaded.remove();
      }
   }
}

/**
  * XML解析核心逻辑
  * param: inputSource 当前资源ClassPathResource输入流
  * param: resource 当前资源ClassPathResource对象
  */
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {

   try {
      //加载xml文件 获取document对象 用于解析xml
      Document doc = doLoadDocument(inputSource, resource);
      //根据返回的document对象注册bean 并返回注册个数
      int count = registerBeanDefinitions(doc, resource);
      if (logger.isDebugEnabled()) {
         logger.debug("Loaded " + count + " bean definitions from " + resource);
      }
      //返回注册个数
      return count;
   }
   catch (xxException ex) {
       //略
   }
}

/**
 * 根据资源获取Document对象
 */
protected Document doLoadDocument(InputSource inputSource, Resource resource) throws Exception {
    //this.documentLoader = new DefaultDocumentLoader(); 默认生成的无参构造器 无任何操作
    //其余参数方法的解析请查看下一代码块
   return this.documentLoader.loadDocument(inputSource, getEntityResolver(), this.errorHandler,
         getValidationModeForResource(resource), isNamespaceAware());
}

//DefaultCocumentLoader类
/**
 * param: inputSource XML实体的单个输入源
 * param: entityResolver -> ResourceEntityResolver 用于解析DTD或XSD的XML文件
 * param：errorHandler 错误处理器
 * param：validationMode XML文件验证模式 这里是XSD（3）
 * param：namespaceAware 为false (true时表示开启解析命名空间）
 */
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
      ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {
   //在factory的创建中 如果验证模式是XSD 则会设置namespaceAware为true 这里是开启了命名空间感知
   //实际类型是生成了com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl
   DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
   if (logger.isTraceEnabled()) {
      logger.trace("Using JAXP provider [" + factory.getClass().getName() + "]");
   }
   //使用factory创建一个 JAXP DocumentBuilder，将使用它来解析 XML 文档
   //com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderImpl
   DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
   //生成com.sun.org.apache.xerces.internal.dom.DeferredDocumentImpl对象
   return builder.parse(inputSource);
}

生成的Document对象：

对于doLoadDocument方法中的参数方法的解释

• getEntityResolver()

/**
* 
* 当解析xml时 需要寻找DTD定义 以便对文档进行验证 而默认的方式是通过声明DTD的uri地址去下载对应文件
* 但是这种方式可能会因为网络原因下载失败而导致报错
* 所以该方法是提供一个寻找DTD声明的方法 即读取本地DTD文件路径
*/
protected EntityResolver getEntityResolver() {
    //初次调用 entityResolver默认为null
   if (this.entityResolver == null) {
      //获取资源加载器 
      //在实例化XmlBeanDefinitionReader时就给resourceLoader赋值了 所以get出来的对象是PathMatchingResourcePatternResolver
      ResourceLoader resourceLoader = getResourceLoader();
      if (resourceLoader != null) {
          //详见下一代码片段
         this.entityResolver = new ResourceEntityResolver(resourceLoader);
      }
      else {
         this.entityResolver = new DelegatingEntityResolver(getBeanClassLoader());
      }
   }
   return this.entityResolver;
}

public ResourceEntityResolver(ResourceLoader resourceLoader) {
    //调用父类DelegatingEntityResolver构造器
   super(resourceLoader.getClassLoader());
   //记录resourceLoader 即PathMatchingResourcePatternResolver
   this.resourceLoader = resourceLoader;
}

public DelegatingEntityResolver(@Nullable ClassLoader classLoader) {
    //初始化dtd文件的解析器
   this.dtdResolver = new BeansDtdResolver();
   //解析META-INF/spring.schemas文件（该路径是默认值）这里边包含了XML所有命名空间对应的xsd文件路径 直接本地获取 无需网络下载
   this.schemaResolver = new PluggableSchemaResolver(classLoader);
}

• getValidationModeForResource(Resource resource)

/**
* 获取验证xml的方式 主要用于验证xml文件格式是否正确 文件是否有效
* 验证XML的方式有两种：
*  1. DTD：需要在XML文件头部声明
*  <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "https://www.springframework.org/dtd/spring-beans-2.0.dtd">
*      意思就是使用spring-beans-2.0.dtd该文件来验证当前文件
*
*  2. XSD：XML Schema语言。该语言用于描述XML文件的结构 也是用于验证XML格式是否正确的
*  xmlns="http://www.springframework.org/schema/beans"
*  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
*  xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
*     http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"
*  xmlns=表示命名空间
*  xsi:schemaLocation=命名空间 + 该命名空间所标识的XML Schema文件位置
*
* 默认验证模式：VALIDATION_AUTO（其实最后返回的默认验证模式是XSD
*/
protected int getValidationModeForResource(Resource resource) {
   //可以通过 setValidationMode设定验证模式
   int validationModeToUse = getValidationMode();//成员变量validationMode 默认VALIDATION_AUTO
   if (validationModeToUse != VALIDATION_AUTO) {
      return validationModeToUse;
   }
   //如果没有【显式】的配置验证模式 则从inputStream中读取XML资源内容获取 VALIDATION_DTD or VALIDATION_XSD
   int detectedMode = detectValidationMode(resource);
   //如果发生了异常 则会返回VALIDATION_AUTO
   if (detectedMode != VALIDATION_AUTO) {
      return detectedMode;
   }
   
   return VALIDATION_XSD;
}

• isNamespaceAware()

public boolean isNamespaceAware() {
/**
 * 该属性在关闭XML验证模式后会设置为true 即开启解析命名空间
 * 以使无验证模式下 仍能正确使用命名空间解析XML文件标签
 */
   return this.namespaceAware;
}

继续执行int count = registerBeanDefinitions(doc, resource);

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    //创建DefaultBeanDefinitionDocumentReader根据“spring-beans”DTD 和 XSD 格式（Spring 的默认 XML bean 定义格式）读取 bean 定义。
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   //registry就是XmlBeanFactory对象 这里是已注册的bean数量 
   //即DefaultListableBeanFactory的beanDefinitionMap属性的长度 默认256的容量 
   int countBefore = getRegistry().getBeanDefinitionCount();//map.size()
   //核心代码 注册bean
   ////createReaderContext方法返回XmlReaderContext对象 俗称文档阅读器
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   //返回注册数 即DefaultListableBeanRegistry的beanDefinitionMap的size - 注册前的size
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

//DefaultBeanDefinitionDocumentReader类方法
public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
    //把文档阅读器赋值给了DefaultBeanDefinitionDocumentReader
   this.readerContext = readerContext;
   //这里的getDocumentElement 返回的是代表Beans标签的com.sun.org.apache.xerces.internal.dom.DeferredElementNSImpl对象(父类Element）
   //beans标签就是spring配置文件的根节点
   doRegisterBeanDefinitions(doc.getDocumentElement());
}

protected void doRegisterBeanDefinitions(Element root) {
   //BeanDefinitionParserDelegate用于解析 XML bean 定义的有状态委托类。供主解析器和任何扩展使用
   BeanDefinitionParserDelegate parent = this.delegate;//第一次为null
   
   //创建BeanDefinitionParserDelegate对象 它包含着一个属性DocumentDefaultsDefinition
   //这个成员属性中包含了当前标签上的定义 如lazy-init值 init-method值
   //并在其中初始化完成BeanDefinitionParserDelegate对象后 触发注册事件来做一些事情（默认为空 开发者自行实现）
   this.delegate = createDelegate(getReaderContext(), root, parent);
   /**
    * 1. 空
    * 2. http://www.springframework.org/schema/beans
    * 校验是否是spring的配置文件
    */
   if (this.delegate.isDefaultNamespace(root)) {//判断是不是beans标签 拿命名空间做比较
      //获取profile属性 配置分离
      String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      //以下是加载不同配置文件的逻辑 若无指定profile 直接跳过
      if (StringUtils.hasText(profileSpec)) {
         String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
               profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
         // We cannot use Profiles.of(...) since profile expressions are not supported
         // in XML config. See SPR-12458 for details.
         if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
            if (logger.isDebugEnabled()) {
               logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                     "] not matching: " + getReaderContext().getResource());
            }
            return;
         }
      }
   }
   //空方法 用于开发者实现
   preProcessXml(root);
   //标签解析开始 （查看下一代码片段
   parseBeanDefinitions(root, this.delegate);
   //空方法 用于开发者实现
   postProcessXml(root);
   //设置当前节点为父节点 进行子节点的遍历
   this.delegate = parent;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
   //
   if (delegate.isDefaultNamespace(root)) {
      //获取子标签 其实是把xml转换成了一行一行的文本
      NodeList nl = root.getChildNodes();
      for (int i = 0; i < nl.getLength(); i++) {
         //顺序获取标签对象 这里不要误解 是获取xml一行一行的文本内容 然后判断当前行是不是标签 或者是空行 又或者是xml注释 
         //如果是标签 则会读取整个标签体内容 封装成标签对象了
         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) {
   //对import标签解析
   if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
      importBeanDefinitionResource(ele);
   }
   //对alias标签解析
   else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
      processAliasRegistration(ele);
   }
   //对bean标签解析 ★ 这里作为我们的入口
   else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
      processBeanDefinition(ele, delegate);
   }
   //对beans标签解析
   else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // recurse
      doRegisterBeanDefinitions(ele);
   }
}

//bean标签的解析
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
   //解析bean标签 见下一代码片段
   BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
   if (bdHolder != null) {
      /**
       * 用于处理自定义属性 适用以下场景
       * <bean id="xx" class="xx">
       *     <custom-element></custom-element>
       * </bean>
       * 再次遍历所有标签 通过命名空间来解析自定义属性
       */
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
      try {
         // Register the final decorated instance. 注册最终的装饰实例 ★
         //这里就是bean要注册进ioc容器的入口了（请查看下一代码块
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         getReaderContext().error("Failed to register bean definition with name '" +
               bdHolder.getBeanName() + "'", ele, ex);
      }
      // Send registration event.发送注册事件。
      // 对注册BeanDefinition事件进行监听 这个方法并未实现 继承EmptyReaderEventListener实现
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
   }
}

/**
 * 参数：
 * ele: bean标签
 * containingBean：null
 */
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
   //获取当前元素的id
   String id = ele.getAttribute(ID_ATTRIBUTE);
   //获取当前元素的name属性
   String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

   //别名数组
   List<String> aliases = new ArrayList<>();
   //如果当前元素有name属性 则使用“,;”拆分
   if (StringUtils.hasLength(nameAttr)) {
      String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
      aliases.addAll(Arrays.asList(nameArr));
   }

   //默认把id为bean注册的name
   String beanName = id;
    //如果当前bean没有指定id作为注册时使用的name 则用name属性定义的第一个名称作为beanName
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
       beanName = aliases.remove(0);
    }

   if (containingBean == null) {
   //官方解释：验证指定的 bean 名称和别名尚未在当前级别的 beans 元素嵌套中使用
      //校验bean名称是否重复 如果不重复 则将beanName及其定义的别名通通加入this.usedName 防止其他bean重名
      checkNameUniqueness(beanName, aliases, ele);
   }

   //bean的所有属性都封装在子类 GenericBeanDefinition中 见下一代码片段
   AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
   if (beanDefinition != null) {
      if (!StringUtils.hasText(beanName)) {
         try {
            if (containingBean != null) {
            //内部bean名称生成
               beanName = BeanDefinitionReaderUtils.generateBeanName(
                     beanDefinition, this.readerContext.getRegistry(), true);
            }
            else {
               beanName = this.readerContext.generateBeanName(beanDefinition);
               // Register an alias for the plain bean class name, if still possible,
               // if the generator returned the class name plus a suffix.
               // This is expected for Spring 1.2/2.0 backwards compatibility.
               String beanClassName = beanDefinition.getBeanClassName();
               if (beanClassName != null &&
                     beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                     !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                  aliases.add(beanClassName);
               }
            }
            if (logger.isTraceEnabled()) {
               logger.trace("Neither XML 'id' nor 'name' specified - " +
                     "using generated bean name [" + beanName + "]");
            }
         }
         catch (Exception ex) {
            error(ex.getMessage(), ele);
            return null;
         }
      }
      //这里的别名是通过name属性指定的 不是alias
      String[] aliasesArray = StringUtils.toStringArray(aliases);
      //返回beanDefinitionHolder对象 这个对象封装了对于bean维度的信息 即GenericBeanDefinition，bean名称，别名
      return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
   }

   return null;
}

public AbstractBeanDefinition parseBeanDefinitionElement(
      Element ele, String beanName, @Nullable BeanDefinition containingBean) {
   //this.parseState是ArrayDeque类型 双队列，BeanEntry对象没什么特别的 就是一个包含了beanName的对象
   //用于存储正在解析的标签 如bean/property等 解析完毕后会弹出 先进先出 这里当作栈来使用
   this.parseState.push(new BeanEntry(beanName));
   
   //记录当前类的class路径
   String className = null;
   if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
      className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
   }

   //bean元素可以指定parent属性 将其作为当前bean的父类 具有继承意义
   String parent = null;
   if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
      parent = ele.getAttribute(PARENT_ATTRIBUTE);
   }

   //以下仅仅是解析工作 并没有真正设置到真实的对象当中
   try {
      //用于创建 承载解析标签得到的所有内容的AbstractBeanDefinition子类的GenericBeanDefinition
      //指定父类名称 如果存在classLoader 则立马加载当前bean(this.readerContext.getBeanClassLoader
      //在xml中可以使用parent属性指定父类引用
      AbstractBeanDefinition bd = createBeanDefinition(className, parent);//这里仅设置了上面获取的parent属性值到GenericBeanDefinition对象中

      //解析bean的各种属性到GenericBeanDefinition 如abstract/auto-wire/depend-on/primary等
      parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
      bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

      //会遍历当前bean的所有子节点 解析当前bean的元数据<meta>标签内容并并封装到GenericBeanDefinition（父类AttributeAccessorSupport的成员属性attributes[map]中
      parseMetaElements(ele, bd);
      
      //解析lookup-method属性 同上
      parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
      
      //解析replaced-method属性 同上
      /**
       * replaced-method
       * A类实现了MethodReplacer类后就可以注册到容器中 当B类中的某个方法xx需要被替换
       *     则在XML中写入
       *        <bean class="B">
       *           <replaced-method name="xx" replacer="A"></replaced-method>
       *         </bean>
       * 这样 方法xx就可以被替换 所以返回值也可能会变化
       */
      parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

      //解析constructor-arg属性
      parseConstructorArgElements(ele, bd);
      
      //解析property属性 把解析出来的属性放在MutablePropertyValues类的propertyValueList[List]中
      //仅解析bean本身 不包括父类
      parsePropertyElements(ele, bd);//如果遇上子元素为bean标签 则进入方法parsePropertySubElement后，重新递归parseBeanDefinitionElement方法进行解析
      
      //解析qualifier属性
      //存储在GenericBeanDefinition的父类AbstractBeanDefinition的qualifiers[map]属性中
      parseQualifierElements(ele, bd);

      bd.setResource(this.readerContext.getResource());
      //设置来源
      bd.setSource(extractSource(ele));

      return bd;
   }
   catch (ClassNotFoundException ex) {
      //略
   }
   finally {
      this.parseState.pop();
   }

   return null;
}

Bean的注册

在上面的方法：processBeanDefinition中，有这段代码：

try {
         // Register the final decorated instance. 注册最终的装饰实例 ★
         //这里就是bean要注册进ioc容器的入口了（请查看下一代码块
         BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
      }
      catch (BeanDefinitionStoreException ex) {
         //略
      }

跟踪代码查看实现：

/**
 * 参数：
 * definitionHolder: 当前bean的BeanDefinitionHolder对象
 * registry: defaultListableBeanFactory
 */
public static void registerBeanDefinition(
      BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
      throws BeanDefinitionStoreException {

   // 当前bean名称
   String beanName = definitionHolder.getBeanName();
   /**
    * 使用beanName将BeanDefinition注册进beanDefinitionMap
    */
   registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

   // 如果有别名 则要注册别名
   String[] aliases = definitionHolder.getAliases();
   if (aliases != null) {
      for (String alias : aliases) {
         /**
          * registerAlias：SimpleAliasRegistry的方法 也是DefaultListableBeanFactory的父类
          * 见下面的代码片段
          */
         registry.registerAlias(beanName, alias);
      }
   }
}

/**
 * 参数：
 * beanName 对象注册bean名称
 * beanDefinition 就是上面用于封装bean所有属性及子标签的GenericBeanDefinition对象
 */
@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");
   //是GenericBeanDefinition对象（AbstractBeanDefinition子类 这里需要对该对象做一次校验
   if (beanDefinition instanceof AbstractBeanDefinition) {
      try {
         /**
          * 这里校验不能同时指定<lookup-method/><replaced-method/>和<factory-method/>二者
          * 并且如果指定了<lookup-method/><replaced-method/> 
          * 则会校验方法是否存在 并给他们的MethodOverride对象上的属性overLoading(是否重载)设为false
          */
         ((AbstractBeanDefinition) beanDefinition).validate();
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
               "Validation of bean definition failed", ex);
      }
   }

//从已注册的bean集合中获取当前beanName的对象
   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
   //不为null 则说明当前bean已经注册过了
   if (existingDefinition != null) {
      //是否允许当前bean覆盖第一个bean(同名情况下) 默认true
      if (!isAllowBeanDefinitionOverriding()) {
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
      }
      //这里开始就无论如何都会覆盖当前已存在的bean 部分日志输出代码省略
     
      //覆盖
      this.beanDefinitionMap.put(beanName, beanDefinition);
   }
   //不存在同名的bean 即当前bean还未被注册
   else {
      //这里去判断在此期间是否有任何 bean 被标记为已创建, 存在则返回true 不存在返回false
      if (hasBeanCreationStarted()) {
          //加锁保证线程安全
         synchronized (this.beanDefinitionMap) {
             //将当前bean注册进beanDefinitionMap
            this.beanDefinitionMap.put(beanName, beanDefinition);
            /**
             * beanDefinitionNames是实例注册的名称排序集合List 按注册先后顺序排列
             * 以下操作就是把当前beanName加入beanDefinitionNames集合中
             */
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
            updatedDefinitions.addAll(this.beanDefinitionNames);
            updatedDefinitions.add(beanName);
            //将当前实例放入map 注册完成
            this.beanDefinitionNames = updatedDefinitions;
            removeManualSingletonName(beanName);
         }
      }
      //还没有实例注册 则当前容器内是空的
      else {
         // Still in startup registration phase
         this.beanDefinitionMap.put(beanName, beanDefinition);
         this.beanDefinitionNames.add(beanName);
         removeManualSingletonName(beanName);
      }
      //缓存beanName的数组清空
      this.frozenBeanDefinitionNames = null;
   }

   /**
    * existingDefinition：若存在同名bean时，该对象是当前对象注册前就已注册的“可能”被覆盖的bean
    * containsSingleton()会去DefaultSingletonBeanRegistry的singletonObjects[map]中查找是否存在
    * 当前bean的单例实例缓存。注意：【singletonObjects是缓存单例实例bean的map集合】
    */
   if (existingDefinition != null || containsSingleton(beanName)) {
      //重置所有beanName对应的缓存
      resetBeanDefinition(beanName);
   }
   else if (isConfigurationFrozen()) {
      //删除关于按类型映射的任何假设
      clearByTypeCache();
   }
}

//别名的注册
public void registerAlias(String name, String alias) {
   //aliasMap: Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
   synchronized (this.aliasMap) {
      if (alias.equals(name)) {
         //如果别名和bean注册名一致 则不保存 其实也是覆盖的一种方式
         this.aliasMap.remove(alias);
         
      }
      else {
         //获取别名注册的beanName
         String registeredName = this.aliasMap.get(alias);
         // 如果当前别名已经被注册
         if (registeredName != null) {
            //如果当前beanName和已经注册的别名的bean名称一致 则返回
            if (registeredName.equals(name)) {
               // An existing alias - no need to re-register 翻译：已存在别名与当前beanName相同 不需要重复注册
               return;
            }
            //如果允许覆盖 则直接覆盖 默认为true
            if (!allowAliasOverriding()) {
               throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                     name + "': It is already registered for name '" + registeredName + "'.");
            }
            
         }
         /**
          * <bean name="B" class="MDJBean.Car"/>
          * <bean name="C" class="MDJBean.Car"/>
          * <alias name="B" alias="A"/>   // B类的名字有两个 一个是B 一个是A 即大名叫B 小名叫A 只要是这两个名字 都可以指向B
          * <alias name="C" alias="B"/>   // C类的名称也有两个 一个是C 一个是B
          * //单单以上是不会报错的 因为别名不同 不出现闭环 getBean("B")返回的是C对象 详见参考获取对象方法（getBean("A")也会返回C对象
          * //假设现在添加一个别名 A可以叫C （同时需要定义一个A的bean 否则这个别名是没用的 也就不存在循环了）
          * <alias name="A" alias="C"/> //那么通过C别名可以找到A名称的类（这时候spring会再次调用getBean("A") 但getBean又会来aliasMap中找 找到A对应的名称是B 以此产生循环
          * 这样就出现了闭环 循环引用
          * 以下方法就是校验防止出现以上情况
          */
         checkForAliasCircle(name, alias);
         //注册别名
         this.aliasMap.put(alias, name);
         if (logger.isTraceEnabled()) {
            logger.trace("Alias definition '" + alias + "' registered for name '" + name + "'");
         }
      }
   }
}