`

spring源码学习系列2.2-从document到beanDefinition

 
阅读更多
本章探讨从document到beanDefinition的过程-注册beanDefinition到容器beanDefinitionMap中

从xml到document

从document到beanDefinition

从beanDefiniton到instance


涉及到的部分主要类或接口:
org.springframework.beans.factory.xml.BeanDefinitionDocumentReader

org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader

org.springframework.beans.factory.xml.BeanDefinitionParserDelegate

org.springframework.beans.factory.support.BeanDefinitionReaderUtils

org.springframework.beans.factory.config.BeanDefinition

org.springframework.beans.factory.xml.DefaultNamespaceHandlerResolver


从document到beanDefinition

<bean>的解析
从最直接的xml配置开始<bean>

对于像事务tx:annotation等标签在spring-tx.jar/META-INF/spring.handlers下有配置具体的处理类。bean是不是也有一样的配置呢,其实不然,我们找到解析注册标签的入口。

省略从web.xml加载到doc的过程,从解析Element root = doc.getDocumentElement()开始

解析根节点root的任务由DefaultBeanDefinitionDocumentReader开始

DefaultBeanDefinitionDocumentReader源码:
http://www.grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultBeanDefinitionDocumentReader.java/


DefaultBeanDefinitionDocumentReader.parseBeanDefinitions
/**
	 * Parse the elements at the root level in the document:
	 * "import", "alias", "bean".
	 * @param root the DOM root element of the document
	 */
	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		if (delegate.isDefaultNamespace(root)) {
			NodeList nl = root.getChildNodes();
			for (int i = 0; i < nl.getLength(); i++) {
				Node node = nl.item(i);
				if (node instanceof Element) {
					Element ele = (Element) node;
					if (delegate.isDefaultNamespace(ele)) {
//1.处理默认标签
						parseDefaultElement(ele, delegate);
					}
					else {
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			delegate.parseCustomElement(root);
		}
	}

对于默认的标签,如"import", "alias", "bean" 在parseDefaultElement处开始解析。非默认的标签需定义schema/handlers进行处理。


查看默认标签的处理方法:
DefaultBeanDefinitionDocumentReader#parseDefaultElement
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
//1.1 处理import标签
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			importBeanDefinitionResource(ele);
		}
//1.2 处理alias标签
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			processAliasRegistration(ele);
		}
//1.3 处理bean标签
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}


继续bean标签的处理BEAN_ELEMENT:
DefaultBeanDefinitionDocumentReader#processBeanDefinition
/**
	 * Process the given bean element, parsing the bean definition
	 * and registering it with the registry.
	 */
	protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
//1.3.1 生成beanDefinitionHolder
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
//1.3.2 解析bean标签的自定义元素
//扩展BeanDefinition-自定义标签
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
//1.3.3 注册beanDefinitionMap
				// 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));
		}
	}


从以上代码可以看到,DefaultBeanDefinitionDocumentReader将解析生成beanDefinition的任务委托给了BeanDefinitionParserDelegate进行处理。


beanDefinitionDocumentReader
-------------------------------------------------------承上启下的分割线----------------------------------------------
beanDefinitionParserDelegate



BeanDefinitionParserDelegate源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/BeanDefinitionParserDelegate.java#BeanDefinitionParserDelegate

由上可知,处理bean标签分3个部分:
一是解析bean标签生成BeanDefinitionHolder-处理spring默认元素或属性
BeanDefinitionParserDelegate#parseBeanDefinitionElement
/**
	 * Parses the supplied {@code &lt;bean&gt;} element. May return {@code null}
	 * if there were errors during parse. Errors are reported to the
	 * {@link org.springframework.beans.factory.parsing.ProblemReporter}.
	 */
	public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

		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 {
					if (containingBean != null) {
						beanName = BeanDefinitionReaderUtils.generateBeanName(
								beanDefinition, this.readerContext.getRegistry(), true);
					}
					else {
						beanName = this.readerContext.generateBeanName(beanDefinition);
						// Register an alias for the plain bean class name, if still possible,
						// if the generator returned the class name plus a suffix.
						// This is expected for Spring 1.2/2.0 backwards compatibility.
						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;
	}

可以看到,先生成beanDefinition再包装成beanDefinitionHolder
(1)生成beanDefinition的过程
BeanDefinitionParserDelegate#createBeanDefinition
protected AbstractBeanDefinition createBeanDefinition(String className, String parentName)
			throws ClassNotFoundException {

		return BeanDefinitionReaderUtils.createBeanDefinition(
				parentName, className, this.readerContext.getBeanClassLoader());
	}


创建GenericBeanDefinition

BeanDefinitionReaderUtils#createBeanDefinition
public static AbstractBeanDefinition createBeanDefinition(
			String parentName, String className, ClassLoader classLoader) throws ClassNotFoundException {

		GenericBeanDefinition bd = new GenericBeanDefinition();
		bd.setParentName(parentName);
		if (className != null) {
			if (classLoader != null) {
				bd.setBeanClass(ClassUtils.forName(className, classLoader));
			}
			else {
				bd.setBeanClassName(className);
			}
		}
		return bd;
	}


这里可以发挥你的想象力。就像平时定义了一个model,然后设置各种属性的过程。这里处理的属性或子标签都是spring默认定义的属性或标签,自定义的标签会在第二步进行处理

bd.setBeanClass涉及到从benDefintion到instance的一个处理过程:resolveBeanClass
如果这里设置了beanClass,resolveBeanClass可以直接返回。

那这里会不会设置beanClass呢?
关键点是this.readerContext.getBeanClassLoader(),其里面继续调用XmlBeanDefinitionReader.getBeanClassLoader();
查看<spring源码学习系列2.1-从xml到document>创建XmlBeanDefinitionReader对象时,并没有设置beanClassLoader的值


这里定义的beanDefinition的实际类是GenericBeanDefinition,在从beanDefinition到instance的过程中,会转为RootBeanDefinition

平常我们只会设置几个熟悉的属性,其实beanDefinition中有很多属性,
例如:lookup-method replace-method等

spring是如何解析这些特殊属性或标签的来生成实例的呢?

其他属性可查看BeanDefinitionParserDelegate的源码,其用静态变量基本定义了所有属性

(2)此时生成的beanDefinitionHolder对象也很简单,只是存储了beanDefinition及其名称等


二是装饰第一步生成的BeanDefinitionHolder对象-处理自定义标签或属性-可以看做spring的一种扩展-对spring的默认标签进行扩展

public BeanDefinitionHolder decorateBeanDefinitionIfRequired(
			Element ele, BeanDefinitionHolder definitionHolder, BeanDefinition containingBd) {

		BeanDefinitionHolder finalDefinition = definitionHolder;

		// Decorate based on custom attributes first.
		NamedNodeMap attributes = ele.getAttributes();
		for (int i = 0; i < attributes.getLength(); i++) {
			Node node = attributes.item(i);
			finalDefinition = decorateIfRequired(node, finalDefinition, containingBd);
		}

		// Decorate based on custom nested elements.
		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;
	}

// Decorate based on custom attributes first.
NamedNodeMap attributes = ele.getAttributes();

// Decorate based on custom nested elements.
NodeList children = ele.getChildNodes();

这里继续循环bean标签的属性或子标签,难道是继续对第一步的属性进行深入处理?其实不然,继续跟到decorateIfRequired方法中看看
private 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;
	}

这段代码中,有个很重要的分子判断!isDefaultNamespace(namespaceUri),即是否是自定义标签,如果不是则继续获取相应命名空间处理类进行解析

可见装饰主要是对自定义子标签或属性的解析过程-对spring bean标签的扩展

NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);


this.readerContext.getNamespaceHandlerResolver()获取的是DefaultNamespaceHandlerResolver,其主要职责是管理命名空间处理器的。其数据来源主要是META-INF/spring.handlers下的内容,加载这些文件用到了懒加载机制(Load the specified NamespaceHandler mappings lazily)

resolve方法中,首先加载META-INF/spring.handler文件:
Properties mappings =
								PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);


并将其Properties类中的文件,转换为hashMap缓存起来:
CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);


再就是根据命名空间,读取相应命名空间处理器,并初始化返回:
NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);


将namespaceHandler放入handlerMappings中(之前将Properties转换为hashMap,value值只是string类型的)
handlerMappings.put(namespaceUri, namespaceHandler);



可跟踪源代码,借鉴spring是如何读取配置文件的

DefaultNamespaceHandlerResolver源码:
http://grepcode.com/file/repository.springsource.com/org.springframework/org.springframework.beans/3.2.2/org/springframework/beans/factory/xml/DefaultNamespaceHandlerResolver.java/


三是注册到beanDefinition容器
// Register the final decorated instance.
				BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());


/**
	 * Register the given bean definition with the given bean factory.
	 * @param definitionHolder the bean definition including name and aliases
	 * @param registry the bean factory to register with
	 * @throws BeanDefinitionStoreException if registration failed
	 */
	public static void registerBeanDefinition(
			BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
			throws BeanDefinitionStoreException {

		// Register bean definition under primary name.
		String beanName = definitionHolder.getBeanName();
		registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

		// Register aliases for bean name, if any.
		String[] aliases = definitionHolder.getAliases();
		if (aliases != null) {
			for (String aliase : aliases) {
				registry.registerAlias(beanName, aliase);
			}
		}
	}

这里registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());实际上就是放到DefaultListableBeanFactory.beanDefinitionMap


至此,从document到beanDefinition分析结束

分享到:
评论

相关推荐

    Spring源码编译缺少的两个包:spring-cglib-repack-3.2.0.jar和spring-objenesis-repack-2.2.jar

    在本案例中,"Spring源码编译缺少的两个包:spring-cglib-repack-3.2.0.jar和spring-objenesis-repack-2.2.jar"揭示了这两个关键的库对于Spring源码编译是必不可少的。下面将详细讲解这两个库的作用及其在Spring中的...

    spring学习----工厂Bean

    在Spring框架中,"工厂Bean"是一个非常关键的概念,它扩展了传统的Bean定义,使得我们可以在Spring IoC容器中创建自定义的实例化逻辑。工厂Bean允许开发者在对象实例化时进行更复杂的控制,比如引入特定的初始化过程...

    基于java的开发源码-Message-Driven Bean EJB实例源代码.zip

    基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-Driven Bean EJB实例源代码.zip 基于java的开发源码-Message-...

    Spring Ioc源码分析系列--自动注入循环依赖的处理.doc

    Spring Ioc 源码分析系列--自动注入循环依赖的处理 本篇文章主要讲解了 Spring Ioc 源码分析系列中自动注入循环依赖的处理机制。循环依赖是 Spring 框架中一个经典的问题,也是面试中常被问到的问题。本篇文章将...

    Spring Ioc源码分析系列--@Autowired注解的实现原理.doc

    Spring Ioc源码分析系列--@Autowired注解的实现原理 @ Автоwired注解是 Spring Framework 中的一个重要组件,它提供了自动装配的功能,能够将 Bean 之间的依赖关系自动解析和注入。今天,我们将深入探讨 @...

    spring源码spring-framework-4.3.2.RELEASE

    通过对Spring 4.3.2.RELEASE源码的深入研究,我们可以了解其设计理念,学习到如何优雅地管理依赖、实现面向切面编程,以及如何利用Spring构建高效、健壮的Web应用。同时,源码阅读也能帮助我们理解Spring如何与其他...

    Spring Boot: Bean definition overriding

    在本文中,我将讨论棘手的Spring Boot bean定义覆盖机制。 为了使您对该主题更加清楚,让我们从小测验开始。请看下一个简单的例子。 因此,我们有2种配置,它们使用名称beanName实例化bean,在主应用程序中,我们仅...

    Spring 源码分析文档----自用

    ### Spring 源码分析——设计模式篇 #### 一、引言 Spring框架作为Java企业级开发领域中不可或缺的一部分,其内部集成了多种设计模式,不仅有助于提高系统的可维护性和扩展性,还能够帮助开发者更好地理解和应用...

    Spring源码学习五:BeanDefinition装载1

    Spring 源码学习五:BeanDefinition 装载 1 在 Spring 框架中,BeanDefinition 是一个核心概念,它描述了一个 Bean 的定义,包括其依赖项、作用域、生命周期等信息。在本篇文章中,我们将深入探讨 Spring 的源码,...

    Spring源码学习二:BeanDefinition解析1

    在Spring框架中,BeanDefinition是核心组件之一,它定义了bean的基本信息和元数据,包括bean的类、...理解和掌握BeanDefinition对于深入学习Spring框架至关重要,因为它直接影响到bean的生命周期管理和依赖注入机制。

    完整Spring框架,包含源码文档等 spring-5.2.9.RELEASE-dist.zip

    springframework 是sping 里面的一个开源框架,主要用户javaee的企业开发。Spring是什么呢?首先它是一个开源的项目,而且非常活跃;它是一个基于IOC和AOP的构架多层j2ee系统的框架,但它不强迫你必须在每一层中必须...

    Spring源码学习四:BeanDefinition装载前奏曲1

    在学习源码时,应重点关注BeanDefinition的创建、加载和实例化过程,理解Spring如何将配置信息转化为运行时的对象。同时,理解BeanFactoryPostProcessor和BeanPostProcessor的作用,以及它们如何扩展Spring的功能,...

    spring源码分析(1-10)

    Spring 源代码分析系列涵盖了多个关键模块,包括事务处理、IoC容器、JDBC、MVC、AOP以及与Hibernate和Acegi安全框架的集成。以下是对这些知识点的详细阐述: 1. **Spring 事务处理**:Spring 提供了声明式事务管理...

    struts2-spring-plugin-2.2.3.1.jar

    使用Struts2-Spring-Plugin-2.2.3.1.jar时,开发者需要在Struts2的配置文件中指定插件,并在Spring配置文件中声明Action类和其他相关bean。一旦配置正确,Struts2框架在处理请求时会自动从Spring容器中获取Action...

    spring-security-web源码所需jar包

    《Spring Security Web源码解析与相关依赖》 Spring Security Web是Spring Security框架的重要组成部分,它主要负责Web应用程序的安全性,包括认证和授权等核心功能。本文将深入探讨Spring Security Web的源码,并...

    Spring Boot源码(spring-boot-2.6.2.zip)

    Spring Boot是Java开发中的一个关键框架,它简化了基于Spring的应用程序开发流程。Spring Boot 2.6.2是该框架的一个稳定版本,提供了一系列...对于Java开发者来说,研究Spring Boot源码是一项非常有价值的学习过程。

    撸一撸Spring Framework-IoC-BeanDefinition(csdn)————程序.pdf

    在BeanFactory篇中,我们了解到BeanFactory在启动时会从配置元信息(通常是XML文件)中读取BeanDefinition,并将它们注册到BeanDefinitionRegistry中。这个过程是通过一系列的委托和解析机制完成的。 当我们运行...

    spring-framework-1.0-m1.zip源码

    2. 控制反转:IoC是指应用程序的控制权从应用程序本身转移到框架,Spring容器根据配置文件动态地创建、装配和管理对象。这种设计模式使得组件之间解耦,降低了系统复杂度。 三、核心组件分析 1. ...

    官方原版源码 spring-5.2.8.RELEASE.zip

    通过阅读源码,开发者可以理解Spring是如何通过精心设计的接口和类,以及一系列的设计模式,实现了高可扩展性和易用性的。 总的来说,Spring框架5.2.8.RELEASE源码的学习是一次深入理解Java企业级开发、掌握模块化...

    spring1.2.6源码

    通过阅读和分析Spring 1.2.6的源码,不仅可以学习到Spring的核心设计原则,还能了解到设计模式的运用,例如工厂模式、单例模式、观察者模式等。同时,这也是提升Java编程技巧和理解框架底层运作的好机会。在实际的...

Global site tag (gtag.js) - Google Analytics