Spring源码阅读4-IOC容器-BeanDefinition的载入和解析

最新推荐文章于 2022-02-20 21:11:00 发布
最新推荐文章于 2022-02-20 21:11:00 发布
阅读量285 收藏
点赞数
分类专栏： Spring源码阅读 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jiakunboy/article/details/90257274
版权

在上一节中，我们读源码到Resource的定位部分。 当DefaultResourceLoader返回Resource后，在AbstractBeanDefinitionReader中会对得到的Resource进行读取和解析。 下面是AbstractBeanDefinitionReader中对应的方法：

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
      ResourceLoader resourceLoader = getResourceLoader();
      if (resourceLoader == null) {
         throw new BeanDefinitionStoreException(
               "Cannot load bean definitions from location [" + location + "]: no ResourceLoader available");
      }

      if (resourceLoader instanceof ResourcePatternResolver) {
         // Resource pattern matching available.
         try {
                // 获取Resource, 终于发现了，我们这一节的重点， Resource的定位。 下面我们进去看看，到底怎么加载的
            Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
            // BeanDefinition 的载入和解析
            int count = loadBeanDefinitions(resources);
            if (actualResources != null) {
               Collections.addAll(actualResources, resources);
            }
            if (logger.isTraceEnabled()) {
               logger.trace("Loaded " + count + " bean definitions from location pattern [" + location + "]");
            }
            return count;
         }
         catch (IOException ex) {
            throw new BeanDefinitionStoreException(
                  "Could not resolve bean definition resource pattern [" + location + "]", ex);
         }
      }
      else {
         // Can only load single resources by absolute URL.
         Resource resource = resourceLoader.getResource(location);
         int count = loadBeanDefinitions(resource);
         if (actualResources != null) {
            actualResources.add(resource);
         }
         if (logger.isTraceEnabled()) {
            logger.trace("Loaded " + count + " bean definitions from location [" + location + "]");
         }
         return count;
      }
   }

下面我们进入到loadBeanDefinitions中，发现会走到XmlBeanDefinitionReader类中的loadBeanDefinitions方法：

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 == null) {
			currentResources = new HashSet<>(4);
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
            // 得到XML文件， 并获取IO流inputStream
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
                // 具体的读取过程，从xml文件载入BeanDefinition的过程
				return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
			}
			finally {
				inputStream.close();
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException(
					"IOException parsing XML document from " + encodedResource.getResource(), ex);
		}
		finally {
			currentResources.remove(encodedResource);
			if (currentResources.isEmpty()) {
				this.resourcesCurrentlyBeingLoaded.remove();
			}
		}
	}

然后会到doLoadBeanDefinitions方法中：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {

		try {
            // 读取XML文件的Doucument对象，这个解析过程是由DocumentLoader来完成 
			Document doc = doLoadDocument(inputSource, resource);
            
            // 启动对BeanDefinition的详细解析过程，使用Spring的 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);
		}
	}

由此可以看到，首先是利用XML解析器获得document对象， 然后再解析Bean规则完成对BeanDefinition的载入。下面我们看registerBeanDefinitions过程，最终可以到DefaultBeanDefinitionDocumentReader类中的doRegisterBeanDefinitions方法：

protected void doRegisterBeanDefinitions(Element root) {
		// Any nested <beans> elements will cause recursion in this method. In
		// order to propagate and preserve <beans> default-* attributes correctly,
		// keep track of the current (parent) delegate, which may be null. Create
		// the new (child) delegate with a reference to the parent for fallback purposes,
		// then ultimately reset this.delegate back to its original (parent) reference.
		// this behavior emulates a stack of delegates without actually necessitating one.
		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);
        // 具体的处理过程是由BeanDefinitionParserDelegate来完成的
		parseBeanDefinitions(root, this.delegate);
		postProcessXml(root);

		this.delegate = parent;
	}

看下parseBeanDefinitions方法：

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)) {
                        // 解析默认元素
						parseDefaultElement(ele, delegate);
					}
					else {
                         // 解析用户定义元素，如注解的解析
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
            // 解析用户定义元素，如注解的解析
			delegate.parseCustomElement(root);
		}
	}

通过上面我们看到，此时会对具体的元素进行解析，下面我们仅仅分析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);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
		    // Bean标签的解析过程
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// recurse
			doRegisterBeanDefinitions(ele);
		}
	}

