关于spring:Spring源码解析xml加载流程1

DefaultResourceLoader
AbstractApplicationContext
AbstractRefreshableApplicationContext
AbstractRefreshableConfigApplicationContext
AbstractXmlApplicationContext
ClassPathXmlApplicationContext

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");

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

   // 初始化配置文件 xml 的地位，解析 configLocations，即.xml 文件
   // 办法实现所在位置：父类 AbstractRefreshableConfigApplicationContext
   setConfigLocations(configLocations);
   if (refresh) {
       //spring 容器启动的主流程（***** 重要 *****）// 办法实现所在位置：父类 AbstractApplicationContext
      refresh();}
}
// 此办法所在类：AbstractRefreshableConfigApplicationContext
public void setConfigLocations(@Nullable String... locations) {if (locations != null) {Assert.noNullElements(locations, "Config locations must not be null");
      // 将 xml 文件维护在 configLocations 属性上
      this.configLocations = new String[locations.length];
      for (int i = 0; i < locations.length; i++) {
         //resolvePath 办法波及含糊匹配，先不看
         this.configLocations[i] = resolvePath(locations[i]).trim();}
   }
   else {this.configLocations = null;}
}

/**
 * 该办法是 spring 容器初始化的外围办法。* 是 spring 容器初始化的外围流程，是一个典型的父类模板设计模式的使用
 * 依据不同的上下文对象，会掉到不同的上下文对象子类办法中
 *
 * 外围上下文子类有：* ClassPathXmlApplicationContext
 * FileSystemXmlApplicationContext
 * AnnotationConfigApplicationContext
 * EmbeddedWebApplicationContext(springboot)
 */
@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.
      /*
       * 1、创立 BeanFactory 对象
       * 2、xml 解析
       *    传统标签解析：bean、import 等
       *    自定义标签解析：例如：<context:component-scan base-package="com.xiangxue.jack"/>
       *    自定义标签解析流程：*     a、依据以后解析标签的头信息找到对应的 namespaceUri
       *     b、加载 spring 所以 jar 中的 spring.handlers 文件。并建设映射关系
       *     c、依据 namespaceUri 从映射关系中找到对应的实现了 NamespaceHandler 接口的类
       *     d、调用类的 init 办法，init 办法是注册了各种自定义标签的解析类
       *     e、依据 namespaceUri 找到对应的解析类，而后调用 paser 办法实现标签解析
       * 3、把解析进去的 xml 标签信息封装成 BeanDefinition 对象
       */
      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.
         // 注册 beanFactoryPostProcessor 对象
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         // 注册 beanPostProcessor 实例，在 bean 创立的时候实现拦挡
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         // 国际化，重要水平 2
         initMessageSource();

         // Initialize event multicaster for this context.
         // 初始化工夫治理类
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         // 此办法着重了解模板设计模式，因为在 springboot 中，这个办法是用来做内嵌 tomcat 启动的
         onRefresh();

         // Check for listener beans and register them.
         // 往工夫治理类中注册事件类
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         /*
          * 在之前曾经实例化了 BeanFactoryPostProcessor 以及 beanPostProcessor
          * 上面开始实例化剩下的所有非懒加载的单例对象
          */
         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 办法
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
   // 外围办法，必须读，重要水平：5
   // 此办法是钩子办法，在子类中实现
   refreshBeanFactory();
   return getBeanFactory();}

//AbstractRefreshableApplicationContext(继承 AbstractApplicationContext)
protected final void refreshBeanFactory() throws BeansException {

   // 如果 BeanFactory 不为空，则革除 BeanFactory 和外面的实例
   if (hasBeanFactory()) {destroyBeans();
      closeBeanFactory();}
   try {
      // 创立 DefaultListableBeanFactory
      DefaultListableBeanFactory beanFactory = createBeanFactory();
      beanFactory.setSerializationId(getId());

      // 设置是否能够循环依赖 allowCircularReferences
      // 是否容许应用雷同名称从新注册不同的 bean 实现.
      customizeBeanFactory(beanFactory);

      // 解析 xml，并把 xml 中的标签封装成 BeanDefinition 对象，调用子类办法
      loadBeanDefinitions(beanFactory);
      synchronized (this.beanFactoryMonitor) {this.beanFactory = beanFactory;}
   }
   catch (IOException ex) {throw new ApplicationContextException("I/O error parsing bean definition source for" + getDisplayName(), ex);
   }
}

