| 版本 | 内容 | 时间 | | ---- | ---- | -------------------- | | V1 | 新增 | 2023-01-31 22:47:07 | ## 写在前面编写 XML 配置文件配置一些 bean 的信息，这些信息会通过 SAX 解析为 DoCument 文档，解析 XML 的标签转为 BeanDefinition 对象，最后将这些包含 Bean 的一些元信息的 BeanDefinition 注册到注册中心中，后续创建真正的实例就是通过 BeanDefinition 来创建的。 ## 配置文件加载入口测试本篇使用 XmlBeanFactory 作为入口来分析 Spring 是如何加载配置文件的。虽然 XmlBeanFactory 不再直接使用，但是解析配置文件的功能还是一样的流程。下面是测试的一些类，通过该入口分析加载配置文件的流程： ```java public interface UserService { void getUserById(); } public class UserServiceImpl implements UserService{ @Override public void getUserById() { System.out.println("韩梅梅"); } } public class Main { public static void main(String[] args) { BeanFactory ioc = new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml")); UserService userService = ioc.getBean("userService", UserService.class); userService.getUserById(); } } ``` 配置文件 ```xml ``` 接下来就是分析 `new XmlBeanFactory(new ClassPathResource("beanFactoryTest.xml"))` 是如何解析配置文件的了。 ## XmlBeanFactory委托加载 XmlBeanFactory 的源码 ```java public class XmlBeanFactory extends DefaultListableBeanFactory { private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this); public XmlBeanFactory(Resource resource) throws BeansException { this(resource, null); } public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException { super(parentBeanFactory); this.reader.loadBeanDefinitions(resource); } ``` XmlBeanFactory 是 DefaultListableBeanFactory 的一个实现，用于从 XML 文件中读取 BeanDefinition 对象，读取操作委托给内部的 XmlBeanDefinitionReader 对象。 > 注意：这里创建 XmlBeanDefinitionReader 时将当前 XmlBeanFactory 对象作为构造方法的参数传递进去了。 ## 读取资源转为 InputSource 接下来到了`XmlBeanDefinitionReader#loadBeanDefinitions(Resource)` 方法， ```java @Override public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { // 将 resource 包装成带编码格式的 EncodeResource // 调用重载的 loadBeanDefinitions return loadBeanDefinitions(new EncodedResource(resource)); } 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); } // 拿到当前线程已经加载过的所有 EncodedResource 资源 Set currentResources = this.resourcesCurrentlyBeingLoaded.get(); // 添加当前的 EncodedResource 到 ThreadLocal 的 set 中 if (!currentResources.add(encodedResource)) { // 说明当前 EncodedResource 已经加载过，不能重复加载 throw new BeanDefinitionStoreException( "Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } // 获取 EncodedResource 包装的输入流 try (InputStream inputStream = encodedResource.getResource().getInputStream()) { // 将输入流包装成 InputSource，InputSource 是 SAX 中表示资源的对象，它的全路径是org.xml.sax.InputSource InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } // 核心部分：加载 BeanDefinition 的入口 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } catch (IOException ex) { throw new BeanDefinitionStoreException( "IOException parsing XML document from " + encodedResource.getResource(), ex); } finally { // 因为 resourcesCurrentlyBeingLoaded 表示当前线程正在加载的 resource // 执行到这里，当前这个 resource 已经处理完事了，需要从 set 中移除 currentResources.remove(encodedResource); if (currentResources.isEmpty()) { // 防止 ThreadLocal 内存泄漏 this.resourcesCurrentlyBeingLoaded.remove(); } } } ``` 该方法的主要作用就是将我们写的配置文件转为 JDK 中的 InputSource 对象。 ## 加载 BeanDefinition 入口（核心）将配置文件转为 JDK 中的 InputSource 对象后，接下里就是需要解析 XML 文件为 Java 的 Document 对象了。 `XmlBeanDefinitionReader#doLoadBeanDefinitions(InputSource,Resource)` ```java protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { // 将 resource 转换成程序能够识别的带有层次结构的 Document 对象 Document doc = doLoadDocument(inputSource, resource); // 将 Document 解析成 BeanDefinition 并注册到注册中心 int count = registerBeanDefinitions(doc, resource); if (logger.isDebugEnabled()) { logger.debug("Loaded " + count + " bean definitions from " + resource); } // 返回新注册到 BeanFactory 中的 BeanDefinition 数量 return count; } // ... 省略一堆 catch 代码块 } ``` 对于上面的 doLoadDocument 方法，就是通过 SAX 解析 XML 文件，转换为 Java 的 Document 对象。这里没必要去深入研究是如何解析的。拿到带有层次结构的 Document 对象后，就会通过 `XmlBeanDefinitionReader#registerBeanDefinitions(Document, Resource)` 方法将配置文件中定义的一些 Bean 信息解析为 BeanDefinition 并注册到注册中心 XmlBeanFactory 中。 ```java public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 创建一个 BeanDefinitionDocumentReader，每个 Document 对象都会创建一个 BeanDefinitionDocumentReader 对象 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); // getRegistry() 返回程序创建的 BeanFactory 的实例 // countBefore 是解析该 Document 之前，BeanDefinitionFactory 中已有的 BeanDefinition 的数量 int countBefore = getRegistry().getBeanDefinitionCount(); // 解析 Document，并注册到 BeanDefinitionFactory // XMLReaderContext：包含的最主要的参数是，当前 this -> XmlBeanDefinitionReader -> BeanDefinition documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); // 返回新注册的 BeanDefinition 的数量 return getRegistry().getBeanDefinitionCount() - countBefore; } ``` 这个方法主要作用就是反射创建一个 DefaultBeanDefinitionDocumentReader 对象，通过该对象去解析 Document 对象并将其转为 BeanDefinition 对象注册到注册中心。 ## 加载 BeanDefinition（核心） ### 解析 beans 标签入口 `DefaultBeanDefinitionDocumentReader#registerBeanDefinitions(Document,XmlReaderContext)` ```java public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { // 将上下文对象保存到 reader 中 this.readerContext = readerContext; // doc.getDocumentElement() -> 拿出 Document 的顶层标签 -> doRegisterBeanDefinitions(doc.getDocumentElement()); } ``` 这里就是从配置文件的顶层标签 `` 开始解析了。 ### 解析 beans 标签 ```java protected void doRegisterBeanDefinitions(Element root) { // 所有嵌套的标签都会在这个方法里面去递归 // Any nested elements will cause recursion in this method. In // order to propagate and preserve default-* attributes correctly, // keep track of the current (parent) delegate, which may be null. Create // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one. BeanDefinitionParserDelegate parent = this.delegate; // 获取 BeanDefinitionParserDelegate 标签解析器对象，填充一些默认信息，例如设置默认的 init 和 destroy 方法 this.delegate = createDelegate(getReaderContext(), root, parent); // 一般情况下都是默认的，判断当前标签是否是激活的 Profile 环境 if (this.delegate.isDefaultNamespace(root)) { // 获取标签的属性 profile：dev/prod/pre String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE); // 条件成立，说明 beans 标签上的 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. // environment.acceptsProfiles(String...profiles)：条件成立说明 beans 标签可以继续解析成 BeanDefinition // 整个 if 条件成立，说明改 beans 标签不再继续解析 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; } ``` 这个方法大致分为如下几个流程： - 创建一个 BeanDefinitionParserDelegate 委托解析的对象，填充一些默认信息，例如默认的 Bean 的 init 和 destroy 方法； - 判断当前解析的标签的 Profile 属性； - 扩展点：preProcessXml 方法默认空实现，留给子类扩展； - parseBeanDefinitions 方法真正解析 bean 标签； - 扩展点：postProcessXml 方法默认空实现，留个子类扩展； DefaultBeanDefinitionDocumentReader#parseBeanDefinitions 解析 ```java /** * Parse the elements at the root level in the document: * "import", "alias", "bean". * @param root the DOM root element of the document */ protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { // 条件成立，说明当前root 是缺省的 spring 命名空间 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; // 条件成立说明当前子标签是缺省的 spring 命名空间 if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } // 说明标签不是缺省的命名空间，需要走自定义解析 else { delegate.parseCustomElement(ele); } } } } // 说明不是默认的命名空间，需要走自定义的解析 else { delegate.parseCustomElement(root); } } ``` 这个方法主要就是迭代解析 import、alias 和 bean 这些标签，（自定义的命名空间的标签走自定义的解析）。核心就是 DefaultBeanDefinitionDocumentReader#parseDefaultElement 方法： ```java 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 标签前面已经分析到了解析 bean 标签的入口，接下来就是看 Spring 是如何解析 bean 标签并注册到注册中心中。 DefaultBeanDefinitionDocumentReader#processBeanDefinition ```java /** * Process the given bean element, parsing the bean definition * and registering it with the registry. */ protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // 解析完成后返回一个 BeanDefinitionHolder 对象，这个对象主要是保存别名信息 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { // 如果 BeanDefinition 需要装饰的话就去装饰下，主要是处理 bean 标签下面的自定义属性 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)); } } ``` 这个方法主要的步骤是： - 先解析出一个 BeanDefinitionHolder 对象，BeanDefinitionHolder 内部封装 BeanDefinition，包括 bean 标签的所有信息； - 将解析出来的 BeanDefinitionHolder 对象注册到注册中心去，就是存一些 Map 和 List 到内存中，一般就是 beanName 或者别名作为 key；第一步很简单，就是解析 bean 标签的属性和它的子标签，就不跟代码了，解析 bean 标签的代码如下： BeanDefinitionParserDelegate#parseBeanDefinitionElement(Element, String, BeanDefinition) ```java @Nullable public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean) { // 表示当前解析器的状态，因为下面要解析标签，所以状态设置为了 BeanEntry this.parseState.push(new BeanEntry(beanName)); String className = null; // 获取 class 标签，一般情况都包含 class 标签，除非是 bean 标签作为 parent 标签让其他 bean 继承时 if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim(); } String parent = null; if (ele.hasAttribute(PARENT_ATTRIBUTE)) { // 获取 parent 标签 parent = ele.getAttribute(PARENT_ATTRIBUTE); } try { // 就是创建一个 GenericBeanDefinition 对象，设置一下 beanClass/beanClassName AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 解析 bean 标签的一些属性，例如 init-metho，destroy-method 等等 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); // 解析 bean 的子标签 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); // 解析 bean 的子标签 parseMetaElements(ele, bd); // 解析 bean 的子标签 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); // 解析 bean 的子标签 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); // 解析 bean 的子标签 parseConstructorArgElements(ele, bd); // 解析 bean 的子标签 parsePropertyElements(ele, bd); // 解析 bean 的子标签 parseQualifierElements(ele, bd); bd.setResource(this.readerContext.getResource()); bd.setSource(extractSource(ele)); return bd; } catch (ClassNotFoundException ex) { error("Bean class [" + className + "] not found", ele, ex); } catch (NoClassDefFoundError err) { error("Class that bean class [" + className + "] depends on not found", ele, err); } catch (Throwable ex) { error("Unexpected failure during bean definition parsing", ele, ex); } finally { // 弹出最开始压入的元素 this.parseState.pop(); } return null; } ``` 到这里解析 bean 标签就结束了，详情可以自行深入阅读源码。 ### 解析 import、alias、嵌套 beans 标签源码和解析 bean 标签类似，可自行阅读源码。 ## 小结无

02-Spring5核心源码-IOC-加载配置文件.

Dylan Kwok

02-Spring5核心源码-IOC-加载配置文件