默认标签的解析
spring中的标签包括默认标签和自定义标签两种,默认标签的解析是在parseDefaultElement方法中进行的,在该方法中分别对4中不同的标签(import、alias、bean和beans)进行解析
//public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader
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);
}
}
1、bean标签的解析及注册
//public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//1.解析ele,返回BeanDefinitionHolder类型实例bdHolder,经过这个方法后,bdHolder实例已经包含我们配置文件中配置的各种属性,例如:class,name,id,alias等
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//2.当返回的bdHolder不为空的情况下若存在默认标签的字标签下再有自定义属性,还需要再次对自定义标签进行解析
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//3.对bdHolder进行注册
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//4.发出相应事件,通知相关的监听器,这个bean已经被加载完了
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
逻辑分析:
(1) 首先委托BeanDefinitionParserDelegate类的parseBeanDefinitionElement方法进行元素解析,返回BeanDefinitionHolder 类型的实例bdHolder, 经过这个方法后,bdHolder实例已经包含配置文件中配置的bean标签的各种属性,例如class, name, id, alias之类的属性
(2) 当返回的bdHolder不为空的情况下若存在默认标签的子节点下再有自定义属性, 还需要再次对自定义标签进行解析
(3) 解析完成后,需要对bdHolder进行注册,同样,注册操作委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法
(4) 最后发出响应事件,通知相关的监听器这个bean已经加载完成了
1.1 解析bean标签的属性及默认子元素
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
parseBeanDefinitionElement(Element ele) 方法的实现:
//public class BeanDefinitionParserDelegate
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属性的作用:用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。
List<String> aliases = new ArrayList<String>();
if (StringUtils.hasLength(nameAttr)) {
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
//设置beanName(默认将id设置为beanName)
String beanName = id;
//如果beanName不存在,则将设置的第一个别名作为beanName
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);
}
//解析bean默认的属性,及子标签;如果bean标签中含有自定义子标签,则先不处理自定义子标签
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);
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);
//创建BeanDefinitionHolder实例,并返回
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}
逻辑分析:
(1) 提取元素中的id以及name属性,并默认将id或者别名设置为beanName
(2) 进一步解析其他所有属性及子标签并统一封装至GenericBeanDefinition类型的实例中
(3) 如果检测到bean没有指定beanName,那么使用默认规则为此Bean生成beanName
(4) 将获取到的信息封装到BeanDefinitionHolder的实例中
解析bean的属性,及子标签:
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean)
parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean)方法的实现:
//public class BeanDefinitionParserDelegate
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {
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);
}
//要解析属性首先要创建用于存储承载属性的实例(即存储bean标签对应属性的实例),创建GenericBeanDefinition类型实例,并且返回该实例,
//使用抽象父类AbstractBeanDefinition接收
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
//解析bean标签的各种属性,并封装至GenericBeanDefinition类型的实例中
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
//以下为解析bean标签的子标签
//解析meta子元素(将GenericBeanDefinition类型实例传入,以便将解析后的结果存入该实例中)
parseMetaElements(ele, bd);
//解析lookup-method子标签
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
//解析replace-methos子标签
parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
//解析constructor-arg子标签
parseConstructorArgElements(ele, bd);
//解析property子标签
parsePropertyElements(ele, bd);
//解析qualifier子标签
parseQualifierElements(ele, bd);
bd.setResource(this.readerContext.getResource());
bd.setSource(extractSource(ele));
return bd;
}
catch (ClassNotFoundException ex) {
error("Bean class [" + className + "] not found", ele, ex);
}
catch (NoClassDefFoundError err) {
error("Class that bean class [" + className + "] depends on not found", ele, err);
}
catch (Throwable ex) {
error("Unexpected failure during bean definition parsing", ele, ex);
}
finally {
this.parseState.pop();
}
return null;
}
逻辑分析:
(1) 创建用于存储属性的BeanDefinition
(2) 解析各种属性
(3) 解析子元素
1.1.1 创建用于存储属性的BeanDefinition
注:
(1) BeanDefinition是一个接口,在spring中存在三种实现: RootBeanDefinition、ChildBeanDefinition以及GenericBeanDefinition; 三种实现均继承了AbstractBeanDefinition.其中BeanDefinition是配置文件<bean>元素标签在容器内部的表示形式; <bean>元素标签拥有class、scope、lazy-init等配置属性,BeanDefinition则提供了beanClass、scope、lazyInit属性,BeanDefinition的<bean>中的属性是一一对应的
(2) 在配置文件中可以定义父<bean>和子<bean>,父<bean>用RootBeanDefinition表示,而子<bean>用ChildBeanDefinition表示,而没有子<bean>和父<bean>之分就使用RootBeanDefinition表示
(3) spring通过BeanDefinition将配置文件中的<bean>的配置信息转换为容器的内部表示, 并将BeanDefinition注册到BeanDefinitionRegistry中; spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库,主要是以map的形式保存,后续操作直接从BeanDefinitionRegistry中读取配置信息
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
createBeanDefinition(String className, String parentName)方法的实现:
//public class BeanDefinitionParserDelegate
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
throws ClassNotFoundException {
return BeanDefinitionReaderUtils.createBeanDefinition(
parentName, className, this.readerContext.getBeanClassLoader());
}
//public class BeanDefinitionReaderUtils
public static AbstractBeanDefinition createBeanDefinition(
String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {
GenericBeanDefinition bd = new GenericBeanDefinition();
//parentName可能为空
bd.setParentName(parentName);
if (className != null) {
if (classLoader != null) {
//如果类名和类加载器都不为空,则使用已传入的classLoder同一虚拟机加载类对象,否则实时记录className;
bd.setBeanClass(ClassUtils.forName(className, classLoader));
}
else {
bd.setBeanClassName(className);
}
}
return bd;
}
逻辑分析:
(1) 在createBeanDefinition方法中委托BeanDefinitionReaderUtils类中的createBeanDefinition方法创建GenericBeanDefinition类型实例
(2) 创建GenericBeanDefinition类型实例并设置beanClass或beanClassName属性
1.1.2 解析各种属性
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
parseBeanDefinitionAttributes(Element ele, String beanName,BeanDefinition containingBean, AbstractBeanDefinition bd)方法的实现:
//public class BeanDefinitionParserDelegate
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
BeanDefinition containingBean, AbstractBeanDefinition bd) {
//1.如果含有singleton属性则报错,提示该属性已升级为scope属性
if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
}
//2.解析scope属性
else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
}
//3.如果存在内部Bean
else if (containingBean != null) {
// Take default from containing bean in case of an inner bean definition.
//在嵌入beanDifintion情况下且没有单独制定scope属性,则使用父类默认的属性
bd.setScope(containingBean.getScope());
}
//4.解析abstract属性
if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
}
//5.解析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));
//6.解析autowire属性
String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
bd.setAutowireMode(getAutowireMode(autowire));
//7.解析dependency-check属性
String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
bd.setDependencyCheck(getDependencyCheck(dependencyCheck));
//8.解析depends-on属性
if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
}
//9.解析autowire-candidate属性
String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) {
String candidatePattern = this.defaults.getAutowireCandidates();
if (candidatePattern != null) {
String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
}
}
else {
bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
}
//10.解析primary属性
if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
}
//11.解析init-method属性
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);
}
}
//解析destory-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;
}
逻辑分析:
解析bean标签的各种属性,并存储在GenericBeanDefinition类型实例中(该方法中解析的都是属性)
1.1.3 解析子标签meta
public void parseMetaElements(Element ele, BeanMetadataAttributeAccessor attributeAccessor) {
//获取当前节点的所有子节点
NodeList nl = ele.getChildNodes();
//遍历子节点集合,找出所有的meta子节点
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);
//存储meta标签中的key和value的值,当需要使用里面的信息的时候,可以通过BeanDefinition的getAttribute(key)属性进行获取
BeanMetadataAttribute attribute = new BeanMetadataAttribute(key, value);
attribute.setSource(extractSource(metaElement));
//一个bean内部可能有多个meta子标签
attributeAccessor.addMetadataAttribute(attribute);
}
}
}
1.1.4 解析子标签lookup-method
public void parseLookupOverrideSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
//遍历bean标签的子元素,找出lookup-method子标签,进行解析
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;
//获取lookup-methiod中设置的方法名
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);
}
}
}
逻辑分析:
在数据存储上面通过使用LookupOverride类型的实体来进行数据承载并记录在AbstractBeanDefinition中的methodOverrides属性中
1.1.5 解析子标签replace-method
public void parseReplacedMethodSubElements(Element beanEle, MethodOverrides overrides) {
NodeList nl = beanEle.getChildNodes();
//遍历bean标签的子元素,找出replace-method子标签,进行解析
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.
//获取replace-method标签的子标签
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还是replace-method都是构造了一个MethodOverride,并最终记录在了AbstractBeanDefinition中的methodOverrides属性中;
1.1.6 解析子标签constructor-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)) {
//解析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);
//如果constructor-arg标签设置了index属性
if (StringUtils.hasLength(indexAttr)) {
try {
int index = Integer.parseInt(indexAttr);
if (index < 0) {
error("'index' cannot be lower than 0", ele);
}
else {
try {
//将index的值传入
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 {
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));
bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
}
finally {
this.parseState.pop();
}
}
}
逻辑分析:
(1) 遍历所有子节点, 找出<constructor-arg>标签并进行解析
(2) 如果配置中指定了index属性
- 解析constructor-arg的子元素
- 使用ContructorArgumentValues.ValueHolder类型来封装解析出来的元素
- 将type、name和index属性一并封装在ContructorArgumentValues.ValueHolder类型中, 并添加至当前BeanDefinition的constructorArgumentValues的indexArgumentValues属性中
(3) 如果没有指定index属性
- 解析constructor-arg的子元素
- 使用ContructorArgumentValues.ValueHolder类型来封装解析出来的元素
- 将type、name和index属性一并封装在ContructorArgumentValues.ValueHolder类型中, 并添加至当前BeanDefinition的constructorArgumentValues的genericArgumentValues属性中
(4) 对于是否制定index属性来讲, spring的处理流程是不同的,关键在于属性信息被保存的位置
接下来是对<constructor-arg>的子标签进行解析:
Object value = parsePropertyValue(ele, bd, null);
parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) 方法的实现:
public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {
String elementName = (propertyName != null) ?
"<property> element for property '" + propertyName + "'" :
"<constructor-arg> element";
//一个属性只能对应一种类型: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);
//只允许有ref属性或者value属性,或者子元素
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);
}
//ref的属性的处理,使用Runtimereference封装对应的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) {
/**
* <constrtuctor-arg>
* <map>
* <entry key="k1" value="v2"/>
* <entry key="k1" value="v2"/>
* </map>
* </constrtuctor-arg>
*/
return parsePropertySubElement(subElement, bd);
}
else {
// Neither child element nor "ref" or "value" attribute found.
//既没有ref也没有value,也没有子元素,spring报错
error(elementName + " must specify a ref or value", ele);
return null;
}
}
逻辑分析:
(1) 略过description或者meta
(2) 提取constructor-arg上的arg和value属性,以便于根据规则验证正确性,其规则为在constructor-arg上不存在以下情况
- 同时既有ref属性又有value属性
- 存在ref属性或者value属性且又有子元素
(3) ref属性的处理,使用RuntimeBeanReference封装对应的ref名称
(4) value属性的处理, 使用TypedStringvalue封装
(5) 子元素的处理
接下来是对子元素的处理,在parsePropertySubElement方法中实现了对各种子元素的分类处理:
parsePropertySubElement(subElement, bd);
parsePropertySubElement(Element ele, BeanDefinition bd)方法的实现:
public Object parsePropertySubElement(Element ele, BeanDefinition bd) {
return parsePropertySubElement(ele, bd, null);
}
/**
* Parse a value, ref or collection sub-element of a property or
* constructor-arg element.
* @param ele subelement of property element; we don't know which yet
* @param defaultValueType the default type (class name) for any
* {@code <value>} tag that might be created
*/
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)) {
String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
boolean toParent = false;
if (!StringUtils.hasLength(refName)) {
//解析local
refName = ele.getAttribute(LOCAL_REF_ATTRIBUTE);
if (!StringUtils.hasLength(refName)) {
//解析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元素的解析
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)) {
//解析array子元素
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;
}
}
1.1.7解析子元素property
parsePropertyElement方法实现了对/标签中property子标签的提取,property使用方法如下:
<bean id=“test” class=“test.TestClass”>
<property name=“testStr” value=“aaa” />
</bean>
或者
<bean id=“test”>
<property name=“testStr”>
<list>
<value>aa</value>
<value>bb</value>
</list>
</property>
</bean>
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) {
//获取配置元素中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));
bd.getPropertyValues().addPropertyValue(pv);
}
finally {
this.parseState.pop();
}
}
逻辑分析:
该方法与构造函数的注入方式不同的是将返回值使用PropertyValue进行封装,并记录在BeanDefinition中的propertyValues属性中
至此已经完成了对XML文档到GenericBeanDefinition的转换,XML中所有的配置都可以在
GenericBeanDefinition中找到对应的配置,GenericBeanDefinition只是子类实现,而大部分的通用属性都保存在AbstractBeanDefinition中;
1.2 解析默认标签中的自定义标签元素
在parseDefaultElement(Element, BeanDefinitionParserDelegate)方法中对bean标签进行处理,具体内容如下:
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//1.解析ele,返回BeanDefinitionHolder类型实例bdHolder,经过这个方法后,bdHolder实例已经包含我们配置文件中配置的各种属性,例如:class,name,id,alias等
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
//2.当返回的bdHolder不为空的情况下若存在默认标签的字标签下再有自定义属性,还需要再次对自定义标签进行解析
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
//3.对bdHolder进行注册
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
//4.发出相应事件,通知相关的监听器,这个bean已经被加载完了
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
该句代码适用于这样的场景:
<bean>
<mybean:user username=“test”>
</bean>
即当spring中的bean使用的是默认的标签配置但其中的子标签使用了自定义的配置时,这句代码便会起作用
decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) 方法的实现:
//public class BeanDefinitionParserDelegate
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(Element ele, BeanDefinitionHolder definitionHolder) {
//传递第三个参数是为了使用父类的scope属性,以备子类若没有设置scope属性是默认使用父类的属性,这里分析的是顶层配置,所以传递null
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;
}
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;
}
逻辑分析:
(1) 首先获取属性或者元素的命名空间,以此来判断该元素或者属性是否适用于自定义标签的解析条件,找出自定义类型所对应的NamespaceHandler并进一步解析
(2) decorateBeanDefinitionIfRequired方法的作用,在decorateBeanDefinitionIfRequired中我们可以看到对于程序默认的标签的处理其实是直接略过的,因为默认标签到这里已经被处理完了,这里只对自定义的标签进行处理,在方法中实现了寻找自定义标签并根据自定义标签寻找命名空间处理器,并进行进一步的解析
(3) spring中对默认标签和自定义标签的解析都是在BeanDefinitionParserDelegate类中完成的
1.3注册解析的BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
//public class BeanDefinitionReaderUtils
public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {
//1.使用beanName做唯一标识注册
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());
//2.注册所有的别名
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
//便利别名集合,对别名进行注册
for (String alias : aliases) {
registry.registerAlias(beanName, alias);
}
}
}
逻辑分析:
解析的BeanDefinition都会被注册到BeanDefinitionRegistry类型的实例registry中,而对于beanDefinition的注册分为了两部分:通过beanName的注册以及通过别名的注册
1.3.1 通过beanName注册BeanDefinition
registerBeanDefinition(beanName, definitionHolder.getBeanDefinition())方法的实现:
//public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
//判断beanName和beanDefinition不能为空
Assert.hasText(beanName, "Bean name must not be empty");
Assert.notNull(beanDefinition, "BeanDefinition must not be null");
if (beanDefinition instanceof AbstractBeanDefinition) {
try {
/**
* 注册前的最后一次校验,这里的校验不同于之前的XML文件校验
* 主要是对于AbstracBeanDefinition属性中的methodOverrides校验,
* 校验methodOverrides是否与工厂方法并存或者methodOverrides对应的方法不存在
*/
((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()) {
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 + "]");
}
}
//注册beanDefinition(将beanDefinition放入map缓存中)
this.beanDefinitionMap.put(beanName, beanDefinition);
}
//处理注册未被注册的beanName的情况
else {
//不是第一次注册beanDefinition
if (hasBeanCreationStarted()) {
//因为beanDefinitionMap是全局变量,这里肯定会存在并发访问的情况
synchronized (this.beanDefinitionMap) {
//注册beanDefinition
this.beanDefinitionMap.put(beanName, beanDefinition);
//创建新的集合来更新存储已注册beanName的beanDefinitionNames集合
List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);
updatedDefinitions.addAll(this.beanDefinitionNames);
updatedDefinitions.add(beanName);
this.beanDefinitionNames = updatedDefinitions;
//更新manualSingletonNames(存储单例bean)集合
if (this.manualSingletonNames.contains(beanName)) {
Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);
updatedSingletons.remove(beanName);
this.manualSingletonNames = updatedSingletons;
}
}
}
//第一次注册beanDefinition
else {
this.beanDefinitionMap.put(beanName, beanDefinition);
this.beanDefinitionNames.add(beanName);
this.manualSingletonNames.remove(beanName);
}
this.frozenBeanDefinitionNames = null;
}
if (oldBeanDefinition != null || containsSingleton(beanName)) {
//重置所有beanName对应的缓存
resetBeanDefinition(beanName);
}
}
逻辑分析:
(1) 对AbstractBeanDefinition的校验; 在解析XML文件时也进行过校验,但是,之前的校验是针对XML格式的校验,而此时的校验是针对于AbstractBeanDefinition的methodOverrides属性的
(2) 对beanName已经注册的情况;如果设置了不允许覆盖,则需要抛出异常没否则直接覆盖
(3) 加入map缓存;beanName为key,beanDefinition为value
(4) 清除解析之前留下的对应beanName的缓存
1.3.2 通过别名注册BeanDefinition
//public class SimpleAliasRegistry implements AliasRegistry
public void registerAlias(String name, String alias) {
Assert.hasText(name, "'name' must not be empty");
Assert.hasText(alias, "'alias' must not be empty");
//如果beanName与alias相同的话不记录alias,并删除对应的alias
if (alias.equals(name)) {
this.aliasMap.remove(alias);
}
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 register alias '" + alias + "' for name '" +
name + "': It is already registered for name '" + registeredName + "'.");
}
}
//alias循环检查,当A->B存在时,若再次出翔A->C->B时候则会抛出异常
checkForAliasCircle(name, alias);
this.aliasMap.put(alias, name);
}
}
逻辑分析:
(1) alias与beanName相同情况处理: 若alias与beanName名称相同则不需要处理并删除原有alias
(2) alias覆盖处理: 若aliasName已经使用并已经指向了另一beanName则需要用户的设置进行处理
(3) alias循环检查: 当A -> B存在时,若再次出现A -> C -> B是会抛出异常
(4) 注册alias,即将alias和beanName存入aliasMap集合中
1.4 通知监听器解析及注册完成
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder))
这里的实现只为了扩展,当程序开发人员需要对注册BeanDefinition事件进行监听是可以通过注册监听器的方式并将处理逻辑写入监听器中,目前在spring中并没有对此时间做任何逻辑处理
2、alias标签的解析
processAliasRegistration(ele)
processAliasRegistration(Element ele)方法的实现:
//public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader
protected void processAliasRegistration(Element ele) {
//获取name的值
String name = ele.getAttribute(NAME_ATTRIBUTE);
//获取alias的值
String alias = ele.getAttribute(ALIAS_ATTRIBUTE);
//定义一个验证标签,只有name和alias的值都不为空才对alias进行注册
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基本一样,都是通过调用getReaderContext().getRegistry().
registerAlias(name, alias)方法将别名与beanName组成一对注册至registry中
3、import标签的解析
importBeanDefinitionResource(ele)
//public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader
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;
}
//解析路径中的系统属性,格式如:"${user.dir}"
location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location);
Set<Resource> actualResources = new LinkedHashSet<Resource>(4);
//判定location是绝对路径还是相对路径
boolean absoluteLocation = false;
try {
absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute();
}
catch (URISyntaxException ex) {
}
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 {
//如果是相对地址则根据相对地址计算出绝对地址
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));
}
逻辑分析:
(1) 获取resource属性所表示的路径
(2) 解析路径中的系统属性,格式如"${user.dir}"
(3) 判定location是绝对路径还是相对路径
(4) 如果是绝对路径则递归调用bean的解析过程,进行另一次的解析
(5) 如果是相对路径则计算出绝对路径并进行解析
(6) 通知监听器,解析完成
4、beans标签的解析
doRegisterBeanDefinitions(ele)
对于嵌入式beans标签,则递归调用beans的解析过程
doRegisterBeanDefinitions(Element root)方法的实现:
//public class DefaultBeanDefinitionDocumentReader implements BeanDefinitionDocumentReader
protected void doRegisterBeanDefinitions(Element root) {
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createDelegate(getReaderContext(), root, parent);
//判断是否是默认的名称空间
if (this.delegate.isDefaultNamespace(root)) {
//处理profile属性
String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
if (StringUtils.hasText(profileSpec)) {
String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
return;
}
}
}
//解析前处理,留给子类实现(设计模式:模板方法模式)
preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
//解析后处理,留给子类实现
postProcessXml(root);
this.delegate = parent;
}
148
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