重点关注processBeanDefinition方法，具体的如下：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {       // 解析BeanDefinition
        // BeanDefinitionHolder 为BeanDefinition的封装类，用它来向IOC容器注册
		BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
		if (bdHolder != null) {
			bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
			try {
				// Register the final decorated instance.
                // 向IOC容器注册解析得到的BeanDefinition
				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));
		}
	}

这里我们可以看到最终是由BeanDefinitionParserDelegate来对Element进行解析的， 具体的在实现如下：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
		String id = ele.getAttribute(ID_ATTRIBUTE);
		String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

​		List<String> aliases = new ArrayList<>();
​		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.isTraceEnabled()) {
​				logger.trace("No XML 'id' specified - using '" + beanName +
​						"' as bean name and " + aliases + " as aliases");
​			}
​		}

​		if (containingBean == null) {
​			checkNameUniqueness(beanName, aliases, ele);
​		}
​         
​        // 这里会触发对Bean的详细解析过程
​		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.isTraceEnabled()) {
​						logger.trace("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;
​	}

我们可以看到在parseBeanDefinitionElement方法中，有对Bean的详细解析：

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, @Nullable BeanDefinition containingBean) {

		this.parseState.push(new BeanEntry(beanName));

		String className = null;
         //获取ClassName
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
		}
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
            // 生成BeanDefinition对象
			AbstractBeanDefinition bd = createBeanDefinition(className, parent);

			parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
			bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
            // 对各种Bean属性进行解析
			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的地方，最终得到了BeanDefinitionHolder对象，对各种元素的解析我们不进入分析，有兴趣的话可以自己看。下面是时序图：
BeanDefinition的载入和加载

