1. 首页
  2. Java
  3. Spring
  4. Spring源码分析

默认标签解析 一

spring标签分为默认标签和自定义标签,两种标签的解析方式有很大不同。默认标签的解析是在parseDefaultElement函数中进行的,调用逻辑还是比较清晰的,分别对四种标签(import,alias,bean,beans)做了不同的处理。

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
	if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
		importBeanDefinitionResource(ele);
	}
	else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
		processAliasRegistration(ele);
	}
	else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		processBeanDefinition(ele, delegate);
	}
	else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
		// recurse
		doRegisterBeanDefinitions(ele);
	}
}

bean标签的解析及注册

四种标签的解析中bean标签的解析过程最为复杂和重要,如果能够理解bean标签的解析过程,那么其他标签的解析自然会迎刃而解

首先来看看processBeanDefinition(ele,delegate)

/**
	 * 处理给定的bean元素,解析bean定义 并在注册中心注册。
	 * @param ele
	 * @param 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));
		}
	}

这段代码的大致逻辑总结如下:

  • 1、首先委托BeanDefinitionDelegate类的parseBeanDefinitionElement方法进行元素解析,返回BeanDefinitionHolder类型的实例bdHolder,经过这个方法的处理,bdHolder实例已经包含了我们配置文件中的各种属性了,例如class、name、id、alias之类的属性。
  • 2、当返回的bdHolder不为空的情况下,若存在默认标签的子节点下再有自定义属性,还需要再次对自定义标签进行解析。
  • 3、解析完成后,需要对解析后的bdholder进行注册,同样的,注册操作委托给了BeanDefinitionReaderUtils的registerBeanDefinition方法。
  • 4、最后发出响应事件,通知相关的监听器,这个bean已经加载完成了。

配合时序图,我们理解一下操作逻辑过程

解析BeanDefinition

首先我们从元素解析及信息提取开始,也就是

BeanDefinitionHolder dbHolder = delegate.parseBeanDefinitionElement(ele),进入BeanDefinitionDelegate类的parseBeanDefinitionElement方法。

	/**
	 * 解析提供的{@code <bean>}元素。可能返回{@code null}
	 * 如果在解析过程中出现错误。将错误报告给
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}。
	 */
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
		return parseBeanDefinitionElement(ele, null);
	}

	/**
	 * 解析提供的{@code <bean>}元素。可能返回{@code null}
	 * 如果在解析过程中出现错误。将错误报告给
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
	 */
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);  //解析id属性
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);  //解析name属性
		//分割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);
		}

		AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
		if (beanDefinition != null) {
			if (!StringUtils.hasText(beanName)) {
				try {
					//如果不存在beanName那么根据Spring中提供的命名规则为当前bean生成对应的beanName
					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;
	}

以上便是对默认标签解析的全过程,在开始对属性展开全面解析前,Spring在外层又做了一个当前层的功能架构,那么在当前层完成的主要工作包括如下:

  • 1、提取元素中的id以及name属性
  • 2、进一步解析其他所有属性并统一封装至GenericBeanDefinition类型的实例中
  • 3、如果检测到bean没有指定beanName,那么使用默认的规则为此Bean生成beanName
  • 4、将获取到的信息封装到BeanDefinitionHolder的实例中

查看步骤2中对标签的其他属性的解析过程:

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);
	 }
	 //创建用于承载属性的AbstractBeanDefinition类型的GenericBeanDefinition
	 AbstractBeanDefinition bd = createBeanDefinition(className, parent);
	 //硬编码解析默认bean的各种属性
	 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
	 //提取description
	 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
	 //解析元数据
	 parseMetaElements(ele, bd);
	 //解析lookup-method属性
	 parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
	 //解析replaced-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.1.1、创建用于属性承载的BeanDefinition

