spring源码分析-默认标签解析_spring源码默认标签的解析案例-CSDN博客

本文链接：https://blog.csdn.net/ginkgo_biloba/article/details/95041388

默认标签解析

通过上一章节，解析默认标签进入方法parseDefaultElement(ele, delegate);这个方法分别对4个标签做了不同处理（import,alias,bean,beans）

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标签的解析及注册

进入函数processBeanDefinition(ele, delegate);

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
    BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
    if (bdHolder != null) {
        bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
        try {
            // 注册最终修饰的实例。
            BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to register bean definition with name '" +
                    bdHolder.getBeanName() + "'", ele, ex);
        }
        // 发送注册事件
        getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
    }
}

大致逻辑总结如下：

首先委托BeanDefinitionParserDelegate 类的 parseBeanDefinitionElement方法进行元素解析，
返回 BeanDefinitionHolder 类型的实例bdHolderr，经过这个方法后， bdHolder 实例已经包含我们配置文件中配置的各种属性了，例如 class 、 name 、 id 、 alias 之类的属性。
当返回的 bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性，还需要再次对自定义标签进行解析。
解析完成后，需要对解析后的 bdHolder进行注册，同样，注册操作委托给了 BeanDefinitionReaderUtils 的 registerBeanDefinition 方法。

解析BeanDefinition

首先我们从元素解析及信息提取开始,BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

BeanDefinitionHolder 这个类的作用

/**
 * 具有名称和别名的BeanDefinition的持有者。可以注册为内部bean的占位符。
 * 也可以用于内部bean定义的编程注册。
 * 如果您不关心BeanNameAware等，注册RootBeanDefinition或ChildBeanDefinition就足够了。
 */

进入parseBeanDefinitionElement 方法

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

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

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

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

    //important！！！
    AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
    if (beanDefinition != null) {
        //如果不存在beanName,则根据spring提供的命名规则为当前bean生成对应的beanName
        if (!StringUtils.hasText(beanName)) {
            try {
                if (containingBean != null) {
                    beanName = BeanDefinitionReaderUtils.generateBeanName(
                            beanDefinition, this.readerContext.getRegistry(), true);
                }
                else {
                    beanName = this.readerContext.generateBeanName(beanDefinition);
                    // 如果生成器返回类名加后缀，则注册普通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);
                    }
                }
                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;
}

现在只能看到对属性 id 以及 name 的解析，但是很庆幸，思路我们已经了解了。
在开始对属性展开全面解析前， Spring 在外层又做了一个当前层的功能架构，在当前层完成的主要工作包括如下内容。

提取元素巾的 id 以及 name 属性。
进一步解析其他所有属性并统一封装至 GenericBeanDefinition 类型的实例中。（后面parseBeanDefinitionElement方法会看到）
如果检测到 bean 没有指定 beanName ，那么使用默认规则为此 Bean 生成 beanName 。
将获取到的信息封装到 BeanDefinitionHolder 的实例中。

进一步查看parseBeanDefinitionElement方法

/**
*解析bean定义本身，而不考虑名称或别名。
如果在解析bean定义期间出现问题，可能会返回{@code null}。
*/
public AbstractBeanDefinition parseBeanDefinitionElement(
        Element ele, String beanName, BeanDefinition containingBean) {

    //将新的{@link Entry}添加到{@link Stack}。
    this.parseState.push(new BeanEntry(beanName));

    String className = null;
    //解析class属性
    if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
        className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
    }

    try {
        String parent = null;
        //解析parent属性
        if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
            parent = ele.getAttribute(PARENT_ATTRIBUTE);
        }
        //创始用于承载属性的 AbstractBeanDefinition 类型的 GenericBeanDefination ,创建 GenericBeanDefinition类型的实例   important！！！！
        AbstractBeanDefinition bd = createBeanDefinition(className, parent);

        // ＠硬编码解析默认 bean的各种属性   important！！！！
        parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
 //   提取Description
        bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

        //提取元数据  important！！！！
        parseMetaElements(ele, bd);
        //解析lookup-method 属性
        parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
         //解析replace-method 属性
        parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

        // //解析构造函数参数
        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 {
        this.parseState.pop();
    }

    return null;
}

bean 标签的所有属性，不论常用的还是不常用的我们都看到了 !

1. 创建用于属性承载的 BeanDefinition

BeanDefinition 是一个接口，在 Spring 中存在三种实现： RootBeanDefinition 、 ChildBeanDefinition 以及 GenericBeanDefinition 。三种实现均继承了 AbstractBeanDefiniton 。BeanDefinition 则提供了相应的 beanClass 、 scope 、 lazyInit属性， BeanDefinition 和＜bean＞中的属性是一一对应的。

Spring 通过 BeanDefinition 将配置文件中的＜bean＞配置信息转换为容器的内部表示，并将这些BeanDefiniton注册到BeanDefinitonRegistry 中。 Spring 容器的 BeanDefinitionRegistry 就像是 Spring 配置信息的内存数据库，主要是以 map 的形式保存，后续操作直接从 BeanDefinitionRegistry 中读取配置信息。

TODO：没有找到上一步的源码

由此可知，要解析属性首先要创建用于承载属性的实例，也就是创建GenericBeanDefinition类型的实例。而代码 createBeanDefinition(className, parent)的作用就是实现此功能。

