Spring源码解读(二)Bean创建过程之解析——BeanDefinition

前言

SpringBean的创建方式较为复杂,这一系列博文将分为几个大类:解析、注册、加载、创建。在解析的过程中又可以分为两个部分 读取文件转换为Document对象和解析标签将bean转换为BeanDifinition对象,这两点也是这篇博文主要讲解的内容。

BeanDefinition

BeanDefinition 是一个bean的描述,它不仅包含了bean自己基础的属性和方法,又在抽象曾经增加了bean作用域、注入方式等等。

BeanDefinition继承关系如下图。

Spring源码解读(二)Bean创建过程之解析——BeanDefinition_第1张图片

解析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 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) {
   // 任何嵌套的  元素都将导致此方法中的递归。为了正确传播和保留  默认属性,请跟踪当前(父)委托,该委托可能为空。
   // 使用对父级的引用创建新的(子级)委托以用于回退目的,然后最终将 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 {
			// 解析自定义的标签 如 
			delegate.parseCustomElement(root);
		}
	}

解析Spring默认标签

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader#parseDefaultElement

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		// 解析
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
		// 解析
		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中的标签的各个元素和属性得到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的基础信息,如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 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。

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));
			// 解析
			parseMetaElements(ele, bd);
			// 解析
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			// 解析
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
			// 解析
			parseConstructorArgElements(ele, bd);
			// 解析
			parsePropertyElements(ele, bd);
			// 解析
			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());

你可能感兴趣的:(java,spring,xml,bean,dom)