spring中默认标签Bean标签解析一

在Spring种有两种标签,一种是默认标签,另一种是自定义标签.对两种标签的用法和解析方式存在着很大的不同.
首先分析的是默认标签的解析过程.
解析标签的入口代码

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

接着进入到parseDefaultElement方法中

    private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
        if (delegate.nodeNameEquals(ele, "import")) {
        	// 解析import标签
            this.importBeanDefinitionResource(ele);
        } else if (delegate.nodeNameEquals(ele, "alias")) {
        	// 解析alias标签
            this.processAliasRegistration(ele);
        } else if (delegate.nodeNameEquals(ele, "bean")) {
        	// 解析bean标签
            this.processBeanDefinition(ele, delegate);
        } else if (delegate.nodeNameEquals(ele, "beans")) {
        	// 解析beans标签
            this.doRegisterBeanDefinitions(ele);
        }
    }

从上面可以看到Spring分别对四种标签做了不同的解析.在这四种标签里边,bean标签的解析最复杂也是最重要,理解了bean标签的处理过程,其他的举一反三就能明白.

bean标签的解析及注册

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
		// 元素解析,经过这个方法后
		// bdHolder包含了配置文件中的配置的各种属性:
		// class、name、id、alias等
        BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
        if (bdHolder != null) {
        	// 判断是否需要进一步的解析
        	// 如果默认标签的子节点有自定义标签,则需要进一步解析自定义标签
            bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

            try {
            	// 对解析后的bdHolder进行注册
                BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, this.getReaderContext().getRegistry());
            } catch (BeanDefinitionStoreException var5) {
                this.getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, var5);
            }
            // 发出响应事件:通知相关监听器,bean加载完成
            this.getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
        }
    }

对应的时序图如下
在这里插入图片描述

解析BeanDefinition

根据时序图一步步解析

	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}
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)) {
			// name属性是可以根据分隔符进行分隔而设置多个的
			String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
			aliases.addAll(Arrays.asList(nameArr));
		}
		// beanName 等于id
		String beanName = id;
		// 如果beanName为空并且别名不为空,则取别名中的第一个作为beanName
		// 否则beanName就是id
		if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
			beanName = aliases.remove(0);
		}

		if (containingBean == null) {
			// 检查beanName和aliases有没有被使用
			checkNameUniqueness(beanName, aliases, ele);
		}

		// 进一步解析元素的其他属性,并创建beanDefinition
		// 把解析的元素存储在beanDefinition的属性中
		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			// 如果没有指定beanName,则按照默认规则生成beanName
			if (!StringUtils.hasText(beanName)) {
				try {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						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;
	}

接下来主要看一下对其他元素的解析:

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

		this.parseState.push(new BeanEntry(beanName));

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

		try {
			// 1、创建beanDefinition,根据源码可知,这里创建的是GenericBeanDefinition类型的
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);
			// 2、硬编码解析默认bean的各种属性
			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			// 提取description
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
			// 3、解析元数据
			parseMetaElements(ele, bd);
			// 4、解析lookup-override属性
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 5、解析replace-method
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			// 6、解析构造器参数
			parseConstructorArgElements(ele, bd);
			// 7、解析property子元素
			parsePropertyElements(ele, bd);
			// 8、解析qualifier
			parseQualifierElements(ele, bd);

			bd.setResource(this.readerContext.getResource());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (Exception ex) {
			error("error", ele, ex);
		}
		finally {
			this.parseState.pop();
		}
		return null;
	}

根据解析的代码我们逐步进入源码一探究竟.
1、创建用于承载属性的BeanDefintion
为什么解析bean的时候需要创建BeanDefinition呢?
因为BeanDefinition中的属性和< bean>标签的属性是一一对应的,比如BeanDefinition提供了beanClass、scope、lazyInit等和< bean>标签的class、scope、lazy-int等属性对应.
这里还有一个面试题,有一次小编面试的时候就遇到了,当时回答的也是惨不忍睹,但是出奇的是,面试竟然过了.
当时面试官问了这么一个问题:你知道Spring中的BeanDefinition有几种吗?
我的内心就是:不就是BeanDefinition吗?还有几种吗?回来百度之后才知道,BeanDefinition是接口,他的实现类有几个,就有几种,但是关键的实现类有三个:RootBeanDefinitionChildBeanDefinitionGenericBeanDefinition.面试的时候只要回答出这三个,并且把这三种BeanDefinition的使用场景讲清楚就够了,并不需要把每一个都讲出来.

  • RootBeanDefinition:最常用的实现类,他对应一般性的< bean>,在配置文件中可以定义父< bean>和子< bean>,父< bean>用RootBeanDefinition,而子< bean>用ChildBeanDefinition表示,如果没有父< bean>就使用RootBeanDefinition.AbstractBeanDefinition对两者共同的类信息进行了抽象
  • GenericBeanDefinition:他是自2.5版本以后新加入的bean文件配置属性定义类,是一站式服务类.

