17--Spring解析xml默认命名空间

版权声明：如有转载，请标明出处，谢谢合作！ https://blog.csdn.net/lyc_liyanchao/article/details/83026204

上一节分析了Spring将xml文件转换为Document对象的过程，接下来Spring会对已转换的Document对象进行解析。打开XmlBeanDefinitionReader类的registerBeanDefinitions方法。打开DefaultBeanDefinitionDocumentReader类的doRegisterBeanDefinitions方法。

1. 引言

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
    // 1、创建documentReader对象
    BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
    // 2、读取已经注册的bean个数
    int countBefore = getRegistry().getBeanDefinitionCount();
    // 3、解析Document并注册BeanDefinition
    documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
    // 4、返回本次注册的bean个数
    return getRegistry().getBeanDefinitionCount() - countBefore;
}

该方法总共分为了四步，第三步是执行对Document对象解析和注册BeanDefinition。先来看对Document对象的解析过程。

2.doRegisterBeanDefinitions方法分析

protected void doRegisterBeanDefinitions(Element root) {
    // 1、创建BeanDefinitionParserDelegate对象，用来解析Element元素
    BeanDefinitionParserDelegate parent = this.delegate;
    this.delegate = createDelegate(getReaderContext(), root, parent);

    // 2、解析并验证profile节点，如果配置了profile属性，则验证当前环境是否激活了对应的profile节点，
    // 用于多开发环境配置，该方式在开发中已不多见。
    // 例如：System.setProperty("spring.profiles.active", "dev");
    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);
            if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
                return;
            }
        }
    }

    // 3、解析前置处理，空的模板方法
    preProcessXml(root);

    // 4、解析并注册BeanDefinition
    parseBeanDefinitions(root, this.delegate);

    // 5、解析后置处理，空的模板方法
    postProcessXml(root);

    this.delegate = parent;
}

doRegisterBeanDefinitions方法并没有自己去执行对xml节点的解析而是委托给了BeanDefinitionParserDelegate，通过代理去解析xml节点。Spring的xml文件又可能包含默认命名空间和自定义命名空间，我们来看Spring是如何进行处理的。

3.parseBeanDefinitions方法简析

protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
    // 1、解析默认命名空间
    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);
                }
                // 自定义命名空间
                else {
                    delegate.parseCustomElement(ele);
                }
            }
        }
    }
    // 2、解析自定义命名空间
    else {
        delegate.parseCustomElement(root);
    }
}

这与上一节的xml解析分析大致相同，只是增加了对命名空间的判断，针对不同的命名空间使用不同的方法进行解析。先来看对默认命名空间中的标签的解析。

4.parseDefaultElement解析默认标签

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
    // 1、解析import标签，并注册beanDefinition
    if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
        importBeanDefinitionResource(ele);
    }
    // 2、解析alias标签，并注册别名
    else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
        processAliasRegistration(ele);
    }
    // 3、解析bean标签，并注册beanDefinition
    else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
        processBeanDefinition(ele, delegate);
    }
    // 4、解析beans标签
    else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
        doRegisterBeanDefinitions(ele);
    }
}

代码到这里，相信大家已经有所了然了，日常开发中的常见标签已经展现出来了（虽然现在提倡无配置文件，但是还是要对其原理有所了解）。parseDefaultElement方法对import、alias、bean、beans四种标签分别做了单独处理，bean标签的解析最复杂也是一个比较基础的操作，先来看对bean标签的解析，如果大家能够了解bean的解析，那么其他的解析过程相信大家都能看懂，因为相对而言要比解析bean标签简单的多。

5.解析Bean标签

/**
 * 解析bean标签将其转换为definition并注册到BeanDefinitionRegistry
 * Process the given bean element, parsing the bean definition and registering it with the registry.
 */
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    // 1、将解析的节点信息封装至BeanDefinitionHolder对象
    // BeanDefinitionHolder-->封装了BeanDefinition,beanName以及aliases
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        // 2、装饰BeanDefinition
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // Register the final decorated instance.
            // 3、执行注册
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex);
        }
        // Send registration event.
        // 4、发送注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