//为给定的类名和父名创建bean定义
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
        throws ClassNotFoundException {

    return BeanDefinitionReaderUtils.createBeanDefinition(
            parentName, className, this.readerContext.getBeanClassLoader());
}

//为给定的类名和父名创建bean定义,如果指定了ClassLoader，则急切地加载bean类。
public static AbstractBeanDefinition createBeanDefinition(
        String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

    GenericBeanDefinition bd = new GenericBeanDefinition();
    bd.setParentName(parentName);
    if (className != null) {
        if (classLoader != null) {
            //如果 classLoader 不为空， 则使用以传人的 classLoader 同一虚拟机加载类对象，否则只是记录className
            bd.setBeanClass(ClassUtils.forName(className, classLoader));
        }
        else {
            bd.setBeanClassName(className);
        }
    }
    return bd;
}

2.解析各种属性

创建了 bean 信息的承载实例后，便可以进行 bean 信息的各种属性解析了，首先我
们进入 parseBeanDefinitionAttributes 方法。该方法是对 element 所有元素属性进行解析：

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

    //解析singleton属性
    if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
        error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
    }
    //解析scope属性
    else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
        bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
    }
    else if (containingBean != null) {
        // 在嵌入 beanDifinition 情况下且没有单独指定 scope 属性则使用父类默认的属性
        bd.setScope(containingBean.getScope());
    }

    解析abstract属性
    if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
        bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
    }

    //解析lazy-init属性
    String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
    if (DEFAULT_VALUE.equals(lazyInit)) {
        lazyInit = this.defaults.getLazyInit();
    }
    //若没有设置号或设置成其他字何都会被设置为 false
    bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

    //解析autowire属性
    String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
    bd.setAutowireMode(getAutowireMode(autowire));

    //解析dependencyCheck属性
    String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
    bd.setDependencyCheck(getDependencyCheck(dependencyCheck));

    //解析depends-on属性
    if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
        String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
        bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
    }

    //解析 autowireCandidate 属性
    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));
    }

    //解析 primary 属性
    if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
        bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
    }

    //解析 init 属性
    if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
        String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
        if (!"".equals(initMethodName)) {
            bd.setInitMethodName(initMethodName);
        }
    }
    else {
        if (this.defaults.getInitMethod() != null) {
            bd.setInitMethodName(this.defaults.getInitMethod());
            bd.setEnforceInitMethod(false);
        }
    }

    //解析 destroy-method 属性
    if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
        String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
        bd.setDestroyMethodName(destroyMethodName);
    }
    else {
        if (this.defaults.getDestroyMethod() != null) {
            bd.setDestroyMethodName(this.defaults.getDestroyMethod());
            bd.setEnforceDestroyMethod(false);
        }
    }

    //解析 factory-method 属性
    if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
        bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
    }
     //解析 factory-bean 属性
    if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
        bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
    }

    return bd;
}

TODO : 查阅不熟悉的标签

3.解析元素meta

meta标签的使用

<bean id="myTestBean" class="bean.MyTestBean">
    <property name="name" value="Tom"/>
　　<meta key = "key" value = "values">
</bean>

meta标签的作用 TODO：应用场景

这段代码并不会体现在 MyTestBean 的属性当中，而是一个额外的声明，当需要使用里面的信息的时候可以通过BeanDefinition 的getAttribute(key)方法进行获取。

对 meta 属性的解析代码如下：

public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
    //获取当前节点的所有子元素
    NodeList nl = ele.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        //提取meta
        if (isCandidateElement(node) && nodeNameEquals(node, META_ELEMENT)) {
            Element metaElement = (Element) node;
            String key = metaElement.getAttribute(KEY_ATTRIBUTE);
            String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
            //使用 key、value 构造 BeanMetadataAttribute
            BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
            attribute.setSource(extractSource(metaElement));
            //记录信息
            attributeAccessor.addMetadataAttribute(attribute);
        }
    }
}

4. 解析元素 lookup-method

lookup-method作用

demo

//User类
public class User {
	public void showMe(){
		System.out.println("我是user");
	}
}

//Test类
public abstract class TestLookUp {
 	public abstract UserLookUp getBean();
	public void showMe(){
		this.getBean().showMe();
	}
}
//测试代码
public static void main(String[] args) {
	ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-bean-lookup.xml");
	TestLookUp user = (TestLookUp) applicationContext.getBean("testLookUp");
	user.showMe();
}

xml配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
 
	<bean id="userLookUp" class="lantao.UserLookUp"/>
 
	<bean id="testLookUp" class="lantao.TestLookUp">
		<lookup-method name="getBean" bean="userLookUp"/>
	</bean>
 
</beans>

程序输出

我是user

测试代码的抽象类没有被实现，但是可以直接调用，这个过程是获取器注入，是一种特殊的方法注入，把一个方法声明为返回某种类型的bean，但实际要返回的bean实在配置文件里配置的。这个方法可用在有些可插拔的功能上，接触程序依赖。

源码

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        //当且仅当spring默认bean的子元索为<lookup-method>有效
        if (isCandidateElement(node) && nodeNameEquals(node, LOOKUP_METHOD_ELEMENT)) {
            Element ele = (Element) node;
            //获取要修饰的方法
            String methodName = ele.getAttribute(NAME_ATTRIBUTE);
            //获取配置返回的bean
            String beanRef = ele.getAttribute(BEAN_ELEMENT);
            LookupOverride override = new LookupOverride(methodName, beanRef);
            override.setSource(extractSource(ele));
            overrides.addOverride(override);
        }
    }
}

