Spring IOC系列学习笔记二：obtainFreshBeanFactory方法

最新推荐文章于 2024-05-20 20:07:43 发布
最新推荐文章于 2024-05-20 20:07:43 发布
阅读量247 收藏 2
点赞数
分类专栏： Spring 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhengguofeng0328/article/details/115110668
版权

原文地址程序员囧辉大佬

相关文章

Spring IOC系列学习笔记一：前置刷新
Spring IOC系列学习笔记二：obtainFreshBeanFactory方法
Spring IOC系列学习笔记三：parseDefaultElement详解
Spring IOC系列学习笔记四：parseCustomElement解析
Spring IOC系列学习笔记五：context:component-scan 节点解析
Spring IOC系列学习笔记六：invokeBeanFactoryPostProcessors解析
Spring IOC系列学习笔记七：registerBeanPostProcessors
Spring IOC系列学习笔记八：finishBeanFactoryInitialization
Spring IOC系列学习笔记九：getBean方法
Spring IOC系列学习笔记十：createBean方法（上）
Spring IOC系列学习笔记十一：createBean方法（下）
Spring IOC系列学习笔记十二：@Autowire注解

文章目录

前言

已经把refresh方法的前置刷新环境准备了解了一下，现在正式进入refresh方法。

obtainFreshBeanFactory方法概述

从名字中可以看出她会获得一个bean的实例，在这个方法中他去读取spring的配置文件，解析所有的标签，将所有的Bean实例化成BeanDefinition加载到BeanFactory中。
有三个重要的缓存：

  • beanDefinitionNames缓存：所有被加载到 BeanFactory 中的 bean 的 beanName 集合。
  • beanDefinitionMap缓存：所有被加载到 BeanFactory 中的 bean 的 beanName 和BeanDefinition 映射。
  • aliasMap缓存：所有被加载到 BeanFactory 中的 bean 的 beanName 和别名映射。
    下面进入正文。

代码块一：obtainFreshBeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		1、刷新Bean的工厂
		refreshBeanFactory();
		ConfigurableListableBeanFactory beanFactory = getBeanFactory();
		if (logger.isDebugEnabled()) {
			logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
		}
		return beanFactory;
	}

1、刷新bean工厂 见代码块二

代码块二：refreshBeanFactory

	@Override
	protected final void refreshBeanFactory() throws BeansException {
		如果原来已经有bean工厂了就先销毁，创建一个新的工厂
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			1、创建bean工厂 ，这儿用的是子实现DefaultListableBeanFactory里面有两个重要的缓存
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			2、加载bean定义
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

2、加载bean定义见代码三，由AbstractXmlApplicationContext实现

代码块三：loadBeanDefinitions

	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// Create a new XmlBeanDefinitionReader for the given BeanFactory.
		1、创建一个xml的读取器，读取BeanFactory
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// Configure the bean definition reader with this context's
		// resource loading environment.
		2、设置环境
		beanDefinitionReader.setEnvironment(this.getEnvironment());
		beanDefinitionReader.setResourceLoader(this);
		beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

		// Allow a subclass to provide custom initialization of the reader,
		// then proceed with actually loading the bean definitions.
		initBeanDefinitionReader(beanDefinitionReader);
		3、加载bean定义
		loadBeanDefinitions(beanDefinitionReader);
	}


	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		1、从配置的资源获取
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		2、从配置中获取要解析的配置文件地址
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
		3、读取配置文件的bean定义
			reader.loadBeanDefinitions(configLocations);
		}
	}

2、这儿是从web.xml中配置的路径，如果没有配置则读取默认的路径：/WEB-INF/applicationContext.xml

	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int counter = 0;
		for (String location : locations) {
			1、读取配置文件返回读取的个数
			counter += loadBeanDefinitions(location);
		}
		return counter;
	}

1、读取配置文件返回读取的数量见代码块四

