spring源码-2-xml标签的解析

xml解析- 解析beandefinition

DefaultBeanDefinitionDocumentReader 解析

            对xml注册后，spring对xml的标签进行拆分解析，由bean -》属性解析 -》子bean解析-》完成解析
    

doRegisterBeanDefinitions 注册beandefinition

//  profile 
protected void doRegisterBeanDefinitions(Element root) {
        BeanDefinitionParserDelegate parent = this.delegate; //定义xml node 各个节点
        this.delegate = createDelegate(getReaderContext(), root, parent);

        if (this.delegate.isDefaultNamespace(root)) {
            //处理profile 属性
            String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
            if (StringUtils.hasText(profileSpec)) {
                //解析 ,: 切割
                String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
                        profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
                if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
                                "] not matching: " + getReaderContext().getResource());
                    }
                    return;
                }
            }
        }
        preProcessXml(root);  //空方法 ， 模板设计模式预留给子类实现。
        //解析beandefinition
        //解析各个节点 node 对bean 的处理 （各种标签 beans import 等）
        parseBeanDefinitions(root, this.delegate);
        postProcessXml(root); 

        this.delegate = parent;
    }

parseBeanDefinitions 判断解析方式 默认方式 /自定义方式 （可扩展性）

//从命名空间判断处理方式  可扩展性，采用自己的解析方式  如阿里  springext （spring扩展）
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        //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)) {
                        parseDefaultElement(ele, delegate);  //处理默认element
                    }
                    else {
                        delegate.parseCustomElement(ele);  //委托处理自定义element
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);//委托处理自定义element
        }
    }

parseDefaultElement 默认解析方式 （默认标签 bean alias import 等）

//默认解析
    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);  //beans  进入第一步分析的注册beandefinition 
        }
    }

processBeanDefinition 开始解析bean标签

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        //委托标签解析类解析，返回解析bean标签后的属性等信息
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            //若没有自定义属性直接返回，有自定义属性则解析
            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.
            //XmlReaderContext   发出响应  由监听器监听bean的解析完成
            getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

parseBeanDefinitionElement id name 属性解析 继续解析其它属性

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
        String id = ele.getAttribute(ID_ATTRIBUTE);  //id 属性
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  //name 属性

        List<String> aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            //以，；切割 name属性
            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 (logger.isDebugEnabled()) {
                logger.debug("No XML 'id' specified - using '" + beanName +
                        "' as bean name and " + aliases + " as aliases");
            }
        }

        if (containingBean == null) {
            checkNameUniqueness(beanName, aliases, ele);  //检查beanname 是否重复
        }
        //其它bean的属性解析 后续复杂属性会慢慢拆分到各个方法中解析
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            if (!StringUtils.hasText(beanName)) {
                try {
                    //没有beanname  由spring生成
                    if (containingBean != null) {
                        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.isDebugEnabled()) {
                        logger.debug("Neither XML 'id' nor 'name' specified - " +
                                "using generated bean name [" + beanName + "]");
                    }
                }
                catch (Exception ex) {
                    error(ex.getMessage(), ele);
                    return null;
                }
            }
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }

        return null;
    }