• 2. 糟糕!XmlBeanFactory被废弃了

    对Spring有些了解的应该XmlBeanFactory已经过时了。没错,本篇要讲的XmlBeanFactory在Spring3.1这个很久远版本就开始过时了。

    @deprecated as of Spring 3.1 in favor of {@link DefaultListableBeanFactory}
    

    取而代之的写法如下

    ClassPathResource resource=new ClassPathResource("spring-config.xml");
    DefaultListableBeanFactory beanFactory=new DefaultListableBeanFactory();
    XmlBeanDefinitionReader beanDefinitionReader=new XmlBeanDefinitionReader(beanFactory);
    beanDefinitionReader.loadBeanDefinitions(resource);

    概括DefaultListableBeanFactory + XmlBeanDefinitionReader 取代了 XmlBeanFactory容器的创建和初始化,可以联想到通过组合的方式灵活度是比XmlBeanFactory高的,针对不同的资源读取组合的方式只需替换不同的读取器BeanDefinitionReader就可以了,而XmlBeanFactory中的读取器XmlBeanDefinitionReader限定其只能读取XML格式的文件资源,所以至于XmlBeanFactory被废弃的原因可想而知。

    3. XmlBeanFactory?!XML,你会XML解析吗?

    <?xml version="1.0" encoding=" UTF-8" standalone="yes"?><root>
    <code>0</code>
    <message>调用成功</message>
    </root>

    附上DOM4J解析的代码

    String xml="<?xml version=\"1.0\" encoding=\" UTF-8\" standalone=\"yes\"?><root>\n" +
                    "<code>0</code>\n" +
                    "<message>调用成功</message>\n" +
                    "</root>";
    Document document = DocumentHelper.parseText(xml);
    Element root = document.getRootElement();
    String code = root.elementText("code");
    String message =root.elementText("message");

    XML文档被解析成DOM树,其中Document是整个DOM的根节点,root为根元素,由根元素一层一层向下解析element元素,容器启动解析XML流程就是这样。

    三. XmlBeanFactory启动流程分析

    XmlBeanFactory容器启动就两行代码

    ClassPathResource resource = new ClassPathResource("spring-config.xml");
    XmlBeanFactory beanFactory = new XmlBeanFactory(resource);

    怎么样?看似简单就证明了Java封装的强大,但背后藏了太多。 这里就送上XmlBeanFactory启动流程图,对应的就是上面的两行代码。

    这是啥?!看得头晕的看官老爷们别急着给差评啊(瑟瑟发抖中)。这里精简下,想快速理解的话直接看精简版后的,想深入到细节建议看下上面的时序图。Spring源码解析02:Spring IOC容器之XmlBeanFactory启动流程分析和源码解析-LMLPHP整个就是bean的加载阶段。通过解析XML中的标签元素生成beanDefinition注册到beanDefinitionMap中。

    四. XmlBeanFactory启动源码解析

    按照XmlBeanFactory启动流程的先后顺序整理的关键性代码索引列表,其中一级索引为类,二级索引对应其类下的方法。符号 ---▷表示接口的实现。建议可以观察方法索引的参数变化(资源转换)来分析整个流程,来加深对流程的理解。

  • 好了,当你心里对这个流程有个大概的样子之后,这里就可以继续走下去。建议还是很模糊的同学自重,避免走火入魔想对我人身攻击的。下面就每个方法重要的点一一解析,严格按照方法的执行先后顺序来说明。

    1.1 XmlBeanFactory(Resource resource)

    功能概述: XmlBeanFactory的构造方法,整个容器启动的入口,完成bean工厂的实例化和BeanDefinition加载(解析和注册)。

    /**
     * XmlBeanFactory
     **/

    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }

    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException  {
     super(parentBeanFactory); 
     // 加载(解析注册)BeanDefinition
     this.reader.loadBeanDefinitions(resource);
    }

    知识点:

    2.1 loadBeanDefinitions(Resource resource)

    功能概述: 上面根据ClassPathResource资源访问策略拿到了资源Resource,这里将Resource进行特定的编码处理,然后将编码后的Resource转换成SAX解析XML文件所需要的输入源InputSource。

    /**
     * XmlBeanDefinitionReader
     **/

    public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
     // 把从XML文件读取的Resource资源进行编码处理
        return loadBeanDefinitions(new EncodedResource(resource));
    }

    /**
     * XmlBeanDefinitionReader
     **/

    public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
        ...
        // 完成resource->inputStream->inputSource转换,使用SAX方式接收输入源InputSource解析XML
        try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
            InputSource inputSource = new InputSource(inputStream);
            if (encodedResource.getEncoding() != null) {
                inputSource.setEncoding(encodedResource.getEncoding());
            }
            // 执行加载BeanDefinition
            return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
        }
        ...
    }

    知识点:

    2.2 doLoadBeanDefinitions(InputSource inputSource, Resource resource)

    功能概述: 获取DOM Document对象,XmlBeanDefinitionReader本身没有对文档读取的能力,而是委托给DocumentLoader的实现类DefaultDocumentLoader去读取输入源InputResource从而得到Document对象。获得Document对象后,接下来就是BeanDefinition的解析和注册。

    /**
     * XmlBeanDefinitionReader
     **/

    protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
        throws BeanDefinitionStoreException 
    {
        ...
            try {
                // inputSource->DOM Document
                Document doc = doLoadDocument(inputSource, resource);
                int count = registerBeanDefinitions(doc, resource);
                return count;
            }
        ...
    }

    知识点:

    2.3 registerBeanDefinitions(Document doc, Resource resource)

    功能概述: 解析DOM Document成容器的内部数据接口BeanDefinition并注册到容器内部。

    /**
     * XmlBeanDefinitionReader
     **/

    public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
     BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
     // 已注册的BeanDefinition的数量
        int countBefore = getRegistry().getBeanDefinitionCount();
     // DOM Document->BeanDefinition,注册BeanDefinition至容器
        documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
        // 返回此次注册新增的BeanDefinition数量
     return getRegistry().getBeanDefinitionCount() - countBefore;
    }

    知识点:

    3.1 registerBeanDefinitions(Document doc, XmlReaderContext readerContext)

    功能概述: 在此之前一直 是XML加载解析的准备阶段,在获取到Document对象之后就开始真正的解析了。

    /**
     * DefaultBeanDefinitionDocumentReader
     **/

    public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
     this.readerContext = readerContext;
     doRegisterBeanDefinitions(doc.getDocumentElement());
    }

    3.2 doRegisterBeanDefinitions(Element root)

    功能概述: 解析Element,DefaultBeanDefinitionDoucumentReader同样不具有解析Element的能力,委托给BeanDefinitionParserDelegate执行。

    /**
     * DefaultBeanDefinitionDocumentReader
     **/

    protected void doRegisterBeanDefinitions(Element root) {
        BeanDefinitionParserDelegate parent = this.delegate;
        this.delegate = createDelegate(getReaderContext(), root, parent);
        ...
        // 解析前处理,留给子类实现
     preProcessXml(root);
     parseBeanDefinitions(root, this.delegate);
        // 解析后处理,留给子类实现
     postProcessXml(root);

     this.delegate = parent;
    }

    知识点:

    3.3 parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate)

    功能概述: 判别XML中Bean的声明标签是默认的还是自定义的,执行不同的解析逻辑。对于根节点或者子节点是默认命名空间采用parseDefaultElement,否则使用parseCustomElement对自定义命名空间解析。

    /**
     * DefaultBeanDefinitionDocumentReader
     **/

    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate){
     // 对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标签解析
         parseDefaultElement(ele, delegate);
        }
        else {
                        // 对自定义的Bean标签解析
         delegate.parseCustomElement(ele);
        }
       }
      }
     }
     else {
      delegate.parseCustomElement(root);
     }
    }

    知识点:

  • 3.4 parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate)

    功能概述: 上面说到Spring标签包括默认标签和自定义标签两种。解析这两种方式分别不同。以下就默认标签进行说明BeanDefinitionParseDelegate对Bean标签元素的解析过程。

    /**
     * DefaultBeanDefinitionDocumentReader
     **/

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
            // import标签
      importBeanDefinitionResource(ele);
     }
     else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
            // alias标签
      processAliasRegistration(ele);
     }
     else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
            // bean标签
      processBeanDefinition(ele, delegate);
     }
     else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
      // beans标签
      doRegisterBeanDefinitions(ele);
     }
    }

    知识点:

    3.5 processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate)

    功能概述: 在4中默认标签当中,其中核心的是对bean标签的解析。以下就对bean标签的解析来看解析过程。

    /**
     * DefaultBeanDefinitionDocumentReader
     **/

    protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate){
     BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); // 参考4.1源码
     if (bdHolder != null) {
      bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); // 参考4.2源码
      try {
       BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); // 参考5.1源码
      }
      ...
      // Send registration event.
      getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
     }
    }

    流程解读:

    4.1 registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

    功能概述: 通过BeanDefinitionParseDelegate对Bean标签的解析,解析得到id和name这些信息封装到BeanDefinitionHolder并返回。

    /**
     * BeanDefinitionParseDelegate
     **/

    public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
        return parseBeanDefinitionElement(ele, null);
    }
    /**
     * BeanDefinitionParseDelegate
     **/

    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<>();
      if (StringUtils.hasLength(nameAttr)) {
       String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
       aliases.addAll(Arrays.asList(nameArr));
      }

      String beanName = id;
      if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
       beanName = aliases.remove(0);
      }

      if (containingBean == null) {
       checkNameUniqueness(beanName, aliases, ele);
      }

      AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
       ...
       String[] aliasesArray = StringUtils.toStringArray(aliases);
       return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
      }

    4.2 decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd)

    功能概述: 4.1是对默认标签的属性解析,那如果标签有自定义属性和自定义子节点,这时就要通过decorateBeanDefinitionIfRequired解析这些自定义属性和自定义子节点。

    /**
     * BeanDefinitionParseDelegate
     **/

    public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
        Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd)
     
    {

        BeanDefinitionHolder finalDefinition = originalDef;

        // Decorate based on custom attributes first.
        // 首先对自定义属性解析和装饰
        NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }

        // Decorate based on custom nested elements.
        // 装饰标签下的自定义子节点
        NodeList children = ele.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {
            Node node = children.item(i);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
                finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
            }
        }
        return finalDefinition;
    }

    5.1 registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

    功能概述: 通过beanName注册BeanDefinition至BeanDefinitionMap中去,至此完成Bean标签的解析,转换成Bean在容器中的数据结构BeanDefinition.

    /**
     * BeanDefinitionReaderUtils
     **/

    public static void registerBeanDefinition(
       BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)

      throws BeanDefinitionStoreException 
    {

     // Register bean definition under primary name.
        // 使用beanName注册BeanDefinition
     String beanName = definitionHolder.getBeanName();
      
     registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

     // Register aliases for bean name, if any.
        // 使用别名注册BeanDefiniion
     String[] aliases = definitionHolder.getAliases();
     if (aliases != null) {
      for (String alias : aliases) {
       registry.registerAlias(beanName, alias);
      }
     }
    }

    /**
     * BeanDefinitionParseDelegate
     **/

    public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
       throws BeanDefinitionStoreException 
    {
        ...
        BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
     if (existingDefinition != null) {
         ...
         this.beanDefinitionMap.put(beanName, beanDefinition);
     }else{
         if (hasBeanCreationStarted()) {
       // beanDefinitionMap是全局变量,会存在并发访问问题
       synchronized (this.beanDefinitionMap) {
        this.beanDefinitionMap.put(beanName, beanDefinition);
        List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
        updatedDefinitions.addAll(this.beanDefinitionNames);
        updatedDefinitions.add(beanName);
        this.beanDefinitionNames = updatedDefinitions;
        removeManualSingletonName(beanName);
       }
      }
      else {
       // Still in startup registration phase
       this.beanDefinitionMap.put(beanName, beanDefinition);
       this.beanDefinitionNames.add(beanName);
       removeManualSingletonName(beanName);
      }
      this.frozenBeanDefinitionNames = null;
     }
        ...
    }

    五. 结语

    总结Spring IOC基础容器XmlBeanFactory的启动流程概括如下:

    本篇就XmlBeanFactory容器启动流程分析和源码解析两个角度来对Spring IOC容器有个基础的认识。有了这篇基础,下篇就开始对Spring的扩展容器ApplicationContext进行分析。最后希望大家看完都有所收获,可以的话给个关注,感谢啦。

    六. 附录

    附上我编译好的Spring源码,版本是当前最新版本5.3.0,欢迎star

    spring-framework-5.3.0编译源码

    05-18 12:13