Spring源码解析(15)之refresh源码分析(三)配置文件解析

已于 2022-02-21 10:15:29 修改
阅读量470 收藏
点赞数 1
分类专栏： Spring源码分析系列 文章标签： spring源码分析 spring配置文件解析源码 spring自定标签 Spring配置文件解析 Spring标签解析源码分析
于 2022-02-20 17:21:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jokeMqc/article/details/123029526
版权

一、前言

在前面的博客中我们有介绍到refresh方法中的otainFreshBeanFaction方法，这个方法的作用就是获取bean工厂，在这期间还会完成配置文件的加载，生成BeanDefinition，需要注意的是这里生成的BeanFactory默认的是DefaultListableBeanFactory，需要注意的是，我们自定的一些xsd约束文件也是在这里完成解析，通过实现BeanDefitionParser接口，并且实现parse方法，自定义的标签也通过实现NamespaceHandlerSupport接口，并实现init方法。下面是我画的bean配置文件的解析流程图：

通过这一节博客的学习我们主要是看看spring是如何解析配置文件，并且知道是如何解析我们自定义的xsd，这样子以后如果我们要遇到一个需求需要自定义标签的解析就不会无从下手了。

二、Spring配置文件解析流程源码分析

        2.1入库：obtainFreshBeanFactory

	protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
		/**
		 *  刷新bean工厂，判断bean工厂是否已经存在，如果存在需要进行销毁和关闭
		 *  默认调用的是AbstractRefreshableApplicationContext的refreshBeanFactory方法.
		 *  刷新Bean工厂时会进行bean定义的加载操作。
		 *  初始化BeanFactory,并进行XML文件读取，并将得到的BeanFactory记录在当前实体的属性中
		 */
		refreshBeanFactory();
		return getBeanFactory();
	}

        我们接着往下看refreshBeanFactory方法：

	@Override
	protected final void refreshBeanFactory() throws BeansException {
		// 判断bean工厂是否存在，如果存在需要先销毁和关闭。否则会出现问题
		if (hasBeanFactory()) {
			// 销毁bean，根据bean的名称将bean工厂中的所有bean都从map中移除
			destroyBeans();
			// 关闭bean工厂，设置Bean工厂的序列化id为null，并将beanFactory的值赋值为null
			closeBeanFactory();
		}
		try {
			// 重新创建bean工厂，默认返回的是Bean工厂类型是：DefaultListableBeanFactory
			DefaultListableBeanFactory beanFactory = createBeanFactory();

			// 设置序列化ID，ID: class名称 + "@" + 对象的十六进制值
			beanFactory.setSerializationId(getId());

			// 定制bean工厂。作用：设置bean定义是否可以被覆盖以及设置bean在创建的时候是否允许循环引用.
			customizeBeanFactory(beanFactory);

			// 解析并加载bean的定义，默认是通过AbstractXmlApplicationContext类中的loadBeanDefinitions实现
			loadBeanDefinitions(beanFactory);

			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}

        该方法里面首先会去判断是否存在beanFactory，如果存在的话就先去销毁对应的factory，然后调用createBeanFactory创建一个bean工厂，默认给我们创建的DefaultListableBeanFactory,然后设置一些属性信息，其中在loadBeanFinitions里面就就是去解析配置文件。

2.2 loadBeanDefinitions(beanFactory)

        创建一个xml格式的bean读取器，然后设置一些属性值。

	@Override
	protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
		// 创建Xml格式的Bean读取器，里面会设置bean工厂的资源加载器及环境信息
		XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

		// 对象创建bean读取器的时候已经初始化.此处直接获取
		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.
		// 初始化beanDefinitionReader对象，此处设置配置文件是否要进行验证
		initBeanDefinitionReader(beanDefinitionReader);

		// 会解析xml中的标签属性，并添加到bean定义中.
		loadBeanDefinitions(beanDefinitionReader);
	}

        然后接着往下看loadBeanDefinitions(beanDefinitionReader);

