在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是接口,他的实现类有几个,就有几种,但是关键的实现类有三个:RootBeanDefinition、ChildBeanDefinition、GenericBeanDefinition.面试的时候只要回答出这三个,并且把这三种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>
550
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