这段代码和parseMetaElements很相似，不同点：在数据存储上面通过使用 LookupOverride 类型的实体类来进行数据承载并记录在 AbstractBeanDefinition中的methodOverrides 属性中。

5. 解析元素 replaced-method

元素用法：可以在运行时用新的方法替换现有的方法。与之前的 look-up 不同的是，replaced-method不但可以动态地替换返回实体 bean ，而且还能动态地更改原有方法的逻辑。

demo

//在changeMe中完成某个业务逻辑
public class TestChangeMethod {
    public void changeMe(){
        System.out.println("changeMe");
    }
}
// 在运行了一段时间后需要改变原有的业务逻辑
public class TestMethodReplacer implements MethodReplacer{
    @Override
    public Object reimplement(Object obj, Method method, Object[] args)throws Throwable{
        System.out.println("我替换了原有的方法");
        return null;
    }
}

//测试
public class test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext bf = new ClassPathXmlApplicationContext("test/replacemethod/replaceMethodTest.xml");
        TestChangeMethod test = (TestChangeMethod) bf.getBean("testChangeMethod");
        test.changeMe();
    }
}

xml配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <bean id="testChangeMethod" class="test.Replacemethod.TestChangeMethod">
        <replaced-method name="changeMe" replacer="replacer"/>
    </bean>
 
    <bean id="replacer" class="test.replacemethod.TestMethodReplacer"/>
</beans>

控制台成功打印出"我替换了原有的方法"。

源码

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        //当且仅当spring默认bean的子元索为<replace-method>有效
        if (isCandidateElement(node) && nodeNameEquals(node, REPLACED_METHOD_ELEMENT)) {
            Element replacedMethodEle = (Element) node;
            //提取要替换的旧方法
            String name = replacedMethodEle.getAttribute(NAME_ATTRIBUTE);
            //提取对应的新方法
            String callback = replacedMethodEle.getAttribute(REPLACER_ATTRIBUTE);
            ReplaceOverride replaceOverride = new ReplaceOverride(name, callback);
            // Look for arg-type match elements.
            List<Element> argTypeEles = DomUtils.getChildElementsByTagName(replacedMethodEle, ARG_TYPE_ELEMENT);
            for (Element argTypeEle : argTypeEles) {
                //记录参数
                String match = argTypeEle.getAttribute(ARG_TYPE_MATCH_ATTRIBUTE);
                match = (StringUtils.hasText(match) ? match : DomUtils.getTextValue(argTypeEle));
                if (StringUtils.hasText(match)) {
                    replaceOverride.addTypeIdentifier(match);
                }
            }
            replaceOverride.setSource(extractSource(replacedMethodEle));
            overrides.addOverride(replaceOverride);
        }
    }
}

无论是 look-up 还是 replaced-method 都是构造了一个MethodOverride，并最
终记录在了AbstractBeanDefinition 中的methodOverrides属性中。这个属性的功能在后续介绍。

6. 解析元素 constructor-arg

用法:

下面代码实现的功能：实现的功能就是对HelloBean自动寻找对应的构造函数,并在初始化的时候将设置的参数传入进去.

<beans>
    <!-- 默认的情况下是按照参数的顺序注入,当指定index索引后就可以改变注入参数的顺序 -->
    <bean id="helloBean" class="com.HelloBean">
        <constructor-arg index="0">
            <value>Spring</value>
        </constructor-arg>
        <constructor-arg index="1">
            <value>你好</value>
        </constructor-arg>
    </bean>
</beans>

源码 parseConstructorArgElement

public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
            parseConstructorArgElement((Element) node, bd);
        }
    }
}

功能：遍历所有子元素，提取所有constructor-arg ，然后进行解析 ,解析工作在parseConstructorArgElement((Element) node, bd);方法中。

public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
    //提取index属性
    String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
    //提取type属性
    String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
    //提取name属性
    String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
    if (StringUtils.hasLength(indexAttr)) {
        try {
            int index = Integer.parseInt(indexAttr);
            if (index < 0) {
                error("'index' cannot be lower than 0", ele);
            }
            else {
                try {
                    this.parseState.push(new ConstructorArgumentEntry(index));
                    //解析ele对应的属性元素   important!!!
                    Object value = parsePropertyValue(ele, bd, null);
                    ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
                    if (StringUtils.hasLength(typeAttr)) {
                        valueHolder.setType(typeAttr);
                    }
                    if (StringUtils.hasLength(nameAttr)) {
                        valueHolder.setName(nameAttr);
                    }
                    valueHolder.setSource(extractSource(ele));
                    //不允许指定重复的参数
                    if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
                        error("Ambiguous constructor-arg entries for index " + index, ele);
                    }
                    else {
                        //important！！
                        bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
                    }
                }
                finally {
                    this.parseState.pop();
                }
            }
        }
        catch (NumberFormatException ex) {
            error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
        }
    }
    else {
        try {
            //没有index属性则自动忽略，自动寻找
            this.parseState.push(new ConstructorArgumentEntry());
            Object value = parsePropertyValue(ele, bd, null);
            ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
            if (StringUtils.hasLength(typeAttr)) {
                valueHolder.setType(typeAttr);
            }
            if (StringUtils.hasLength(nameAttr)) {
                valueHolder.setName(nameAttr);
            }
            valueHolder.setSource(extractSource(ele));
            //important！！！
           
           bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
        }
        finally {
            this.parseState.pop();
        }
    }
}