2.3loadBeanDefinitions(beanDefinitionReader)

        这里会分为两个分支，一个是直接去解析resources,另外一个是去解析传入的配置文件列表，这里我们会走第二个分支。

	protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
		// 通过另外一个构造函数构造的容器，会使用configResources的方式去加载bean定义
		Resource[] configResources = getConfigResources();
		if (configResources != null) {
			reader.loadBeanDefinitions(configResources);
		}
		// 获取所有的配置文件名称，例如：{"beans.xml"}。主要是xml配置文件的名称
		String[] configLocations = getConfigLocations();
		if (configLocations != null) {
			reader.loadBeanDefinitions(configLocations);
		}
	}


	@Override
	public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {
		Assert.notNull(locations, "Location array must not be null");
		int count = 0;
		for (String location : locations) {
			// 加载bean定义
			count += loadBeanDefinitions(location);
		}
		return count;
	}

	@Override
	public int loadBeanDefinitions(String location) throws BeanDefinitionStoreException {
		return loadBeanDefinitions(location, null);
	}

2.4 loadBeanDefinitions(location,null)

	public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {

		// resourceLoader是在XmlApplicationContext中通过setResourceLoader方法设置进去的属性
		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[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);
				// 加载bean定义.
				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;
		}
	}

	@Override
	public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {
		Assert.notNull(resources, "Resource array must not be null");
		int count = 0;
		for (Resource resource : resources) {
			// 加载bean定义
			count += loadBeanDefinitions(resource);
		}
		return count;
	}

        其实到最后也是调用回到loadBeanDefinitions(resource);

2.5loadBeanDefinitions(resource)

	@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.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 {
			InputStream inputStream = encodedResource.getResource().getInputStream();
			try {
				InputSource inputSource = new InputSource(inputStream);
				if (encodedResource.getEncoding() != null) {
					inputSource.setEncoding(encodedResource.getEncoding());
				}
				// 执行bean定义加载
				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();
			}
		}
	}

        这里真正干活的是doLoadBeanFinitions;

2.6 doLoadBeanDefinitions

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

		try {
			// 将xml配置文件通过JDK中的JAXP(Java API for XMLProcessing)解析为Document对象
			Document doc = doLoadDocument(inputSource, resource);
			// 注册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);
		}
	}

2.7 registerBeanDefinitions

	public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// 通过反射创建Bean定义文档读取器，默认类型为：DefaultBeanDefinitionDocumentReader
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		// 获取之前已经加载的bean定义数量，直接通过beanDefinitionMap.size获取
		int countBefore = getRegistry().getBeanDefinitionCount();
		// 执行xml的解析及bean定义注册。在创建bean定义读取器上下文时，会去创建默认的DefaultNamespaceHandlerResolver
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		// 返回本次注册的bean定义的数量
		return getRegistry().getBeanDefinitionCount() - countBefore;
	}
    
    // 去解析注册bean定义
	@Override
	public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
		this.readerContext = readerContext;
		// 执行bean定义的注册操作
		doRegisterBeanDefinitions(doc.getDocumentElement());
	}

2.8 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;
		// 创建bean定义解析器委托对象，同时解析<beans/>标签中的一些全局属性
		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;
				}
			}
		}
		// 在spring解析xml之前，处理一些自定义的元素类型
		preProcessXml(root);

		// 解析bean定义
		parseBeanDefinitions(root, this.delegate);

		// 在spring解析xml之后，处理一些自定义的元素类型
		postProcessXml(root);

		this.delegate = parent;
	}

        preProcessXml和postProcessXml这两个进去你们可以看到是一个空实现，这里是可以留给我们进行拓展，这个是一个拓展点。