2、硬编码解析属性
有了beanDefinition之后,就可以进行属性的解析,并把解析的属性值存放到beanDefinition对应的成员变量中.

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
			@Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
		// 如果有singleton属性则报错,
		// 因为我的源码版本是5.2.8,
		// Spring在老的1.x版本中使用singleton,但是后面把这个属性弃用了,改成使用scope
		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));
		}
		// 在嵌入beanDefinition情况下,并没有单独指定scope属性,则使用父类默认的属性
		else if (containingBean != null) {
			// Take default from containing bean in case of an inner bean definition.
			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 (isDefaultValue(lazyInit)) {
			lazyInit = this.defaults.getLazyInit();
		}
		// 如果没有设置或设置成其他字符都会被设置为false
		bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
		// 解析autowire属性
		String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
		bd.setAutowireMode(getAutowireMode(autowire));
		
		// 解析dependency-on属性
		if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
			String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
			bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
		}
		
		// 解析autowire-candidate属性
		String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
		if (isDefaultValue(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-method属性
		if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
			String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
			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;
	}

3、解析子元素meta

meta属性的使用:

<bean id="myTestBean" class="bean.myTestBean">
	<meta key="myKey" value="myValue">
</bean>

上面meta的配置并不会被注入到myTestBean的属性中,仅仅是一个声明的作用,当需要使用里面的信息的时候,可以通过BeanDefinition的get Attribute(key)方法获取.

	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;
				// 使用key、value构造BeanMetadataAttribute
				String key = metaElement.getAttribute(KEY_ATTRIBUTE);
				String value = metaElement.getAttribute(VALUE_ATTRIBUTE);
				BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
				// 记录信息
				attribute.setSource(extractSource(metaElement));
				attributeAccessor.addMetadataAttribute(attribute);
			}
		}
	}

4、解析子元素lookup-method

lookup-method的使用
(1)创建一个父类

public class Animal {
    public void showMe(){
        System.out.println("I am a animal");
    }
}

(2)创建一个子类

public class BlackCat extends Animal{

    @Override
    public void showMe() {
        System.out.println("I am blackCat");
    }
}

(3)创建一个调用方法

public abstract class GetBeanTest {
    
    public void showMe(){
    	// 注意这里
        this.getBean().showMe();
    }
    
    public abstract Animal getBean();

}

(4)测试

public class Main {

    public static void main(String[] args) {
        ApplicationContext bf = new ClassPathXmlApplicationContext("lookupTest.xml");
        GetBeanTest getBeanTest = bf.getBean("getBeanTest");
        getBeanTest.showMe();
    }
}

到这里,除了配置文件之外,其他的准备工作都好了.
上面注意的地方,肯定会有疑惑,为什么抽象方法还没有实现就能调用呢?这就是lookup-method的作用了.
(5)配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beas 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= "getBeanTest" class="com.itpluto.demo.GetBeanTest">
        <lookup-method name="getBean" bean="blackCat" />
    </bean>
    <bean id="blackCat" class="com.itpluto.demo.BlackCat"></bean>
</beas>

这个配置文件就是把上面GetBeanTest类中getBean方法返回值指定为blackCat.
这样的话,getBeanTest.showMe();控制台输出的就是 I am blackCat.
如果以后blackCat不能满足我们了,我们只需要修改一下配置文件,增加一个新的Animal的实现类即可.

public class WhiteCat extends Animal{

    @Override
    public void showMe() {
        System.out.println("I am whiteCat");
    }
}
<?xml version="1.0" encoding="UTF-8" ?>
<beas 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= "getBeanTest" class="com.itpluto.demo.GetBeanTest">
        <lookup-method name="getBean" bean="whiteCat" />
    </bean>
    <bean id="whiteCat" class="com.itpluto.demo.WhiteCat"></bean>
</beas>

这个时候控制台输出的就是:I am whiteCat

源码解析

public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			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);
			}
		}
	}

5、解析子元素replace-method

replace-method的使用
方法替换:可以在运行时用新的方法替换现有的方法,replace-method不但可以动态替换返回实体bean,而且还能动态的更改原有方法的逻辑.