上述代码的大致流程

如果配置中指定了index属性,那么操作步骤如下.
- 解析constructor-arg的子元素.
- 使用ConstructorArgumentValues.ValueHolder类型来封装解析出来的元素.
- 将type name和index属性一并封装在ConstructorArgumentValues.ValueHolder类型中并添加至当前BeanDefinition的constructorArgumentValues()的indexedArgumentValues属性中.
如果没有指定index属性,那么操作步骤如下. TODO 好像有错误
- 解析constructor-arg的子元素.
- 使用ConstructorArgumentValues.ValueHolder类型来封装解析出来的元素.
- 将type name和index属性一并封装在ConstructorArgumentValues.ValueHolder类型中并添加至当前BeanDefinition的constructorArgumentValues()的genericArgumentValues属性中.

进入parsePropertyValue方法

/**
 * 获取属性元素的值。可能是一个list等。
 * 也用于构造函数参数，“propertyName”在这种情况下为null。
 */
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
    String elementName = (propertyName != null) ?
            "<property> element for property '" + propertyName + "'" :
            "<constructor-arg> element";

    //一个属性只能对应一种类型: ref, value, list, etc.
    NodeList nl = ele.getChildNodes();
    Element subElement = null;
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        //对应 description 或者 meta 不处理
        if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
                !nodeNameEquals(node, META_ELEMENT)) {
            // Child element is what we're looking for.
            if (subElement != null) {
                error(elementName + " must not contain more than one sub-element", ele);
            }
            else {
                subElement = (Element) node;
            }
        }
    }

    // 解析constructor-arg上的ref属性
    boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
     // 解析constructor-arg上的value属性
    boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
    if ((hasRefAttribute && hasValueAttribute) ||
            ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
        /**
             * 在constructor-arg上不存在 : 
             *      1. 同时既有ref属性又有value属性
             *      2. 存在ref属性或者value属性且又有子元素
             */   
        error(elementName +
                " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
    }

    if (hasRefAttribute) {
        // ref属性的处理,使用RuntimeBeanReference封装对应的ref名称
        String refName = ele.getAttribute(REF_ATTRIBUTE);
        if (!StringUtils.hasText(refName)) {
            error(elementName + " contains empty 'ref' attribute", ele);
        }
        RuntimeBeanReference ref = new RuntimeBeanReference(refName);
        ref.setSource(extractSource(ele));
        return ref;
    }
    else if (hasValueAttribute) {
         // value属性的处理,使用TypedStringValue封装
        TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
        valueHolder.setSource(extractSource(ele));
        return valueHolder;
    }
    else if (subElement != null) {
        // 解析子元素
        return parsePropertySubElement(subElement, bd);
    }
    else {
        // // 既没有ref也没有value子元素则报错
        error(elementName + " must specify a ref or value", ele);
        return null;
    }
}

上述代码的功能

略过description和meta.
提取constructor-arg上的ref和value属性,以便于根据规则验证正确性,其规则为在constructor-arg上不存在以下情况.
同时既有ref又有value属性.
存在ref属性或者value属性且又有子元素.
ref属性的处理.使用RuntimeBeanReference封装对应的ref名称,如:<constructor-arg ref="a" >
value属性的处理.使用TypedStringValue封装,例如:<constructor-arg value="a" >

子元素的处理.例如 :

<constructor-arg>
    <map>
        <entry key="key" value="value" />
   </map>
</constructor-arg>

而对于子元素的处理,例如这里提到的在构造函数中又嵌入了子元素map是怎么实现的呢?parsePropertySubElement中实现了对各种子元素的分离处理.

public Object parsePropertySubElement(Element ele, BeanDefinition bd) {
    return parsePropertySubElement(ele, bd, null);
}

//解析property或constructor-arg元素的value，ref或collection子元素。
public Object parsePropertySubElement(Element ele, BeanDefinition bd, String defaultValueType) {
    if (!isDefaultNamespace(ele)) {
        return parseNestedCustomElement(ele, bd);
    }
    else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
        BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
        if (nestedBd != null) {
            nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
        }
        return nestedBd;
    }
    else if (nodeNameEquals(ele, REF_ELEMENT)) {
        // A generic reference to any name of any bean.
        String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
        boolean toParent = false;
        if (!StringUtils.hasLength(refName)) {
            // A reference to the id of another bean in the same XML file.  解析local
            refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
            if (!StringUtils.hasLength(refName)) {
                // A reference to the id of another bean in a parent context.  解析parent
                refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
                toParent = true;
                if (!StringUtils.hasLength(refName)) {
                    error("'bean', 'local' or 'parent' is required for <ref> element", ele);
                    return null;
                }
            }
        }
        if (!StringUtils.hasText(refName)) {
            error("<ref> element contains empty target attribute", ele);
            return null;
        }
        RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
        ref.setSource(extractSource(ele));
        return ref;
    }
    //解析idref TODO
    else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
        return parseIdRefElement(ele);
    }
    //解析value元素
    else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
        return parseValueElement(ele, defaultValueType);
    }
    //解析null
    else if (nodeNameEquals(ele, NULL_ELEMENT)) {
        // It's a distinguished null value. Let's wrap it in a TypedStringValue
        // object in order to preserve the source location.
        TypedStringValue nullHolder = new TypedStringValue(null);
        nullHolder.setSource(extractSource(ele));
        return nullHolder;
    }
    else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
        //解析aray子数组
        return parseArrayElement(ele, bd);
    }
    else if (nodeNameEquals(ele, LIST_ELEMENT)) {
        //解析list子数组
        return parseListElement(ele, bd);
    }
    else if (nodeNameEquals(ele, SET_ELEMENT)) {
        //解析set子数组
        return parseSetElement(ele, bd);
    }
    else if (nodeNameEquals(ele, MAP_ELEMENT)) {
        //解析map子数组
        return parseMapElement(ele, bd);
    }
    else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
        //解析props子数组
        return parsePropsElement(ele);
    }
    else {
        error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
        return null;
    }
}