2.9 parseBeanDefinitions

	protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
		// 判断是否为自定义标签，根据nameSpace的uri进行判断。
		// spring的beans的nameSpace对应的uri为：http://www.springframework.org/schema/beans
		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)) {
						// 解析Spring中的默认xml节点(import,alias,beans)
						parseDefaultElement(ele, delegate);
					}
					else {
						// 解析自定义标签内容
						delegate.parseCustomElement(ele);
					}
				}
			}
		}
		else {
			// 如果不是spring默认的命名空间，则作为扩展标签进行解析.
			delegate.parseCustomElement(root);
		}
	}

	private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
		if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
			// 处理import标签解析
			importBeanDefinitionResource(ele);
		}
		else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
			// 处理alias标签解析
			processAliasRegistration(ele);
		}
		else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
			// 处理bean标签解析
			processBeanDefinition(ele, delegate);
		}
		else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
			// 处理beans标签解析
			doRegisterBeanDefinitions(ele);
		}
	}

        这里就可以看到，如果是默认的标签：import、bean、beans、alias就会走默认的解析，parseDefaultElement，否则就走parseCustomElement。

三、自定义配置文件解析

3.1 User.java

public class User {
	private String userName;

	public String getUserName() {
		return userName;
	}

	public void setUserName(String userName) {
		this.userName = userName;
	}
}

3.2 自定义UserBeanDefinitionParse


/**
 * @author maoqichuan
 * @date 2022年02月21日 9:52
 */
public class UserNameBeanDefinitionParser  implements BeanDefinitionParser {
	@Override
	public BeanDefinition parse(Element element, ParserContext parserContext) {
		RootBeanDefinition beanDefinition = new RootBeanDefinition();
		beanDefinition.setBeanClass(User.class);

		String id = element.getAttribute("id");
		String userName = element.getAttribute("userName");

		// 此处可以加一些自定义的校验逻辑，校验必填属性的值及类型或者格式等
		if (null == id || "".equals(id.trim())) {
			throw new RuntimeException("id不能为空！");
		}
		// 注册bean定义到bean定义注册中心
		parserContext.getRegistry().registerBeanDefinition(id, beanDefinition);

		if (StringUtils.hasText(id)) {
			beanDefinition.getPropertyValues().addPropertyValue("id", id);
		}
		if (StringUtils.hasText(userName)) {
			beanDefinition.getPropertyValues().addPropertyValue("name", userName);
		}
		return beanDefinition;
	}
}

3.3 UserNamespaceHandler

/**
 * MyNamespaceHandler
 */
public class UserNamespaceHandler extends NamespaceHandlerSupport{
	/**
	 * 注册标签的解析类
	 */
	@Override
	public void init() {
		registerBeanDefinitionParser("mqc:user",new UserBeanDefinitionParse());
	}
}

3.4 创建Spring.handlers文件

        在resource目录下创建META-INF目录下，并创建三个文件：Spring.handlers,Spring.schemas、user.xsd。

        Spring.handlers：

http\://www.mqc.com/schema/user=org.springframework.mqc.selftag.UserNamespaceHandler

        Spring.schemas：

http\://www.mqc.com/schema/user.xsd=META-INF/user.xsd

        user.xsd：

<?xml version="1.0" encoding="UTF-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
		targetNamespace="http://www.mqc.com/schema/user"
		xmlns:tns="http://www.mqc.com/schema/user"
		elementFormDefault="qualified">
	<element name="mqc">
		<complexType>
			<attribute name ="userName" type = "string"/>
		</complexType>
	</element>
</schema>

        3.5创建配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:aaa="http://www.mqc.com/schema/user"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.mqc.com/schema/user http://www.mqc.com/schema/user.xsd">

	<aaa:mqc  userName = "lee" />
</beans>

        到这里spring自定义标签大概就已经结束了，其实如果到后面的公司有自定义标签的需求的话，大家可以去看看spring context的标签解析，spring怎么做我们就怎么做就可以了。