//AbstractXmlApplicationContext 类（继承 AbstractRefreshableConfigApplicationContext）protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
   // Create a new XmlBeanDefinitionReader for the given BeanFactory.
   // 创立 xml 的解析器，这里是一个委托模式
   XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

   // Configure the bean definition reader with this context's
   // resource loading environment.
   beanDefinitionReader.setEnvironment(this.getEnvironment());

   // 这里传一个 this 进去，因为 ApplicationContext 是实现了 ResourceLoader 接口的
   beanDefinitionReader.setResourceLoader(this);
   beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

   // Allow a subclass to provide custom initialization of the reader,
   // then proceed with actually loading the bean definitions.
   initBeanDefinitionReader(beanDefinitionReader);

   // 次要看这个办法  重要水平 5
   loadBeanDefinitions(beanDefinitionReader);
}
// 以后类
protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {Resource[] configResources = getConfigResources();
   if (configResources != null) {reader.loadBeanDefinitions(configResources);
   }
   // 获取须要加载的 xml 配置文件
   // 在第一步 classPathXmlApplicationContext 结构器中，曾经初始化了 configLocation
   String[] configLocations = getConfigLocations();
   if (configLocations != null) {reader.loadBeanDefinitions(configLocations);
   }
}

//AbstractBeanDefinitionReader 类中办法
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {Assert.notNull(locations, "Location array must not be null");
   int count = 0;
   // 配置文件有多个，加载多个配置文件，循环解析
   for (String location : locations) {
       // 调用以后类的办法
      count += loadBeanDefinitions(location);
   }
   return count;
}

@Override
public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
    // 调用以后类的办法
   return loadBeanDefinitions(location, null);
}
public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {// 之前 AbstractXmlApplicationContext 类中 loadBeanDefinitions() 办法中
   //beanDefinitionReader.setResourceLoader(this); 传入的 this，用于此处拿到上下文对象
   ResourceLoader resourceLoader = getResourceLoader();
   if (resourceLoader == null) {
      throw new BeanDefinitionStoreException("Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
   }

   if (resourceLoader instanceof ResourcePatternResolver) {
      // Resource pattern matching available.
      try {
         // 把字符串类型的 xml 文件门路，形如：classpath*:user/**/*-context.xml, 转换成 Resource 对象类型，其实就是用流
         // 的形式加载配置文件，而后封装成 Resource 对象，不重要，能够不看
         Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

         // 次要看这个办法 ** 重要水平 5
         // 调用以后类的办法 - 重载
         int count = loadBeanDefinitions(resources);
         if (actualResources != null) {Collections.addAll(actualResources, resources);
         }
         if (logger.isTraceEnabled()) {logger.trace("Loaded" + count + "bean definitions from location pattern [" + location + "]");
         }
         return count;
      }
      catch (IOException ex) {
         throw new BeanDefinitionStoreException("Could not resolve bean definition resource pattern [" + location + "]", ex);
      }
   }
   else {
      // Can only load single resources by absolute URL.
      // 这个 Resource 仅仅可能加载单个的绝对路径的 xml 配置文件
      Resource resource = resourceLoader.getResource(location);
      int count = loadBeanDefinitions(resource);
      if (actualResources != null) {actualResources.add(resource);
      }
      if (logger.isTraceEnabled()) {logger.trace("Loaded" + count + "bean definitions from location [" + location + "]");
      }
      return count;
   }
}

public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {Assert.notNull(resources, "Resource array must not be null");
   int count = 0;
   for (Resource resource : resources) {
      // 模板设计模式，调用到子类中的办法
      count += loadBeanDefinitions(resource);
   }
   return count;
}

// 子类 XmlBeanDefinitionReader 中的办法（继承 AbstractBeanDefinitionReader）// 对接口 BeanDefinitionReader 的实现
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
   //EncodedResource 带编码的对 Resource 对象的封装
   return loadBeanDefinitions(new EncodedResource(resource));
}

// 从资源 Resource 中拿到输出流 InputStream，保护到 InputSource 中，而后调用 doLoaderBeanDefinitions 解析
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");
   if (logger.isTraceEnabled()) {logger.trace("Loading XML bean definitions from" + encodedResource);
   }

   Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
   if (currentResources == null) {currentResources = new HashSet<>(4);
      this.resourcesCurrentlyBeingLoaded.set(currentResources);
   }
   if (!currentResources.add(encodedResource)) {
      throw new BeanDefinitionStoreException("Detected cyclic loading of" + encodedResource + "- check your import definitions!");
   }
   try {
      // 获取 Resource 对象中的 xml 文件流对象
      InputStream inputStream = encodedResource.getResource().getInputStream();
      try {
         //InputSource 是 jdk 中的 sax xml 文件解析对象
         InputSource inputSource = new InputSource(inputStream);
         if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());
         }
         // 次要看这个办法 **  重要水平 5-    ***** 加载 beanDefinition*****
         return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
      }
      finally {inputStream.close();
      }
   }
   catch (IOException ex) {
      throw new BeanDefinitionStoreException("IOException parsing XML document from" + encodedResource.getResource(), ex);
   }
   finally {currentResources.remove(encodedResource);
      if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();
      }
   }
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
      throws BeanDefinitionStoreException {

   try {
      // 把 inputSource 封装成 Document 文件对象，这是 jdk 的 API
      Document doc = doLoadDocument(inputSource, resource);

      // 次要看这个办法，依据解析进去的 document 对象，拿到外面的标签元素封装成 BeanDefinition
      int count = registerBeanDefinitions(doc, resource);
      if (logger.isDebugEnabled()) {logger.debug("Loaded" + count + "bean definitions from" + resource);
      }
      return count;
   }
   // 异样此处略去......
}