7. 解析子元素 property

property使用方法

<bean id="test" class="test.TestClass">
    <property name="testStr" value="aaa" />
</bean>

或者

<bean id="a">
        <property name="p">
            <list>
                <value>aa</value>
                <value>bb</value>
            </list>
        </property>
</bean>

源码

//获取所有property子元素，然后调用parsePropertyElement处理
public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
    NodeList nl = beanEle.getChildNodes();
    for (int i = 0; i < nl.getLength(); i++) {
        Node node = nl.item(i);
        if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
            parsePropertyElement((Element) node, bd);
        }
    }
}

public void parsePropertyElement(Element ele, BeanDefinition bd) {
    String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
    if (!StringUtils.hasLength(propertyName)) {
        error("Tag 'property' must have a 'name' attribute", ele);
        return;
    }
    this.parseState.push(new PropertyEntry(propertyName));
    try {
        //不允许多次对同一属性配置
        if (bd.getPropertyValues().contains(propertyName)) {
            error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
            return;
        }
        Object val = parsePropertyValue(ele, bd, propertyName);
        PropertyValue pv = new PropertyValue(propertyName, val);
        parseMetaElements(ele, pv);
        pv.setSource(extractSource(ele));
        bd.getPropertyValues().addPropertyValue(pv);
    }
    finally {
        this.parseState.pop();
    }
}

可以看到上面方法与构造方法注入方式不同的是返回值使用PropertyValue进行封装,并记录在了BeanDefinition中的propertyValues属性中.

8.解析 qualifier TODO

对于qualifier元素的获取,我们接触更多的是注解的形式,在使用Spring框架中进行自动注入时,Spring容器中匹配的候选Bean数目必须有且仅有一个.当找不到一个匹配的Bean时,Spring容器将抛出BeanCreationException异常,并指出必须至少拥有一个匹配的Bean。

Spring允许我们通过Qualifier指定注入Bean的名称,这样歧义就消除了,而对于配置方式使用如下:

<bean id="myTestBean" class="bean.MyTestBean">
     <qualifier type="org.springframework.beans.factory.annotation.Qualifier" value="qf" />
</bean>

AbstractBeanDefinition属性

至此我们便完成了对XML文档到GenericBeanDefinition的转换,也就是说到这里,XML中所有的配置都可以在GenericBeanDefinition的实例类中找到对应的位置.

GenericBeanDefinition只是子类实现,而大部分的通用属性都保存在了AbstractBeanDefinition中,那么我们再次通过AbstractBeanDefinition的属性来回顾一下我们都解析了哪些对应的配置.

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable {
 
    // 此处省略静态变量以及final常量
 
    /**
     * bean的作用范围,对应bean属性scope
     */
    @Nullable
    private String scope = SCOPE_DEFAULT;
 
    /**
     * 是否是抽象,对应bean属性abstract
     */
    private boolean abstractFlag = false;
    
    /**
     * 是否延时加载,对应bean的属性lazy-init
     */
    private boolean lazyInit = false;
 
    /**
     * 自动注入模式,对应bean属性autowire
     */
    private int autowireMode = AUTOWIRE_NO;
 
    /**
     * 依赖检查,Spring 3.0 后弃用这个属性
     */
    private int dependencyCheck = DEPENDENCY_CHECK_NONE;
 
    /**
     * 用来表示一个bean的实例化依靠另一个bean先实例化,对应bean属性depend-on
     */
    @Nullable
    private String[] dependsOn;
 
    /**
     * autowire-candidate属性设置为false,这样容器在查找自动装配对象时,将不在考虑该bean,
     * 即它不会被考虑作为其他bean自动装配的候选者,但是该bean本身还是可以使用自动装配来注入其
     * 他bean的.对应bean属性autowire-candidate
     */
    private boolean autowireCandidate = true;
 
    /**
     * 自动装配时当出现多个bean候选者时,将作为首选者,对应bean属性primary
     */
    private boolean primary = false;
 
    /**
     * 用于记录Qualifier,对应子元素qualifier
     */
    private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();
 
    
    @Nullable
    private Supplier<?> instanceSupplier;
 
    /**
     * 允许访问非公开的构造器和方法,程序设置
     */
    private boolean nonPublicAccessAllowed = true;
 
    /**
     * 是否以一种宽松的模式解析构造函数,默认为true,
     * 如果为false,则在如下情况
     * interface ITest{ }
     * class ITestImpl implements ITest{ };
     * class Main{
     *    Main(ITest i){ }
     *    Main(ITestImpl i){ }   
     * }
     * 抛出异常,因为Spring无法准确定位哪个构造函数
     * 程序设置
     */
    private boolean lenientConstructorResolution = true;
    
    /**
     * 对应bean属性factory-bean
     */
    @Nullable
    private String factoryBeanName;
 
    /**
     * 对应bean属性factory-method
     */
    @Nullable
    private String factoryMethodName;
 
    /**
     * 记录构造函数注入属性,对应bean属性constructor-arg
     */
    @Nullable
    private ConstructorArgumentValues constructorArgumentValues;
 
    /**
     * 普通属性集合
     */
    @Nullable
    private MutablePropertyValues propertyValues;
 
    /**
     * 方法重写的持有者,记录lookup-method, replaced-method元素
     */
    @Nullable
    private MethodOverrides methodOverrides;
 
    /**
     * 初始化方法,对应bean属性init-method
     */
    @Nullable
    private String initMethodName;
 
    /**
     * 销毁方法,对应bean属性destory-method
     */
    @Nullable
    private String destroyMethodName;
 
    /**
     * 是否执行init-method,程序设置
     */
    private boolean enforceInitMethod = true;
 
    /**
     * 是否执行destory-method,程序设置
     */
    private boolean enforceDestroyMethod = true;
 
    /**
     * 是否是用户定义的而不是应用程序本身定义的,创建AOP时候为true,程序设置
     */
    private boolean synthetic = false;
 
    /**
     * 定义这个bean的应用
     * APPLICATION      :   用户
     * INFRASTRUCTURE   :   完全内部使用,与用户无关
     * SUPPORT          :   某些复杂配置的一部分
     * 程序设置
     */
    private int role = BeanDefinition.ROLE_APPLICATION;
 
    /**
     * bean的描述信息
     */
    @Nullable
    private String description;
 
    /**
     * 这个bean定义的资源
     */
    @Nullable
    private Resource resource;
 
    // 此处省略get/set方法
    
}