可以看到Spring将解析之后的内容封装至了BeanDefinitionHolder类，该类封装了BeanDefinition,beanName以及aliases，BeanDefinition封装了bean标签的各种信息。

该方法还执行了对BeanDefinition的注册，留在下节分析。来看bean标签解析的具体过程。

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
    // 1、解析bean的id和bean的别名
    // 获取id标签属性
    String id = ele.getAttribute(ID_ATTRIBUTE);
    // 获取name（别名）标签属性，缓存至List集合
    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));
    }

    // 如果bean的id为空，但是别名不为空的话，那么默认采用第一个别名作为beanName
    // 例如：<bean class="com.lyc.cn.v2.day01.Dog" name="myDog1,myDog2"/>，使用myDog1作为beanName
    String beanName = id;
    if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
        beanName = aliases.remove(0);
    }

    // 2、containingBean不为空，则检查beanName和别名是否被使用
    if (containingBean == null) {
        checkNameUniqueness(beanName, aliases, ele);
    }

    // 3、解析bean标签，将其转换为BeanDefinition对象
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);

    // 4、如果beanDefinition且未配置bean的id属性，name属性，则为当前bean生成id和别名
    // 例如：<bean class="com.lyc.cn.v2.day01.Dog"/>，<bean factory-bean="dog4"/>，<bean parent="outer"/>等
    if (beanDefinition != null) {
        if (!StringUtils.hasText(beanName)) {
            try {
                // containingBean不为null，则当前bean是内部bean，使用BeanDefinitionReaderUtils生成beanName
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);
                } else {
                    // 否则，使用XmlReaderContext对象生成beanName
                    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.
                    // 如果生成器返回的是类名加上后缀，则为普通bean类名注册一个别名。这在Spring 1.2/2.0的向后兼容性中是可以实现的。
                    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;
            }
        }
        // 5、创建并返回BeanDefinitionHolder对象
        String[] aliasesArray = StringUtils.toStringArray(aliases);
        return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
    }
    return null;
}

首先对id，name属性进行解析，该过程比较简单，接下来就是对bean中其他属性的解析。来看parseBeanDefinitionElement方法。

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) {
    this.parseState.push(new BeanEntry(beanName));
    // 1、解析class属性
    String className = null;
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }
    // 2、解析parent属性
    String parent = null;
    if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
        parent = ele.getAttribute(PARENT_ATTRIBUTE);
    }
    try {
        // 3、创建AbstractBeanDefinition对象
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);
        // 4、解析bean标签属性
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
        // 5、解析meta标签
        parseMetaElements(ele, bd);
        // 6、解析lookup-method属性
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
        // 7、解析replace-method属性
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
        // 8、解析构造函数参数
        parseConstructorArgElements(ele, bd);
        // 9、解析property属性
        parsePropertyElements(ele, bd);
        // 10、解析qualifier属性
        parseQualifierElements(ele, bd);
        // 11、设置bean定义来源和元数据的来源
        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标签属性。

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
																@Nullable BeanDefinition containingBean,
																AbstractBeanDefinition bd) {

    // 1、设置bean作用域
    if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
        error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
    } else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
    } else if (containingBean != null) {
        // Take default from containing bean in case of an inner bean definition.
        // 未明确指定bean的作用域,且当前被解析bean是内部bean的话，
        // 则默认使用outer bean的的作用域作为当前bean的作用域
        // 例如:下面的配置，解析到inner属性时，inner未指定作用域，则使用outer的作用域，也就是prototype
        /**
        <bean id="outer" class="com.lyc.cn.v2.day01.inner.Outer" scope="prototype">
            <property name="inner">
                <bean id="inner" class="com.lyc.cn.v2.day01.inner.Inner"/>
            </property>
         </bean>
         **/
        bd.setScope(containingBean.getScope());
    }

    // 2、设置abstract属性
    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }

    // 3、设置lazy-init(延迟加载)属性；
    // 如果该属性为true的话，ApplicationContext容器在初始化时不会加载该bean；
    // 而是在第一次向容器索取该bean时才会被初始化
    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
    if (DEFAULT_VALUE.equals(lazyInit)) {
        lazyInit = this.defaults.getLazyInit();
    }
    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    // 4、设置autowire属性，此属性默认不开启
    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
    bd.setAutowireMode(getAutowireMode(autowire));

    // 5、设置depends-on属性，如果BeanA依赖于BeanB，可通过depends-on属性使BeanB在BeanA之前完初始化
    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
    }

    // 6、设置autowire-candidate属性，当一个接口有多个实现类时，
    // 配置autowire-candidate属性可以明确指定实现类是否参与自动注入
    String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
    if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
        String candidatePattern = this.defaults.getAutowireCandidates();
        if (candidatePattern != null) {
            String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
            bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
        }
    } else {
        bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
    }

    // 7、设置primary属性，当byType注入有多个类型时，
    // 可以指定primary="true"，提高注入的优先级，避免抛出异常
    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }

    // 8、设置init-method，bean初始化完成后回调该方法
    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
        bd.setInitMethodName(initMethodName);
    }
    else if (this.defaults.getInitMethod() != null) {
        // 尝试从DocumentDefaultsDefinition对象中获取init-method属性
        // DocumentDefaultsDefinition对象保存了Spring bean的一些简单设置，
        // 我们可以通过该类设定通用的bean属性模板
        bd.setInitMethodName(this.defaults.getInitMethod());
        bd.setEnforceInitMethod(false);
    }

    // 9、设置destroy-method属性，bean销毁后回调该方法
    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
        bd.setDestroyMethodName(destroyMethodName);
    }
    else if (this.defaults.getDestroyMethod() != null) {
        // 尝试从DocumentDefaultsDefinition对象中获取destroy-method属性
        bd.setDestroyMethodName(this.defaults.getDestroyMethod());
        bd.setEnforceDestroyMethod(false);
    }

    // 10、设置factory-method属性，该属性可指定静态工厂或实例工厂方法实例化bean
    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
    // 11、设置factory-bean属性，一般和factory-method属性一起使用，
    // 指定工厂bean和工厂bean的工厂方法
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }

    return bd;
}