代码块四：loadBeanDefinitions

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {
		1、获取资源加载器这儿是ClassPathXmlApplicationContext
		ResourceLoader resourceLoader = getResourceLoader();
		if (resourceLoader == null) {
			throw new BeanDefinitionStoreException(
					"Cannot import bean definitions from location [" + location + "]: no ResourceLoader available");
		}
		判断ClassPathXmlApplicationContext是否是ResourcePatternResolver的实例，观察继承图谱为true
		if (resourceLoader instanceof ResourcePatternResolver) {
			// Resource pattern matching available.
			try {
				2、将applicationContext.xml封装成 resources
				Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				3、加载配置文件 返回当前加载的个数
				int loadCount = loadBeanDefinitions(resources);
				if (actualResources != null) {
					for (Resource resource : resources) {
						actualResources.add(resource);
					}
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Loaded " + loadCount + " bean definitions from location pattern [" + location + "]");
				}
				return loadCount;
			}
			catch (IOException ex) {
				throw new BeanDefinitionStoreException(
						"Could not resolve bean definition resource pattern [" + location + "]", ex);
			}
		}
		else {
			// Can only load single resources by absolute URL.
			4、每次只能加载一个资源
			Resource resource = resourceLoader.getResource(location);
			5、加载配置文件
			int loadCount = loadBeanDefinitions(resource);
			if (actualResources != null) {
				actualResources.add(resource);
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Loaded " + loadCount + " bean definitions from location [" + location + "]");
			}
			return loadCount;
		}
	}

3、加载配置文件 见代码块五

代码块五：loadBeanDefinitions

	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int counter = 0;
		for (Resource resource : resources) {
			1、返回本次加载的个数并加上历史加载的 ，得到的是总个数
			counter += loadBeanDefinitions(resource);
		}
		return counter;
	}

1、这儿的方法是XmlBeanDefinitionReader中的loadBeanDefinitions

	@Override
	public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(new EncodedResource(resource));
	}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
		Assert.notNull(encodedResource, "EncodedResource must not be null");
		if (logger.isInfoEnabled()) {
			logger.info("Loading XML bean definitions from " + encodedResource.getResource());
		}
		1、获取当前正在加载的资源
		Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();
		if (currentResources == null) {
			currentResources = new HashSet<>(4);
			2、把currentResources设置成当前线程解析的资源
			this.resourcesCurrentlyBeingLoaded.set(currentResources);
		}
		3、如果把要加载的资源没有添加进去，则出现了循环加载配置文件抛出异常  
		if (!currentResources.add(encodedResource)) {
			throw new BeanDefinitionStoreException(
					"Detected cyclic loading of " + encodedResource + " - check your import definitions!");
		}
		try {
			4、获取inputStream
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				5、把inputStream封装成InputSource
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				5、真正执行的方法  以do开头
				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();
			}
		}
	}

5、真正执行的方法 以do开头 见代码块六

代码块六：doLoadBeanDefinitions

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
			throws BeanDefinitionStoreException {
		try {
			1、封装成Document来进行解析（这儿不多做解释，这是一种解析xml的方式还有其他的方式）
			Document doc = doLoadDocument(inputSource, resource);
			2、注册bean定义，开始解析节点
			return registerBeanDefinitions(doc, resource);
		}
		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);
		}
	}

代码块七：registerBeanDefinitions

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		1、创建document读取器
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		2、获取原来注册的实例个数
		int countBefore = getRegistry().getBeanDefinitionCount();
		3、createReaderContext根据resource获取XmlReaderContext
		4、registerBeanDefinitions 注册成BeanDefinition实例
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		5、获取新注册的实例个数
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}

3、createReaderContext根据resource获取XmlReaderContext 见代码块八
4、registerBeanDefinitions 注册成BeanDefinition实例见代码块九

代码块八：createReaderContext

	public XmlReaderContext createReaderContext(Resource resource) {
		return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
				this.sourceExtractor, this, getNamespaceHandlerResolver());
	}


		public NamespaceHandlerResolver getNamespaceHandlerResolver() {
		if (this.namespaceHandlerResolver == null) {
			this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
		}
		return this.namespaceHandlerResolver;
	}

		protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
		ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
		return new DefaultNamespaceHandlerResolver(cl);
	}

		public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader) {
		this(classLoader, DEFAULT_HANDLER_MAPPINGS_LOCATION);
	}

	public DefaultNamespaceHandlerResolver(@Nullable ClassLoader classLoader, String handlerMappingsLocation) {
		1、这儿handlerMappingsLocation的值为 META-INF/spring.handlers
		Assert.notNull(handlerMappingsLocation, "Handler mappings location must not be null");
		this.classLoader = (classLoader != null ? classLoader : ClassUtils.getDefaultClassLoader());
		this.handlerMappingsLocation = handlerMappingsLocation;
	}

