Spring源码阅读——ClassPathXmlApplicationContext（三）

摘要：在上一篇源码阅读二文章的最后，需要解析元素，创建实例完成必须的装配和进行最终的注册来完成元素的解析和注册，下面分别阅读三步的源码。

在上一篇Spring源码阅读——ClassPathXmlApplicationContext（二）文章的最后，需要解析bean元素，创建BeanDefinitionHolder实例、完成必须的装配和进行最终的注册bean来完成bean元素的解析和注册，下面分别阅读三步的源码。

BeanDefinitionHolder的创建是委托给BeanDefinitionParserDelegate这个代理类的parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean)方法来完成的，此方法的实现如下：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
        // 获取id属性值
        String id = ele.getAttribute(ID_ATTRIBUTE);
        // 获取name属性值
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
        //解析name属性值，将所有name放入List中
        List aliases = new ArrayList<>();
        if (StringUtils.hasLength(nameAttr)) {
            String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
            aliases.addAll(Arrays.asList(nameArr));
        }
        // 赋值beanName为id
        String beanName = id;
        if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
            // 如果id为空，且name属性不为空，取第一个name为beanName
            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);
        }
        // 解析bean元素
        AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
        if (beanDefinition != null) {
            // 如果beanName为空
            if (!StringUtils.hasText(beanName)) {
                try {
                    if (containingBean != null) {
                        // 生成默认的beanName
                        beanName = BeanDefinitionReaderUtils.generateBeanName(
                                beanDefinition, this.readerContext.getRegistry(), true);
                    }
                    else {
                        // 生成默认的beanName
                        beanName = this.readerContext.generateBeanName(beanDefinition);
                        // 通过beanClass生成一个alias
                        String beanClassName = beanDefinition.getBeanClassName();
                        if (beanClassName != null &&
                                beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
                                !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
                            aliases.add(beanClassName);
                        }
                    }
                }
                catch (Exception ex) {
                    error(ex.getMessage(), ele);
                    return null;
                }
            }
            // 得到别名数组
            String[] aliasesArray = StringUtils.toStringArray(aliases);
            // 创建BeanDefinitionHolder对象并返回
            return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
        }

        return null;
    }

在上述源码中，调用了parseBeanDefinitionElement(ele, beanName, containingBean)方法创建AbstractBeanDefinition 实例，下面是此方法的实现：

public AbstractBeanDefinition parseBeanDefinitionElement(
            Element ele, String beanName, @Nullable BeanDefinition containingBean) {
        // 根据beanName创建BeanEntry实体，并且push BeanEntry
        this.parseState.push(new BeanEntry(beanName));
        // 获取class属性值
        String className = null;
        if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
            className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
        }
        // 获取parent属性值
        String parent = null;
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }

        try {
            // 创建AbstractBeanDefinition实例
            AbstractBeanDefinition bd = createBeanDefinition(className, parent);
            // 设置AbstractBeanDefinition实例的其他各种属性
            parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
            // 获取子元素description
            bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            // 获取子元素meta
            parseMetaElements(ele, bd);
            // 解析子元素lookup-method
            parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
            // 解析子元素replaced-method
            parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
            // 解析子元素constructor-arg
            parseConstructorArgElements(ele, bd);
            // 解析子元素property
            parsePropertyElements(ele, bd);
            // 解析子元素qualifier
            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 {
            // pop BeanEntry
            this.parseState.pop();
        }

        return null;
    }

decorateBeanDefinitionIfRequired(ele, bdHolder)接口的最终实现如下：

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

        BeanDefinitionHolder finalDefinition = definitionHolder;

        // 根据自定义属性装饰
       // 获取所有属性
        NamedNodeMap attributes = ele.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {
            Node node = attributes.item(i);
            finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
        }

        // 装饰基于自定义嵌套元素的装饰
        // 获取所有嵌套元素
        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;
    }

此方法在存在非默认命名空间时，解析自定义的属性和嵌套元素，decorateIfRequired(node, finalDefinition, containingBd)方法的实现如下：

public BeanDefinitionHolder decorateIfRequired(
            Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {

        // 获取命名空间uri
        String namespaceUri = getNamespaceURI(node);
        // 如果不是默认命名空间uri
        if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
            // 获取命名空间handler
            NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
            if (handler != null) {
                // 调用此handler 的decorate方法创建BeanDefinitionHolder实例
                BeanDefinitionHolder decorated =
                        handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
                if (decorated != null) {
                    return decorated;
                }
            }
            else if (namespaceUri.startsWith("http://www.springframework.org/")) {
                error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
            }
            else {
                // A custom namespace, not to be handled by Spring - maybe "xml:...".
                if (logger.isDebugEnabled()) {
                    logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
                }
            }
        }
        return originalDef;
    }

接下来是往注册表中注册bean，BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry())的实现如下：

public static void registerBeanDefinition(
            BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
            throws BeanDefinitionStoreException {

        String beanName = definitionHolder.getBeanName();
        // beanName 作为key，注册bean definition
        registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

        // beanName 作为key，注册alias
        String[] aliases = definitionHolder.getAliases();
        if (aliases != null) {
            for (String alias : aliases) {
                registry.registerAlias(beanName, alias);
            }
        }
    }

在SimpleBeanDefinitionRegistry类中，定义了注册bean definition的Mam对象，map初始大小为64，如下：
private final Map beanDefinitionMap = new ConcurrentHashMap<>(64);
registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException {

        Assert.hasText(beanName, ""beanName" must not be empty");
        Assert.notNull(beanDefinition, "BeanDefinition must not be null");
        this.beanDefinitionMap.put(beanName, beanDefinition);
    }

通过这篇文章，学习了ClassPathXmlApplicationContext的启动解析默认命名空间中元素的解析过程，下面继续学习自定义命名空间中bean的解析。