前言
SpringBean的创建方式较为复杂，这一系列博文将分为几个大类：解析、注册、加载、创建。在解析的过程中又可以分为两个部分 读取文件转换为Document对象和解析标签将bean转换为BeanDifinition对象，这两点也是这篇博文主要讲解的内容。
BeanDefinition
BeanDefinition 是一个bean的描述，它不仅包含了bean自己基础的属性和方法，又在抽象曾经增加了bean作用域、注入方式等等。
BeanDefinition继承关系如下图。
解析XML得到DOM对象
spring定义了一个底层资源接口 Resource，它抽象了所有Spring内部使用到的底层资源如 File、URL、Classpath等等，有了这个接口便可以对所有资源进行统一处理。
进入到XmlBeanDefinitionReader后，首先使用的就是通过EncodeResource进行Resource参数进行封装。Resource不是这篇博文的重点，不再解释。
程序入口
XmlBeanDefinitionReader#loadBeanDefinitions(EncodedResource) 此方法处理从指定的 XML 文件加载 bean 定义。
public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isTraceEnabled()) {
logger.trace("Loading XML bean definitions from " + encodedResource);
}
Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
}
try (InputStream inputStream = encodedResource.getResource().getInputStream()) {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
// 经过以上一些读取xml文件的操作，至此拿到了InputSource对象
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.remove();
}
}
}org.springframework.beans.factory.xml. XmlBeanDefinitionReader#doLoadBeanDefinitions
在XmlBeanDefinitionReader中是委托给DefaultDoucumentLoader解析文件从而获得Document对象。
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
throws BeanDefinitionStoreException {
try {
// 将xml解析为可曹祖的 document对象
Document doc = doLoadDocument(inputSource, resource);
// 注册 DOM 文档中的 bean 定义。
int count = registerBeanDefinitions(doc, resource);
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + count + " bean definitions from " + resource);
}
return count;
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (SAXParseException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
}
catch (SAXException ex) {
throw new XmlBeanDefinitionStoreException(resource.getDescription(),
"XML document from " + resource + " is invalid", ex);
}
catch (ParserConfigurationException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Parser configuration exception parsing XML from " + resource, ex);
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"IOException parsing XML document from " + resource, ex);
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(resource.getDescription(),
"Unexpected exception parsing XML document from " + resource, ex);
}
}解析并注册BeanDefinition
org.springframework.beans.factory.xml. XmlBeanDefinitionReader#registerBeanDefinitions
创建新的解析器类（DefaultBeanDefinitionDocumentReader），调用它的registerBeanDeifinition方法，注册这个DOM中的bean定义
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
// 新建一个解析器类
BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
int countBefore = getRegistry().getBeanDefinitionCount();
// 使用这个新建的解析器类，完成注册 BeanDefinition, 这里调用的org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader实现类
documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
return getRegistry().getBeanDefinitionCount() - countBefore;
}解析BeanDefinitions
根据“spring-beans”解析 bean 定义。
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions
protected void doRegisterBeanDefinitions(Element root) { // 任何嵌套的 <beans> 元素都将导致此方法中的递归。为了正确传播和保留 <beans> 默认属性，请跟踪当前（父）委托，该委托可能为空。 // 使用对父级的引用创建新的（子级）委托以用于回退目的，然后最终将 this.delegate 重置回其原始（父级）引用。这种行为模拟了一堆委托，而实际上不需要一个委托。 // 因为xml中标签的嵌套关系，为了保证嵌套关系的正确，使用一个委托对象以便完成父级的追踪 BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); if (this.delegate.isDefaultNamespace(root)) { String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE); if (StringUtils.hasText(profileSpec)) { String[] specifiedProfiles = StringUtils.tokenizeToStringArray( profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS); // We cannot use Profiles.of(...) since profile expressions are not supported // in XML config. See SPR-12458 for details. if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { if (logger.isDebugEnabled()) { logger.debug("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + getReaderContext().getResource()); } return; } } } preProcessXml(root); // 开始解析 parseBeanDefinitions(root, this.delegate); postProcessXml(root); this.delegate = parent; }
解析DOM中的各个元素
org.springframework.beans.factory.xml. DefaultBeanDefinitionDocumentReader#parseBeanDefinitions
至此，才真正来到处理各个元素，parseBeanDefinitions处理xml中的根节点元素 import、alias、bean
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
// 这里指处理spring命名空间的标签
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)) {
// 解析默认的元素 "import", "alias", "bean".
parseDefaultElement(ele, delegate);
}
else {
// 解析自定义的元素
delegate.parseCustomElement(ele);
}
}
}
}
else {
// 解析自定义的标签 如 <tx:annotation-driven />
delegate.parseCustomElement(root);
}
}解析Spring默认标签
org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
// 解析<import>
if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
importBeanDefinitionResource(ele);
}
// 解析<alias>
else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
processAliasRegistration(ele);
}
// bean
else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
processBeanDefinition(ele, delegate);
}
// beans
else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
// recurse
doRegisterBeanDefinitions(ele);
}
}对bean元素进行解析处理
重点看解析bean元素的操作（其他几个元素不在这篇博文的分析范围内） org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#processBeanDefinition
这里会根据给定的元素解析出bean的信息，并且注册到注册表中。通过委托BeanDefinition Delegate.parseBeanDefinitionElement(ele) 和BeanDefinition Delegate.decorateBeanDefinitionIfRequired(ele, bdHolder) 两个方法解析DOM中的<bean>标签的各个元素和属性得到BeanDefinition，这时的BeanDefiniton就包括常见的一些属性了，如baneName,alias等。 得到BeanDefinition然后再委托BeanDefinitionReaderUtils进行Bean注册。
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
// 解析bean的属性，得到BeanDefinitionHolder对象
// BeanDefinitionHolder最终会包含bean的所有信息
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
if (bdHolder != null) {
// 如果bean中有自定义的标签，则对自定义的标签进行解析
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// bean解析完成，注册
// Register the final decorated instance.
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
}
catch (BeanDefinitionStoreException ex) {
getReaderContext().error("Failed to register bean definition with name '" +
bdHolder.getBeanName() + "'", ele, ex);
}
// 发送注册事件
// Send registration event.
getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
}
}解析BeanDefinition
BeanDefinitionParserDelegate#parseBeanDefinitionElement (Element,BeanDefinition)
解析<bean>中的各个元素，装饰bean的基础信息，如beanName, ID，aliases等。
@Nullable
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
// 获取ID和Name属性
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
List<String> aliases = new ArrayList<>();
// 解析bean的name属性，注意：name属性是指 alias 的指，并不是beanName
if (StringUtils.hasLength(nameAttr)) {
// 可能有多个，通过 ",; " 分割后 加入到 aliases 中
// MULTI_VALUE_ATTRIBUTE_DELIMITERS = ",; "
String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
aliases.addAll(Arrays.asList(nameArr));
}
// id属性才是beanName的名字
String beanName = id;
if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
// id为空的话，去第一个别名为beanName
beanName = aliases.remove(0);
if (logger.isTraceEnabled()) {
logger.trace("No XML 'id' specified - using '" + beanName +
"' as bean name and " + aliases + " as aliases");
}
}
if (containingBean == null) {
// 检查当前bean的beanName和aliases是否在当前级别的 beans 元素嵌套中使用。保证beanName和别名的唯一性
checkNameUniqueness(beanName, aliases, ele);
}
// 解析当前bean所有的字节点，创建抽象的BeanDefinition,
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
if (beanDefinition != null) {
if (!StringUtils.hasText(beanName)) {
// 如果此时beanName还是为空，spring会根据指定的beanName生成策略创建beanName
try {
if (containingBean != null) {
beanName = BeanDefinitionReaderUtils.generateBeanName(
beanDefinition, this.readerContext.getRegistry(), true);
}
else {
beanName = this.readerContext.generateBeanName(beanDefinition);
// 如果生成器返回类名加上后缀，则为普通 bean 类名注册一个别名
String beanClassName = beanDefinition.getBeanClassName();
if (beanClassName != null &&
beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
aliases.add(beanClassName);
}
}
if (logger.isTraceEnabled()) {
logger.trace("Neither XML 'id' nor 'name' specified - " +
"using generated bean name [" + beanName + "]");
}
}
catch (Exception ex) {
error(ex.getMessage(), ele);
return null;
}
}
// BeanDefinition中别名属性是一个数组
String[] aliasesArray = StringUtils.toStringArray(aliases);
// 根据beanDefinition、beanName、别名 构建BeanDefinitionHolder并返回
return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}
return null;
}解析<bean>中的各个元素用来装饰bean。
BeanDefinitionParserDelegate#parseBeanDefinitionElement(String, BeanDefinition)
@Nullable
public AbstractBeanDefinition parseBeanDefinitionElement(
Element ele, String beanName, @Nullable BeanDefinition containingBean) {
this.parseState.push(new BeanEntry(beanName));
// 获取class属性
String className = null;
if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
}
// parent属性
String parent = null;
if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
parent = ele.getAttribute(PARENT_ATTRIBUTE);
}
try {
// 创建抽象的BeanDefinition
AbstractBeanDefinition bd = createBeanDefinition(className, parent);
// 解析bean属性,作用域、是否懒加载、销毁方法等等
parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
// 解析<meta>
parseMetaElements(ele, bd);
// 解析<lookup-method />
parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
// 解析<replace-method />
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;
}解析bean的自定义标签
BeanDefinitionParserDelegate#decorateBeanDefinitionIfRequired (BeanDefinitionHolder, BeanDefinition)
public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
Element ele, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
BeanDefinitionHolder finalDefinition = originalDef;
// 装饰自定义属性
NamedNodeMap attributes = ele.getAttributes();
for (int i = 0; i < attributes.getLength(); i++) {
Node node = attributes.item(i);
// 通过命名空间处理程序装饰给定的 bean 定义
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;
}通过命名空间处理程序装饰给定的 bean 定义
BeanDefinitionParserDelegate#decorateIfRequired
public BeanDefinitionHolder decorateIfRequired(
Node node, BeanDefinitionHolder originalDef, @Nullable BeanDefinition containingBd) {
// xml的命名空间
String namespaceUri = getNamespaceURI(node);
if (namespaceUri != null && !isDefaultNamespace(namespaceUri)) {
NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
if (handler != null) {
// 根据命名空间解析标签，装饰BeanDefinition
BeanDefinitionHolder decorated =
handler.decorate(node, originalDef, new ParserContext(this.readerContext, this, containingBd));
if (decorated != null) {
return decorated;
}
}
else if (namespaceUri.startsWith("http://www.springframework.org/schema/")) {
// spring的命名空间，但是无法识别
error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", node);
}
else {
if (logger.isDebugEnabled()) {
logger.debug("No Spring NamespaceHandler found for XML schema namespace [" + namespaceUri + "]");
}
}
}
return originalDef;
}解析完成，得到BeanDefinition
至此，上节中提到的 “ delegate.parseBeanDefinitionElement(ele) 和 delegate.decorateBeanDefinitionIfRequired(ele, bdHolder) ” 两个解析方法的主要调用链已经分析完了，同时我们也拿到了预期想要的 BeanDefinition，接下来就要把BeanDefinition注册到注册表中，执行注册逻辑。下一篇博文再分析注册方法
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
1372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