Kevin-Jia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring5 框架 ---- IOC容器 ---- 代码
09-10
Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- ...
Spring 源码分析（2）--SpringIoC源码分析
aidaowuqiong的博客
10-15 551
SpringIoC 初始化整体流程的跟踪，篇幅较长，耐心看完，肯定有惊喜。
ureport2整合springboot详细教程，从代码到数据源的添加完成
qq_34302802的博客
07-02 8857
1、官网文档，可以根据文档说明来完成代码部分 http://wiki.bsdn.org/pages/viewpage.action?pageId=76448360 项目效果： 2、springboot搭建就不介绍了！进入正题，一步一步操作，springboot项目建好后，先打开pom.xml即可 ①、打开pom.xml，但是这个一般在搭建好springboot项目就会有的，也不排除一些人是手动操作的就可能没有，我这里也写上 <!-- 第一步 --> <parent>
Ureport2 ---报表设计（1）
热门推荐
一个努力飞行的菜鸟
09-08 3万+
一、概述：UReport2是一款基于架构在Spring之上纯Java的高性能报表引擎，通过迭代单元格可以实现任意复杂的中国式报表。相比UReport1，UReport2重写了全部代码，弥补了UReport1在功能及性能上的各种不足。 在UReport2中，提供了全新的基于网页的报表设计器，可以在Chrome、Firefox、Edge等各种主流浏览器运行（IE浏览器除外）。使用URep
ureport2报表详细使用（一）-集成及配置
龙傲天的博客
06-04 7197
一、报表简介 UReport2是一款基于架构在Spring之上纯Java的高性能报表引擎，通过迭代单元格可以实现任意复杂的中国式报表。 在UReport2中，提供了全新的基于网页的报表设计器，可以在Chrome、Firefox 等各种主流浏览器运行 （不支持IE）。 使用UReport2，打开浏览器即可完成各种复杂报表的设计制作。 二、主体功能 UReport2支持创建数据源、添加数据集，并对数据集进行函数、表达式处理；（参考【数据处理】） UReport2支持对数据集形成可视化报表，包
Eclipse中可正常运行工程导入IDEA报错：class path resource [applicationContext.xml] cannot be opened，配置文件找不到解决方式；
baidu_41928709的博客
11-23 568
出现配置文件找不到的原因是IDEA（V2019.3.5）将源码文件夹和配置文件夹区分开来了。 解决方式： 1.右键点击main方法所在文件夹，标记为源码文件夹Sources Root 2.右键点击配置文件所在文件夹，标记为资源文件夹Resources Root 3.运行main成功。 ...
详解Spring框架---IOC装配Bean
08-31
通过使用IOC容器，Spring框架可以自动管理Bean的生命周期和依赖关系，提高应用程序的灵活性和可维护性。 测试Bean实例化 在 Spring 框架中，我们可以使用Junit测试框架来测试Bean的实例化。例如，我们可以使用以下...
Spring框架-IoC容器
11-13
Spring-IoC容器
Java-Spring-SpringIoC容器-SpringIoC的学习
最新发布
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
spring在IoC容器中装配Bean详解
08-28
在 Spring 框架中，IoC 容器是 Bean 的容器，负责创建、管理和装配 Bean。在本文中，我们将详细介绍 Spring 在 IoC 容器中装配 Bean 的过程。 一、Spring 配置概述 Spring 配置概述分为三部分：基于 XML 的配置、...
Ureport2 安装，配置及问题详解
Robin's Home
04-02 9894
Ureport2 安装，配置及问题详解 本文详细介绍了笔者Ureport2的安装，配置以及在此过程中遇到的问题和解决方法。 本安装 基于IDEA+SpringBoot， 存储使用mysql数据库 1 pre-condition 1)首先需要安装IDEA， jdk8， ...
Spring Boot 2.1.8.RELEASE集成UReport2 (五)集成Ureport 报错
fuwen1989
09-17 3051
今天尝试使用Spring Boot 2.1.8.RELEASE搭建Ureport环境,竟然一上去就遇到如下错误（新版本还是有坑的） . ____ _ __ _ _ /\\ / ___'_ __ _ _(_)_ __ __ _ \ \ \ \ ( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \ \\/ __...
Spring加载xml文件错误异常：Offending resource: class path resource [spring-context.xml];
com15169113041的博客
10-10 2万+
很少写单纯的java工程，在运行的时候，加载xml文件的时候报错，在此记录错误信息，备自己以后查阅，错误信息如下：   Java HotSpot(TM) 64-Bit Server VM warning: ignoring option MaxPermSize=256m; support was removed in 8.0 log4j:WARN File option not set fo
【Spring源码--IOC容器的实现】（三）BeanDefinition的载入和解析【I】
Frankenstein的博客
08-15 4583
一步步解析源码，本篇文章分析到Xml中bean常用配置的解析
spring源码学习bean载入时的安全检测方式-threadlocal
有梦才叫青春
01-16 723
SpringIOC容器启动后开启了BeanDefinition的Resource定位，载入和注册的三个过程，loadBeanDefinitions方法中提供了Resource的定位的三种方式，classpath,url,getResourceByPath，其次就是载入的过程，主要采用原始的IO的InputSource,但是在解析xml之前做了一些安全性的操作，这种安全性的操作可以用在自己的编码中。
java加载xml配置文件_spring加载xml配置文件的源码分析
weixin_28993311的博客
02-25 197
1 将资源文件封装成Resource如Resource re = new ClassPathResource(“”);将加载好的资源文件 通过XmlBeanFactory初始化public class XmlBeanFactory extends DefaultListableBeanFactory {private final XmlBeanDefinitionReader reader = n...
springMVC 启动加载过程
kunpeng90的博客
05-04 2万+
spring启动component-scan类扫描加载过程—源码分析 spring通过DispatcherServlet加载: 系统配置: &lt;servlet&gt; &lt;servlet-name&gt;spring&lt;/servlet-name&gt; &lt;servlet-class&gt;org.springframework.web.servlet.Dis...
Spring是怎么解决循环依赖的:
myStyle的博客
01-29 962
面试题：Spring是怎么解决循环依赖的: 通过三级缓存实现循环依赖的，原理是使用了3个Map， singletonObjects 一级缓存（单例池），用于保存实例化、注入、初始化完成的bean实例 首先Spring会尝试从一级缓存中获取singletonObjects protected Object getSingleton(String beanName, boolean allowEarlyReference) { Object singletonObject = this.
Spring源码解读（二）Bean创建过程之解析——BeanDefinition
lishuzhen5678的博客
02-20 590
前言 SpringBean的创建方式较为复杂，这一系列博文将分为几个大类：解析、注册、加载、创建。在解析的过程中又可以分为...
Spring源码深度解析：IOC容器与核心组件
在Spring源码解析的第一部分，作者着重讲解了IOC容器的启动过程，包括BeanFactory如何解析配置信息，如何创建和初始化Bean。这部分内容通常涉及到类路径扫描、BeanDefinition的注册和Bean实例化的过程。Bean...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值