handlerMappingsLocation的值为：META-INF/spring.handlers ，并且这边有个重要的属性 handlerMappings，handlerMappings 用于存放命名空间和该命名空间handler类的映射。此时handlerMappings内容如下所示：
handlerMappings

代码块九：registerBeanDefinitions

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;
		1、创建BeanDefinitionParserDelegate
		this.delegate = createDelegate(getReaderContext(), root, parent);
		2、该节点是否是默认的命名空间下的节点
		if (this.delegate.isDefaultNamespace(root)) {
			3、解析profile属性  就是我们常用的环境比如 dev环境pro环境test环境等  不同环境下配置可能不同
			String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
			if (StringUtils.hasText(profileSpec)) {
				String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
						profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
				4、校验当前节点是否是 当前环境下的 如果不是则直接返回 不做解析
				if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
					if (logger.isInfoEnabled()) {
						logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
								"] not matching: " + getReaderContext().getResource());
					}
					return;
				}
			}
		}
		5、前置处理
		preProcessXml(root);
		6、解析节点
		parseBeanDefinitions(root, this.delegate);
		7、后置处理
		postProcessXml(root);

		this.delegate = parent;
	}

5、解析节点 进入代码十

代码块十：parseBeanDefinitions

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		1、当前节点是否是默认命名空间 最常见的如<beans>节点
		if (delegate.isDefaultNamespace(root)) {
			2、遍历子节点进行处理
			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)) {
						3、处理默认的节点 如bean节点
						parseDefaultElement(ele, delegate);
					}
					else {
						4、定制节点 比如<context:component-scan  base-package="com.zgf"> </context:component-scan>
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		5、如果不是则直接走定制的命名空间解析
		else {
			delegate.parseCustomElement(root);
		}
	}

最终进入解析节点的过程。

  • 如果是默认的节点就进入parseDefaultElement方法，如最常见的bean节点的解析
  • 否则进入parseCustomElement方法解析，如常见的开启注解读取<context:component-scan
    base-package=“com.zgf”> </context:component-scan>以及。

总结

本文主要介绍了：

  • 创建一个新的 BeanFactory：DefaultListableBeanFactory。
  • 根据 web.xml 中 contextConfigLocation 配置的路径，读取 Spring
    配置文件，验证配置文件的内容，并封装成 Resource。
  • 根据 Resource 加载 XML 配置文件，并解析成 Document 对象 。
  • 拿到 Document 中的根节点，遍历根节点和所有子节点。