一开始使用的业务:

public class TestChangeMethod {
    public void changeMe(){
        System.out.println("changeMe");
    }
}

后来需要改变原有的业务逻辑:

    public class TestMethodReplacer implements MethodReplacer{

    @Override
    public Object reImplement(Object obj, Method method, Object[] arg) throws Throwable{
        System.out.println("我替换了原来的方法");
        return null;
    }
}

配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beas 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="com.itpluto.demo.TestChangeMethod">
        <repace-method name="changeMe" replacer="testMethodReplacer"/>
    </bean>
    <bean id="testMethodReplacer" class="com.itpluto.demo.TestMethodReplacer"></bean>

</beas>

测试

public static void main(String[] args) {
        ApplicationContext bf = new ClassPathXmlApplicationContext("replaceMethod.xml");
        TestChangeMethod testChangeMethod = bf.getBean("testChangeMethod");
        testChangeMethod.changeMe();
    }

输出的结果:我替换了原来的方法.

源码解析:

public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			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);
			}
		}
	}

6、解析子元素construtor-arg

源码解析

	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)) {
				// 解析construct-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对应的属性元素
						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 {
							//注意这使用的是beanDefinition的ConstructorArgumentValues的indexedArgumentValues
							bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
						}
					}
					finally {
						this.parseState.pop();
					}
				}
			}
			catch (NumberFormatException ex) {
				error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
			}
		}
		// 没有index属性,自动寻找
		else {
			try {
				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));
				// 	注意这里使用的是beanDefinition的ConstructorArgumentValues的genericArgumentValues属性
				bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
			}
			finally {
				this.parseState.pop();
			}
		}
	}

可以看到对于是否有index的属性,大致流程是相同的,只是最后存放的位置不同.
下面接着探索

public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
		String elementName = (propertyName != null ?
				"<property> element for property '" + propertyName + "'" :
				"<constructor-arg> element");

		// Should only have one child element: ref, value, list, etc.
		// 一个属性只能对应一种类型:ref、value、list等
		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;
				}
			}
		}
		// 判断是否有ref属性
		boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
		// 判断是否有value属性
		boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
		// construct-arg上不存在
		// 	1、既有ref属性又有value属性
		//	2、存在ref属性或者value属性且又有子元素
		if ((hasRefAttribute && hasValueAttribute) ||
				((hasRefAttribute || hasValueAttribute) && subElement != null)) {
			error(elementName +
					" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
		}
		// 解析ref属性,使用RuntimeBeanReference来封装对应的ref名称
		if (hasRefAttribute) {
			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;
		}
		// 解析value属性,使用TypedStringValue来封装
		else if (hasValueAttribute) {
			TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
			valueHolder.setSource(extractSource(ele));
			return valueHolder;
		}
		// 解析子元素
		else if (subElement != null) {
			return parsePropertySubElement(subElement, bd);
		}
		else {
			// Neither child element nor "ref" or "value" attribute found.
			error(elementName + " must specify a ref or value", ele);
			return null;
		}
	}

而对于有子元素是如何处理的呢?

	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
	}
public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
		if (!isDefaultNamespace(ele)) {
			// 如果不是默认的子元素,就使用自定义解析
			return parseNestedCustomElement(ele, bd);
		}
		// 对bean元素的解析,和之前分析的一致
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
		// 对于ref元素的解析
		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 a parent context.
				// 解析parent
				refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
				toParent = true;
				if (!StringUtils.hasLength(refName)) {
					error("'bean' 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解析
		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;
		}
		// 对array解析
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
		// 对list解析
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
		// 对set解析
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
		// 对map解析
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		// 对props解析
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

可以看到,Spring对不同的子元素分别做了解析处理.

7、解析子元素property

	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)) {
				// 解析 property
				parsePropertyElement((Element) node, bd);
			}
		}
	}
public void parsePropertyElement(Element ele, BeanDefinition bd) {
		// 获取配置元素中的name值
		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));
			// 记录在beadfinition的propertyValues属性中
			bd.getPropertyValues().addPropertyValue(pv);
		}
		finally {
			this.parseState.pop();
		}
	}

8、解析子元素qualifer
该属性我们最多的是运用在注解当中,但是Spring配置文件中也提供了这个属性.
Spring允许我们通过Qualifier指定注入Bean的名称,消除歧义:

    <bean id="testMethodReplacer" class="com.itpluto.demo.TestMethodReplacer">
        <qualifer type="org.Springframework.beans.factory.annotation.Qualifier" value="qt"/>
    </bean>
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值