<?xml version="1.0" encoding="UTF-8"?>

 <beans xmlns="http://www.springframework.org/schema/beans"

        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd ">

         <bean id="userBean" class="com.luban.springsource.xml.UserBean"></bean>

 </beans>

 public class XmlBeanTest {

     public static void main(String[] args) {

         ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");

         System.out.println(ac.getBean(UserBean.class));

     }

 }

 public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, @Nullable ApplicationContext parent) throws BeansException {

     super(parent);

     this.setConfigLocations(configLocations);

     if (refresh) {

         this.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.

         /**

          * 返回一个factory

          * xml格式的配置文件，是在这个方法中扫描到beanDefinitionMap中的

          * 在org.springframework.web.context.support.XmlWebApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.support.DefaultListableBeanFactory)中会创建一个XmlBeanDefinitionReader来解析xml文件

          * 会把bean.xml解析成一个InputStream,然后再解析成document格式

          * 按照document格式解析，从root节点进行解析，判断root节点是bean？还是beans?还是import等，如果是bean

          * 就把解析到的信息包装成beanDefinitionHolder，然后调用DefaultListablebeanFactory的注册方法将bean放到beanDefinitionMap中

          */

         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.

             //初始化MessageSource组件(该组件在spring中用来做国际化、消息绑定、消息解析)

             initMessageSource();

             // Initialize event multicaster for this context.

             /**

              * 注册一个多事件派发器

              * 先从beanFactory获取，如果没有，就创建一个，并将创建的派发器放到beanFactory中

              */

             initApplicationEventMulticaster();

             // Initialize other special beans in specific context subclasses.

             /**

              * 这是一个空方法，在springboot中，如果集成了Tomcat，会在这里new Tomcat()

              */

             onRefresh();

             // Check for listener beans and register them.

             /**

              * 注册所有的事件监听器

              * 将容器中的时间监听器添加到 applicationEventMulticaster 中

              *

              */

             registerListeners();

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

             /**

              * TODO

              * 完成对bean的实例化

              *

              * 主要的功能都在这里面

              */

             finishBeanFactoryInitialization(beanFactory);

             // Last step: publish corresponding event.

             /**

              * 当容器刷新完成之后，发送容器刷新完成事件

              * publishEvent(new ContextRefreshedEvent(this));

              */

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

         }

     }

 }

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

    BeanDefinitionDocumentReader documentReader = this.createBeanDefinitionDocumentReader();

    int countBefore = this.getRegistry().getBeanDefinitionCount();

    documentReader.registerBeanDefinitions(doc, this.createReaderContext(resource));

    return this.getRegistry().getBeanDefinitionCount() - countBefore;

}

 private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {

         if (delegate.nodeNameEquals(ele, "import")) {

             this.importBeanDefinitionResource(ele);

         } else if (delegate.nodeNameEquals(ele, "alias")) {

             this.processAliasRegistration(ele);

         } else if (delegate.nodeNameEquals(ele, "bean")) {

             this.processBeanDefinition(ele, delegate);

         } else if (delegate.nodeNameEquals(ele, "beans")) {

             this.doRegisterBeanDefinitions(ele);

         }

     }