技术路上的苦行僧
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring源码分析(4)
静静的爱着你
11-02 150
loadBeanDefinitions public int loadBeanDefinitions(String location, Set<Resource> actualResources) throws BeanDefinitionStoreException { ResourceLoader resourceLoader = getResourceLoader(); if (resourceLoader == null) { throw new BeanDefinitionSt
Spring启动流程refresh()源码深入解析
09-07
Spring框架的启动流程是其核心功能之一，其中`refresh()`方法起到了至关重要的作用。当我们调用`ApplicationContext`的`refresh()`方法时，Spring容器开始初始化并加载配置，为应用程序提供服务。下面我们将深入分析...
spring源码学习 - refresh()
qq_35185546的博客
10-28 381
refresh函数refresh的执行过程prepareRefresh切换容器为可修改状态确认Log记录已经开启初始化占位符资源，该方法为空确认运行环境配置正确创建早期时间监听器容集合，保存早期监听器，也就是在之前已经初始化的监听器。创建早期事件集合obtainFreshBeanFactoryprepareBeanFactory(beanFactory)postProcessBeanFactory(beanFactory)invokeBeanFactoryPostProcessors(beanFactory
Spring源码学习【二】IOC容器的初始化（一）Resource定位
一颗贪婪的星
07-24 1102
目录 一、总览 二、源码分析 1. refresh 2. obtainFreshBeanFactory 3. refreshBeanFactory 4-5. loadBeanDefinitions 6. loadBeanDefinitions 7. getResources 8. getResource 一、总览 在使用IOC容器之前，需要定义一个Resource来定位容器B...
【Spring源码解析】Spring XML配置默认bean标签解析
燃尽余火的博客
07-13 661
上文对XmlBeanFactory文件资源加载的流程做了初步的讲解，主要内容是Reousce资源的加载，XmlBeanFactory初始化，Resouce对象进行编码并转换成数据流，Xml配置文件验证，转换成Document对象，之后进行解析注册操作。上次解析的内容是初步整理，到 registerBeanDefinitions 方法，此处继续向下解析。 preProcessXml,postProcessXml 都是给使用的时候扩展使用，Spring 并没有完成功能。 parseBeanDefinitions
Spring容器之refresh方法源码分析
持之以恒
07-30 1637
BeanFactory作为IOC容器的核心接口，ApplicationContext接口包含了BeanFactory的所用功能 来看看两者关系： 既然是继承关系，那么ApplicationContext包含了BeanFactory的所用功能也就不足为奇了 ApplicationContext作为Spring上下文的关键接口，除了BeanFactory的功能，还包括各种环境、参数、BeanFactoryPostProcessors后处理器、事件以及单例bean的初始化等一系列操作，其中以refresh方法为s
深入解析Spring IoC：源码与实践指南
最新发布
12-13
在深入解析Spring IoC的过程中，我们首先关注的是其核心组件——IoC...通过阅读和分析源码，我们可以学习到如何配置和管理Bean，以及如何自定义Bean的行为，这对于提升代码质量，优化系统性能有着积极的影响。
深入解析Spring IoC源码：核心机制与实践应用
12-13
通过对Spring IoC源码的深入解析，我们可以了解到Spring如何高效地管理Bean的生命周期，以及如何通过注解实现灵活的配置。这对于开发者来说，不仅有助于提升代码质量，还能更好地利用Spring框架提供的功能，提高开发...
springBean加载过程源码解析文档，附有代码类名和行数
06-15
Spring Bean 加载过程源码解析文档 Spring Bean 加载过程是 Spring 框架中最核心的部分之一，涉及到 ApplicationContext 的初始化、Bean 的加载和注册等过程。在 Spring Boot 应用程序中，SpringApplication 负责...
Spring源码refresh方法调试笔记
11-01
Spring源码refresh方法调试笔记，经过的所有的类，和步骤都有记载
spring动态加载(刷新)配置文件
ardo_pass的博客
12-04 1万+
在程序开发时，通常会经常修改spring的配置文件，不得不重启tomcat来加载spring配，费时费力。如果能在不重启tomcat的情况下，手动动态加载spring 配置文件，动态重启读取spring配置文件，这样会十分方便。spring貌似自带refresh刷新效果，只要获取到XmlWebApplicationContext，调用refresh即可。 代码如下： /**
Spring源码解析--Spring配置文件解析NamespaceHandler（五）
lppl010_的专栏
05-03 412
https://blog.csdn.net/qq924862077/article/details/72887698上一篇博客 Spring源码解析--Spring配置文件解析BeanDefinitionParserDelegate（四）中我们介绍了对Bean基本元素的解析处理器，接下来我们介绍一下Spring提供的NamespaceHandler的处理机制，简单来说就是命名空间处理器，Sprin...
Spring4.3.x 浅析xml配置的解析过程（5）——解析自定义命名空间的标签
chyohn的博客
02-09 2838
概述在上一篇解析<bean>标签及其所有子标签我们详细探讨了如何使用<bean>标签来创建一个BeanDefintion对象。这一篇我们开始探讨一下spring如何处理其它命名空间的xml标签，比如spring扩展的http://www.springframework.org/schema/context、http://www.springframework.org/schema/p和http://
spring拓展之定义自己的namespace
流连是谁的博客
10-24 5430
1.查看源码认识spring是怎么加载xml配置的1.1 spring是怎么创建对象的？查看spring beanFactory的继承关系 通过查看源码可以得知，BeanFactory 中的对象创建是实际是根据RootBeanDefinition创建的, 在AbstractAutowireCapableBeanFactory有具体的实现，包括创建实例，利用Spring拓展的 java的内省Be
关于Spring加载classpath与classpath*的过程剖析
热门推荐
老张
07-12 4万+
提到Spring配置文件，我不知道各位想到的是什么，首先浮现在我脑海里面的就是classpath 和 classpath*。    网上有很多关于这个2个前缀分别能读到那些资源文件的文章，但是我相信仍然有大部分同学是迷糊的，或者说知其然不知其所以然。那么这篇文章就带你走进Spring源码，让你知其然，更知其所以然。    关于Spring Resource的资源类型以及继承体系我们已经在上一篇
getResources()详解
博客
09-05 9939
/** * Return &lt;code&gt;getActivity().getResources()&lt;/code&gt;. */ final public Resources getResources() { if (mHost == null) { throw new IllegalStateException("Fragment " + this...
spring源码refresh()刷新容器详解
three_stand的博客
06-13 1575
publicvoidrefresh()throwsBeansException,IllegalStateException{ synchronized(this.startupShutdownMonitor){ //Preparethiscontextforrefreshing. prepareRef...
5.2Spring源码解析——refresh方法
szhlcy的博客
12-18 210
 refresh方法在ConfigurableApplicationContext类中定义的具体实现是在AbstractApplicationContext中实现。这个方法的原文描述信息是：由于这是一个启动方法，如果它调用失败，它应该销毁已创建的单例，以避免悬空资源。换句话说，在调用该方法之后，应该实例化所有单例或者不是单例的对象。  在类ConfigurableApplicati...
Spring源码由浅入深系列三 refresh
张新意专栏
10-17 1783
Spring中的refresh是一个相当重要的方法。它完成IOC的第一个阶段，将xml中的bean转化为beanDefinition.详细说明如上图所示。 在上图中，创建obtainFreshBeanFactory的过程值得展开来讲。而IOC的第二个阶段是getBean，都将在后续讲解。 applicationEventMulticaster与listener是一个标准的观察者设计模式
深度探索：Spring IoC源码解析与Bean生命周期
"本文深入解析了Spring IoC的源码机制，主要关注Spring框架中IoC容器的初始化、Bean工厂的实例化、Bean定义的读取以及Bean的生命周期管理。通过对 AnnotationConfigApplicationContext 的实例化过程的分析，揭示了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值