在 spring 的加载过程中，BeanDefinition 是一个重要的数据结构，它是在创建对象之前，对象数据的一种存在模式
xml —— beanDefinition ——bean 从 xml 配置 bean，到解析 xml 创立 beanDefinition，到从 beanDefinition 实例为 bean 对象，这是一个流程。

//XmlBeanDefinitionReader 类
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
   // 又来一记委托模式，BeanDefinitionDocumentReader 委托这个类进行 document 的解析
   BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
   int countBefore = getRegistry().getBeanDefinitionCount();
   // 次要看这个办法，createReaderContext(resource) XmlReaderContext 上下文，封装了 XmlBeanDefinitionReader 对象
   documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
   return getRegistry().getBeanDefinitionCount() - countBefore;
}

spring 将 xml 文件封装成了 Document 对象，而后委托给 BeanDefinitionDocumentReader 来解析

//DefaultBeanDefinitionDocumentReader（实现 BeanDefinitionDocumentReader 接口）public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
   this.readerContext = readerContext;
   // 次要看这个办法，把 root 节点传进去
   // 注册 beanDefinition，将 document 中 root 元素传入
   doRegisterBeanDefinitions(doc.getDocumentElement());
}

// 委托给 document 的解析器，入参为 document 的根元素，就是 spring-context.xml 的 beans 元素：protected void doRegisterBeanDefinitions(Element root) {
   BeanDefinitionParserDelegate parent = this.delegate;
   this.delegate = createDelegate(getReaderContext(), root, parent);

   if (this.delegate.isDefaultNamespace(root)) {String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
      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);

   // 次要看这个办法，标签具体解析过程
   // 具体的解析 document 对象，注册 beanDefinition 的逻辑在这里实现
   parseBeanDefinitions(root, this.delegate);
   postProcessXml(root);

   this.delegate = parent;
}

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // 判断根元素的命名空间是否为空或者是 xmlns="http://www.springframework.org/schema/beans"
   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)) {
               // 默认标签解析，bean，import 等
               parseDefaultElement(ele, delegate);
            }
            else {
               // 自定义标签解析, context 等
               // a、依据以后解析标签的头信息找到对应的 namespaceUri
               // b、加载 spring 所以 jar 中的 spring.handlers 文件。并建设映射关系
               // c、依据 namespaceUri 从映射关系中找到对应的实现了 NamespaceHandler 接口的类
               // d、调用类的 init 办法，init 办法是注册了各种自定义标签的解析类
               // e、依据 namespaceUri 找到对应的解析类，而后调用 paser 办法实现标签解析
               delegate.parseCustomElement(ele);//*********** 重点
            }
         }
      }
   }
   else {delegate.parseCustomElement(root);
   }
}

上述是启动 spring 流程的第一步，解析配置文件，当然咱们这里是以 xml 配置的形式剖析。也可能是注解配置的办法，后续再来剖析注解形式。
创立 applicationContext 对象，将 xml 文件的门路保护到 AbstractRefreshableApplicationContext 的属性上
refresh 启动 spring 流程，这里是 spring 启动的外围流程
第一步 obtainBeanFactory，这这个办法里，会创立 bean 工厂，加载 xml 文件，委托给 XmlBeanDefinitionReader 解析
XmlBeanDefinitionReader 将 xml 字符串门路封装为 Resource 对象，再转为 InputStream 流，最初把输出流生成 Document 对象，而后委托给 BeanDefinitionDocumentReader 解析。

关于spring:Spring源码解析xml加载流程1

1. 类的层级图

2. spring 容器启动入口，执行胜利容器就启动实现了

3. 进入 ClassPathXmlApplicationContext 类的构造方法

4. spring 容器启动的外围办法 refresh();

5. obtainFreshBeanFactory() 辨析

6. refreshBeanFactory() 辨析

7. loadBeanDefinitions() 辨析

8. 委托给 reader 来解析 reader.loadBeanDefinitions()

9. EncodedResource 带编码的对 Resource 对象的封装，将 inputSource 对象封装成 Documet 对象

10. 解析为 document 对象，之后就要注册 beanDefinition 了

11. 通过上一个委托进行注册 beanDefinition

总结：

Just My Socks（注册教程内含优惠码）

关于spring:Spring源码解析xml加载流程1

1. 类的层级图

2. spring 容器启动入口，执行胜利容器就启动实现了

3. 进入 ClassPathXmlApplicationContext 类的构造方法

4. spring 容器启动的外围办法 refresh();

5. obtainFreshBeanFactory() 辨析

6. refreshBeanFactory() 辨析

7. loadBeanDefinitions() 辨析

8. 委托给 reader 来解析 reader.loadBeanDefinitions()

9. EncodedResource 带编码的对 Resource 对象的封装，将 inputSource 对象封装成 Documet 对象

10. 解析为 document 对象，之后就要注册 beanDefinition 了

11. 通过上一个委托进行注册 beanDefinition

总结：

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）