解析默认标签中的自定义标签元素

到了这里我们已经完成了分析默认标签的解析与提取过程(parseBeanDefinitionElement),加下来进入下一步

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
            try {
                //注册最终修饰的实例
                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));
        }
    }

进入方法decorateBeanDefinitionIfRequired(ele, bdHolder);,这句代码的适用场景:pring中的bean使用的是默认的标签配置,但是其中的子元素却使用了自定义的配置。

<bean id="test" class="test.MyClass">
        <myBean:user userName="aaa"/>
</bean>

疑问：bean的解析分为两种类型,一种是默认类型的解析,另一种是自定义类型的解析,这不正是自定义类型的解析吗?为什么会在默认类型解析中单独添加一个方法来处理呢?

这个自定义类型并不是以Bean的形式出现的.之前讲过的两种类型的不同处理只是针对Bean的这里我们看到,这里我们看到,这个自定义类型其实是属性

进入代码

//第三个参数作用：父类bean,当对某个嵌套配置进行分析时,这里需要传递父类beanDefinition.分析源码得知这里传递的参数其实是为了使用父类的scope属性,以备子类若没有设置scope时默认使用父类的属性,这里分析的是顶层配置,所以传递null.
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
    return decorateBeanDefinitionIfRequired(ele, definitionHolder, null);
}

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
        Element ele, BeanDefinitionHolder definitionHolder, 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;
}

在decorateBeanDefinitionIfRequired中我们可以看到对于程序默认的标签的处理其实是直接略过的，因为默认的标签到这里已经被处理完了，这里只对自定义的标签或者说对 bean 的向定义属性感兴趣。

接下来进入方法：decorateIfRequired(node, finalDefinition, containingBd)

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

    //获取自定义标签的命名空间
    String namespaceUri = getNamespaceURI(node);
    //对于非默认标签进行装饰
    if (!isDefaultNamespace(namespaceUri)) {
        //根据命名空间找到对应的处理器
        NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
        if (handler != null) {
            //进行修饰
            return handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
        }
        else if (namespaceUri != null && 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;
}

上述代码的功能：

首先获取属性或者元素的命名空间,以此来判断该元素或者属性是否适用于自定义标签的解析条件,找出自定义类型所对应的NamespaceHandler并进行进一步解析,这个以后在详细讲此处先略过.

注册解析的BeanDefinition

对于配置文件,解析也解析完了,装饰也完成了,对于得到的beanDinition已经可以满足后续的使用要求了,唯一还剩下的工作就是注册了,也就是processBeanDefinition方法中的BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());代码的解析了.

/**
 * Register the given bean definition with the given bean factory.
 * @param definitionHolder the bean definition including name and aliases
 * @param registry the bean factory to register with
 * @throws BeanDefinitionStoreException if registration failed
 */