SpringIOC+SpringMVC学习笔记
02-21
个人学习spring框架时记录的笔记，纯手敲，SpringIOC+SpringMVC学习笔记，有兴趣的可以参考
spring源码系列三-obtainFreshBeanFactory()
一个喜欢诗和远方的程序媛
04-02 636
1.spring源码中refresh()方法包含的13个主要的方法。obtainFreshBeanFactory()方法为其中之一显得尤为重要。2.obtainFreshBeanFactory()方法主要作用：是创建BeanFactory对象，并解析xml封装成BeanDefinition对象。3.obtainFreshBeanFactory()内部方法调用链比较长，如下：行文中均以比较重要的方法代码片段为例，有些次要方法没有详细展开。
Spring ApplicationContext容器启动refresh方法简单分析
simba_1986的专栏
02-07 3657
ApplicationContext容器启动过程代码分析 @Override public void refresh() throws BeansException, IllegalStateException { synchronized (this.startupShutdownMonitor) { // Prepare this context for refreshing
三、Spring源码学习之obtainFreshBeanFactory方法
weixin_44877172的博客
03-22 299
Spring源码学习之obtainFreshBeanFactory方法
Spring源码之obtainFreshBeanFactory()
最新发布
苟且。的博客
05-20 980
是Spring框架中用于初始化和刷新应用上下文中的关键方法。它通过调用方法，确保实例是最新的，并载入所有的Bean定义。涉及的主要方法包括和，相关的核心类有和。此外，方法负责具体加载和注册Bean定义，确保BeanFactory能够正确管理应用中的所有Bean。这些方法和类共同确保Spring应用上下文能够正确初始化和管理Bean的生命周期。
Spring IoC源码学习：obtainFreshBeanFactory 详解
2401_84048225的博客
04-17 758
Override// 1.为指定BeanFactory创建XmlBeanDefinitionReader// 2.使用此上下文的资源加载环境配置 XmlBeanDefinitionReader// resourceLoader赋值为XmlWebApplicationContext// 3.加载 bean 定义3.加载 bean 定义，。代码块3：loadBeanDefinitions// 1.获取配置文件路径= null) {// 2.根据配置文件路径加载 bean 定义。
Spring-IOC笔记
08-04
spring-IOC的一些笔记心得
Spring_IoC入门笔记.md
05-29
依赖注入：Dependency Injection IOC的作用：降低程序间的偶合（依赖关系） 依赖关系的管理：以后都交给spring来维护 ... ref:用于指定其他bean类型数据，它所指的是在spring的IOC容器中出现的bean
使用spring的IOC解决程序耦合的方法
08-26
"使用Spring的IOC解决程序耦合的方法" 本文主要介绍了使用Spring的IOC解决程序耦合的方法，通过示例代码详细地介绍了如何使用Spring的IOC来解决程序耦合的问题。 IOC（Inversion of Control）是指控制反转的设计...
深入解析Spring IoC：源码与实践指南
12-13
在深入解析Spring IoC的过程中，我们首先关注的是其核心组件&mdash;&mdash;IoC（Inversion of Control，控制反转）机制。Spring框架通过IoC容器管理应用程序的组件，实现了依赖注入，使得对象之间的依赖关系由容器负责建立和...
obtainFreshBeanFactory()详解
xizhuyuan1676的博客
05-12 178
obtainFreshBeanFactory()详解
obtainFreshBeanFactory 详解（二）
Jay的博客
08-04 1082
前言 上文 Spring IoC：ApplicationContext 刷新前的配置 介绍了 refresh 方法前的环境准备操作，接下来正式进入 refresh 方法。prepareRefresh 是refresh 里的第一个方法，主要是一些准备工作，比较简单的方法，看一下就了解了。接下来是 obtainFreshBeanFactory 方法，该方法用于获得一个新的 BeanFactory，本文将详细介绍该方法。 提醒读者的一点，本节了解即可，主要对于配置，BeanFactory有个印象即可，本章对于sp
Spring之启动过程obtainFreshBeanFactory()
thewindkee的博客
01-20 1855
1.refresh流程 我们知道refresh是spring启动的关键方法，refresh启动过程中，先要得到beanFactory 以及 需要交给beanFactory管理的bean。 在refresh时，prepareRefresh后，马上就调用了obtainFreshBeanFactory创建beanFactory以及扫描bean信息(beanDefinition)，并通过BeanDefin...
Spring IOC：obtainFreshBeanFactory调用链
CRUD工程师
01-15 436
obtainFreshBeanFactory 方法会解析所有 Spring 配置文件（即我们在前文中介绍的contextConfigLocation配置），将所有 Spring 配置文件中的 bean 定义封装成 BeanDefinition，加载到 BeanFactory 中。
Spring5 IOC源码解读系列2—obtainFreshBeanFactory方法
JayLaiSCUT的博客
06-15 4635
一 概述 obtainFreshBeanFactory主要刚了两件大事：1）干掉旧的BeanFactory，生成新的BeanFactory 2）加载Spring配置文件转换为BeanDefinition，并注册到beanDefinitionMap中。第2件事的BeanDefinition加载流程说详细点就是：1）Resource定位，即在Resource类中封装配置文件的路径和对应类加载器 2）将定义的配置文件转换为BeanDefinition 3）执行BeanDefinitionReaderUtils
【spring源码系列-06】refresh中obtainFreshBeanFactory方法的执行流程
热门推荐
zhenghuishengq的博客
06-19 1万+
obtainFreshBeanFactory
Spring源码解析二 obtainFreshBeanFactory
小tu豆的博客
06-15 231
我们接着上次的说，上次还剩下AnnotationConfigApplicationContex这个类的构造方法里调用的refresh();没有说，我们今天来看看这个重点方法：refresh();
Spring 2.5学习笔记：IoC与AOP详解
Spring2.5学习笔记是一份详细的指南，涵盖了Spring框架的多个核心概念和实践，适合于希望深入理解Spring 2.5.6版本的开发者。作者懒洋洋(QQ:125392310)在2010年07月28日整理的这份笔记主要分为以下几个部分： 1. **...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值
>