BeanDefinition是一个接口,在Spring中存在三种实现:RootBeanDefinition、ChildBeanDefinition以及GenericBeanDefinition。三种实现均继承了AbstractBeanDefinition,其中BeanDefinition是配置文件元素标签在容器中的内部表现形式。元素标签拥有class、scope、lazy-init等配置属性,BeanDefinition则提供了相应的beanClass、scope、lazyInit属性,BeanDefinition和中的属性是一一对应的。其中RootBeanDefinition是最常用的实现类,它对应一般性的元素标签,GenericBeanDefinition是2.5版本以后新加入的bean文件配置属性定义类,是一站式服务类。

在配置文件中定义父和子,父用RootBeanDefinition表示,而子用ChildBeanDefinition表示,而没有父的就使用RootBeanDefinition表示。AbstractBeanDefinition对两者共同的类信息进行抽象。
Spring通过BeanDefinition将配置文件中的配置信息转换为容器的内部表示,并将这些BeanDefinition注册到BeanDefinitionRegistry中,Spring容器的BeanDefinitionRegistry就像是Spring配置信息的内存数据库,主要是以map形式保存,后续操作直接从BeanDefinitionRegistry中读取配置信息。

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

protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)throws ClassNotFoundException {
    return BeanDefinitionReaderUtils.createBeanDefinition(
       parentName, className, this.readerContext.getBeanClassLoader());
}

BeanDefinitionReaderUtils.java

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) {
	 //如果classLoader不为空,则使用已传入的classLoader同一虚拟机加载类对象,否则只是记录className
	 bd.setBeanClass(ClassUtils.forName(className, classLoader));
   }
   else {
	 bd.setBeanClassName(className);
   }
  }
  return bd;
}

1.1.2、解析各种属性

当创建了bean信息的承载实例后,就可以进行bean信息的各种属性解析了,首先进入parseBeanDefinitionAttributes方法,parseBeanDefinitionAttributes方法是对element所有元素属性进行解析:

public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
     BeanDefinition containingBean, AbstractBeanDefinition bd) {
  //这里如果配置了singleton属性的话会报错。Spring在2.5版本之后就放弃了这种用法
  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) {
	// Take default from containing bean in case of an inner bean definition.
	//在嵌入beanDefinition情况下且没有单独指定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));
    //解析dependency-check
    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));
    }
    //解析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));
    }
    //解析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);
     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;
}

1.1.3、解析子元素meta

在开始解析元数据的分析前,我们先回顾一下元数据meta属性的使用。

  <bean id="myTestBean" class="container.MyTestBean" >
    <meta key="testStr" value="testValue"/>
  </bean>

这段代码并不会体现在MyTestBean的属性中,它是一个额外的声明,当需要使用到里面的信息时可以通过BeanDefinition的getAttribute(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;
	 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);
   }
  }
}

1.1.4、解析子元素lookup-method

子元素lookup并不是很常用,但是在某些时候它的确是非常有用的属性,通常称它为获取器注入,引用《Spring in Action》中的一句话获取器注入是一种特殊的方法注入,它是把一个方法声明为返回某种类型的bean,但实际要返回的bean是在配置文件里面配置的,此方法可以用在设计有些可以插拔的功能上,解除程序依赖。

1、首先我们创建一个父类

package test.lookup.bean;
public class User {
  public void showMe() {
    System.out.println("i am user");
  }
}

2、创建其子类并覆盖showMe方法

package test.lookup.bean;
public class Teacher extends User {
  @Override
  public void showMe() {
    System.out.println("i am teacher");
  }
}

3、创建调用方法

package test.lookup.bean;
public abstract class GetBeanTest {
  public void showMe() {
    this.getBean().showMe();
  }
  public abstract User getBean();
}

4、创建测试方法

package test.lookup;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test.lookup.bean.GetBeanTest;
public class Main {
  public static void main(String[] args) {
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("test/lookup/LookupTest.xml");
    GetBeanTest bean = (GetBeanTest) applicationContext.getBean("getBeanTest");
    bean.showMe();
  }
}