public static void registerBeanDefinition(
        BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
        throws BeanDefinitionStoreException {

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

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

使用beanName 注册BeanDefinition

对于beanDefinition的注册,或许很多人认为的方式就是讲beanDefinition直接放入map中就好了,使用beanName作为key.确实,Spring就是这么做的,只不过除此之外,它还做了点别的事情.

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

		Assert.hasText(beanName, "Bean name must not be empty");
		Assert.notNull(beanDefinition, "BeanDefinition must not be null");

		if (beanDefinition instanceof AbstractBeanDefinition) {
            /**
            注册前最后一次校验，不是对XML文件进行校验
            主要是对于AbstractBeanDefinition属性中的methodOverrides的校验
            校验methodOverrides是否与工厂方法并存，或者methodOverrides对应的方法根本不存在
            */
			try {
				((AbstractBeanDefinition) beanDefinition).validate();
			}
			catch (BeanDefinitionValidationException ex) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Validation of bean definition failed", ex);
			}
		}

		BeanDefinition oldBeanDefinition;

		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
        //处理已经注册的beanName的情况
		if (oldBeanDefinition != null) {
            // 如果对应的BeanName已经注册且在配置中配置了bean则不允许被覆盖(抛出异常)
			if (!isAllowBeanDefinitionOverriding()) {
				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
						"': There is already [" + oldBeanDefinition + "] bound.");
			}
			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
				if (this.logger.isWarnEnabled()) {
					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
							"' with a framework-generated bean definition: replacing [" +
							oldBeanDefinition + "] with [" + beanDefinition + "]");
				}
			}
			else if (!beanDefinition.equals(oldBeanDefinition)) {
				if (this.logger.isInfoEnabled()) {
					this.logger.info("Overriding bean definition for bean '" + beanName +
							"' with a different definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			else {
				if (this.logger.isDebugEnabled()) {
					this.logger.debug("Overriding bean definition for bean '" + beanName +
							"' with an equivalent definition: replacing [" + oldBeanDefinition +
							"] with [" + beanDefinition + "]");
				}
			}
			this.beanDefinitionMap.put(beanName, beanDefinition);
		}
		else {
			if (hasBeanCreationStarted()) {
				// Cannot modify startup-time collection elements anymore (for stable iteration)
                // beanDefinitionMap:new ConcurrentHashMap<String, BeanDefinition>(256);
                //因为beanDefinitionMap是全局变量,这里定会存在并发访问的情况
				synchronized (this.beanDefinitionMap) {
					this.beanDefinitionMap.put(beanName, beanDefinition);
					List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
					updatedDefinitions.addAll(this.beanDefinitionNames);
					updatedDefinitions.add(beanName);
					this.beanDefinitionNames = updatedDefinitions;
					if (this.manualSingletonNames.contains(beanName)) {
						Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
						updatedSingletons.remove(beanName);
						this.manualSingletonNames = updatedSingletons;
					}
				}
			}
			else {
				// Still in startup registration phase
                //注册beanDefinition
				this.beanDefinitionMap.put(beanName, beanDefinition);
                //记录beanName
				this.beanDefinitionNames.add(beanName);
				this.manualSingletonNames.remove(beanName);
			}
			this.frozenBeanDefinitionNames = null;
		}

		if (oldBeanDefinition != null || containsSingleton(beanName)) {
            //重置所有beanName对应的缓存
			resetBeanDefinition(beanName);
		}
	}

上面的代码中我们看到,在对于bean的注册处理方式上,主要进行了几个步骤:

对于AbstractBeanDefinition的校验,在解析XML文件的时候我们提过校验,但是此校验非彼校验,之前的校验是针对XML格式的校验,而此时的校验是针对AbstractBeanDefinition属性中的methodOverrides的校验;
对beanName已经注册的情况的处理,如果设置了不允许bean的覆盖,则需要抛出异常,否则直接覆盖;
加入map缓存;
清楚解析之前留下的对应的beanName的缓存.

通过别名注册BeanDefinition

@Override
public void registerAlias(String name, String alias) {
    Assert.hasText(name, "'name' must not be empty");
    Assert.hasText(alias, "'alias' must not be empty");
    //锁
    synchronized (this.aliasMap) {
        //如果beanName与alias相同的话不记录alias,并删除对应的alias
        if (alias.equals(name)) {
            this.aliasMap.remove(alias);
            if (logger.isDebugEnabled()) {
                logger.debug("Alias definition '" + alias + "' ignored since it points to same name");
            }
        }
        else {
            String registeredName = this.aliasMap.get(alias);
            if (registeredName != null) {
                if (registeredName.equals(name)) {
                    // An existing alias - no need to re-register
                    return;
                }
                //如果alias不允许被覆盖则抛出异常
                if (!allowAliasOverriding()) {
                    throw new IllegalStateException("Cannot define alias '" + alias + "' for name '" +
                            name + "': It is already registered for name '" + registeredName + "'.");
                }
                if (this.logger.isInfoEnabled()) {
                    logger.info("Overriding alias '" + alias + "' definition for registered name '" +
                            registeredName + "' with new target name '" + name + "'");
                }
            }
            // 当 A -> B 存在时,若再次出现 A -> C -> B 时则会抛出异常
            checkForAliasCircle(name, alias);
            this.aliasMap.put(alias, name);
            if (logger.isDebugEnabled()) {
                logger.debug("Alias definition '" + alias + "' registered for name '" + name + "'");
            }
        }
    }
}

由以上代码中可以得知注册alias的步骤如下:

alias与beanName相同情况的处理,若alias与beanName名称相同则不需要处理并删除原有alias;
alias覆盖处理,若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理.
alias循环检查,当 A -> B 存在时,若再次出现 A -> C -> B 时则会抛出异常.(TODO)
注册alias.

通知监听器解析及注册完成

通过代码getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));完成此工作,这里的实现只为扩展,当程序开发人员需要对注册BeanDefinition事件进行监听时可以通过注册监听器的方式并将处理逻辑写入监听器中,目前在Spring中并没有对此事做任何逻辑处理.