其他的方法大家可以通过在配置文件中配置属性，debug跟踪调试，不在一一赘述。到这里Spring已经将xml中的配置信息封装至BeanDefinitionHolder对象，接下来就可以执行对bean的注册了。

另外对bean name的生成策略简单分析一下：
上面parseBeanDefinitionElement方法已经有所简介，来看一下具体过程：

public static String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean) throws
			BeanDefinitionStoreException {

	// 1、获取bean的className
	String generatedBeanName = definition.getBeanClassName();

	// 2、如果generatedBeanName为null，
	// 则判断其是否有parent属性或者factory-bean并生成generatedBeanName
	if (generatedBeanName == null) {
		// parent属性不为空
		if (definition.getParentName() != null) {
			generatedBeanName = definition.getParentName() + "$child";
		}
		// factory-bean属性不为空
		else if (definition.getFactoryBeanName() != null) {
			generatedBeanName = definition.getFactoryBeanName() + "$created";
		}
	}
	// 3、如果上述方法均无法生成generatedBeanName，则抛出异常
	if (!StringUtils.hasText(generatedBeanName)) {
		throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither "
				+ "'class' nor 'parent' nor 'factory-bean' - can't "
				+ "generate bean name");
	}

	// 4、判断是否内部bean，并根据生成的generatedBeanName，拼接最终的beanName返回
	String id = generatedBeanName;
	if (isInnerBean) {
		// Inner bean: generate identity hashcode suffix.
		// GENERATED_BEAN_NAME_SEPARATOR-->#
		id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition);
	} else {
		// Top-level bean: use plain class name.
		// Increase counter until the id is unique.
		int counter = -1;
		while (counter == -1 || registry.containsBeanDefinition(id)) {
			counter++;
			// GENERATED_BEAN_NAME_SEPARATOR-->#
			id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter;
		}
	}
	return id;
}

这一部分的代码比较多，也比较细，一时间找不到应该如何写才能让读者更清晰的了解解析过程，感兴趣的多多调试跟踪代码吧。