到这里为止,除了配置文件外,整个测试方法就完成了,如果之前没有接触过获取器注入的小伙伴们,可能会有疑问:抽象方法还没有实现,怎么可以直接调用?答案就是Spring为我们提供的获取器中,下面我们看看配置文件是怎么配置的

<?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="getBeanTest" class="test.lookup.bean.GetBeanTest">
    <lookup-method name="getBean" bean="teacher" />
  </bean>
  <bean id="teacher" class="test.lookup.bean.Teacher" />
</beans>

在配置文件中,看到了源码解析中提到的lookup-method子元素,这个配置所完成的功能是动态地将teache所代表的bean作为getBean的返回值。运行测试方法我们会看到控制台上输出:i am teacher
在当我们的业务变更或者其他情况下,teacher里面的业务逻辑已经不再符合我们的业务需要,需要怎么替换呢,这时我们需要新加逻辑类:

package test.lookup.bean;
public class Student extends User {
  @Override
  public void showMe() {
    System.out.println("i am student");
  }
}

同时修改配置文件

<?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="getBeanTest" class="test.lookup.bean.GetBeanTest">
    <!-- <lookup-method name="getBean" bean="teacher" /> -->
    <lookup-method name="getBean" bean="student" />
  </bean>
  <bean id="teacher" class="test.lookup.bean.Teacher" />
  <bean id="student" class="test.lookup.bean.Student"/>
</beans>

再次运行测试,会发现不一样的结果:i am student
这里我们已经初步了解lookup-method子元素提供的功能,下面我们在看看属性提取源码

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);
	 String beanRef = ele.getAttribute(BEAN_ELEMENT);
	 LookupOverride override = new LookupOverride(methodName, beanRef);
	 override.setSource(extractSource(ele));
	 overrides.addOverride(override);
   }
  }
}

上面的代码和parseMetaElements的代码大同小异,最大的区别就是在if判断中的阶段名称在这里被修改为LOOKUP_METHOD_ELEMENT。还有在数据存储上面通过使用LookupOverride类型的实体类来进行数据承载并记录在AbstractBeanDefinition中的methodOverrides属性中。

1.1.5、解析子元素replaced-method

这个方法主要是对bean中的replaced-method子元素进行提取,在开始提取之前先介绍一下这个元素的用法
方法替换:可以在运行时用新的方法替换现有的方法,与之前的look-up不同的是,replaced-method不但可以动态地替换返回实体bean,而且还能动态地更改原有方法的逻辑。下面是使用示例

1、在changeMe中完成某个业务逻辑

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

2、在运营一段时间后需要改变原有的业务逻辑

package test.replace;
import java.lang.reflect.Method;
import org.springframework.beans.factory.support.MethodReplacer;
public class TestMethodReplacer implements MethodReplacer {
  @Override
  public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
    System.out.println("我替换了原有方法");
    return null;
  }
}

3、使替换后的类生效

<?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.replace.TestChangeMethod">
    <replaced-method name="changeMe" replacer="replacer" />
  </bean>
  <bean id="replacer" class="test.replace.TestMethodReplacer" />
</beans>

4、测试

package test.replace;
import java.lang.reflect.Method;
import org.springframework.beans.factory.support.MethodReplacer;
public class TestMethodReplacer implements MethodReplacer {
  @Override
  public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
    System.out.println("我替换了原有方法");
    return null;
  }
}

代码编写好了,运行测试类可以看到预期的结果,控制台成功打印出“我替换了原有的方法”,也就是说我们做到了动态地替换原有的方法,知道了这个元素的用法后,我们再来看元素的提取过程:

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的子元素下且为<replaced-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属性中,这个属性是如何使用以完成它所提供的功能后面章节会进行详细介绍。

1.1.6、解析子元素constructor-arg

对构造函数的解析是非常常用的,同时也是非常复杂的,也相信大家对构造函数的配置都不陌生,举个简单的小栗子:

<bean id="user" class="entity.User" >
       <constructor-arg index="0" value="hello"></constructor-arg>
       <constructor-arg index="1" value="test"></constructor-arg>
</bean>

上面的配置是Spring构造函数配置中最基础的配置,实现的功能就是对user的自动寻找对应的构造函数,并在初始化的时候将设置的参数传入进去,下面来看看XML具体的解析过程
对于constructor-arg子元素的解析,Spring是通过parseConstructorArgElements函数来实现的,具体代码如下:

  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);
     }
    }
  }

首先是遍历了所有子元素,也就是提取所有的constructor-arg然后进行解析,但是具体的解析却被放在了另一个函数parseConstructorArgElement中,代码如下:

  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 {
            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 {
     //没有index属性则忽略去属性,自动寻找
     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();
     }
    }
  }

上面的代码首先是提取constructor-arg上必要的属性(index、type、name)。
如果配置中指定了index属性,那么操作如下:

  • 1、解析constructor-arg的子元素
  • 2、使用ConstructorArgumentValues.ValueHolder类型来封装解析出来的元素
  • 3、将type、name和index属性一并封装在ConstructorArgumentValues.ValueHolder类型中并添加至当前BeanDefinition的constructorArgumentVaules的indexedArgumentValues属性中

如果没有指定index属性,那么操作步骤如下:

  • 1、解析contructor-arg的子元素
  • 2、使用ConstructorArgumentValues.ValuesHolder类型来封装解析出来的属性
  • 3、将type、name和index属性一并封装在

ConstructorArgumentValues.ValueHolder类型中并添加至当前BeanDefinition的constructorArgumentVaules的indexedArgumentValues属性中
对于是否指定index属性来讲,Spring的处理流程是不同的,关键在于属性的信息被保存的位置。

了解了整个流程后,我们尝试进一步了解解析构造函数配置中子元素的过程,进入parsePropertyValue:

  public Object parsePropertyValue(Element ele, BeanDefinition bd, 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;
       }
     }
    }
    //解析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 {
     // Neither child element nor "ref" or "value" attribute found.
     // 既没有reg也没有value也没有子元素,Spring就蒙圈了
     error(elementName + " must specify a ref or value", ele);
     return null;
    }
  }

从代码上来看,对构造函数的解析经历了一下几个步骤

  • 1、略过description或者meta
  • 2、提取constructor-arg上的ref和value属性,以便于根据规则验证正确性,其规则为在constructor-arg上不存在以下情况,同时既有ref属性又有value属性,或者存在ref属性或者value属性且又有子元素
  • 3、ref属性的处理,使用RuntimeBeanReference封装对应的ref名称,如:<constructor-arg ref=”a”>
  • 4、value属性的处理,使用TypedStringValue封装,例如:<constructor vaule=”a”>
  • 5、子元素的处理,例如: <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);
  }
 
  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元素的解析
    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" class="test.testClass">
    <property name="testStr">
     <list>
       <value>aaa</value>
       <value>bbb</value>
     </list>
    </property>
  </bean>

具体的解析过程

 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);
     }
    }
  }

这个函数并不难理解,提取所有property的子元素,然后调用parsePropertyElement处理,代码如下:

  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属性中。

1.1.8、解析子元素qualifier

对于元素qualifier的获取,我们更多的接触的是注解的方式,在使用Spring框架进行自动注入时,Spring容器中匹配的候选Bean数目必须有且仅有一个,当找不到一个匹配的Bean时,Spring容器将抛出BeanCreationException异常,并指出必须至少拥有一个匹配的Bean。
Spring允许我们通过Qualifier指定注入Bean的名称,这样就消除歧义了,对于配置方式的使用如下:

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

解析过程大同小异,这里就不再重复叙述

发布者:Craig,转转请注明出处:https://www.goodlymoon.com/archives/816.html

发表评论

电子邮件地址不会被公开。 必填项已用*标注

QR code