alias 标签的解析

alias标签应用场景

在对bean进行定义时,除了使用id属性来指定名称之外,为了提升多个名称,可以使用alias标签来指定.而所有的这些名称都指向同一个bean,在某些情况下提供别名非常有用,比如为了让应用的每个组件能更容易地对公共组件进行引用.

alias标签使用方法

配置文件定义JavaBean

<bean id="testBean" class="com.test" />

要给这个JavaBean增加别名,以方便不同对象来调用.我们就可以直接使用bean标签中的name属性:

<bean id="testBean" name="testBean,testBean2" class="com.test" />

同样,Spring还有另外一种声明别名的方式:

<bean id="testBean" class="com.test" />
<alias name="testBean" alias="testBean,testBean2" />

举例：组件A在XML配置文件中定义了一个名为componentA的DataSource类型的bean,但组件B却想在其XML文件中以componentB命名来引用此bean.而且在主程序MyApp的XML配置文件中,希望以myApp的名字来引用此bean.最后容器加载3个XML文件来生成最终的ApplicationContext.在此情形下,可通过在配置文件中添加下列alias元素来实现

<alias name="componentA" alias="componentB" />
<alias name="componentA" alias="myApp" />

这样一来,每个组件及主程序就可通过唯一名字来引用同一个数据源而互不干扰.

源码分析

protected void processAliasRegistration(Element ele) {
    //获取beanName
    String name = ele.getAttribute(NAME_ATTRIBUTE);
    //获取alias
    String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
    boolean valid = true;
    if (!StringUtils.hasText(name)) {
        getReaderContext().error("Name must not be empty", ele);
        valid = false;
    }
    if (!StringUtils.hasText(alias)) {
        getReaderContext().error("Alias must not be empty", ele);
        valid = false;
    }
    if (valid) {
        try {
            //注册alias
            getReaderContext().getRegistry().registerAlias(name, alias);
        }
        catch (Exception ex) {
            getReaderContext().error("Failed to register alias '" + alias +
                    "' for bean with name '" + name + "'", ele, ex);
        }
        getReaderContext().fireAliasRegistered(name, alias, extractSource(ele));
    }
}

可以发现,跟之前讲过的bean中的alias解析大同小异,都是将别名与beanName组成一队注册至registry中

import标签的解析

场景

庞大项目的分模块开发时，构造spring配置文件

使用方法

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="customerContext.xml" />
    <import resource="systemContext.xml" />
    ... ...
</beans>

applicationContext.xml文件中使用import的方式导入有模块配置文件,以后若有新模块的加入,那就可以简单修改这个文件即可.这样大大简化了配置后期维护的复杂度,并使配置模块化,易于管理.

源码分析

protected void importBeanDefinitionResource(Element ele) {
    //获取resource属性
    String location = ele.getAttribute(RESOURCE_ATTRIBUTE);
    //如果不存在resource属性则不做任何处理
    if (!StringUtils.hasText(location)) {
        getReaderContext().error("Resource location must not be empty", ele);
        return;
    }

    // 解析系统属性，格式为: e.g. "${user.dir}"
    location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);

    Set<Resource> actualResources = new LinkedHashSet<Resource>(4);

    // 判断 location 是绝对还是相对 URI
    boolean absoluteLocation = false;
    try {
        absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
    }
    catch (URISyntaxException ex) {
        // cannot convert to an URI, considering the location relative
        // unless it is the well-known Spring prefix "classpath*:"
    }

    // Absolute or relative?
    //如果是绝对URI,则直接根据地址加载对应的文件
    if (absoluteLocation) {
        try {
            int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources);
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]");
            }
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error(
                    "Failed to import bean definitions from URL location [" + location + "]", ele, ex);
        }
    }
    else {
        // No URL -> considering resource location as relative to the current file.
        //如果是相对地址，则根据根据相对地址计算出绝对地址
        try {
            int importCount;
            //Resource存在多个子实现类，如 VfsResource，FileSystemResource，每个Resource的createRelative方法不一样，这里先使用子类的方法尝试解析
            Resource relativeResource = getReaderContext().getResource().createRelative(location);
            if (relativeResource.exists()) {
                importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource);
                actualResources.add(relativeResource);
            }
            else {
                //如果解析不成功，则使用默认的解析器ResourcePatternResolver进行解析
                String baseLocation = getReaderContext().getResource().getURL().toString();
                importCount = getReaderContext().getReader().loadBeanDefinitions(
                        StringUtils.applyRelativePath(baseLocation, location), actualResources);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]");
            }
        }
        catch (IOException ex) {
            getReaderContext().error("Failed to resolve current resource location", ele, ex);
        }
        catch (BeanDefinitionStoreException ex) {
            getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]",
                    ele, ex);
        }
    }
    //解析后进行监听激活处理
    Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]);
    getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele));
}

上述代码的大致流程如下

获取resource属性表示的路径;
解析路径中的系统属性,格式如"${user.dir}";
判定location是绝对路径还是相对路径;
如果是绝对路径则递归调用bean的解析过程,进行另一次的解析;
如果是相对路径则计算出绝对路径并进行解析;
通知监听器,解析完成.

嵌入式beans标签的解析

使用场景

非常类似于import标签所提供的功能

使用方法

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="aa" class="test.aa" />
    <beans></beans>
</beans>